DynamicContentPostList: Ignore invisible entries

Issue: #18

.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,9 +1,9 @@
 
-
-CXXFLAGS=-std=c++17 -O0 -g -no-pie -pipe -MMD -Wall -Wextra
-RELEASE_CXXFLAGS=-std=c++17 -O3 -pipe -MMD -Wall -Wextra
+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
+INCLUDEFLAGS=-I submodules/sqlitemoderncpp/hdr -I submodules/cpp-httplib -I submodules/exile.h
 
 CXX=g++
 
@@ -14,6 +14,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 +22,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))
@@ -35,16 +36,25 @@ GTEST_DIR = /home/data/SOURCES/gtest/googletest
 
 GTESTS_TESTDIR = ./tests/
 
-GTEST_CXXFLAGS=-std=c++17 -isystem $(GTEST_DIR)/include -I$(GTEST_DIR) -g -O0 -pipe -Wall -Wextra
+GTEST_CXXFLAGS=-std=$(CPPSTD) -isystem $(GTEST_DIR)/include -I$(GTEST_DIR) -g -O0 -pipe -Wall -Wextra
 GTEST_LDFLAGS=-lsqlite3 -g -O0 -lpthread -lcrypto -lstdc++fs
 GTEST_OBJECTS=$(filter-out qswiki.o, $(WIKIOBJECTS))
 
 .DEFAULT_GOAL := qswiki
 
 release: CXXFLAGS=$(RELEASE_CXXFLAGS)
+profile: CXXFLAGS=$(RELEASE_CXXFLAGS) -pg
+profile: LDFLAGS+= -pg
+
 release: qswiki
-qswiki: $(WIKIOBJECTS)
-	$(CXX) $(WIKIOBJECTS) ${LDFLAGS} ${INCLUDEFLAGS}  -o qswiki
+profile: 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) $(WIKIOBJECTS) exile.o ${LDFLAGS} ${INCLUDEFLAGS}  -o qswiki
 
 test: $(TESTOBJECTS)
 	$(CXX) $(TESTOBJECTS) ${LDFLAGS} -o test
@@ -53,11 +63,11 @@ gtest: $(GTESTS_TESTDIR)/*.cpp $(GTEST_OBJECTS)
 	$(CXX) -o gtest $(GTESTS_TESTDIR)/*.cpp $(GTEST_OBJECTS) $(GTEST_CXXFLAGS) $(GTEST_DIR)/src/gtest_main.cc $(GTEST_DIR)/src/gtest-all.cc $(GTEST_LDFLAGS)
 
 %.o:%.cpp
-	$(CXX) ${CXXFLAGS} ${LDFLAGS} ${INCLUDEFLAGS} -c -o $@ $<
+	$(CXX) ${CXXFLAGS} ${INCLUDEFLAGS} -c -o $@ $<
 
 version.o:version.cpp
-	$(CXX) ${CXXFLAGS} ${LDFLAGS} ${INCLUDEFLAGS} -DGITCOMMIT=\"$(shell git rev-parse --short HEAD)\" -c -o $@ $<
+	$(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

@@ -72,8 +72,7 @@ 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

authenticator.cpp

@@ -21,7 +21,7 @@ Authenticator::Authenticator(UserDao &userDao)
 // TODO: make failure counter configurable
 bool Authenticator::isBanned(std::string ip)
 {
-	if(utils::hasKey(loginFails, ip))
+	if(loginFails.contains(ip))
 	{
 		LoginFail &fl = loginFails[ip];
 		std::lock_guard<std::mutex> lock(fl.mutex);

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(static_cast<std::string>(entry.path().filename()).find(prefix) == 0)
+		if(std::string_view(entry.path().filename().c_str()).starts_with(prefix))
 		{
 			std::filesystem::remove_all(entry);
 		}

cache/mapcache.cpp

@@ -0,0 +1 @@
+#include "mapcache.h"

cache/mapcache.h

@@ -0,0 +1,38 @@
+#ifndef MAPCACHE_H
+#define MAPCACHE_H
+#include <map>
+#include <set>
+#include <shared_mutex>
+#include <optional>
+
+/* Thread-Safe Key-Value store */
+template <class T> class MapCache
+{
+  private:
+	std::map<std::string, T> cache;
+	mutable std::shared_mutex sharedMutex;
+
+  public:
+	std::optional<T> find(const std::string &key) const
+	{
+		std::shared_lock<std::shared_mutex> lock(this->sharedMutex);
+		auto it = this->cache.find(key);
+		if(it != this->cache.end())
+		{
+			return it->second;
+		}
+		return {};
+	}
+	void set(const std::string &key, const T &val)
+	{
+		std::lock_guard<std::shared_mutex> lock{sharedMutex};
+		this->cache[key] = val;
+	}
+	void clear()
+	{
+		std::lock_guard<std::shared_mutex> lock{sharedMutex};
+		this->cache.clear();
+	}
+};
+
+#endif // MAPCACHE_H

cli.cpp

@@ -54,7 +54,7 @@ std::pair<bool, std::string> CLIHandler::user_add(const std::vector<std::string>
 	return {true, ""};
 }
 
-std::pair<bool, std::string> CLIHandler::user_change_pw(const std::vector<std::string> &args)
+std::pair<bool, std::string> CLIHandler::user_change_pw([[maybe_unused]] const std::vector<std::string> &args)
 {
 	std::string username = args.at(0);
 	std::string password = args.at(1);
@@ -75,19 +75,16 @@ std::pair<bool, std::string> CLIHandler::user_change_pw(const std::vector<std::s
 
 		userDao->save(*user);
 	}
-	else
-	{
-		return {false, "User not found"};
-	}
+	return {false, "User not found"};
 }
 
-std::pair<bool, std::string> CLIHandler::user_rename(const std::vector<std::string> &args)
+std::pair<bool, std::string> CLIHandler::user_rename([[maybe_unused]] const std::vector<std::string> &args)
 {
 
 	return {true, ""};
 }
 
-std::pair<bool, std::string> CLIHandler::user_set_perms(const std::vector<std::string> &args)
+std::pair<bool, std::string> CLIHandler::user_set_perms([[maybe_unused]] const std::vector<std::string> &args)
 {
 	auto userDao = this->db->createUserDao();
 	std::string username = args.at(0);
@@ -107,7 +104,7 @@ std::pair<bool, std::string> CLIHandler::user_set_perms(const std::vector<std::s
 	return {false, "User not found"};
 }
 
-std::pair<bool, std::string> CLIHandler::user_list(const std::vector<std::string> &args)
+std::pair<bool, std::string> CLIHandler::user_list([[maybe_unused]] const std::vector<std::string> &args)
 {
 	auto userDao = this->db->createUserDao();
 	QueryOption o;
@@ -138,7 +135,7 @@ std::pair<bool, std::string> CLIHandler::user_show(const std::vector<std::string
 	return {false, "User not found"};
 }
 
-std::pair<bool, std::string> CLIHandler::page_list(const std::vector<std::string> &args)
+std::pair<bool, std::string> CLIHandler::page_list([[maybe_unused]] const std::vector<std::string> &args)
 {
 	auto pageDao = this->db->createPageDao();
 	QueryOption o;
@@ -163,7 +160,7 @@ std::pair<bool, std::string> CLIHandler::pageperms_set_permissions(const std::ve
 	return {true, ""};
 }
 
-std::pair<bool, std::string> CLIHandler::attach(const std::vector<std::string> &args)
+std::pair<bool, std::string> CLIHandler::attach([[maybe_unused]] const std::vector<std::string> &args)
 {
 	/* TODO: consider authentication */
 	pid_t pid = getpid();
@@ -245,7 +242,38 @@ std::pair<std::string, std::vector<std::string>> CLIHandler::splitCommand(std::s
 	return {cmd, splitted};
 }
 
-std::pair<bool, std::string> CLIHandler::version(const std::vector<std::string> &args)
+std::pair<bool, std::string> CLIHandler::version([[maybe_unused]] const std::vector<std::string> &args)
 {
 	return {true, get_version_string()};
 }
+
+std::pair<bool, std::string> CLIHandler::category_list([[maybe_unused]] const std::vector<std::string> &args)
+{
+	auto categoryDao = this->db->createCategoryDao();
+	auto categories = categoryDao->fetchList(QueryOption{});
+	std::stringstream stream;
+	for(std::string &cat : categories)
+	{
+		stream << cat << std::endl;
+	}
+	return {true, stream.str()};
+}
+
+std::pair<bool, std::string> CLIHandler::category_delete(const std::vector<std::string> &args)
+{
+	auto categoryDao = this->db->createCategoryDao();
+	categoryDao->deleteCategory(args.at(0));
+	return {true, ""};
+}
+
+std::pair<bool, std::string> CLIHandler::category_show(const std::vector<std::string> &args)
+{
+	auto categoryDao = this->db->createCategoryDao();
+	auto members = categoryDao->fetchMembers(args.at(0), QueryOption{});
+	std::stringstream stream;
+	for(std::string &member : members)
+	{
+		stream << member << std::endl;
+	}
+	return {true, stream.str()};
+}

cli.h

@@ -22,17 +22,20 @@ class CLIHandler
 	Config *conf;
 
   protected:
-	std::pair<bool, std::string> attach(const std::vector<std::string> &args);
-	std::pair<bool, std::string> cli_help(const std::vector<std::string> &args);
-	std::pair<bool, std::string> user_add(const std::vector<std::string> &args);
-	std::pair<bool, std::string> user_change_pw(const std::vector<std::string> &args);
-	std::pair<bool, std::string> user_rename(const std::vector<std::string> &args);
-	std::pair<bool, std::string> user_set_perms(const std::vector<std::string> &args);
-	std::pair<bool, std::string> user_list(const std::vector<std::string> &args);
-	std::pair<bool, std::string> user_show(const std::vector<std::string> &args);
-	std::pair<bool, std::string> page_list(const std::vector<std::string> &args);
-	std::pair<bool, std::string> pageperms_set_permissions(const std::vector<std::string> &args);
-	std::pair<bool, std::string> version(const std::vector<std::string> &args);
+	std::pair<bool, std::string> attach([[maybe_unused]] const std::vector<std::string> &args);
+	std::pair<bool, std::string> cli_help([[maybe_unused]] const std::vector<std::string> &args);
+	std::pair<bool, std::string> user_add([[maybe_unused]] const std::vector<std::string> &args);
+	std::pair<bool, std::string> user_change_pw([[maybe_unused]] const std::vector<std::string> &args);
+	std::pair<bool, std::string> user_rename([[maybe_unused]] const std::vector<std::string> &args);
+	std::pair<bool, std::string> user_set_perms([[maybe_unused]] const std::vector<std::string> &args);
+	std::pair<bool, std::string> user_list([[maybe_unused]] const std::vector<std::string> &args);
+	std::pair<bool, std::string> user_show([[maybe_unused]] const std::vector<std::string> &args);
+	std::pair<bool, std::string> page_list([[maybe_unused]] const std::vector<std::string> &args);
+	std::pair<bool, std::string> pageperms_set_permissions([[maybe_unused]] const std::vector<std::string> &args);
+	std::pair<bool, std::string> version([[maybe_unused]] const std::vector<std::string> &args);
+	std::pair<bool, std::string> category_list([[maybe_unused]] const std::vector<std::string> &args);
+	std::pair<bool, std::string> category_delete([[maybe_unused]] const std::vector<std::string> &args);
+	std::pair<bool, std::string> category_show([[maybe_unused]] const std::vector<std::string> &args);
 
 	std::vector<struct cmd> cmds{
 		{{"user",
@@ -50,6 +53,13 @@ class CLIHandler
 		  1,
 		  {{{"list", "- lists existing pages", 0, {}, &CLIHandler::page_list}}},
 		  &CLIHandler::cli_help},
+		 {"category",
+		  "operation on categories",
+		  1,
+		  {{{"list", "- lists existing categories", 0, {}, &CLIHandler::category_list},
+			{"delete", " - deletes a category", 1, {}, &CLIHandler::category_delete},
+			{"show", " - shows pages of a category", 1, {}, &CLIHandler::category_show}}},
+		  &CLIHandler::cli_help},
 		 {"pageperms",
 		  "set permissions on pages",
 		  1,
@@ -63,7 +73,7 @@ class CLIHandler
 		  "exit cli",
 		  0,
 		  {},
-		  [](CLIHandler *, const std::vector<std::string> &args) -> std::pair<bool, std::string>
+		  [](CLIHandler *, [[maybe_unused]] const std::vector<std::string> &args) -> std::pair<bool, std::string>
 		  {
 			  exit(EXIT_SUCCESS);
 			  return {true, ""};

cliconsole.cpp

@@ -104,7 +104,17 @@ void CLIConsole::startInteractive()
 		auto pair = CLIHandler::splitCommand(input);
 		if(pair.first == "exit")
 		{
-			std::cout << "Exiting CLI";
+			if(attached)
+			{
+				std::cout << "You are attached. Quit attached instance too (y) or only this one(n)" << std::endl;
+				char response;
+				std::cin >> response;
+				if(response == 'y')
+				{
+					this->send("exit");
+				}
+			}
+			std::cout << "Exiting CLI" << std::endl;
 			exit(EXIT_SUCCESS);
 		}
 		if(pair.first == "attach")

cliserver.cpp

@@ -36,7 +36,7 @@ bool CLIServer::detachServer(std::string socketpath)
 		exit(EXIT_FAILURE);
 	}
 
-	auto worker = [=]
+	auto worker = [this, s]
 	{
 		while(true)
 		{

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);
@@ -96,6 +97,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);

config.h

@@ -41,6 +41,8 @@ struct ConfigUrls
 	std::string linkhistorysort;
 	std::string adminregisterurl;
 	std::string usersettingsurl;
+	std::string rooturl;
+	std::string atomurl;
 };
 
 class ConfigVariableResolver

database/categorydaosqlite.cpp

@@ -42,6 +42,7 @@ std::optional<Category> CategoryDaoSqlite::find(std::string name)
 	{
 		throwFrom(e);
 	}
+	return {};
 }
 
 void CategoryDaoSqlite::save(const Category &c)
@@ -64,9 +65,9 @@ void CategoryDaoSqlite::deleteCategory(std::string name)
 	try
 	{
 
-		*db << "BEGIN";
-		*db << "DELETE FROM categorymember WHERE catid = (SELECT id FROM category WHERE name = ?)" << name;
-		*db << "DELETE FROM category WHERE name = ?" << name;
+		*db << "BEGIN;";
+		*db << "DELETE FROM categorymember WHERE category = (SELECT id FROM category WHERE name = ?);" << name;
+		*db << "DELETE FROM category WHERE name = ?;" << name;
 		*db << "COMMIT;";
 	}
 	catch(sqlite::sqlite_exception &e)

database/pagedaosqlite.cpp

@@ -58,9 +58,9 @@ std::optional<Page> PageDaoSqlite::find(unsigned int id)
 	result.pageid = id;
 	try
 	{
-		auto ps = *db << "SELECT name, lastrevision, visible FROM page WHERE id = ?";
+		auto ps = *db << "SELECT name, title, lastrevision, visible 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);
 	}
 	catch(const sqlite::errors::no_rows &e)
 	{
@@ -97,9 +97,10 @@ 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, visible) VALUES((SELECT id FROM page WHERE "
+			   "name = "
+			   "? OR id = ?), ?, ?, ?, ?)"
+			<< page.name << page.pageid << page.name << page.title << page.current_revision << page.listed;
 	}
 	catch(sqlite::sqlite_exception &e)
 	{
@@ -183,7 +184,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;

database/permissionsdao.h

@@ -1,5 +1,6 @@
 #ifndef PERMISSIONSDAO_H
 #define PERMISSIONSDAO_H
+#include <optional>
 #include "../permissions.h"
 #include "../user.h"
 class PermissionsDao

database/sqlitedao.cpp

@@ -22,18 +22,17 @@ SOFTWARE.
 
 bool SqliteDao::execBool(sqlite::database_binder &binder) const
 {
-	bool result;
+	bool result = false;
 	try
 	{
-		bool result;
 		binder >> result;
-		return result;
 	}
 	catch(sqlite::sqlite_exception &e)
 	{
 		// TODO: well, we may want to check whether rows have found or not and thus log this here
-		return false;
+		result = false;
 	}
+	return result;
 }
 
 int SqliteDao::execInt(sqlite::database_binder &binder) const
@@ -52,4 +51,5 @@ int SqliteDao::execInt(sqlite::database_binder &binder) const
 	{
 		throwFrom(e);
 	}
+	return 0;
 }

database/sqlitequeryoption.cpp

@@ -46,15 +46,18 @@ SqliteQueryOption &SqliteQueryOption::setPrependWhere(bool b)
 std::string SqliteQueryOption::build()
 {
 	std::string result;
+	if(this->prependWhere)
+	{
+		result += "WHERE ";
+	}
 	if(!o.includeInvisible && !this->visibleColumnName.empty())
 	{
-		if(this->prependWhere)
-		{
-			result += "WHERE ";
-		}
 		result += this->visibleColumnName + " = 1";
 	}
-
+	else
+	{
+		result += " 1 = 1";
+	}
 	result += " ORDER BY " + orderByColumnName;
 	if(o.order == ASCENDING)
 	{
@@ -66,7 +69,8 @@ std::string SqliteQueryOption::build()
 	}
 	// TODO: limits for offset?
 	if(o.limit > 0)
+	{
 		result += " LIMIT " + std::to_string(o.limit) + " OFFSET " + std::to_string(o.offset);
-
+	}
 	return result;
 }

database/userdaosqlite.cpp

@@ -37,7 +37,6 @@ bool UserDaoSqlite::exists(std::string username)
 
 std::optional<User> UserDaoSqlite::find(std::string username)
 {
-
 	try
 	{
 		User user;
@@ -48,7 +47,7 @@ std::optional<User> UserDaoSqlite::find(std::string username)
 		stmt >> std::tie(user.login, user.password, user.salt, perms, user.enabled);
 		user.permissions = Permissions{perms};
 
-		return std::move(user);
+		return user;
 	}
 	catch(const sqlite::errors::no_rows &e)
 	{
@@ -58,6 +57,7 @@ std::optional<User> UserDaoSqlite::find(std::string username)
 	{
 		throwFrom(e);
 	}
+	return {};
 }
 
 std::optional<User> UserDaoSqlite::find(int id)
@@ -71,7 +71,7 @@ std::optional<User> UserDaoSqlite::find(int id)
 		stmt >> std::tie(user.login, user.password, user.salt, perms, user.enabled);
 		user.permissions = Permissions{perms};
 
-		return std::move(user);
+		return user;
 	}
 	catch(const sqlite::errors::no_rows &e)
 	{
@@ -81,6 +81,7 @@ std::optional<User> UserDaoSqlite::find(int id)
 	{
 		throwFrom(e);
 	}
+	return {};
 }
 
 std::vector<User> UserDaoSqlite::list(QueryOption o)
@@ -116,7 +117,7 @@ std::vector<User> UserDaoSqlite::list(QueryOption o)
 	return result;
 }
 
-void UserDaoSqlite::deleteUser(std::string username)
+void UserDaoSqlite::deleteUser([[maybe_unused]] std::string username)
 {
 	// What to do with the contributions of the user?
 }

dynamic/dynamiccontent.cpp

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

dynamic/dynamiccontent.h

@@ -0,0 +1,22 @@
+#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;
+
+  public:
+	DynamicContent(Template &templ, Database &database, UrlProvider &urlProvider);
+	virtual std::string render() = 0;
+	virtual ~DynamicContent()
+	{
+	}
+};
+
+#endif // DYNAMICCONTENT_H

dynamic/dynamiccontentpostlist.cpp

@@ -0,0 +1,44 @@
+#include <chrono>
+#include "dynamiccontentpostlist.h"
+
+void DynamicContentPostList::setCategory(std::string catname)
+{
+	this->catname = catname;
+}
+
+std::string DynamicContentPostList::render()
+{
+	auto categoryDao = this->database->createCategoryDao();
+	auto pageDao = this->database->createPageDao();
+	auto revisionDao = this->database->createRevisionDao();
+	QueryOption option;
+	option.includeInvisible = false;
+	auto members = categoryDao->fetchMembers(this->catname, option);
+	std::vector<std::pair<std::string, time_t>> pageList;
+	for(std::string &member : members)
+	{
+		auto revision = revisionDao->getRevisionForPage(member, 1);
+		pageList.push_back({member, 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,16 @@
+#ifndef DYNAMICCONTENTPOSTLIST_H
+#define DYNAMICCONTENTPOSTLIST_H
+
+#include "dynamiccontent.h"
+class DynamicContentPostList : public DynamicContent
+{
+  private:
+	std::string catname;
+
+  public:
+	using DynamicContent::DynamicContent;
+	void setCategory(std::string catname);
+	std::string render() override;
+};
+
+#endif // DYNAMICCONTENTPOSTLIST_H

gateway/httpgateway.cpp

@@ -41,7 +41,7 @@ Request HttpGateway::convertRequest(httplib::Request request)
 	// TODO: this eats resources, where perhaps it does not need to. move it to request?
 	for(auto &it : request.params)
 	{
-		it.second = utils::html_xss(std::string{it.second});
+		it.second = utils::html_xss(it.second);
 	}
 	if(request.method == "GET")
 	{
@@ -83,7 +83,8 @@ void HttpGateway::work(RequestWorker &worker)
 {
 	httplib::Server server;
 	server.set_payload_max_length(this->maxPayloadLength);
-	auto handler = [&](const httplib::Request &req, httplib::Response &res) {
+	auto handler = [&](const httplib::Request &req, httplib::Response &res)
+	{
 		Request wikiRequest = convertRequest(req);
 		Logger::debug() << "httpgateway: received request " << wikiRequest;
 		Response wikiresponse = worker.processRequest(wikiRequest);

handlers/handler.cpp

@@ -34,7 +34,7 @@ void Handler::setGeneralVars(TemplatePage &page)
 }
 Response Handler::errorResponse(std::string errortitle, std::string errormessage, int status)
 {
-	TemplatePage &error = this->templ->getPage("error");
+	TemplatePage error = this->templ->getPage("error");
 	error.setVar("title", createPageTitle(errortitle));
 	error.setVar("errortitle", errortitle);
 	error.setVar("errormessage", errormessage);

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:
@@ -36,12 +39,12 @@ class Handler
 	}
 
 	virtual Response handle(const Request &r);
-	virtual Response handleRequest(const Request &r)
+	virtual Response handleRequest([[maybe_unused]] const Request &r)
 	{
 		return this->errorResponse("Invalid action", "This action is not implemented yet");
 	}
 
-	virtual bool canAccess(const Permissions &perms)
+	virtual bool canAccess([[maybe_unused]] const Permissions &perms)
 	{
 		return false;
 	}
@@ -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/handlerallcategories.cpp

@@ -32,7 +32,7 @@ Response HandlerAllCategories::handleRequest(const Request &r)
 			"No categories",
 			"This wiki does not have any categories defined yet or your query options did not yield any results");
 	}
-	TemplatePage &searchPage = this->templ->getPage("allcategories");
+	TemplatePage searchPage = this->templ->getPage("allcategories");
 	std::string body =
 		this->templ->renderSearch(resultList, [&](std::string str) { return this->urlProvider->category(str); });
 	searchPage.setVar("categorylist", body);

handlers/handlerallpages.cpp

@@ -32,7 +32,7 @@ Response HandlerAllPages::handleRequest(const Request &r)
 		{
 			return errorResponse("No pages", "This wiki does not have any pages yet");
 		}
-		TemplatePage &searchPage = this->templ->getPage("allpages");
+		TemplatePage searchPage = this->templ->getPage("allpages");
 		std::string body = this->templ->renderSearch(resultList);
 		searchPage.setVar("pagelist", body);
 		searchPage.setVar("title", createPageTitle("All pages"));

handlers/handlercategory.cpp

@@ -33,7 +33,7 @@ Response HandlerCategory::handleRequest(const Request &r)
 		}
 		QueryOption qo = queryOption(r);
 		auto resultList = categoryDao->fetchMembers(categoryname, qo);
-		TemplatePage &searchPage = this->templ->getPage("show_category");
+		TemplatePage searchPage = this->templ->getPage("show_category");
 		std::string body = this->templ->renderSearch(resultList);
 		searchPage.setVar("pagelist", body);
 		searchPage.setVar("categoryname", categoryname);

handlers/handlerdefault.cpp

@@ -20,7 +20,7 @@ SOFTWARE.
 */
 #include "handlerdefault.h"
 
-Response HandlerDefault::handleRequest(const Request &r)
+Response HandlerDefault::handleRequest([[maybe_unused]] const Request &r)
 {
 	return Response::redirectTemporarily(this->urlProvider->index());
 }
@@ -29,7 +29,7 @@ HandlerDefault::~HandlerDefault()
 {
 }
 
-bool HandlerDefault::canAccess(const Permissions &perms)
+bool HandlerDefault::canAccess([[maybe_unused]] const Permissions &perms)
 {
 	return true;
 }

handlers/handlerfactory.cpp

@@ -33,7 +33,8 @@ SOFTWARE.
 #include "handlerhistory.h"
 #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")
@@ -80,6 +81,14 @@ std::unique_ptr<Handler> HandlerFactory::createHandler(const std::string &action
 	{
 		return produce<HandlerUserSettings>(userSession);
 	}
+	if(action == "version")
+	{
+		return produce<HandlerVersion>(userSession);
+	}
+	if(action == "feed")
+	{
+		return produce<HandlerFeedGenerator>(userSession);
+	}
 
 	return produce<HandlerInvalidAction>(userSession);
 }

handlers/handlerfeedgenerator.cpp

@@ -0,0 +1,129 @@
+#include "handlerfeedgenerator.h"
+#include "../parser.h"
+std::vector<HandlerFeedGenerator::EntryRevisionPair> HandlerFeedGenerator::fetchEntries(
+	std::vector<std::string> categories)
+{
+	auto revisionDao = this->database->createRevisionDao();
+	auto pageDao = this->database->createPageDao();
+
+	std::vector<EntryRevisionPair> result;
+	QueryOption option;
+	option.includeInvisible = false;
+	// option.limit = 20;
+	std::set<std::string> members;
+	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)
+		{
+			auto catmembers = categoryDao->fetchMembers(cat, option);
+			std::copy(catmembers.begin(), catmembers.end(), std::inserter(members, members.end()));
+		}
+	}
+	for(const std::string &member : members)
+	{
+		auto page = pageDao->find(member).value();
+		auto revision = revisionDao->getRevisionForPage(page.name, 1).value();
+		result.push_back({page, 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;
+}
+
+Response 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();
+
+	if(utils::trim(filter).empty())
+	{
+		filter = "All pages";
+	}
+
+	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 entryurl =
+			this->urlProvider->combine({this->urlProvider->rootUrl(), this->urlProvider->page(page.name)});
+		TemplatePage atomentry = this->templ->getPage("feeds/atomentry");
+		atomentry.setVar("entrytitle", utils::html_xss(page.title));
+		atomentry.setVar("entryurl", utils::html_xss(entryurl));
+		atomentry.setVar("entryid", utils::html_xss(entryurl));
+		atomentry.setVar("entrypublished", entryPublished);
+		Parser parser;
+		atomentry.setVar("entrycontent", utils::html_xss(parser.parse(*pageDao, *this->urlProvider, current.content)));
+		stream << atomentry.render();
+	}
+	stream << atomfooter;
+	TemplatePage atomheader = this->templ->getPage("feeds/atomheader");
+	atomheader.setVar("subtitle", filter);
+	atomheader.setVar("atomfeeduniqueid", utils::html_xss(this->urlProvider->atomFeed(filter)));
+	atomheader.setVar("atomfeedupdate", utils::formatLocalDate(newestPublished, dateformat) + "Z");
+
+	Response result;
+	result.setStatus(200);
+	result.setContentType("application/atom+xml");
+	result.setBody(atomheader.render() + stream.str());
+	return result;
+}
+
+Response HandlerFeedGenerator::handleRequest(const Request &r)
+{
+	Response response;
+	try
+	{
+		std::string type = r.get("type");
+		std::string categories = r.get("cats");
+
+		auto entries = fetchEntries(utils::split(categories, ','));
+		if(type == "atom")
+		{
+			std::string filter = categories;
+			response = generateAtom(entries, filter);
+		}
+		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);
+	Response 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/handlerhistory.cpp

@@ -50,7 +50,8 @@ Response HandlerHistory::handleRequest(const Request &r)
 	std::vector<Revision> resultList;
 	auto revisionDao = this->database->createRevisionDao();
 
-	auto makeSortedLink = [&](unsigned int limit, unsigned int offset, unsigned int order) {
+	auto makeSortedLink = [&](unsigned int limit, unsigned int offset, unsigned int order)
+	{
 		if(!page.empty())
 		{
 			return this->urlProvider->pageHistorySort(page, limit, offset, order);
@@ -122,7 +123,7 @@ Response HandlerHistory::handleRequest(const Request &r)
 	return response;
 }
 
-bool HandlerHistory::canAccess(const Permissions &perms)
+bool HandlerHistory::canAccess([[maybe_unused]] const Permissions &perms)
 {
 	return true; // This is a lie but we need to this a little more fine grained here, which we do in the handleRequest
 }

handlers/handlerinvalidaction.cpp

@@ -20,12 +20,12 @@ SOFTWARE.
 */
 #include "handlerinvalidaction.h"
 
-Response HandlerInvalidAction::handleRequest(const Request &r)
+Response HandlerInvalidAction::handleRequest([[maybe_unused]] const Request &r)
 {
 	return errorResponse("Invalid action", "No action defined for this action");
 }
 
-bool HandlerInvalidAction::canAccess(const Permissions &perms)
+bool HandlerInvalidAction::canAccess([[maybe_unused]] const Permissions &perms)
 {
 	return true;
 }

handlers/handlerlogin.cpp

@@ -55,7 +55,7 @@ Response HandlerLogin::handleRequest(const Request &r)
 	{
 		page = "index";
 	}
-	TemplatePage &loginTemplatePage = this->templ->getPage("login");
+	TemplatePage loginTemplatePage = this->templ->getPage("login");
 	setGeneralVars(loginTemplatePage);
 	loginTemplatePage.setVar("loginurl", urlProvider->login(page));
 	loginTemplatePage.setVar("title", createPageTitle("Login"));
@@ -66,7 +66,7 @@ Response HandlerLogin::handleRequest(const Request &r)
 	return result;
 }
 
-bool HandlerLogin::canAccess(const Permissions &perms)
+bool HandlerLogin::canAccess([[maybe_unused]] const Permissions &perms)
 {
 	return true;
 }

handlers/handlerpage.cpp

@@ -63,8 +63,9 @@ void HandlerPage::setPageVars(TemplatePage &page, std::string pagename)
 	if(!pagename.empty())
 	{
 		std::string headerlinks;
-		TemplatePage &headerlink = this->templ->getPage("_headerlink");
-		auto addHeaderLink = [&headerlinks, &headerlink](std::string href, std::string value) {
+		TemplatePage headerlink = this->templ->getPage("_headerlink");
+		auto addHeaderLink = [&headerlinks, &headerlink](std::string href, std::string value)
+		{
 			headerlink.setVar("href", href);
 			headerlink.setVar("value", value);
 			headerlinks += headerlink.render();

handlers/handlerpageedit.cpp

@@ -23,9 +23,9 @@ SOFTWARE.
 #include "../request.h"
 
 #include "../parser.h"
-bool HandlerPageEdit::canAccess(std::string page)
+bool HandlerPageEdit::canAccess([[maybe_unused]] std::string page)
 {
-	return this->userSession->user.permissions.canEdit();
+	return effectivePermissions(page).canEdit();
 }
 
 bool HandlerPageEdit::pageMustExist()
@@ -66,6 +66,7 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 				this->database->beginTransaction();
 				std::string visiblecmd = parser.extractCommand("visible", newContent);
 				std::string rename = parser.extractCommand("rename", newContent);
+				std::string customtitle = parser.extractCommand("pagetitle", newContent);
 				Page page;
 				std::optional<Page> currentPage = pageDao.find(pagename);
 				if(currentPage)
@@ -83,6 +84,11 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 				page.current_revision = current_revision;
 				page.listed = !(visiblecmd == "0");
 				page.name = pagename;
+				page.title = customtitle;
+				if(page.title.empty())
+				{
+					page.title = page.name;
+				}
 				pageDao.save(page);
 
 				Revision newRevision;
@@ -121,7 +127,7 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 		}
 	}
 
-	TemplatePage &templatePage = this->templ->getPage("page_creation");
+	TemplatePage templatePage = this->templ->getPage("page_creation");
 	templatePage.setVar("actionurl", urlProvider->editPage(pagename));
 	templatePage.setVar("content", body);
 	setPageVars(templatePage, pagename);

handlers/handlerpageview.cpp

@@ -23,7 +23,7 @@ SOFTWARE.
 #include "../logger.h"
 #include "../parser.h"
 #include "../htmllink.h"
-
+#include "../dynamic/dynamiccontentpostlist.h"
 bool HandlerPageView::canAccess(std::string page)
 {
 	return effectivePermissions(page).canRead();
@@ -128,7 +128,7 @@ 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);
+	TemplatePage page = this->templ->getPage(templatepartname);
 
 	Parser parser;
 	Response result;
@@ -136,10 +136,21 @@ Response HandlerPageView::handleRequest(PageDao &pageDao, std::string pagename,
 	std::string indexcontent;
 	std::string parsedcontent;
 
+	std::function<std::string(std::string_view, std::string_view)> dynamicParseCallback =
+		[&](std::string_view key, std::string_view value) -> std::string
+	{
+		if(key == "dynamic:postlist")
+		{
+			std::shared_ptr<DynamicContentPostList> postlist = createDynamic<DynamicContentPostList>();
+			postlist->setCategory(std::string(value));
+			return postlist->render();
+		}
+		return std::string{};
+	};
 	if(revisionid > 0)
 	{
 		indexcontent = createIndexContent(parser, revision->content);
-		parsedcontent = parser.parse(pageDao, *this->urlProvider, revision->content);
+		parsedcontent = parser.parse(pageDao, *this->urlProvider, revision->content, dynamicParseCallback);
 	}
 	else
 	{
@@ -162,18 +173,23 @@ Response HandlerPageView::handleRequest(PageDao &pageDao, std::string pagename,
 		}
 		else
 		{
-			parsedcontent = parser.parse(pageDao, *this->urlProvider, revision->content);
+			parsedcontent = parser.parse(pageDao, *this->urlProvider, revision->content, dynamicParseCallback);
 			this->cache->put(cachekeyparsedcontent, parsedcontent);
 		}
 	}
 	std::string revisionstr = std::to_string(revision->revision);
+	std::string customtitle = parser.extractCommand("pagetitle", revision->content);
 	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();
@@ -37,7 +41,7 @@ Response HandlerSearch::handleRequest(const Request &r)
 		{
 			return errorResponse("No results", "Your search for " + q + " did not yield any results.");
 		}
-		TemplatePage &searchPage = this->templ->getPage("search");
+		TemplatePage searchPage = this->templ->getPage("search");
 		std::string body = this->templ->renderSearch(resultList);
 		searchPage.setVar("pagelist", body);
 		searchPage.setVar("searchterm", q);

handlers/handlerusersettings.cpp

@@ -51,7 +51,7 @@ Response HandlerUserSettings::handleRequest(const Request &r)
 		}
 	}
 
-	TemplatePage &userSettingsPage = this->templ->getPage("usersettings");
+	TemplatePage userSettingsPage = this->templ->getPage("usersettings");
 	setGeneralVars(userSettingsPage);
 	userSettingsPage.setVar("usersettingsurl", urlProvider->userSettings());
 	userSettingsPage.setVar("title", createPageTitle("User settings - " + this->userSession->user.login));
@@ -62,7 +62,7 @@ Response HandlerUserSettings::handleRequest(const Request &r)
 	return result;
 }
 
-bool HandlerUserSettings::canAccess(const Permissions &perms)
+bool HandlerUserSettings::canAccess([[maybe_unused]] const Permissions &perms)
 {
 	return this->userSession->loggedIn;
 }

handlers/handlerversion.cpp

@@ -0,0 +1,9 @@
+#include "handlerversion.h"
+#include "../version.h"
+Response HandlerVersion::handleRequest([[maybe_unused]] const Request &r)
+{
+	Response response;
+	response.setContentType("text/plain");
+	response.setBody(get_version_string());
+	return response;
+}

handlers/handlerversion.h

@@ -0,0 +1,18 @@
+#ifndef HANDLERVERSION_H
+#define HANDLERVERSION_H
+#include "handler.h"
+class HandlerVersion : public Handler
+{
+  public:
+	using Handler::Handler;
+
+  public:
+	Response handleRequest(const Request &r) override;
+
+	bool canAccess([[maybe_unused]] const Permissions &perms) override
+	{
+		return true;
+	}
+};
+
+#endif // HANDLERVERSION_H

iparser.h

@@ -2,16 +2,28 @@
 #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 extractCommand(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::vector<std::string> extractCategories(const std::string &content) const = 0;
 
 	virtual ~IParser(){};
 };

page.h

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

parser.cpp

@@ -27,7 +27,7 @@ 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\])";
@@ -46,7 +46,7 @@ std::vector<Headline> Parser::extractHeadlines(std::string content) const
 	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,7 +62,7 @@ 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::extractCommand(std::string cmdname, const std::string &content) const
 {
 	std::string cmd = "[cmd:" + cmdname + "]";
 	std::string cmdend = "[/cmd:" + cmdname + "]";
@@ -116,31 +116,37 @@ 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::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|li||ul|ol|link|wikilink|h\d|cmd:rename|cmd:redirect|cmd:pagetitle|category|dynamic:postlist)*?\]((\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"};
+			content = 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[0] == 'h')
+			{
+				return "<" + tag + " id='" + content + "'>" + content + "</" + tag + ">";
+			}
+			return callback(tag, content);
+		});
 	result = utils::strreplace(result, "\r\n", "<br>");
 	return result;
 }

parser.h

@@ -8,12 +8,15 @@ class Parser : public IParser
 	std::string processLink(const PageDao &pageDao, UrlProvider &urlProvider, 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 extractCommand(std::string cmdname, const std::string &content) const;
+	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;
+
 	using IParser::IParser;
-	~Parser(){};
 };
 
 #endif // PARSER_H

qswiki.cpp

@@ -43,7 +43,7 @@ SOFTWARE.
 #include "cliserver.h"
 #include "version.h"
 
-void sigterm_handler(int arg)
+void sigterm_handler([[maybe_unused]] int arg)
 {
 	// TODO: proper shutdown.
 	exit(EXIT_SUCCESS);
@@ -180,7 +180,9 @@ int main(int argc, char **argv)
 		userdao->save(anon.value());
 		User::setAnon(anon.value());
 
-		Template siteTemplate{config.templateprefix, config.templatepath, config.urls, config.configVarResolver};
+		MapCache<TemplatePage> mapCache;
+		Template siteTemplate{config.templateprefix, config.templatepath, config.urls, config.configVarResolver,
+							  mapCache};
 		UrlProvider urlProvider{config.urls};
 
 		auto cache = createCache(config.configVarResolver);

requestworker.cpp

@@ -59,7 +59,7 @@ Response RequestWorker::processRequest(const Request &r)
 		if(session.loggedIn && session.csrf_token != r.post("csrf_token"))
 		{
 			// TODO: this is code duplication
-			TemplatePage &error = this->templ->getPage("error");
+			TemplatePage error = this->templ->getPage("error");
 			error.setVar("errortitle", "Invalid csrf token");
 			error.setVar("errormessage", "Invalid csrf token");
 			return {403, error.render()};

response.cpp

@@ -32,12 +32,12 @@ Response::Response(int http_status_code, std::string html)
 	this->html = std::move(html);
 }
 
-void Response::addHeader(const std::string &key, const std::string &value)
+void Response::addHeader(std::string key, std::string value)
 {
 	this->responseHeaders.insert(std::make_pair(key, value));
 }
 
-Response Response::redirectTemporarily(const std::string &url)
+Response Response::redirectTemporarily(std::string url)
 {
 	Response result;
 	result.addHeader("Location", url);

response.h

@@ -27,8 +27,8 @@ class Response
 		return this->html;
 	}
 
-	void addHeader(const std::string &key, const std::string &value);
-	static Response redirectTemporarily(const std::string &url);
+	void addHeader(std::string key, std::string value);
+	static Response redirectTemporarily(std::string url);
 
 	void setStatus(int status)
 	{

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,22 @@ 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 */
+	policy->vow_promises = EXILE_SYSCALL_VOW_STDIO | EXILE_SYSCALL_VOW_WPATH | EXILE_SYSCALL_VOW_CPATH |
+						   EXILE_SYSCALL_VOW_RPATH | EXILE_SYSCALL_VOW_INET | EXILE_SYSCALL_VOW_UNIX |
+						   EXILE_SYSCALL_VOW_THREAD;
 
-	/* 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)
+	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, visible 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), 

template.cpp

@@ -24,12 +24,25 @@ SOFTWARE.
 #include "htmllink.h"
 #include "logger.h"
 Template::Template(std::string templateprefix, std::string templatepath, ConfigUrls &configUrls,
-				   ConfigVariableResolver &configVarsResolver)
+				   ConfigVariableResolver &configVarsResolver, MapCache<TemplatePage> &pageCache)
 {
 	this->templateprefix = templateprefix;
 	this->templatepath = templatepath;
 	this->configUrls = &configUrls;
 	this->configVarResolver = &configVarsResolver;
+	this->pageCache = &pageCache;
+}
+
+TemplatePage Template::getPage(const std::string &pagename)
+{
+	auto result = this->pageCache->find(pagename);
+	if(result)
+	{
+		return *result;
+	}
+	auto page = createPage(pagename);
+	this->pageCache->set(pagename, page);
+	return page;
 }
 
 std::string Template::getPartPath(std::string_view partname)
@@ -54,7 +67,7 @@ std::string Template::resolveIncludes(std::string_view content)
 	return replacer.parse(content);
 }
 
-TemplatePage Template::createPage(std::string name)
+TemplatePage Template::createPage(std::string_view name)
 {
 	std::string content = loadResolvedPart(name);
 	Varreplacer replacer(this->templateprefix);
@@ -65,16 +78,6 @@ TemplatePage Template::createPage(std::string name)
 	return TemplatePage(replacer.parse(content));
 }
 
-TemplatePage &Template::getPage(const std::string &pagename)
-{
-	if(utils::hasKey(pagesMap, pagename))
-	{
-		return pagesMap[pagename];
-	}
-	pagesMap.insert(std::make_pair(pagename, createPage(pagename)));
-	return pagesMap[pagename];
-}
-
 // TODO: this restricts template a bit
 std::string Template::renderSearch(const std::vector<std::string> &results,
 								   std::function<std::string(std::string)> callback) const
@@ -138,7 +141,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>";
 		}
 	};
 
@@ -152,7 +155,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

@@ -8,31 +8,29 @@
 #include "response.h"
 #include "searchresult.h"
 #include "revision.h"
+#include "cache/mapcache.h"
 class Template
 {
   private:
 	ConfigVariableResolver *configVarResolver;
 	ConfigUrls *configUrls;
+	MapCache<TemplatePage> *pageCache;
 
 	std::string templateprefix;
 	std::string templatepath;
 
-	std::map<std::string, TemplatePage> pagesMap;
 	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 name);
+	TemplatePage createPage(std::string_view name);
 
   public:
 	Template(std::string templateprefix, std::string templatepath, ConfigUrls &configUrls,
-			 ConfigVariableResolver &configVarsResolver);
-	/* TODO: returning this as a reference is by no means a risk free business,
-		because between requests, different vars can be set conditionally,
-		thus creating a mess
-	*/
-	TemplatePage &getPage(const std::string &pagename);
+			 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/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,7 @@
+<entry>
+    <title>{qswiki:var:entrytitle}</title>
+    <link href="{qswiki:var:entryurl}"/>
+    <id>{qswiki:var:entryid}</id>
+    <published>{qswiki:var:entrypublished}</published>
+    <content type="html">{qswiki:var:entrycontent}</content>
+</entry>

template/quitesimple/feeds/atomfooter

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

template/quitesimple/feeds/atomheader

@@ -0,0 +1,8 @@
+<?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>
+  <updated>{qswiki:var:atomfeedupdate}</updated>

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/page_header

@@ -6,20 +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: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/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/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;
+	}
 }

templatepage.cpp

@@ -27,7 +27,7 @@ TemplatePage::TemplatePage()
 
 TemplatePage::TemplatePage(std::string content)
 {
-	this->content = content;
+	this->content = std::make_shared<std::string>(content);
 }
 
 void TemplatePage::setVar(const std::string &key, std::string value)
@@ -40,5 +40,5 @@ std::string TemplatePage::render() const
 	Varreplacer replacer("{qswiki:");
 	replacer.addResolver("var",
 						 [&](std::string_view key) { return utils::getKeyOrEmpty(this->varsMap, std::string(key)); });
-	return replacer.parse(this->content);
+	return replacer.parse(*this->content);
 }

templatepage.h

@@ -3,10 +3,11 @@
 #include <string>
 #include <string_view>
 #include <map>
+#include <memory>
 class TemplatePage
 {
   private:
-	std::string content;
+	std::shared_ptr<const std::string> content;
 	std::map<std::string, std::string> varsMap;
 
   public:

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)
@@ -119,3 +120,28 @@ 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

@@ -48,6 +48,12 @@ class UrlProvider
 	std::string category(std::string catname);
 
 	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

utils.cpp

@@ -84,7 +84,7 @@ std::string utils::urldecode(std::string_view str)
 	return result;
 }
 
-std::vector<std::string> utils::split(const std::string &str, char delim)
+std::vector<std::string> utils::split(std::string str, char delim)
 {
 	std::vector<std::string> result;
 	std::stringstream stream(str);
@@ -97,7 +97,7 @@ std::vector<std::string> utils::split(const std::string &str, char delim)
 }
 
 // TODO: can easily break if we pass a regex here
-std::vector<std::string> utils::split(const std::string &str, const std::string &delim)
+std::vector<std::string> utils::split(std::string str, const std::string &delim)
 {
 	std::regex regex{delim + "+"};
 	return split(str, regex);
@@ -112,7 +112,7 @@ std::vector<std::string> utils::split(const std::string &str, std::regex &regex)
 	return result;
 }
 
-std::string utils::strreplace(const std::string &str, const std::string &search, const std::string &replace)
+std::string utils::strreplace(std::string str, const std::string &search, const std::string &replace)
 {
 	std::string result = str;
 	auto searchlength = search.length();
@@ -138,6 +138,10 @@ std::string utils::readCompleteFile(std::string_view filepath)
 {
 
 	std::fstream stream(std::string{filepath});
+	if(!stream.is_open())
+	{
+		throw std::runtime_error("stream is not open");
+	}
 	std::stringstream ss;
 	ss << stream.rdbuf();
 	std::string content = ss.str();
@@ -166,7 +170,10 @@ std::string utils::regex_callback_replacer(std::regex regex, const std::string &
 	return result;
 }
 
-std::string utils::toISODate(time_t t)
+/* TODO: Convert to C++20, but currently the state is rather poor and would
+ * require workarounds, so keep it this way for now, and do it properly
+ * once compiler support gets there */
+std::string utils::formatLocalDate(time_t t, std::string format)
 {
 	struct tm lt;
 	if(localtime_r(&t, &lt) == nullptr)
@@ -174,7 +181,7 @@ std::string utils::toISODate(time_t t)
 		return {};
 	}
 	char result[20];
-	size_t x = strftime(result, sizeof(result), "%Y-%m-%d %H:%M:%S", &lt);
+	size_t x = strftime(result, sizeof(result), format.c_str(), &lt);
 	if(x == 0)
 	{
 		return {};
@@ -182,10 +189,19 @@ std::string utils::toISODate(time_t t)
 	return std::string{result};
 }
 
-std::string utils::trim(const std::string &str)
+std::string utils::toISODateTime(time_t t)
+{
+	return utils::formatLocalDate(t, "%Y-%m-%d %H:%M:%S");
+}
+
+std::string utils::toISODate(time_t t)
+{
+	return utils::formatLocalDate(t, "%Y-%m-%d");
+}
+
+std::string utils::trim(std::string_view view)
 {
 	std::string_view chars = " \t\n\r";
-	std::string_view view = str;
 	auto n = view.find_first_not_of(chars);
 	if(n != std::string_view::npos)
 	{

utils.h

@@ -8,25 +8,20 @@
 #include <map>
 #include <regex>
 #include <ctime>
+#include <limits>
 namespace utils
 {
 
-std::vector<std::string> split(const std::string &str, char delim);
-std::vector<std::string> split(const std::string &str, const std::string &delim);
+std::vector<std::string> split(std::string str, char delim);
+std::vector<std::string> split(std::string str, const std::string &delim);
 std::vector<std::string> split(const std::string &str, std::regex &regex);
 std::string urldecode(std::string_view str);
-std::string strreplace(const std::string &str, const std::string &search, const std::string &replace);
+std::string strreplace(std::string str, const std::string &search, const std::string &replace);
 
 std::string html_xss(std::string_view str);
 std::string getenv(const std::string &key);
 
-template <class T, class U> bool hasKey(const std::map<T, U> &map, T key)
-{
-	auto k = map.find(key);
-	return k != map.end();
-}
-
-template <class T, class U> U getKeyOrEmpty(const std::map<T, U> &map, T key)
+template <class T, class U> U getKeyOrEmpty(const std::map<T, U> &map, const T &key)
 {
 	auto k = map.find(key);
 	if(k != map.end())
@@ -36,7 +31,7 @@ template <class T, class U> U getKeyOrEmpty(const std::map<T, U> &map, T key)
 	return U();
 }
 
-template <class T, class U> U getKeyOrEmpty(std::multimap<T, U> map, T key)
+template <class T, class U> U getKeyOrEmpty(const std::multimap<T, U> &map, const T &key)
 {
 	auto k = map.find(key);
 	if(k != map.end())
@@ -46,7 +41,7 @@ template <class T, class U> U getKeyOrEmpty(std::multimap<T, U> map, T key)
 	return U();
 }
 
-template <class T, class U> std::vector<U> getAll(std::multimap<T, U> map, T key)
+template <class T, class U> std::vector<U> getAll(const std::multimap<T, U> &map, const T &key)
 {
 	std::vector<U> result;
 	auto range = map.equal_range(key);
@@ -86,14 +81,16 @@ inline unsigned int toUInt(const std::string &str)
 	return result;
 }
 
+std::string formatLocalDate(time_t t, std::string format);
 std::string toISODate(time_t t);
+std::string toISODateTime(time_t t);
 
 template <class T> inline std::string toString(const T &v)
 {
 	return std::string(v.begin(), v.end());
 }
 
-std::string trim(const std::string &str);
+std::string trim(std::string_view view);
 
 } // namespace utils
 #endif

varreplacer.cpp

@@ -60,12 +60,12 @@ std::string Varreplacer::makeReplacement(std::string_view varkeyvalue)
 	std::string_view value;
 
 	std::tie(key, value) = extractKeyAndValue(varkeyvalue);
-	if(utils::hasKey(keyValues, key))
+	if(keyValues.contains(key))
 	{
 		std::string replacementContent = keyValues[key];
 		return replacementContent;
 	}
-	else if(utils::hasKey(resolverFunctionsMap, key))
+	else if(resolverFunctionsMap.contains(key))
 	{
 
 		auto resolver = this->resolverFunctionsMap[key];