From ab9a0bd4e24009834ff316f5ae6aeb6c6aa1c226 Mon Sep 17 00:00:00 2001
From: fwastring <fredrik@wastring.com>
Date: Mon, 13 Oct 2025 10:38:50 +0200
Subject: [PATCH] initial

---
 .cache/nix/fetcher-cache-v4.sqlite            |  Bin 0 -> 12288 bytes
 .gitignore                                    |    6 +
 LICENSE                                       |    8 +
 README.md                                     |  142 +
 doc/Makefile                                  |    3 +
 doc/doxygen.cfg                               | 2660 +++++++++++++++++
 flake.lock                                    |   61 +
 flake.nix                                     |   65 +
 result                                        |    1 +
 src/.gitignore                                |    2 +
 src/cli/.gitignore                            |    1 +
 src/cli/Makefile                              |   31 +
 src/cli/cliclient.cpp                         |  455 +++
 src/cli/cliclient.h                           |   54 +
 src/cli/main.cpp                              |   56 +
 src/cli/utils.cpp                             |  325 ++
 src/cli/utils.h                               |   11 +
 src/examples/.gitignore                       |   10 +
 src/examples/001_single_request/Makefile      |   25 +
 src/examples/001_single_request/main.cpp      |   18 +
 src/examples/002_simple_task/Makefile         |   25 +
 src/examples/002_simple_task/main.cpp         |   77 +
 src/examples/003_webserver/Makefile           |    7 +
 src/examples/003_webserver/main.cpp           |   55 +
 src/examples/004_timers/Makefile              |   22 +
 src/examples/004_timers/main.cpp              |   45 +
 src/examples/005_websocket_server/Makefile    |    7 +
 src/examples/005_websocket_server/main.cpp    |   36 +
 src/examples/005_websocket_server/winner.cpp  |   43 +
 src/examples/005_websocket_server/winner.h    |   30 +
 src/examples/006_websocket_client/Makefile    |    7 +
 src/examples/006_websocket_client/main.cpp    |   13 +
 src/examples/006_websocket_client/main2.cpp   |   37 +
 .../006_websocket_client/winnerclient.cpp     |   49 +
 .../006_websocket_client/winnerclient.h       |   18 +
 src/examples/007_events/Makefile              |   10 +
 src/examples/007_events/main.cpp              |   78 +
 src/examples/008_workers/Makefile             |   11 +
 src/examples/008_workers/main.cpp             |  103 +
 src/examples/009_threads/Makefile             |   12 +
 src/examples/009_threads/main.cpp             |   63 +
 src/examples/010_echoserver/Makefile          |   10 +
 src/examples/010_echoserver/echoserver.cpp    |   23 +
 .../010_echoserver/echoserverconnection.cpp   |   39 +
 .../010_echoserver/echoserverconnection.h     |   19 +
 .../010_echoserver/echoservertask.cpp         |   52 +
 src/examples/010_echoserver/echoservertask.h  |   39 +
 src/examples/011_echoclient/Makefile          |   10 +
 src/examples/011_echoclient/echoclient.cpp    |   14 +
 .../011_echoclient/echoclientconnection.cpp   |   36 +
 .../011_echoclient/echoclientconnection.h     |   17 +
 .../011_echoclient/echoclienttask.cpp         |   20 +
 src/examples/011_echoclient/echoclienttask.h  |   35 +
 src/examples/020_cliclient/Makefile           |    9 +
 src/examples/020_cliclient/cliclient.cpp      |   98 +
 src/examples/020_cliclient/webserver.cpp      |   57 +
 src/examples/020_cliclient/webserver.h        |   23 +
 src/examples/030_httpclient/Makefile          |   11 +
 src/examples/030_httpclient/main.cpp          |   76 +
 src/examples/Makefile                         |   15 +
 src/framework/bridgetask.cpp                  |   20 +
 src/framework/bridgetask.h                    |  142 +
 src/framework/engine.cpp                      |  644 ++++
 src/framework/engine.h                        |  151 +
 src/framework/eventloop.cpp                   |  726 +++++
 src/framework/eventloop.h                     |  308 ++
 src/framework/loadbalancer.cpp                |  161 +
 src/framework/loadbalancer.h                  |   78 +
 src/framework/logger.cpp                      |  179 ++
 src/framework/logger.h                        |  382 +++
 src/framework/mk.inc                          |  140 +
 src/framework/msgqueue.h                      |   72 +
 src/framework/pollstate.h                     |   25 +
 src/framework/serversocket.cpp                |   51 +
 src/framework/serversocket.h                  |   58 +
 src/framework/shortmessageconnection.cpp      |   68 +
 src/framework/shortmessageconnection.h        |   47 +
 src/framework/socket.cpp                      |  370 +++
 src/framework/socket.h                        |  237 ++
 src/framework/socketconnection.cpp            |  327 ++
 src/framework/socketconnection.h              |  327 ++
 src/framework/socketreceiver.cpp              |  103 +
 src/framework/socketreceiver.h                |   59 +
 src/framework/synchronousbridge.cpp           |   27 +
 src/framework/synchronousbridge.h             |   69 +
 src/framework/task.cpp                        |  146 +
 src/framework/task.h                          |  519 ++++
 src/framework/taskconfig.cpp                  |  196 ++
 src/framework/taskconfig.h                    |  161 +
 src/framework/threadbridge.cpp                |   42 +
 src/framework/threadbridge.h                  |   37 +
 src/framework/unixdomainbridge.cpp            |   42 +
 src/framework/unixdomainbridge.h              |   49 +
 src/framework/unixdomainclient.cpp            |   87 +
 src/framework/unixdomainclient.h              |   62 +
 src/framework/workerprocess.h                 |   52 +
 src/gtkgui/.gitignore                         |    1 +
 src/gtkgui/Makefile                           |   26 +
 src/gtkgui/gtkclient.cpp                      |  407 +++
 src/gtkgui/gtkclient.css                      |   11 +
 src/gtkgui/gtkclient.h                        |   73 +
 src/gtkgui/main.cpp                           |   57 +
 src/http/cookiefile.cpp                       |   98 +
 src/http/cookiefile.h                         |   37 +
 src/http/cookiemanager.cpp                    |  288 ++
 src/http/cookiemanager.h                      |   95 +
 src/http/http_common.cpp                      |  173 ++
 src/http/http_common.h                        |   62 +
 src/http/httpclientconnection.cpp             |  397 +++
 src/http/httpclientconnection.h               |  160 +
 src/http/httpclienttask.cpp                   |   52 +
 src/http/httpclienttask.h                     |  122 +
 src/http/httpconnection.cpp                   |  359 +++
 src/http/httpconnection.h                     |  112 +
 src/http/httphost.h                           |   47 +
 src/http/httprequestengine.cpp                |  220 ++
 src/http/httprequestengine.h                  |  137 +
 src/http/httpserverconnection.cpp             |  468 +++
 src/http/httpserverconnection.h               |  189 ++
 src/http/httptask.cpp                         |   22 +
 src/http/httptask.h                           |   75 +
 src/http/mk.inc                               |   25 +
 src/http/sha1.cpp                             |  306 ++
 src/http/sha1.h                               |   36 +
 src/http/singlerequest.cpp                    |   19 +
 src/http/singlerequest.h                      |   49 +
 src/http/webservertask.cpp                    |  122 +
 src/http/webservertask.h                      |  141 +
 src/http/websocketbridge.cpp                  |  239 ++
 src/http/websocketbridge.h                    |   65 +
 src/json11/CMakeLists.txt                     |   21 +
 src/json11/LICENSE.txt                        |   19 +
 src/json11/Makefile                           |    7 +
 src/json11/README.md                          |   42 +
 src/json11/json11.cpp                         |  808 +++++
 src/json11/json11.hpp                         |  232 ++
 src/json11/test.cpp                           |  205 ++
 src/measurement/defs.cpp                      |  237 ++
 src/measurement/defs.h                        |   12 +
 src/measurement/downloadtask.cpp              |   68 +
 src/measurement/downloadtask.h                |   22 +
 src/measurement/infotask.cpp                  |   45 +
 src/measurement/infotask.h                    |   46 +
 src/measurement/latencytask.cpp               |   34 +
 src/measurement/latencytask.h                 |   16 +
 src/measurement/measurementagent.cpp          |  604 ++++
 src/measurement/measurementagent.h            |   88 +
 src/measurement/measurementtask.cpp           |   62 +
 src/measurement/measurementtask.h             |  115 +
 src/measurement/mk.inc                        |   18 +
 src/measurement/pingsweeptask.cpp             |   57 +
 src/measurement/pingsweeptask.h               |   32 +
 src/measurement/progresstask.cpp              |   79 +
 src/measurement/progresstask.h                |  108 +
 src/measurement/rpingtask.cpp                 |   61 +
 src/measurement/rpingtask.h                   |   30 +
 src/measurement/singlerequesttask.cpp         |   19 +
 src/measurement/singlerequesttask.h           |   13 +
 src/measurement/speedtest.cpp                 |  358 +++
 src/measurement/speedtest.h                   |   48 +
 src/measurement/tickettask.cpp                |   28 +
 src/measurement/tickettask.h                  |   20 +
 src/measurement/uploadinfotask.cpp            |   41 +
 src/measurement/uploadinfotask.h              |   15 +
 src/measurement/uploadtask.cpp                |   83 +
 src/measurement/uploadtask.h                  |   20 +
 src/measurement/warmuptask.cpp                |    9 +
 src/measurement/warmuptask.h                  |   16 +
 src/measurement/wsdownloadtask.cpp            |   97 +
 src/measurement/wsdownloadtask.h              |   32 +
 src/measurement/wsuploadtask.cpp              |   93 +
 src/measurement/wsuploadtask.h                |   28 +
 src/qt5gui/.gitignore                         |    3 +
 src/qt5gui/bredbandskollen.pro                |   89 +
 src/qt5gui/main.cpp                           |   67 +
 src/test/.gitignore                           |    2 +
 src/test/Makefile                             |   11 +
 src/test/README.md                            |   14 +
 src/test/task/Makefile                        |   21 +
 src/test/task/task.cpp                        |   76 +
 src/wincli/targetver.h                        |    8 +
 src/wincli/wincli.sln                         |   31 +
 src/wincli/wincli.vcxproj                     |  252 ++
 183 files changed, 20701 insertions(+)
 create mode 100644 .cache/nix/fetcher-cache-v4.sqlite
 create mode 100644 .gitignore
 create mode 100644 LICENSE
 create mode 100644 README.md
 create mode 100644 doc/Makefile
 create mode 100644 doc/doxygen.cfg
 create mode 100644 flake.lock
 create mode 100644 flake.nix
 create mode 120000 result
 create mode 100644 src/.gitignore
 create mode 100644 src/cli/.gitignore
 create mode 100644 src/cli/Makefile
 create mode 100644 src/cli/cliclient.cpp
 create mode 100644 src/cli/cliclient.h
 create mode 100644 src/cli/main.cpp
 create mode 100644 src/cli/utils.cpp
 create mode 100644 src/cli/utils.h
 create mode 100644 src/examples/.gitignore
 create mode 100644 src/examples/001_single_request/Makefile
 create mode 100644 src/examples/001_single_request/main.cpp
 create mode 100644 src/examples/002_simple_task/Makefile
 create mode 100644 src/examples/002_simple_task/main.cpp
 create mode 100644 src/examples/003_webserver/Makefile
 create mode 100644 src/examples/003_webserver/main.cpp
 create mode 100644 src/examples/004_timers/Makefile
 create mode 100644 src/examples/004_timers/main.cpp
 create mode 100644 src/examples/005_websocket_server/Makefile
 create mode 100644 src/examples/005_websocket_server/main.cpp
 create mode 100644 src/examples/005_websocket_server/winner.cpp
 create mode 100644 src/examples/005_websocket_server/winner.h
 create mode 100644 src/examples/006_websocket_client/Makefile
 create mode 100644 src/examples/006_websocket_client/main.cpp
 create mode 100644 src/examples/006_websocket_client/main2.cpp
 create mode 100644 src/examples/006_websocket_client/winnerclient.cpp
 create mode 100644 src/examples/006_websocket_client/winnerclient.h
 create mode 100644 src/examples/007_events/Makefile
 create mode 100644 src/examples/007_events/main.cpp
 create mode 100644 src/examples/008_workers/Makefile
 create mode 100644 src/examples/008_workers/main.cpp
 create mode 100644 src/examples/009_threads/Makefile
 create mode 100644 src/examples/009_threads/main.cpp
 create mode 100644 src/examples/010_echoserver/Makefile
 create mode 100644 src/examples/010_echoserver/echoserver.cpp
 create mode 100644 src/examples/010_echoserver/echoserverconnection.cpp
 create mode 100644 src/examples/010_echoserver/echoserverconnection.h
 create mode 100644 src/examples/010_echoserver/echoservertask.cpp
 create mode 100644 src/examples/010_echoserver/echoservertask.h
 create mode 100644 src/examples/011_echoclient/Makefile
 create mode 100644 src/examples/011_echoclient/echoclient.cpp
 create mode 100644 src/examples/011_echoclient/echoclientconnection.cpp
 create mode 100644 src/examples/011_echoclient/echoclientconnection.h
 create mode 100644 src/examples/011_echoclient/echoclienttask.cpp
 create mode 100644 src/examples/011_echoclient/echoclienttask.h
 create mode 100644 src/examples/020_cliclient/Makefile
 create mode 100644 src/examples/020_cliclient/cliclient.cpp
 create mode 100644 src/examples/020_cliclient/webserver.cpp
 create mode 100644 src/examples/020_cliclient/webserver.h
 create mode 100644 src/examples/030_httpclient/Makefile
 create mode 100644 src/examples/030_httpclient/main.cpp
 create mode 100644 src/examples/Makefile
 create mode 100644 src/framework/bridgetask.cpp
 create mode 100644 src/framework/bridgetask.h
 create mode 100644 src/framework/engine.cpp
 create mode 100644 src/framework/engine.h
 create mode 100644 src/framework/eventloop.cpp
 create mode 100644 src/framework/eventloop.h
 create mode 100644 src/framework/loadbalancer.cpp
 create mode 100644 src/framework/loadbalancer.h
 create mode 100644 src/framework/logger.cpp
 create mode 100644 src/framework/logger.h
 create mode 100644 src/framework/mk.inc
 create mode 100644 src/framework/msgqueue.h
 create mode 100644 src/framework/pollstate.h
 create mode 100644 src/framework/serversocket.cpp
 create mode 100644 src/framework/serversocket.h
 create mode 100644 src/framework/shortmessageconnection.cpp
 create mode 100644 src/framework/shortmessageconnection.h
 create mode 100644 src/framework/socket.cpp
 create mode 100644 src/framework/socket.h
 create mode 100644 src/framework/socketconnection.cpp
 create mode 100644 src/framework/socketconnection.h
 create mode 100644 src/framework/socketreceiver.cpp
 create mode 100644 src/framework/socketreceiver.h
 create mode 100644 src/framework/synchronousbridge.cpp
 create mode 100644 src/framework/synchronousbridge.h
 create mode 100644 src/framework/task.cpp
 create mode 100644 src/framework/task.h
 create mode 100644 src/framework/taskconfig.cpp
 create mode 100644 src/framework/taskconfig.h
 create mode 100644 src/framework/threadbridge.cpp
 create mode 100644 src/framework/threadbridge.h
 create mode 100644 src/framework/unixdomainbridge.cpp
 create mode 100644 src/framework/unixdomainbridge.h
 create mode 100644 src/framework/unixdomainclient.cpp
 create mode 100644 src/framework/unixdomainclient.h
 create mode 100644 src/framework/workerprocess.h
 create mode 100644 src/gtkgui/.gitignore
 create mode 100644 src/gtkgui/Makefile
 create mode 100644 src/gtkgui/gtkclient.cpp
 create mode 100644 src/gtkgui/gtkclient.css
 create mode 100644 src/gtkgui/gtkclient.h
 create mode 100644 src/gtkgui/main.cpp
 create mode 100644 src/http/cookiefile.cpp
 create mode 100644 src/http/cookiefile.h
 create mode 100644 src/http/cookiemanager.cpp
 create mode 100644 src/http/cookiemanager.h
 create mode 100644 src/http/http_common.cpp
 create mode 100644 src/http/http_common.h
 create mode 100644 src/http/httpclientconnection.cpp
 create mode 100644 src/http/httpclientconnection.h
 create mode 100644 src/http/httpclienttask.cpp
 create mode 100644 src/http/httpclienttask.h
 create mode 100644 src/http/httpconnection.cpp
 create mode 100644 src/http/httpconnection.h
 create mode 100644 src/http/httphost.h
 create mode 100644 src/http/httprequestengine.cpp
 create mode 100644 src/http/httprequestengine.h
 create mode 100644 src/http/httpserverconnection.cpp
 create mode 100644 src/http/httpserverconnection.h
 create mode 100644 src/http/httptask.cpp
 create mode 100644 src/http/httptask.h
 create mode 100644 src/http/mk.inc
 create mode 100644 src/http/sha1.cpp
 create mode 100644 src/http/sha1.h
 create mode 100644 src/http/singlerequest.cpp
 create mode 100644 src/http/singlerequest.h
 create mode 100644 src/http/webservertask.cpp
 create mode 100644 src/http/webservertask.h
 create mode 100644 src/http/websocketbridge.cpp
 create mode 100644 src/http/websocketbridge.h
 create mode 100644 src/json11/CMakeLists.txt
 create mode 100644 src/json11/LICENSE.txt
 create mode 100644 src/json11/Makefile
 create mode 100644 src/json11/README.md
 create mode 100644 src/json11/json11.cpp
 create mode 100644 src/json11/json11.hpp
 create mode 100644 src/json11/test.cpp
 create mode 100644 src/measurement/defs.cpp
 create mode 100644 src/measurement/defs.h
 create mode 100644 src/measurement/downloadtask.cpp
 create mode 100644 src/measurement/downloadtask.h
 create mode 100644 src/measurement/infotask.cpp
 create mode 100644 src/measurement/infotask.h
 create mode 100644 src/measurement/latencytask.cpp
 create mode 100644 src/measurement/latencytask.h
 create mode 100644 src/measurement/measurementagent.cpp
 create mode 100644 src/measurement/measurementagent.h
 create mode 100644 src/measurement/measurementtask.cpp
 create mode 100644 src/measurement/measurementtask.h
 create mode 100644 src/measurement/mk.inc
 create mode 100644 src/measurement/pingsweeptask.cpp
 create mode 100644 src/measurement/pingsweeptask.h
 create mode 100644 src/measurement/progresstask.cpp
 create mode 100644 src/measurement/progresstask.h
 create mode 100644 src/measurement/rpingtask.cpp
 create mode 100644 src/measurement/rpingtask.h
 create mode 100644 src/measurement/singlerequesttask.cpp
 create mode 100644 src/measurement/singlerequesttask.h
 create mode 100644 src/measurement/speedtest.cpp
 create mode 100644 src/measurement/speedtest.h
 create mode 100644 src/measurement/tickettask.cpp
 create mode 100644 src/measurement/tickettask.h
 create mode 100644 src/measurement/uploadinfotask.cpp
 create mode 100644 src/measurement/uploadinfotask.h
 create mode 100644 src/measurement/uploadtask.cpp
 create mode 100644 src/measurement/uploadtask.h
 create mode 100644 src/measurement/warmuptask.cpp
 create mode 100644 src/measurement/warmuptask.h
 create mode 100644 src/measurement/wsdownloadtask.cpp
 create mode 100644 src/measurement/wsdownloadtask.h
 create mode 100644 src/measurement/wsuploadtask.cpp
 create mode 100644 src/measurement/wsuploadtask.h
 create mode 100644 src/qt5gui/.gitignore
 create mode 100644 src/qt5gui/bredbandskollen.pro
 create mode 100644 src/qt5gui/main.cpp
 create mode 100644 src/test/.gitignore
 create mode 100644 src/test/Makefile
 create mode 100644 src/test/README.md
 create mode 100644 src/test/task/Makefile
 create mode 100644 src/test/task/task.cpp
 create mode 100644 src/wincli/targetver.h
 create mode 100644 src/wincli/wincli.sln
 create mode 100644 src/wincli/wincli.vcxproj

diff --git a/.cache/nix/fetcher-cache-v4.sqlite b/.cache/nix/fetcher-cache-v4.sqlite
new file mode 100644
index 0000000000000000000000000000000000000000..22177ed1dcd34b80368b63f7d0952a81c2bbc0fe
GIT binary patch
literal 12288
zcmWFz^vNtqRY=P(%1ta$FlG>7U}9o$P*7lCU|?ckU|?oI07eD|1{MUD0mMh*Vr4Qh
z=yi$k^8a99;^$!C=ion!Rn@5AXb6mkz-S1JhQMeDjE2By2#kinXb6mkz-S1JhQMeD
z&?y8Oofz50#l;z$l1mbka#EcWlQSR$lXH-(V~DFlh@+E_s{&YDL4!*{K|vuUKQ}Qm
z55y`-tte5*%P&#LE6vH#0ZV45R)S;{6cn&XmL=wtrh=uhNS0*grWThZ<`yVq=9Q$T
zrxu}^Tu_vmn^;t-0J1>?;szZMN0UoalZj2-R-BO`GcP5zqPQ?8vm`Y>v9u%~%#R1V
zJ>C#Zf%^3vprGXib@ch282DH6JAwG4cr*k?Ltr!nMnhmU1V%$(Gz3ONU^E0qLtr!n
zMnhmU1V%#uTL`2wv1%7Ov!rL1_#_sW_~xf%re&t4R4WywmMK{&nWUJcC0kmgB&V7t
zTbdf1m>L=;nWtD7Cz+-i8yc8cn5QLLni`pyE7evj<sj)-vNAL`F)}tVG%`1;&3Lmj
zKa`PGxlkKqO;Bo?bAD-F2{~32LG>zGnVN%*<pTHr%Nh8~`S)S--Kf}T2#kinXb6mk
zz-S1JhQMeDjE2By2#kinXb6mkz-S1Jh5*?i;Krg|$Vl;!0h1$(av^7WW(oO20sxzT
Bw?F^@

literal 0
HcmV?d00001

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..072e8a0
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+*.d
+*.o
+src/cli/cli
+
+ # VSCode
+.vscode
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..7c72edb
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,8 @@
+Bredbandskollen CLI - A bandwidth measurement tool
+Copright (C) 2018 The Swedish Internet Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..da10df6
--- /dev/null
+++ b/README.md
@@ -0,0 +1,142 @@
+# Bredbandskollen CLI
+
+The `src` directory contains the source code to the command line version of
+Bredbandskollen CLI, a bandwidth measurement tool.
+
+# How to build Bredbandskollen's CLI client
+
+On Windows, open
+
+    src/wincli/wincli.sln
+
+in Visual Studio 2015 or later, then choose "Build".
+
+On all other platforms, change to the directory
+
+    src/cli
+
+and run the command "make" (or "gmake"). GNU Make and a compiler with support
+for C++11 is required, e.g. GCC version 4.7 or later or LLVM Clang version 3.9 or later.
+
+To use a specific compiler, do e.g.
+
+    make CXX=clang++
+
+To enable support for TLS/SSL, install GnuTLS version 3.5 or later, and do
+
+    make clean
+    make GNUTLS=1
+
+To perform a bandwidth measurement using TLS, do
+
+    ./cli --test --ssl
+
+For more information, see "Platform Notes" below.
+
+# How to run the CLI client
+
+To perform a mesurement, simply run the executable program that was built using
+the above steps. For more information, run it with the --help argument or read
+
+   https://frontend.bredbandskollen.se/download/README.txt
+
+# About the source code
+
+The directories framework and http contain a basic C++ network programming
+framework with support for "tasks" and "timers". Some of the features are
+explained by demo programs in the examples directory.
+The [API documentation](https://www.dsso.se/bbkapi/annotated.html)
+can be built from the source code using [Doxygen](https://www.doxygen.nl/).
+
+The directory `json11` contains a JSON library for C++ provided by Dropbox, Inc.
+
+The directory `measurement` contains the bandwidth measurement engine, built atop
+the framework.
+
+The directory `cli` contains a command line interface to the measurement engine.
+
+The directory `qt5gui`     contains the source code for a GUI to the measurement
+engine. To build it, Qt5 and QWebEngine are required. You must run the Qt5
+version of `qmake` to create a Makefile before running `make` to build the GUI.
+
+# Platform Notes
+
+* Windows
+
+The code has not been thoroughly tested on Windows. Pull requests are welcome.
+
+Visual Studio 2015 or later is required, as are the components
+MSVC v140 (VS 2015 C++ build tools) and Windows 10 SDK. Visual Studio 2022 Community
+can be downloaded from https://visualstudio.microsoft.com/
+
+Open src/wincli/wincli.sln in Visual Studio, then select "Build".
+
+* MacOS
+
+Install Xcode from App Store, then go to src/cli and do make.
+For SSL support, install Homebrew from https://brew.sh and then do
+
+    brew install gnutls
+
+Once GnuTLS is installed, go to src/cli and do
+
+    make clean
+    make GNUTLS=1
+
+* Linux
+
+Make sure g++ version 4.7 or later is installed. Then go to src/cli and do
+
+    make
+
+If GnuTLS version 3.5 or later is installed, including development files, do
+
+    make clean
+    make GNUTLS=1
+
+* OpenWrt
+
+OpenWrt is also Linux, but will generally include cross-compiling.
+
+See [here](https://openwrt.org/docs/guide-developer/toolchain/crosscompile) for setting up the OpenWrt toolchain and getting ready to compile.
+
+After setting the `STAGING_DIR` environment variable and adding the cross-compiler bin folder to `PATH`, note the name of the g++ executable there and run make with CXX set to it, e.g.:
+
+    make CXX=aarch64-openwrt-linux-musl-g++
+
+* OpenBSD
+
+Install gmake, llvm and gnutls using pkg_add, then go to src/cli and do
+
+    gmake
+or
+
+    gmake GNUTLS=1
+
+* FreeBSD
+
+Install gmake and gnutls using pkg, then go to src/cli and do
+
+    gmake
+or
+
+    gmake GNUTLS=1
+
+* NetBSD
+
+Install gmake, llvm, clang, and gnutls using pkgin, then go to src/cli and do
+
+    gmake
+or
+
+    gmake GNUTLS=1
+
+# License
+
+Copright © 2018 The Swedish Internet Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/doc/Makefile b/doc/Makefile
new file mode 100644
index 0000000..76679e0
--- /dev/null
+++ b/doc/Makefile
@@ -0,0 +1,3 @@
+api:
+	cd .. && \
+	doxygen doc/doxygen.cfg
diff --git a/doc/doxygen.cfg b/doc/doxygen.cfg
new file mode 100644
index 0000000..7935bdc
--- /dev/null
+++ b/doc/doxygen.cfg
@@ -0,0 +1,2660 @@
+# Doxyfile 1.9.1
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a double hash (##) is considered a comment and is placed in
+# front of the TAG it is preceding.
+#
+# All text after a single hash (#) is considered a comment and will be ignored.
+# The format is:
+# TAG = value [value, ...]
+# For lists, items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (\" \").
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the configuration
+# file that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# https://www.gnu.org/software/libiconv/ for the list of possible encodings.
+# The default value is: UTF-8.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
+# double-quotes, unless you are using Doxywizard) that should identify the
+# project for which the documentation is generated. This name is used in the
+# title of most generated pages and in a few other places.
+# The default value is: My Project.
+
+PROJECT_NAME           = "Bredbandskollen CLI"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
+# could be handy for archiving the generated documentation or if some version
+# control system is used.
+
+PROJECT_NUMBER         = 1.2
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer a
+# quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          = Asynchronous network task engine
+
+# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
+# in the documentation. The maximum height of the logo should not exceed 55
+# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
+# the logo to the output directory.
+
+PROJECT_LOGO           =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
+# into which the generated documentation will be written. If a relative path is
+# entered, it will be relative to the location where doxygen was started. If
+# left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = doc
+
+# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
+# directories (in 2 levels) under the output directory of each output format and
+# will distribute the generated files over these directories. Enabling this
+# option can be useful when feeding doxygen a huge amount of source files, where
+# putting all generated files in the same directory would otherwise causes
+# performance problems for the file system.
+# The default value is: NO.
+
+CREATE_SUBDIRS         = NO
+
+# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
+# characters to appear in the names of generated files. If set to NO, non-ASCII
+# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
+# U+3044.
+# The default value is: NO.
+
+ALLOW_UNICODE_NAMES    = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
+# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
+# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
+# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
+# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
+# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
+# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
+# Ukrainian and Vietnamese.
+# The default value is: English.
+
+OUTPUT_LANGUAGE        = English
+
+# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all generated output in the proper direction.
+# Possible values are: None, LTR, RTL and Context.
+# The default value is: None.
+
+OUTPUT_TEXT_DIRECTION  = None
+
+# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
+# descriptions after the members that are listed in the file and class
+# documentation (similar to Javadoc). Set to NO to disable this.
+# The default value is: YES.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
+# description of a member or function before the detailed description
+#
+# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+# The default value is: YES.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator that is
+# used to form the text in various listings. Each string in this list, if found
+# as the leading text of the brief description, will be stripped from the text
+# and the result, after processing the whole list, is used as the annotated
+# text. Otherwise, the brief description is used as-is. If left blank, the
+# following values are used ($name is automatically replaced with the name of
+# the entity):The $name class, The $name widget, The $name file, is, provides,
+# specifies, contains, represents, a, an and the.
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# doxygen will generate a detailed section even if there is only a brief
+# description.
+# The default value is: NO.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+# The default value is: NO.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
+# before files name in the file list and in the header files. If set to NO the
+# shortest path that makes the file name unique will be used
+# The default value is: YES.
+
+FULL_PATH_NAMES        = YES
+
+# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
+# Stripping is only done if one of the specified strings matches the left-hand
+# part of the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the path to
+# strip.
+#
+# Note that you can specify absolute paths here, but also relative paths, which
+# will be relative from the directory where doxygen is started.
+# This tag requires that the tag FULL_PATH_NAMES is set to YES.
+
+STRIP_FROM_PATH        =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
+# path mentioned in the documentation of a class, which tells the reader which
+# header file to include in order to use a class. If left blank only the name of
+# the header file containing the class definition is used. Otherwise one should
+# specify the list of include paths that are normally passed to the compiler
+# using the -I flag.
+
+STRIP_FROM_INC_PATH    =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
+# less readable) file names. This can be useful is your file systems doesn't
+# support long names like on DOS, Mac, or CD-ROM.
+# The default value is: NO.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
+# first line (until the first dot) of a Javadoc-style comment as the brief
+# description. If set to NO, the Javadoc-style will behave just like regular Qt-
+# style comments (thus requiring an explicit @brief command for a brief
+# description.)
+# The default value is: NO.
+
+JAVADOC_AUTOBRIEF      = NO
+
+# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
+# such as
+# /***************
+# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
+# Javadoc-style will behave just like regular comments and it will not be
+# interpreted by doxygen.
+# The default value is: NO.
+
+JAVADOC_BANNER         = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
+# line (until the first dot) of a Qt-style comment as the brief description. If
+# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
+# requiring an explicit \brief command for a brief description.)
+# The default value is: NO.
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
+# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
+# a brief description. This used to be the default behavior. The new default is
+# to treat a multi-line C++ comment block as a detailed description. Set this
+# tag to YES if you prefer the old behavior instead.
+#
+# Note that setting this tag to YES also means that rational rose comments are
+# not recognized any more.
+# The default value is: NO.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# By default Python docstrings are displayed as preformatted text and doxygen's
+# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the
+# doxygen's special commands can be used and the contents of the docstring
+# documentation blocks is shown as doxygen documentation.
+# The default value is: YES.
+
+PYTHON_DOCSTRING       = YES
+
+# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
+# documentation from any documented member that it re-implements.
+# The default value is: YES.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
+# page for each member. If set to NO, the documentation of a member will be part
+# of the file/class/namespace that contains it.
+# The default value is: NO.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
+# uses this value to replace tabs by spaces in code fragments.
+# Minimum value: 1, maximum value: 16, default value: 4.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of aliases that act as commands in
+# the documentation. An alias has the form:
+# name=value
+# For example adding
+# "sideeffect=@par Side Effects:\n"
+# will allow you to put the command \sideeffect (or @sideeffect) in the
+# documentation, which will result in a user-defined paragraph with heading
+# "Side Effects:". You can put \n's in the value part of an alias to insert
+# newlines (in the resulting output). You can put ^^ in the value part of an
+# alias to insert a newline as if a physical newline was in the original file.
+# When you need a literal { or } or , in the value part of an alias you have to
+# escape them by means of a backslash (\), this can lead to conflicts with the
+# commands \{ and \} for these it is advised to use the version @{ and @} or use
+# a double escape (\\{ and \\})
+
+ALIASES                =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
+# only. Doxygen will then generate output that is more tailored for C. For
+# instance, some of the names that are used will be different. The list of all
+# members will be omitted, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
+# Python sources only. Doxygen will then generate output that is more tailored
+# for that language. For instance, namespaces will be presented as packages,
+# qualified scopes will look different, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources. Doxygen will then generate output that is tailored for Fortran.
+# The default value is: NO.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for VHDL.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice
+# sources only. Doxygen will then generate output that is more tailored for that
+# language. For instance, namespaces will be presented as modules, types will be
+# separated into more groups, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_SLICE  = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension, and
+# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
+# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, VHDL,
+# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
+# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
+# tries to guess whether the code is fixed or free formatted code, this is the
+# default for Fortran type files). For instance to make doxygen treat .inc files
+# as Fortran files (default is PHP), and .f files as C (default is Fortran),
+# use: inc=Fortran f=C.
+#
+# Note: For files without extension you can use no_extension as a placeholder.
+#
+# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
+# the files are not read by doxygen. When specifying no_extension you should add
+# * to the FILE_PATTERNS.
+#
+# Note see also the list of default file extension mappings.
+
+EXTENSION_MAPPING      =
+
+# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+# according to the Markdown format, which allows for more readable
+# documentation. See https://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you can
+# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+# case of backward compatibilities issues.
+# The default value is: YES.
+
+MARKDOWN_SUPPORT       = YES
+
+# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
+# to that level are automatically included in the table of contents, even if
+# they do not have an id attribute.
+# Note: This feature currently applies only to Markdown headings.
+# Minimum value: 0, maximum value: 99, default value: 5.
+# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
+
+TOC_INCLUDE_HEADINGS   = 5
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by putting a % sign in front of the word or
+# globally by setting AUTOLINK_SUPPORT to NO.
+# The default value is: YES.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should set this
+# tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string);
+# versus func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+# The default value is: NO.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+# The default value is: NO.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
+# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen
+# will parse them like normal C++ but will assume all classes use public instead
+# of private inheritance when no explicit protection keyword is present.
+# The default value is: NO.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES will make
+# doxygen to replace the get and set methods by a property in the documentation.
+# This will only work if the methods are indeed getting or setting a simple
+# type. If this is not the case, or you want to show the methods anyway, you
+# should set this option to NO.
+# The default value is: YES.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+# The default value is: NO.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# If one adds a struct or class to a group and this option is enabled, then also
+# any nested class or struct is added to the same group. By default this option
+# is disabled and one has to add nested compounds explicitly via \ingroup.
+# The default value is: NO.
+
+GROUP_NESTED_COMPOUNDS = NO
+
+# Set the SUBGROUPING tag to YES to allow class member groups of the same type
+# (for instance a group of public functions) to be put as a subgroup of that
+# type (e.g. under the Public Functions section). Set it to NO to prevent
+# subgrouping. Alternatively, this can be done per class using the
+# \nosubgrouping command.
+# The default value is: YES.
+
+SUBGROUPING            = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
+# are shown inside the group in which they are included (e.g. using \ingroup)
+# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
+# and RTF).
+#
+# Note that this feature does not work in combination with
+# SEPARATE_MEMBER_PAGES.
+# The default value is: NO.
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
+# with only public data fields or simple typedef fields will be shown inline in
+# the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO, structs, classes, and unions are shown on a separate page (for HTML and
+# Man pages) or section (for LaTeX and RTF).
+# The default value is: NO.
+
+INLINE_SIMPLE_STRUCTS  = NO
+
+# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
+# enum is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically be
+# useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+# The default value is: NO.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can be
+# an expensive process and often the same symbol appears multiple times in the
+# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
+# doxygen will become slower. If the cache is too large, memory is wasted. The
+# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
+# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
+# symbols. At the end of a run doxygen will report the cache usage and suggest
+# the optimal cache size from a speed point of view.
+# Minimum value: 0, maximum value: 9, default value: 0.
+
+LOOKUP_CACHE_SIZE      = 0
+
+# The NUM_PROC_THREADS specifies the number threads doxygen is allowed to use
+# during processing. When set to 0 doxygen will based this on the number of
+# cores available in the system. You can set it explicitly to a value larger
+# than 0 to get more control over the balance between CPU load and processing
+# speed. At this moment only the input processing can be done using multiple
+# threads. Since this is still an experimental feature the default is set to 1,
+# which efficively disables parallel processing. Please report any issues you
+# encounter. Generating dot graphs in parallel is controlled by the
+# DOT_NUM_THREADS setting.
+# Minimum value: 0, maximum value: 32, default value: 1.
+
+NUM_PROC_THREADS       = 1
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
+# documentation are documented, even if no documentation was available. Private
+# class members and static file members will be hidden unless the
+# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
+# Note: This will also disable the warnings about undocumented members that are
+# normally produced when WARNINGS is set to YES.
+# The default value is: NO.
+
+EXTRACT_ALL            = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
+# be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
+# methods of a class will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIV_VIRTUAL   = NO
+
+# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
+# scope will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PACKAGE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
+# included in the documentation.
+# The default value is: NO.
+
+EXTRACT_STATIC         = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
+# locally in source files will be included in the documentation. If set to NO,
+# only classes defined in header files are included. Does not have any effect
+# for Java sources.
+# The default value is: YES.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. If set to YES, local methods,
+# which are defined in the implementation section but not in the interface are
+# included in the documentation. If set to NO, only methods in the interface are
+# included.
+# The default value is: NO.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base name of
+# the file that contains the anonymous namespace. By default anonymous namespace
+# are hidden.
+# The default value is: NO.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If this flag is set to YES, the name of an unnamed parameter in a declaration
+# will be determined by the corresponding definition. By default unnamed
+# parameters remain unnamed in the output.
+# The default value is: YES.
+
+RESOLVE_UNNAMED_PARAMS = YES
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
+# undocumented members inside documented classes or files. If set to NO these
+# members will be included in the various overviews, but no documentation
+# section is generated. This option has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy. If set
+# to NO, these classes will be included in the various overviews. This option
+# has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+# declarations. If set to NO, these declarations will be included in the
+# documentation.
+# The default value is: NO.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
+# documentation blocks found inside the body of a function. If set to NO, these
+# blocks will be appended to the function's detailed documentation block.
+# The default value is: NO.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation that is typed after a
+# \internal command is included. If the tag is set to NO then the documentation
+# will be excluded. Set it to YES to include the internal documentation.
+# The default value is: NO.
+
+INTERNAL_DOCS          = NO
+
+# With the correct setting of option CASE_SENSE_NAMES doxygen will better be
+# able to match the capabilities of the underlying filesystem. In case the
+# filesystem is case sensitive (i.e. it supports files in the same directory
+# whose names only differ in casing), the option must be set to YES to properly
+# deal with such files in case they appear in the input. For filesystems that
+# are not case sensitive the option should be be set to NO to properly deal with
+# output files written for symbols that only differ in casing, such as for two
+# classes, one named CLASS and the other named Class, and to also support
+# references to files without having to specify the exact matching casing. On
+# Windows (including Cygwin) and MacOS, users should typically set this option
+# to NO, whereas on Linux or other Unix flavors it should typically be set to
+# YES.
+# The default value is: system dependent.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
+# their full class and namespace scopes in the documentation. If set to YES, the
+# scope will be hidden.
+# The default value is: NO.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
+# append additional text to a page's title, such as Class Reference. If set to
+# YES the compound reference will be hidden.
+# The default value is: NO.
+
+HIDE_COMPOUND_REFERENCE= NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
+# the files that are included by a file in the documentation of that file.
+# The default value is: YES.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
+# grouped member an include statement to the documentation, telling the reader
+# which file to include in order to use the member.
+# The default value is: NO.
+
+SHOW_GROUPED_MEMB_INC  = NO
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
+# files with double quotes in the documentation rather than with sharp brackets.
+# The default value is: NO.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
+# documentation for inline members.
+# The default value is: YES.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
+# (detailed) documentation of file and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order.
+# The default value is: YES.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
+# descriptions of file, namespace and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order. Note that
+# this will also influence the order of the classes in the class list.
+# The default value is: NO.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
+# (brief and detailed) documentation of class members so that constructors and
+# destructors are listed first. If set to NO the constructors will appear in the
+# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
+# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
+# member documentation.
+# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
+# detailed member documentation.
+# The default value is: NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
+# of group names into alphabetical order. If set to NO the group names will
+# appear in their defined order.
+# The default value is: NO.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
+# fully-qualified names, including namespaces. If set to NO, the class list will
+# be sorted only by class name, not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the alphabetical
+# list.
+# The default value is: NO.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
+# type resolution of all parameters of a function it will reject a match between
+# the prototype and the implementation of a member function even if there is
+# only one candidate or it is obvious which candidate to choose by doing a
+# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
+# accept a match between prototype and implementation in such cases.
+# The default value is: NO.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
+# list. This list is created by putting \todo commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
+# list. This list is created by putting \test commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
+# list. This list is created by putting \bug commands in the documentation.
+# The default value is: YES.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
+# the deprecated list. This list is created by putting \deprecated commands in
+# the documentation.
+# The default value is: YES.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional documentation
+# sections, marked by \if <section_label> ... \endif and \cond <section_label>
+# ... \endcond blocks.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
+# initial value of a variable or macro / define can have for it to appear in the
+# documentation. If the initializer consists of more lines than specified here
+# it will be hidden. Use a value of 0 to hide initializers completely. The
+# appearance of the value of individual variables and macros / defines can be
+# controlled using \showinitializer or \hideinitializer command in the
+# documentation regardless of this setting.
+# Minimum value: 0, maximum value: 10000, default value: 30.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
+# the bottom of the documentation of classes and structs. If set to YES, the
+# list will mention the files that were used to generate the documentation.
+# The default value is: YES.
+
+SHOW_USED_FILES        = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
+# will remove the Files entry from the Quick Index and from the Folder Tree View
+# (if specified).
+# The default value is: YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
+# page. This will remove the Namespaces entry from the Quick Index and from the
+# Folder Tree View (if specified).
+# The default value is: YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command command input-file, where command is the value of the
+# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
+# by doxygen. Whatever the program writes to standard output is used as the file
+# version. For an example see the documentation.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. To create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option. You can
+# optionally specify a file name after the option, if omitted DoxygenLayout.xml
+# will be used as the name of the layout file.
+#
+# Note that if you run doxygen from a directory containing a file called
+# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
+# tag is left empty.
+
+LAYOUT_FILE            =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
+# the reference definitions. This must be a list of .bib files. The .bib
+# extension is automatically appended if omitted. This requires the bibtex tool
+# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
+# For LaTeX the style of the bibliography can be controlled using
+# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
+# search path. See also \cite for info how to create references.
+
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated to
+# standard output by doxygen. If QUIET is set to YES this implies that the
+# messages are off.
+# The default value is: NO.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
+# this implies that the warnings are on.
+#
+# Tip: Turn warnings on while writing the documentation.
+# The default value is: YES.
+
+WARNINGS               = YES
+
+# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
+# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
+# will automatically be disabled.
+# The default value is: YES.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some parameters
+# in a documented function, or documenting parameters that don't exist or using
+# markup commands wrongly.
+# The default value is: YES.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
+# are documented, but have no documentation for their parameters or return
+# value. If set to NO, doxygen will only warn about wrong or incomplete
+# parameter documentation, but not about the absence of documentation. If
+# EXTRACT_ALL is set to YES then this flag will automatically be disabled.
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = NO
+
+# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
+# a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
+# then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
+# at the end of the doxygen process doxygen will return with a non-zero status.
+# Possible values are: NO, YES and FAIL_ON_WARNINGS.
+# The default value is: NO.
+
+WARN_AS_ERROR          = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that doxygen
+# can produce. The string should contain the $file, $line, and $text tags, which
+# will be replaced by the file and line number from which the warning originated
+# and the warning text. Optionally the format may contain $version, which will
+# be replaced by the version of the file (if it could be obtained via
+# FILE_VERSION_FILTER)
+# The default value is: $file:$line: $text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning and error
+# messages should be written. If left blank the output is written to standard
+# error (stderr).
+
+WARN_LOGFILE           = errors.log
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag is used to specify the files and/or directories that contain
+# documented source files. You may enter file names like myfile.cpp or
+# directories like /usr/src/myproject. Separate the files or directories with
+# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = src/framework src/http src/measurement
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
+# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
+# documentation (see:
+# https://www.gnu.org/software/libiconv/) for the list of possible encodings.
+# The default value is: UTF-8.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
+# *.h) to filter out the source-files in the directories.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# read by doxygen.
+#
+# Note the list of default checked file patterns might differ from the list of
+# default file extension mappings.
+#
+# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
+# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
+# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
+# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment),
+# *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd, *.vhdl,
+# *.ucf, *.qsf and *.ice.
+
+FILE_PATTERNS          = *.c \
+                         *.cc \
+                         *.cxx \
+                         *.cpp \
+                         *.c++ \
+                         *.java \
+                         *.ii \
+                         *.ixx \
+                         *.ipp \
+                         *.i++ \
+                         *.inl \
+                         *.idl \
+                         *.ddl \
+                         *.odl \
+                         *.h \
+                         *.hh \
+                         *.hxx \
+                         *.hpp \
+                         *.h++ \
+                         *.cs \
+                         *.d \
+                         *.php \
+                         *.php4 \
+                         *.php5 \
+                         *.phtml \
+                         *.inc \
+                         *.m \
+                         *.markdown \
+                         *.md \
+                         *.mm \
+                         *.dox \
+                         *.py \
+                         *.pyw \
+                         *.f90 \
+                         *.f95 \
+                         *.f03 \
+                         *.f08 \
+                         *.f18 \
+                         *.f \
+                         *.for \
+                         *.vhd \
+                         *.vhdl \
+                         *.ucf \
+                         *.qsf \
+                         *.ice
+
+# The RECURSIVE tag can be used to specify whether or not subdirectories should
+# be searched for input files as well.
+# The default value is: NO.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+#
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE                =
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+# The default value is: NO.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories.
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       = */test/* *.d
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories use the pattern */test/*
+
+EXCLUDE_SYMBOLS        =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or directories
+# that contain example code fragments that are included (see the \include
+# command).
+
+EXAMPLE_PATH           =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank all
+# files are included.
+
+EXAMPLE_PATTERNS       = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude commands
+# irrespective of the value of the RECURSIVE tag.
+# The default value is: NO.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or directories
+# that contain images that are to be included in the documentation (see the
+# \image command).
+
+IMAGE_PATH             =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command:
+#
+# <filter> <input-file>
+#
+# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
+# name of an input file. Doxygen will then use the output that the filter
+# program writes to standard output. If FILTER_PATTERNS is specified, this tag
+# will be ignored.
+#
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+INPUT_FILTER           =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form: pattern=filter
+# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
+# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
+# patterns match the file name, INPUT_FILTER is applied.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+FILTER_PATTERNS        =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will also be used to filter the input files that are used for
+# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
+# The default value is: NO.
+
+FILTER_SOURCE_FILES    = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
+# it is also possible to disable source filtering for a specific pattern using
+# *.ext= (so without naming a filter).
+# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
+
+FILTER_SOURCE_PATTERNS =
+
+# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want to reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE =
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
+# generated. Documented entities will be cross-referenced with these sources.
+#
+# Note: To get rid of all source code in the generated output, make sure that
+# also VERBATIM_HEADERS is set to NO.
+# The default value is: NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body of functions,
+# classes and enums directly into the documentation.
+# The default value is: NO.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
+# special comment blocks from generated source code fragments. Normal C, C++ and
+# Fortran comments will always remain visible.
+# The default value is: YES.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
+# entity all documented functions referencing it will be listed.
+# The default value is: NO.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES then for each documented function
+# all documented entities called/used by that function will be listed.
+# The default value is: NO.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
+# to YES then the hyperlinks from functions in REFERENCES_RELATION and
+# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
+# link to the documentation.
+# The default value is: YES.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
+# source code will show a tooltip with additional information such as prototype,
+# brief description and links to the definition and documentation. Since this
+# will make the HTML file larger and loading of large files a bit slower, you
+# can opt to disable this feature.
+# The default value is: YES.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+SOURCE_TOOLTIPS        = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code will
+# point to the HTML generated by the htags(1) tool instead of doxygen built-in
+# source browser. The htags tool is part of GNU's global source tagging system
+# (see https://www.gnu.org/software/global/global.html). You will need version
+# 4.8.6 or higher.
+#
+# To use it do the following:
+# - Install the latest version of global
+# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file
+# - Make sure the INPUT points to the root of the source tree
+# - Run doxygen as normal
+#
+# Doxygen will invoke htags (and that will in turn invoke gtags), so these
+# tools must be available from the command line (i.e. in the search path).
+#
+# The result: instead of the source browser generated by doxygen, the links to
+# source code will now point to the output of htags.
+# The default value is: NO.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
+# verbatim copy of the header file for each class for which an include is
+# specified. Set to NO to disable this.
+# See also: Section \class.
+# The default value is: YES.
+
+VERBATIM_HEADERS       = YES
+
+# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
+# clang parser (see:
+# http://clang.llvm.org/) for more accurate parsing at the cost of reduced
+# performance. This can be particularly helpful with template rich C++ code for
+# which doxygen's built-in parser lacks the necessary type information.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+# The default value is: NO.
+
+CLANG_ASSISTED_PARSING = NO
+
+# If clang assisted parsing is enabled and the CLANG_ADD_INC_PATHS tag is set to
+# YES then doxygen will add the directory of each input to the include path.
+# The default value is: YES.
+
+CLANG_ADD_INC_PATHS    = YES
+
+# If clang assisted parsing is enabled you can provide the compiler with command
+# line options that you would normally use when invoking the compiler. Note that
+# the include paths will already be set by doxygen for the files and directories
+# specified with INPUT and INCLUDE_PATH.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_OPTIONS          =
+
+# If clang assisted parsing is enabled you can provide the clang parser with the
+# path to the directory containing a file called compile_commands.json. This
+# file is the compilation database (see:
+# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) containing the
+# options used when the source files were built. This is equivalent to
+# specifying the -p option to a clang tool, such as clang-check. These options
+# will then be passed to the parser. Any options specified with CLANG_OPTIONS
+# will be added as well.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+
+CLANG_DATABASE_PATH    =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
+# compounds will be generated. Enable this if the project contains a lot of
+# classes, structs, unions or interfaces.
+# The default value is: YES.
+
+ALPHABETICAL_INDEX     = YES
+
+# In case all classes in a project start with a common prefix, all classes will
+# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+# can be used to specify a prefix (or a list of prefixes) that should be ignored
+# while generating the index headers.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
+# The default value is: YES.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
+# generated HTML page (for example: .htm, .php, .asp).
+# The default value is: .html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
+# each generated HTML page. If the tag is left blank doxygen will generate a
+# standard header.
+#
+# To get valid HTML the header file that includes any scripts and style sheets
+# that doxygen needs, which is dependent on the configuration options used (e.g.
+# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
+# default header using
+# doxygen -w html new_header.html new_footer.html new_stylesheet.css
+# YourConfigFile
+# and then modify the file new_header.html. See also section "Doxygen usage"
+# for information on how to generate the default header that doxygen normally
+# uses.
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. For a description
+# of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_HEADER            =
+
+# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
+# generated HTML page. If the tag is left blank doxygen will generate a standard
+# footer. See HTML_HEADER for more information on how to generate a default
+# footer and what special commands can be used inside the footer. See also
+# section "Doxygen usage" for information on how to generate the default footer
+# that doxygen normally uses.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FOOTER            =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
+# sheet that is used by each HTML page. It can be used to fine-tune the look of
+# the HTML output. If left blank doxygen will generate a default style sheet.
+# See also section "Doxygen usage" for information on how to generate the style
+# sheet that doxygen normally uses.
+# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
+# it is more robust and this tag (HTML_STYLESHEET) will in the future become
+# obsolete.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_STYLESHEET        =
+
+# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# cascading style sheets that are included after the standard style sheets
+# created by doxygen. Using this option one can overrule certain style aspects.
+# This is preferred over using HTML_STYLESHEET since it does not replace the
+# standard style sheet and is therefore more robust against future updates.
+# Doxygen will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list). For an example see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_STYLESHEET  =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
+# files will be copied as-is; there are no commands or markers available.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
+# will adjust the colors in the style sheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
+# purple, and 360 is red again.
+# Minimum value: 0, maximum value: 359, default value: 220.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
+# in the HTML output. For a value of 0 the output will use grayscales only. A
+# value of 255 will produce the most vivid colors.
+# Minimum value: 0, maximum value: 255, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
+# luminance component of the colors in the HTML output. Values below 100
+# gradually make the output lighter, whereas values above 100 make the output
+# darker. The value divided by 100 is the actual gamma applied, so 80 represents
+# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
+# change the gamma.
+# Minimum value: 40, maximum value: 240, default value: 80.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to YES can help to show when doxygen was last run and thus if the
+# documentation is up to date.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = NO
+
+# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
+# documentation will contain a main index with vertical navigation menus that
+# are dynamically created via JavaScript. If disabled, the navigation index will
+# consists of multiple levels of tabs that are statically embedded in every HTML
+# page. Disable this option to support browsers that do not have JavaScript,
+# like the Qt help browser.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_MENUS     = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
+# shown in the various tree structured indices initially; the user can expand
+# and collapse entries dynamically later on. Doxygen will expand the tree to
+# such a level that at most the specified number of entries are visible (unless
+# a fully collapsed tree already exceeds this amount). So setting the number of
+# entries 1 will produce a full collapsed tree by default. 0 is a special value
+# representing an infinite number of entries and will result in a full expanded
+# tree by default.
+# Minimum value: 0, maximum value: 9999, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_INDEX_NUM_ENTRIES = 100
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files will be
+# generated that can be used as input for Apple's Xcode 3 integrated development
+# environment (see:
+# https://developer.apple.com/xcode/), introduced with OSX 10.5 (Leopard). To
+# create a documentation set, doxygen will generate a Makefile in the HTML
+# output directory. Running make will produce the docset in that directory and
+# running make install will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
+# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
+# genXcode/_index.html for more information.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_DOCSET        = NO
+
+# This tag determines the name of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# The default value is: Doxygen generated docs.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# This tag specifies a string that should uniquely identify the documentation
+# set bundle. This should be a reverse domain-name style string, e.g.
+# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+# The default value is: org.doxygen.Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
+# The default value is: Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
+# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
+# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
+# (see:
+# https://www.microsoft.com/en-us/download/details.aspx?id=21138) on Windows.
+#
+# The HTML Help Workshop contains a compiler that can convert all HTML output
+# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
+# files are now used as the Windows 98 help format, and will replace the old
+# Windows help format (.hlp) on all Windows platforms in the future. Compressed
+# HTML files also contain an index, a table of contents, and you can search for
+# words in the documentation. The HTML workshop also contains a viewer for
+# compressed HTML files.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_HTMLHELP      = NO
+
+# The CHM_FILE tag can be used to specify the file name of the resulting .chm
+# file. You can add a path in front of the file if the result should not be
+# written to the html output directory.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_FILE               =
+
+# The HHC_LOCATION tag can be used to specify the location (absolute path
+# including file name) of the HTML help compiler (hhc.exe). If non-empty,
+# doxygen will try to run the HTML help compiler on the generated index.hhp.
+# The file has to be specified with full path.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+HHC_LOCATION           =
+
+# The GENERATE_CHI flag controls if a separate .chi index file is generated
+# (YES) or that it should be included in the main .chm file (NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+GENERATE_CHI           = NO
+
+# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
+# and project file content.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_INDEX_ENCODING     =
+
+# The BINARY_TOC flag controls whether a binary table of contents is generated
+# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
+# enables the Previous and Next buttons.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members to
+# the table of contents of the HTML help documentation and to the tree view.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
+# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
+# (.qch) of the generated HTML documentation.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
+# the file name of the resulting .qch file. The path specified is relative to
+# the HTML output folder.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QCH_FILE               =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
+# Project output. For more information please see Qt Help Project / Namespace
+# (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
+# Help Project output. For more information please see Qt Help Project / Virtual
+# Folders (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders).
+# The default value is: doc.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
+# filter to add. For more information please see Qt Help Project / Custom
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_NAME   =
+
+# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see Qt Help Project / Custom
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_ATTRS  =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's filter section matches. Qt Help Project / Filter Attributes (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# The QHG_LOCATION tag can be used to specify the location (absolute path
+# including file name) of Qt's qhelpgenerator. If non-empty doxygen will try to
+# run qhelpgenerator on the generated .qhp file.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHG_LOCATION           =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
+# generated, together with the HTML files, they form an Eclipse help plugin. To
+# install this plugin and make it available under the help contents menu in
+# Eclipse, the contents of the directory containing the HTML and XML files needs
+# to be copied into the plugins directory of eclipse. The name of the directory
+# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
+# After copying Eclipse needs to be restarted before the help appears.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the Eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have this
+# name. Each documentation set should have its own identifier.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# If you want full control over the layout of the generated HTML pages it might
+# be necessary to disable the index and replace it with your own. The
+# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
+# of each HTML page. A value of NO enables the index and the value YES disables
+# it. Since the tabs in the index contain the same information as the navigation
+# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+DISABLE_INDEX          = NO
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information. If the tag
+# value is set to YES, a side panel will be generated containing a tree-like
+# index structure (just like the one that is generated for HTML Help). For this
+# to work a browser that supports JavaScript, DHTML, CSS and frames is required
+# (i.e. any modern browser). Windows users are probably better off using the
+# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
+# further fine-tune the look of the index. As an example, the default style
+# sheet generated by doxygen has an example that shows how to put an image at
+# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
+# the same information as the tab index, you could consider setting
+# DISABLE_INDEX to YES when enabling this option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_TREEVIEW      = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
+# doxygen will group on one line in the generated HTML documentation.
+#
+# Note that a value of 0 will completely suppress the enum values from appearing
+# in the overview section.
+# Minimum value: 0, maximum value: 20, default value: 4.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
+# to set the initial width (in pixels) of the frame in which the tree is shown.
+# Minimum value: 0, maximum value: 1500, default value: 250.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+TREEVIEW_WIDTH         = 250
+
+# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
+# external symbols imported via tag files in a separate window.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg
+# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
+# https://inkscape.org) to generate formulas as SVG images instead of PNGs for
+# the HTML output. These images will generally look nicer at scaled resolutions.
+# Possible values are: png (the default) and svg (looks nicer but requires the
+# pdf2svg or inkscape tool).
+# The default value is: png.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FORMULA_FORMAT    = png
+
+# Use this tag to change the font size of LaTeX formulas included as images in
+# the HTML documentation. When you change the font size after a successful
+# doxygen run you need to manually remove any form_*.png images from the HTML
+# output directory to force them to be regenerated.
+# Minimum value: 8, maximum value: 50, default value: 10.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
+# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
+# to create new LaTeX commands to be used in formulas as building blocks. See
+# the section "Including formulas" for details.
+
+FORMULA_MACROFILE      =
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# https://www.mathjax.org) which uses client side JavaScript for the rendering
+# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
+# installed or if you want to formulas look prettier in the HTML output. When
+# enabled you may also need to install MathJax separately and configure the path
+# to it using the MATHJAX_RELPATH option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. See the MathJax site (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details.
+# Possible values are: HTML-CSS (which is slower, but has the best
+# compatibility), NativeMML (i.e. MathML) and SVG.
+# The default value is: HTML-CSS.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_FORMAT         = HTML-CSS
+
+# When MathJax is enabled you need to specify the location relative to the HTML
+# output directory using the MATHJAX_RELPATH option. The destination directory
+# should contain the MathJax.js script. For instance, if the mathjax directory
+# is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
+# Content Delivery Network so you can quickly see the result without installing
+# MathJax. However, it is strongly recommended to install a local copy of
+# MathJax from https://www.mathjax.org before deployment.
+# The default value is: https://cdn.jsdelivr.net/npm/mathjax@2.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = https://cdn.jsdelivr.net/npm/mathjax@2
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+# extension names that should be enabled during MathJax rendering. For example
+# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_EXTENSIONS     =
+
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
+# of code that will be used on startup of the MathJax code. See the MathJax site
+# (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details. For an
+# example see the documentation.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_CODEFILE       =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
+# the HTML output. The underlying search engine uses javascript and DHTML and
+# should work on any modern browser. Note that when using HTML help
+# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
+# there is already a search function so this one should typically be disabled.
+# For large projects the javascript based search engine can be slow, then
+# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
+# search using the keyboard; to jump to the search box use <access key> + S
+# (what the <access key> is depends on the OS and browser, but it is typically
+# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
+# key> to jump into the search results window, the results can be navigated
+# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
+# the search. The filter options can be selected when the cursor is inside the
+# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
+# to select a filter and <Enter> or <escape> to activate or cancel the filter
+# option.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+SEARCHENGINE           = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using JavaScript. There
+# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
+# setting. When disabled, doxygen will generate a PHP script for searching and
+# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
+# and searching needs to be provided by external tools. See the section
+# "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SERVER_BASED_SEARCH    = NO
+
+# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+# search results.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see:
+# https://xapian.org/).
+#
+# See the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH        = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will return the search results when EXTERNAL_SEARCH is enabled.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see:
+# https://xapian.org/). See the section "External Indexing and Searching" for
+# details.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHENGINE_URL       =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+# The default file is: searchdata.xml.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH_ID     =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+# to a relative location where the documentation can be found. The format is:
+# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTRA_SEARCH_MAPPINGS  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
+# The default value is: YES.
+
+GENERATE_LATEX         = YES
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked.
+#
+# Note that when not enabling USE_PDFLATEX the default is latex when enabling
+# USE_PDFLATEX the default is pdflatex and when in the later case latex is
+# chosen this is overwritten by pdflatex. For specific output languages the
+# default can have been set differently, this depends on the implementation of
+# the output language.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         =
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# Note: This tag is used in the Makefile / make.bat.
+# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file
+# (.tex).
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
+# generate index for LaTeX. In case there is no backslash (\) as first character
+# it will be automatically added in the LaTeX code.
+# Note: This tag is used in the generated output file (.tex).
+# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
+# The default value is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_MAKEINDEX_CMD    = makeindex
+
+# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used by the
+# printer.
+# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+# 14 inches) and executive (7.25 x 10.5 inches).
+# The default value is: a4.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PAPER_TYPE             = a4
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. The package can be specified just
+# by its name or with the correct syntax as to be used with the LaTeX
+# \usepackage command. To get the times font for instance you can specify :
+# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
+# To use the option intlimits with the amsmath package you can specify:
+# EXTRA_PACKAGES=[intlimits]{amsmath}
+# If left blank no extra packages will be included.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+EXTRA_PACKAGES         =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
+# generated LaTeX document. The header should contain everything until the first
+# chapter. If it is left blank doxygen will generate a standard header. See
+# section "Doxygen usage" for information on how to let doxygen write the
+# default header to a separate file.
+#
+# Note: Only use a user-defined header if you know what you are doing! The
+# following commands have a special meaning inside the header: $title,
+# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
+# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
+# string, for the replacement values of the other commands the user is referred
+# to HTML_HEADER.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
+# generated LaTeX document. The footer should contain everything after the last
+# chapter. If it is left blank doxygen will generate a standard footer. See
+# LATEX_HEADER for more information on how to generate a default footer and what
+# special commands can be used inside the footer.
+#
+# Note: Only use a user-defined footer if you know what you are doing!
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_FOOTER           =
+
+# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# LaTeX style sheets that are included after the standard style sheets created
+# by doxygen. Using this option one can overrule certain style aspects. Doxygen
+# will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list).
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_STYLESHEET =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the LATEX_OUTPUT output
+# directory. Note that the files will be copied as-is; there are no commands or
+# markers available.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_FILES      =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+# contain links (just like the HTML output) instead of page references. This
+# makes the output suitable for online browsing using a PDF viewer.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, doxygen will use the engine as
+# specified with LATEX_CMD_NAME to generate the PDF file directly from the LaTeX
+# files. Set this option to YES, to get a higher quality PDF documentation.
+#
+# See also section LATEX_CMD_NAME for selecting the engine.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+# command to the generated LaTeX files. This will instruct LaTeX to keep running
+# if errors occur, instead of asking the user for help. This option is also used
+# when generating formulas in HTML.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BATCHMODE        = NO
+
+# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+# index chapters (such as File Index, Compound Index, etc.) in the output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HIDE_INDICES     = NO
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# The default value is: plain.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BIB_STYLE        = plain
+
+# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_TIMESTAMP        = NO
+
+# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
+# path from which the emoji images will be read. If a relative path is entered,
+# it will be relative to the LATEX_OUTPUT directory. If left blank the
+# LATEX_OUTPUT directory will be used.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EMOJI_DIRECTORY  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
+# RTF output is optimized for Word 97 and may not look too pretty with other RTF
+# readers/editors.
+# The default value is: NO.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: rtf.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+# contain hyperlink fields. The RTF file will contain links (just like the HTML
+# output) instead of page references. This makes the output suitable for online
+# browsing using Word or some other Word compatible readers that support those
+# fields.
+#
+# Note: WordPad (write) and others do not support links.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# configuration file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+#
+# See also section "Doxygen usage" for information on how to generate the
+# default style sheet that doxygen normally uses.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an RTF document. Syntax is
+# similar to doxygen's configuration file. A template extensions file can be
+# generated using doxygen -e rtf extensionFile.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_EXTENSIONS_FILE    =
+
+# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
+# with syntax highlighting in the RTF output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_SOURCE_CODE        = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
+# classes and files.
+# The default value is: NO.
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it. A directory man3 will be created inside the directory specified by
+# MAN_OUTPUT.
+# The default directory is: man.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to the generated
+# man pages. In case the manual section does not start with a number, the number
+# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+# optional.
+# The default value is: .3.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_EXTENSION          = .3
+
+# The MAN_SUBDIR tag determines the name of the directory created within
+# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
+# MAN_EXTENSION with the initial . removed.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_SUBDIR             =
+
+# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+# will generate one additional man file for each entity documented in the real
+# man page(s). These additional files only source the real man page, but without
+# them the man command would be unable to find the correct page.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
+# captures the structure of the code including all documentation.
+# The default value is: NO.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: xml.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_OUTPUT             = xml
+
+# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
+# listings (including syntax highlighting and cross-referencing information) to
+# the XML output. Note that enabling this will significantly increase the size
+# of the XML output.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_PROGRAMLISTING     = YES
+
+# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include
+# namespace members in file scope as well, matching the HTML output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_NS_MEMB_FILE_SCOPE = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
+# that can be used to generate PDF.
+# The default value is: NO.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it.
+# The default directory is: docbook.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_OUTPUT         = docbook
+
+# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
+# program listings (including syntax highlighting and cross-referencing
+# information) to the DOCBOOK output. Note that enabling this will significantly
+# increase the size of the DOCBOOK output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_PROGRAMLISTING = NO
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
+# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
+# the structure of the code including all documentation. Note that this feature
+# is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
+# file that captures the structure of the code including all documentation.
+#
+# Note that this feature is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
+# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
+# output from the Perl module output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
+# formatted so it can be parsed by a human reader. This is useful if you want to
+# understand what is going on. On the other hand, if this tag is set to NO, the
+# size of the Perl module output will be much smaller and Perl will parse it
+# just the same.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file are
+# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
+# so different doxyrules.make files included by the same Makefile don't
+# overwrite each other's variables.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
+# C-preprocessor directives found in the sources and include files.
+# The default value is: YES.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
+# in the source code. If set to NO, only conditional compilation will be
+# performed. Macro expansion can be done in a controlled way by setting
+# EXPAND_ONLY_PREDEF to YES.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+# the macro expansion is limited to the macros specified with the PREDEFINED and
+# EXPAND_AS_DEFINED tags.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES, the include files in the
+# INCLUDE_PATH will be searched if a #include is found.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by the
+# preprocessor.
+# This tag requires that the tag SEARCH_INCLUDES is set to YES.
+
+INCLUDE_PATH           =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will be
+# used.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+INCLUDE_FILE_PATTERNS  =
+
+# The PREDEFINED tag can be used to specify one or more macro names that are
+# defined before the preprocessor is started (similar to the -D option of e.g.
+# gcc). The argument of the tag is a list of macros of the form: name or
+# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+# is assumed. To prevent a macro definition from being undefined via #undef or
+# recursively expanded use the := operator instead of the = operator.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+PREDEFINED             = TASKRUNNER_LOGERR TASKRUNNER_LOGWARN \
+                         TASKRUNNER_LOGINFO TASKRUNNER_LOGDBG \
+                         USE_GNUTLS USE_THREADS
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+# tag can be used to specify a list of macro names that should be expanded. The
+# macro definition that is found in the sources will be used. Use the PREDEFINED
+# tag if you want to use a different macro definition that overrules the
+# definition found in the source code.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_AS_DEFINED      =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+# remove all references to function-like macros that are alone on a line, have
+# an all uppercase name, and do not end with a semicolon. Such function macros
+# are typically used for boiler-plate code, and will confuse the parser if not
+# removed.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tag files. For each tag
+# file the location of the external documentation should be added. The format of
+# a tag file without this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where loc1 and loc2 can be relative or absolute paths or URLs. See the
+# section "Linking to external documentation" for more information about the use
+# of tag files.
+# Note: Each tag file must have a unique name (where the name does NOT include
+# the path). If a tag file is not located in the directory in which doxygen is
+# run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+# tag file that is based on the input files it reads. See section "Linking to
+# external documentation" for more information about the usage of tag files.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
+# the class index. If set to NO, only the inherited external classes will be
+# listed.
+# The default value is: NO.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will be
+# listed.
+# The default value is: YES.
+
+EXTERNAL_GROUPS        = YES
+
+# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
+# the related pages index. If set to NO, only the current project's pages will
+# be listed.
+# The default value is: YES.
+
+EXTERNAL_PAGES         = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = YES
+
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH               =
+
+# If set to YES the inheritance and collaboration graphs will hide inheritance
+# and usage relations if the target is undocumented or is not a class.
+# The default value is: YES.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz (see:
+# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+# Bell Labs. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: YES.
+
+HAVE_DOT               = YES
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+# to run in parallel. When set to 0 doxygen will base this on the number of
+# processors available in the system. You can set it explicitly to a value
+# larger than 0 to get control over the balance between CPU load and processing
+# speed.
+# Minimum value: 0, maximum value: 32, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NUM_THREADS        = 0
+
+# When you want a differently looking font in the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the default font as specified with
+# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+# the path where dot can find it using this tag.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
+# each documented class showing the direct and indirect inheritance relations.
+# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+# graph for each documented class showing the direct and indirect implementation
+# dependencies (inheritance, containment, and class references variables) of the
+# class with other documented classes.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+# groups, showing the direct groups dependencies.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LOOK               = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+# class node. If there are many fields or methods and many nodes the graph may
+# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+# number of items for each type to make the size more manageable. Set this to 0
+# for no limit. Note that the threshold may be exceeded by 50% before the limit
+# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+# but if the number exceeds 15, the total amount of fields shown is limited to
+# 10.
+# Minimum value: 0, maximum value: 100, default value: 10.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and
+# methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS
+# tag is set to YES, doxygen will add type and arguments for attributes and
+# methods in the UML graphs. If the DOT_UML_DETAILS tag is set to NONE, doxygen
+# will not generate fields with class member information in the UML graphs. The
+# class diagrams will look similar to the default class diagrams but using UML
+# notation for the relationships.
+# Possible values are: NO, YES and NONE.
+# The default value is: NO.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+DOT_UML_DETAILS        = NO
+
+# The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters
+# to display on a single line. If the actual line length exceeds this threshold
+# significantly it will wrapped across multiple lines. Some heuristics are apply
+# to avoid ugly line breaks.
+# Minimum value: 0, maximum value: 1000, default value: 17.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_WRAP_THRESHOLD     = 17
+
+# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+# collaboration graphs will show the relations between templates and their
+# instances.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+# YES then doxygen will generate a graph for each documented file showing the
+# direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDE_GRAPH          = YES
+
+# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+# set to YES then doxygen will generate a graph for each documented file showing
+# the direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command. Disabling a call graph can be
+# accomplished by means of the command \hidecallgraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALL_GRAPH             = NO
+
+# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command. Disabling a caller graph can be
+# accomplished by means of the command \hidecallergraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH           = NO
+
+# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+# hierarchy of all classes instead of a textual one.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+# dependencies a directory has on other directories in a graphical way. The
+# dependency relations are determined by the #include relations between the
+# files in the directories.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. For an explanation of the image formats see the section
+# output formats in the documentation of the dot tool (Graphviz (see:
+# http://www.graphviz.org/)).
+# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+# to make the SVG files visible in IE 9+ (other browsers do not have this
+# requirement).
+# Possible values are: png, png:cairo, png:cairo:cairo, png:cairo:gd, png:gd,
+# png:gd:gd, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, gif, gif:cairo,
+# gif:cairo:gd, gif:gd, gif:gd:gd, svg, png:gd, png:gd:gd, png:cairo,
+# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+# png:gdiplus:gdiplus.
+# The default value is: png.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_IMAGE_FORMAT       = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INTERACTIVE_SVG        = NO
+
+# The DOT_PATH tag can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the \dotfile
+# command).
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
+
+MSCFILE_DIRS           =
+
+# The DIAFILE_DIRS tag can be used to specify one or more directories that
+# contain dia files that are included in the documentation (see the \diafile
+# command).
+
+DIAFILE_DIRS           =
+
+# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
+# path where java can find the plantuml.jar file. If left blank, it is assumed
+# PlantUML is not used or called during a preprocessing step. Doxygen will
+# generate a warning when it encounters a \startuml command in this case and
+# will not generate output for the diagram.
+
+PLANTUML_JAR_PATH      =
+
+# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
+# configuration file for plantuml.
+
+PLANTUML_CFG_FILE      =
+
+# When using plantuml, the specified paths are searched for files specified by
+# the !include statement in a plantuml block.
+
+PLANTUML_INCLUDE_PATH  =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+# generated by dot. A depth value of 3 means that only nodes reachable from the
+# root by following a path via at most 3 edges will be shown. Nodes that lay
+# further from the root node will be omitted. Note that setting this option to 1
+# or 2 may greatly reduce the computation time needed for large code bases. Also
+# note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+# Minimum value: 0, maximum value: 1000, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10) support
+# this, this feature is disabled by default.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_MULTI_TARGETS      = NO
+
+# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+# explaining the meaning of the various boxes and arrows in the dot generated
+# graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate
+# files that are used to generate the various graphs.
+#
+# Note: This setting is not only used for dot files but also for msc and
+# plantuml temporary files.
+# The default value is: YES.
+
+DOT_CLEANUP            = YES
diff --git a/flake.lock b/flake.lock
new file mode 100644
index 0000000..2468070
--- /dev/null
+++ b/flake.lock
@@ -0,0 +1,61 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1735563628,
+        "narHash": "sha256-OnSAY7XDSx7CtDoqNh8jwVwh4xNL/2HaJxGjryLWzX8=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "b134951a4c9f3c995fd7be05f3243f8ecd65d798",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-24.05",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
diff --git a/flake.nix b/flake.nix
new file mode 100644
index 0000000..8a5e107
--- /dev/null
+++ b/flake.nix
@@ -0,0 +1,65 @@
+{
+  description = "Bredbandskollen CLI";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs =
+    { self, nixpkgs, flake-utils }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = import nixpkgs { inherit system; };
+        lib = pkgs.lib;
+        version = if self ? rev && self.rev != null then self.rev else "unstable";
+      in
+      {
+        packages = {
+          default = pkgs.stdenv.mkDerivation {
+            pname = "bbk";
+            inherit version;
+            src = self;
+
+            nativeBuildInputs = [ pkgs.pkg-config ];
+            buildInputs = [ pkgs.gnutls ];
+
+            makeFlags = [ "GNUTLS=1" ];
+
+            buildPhase = ''
+              runHook preBuild
+              make -C src/cli
+              runHook postBuild
+            '';
+
+            installPhase = ''
+              runHook preInstall
+              install -Dm755 src/cli/cli $out/bin/bbk
+              runHook postInstall
+            '';
+
+            meta = {
+              description = "Swedish Internet Foundation's Bredbandskollen CLI bandwidth measurement tool";
+              homepage = "https://www.bredbandskollen.se/";
+              license = lib.licenses.mit;
+              maintainers = with lib.maintainers; [ "Fredrik Wastring" ];
+              mainProgram = "bbk";
+            };
+          };
+        };
+
+        devShells.default = pkgs.mkShell {
+          buildInputs = [
+            pkgs.gnutls
+            pkgs.pkg-config
+            pkgs.gnumake
+          ];
+        };
+      nixosModules.default =
+        { pkgs, ... }:
+        {
+          environment.systemPackages = [ self.packages.${pkgs.system}.default ];
+        };
+      }
+    );
+}
diff --git a/result b/result
new file mode 120000
index 0000000..c1ba093
--- /dev/null
+++ b/result
@@ -0,0 +1 @@
+/nix/store/nwh5jhgbd3yq2bnryjf1kq6fhbsanm41-bredbandskollen-cli-unstable
\ No newline at end of file
diff --git a/src/.gitignore b/src/.gitignore
new file mode 100644
index 0000000..6142305
--- /dev/null
+++ b/src/.gitignore
@@ -0,0 +1,2 @@
+*.o
+*.d
diff --git a/src/cli/.gitignore b/src/cli/.gitignore
new file mode 100644
index 0000000..573c0c4
--- /dev/null
+++ b/src/cli/.gitignore
@@ -0,0 +1 @@
+cli
diff --git a/src/cli/Makefile b/src/cli/Makefile
new file mode 100644
index 0000000..550081a
--- /dev/null
+++ b/src/cli/Makefile
@@ -0,0 +1,31 @@
+TARGET = cli
+DIRLEVEL = ..
+
+# Possible LOGLEVEL values: dbg, info, warn, err, none
+LOGLEVEL=info
+
+# Uncomment if GnuTLS version 3.5 or later is available
+# GNUTLS=1
+
+# Uncomment this to avoid creating new processes
+# NO_EXTERNAL_CMD=1
+
+SOURCES=../http/cookiefile.cpp \
+	main.cpp \
+	../measurement/wsdownloadtask.cpp \
+	utils.cpp \
+	cliclient.cpp
+
+ifeq ($(SERVER),1)
+SOURCES += ../server/measurementserver.cpp \
+	../server/ticketclient.cpp
+CXXFLAGS += -DRUN_SERVER
+else
+CLEAN += ../server/measurementserver.o ../server/ticketclient.o
+endif
+
+ifeq ($(NO_EXTERNAL_CMD),1)
+CXXFLAGS += -DNO_EXTERNAL_CMD
+endif
+
+include $(DIRLEVEL)/measurement/mk.inc
diff --git a/src/cli/cliclient.cpp b/src/cli/cliclient.cpp
new file mode 100644
index 0000000..f29f5a2
--- /dev/null
+++ b/src/cli/cliclient.cpp
@@ -0,0 +1,455 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#ifdef _WIN32
+#define NOMINMAX
+#include <winsock2.h>
+#include <windows.h>
+#include <iso646.h>
+#include <stdio.h>
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
+#include <exception>
+#include <iostream>
+#include <iomanip>
+#include <fstream>
+
+#include "../json11/json11.hpp"
+#include "cliclient.h"
+
+CliClient::CliClient(const TaskConfig &config) :
+    Logger("CLI"),
+    out(&std::cout),
+    the_config(config) {
+
+    //setlocale(LC_ALL, "");
+
+#ifdef _WIN32
+    out_is_tty = _isatty(_fileno(stdout));
+#else
+    out_is_tty = isatty(fileno(stdout));
+#endif
+    out_quiet = (the_config.value("quiet") == "1" ||
+                 the_config.value("logfile") == "-");
+    if (!the_config.value("out").empty()) {
+        out = new std::ofstream(the_config.value("out"), std::ofstream::app);
+        out_is_tty = false;
+    }
+    report.measurement_server = the_config.value("server");
+    if (the_config.value("pingsweep") != "1" &&
+        !the_config.hasKey("list_measurements")) {
+        if (out_quiet) {
+            // Block all output:
+            out->clear(std::istream::eofbit);
+        } else {
+            *out << "Start: ";
+            sayTime(*out);
+            *out << ((the_config.value("mtype") == "ipv6") ? "  [ipv6]\n" : "\n");
+        }
+    }
+
+    /*
+    try {
+        current_line.imbue(std::locale(""));
+    } catch (std::exception &e) {
+        log() << "cannot set locale: " << e.what();
+    }
+    */
+
+    if (the_config.value("logfile") == "-")
+        out_is_tty = false; // Otherwise output might be garbled by the log.
+}
+
+void CliClient::initialMsgToAgent(std::deque<std::string> &return_msgs) {
+    return_msgs.push_back("{\"method\": \"clientReady\", \"args\": {}}");
+}
+
+void CliClient::newEventFromAgent(std::deque<std::string> &return_msgs,
+                                  const std::string &msg) {
+    std::string jsonerr;
+    auto obj = json11::Json::parse(msg, jsonerr);
+    if (!jsonerr.empty()) {
+        if (BridgeTask::isAgentTerminatedMessage(msg))
+            std::cerr << msg << std::endl;
+        else
+            err_log() << "JSON error: got " << msg;
+        return_msgs.push_back(BridgeTask::msgToAgent("terminate"));
+        return;
+    }
+
+    std::string event = obj["event"].string_value();
+    auto arg_obj = obj["args"];
+
+    if (event == "setInfo" && !arg_obj["logText"].string_value().empty()) {
+        log() << "EVENT: setInfo logText";
+    } else
+        log() << "EVENT: " << event << ' ' << msg;
+
+    if (event == "configuration") {
+        if (!arg_obj["require_consent"].string_value().empty()) {
+            // We need user consent to process personal data.
+            // First fetch the legalese:
+            json11::Json args = json11::Json::object {
+                { "lang", "en" },
+                { "format", "text" },
+                { "consent", arg_obj["require_consent"] },
+            };
+            return_msgs.push_back(BridgeTask::msgToAgent("getContent", args.dump()));
+            // When the content arrives, we'll show it to the user and
+            // ask for consent.
+            return;
+        }
+        report.isp = arg_obj["ispname"].string_value();
+        if (!report.isp.empty())
+            *out << "Network operator: " << report.isp << std::endl;
+
+        if (the_config.value("ssl") == "1")
+            report.tls = 1;
+        int server_port = std::stoi(the_config.value("port"));
+        if (report.measurement_server.empty()) {
+            std::vector<json11::Json> vec = arg_obj["servers"].array_items();
+            for (auto srv : vec) {
+                if (srv["type"].string_value() == the_config.value("mtype")) {
+                    std::string hostname = srv["url"].string_value();
+                    auto pos = hostname.find(':');
+                    if (the_config.value("mtype") != "ipv6" &&
+                        pos != std::string::npos) {
+                        server_port = std::stoi(hostname.substr(pos+1));
+                        hostname.resize(pos);
+                    }
+                    if (report.tls) {
+                        if (int tlsport = srv["tlsport"].int_value()) {
+                            report.measurement_server = hostname;
+                            server_port = tlsport;
+                            break;
+                        }
+                    } else {
+                        report.measurement_server = hostname;
+                        break;
+                    }
+                }
+            }
+            if (report.measurement_server.empty()) {
+                show_message("Error: no measurement server");
+                return_msgs.push_back(BridgeTask::msgToAgent("terminate"));
+                return;
+            }
+        }
+        //*out << "Server: " << report.measurement_server << std::endl;
+        std::string key = arg_obj["hashkey"].string_value();
+        json11::Json out_args = json11::Json::object {
+            { "serverUrl", report.measurement_server },
+            { "serverPort", server_port },
+            { "userKey", key },
+            { "tls", report.tls },
+        };
+        if (the_config.value("pingsweep") == "1")
+            return_msgs.push_back(BridgeTask::msgToAgent("pingSweep"));
+        else
+            return_msgs.push_back(BridgeTask::msgToAgent("startTest", out_args.dump()));
+    } else if (event == "taskProgress") {
+        std::string tst = arg_obj["task"].string_value();
+        if (tst == "download" || tst == "upload" || tst == "uploadinfo") {
+            double val = arg_obj["result"].number_value();
+            do_output(val, " Mbit/s", false);
+        }
+    } else if (event == "taskStart") {
+        std::string tst = arg_obj["task"].string_value();
+        if (tst == "download") {
+            setHeader("Download: ");
+        } else if (tst == "upload") {
+            setHeader("Upload:   ");
+        }
+    } else if (event == "taskComplete") {
+        std::string tst = arg_obj["task"].string_value();
+        if (tst == "global") {
+            if (out_quiet) {
+                // Enable output:
+                out->clear(std::istream::goodbit);
+
+                if (the_config.value("quiet") != "1")
+                    *out << "\n\nRESULT: ";
+
+                std::string limiter = the_config.value("limiter", " ");
+
+                *out << report.download << limiter
+                     << report.upload << limiter
+                     << report.latency << limiter
+                     << report.measurement_server << limiter
+                     << report.isp << limiter
+                     << report.ticket << limiter
+                     << measurement_id;
+                if (report.rating.empty())
+                    *out << std::endl;
+                else
+                    *out << limiter << report.rating << std::endl;
+            }
+            return_msgs.push_back(BridgeTask::msgToAgent("quit"));
+        } else if (tst == "latency") {
+            auto res = arg_obj["result"].number_value();
+            report.latency = res;
+            if (in_progress_task) {
+                deferred_latency = true;
+            } else {
+                setHeader("Latency:  ");
+                do_output(report.latency, " ms", true);
+            }
+        } else if (tst == "download") {
+            in_progress_task = false;
+            auto res = arg_obj["result"].number_value();
+            report.download = res;
+            do_output(res, " Mbit/s", true);
+        } else if (tst == "upload") {
+            in_progress_task = false;
+            auto res = arg_obj["result"].number_value();
+            report.upload = res;
+            do_output(res, " Mbit/s", true);
+            if (deferred_latency) {
+                *out << "Latency:  " << std::flush;
+                do_output(report.latency, " ms", true);
+            }
+            // Since Measure.AutoSaveReport is false, we tell the agent we're done.
+            // Any information can be sent in the args object.
+            return_msgs.push_back(BridgeTask::msgToAgent("saveReport", "{}"));
+        }
+    } else if (event == "agentReady") {
+        // Translate from "user-friendly" option name to agent's name:
+        static const std::map<std::string, std::string> configMap {
+            { "speedlimit", "Measure.SpeedLimit" },
+            { "duration",  "Measure.LoadDuration" },
+            { "iptype", "Measure.IpType" },
+            { "hashkey", "Client.hashkey" }
+        };
+
+        std::map<std::string, std::string> newConfig;
+        if (!savedOptions) {
+            savedOptions = true;
+            auto range = the_config.range("configure");
+            for (auto newp = range.first; newp != range.second; ++newp) {
+                std::string opt = newp->second;
+                auto pos = opt.find('=');
+                std::string attr = opt.substr(0, pos);
+                auto pp = configMap.find(attr);
+                if (pp != configMap.end()) {
+                    std::string value = (pos == std::string::npos) ? "1" :
+                        opt.substr(pos+1);
+                    newConfig[pp->second] = value;
+                }
+            }
+            if (!newConfig.empty()) {
+                json11::Json args = newConfig;
+                auto mesg = BridgeTask::msgToAgent("saveConfigurationOption",
+						   args.dump());
+                return_msgs.push_back(mesg);
+                // Let the agent send agentReady again, with updated options:
+                return_msgs.push_back(BridgeTask::msgToAgent("clientReady"));
+                return;
+            }
+        }
+
+        // Loop over saved configuration options:
+        for (auto &p : arg_obj.object_items()) {
+            std::string attr = p.first;
+            std::string value = p.second.string_value();
+            if (the_config.value(attr) != "override")
+                newConfig[attr] = value;
+        }
+        if (!newConfig.empty()) {
+            json11::Json args = newConfig;
+            auto mesg = BridgeTask::msgToAgent("setConfigurationOption",
+					       args.dump());
+            return_msgs.push_back(mesg);
+        }
+
+        if (the_config.hasKey("list_measurements")) {
+            std::map<std::string, std::string> pars;
+            pars["max"] = the_config.value("list_measurements");
+            if (the_config.hasKey("list_from"))
+                pars["from"] = the_config.value("list_from");
+            // pars["key"] = ...
+            json11::Json args = json11::Json(pars);
+            return_msgs.push_back(BridgeTask::msgToAgent("listMeasurements",
+                                                         args.dump()));
+        } else {
+            return_msgs.push_back(BridgeTask::msgToAgent("getConfiguration"));
+        }
+    } else if (event == "measurementList") {
+        std::vector<json11::Json> vec = arg_obj["measurements"].array_items();
+        if (out_quiet) {
+            *out << arg_obj.string_value() << std::endl;
+        } else if (vec.empty()) {
+            *out << "No measurements found." << std::endl;
+        } else {
+            // {"id":83310,"down":113.994,"up":58.6238,"latency":6.28596,"server":"Stockholm","isp":"Stiftelsen for Internetinfrastruktur","ts":1519736433}
+            *out << "ID\tDownload\tUpload\tLatency\tServer\tISP\tDate\n";
+            for (auto &m : vec) {
+                time_t ts = static_cast<time_t>(m["ts"].number_value());
+                unsigned long id = static_cast<unsigned long>(m["id"].number_value());
+                if (id && ts)
+                    *out << id << "\t"
+                         << m["down"].number_value() << "\t"
+                         << m["up"].number_value() << "\t"
+                         << m["latency"].number_value() << "\t"
+                         << m["server"].string_value() << "\t"
+                         << m["isp"].string_value() << "\t"
+                         << dateString(ts) << "\n";
+            }
+            long n = static_cast<long>(arg_obj["remaining"].number_value());
+            if (n > 0)
+                *out << n << " older measurements\n";
+        }
+        return_msgs.push_back(BridgeTask::msgToAgent("terminate"));
+    } else if (event == "report") {
+        auto res = arg_obj["subscription"];
+        if (res["status"].int_value() != 1)
+            return;
+        std::string isp = res["ispOperator"].string_value();
+        if (!isp.empty() && isp != report.isp)
+            *out << "Service provider: " << isp << std::endl;
+        report.msg = res["ispInfoMessage"].string_value();
+        if (!report.msg.empty())
+            *out << "Message from service provider: " << report.msg << std::endl;
+        std::string subs = res["ispSpeedName"].string_value();
+        if (subs.empty())
+            return;
+        *out << "Subscription: " << subs << std::endl;
+        auto sinfo = arg_obj["subscription_info"];
+        for (auto &p1 : sinfo.array_items()) {
+            for (auto &p2 : p1["categories"].array_items()) {
+                if (p2["description"].string_value() == subs) {
+                    try {
+                        std::string good = p2["good"].string_value(),
+                            acceptable = p2["acceptable"].string_value();
+                        if (good.empty() || acceptable.empty())
+                            return;
+                        if (report.download*1000 >= std::stod(good))
+                            report.rating = "GOOD";
+                        else if (report.download*1000 >= std::stod(acceptable))
+                            report.rating = "ACCEPTABLE";
+                        else
+                            report.rating = "BAD";
+                        *out << "The download result is "
+                             << report.rating << std::endl;
+                        break;
+                    } catch (...) {
+                    }
+                }
+            }
+        }
+        if (report.rating == "BAD") {
+            std::string bmsg = res["ispBadInfoMessage"].string_value();
+            if (!bmsg.empty() && bmsg != report.msg)
+                *out << "Message from service provider regarding the download "
+                     << "result: " << bmsg << std::endl;
+        }
+    } else if (event == "measurementInfo") {
+        measurement_id = arg_obj["MeasurementID"].string_value();
+        if (!measurement_id.empty())
+            *out << "Measurement ID: " << measurement_id << std::endl;
+        std::string imsg = arg_obj["ispInfoMessage"].string_value();
+        if (!imsg.empty() && imsg != report.msg)
+            *out << "Message from service provider: " << imsg << std::endl;
+    } else if (event == "setInfo") {
+        for (auto &p : arg_obj.object_items()) {
+            std::string attr = p.first;
+            std::string value = p.second.string_value();
+            if (attr == "error") {
+                if (!value.empty()) {
+                    std::string ecode = arg_obj["errno"].string_value();
+                    if (ecode.empty())
+                        *out << "fatal error: " << value << std::endl;
+                    else
+                        *out << "fatal error: " << value << " (error code "
+                             << ecode << ")" << std::endl;
+                    break;
+                }
+            } else if (attr == "ticket") {
+                report.ticket = value;
+                *out << "Support ID: " << value << std::endl;
+            } else if (attr == "contents") {
+                json11::Json cobj = p.second;
+                if (!cobj["consent"].string_value().empty() &&
+                    !cobj["body"].string_value().empty()) {
+                    show_message(cobj["body"].string_value());
+                    show_message("Type Y to accept, N to decline: ", false);
+                    std::string reply;
+                    std::getline(std::cin, reply);
+                    if (reply.find_first_of("Yy") != std::string::npos) {
+                        return_msgs.push_back(BridgeTask::msgToAgent("getConfiguration",
+                                                                    cobj.dump()));
+                    } else {
+                        return_msgs.push_back(BridgeTask::msgToAgent("terminate"));
+                    }
+                } else {
+                    show_message("Server error.");
+                    return_msgs.push_back(BridgeTask::msgToAgent("terminate"));
+                }
+            } else if (attr == "logText") {
+            } else if (attr == "approxLatency") {
+                show_message("Response time: " + value);
+            } else if (attr == "bestServer") {
+                if (value.empty())
+                    show_message("error: no server available");
+                else
+                    show_message("Closest server: " + value);
+                return_msgs.push_back(BridgeTask::msgToAgent("terminate"));
+            } else if (attr == "msgToUser") {
+                show_message(value);
+            }
+        }
+    }
+}
+
+void CliClient::show_message(const std::string &msg, bool linefeed) {
+    if (out_quiet)
+        out->clear(std::istream::goodbit);
+    *out << msg;
+    if (linefeed)
+        *out << std::endl;
+    else
+        *out << std::flush;
+    if (out_quiet)
+        out->clear(std::istream::eofbit);
+}
+
+void CliClient::do_output(double value, const char *msg, bool final) {
+    if (out_is_tty) // Erase current line:
+        *out << '\r';
+    if (out_is_tty || final) {
+        auto to_delete = current_line.str().size();
+        current_line.str("");
+        current_line << current_header << std::setw(10) << std::setprecision(3)
+                     << std::fixed << value << msg;
+        *out << current_line.str();
+        if (to_delete > current_line.str().size())
+            *out << std::string(to_delete - current_line.str().size(), ' ');
+        *out << std::flush;
+    }
+    if (final) {
+        current_line.str("");
+        if (value <= 0)
+            *out << " test failed";
+        *out << std::endl;
+    }
+}
+
+void CliClient::do_output(const char *msg, bool final) {
+    if (out_is_tty) // Erase current line:
+        *out << '\r';
+    if (out_is_tty || final) {
+        auto to_delete = current_line.str().size();
+        current_line.str("");
+        current_line << msg;
+        *out << current_line.str();
+        if (to_delete > current_line.str().size())
+            *out << std::string(to_delete - current_line.str().size(), ' ');
+        *out << std::flush;
+    }
+    if (final) {
+        current_line.str("");
+        *out << std::endl;
+    }
+}
diff --git a/src/cli/cliclient.h b/src/cli/cliclient.h
new file mode 100644
index 0000000..c2be173
--- /dev/null
+++ b/src/cli/cliclient.h
@@ -0,0 +1,54 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <deque>
+#include <sstream>
+
+#include "../framework/logger.h"
+#include "../framework/synchronousbridge.h"
+
+class CliClient : public Logger, public SynchronousClient {
+public:
+    CliClient(const TaskConfig &config);
+
+    void initialMsgToAgent(std::deque<std::string> &return_msgs) override;
+
+    // msg is a new message from the agent.
+    // push any return messages onto return_msgs.
+    virtual void newEventFromAgent(std::deque<std::string> &return_msgs,
+                                   const std::string &msg) override;
+    void setHeader(const std::string &hdr) {
+        in_progress_task = true;
+        *out << hdr << std::flush;
+        current_header = hdr;
+    }
+private:
+    // To store the measurement details:
+    struct {
+        double latency, download, upload;
+        std::string ticket, measurement_server, rating, isp, msg;
+        int tls;
+    } report = { -1.0, -1.0, -1.0, "no_support_ID", "", "", "", "", 0 };
+
+    // Stuff to handle output:
+    void show_message(const std::string &msg,  bool linefeed = true);
+    void do_output(const char *msg, bool final = false);
+    void do_output(double value, const char *msg, bool final = false);
+    std::ostream *out;
+    bool out_is_tty, out_quiet;
+    std::ostringstream current_line;
+    std::string current_header;
+    std::string measurement_id;
+    // Set to true during upload and download:
+    bool in_progress_task = false;
+    // It latency result arrives asynchronously during
+    // upload or download, we must wait until the end to show it:
+    bool deferred_latency = false;
+
+    // If user wants to set persistent options, we shoud save them only once.
+    bool savedOptions = false;
+
+    const TaskConfig the_config;
+};
diff --git a/src/cli/main.cpp b/src/cli/main.cpp
new file mode 100644
index 0000000..dca0987
--- /dev/null
+++ b/src/cli/main.cpp
@@ -0,0 +1,56 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <fstream>
+
+#if defined(RUN_SERVER)
+#include "../server/measurementserver.h"
+#endif
+
+#include "../http/httphost.h"
+#include "../http/websocketbridge.h"
+#include "../measurement/measurementagent.h"
+#include "utils.h"
+#include "cliclient.h"
+
+int main(int argc, char *argv[]) {
+
+    // Options for the measurement agent and the client (user interface):
+    TaskConfig agent_cfg, config;
+
+    if (!parseArgs(argc, argv, config, agent_cfg))
+        return 1;
+
+    std::ofstream log_file;
+    config.openlog(log_file);
+    if (!log_file) {
+        std::cerr << "cannot write to log file" << std::endl;
+        return 1;
+    }
+
+    EventLoop loop;
+
+#if defined(RUN_SERVER)
+    if (config.value("run_server") == "1") {
+        std::string srv_cfg = "listen " + config.value("listen");
+        if (!config.value("Measure.LocalAddress").empty())
+            (srv_cfg += ' ') += config.value("Measure.LocalAddress");
+        loop.addTask(new MeasurementServer(srv_cfg));
+        loop.runUntilComplete();
+        return 0;
+    }
+#endif
+
+    CookieFile cf(config.value("config_file"));
+    HttpHost webserver(agent_cfg.value("Measure.Webserver"), 80, "", 0, &cf);
+    MeasurementAgent *agent = new MeasurementAgent(agent_cfg, webserver);
+    CliClient client(config);
+    if (config.value("listen").empty()) {
+        loop.addTask(new SynchronousBridge(agent, &client));
+    } else {
+        loop.addTask(new WebsocketBridge(agent, config));
+    }
+
+    loop.runUntilComplete();
+    return 0;
+}
diff --git a/src/cli/utils.cpp b/src/cli/utils.cpp
new file mode 100644
index 0000000..c1523c2
--- /dev/null
+++ b/src/cli/utils.cpp
@@ -0,0 +1,325 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <direct.h>
+#define mkdir(x) _mkdir(x)
+#else
+#include <csignal>
+#include <unistd.h>
+#include <sys/stat.h>
+#endif
+#include <cstdlib>
+#include <cerrno>
+#include <iostream>
+#include <fstream>
+#include "utils.h"
+#include "../framework/taskconfig.h"
+#include "../measurement/defs.h"
+#include "../http/sha1.h"
+#include "../framework/logger.h"
+#include <vector>
+
+namespace {
+#ifdef _WIN32
+    std::string pathSep = "\\";
+#else
+    std::string pathSep = "/";
+#endif
+}
+
+std::string createAndGetAppDir(std::string dir) {
+    std::string home;
+#ifdef _WIN32
+    if (dir.empty()) {
+        if (!std::getenv("HOMEDRIVE") || !std::getenv("HOMEPATH"))
+            return "";
+        home = std::string(std::getenv("HOMEDRIVE")) + std::getenv("HOMEPATH");
+        dir = home + "\\.bredbandskollen";
+    }
+    _mkdir(dir.c_str());
+#else
+    if (dir.empty()) {
+        if (!std::getenv("HOME"))
+            return "";
+        home = std::getenv("HOME");
+        dir = home + "/.bredbandskollen";
+    }
+    int status = mkdir(dir.c_str(), 0755);
+    if (status && errno != EEXIST) {
+        return "";
+    }
+#endif
+
+#ifdef IS_SANDBOXED
+    if (!home.empty())
+        chdir(home.c_str());
+#endif
+
+    return dir + pathSep;
+}
+
+enum class CliMode { NONE, LIVE, TEST, LOCAL,
+#if defined(RUN_SERVER)
+                     SERVER,
+#endif
+                     IN_ERROR } ;
+
+bool parseArgs(int argc, char *argv[],
+               TaskConfig &client_cfg, TaskConfig &agent_cfg) {
+
+    CliMode mode = CliMode::NONE;
+
+    client_cfg.set("port", "80");
+    client_cfg.set("mtype", "ipv4");
+    client_cfg.set("listen_addr", "127.0.0.1");
+
+    agent_cfg.add("Measure.Webserver", "frontend.bredbandskollen.se");
+    agent_cfg.add("Measure.SettingsUrl", "/api/servers");
+    agent_cfg.add("Measure.ContentsUrl", "/api/content");
+    agent_cfg.add("Measure.MeasurementsUrl", "/api/measurements");
+
+    for (int i=1; i<argc; ++i) {
+        std::string arg(argv[i]);
+        if (arg == "--v6") {
+            client_cfg.set("mtype", "ipv6");
+            client_cfg.set("Measure.IpType", "override");
+        } else if (arg == "--v4") {
+            client_cfg.set("mtype", "ipv4");
+            client_cfg.set("Measure.IpType", "override");
+        } else if (arg == "--test") {
+            mode = (mode == CliMode::NONE) ? CliMode::TEST : CliMode::IN_ERROR;
+        } else if (arg == "--live") {
+            mode = (mode == CliMode::NONE) ? CliMode::LIVE : CliMode::IN_ERROR;
+        } else if (arg == "--version") {
+            std::cout << measurement::appName << ' '
+                      << measurement::appVersion << '\n';
+            return false;
+        } else if (arg == "--quiet") {
+            client_cfg.set("quiet", "1");
+        } else if (arg == "--csv") {
+            client_cfg.set("quiet", "1");
+            client_cfg.set("limiter", ",");
+        } else if (arg == "--local") {
+            mode = (mode == CliMode::NONE) ? CliMode::LOCAL : CliMode::IN_ERROR;
+#if defined(RUN_SERVER)
+        } else if (arg == "--run-server") {
+            mode = (mode == CliMode::NONE) ? CliMode::SERVER : CliMode::IN_ERROR;
+#endif
+        } else if (arg.substr(0, 11) == "--duration=") {
+            agent_cfg.set("Measure.LoadDuration",  argv[i]+11);
+            client_cfg.set("Measure.LoadDuration", "override");
+        } else if (arg.substr(0, 13) == "--speedlimit=") {
+            agent_cfg.set("Measure.SpeedLimit", argv[i]+13);
+            client_cfg.set("Measure.SpeedLimit", "override");
+        } else if (arg.substr(0, 6) == "--out=")
+            client_cfg.set("out", argv[i]+6);
+        else if (arg.substr(0, 6) == "--dir=")
+            client_cfg.set("app_dir", (argv[i]+6) + pathSep);
+        else if (arg.substr(0, 6) == "--log=")
+            client_cfg.set("logfile", argv[i]+6);
+        else if (arg.substr(0, 11) == "--local-ip=")
+            agent_cfg.set("Measure.LocalAddress", argv[i]+11);
+        else if (arg.substr(0, 9) == "--server=")
+            client_cfg.set("server", argv[i]+9);
+        else if (arg.substr(0, 7) == "--port=")
+            client_cfg.set("port", argv[i]+7);
+        else if (arg.substr(0, 12) == "--configure=")
+            client_cfg.add("configure", argv[i]+12);
+        else if (arg.substr(0, 9) == "--listen=")
+            client_cfg.set("listen", argv[i]+9);
+        else if (arg.substr(0, 14) == "--listen-addr=")
+            client_cfg.set("listen_addr", argv[i]+14);
+        else if (arg.substr(0, 12) == "--listen-pw=") {
+            client_cfg.set("listen_pw", argv[i]+12);
+#ifdef USE_GNUTLS
+        } else if (arg == "--ssl") {
+            agent_cfg.set("Measure.TLS", "1");
+            client_cfg.set("ssl", "1");
+            if (client_cfg.value("port") == "80")
+                client_cfg.set("port", "443");
+#endif
+        } else if (arg.substr(0, 9) == "--fakeip=")
+            agent_cfg.set("Client.fakeip", argv[i]+9);
+        else if (arg == "--check-servers")
+            client_cfg.set("pingsweep", "1");
+        else if (arg.substr(0, 14) == "--measurements")
+            client_cfg.set("list_measurements",
+                (arg.size() > 15 && arg[14] == '=') ? argv[i]+15 : "10");
+        else if (arg.substr(0, 10) == "--from-id=") {
+            client_cfg.set("list_from", argv[i]+10);
+            if (client_cfg.value("list_measurements").empty())
+                client_cfg.set("list_measurements", "10");
+        } else if (arg == "--browser") {
+            client_cfg.set("browser", "1");
+            if (client_cfg.value("listen").empty())
+                client_cfg.set("listen", "0"); // Use any avaliable port
+        } else if (arg.substr(0, 13) == "--proxy-host=")
+            agent_cfg.set("Measure.ProxyServerUrl", argv[i]+13);
+        else if (arg.substr(0, 13) == "--proxy-port=")
+            agent_cfg.set("Measure.ProxyServerPort", argv[i]+13);
+        else {
+            int status = 0;
+            if (arg != "--help") {
+                status = 1;
+                std::cerr << argv[0] << ": invalid argument -- " << arg << std::endl;
+            }
+            std::ostream &fh = status ? std::cerr : std::cout;
+            fh << "Usage: " << argv[0] << " [OPTION]...\n\nOptions:\n\n"
+                  "  --help              Show this help text\n"
+                  "  --version           Print version number and exit\n"
+               << "\nNetwork related options:\n"
+#ifndef BBK_WEBVIEW
+               << "  --v6                Prefer IPv6 (default is IPv4)\n"
+#endif
+#ifdef __linux__
+#else
+               << "  --local-ip=IP       Measure using existing local ip address IP\n"
+               << "                      Note: this will not work on all platforms\n"
+#endif
+               << "  --proxy-host=HOST   Use HTTP proxy server HOST\n"
+               << "  --proxy-port=PORT   Use port PORT on proxy server (default 80)\n"
+               << "\nMeasurement configuration:\n"
+#ifndef BBK_WEBVIEW
+               << "  --server=HOST       Use HOST as measurement server\n"
+               << "  --port=N            Port number for measurement server, default 80\n"
+#endif
+#ifdef USE_GNUTLS
+               << "  --ssl               Measure using transport layer security (default port 443)\n"
+#endif
+               << "  --duration=N        Measure upload/download for N seconds (2-10, default 10)\n"
+               << "  --speedlimit=N      Keep upload/download speed below N mbps on average\n"
+               << "\nMeasurement type:\n"
+               << "  --live              Measure using Bredbandskollen's live servers (default)\n"
+               << "  --test              Measure using Bredbandskollen's development servers\n"
+#ifndef BBK_WEBVIEW
+               << "  --local             Don't fetch configuration (server list) from bredbandskollen.se,\n"
+               << "                      communicate only with server given by the --server option.\n"
+#endif
+#if defined(RUN_SERVER)
+               << "  --run-server        Run as a measurement server (requires option --listen=PORT)\n"
+#endif
+               << "\nLogging:\n"
+               << "  --log=FILENAME      Write debug log to FILENAME\n"
+               << "                      (log to stderr if FILENAME is -)\n"
+#ifndef BBK_WEBVIEW
+               << "\nFinding measurement servers:\n"
+               << "  --check-servers     Find closest measurement server\n"
+               << "\nList previous measurements:\n"
+               << "  --measurements      List 10 last measurements\n"
+               << "  --measurements=N    List N last measurements\n"
+               << "                      If --quiet, output will be JSON. Otherwise\n"
+               << "                      output will be lines with tab separated fields.\n"
+               << "  --from-id=N         List only measurements before ID N\n"
+               << "\nBrowser interface:\n"
+               << "  --browser           Use a web browser as interface\n"
+               << "  --listen=PORT       Use web browser as interface;\n"
+               << "                      the browser must connect to the given PORT\n"
+               << "  --listen-addr=IP    When listening, bind socket to ip address IP\n"
+               << "                      (default is 127.0.0.1) to use a web browser on\n"
+               << "                      a remote host as interface\n"
+               << "                      Note: this may not work due to e.g. firewalls.\n"
+               << "                      Don't use it unless you know what you are doing.\n"
+               << "  --listen-pw=PW      Use PW as a one-time password when connecting from browser\n"
+               << "                      Note: DO NOT reuse a sensitive password here!\n"
+               << "                      It is better to omit this option because by default\n"
+               << "                      a secure one-time password will be generated.\n"
+               << "\nCommand line interface:\n"
+               << "  --quiet             Write a single line of output\n"
+               << "  --csv               Write a single line of output, comma separated\n"
+               << "  --out=FILENAME      Append output to FILENAME instead of stdout\n"
+#endif
+               << std::endl;
+            return false;
+        }
+    }
+
+    client_cfg.set("app_dir", createAndGetAppDir(client_cfg.value("app_dir")));
+
+    if (client_cfg.value("local") == "1" && client_cfg.value("server").empty()) {
+        std::cerr << "missing --server option" << std::endl;
+        return false;
+    }
+
+    std::vector<std::string> pdir = { "listen", "port" };
+    for (auto &str : pdir)
+        if (!client_cfg.value(str).empty()) {
+            auto port = client_cfg.value(str);
+            if (port.find_first_not_of("0123456789") != std::string::npos ||
+                port.size() > 5 || std::stod(port) > 65535) {
+                std::cerr << "invalid port number" << std::endl;
+                return false;
+            }
+        }
+
+    switch (mode) {
+    case CliMode::NONE:
+    case CliMode::LIVE:
+        agent_cfg.set("Measure.Webserver", "frontend.bredbandskollen.se");
+        break;
+    case CliMode::TEST:
+        agent_cfg.set("Measure.Webserver", "frontend-beta.bredbandskollen.se");
+        break;
+    case CliMode::LOCAL:
+        client_cfg.set("local", "1");
+        agent_cfg.set("Measure.Webserver", "none");
+        break;
+#if defined(RUN_SERVER)
+    case CliMode::SERVER:
+        client_cfg.set("local", "1");
+        client_cfg.set("run_server", "1");
+        if (client_cfg.value("listen").empty()) {
+            std::cerr << "option --listen is required with --run-server"
+                      << std::endl;
+            return false;
+        }
+        break;
+#endif
+    case CliMode::IN_ERROR:
+        std::cerr << "can have only one of options --live, --test,";
+#if defined(RUN_SERVER)
+        std::cerr << " --run-server,";
+#endif
+        std::cerr << " and --local";
+        return false;
+    }
+
+    if (!client_cfg.value("listen").empty() &&
+        client_cfg.value("listen_pw").empty()) {
+        client_cfg.add("listen_pw", Logger::createHashKey(12));
+    }
+    client_cfg.add("url", "http://" + agent_cfg.value("Measure.Webserver") +
+                   "/standalone/dev/index.php");
+
+    if (client_cfg.value("logfile").empty()) {
+#if defined(RUN_SERVER)
+        if (mode == CliMode::SERVER)
+            client_cfg.add("logfile", client_cfg.value("app_dir") + "server_log");
+        else
+#endif
+            client_cfg.add("logfile", client_cfg.value("app_dir") + "last_log");
+    }
+    client_cfg.set("config_file", client_cfg.value("app_dir") + "config");
+    agent_cfg.set("options_file", client_cfg.value("app_dir") + "ConfigOptions.txt");
+
+    // Default to ipv6 if user wants to use a local ipv6 address
+    if (agent_cfg.value("Measure.LocalAddress").find(':') !=
+        std::string::npos) {
+        client_cfg.set("mtype", "ipv6");
+        client_cfg.set("Measure.IpType", "override");
+    }
+
+    agent_cfg.add("Measure.AutoSaveReport",
+                  client_cfg.value("listen").empty() ? "false" : "true");
+
+    agent_cfg.add("Measure.IpType", client_cfg.value("mtype"));
+
+    agent_cfg.add("Client.appname", measurement::appName);
+    agent_cfg.add("Client.appver", measurement::appVersion);
+    agent_cfg.add("Client.machine", measurement::hw_info);
+    agent_cfg.add("Client.system", measurement::os_version);
+    agent_cfg.add("Client.language", "en");
+
+    return true;
+}
diff --git a/src/cli/utils.h b/src/cli/utils.h
new file mode 100644
index 0000000..4f88339
--- /dev/null
+++ b/src/cli/utils.h
@@ -0,0 +1,11 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+class TaskConfig;
+
+std::string createAndGetAppDir(std::string dir = "");
+
+bool parseArgs(int argc, char *argv[],
+               TaskConfig &client_cfg, TaskConfig &agent_cfg);
diff --git a/src/examples/.gitignore b/src/examples/.gitignore
new file mode 100644
index 0000000..1f2a364
--- /dev/null
+++ b/src/examples/.gitignore
@@ -0,0 +1,10 @@
+boss
+cliclient
+client
+echoclient
+echoserver
+threadserver
+timers
+webserver
+winner
+winnerclient
diff --git a/src/examples/001_single_request/Makefile b/src/examples/001_single_request/Makefile
new file mode 100644
index 0000000..6aded5c
--- /dev/null
+++ b/src/examples/001_single_request/Makefile
@@ -0,0 +1,25 @@
+# Name of the executable program to be built:
+TARGET = client
+
+# Relative path to where the framework directory is located:
+DIRLEVEL = ../..
+
+# Possible LOGLEVEL values: dbg, info, warn, err, none
+LOGLEVEL = dbg
+
+# Set to 1 to link with GnuTLS, i.e. to enable SSL support.
+GNUTLS = 0
+
+# Set to 1 to be able to run tasks in different threads.
+THREADS = 0
+
+# All C++ source files used by the target program
+SOURCES = main.cpp
+
+# To be able to debug the target program
+CXXFLAGS += -g
+
+# Include the HTTP support files. It will also include the base framework,
+# i.e. $(DIRLEVEL)/framework/mk.inc
+# The below line should be the last one in the Makefile.
+include $(DIRLEVEL)/http/mk.inc
diff --git a/src/examples/001_single_request/main.cpp b/src/examples/001_single_request/main.cpp
new file mode 100644
index 0000000..12e80b7
--- /dev/null
+++ b/src/examples/001_single_request/main.cpp
@@ -0,0 +1,18 @@
+#include <http/singlerequest.h>
+#include <framework/eventloop.h>
+
+/* Example 001
+
+Fetch http://frontend.bredbandskollen.se/api/servers, then exit.
+Write debug log to stderr.
+
+*/
+
+int main(int , char *[]) {
+    Task *t = new SingleRequest("MyRequest",
+                                "frontend.bredbandskollen.se",
+                                "/api/servers");
+    EventLoop::runTask(t);
+    // Note: the object t will be deleted by the event loop.
+    return 0;
+}
diff --git a/src/examples/002_simple_task/Makefile b/src/examples/002_simple_task/Makefile
new file mode 100644
index 0000000..af48963
--- /dev/null
+++ b/src/examples/002_simple_task/Makefile
@@ -0,0 +1,25 @@
+# Name of the executable program to be built:
+TARGET = client
+
+# Relative path to where the framework directory is located:
+DIRLEVEL = ../..
+
+# Possible LOGLEVEL values: dbg, info, warn, err, none
+LOGLEVEL = dbg
+
+# Set to 1 to link with GnuTLS, i.e. to enable SSL support.
+GNUTLS = 0
+
+# All C++ source files used by the target program
+SOURCES = main.cpp
+
+# To be able to debug the target program
+CXXFLAGS += -g
+
+# Extra files to be removed by "make clean":
+CLEAN += log.txt
+
+# Include the HTTP support files. It will also include the base framework,
+# i.e. $(DIRLEVEL)/framework/mk.inc
+# The below line should be the last one in the Makefile.
+include $(DIRLEVEL)/http/mk.inc
diff --git a/src/examples/002_simple_task/main.cpp b/src/examples/002_simple_task/main.cpp
new file mode 100644
index 0000000..b281cab
--- /dev/null
+++ b/src/examples/002_simple_task/main.cpp
@@ -0,0 +1,77 @@
+#include <http/singlerequest.h>
+#include <framework/eventloop.h>
+
+/* Example 002
+
+Fetch http://frontend.bredbandskollen.se/api/servers.
+Write the result to stdout.
+Write debug log to log.txt.
+
+*/
+
+class MainTask : public Task {
+public:
+
+    // Each task object has a name (or "label"), which is used (for example)
+    // by the logger.
+    MainTask(const std::string &name) : Task(name) {
+        // Note: the constructor will be executed before the task has been added
+        // to the eventloop.
+        // DO NOT perform any actions that concern the eventloop here!
+        // Instead, most of the initialisation should be performed from within
+        // the start() method, which will be called by the eventloop when the
+        // execution of this task starts.
+    }
+
+    double start() override {
+        dbg_log() << "starting";
+
+        // If child tasks still exist when this task is done,
+        // we want them to be removed:
+        killChildTaskWhenFinished();
+
+        // The second parameter to addNewTask sets this task as
+        // parent of the new task.
+        addNewTask(new SingleRequest("MyRequest",
+                                     "frontend.bredbandskollen.se",
+                                     "/api/servers"), this);
+
+        // First timer is to be called after 10.0 seconds.
+        // If we return <= 0, no timer will be added.
+        return 10.0;
+    }
+
+    double timerEvent() override {
+        std::cerr << "Timeout after " << elapsed() << " seconds";
+
+        // Tell the eventloop that this task has given up:
+        setTimeout();
+
+        // Return number of seconds until this method should be
+        // called again, or <= 0 if you don't want it to be called again.
+        return 0;
+    }
+
+    // Will be called when a child task is finished:
+    void taskFinished(Task *task) override {
+        log() << task->label() << " finished, ok=" << task->finishedOK();
+
+        // Our only child task is a SingleRequest task, so the below cast will
+        // succeed. We need the cast to be able to call httpStatus().
+        if (SingleRequest *req = dynamic_cast<SingleRequest *>(task)) {
+            log() << "Status: " << req->httpStatus();
+            std::cout << "Result: " << req->result() << std::endl;
+            // Calling setResult tells the eventloop that this task is done.
+            setResult("OK");
+        }
+    }
+};
+
+int main(int , char *[]) {
+    std::ofstream log("log.txt");
+    // Note: the log file object must not be destroyed until either the
+    // eventloop is finished, or until setLogFile is called again.
+    Logger::setLogFile(log);
+    EventLoop::runTask(new MainTask("Main Task"));
+    return 0;
+}
diff --git a/src/examples/003_webserver/Makefile b/src/examples/003_webserver/Makefile
new file mode 100644
index 0000000..38af817
--- /dev/null
+++ b/src/examples/003_webserver/Makefile
@@ -0,0 +1,7 @@
+TARGET = webserver
+DIRLEVEL = ../..
+LOGLEVEL = info
+GNUTLS = 0
+SOURCES = main.cpp
+
+include $(DIRLEVEL)/http/mk.inc
diff --git a/src/examples/003_webserver/main.cpp b/src/examples/003_webserver/main.cpp
new file mode 100644
index 0000000..173a7b8
--- /dev/null
+++ b/src/examples/003_webserver/main.cpp
@@ -0,0 +1,55 @@
+#include <http/webservertask.h>
+#include <framework/eventloop.h>
+
+/* Example 003
+
+Start a webserver on port 8080. Write log to stderr.
+From a web browser, you can retrieve the URLs
+
+  http://127.0.0.1:8080/getTime
+  http://127.0.0.1:8080/getStats
+  http://127.0.0.1:8080/shutdown
+
+*/
+
+class WebServer : public WebServerTask {
+public:
+    WebServer(const std::string &cfg) :
+        WebServerTask("WebServer", cfg) {
+    }
+
+    HttpState newGetRequest(HttpServerConnection *,
+                            const std::string &uri) override;
+private:
+    unsigned long tot_no_requests = 0;
+};
+
+HttpState WebServer::newGetRequest(HttpServerConnection *conn,
+                                   const std::string &uri) {
+    ++tot_no_requests;
+    log() << "URI: " << uri << " #" << tot_no_requests;
+    if (uri == "/getTime")
+        // Send current time
+        conn->sendHttpResponse(headers("200 OK"), "text/plain", dateString());
+    else if (uri == "/getStats")
+        // Send number of requests since server was started.
+        conn->sendHttpResponse(headers("200 OK"), "text/plain",
+                               std::to_string(tot_no_requests));
+    else if (uri == "/shutdown") {
+        conn->sendHttpResponse(headers("200 OK"), "text/plain",
+                               "server shutdown");
+        // This will terminate the task, i.e. shut the server down. Normally, of
+        // course, clients wouldn't be able to do this on a production server.
+        setResult("");
+    } else
+        conn->sendHttpResponse(headers("404 Not Found"), "text/plain",
+                               "unknown service");
+    return HttpState::WAITING_FOR_REQUEST;
+}
+
+int main(int , char *[]) {
+    // Listen on port 8080. To listen on the standard port 80, we'd have to
+    // run as a privileged user.
+    EventLoop::runTask(new WebServer("listen 8080"));
+    return 0;
+}
diff --git a/src/examples/004_timers/Makefile b/src/examples/004_timers/Makefile
new file mode 100644
index 0000000..2451371
--- /dev/null
+++ b/src/examples/004_timers/Makefile
@@ -0,0 +1,22 @@
+# Name of the executable program to be built:
+TARGET = timers
+
+# Relative path to where the framework directory is located:
+DIRLEVEL = ../..
+
+# Possible LOGLEVEL values: dbg, info, warn, err, none
+LOGLEVEL = dbg
+
+# Set to 1 to link with GnuTLS, i.e. to enable SSL support.
+GNUTLS = 0
+
+# All C++ source files used by the target program
+SOURCES = main.cpp
+
+# To be able to debug the target program
+CXXFLAGS += -g
+
+# Include the HTTP support files. It will also include the base framework,
+# i.e. $(DIRLEVEL)/framework/mk.inc
+# The below line should be the last one in the Makefile.
+include $(DIRLEVEL)/http/mk.inc
diff --git a/src/examples/004_timers/main.cpp b/src/examples/004_timers/main.cpp
new file mode 100644
index 0000000..428aed1
--- /dev/null
+++ b/src/examples/004_timers/main.cpp
@@ -0,0 +1,45 @@
+#include <framework/task.h>
+#include <framework/eventloop.h>
+
+/* Example 004
+
+Simple demonstration of tasks and timers.
+Write log to stderr.
+
+*/
+
+class PointlessTask : public Task {
+public:
+
+    PointlessTask(const std::string &name,
+                  double tick_length, unsigned int no_ticks) :
+        Task(name),
+        tick_duration(tick_length),
+        ticks(no_ticks), curr_tick(0) {
+    }
+
+    double start() override {
+        dbg_log() << "starting, " << ticks << " ticks";
+        return tick_duration;
+    }
+
+    double timerEvent() override {
+        log() << "timerEvent " << ++curr_tick << " of " << ticks;
+        if (curr_tick < ticks)
+            return tick_duration;
+        setResult("Done after " + std::to_string(elapsed()) + " seconds");
+        return 0.0;
+    }
+private:
+    double tick_duration;
+    unsigned int ticks, curr_tick;
+};
+
+int main(int , char *[]) {
+    EventLoop loop;
+    loop.addTask(new PointlessTask("Pointless 1", 1.0, 3));
+    loop.addTask(new PointlessTask("Pointless 2", 0.7, 5));
+    loop.addTask(new PointlessTask("Pointless 3", 0.5, 7));
+    loop.runUntilComplete();
+    return 0;
+}
diff --git a/src/examples/005_websocket_server/Makefile b/src/examples/005_websocket_server/Makefile
new file mode 100644
index 0000000..2722edd
--- /dev/null
+++ b/src/examples/005_websocket_server/Makefile
@@ -0,0 +1,7 @@
+TARGET = winner
+DIRLEVEL = ../..
+LOGLEVEL = info
+GNUTLS = 0
+SOURCES = main.cpp winner.cpp
+
+include $(DIRLEVEL)/http/mk.inc
diff --git a/src/examples/005_websocket_server/main.cpp b/src/examples/005_websocket_server/main.cpp
new file mode 100644
index 0000000..fb5242e
--- /dev/null
+++ b/src/examples/005_websocket_server/main.cpp
@@ -0,0 +1,36 @@
+#include <framework/eventloop.h>
+#include "winner.h"
+
+/* Example 005
+
+Start a webserver on port 8080. Write log to stderr.
+The client can open a websocket connection on
+
+    ws://127.0.0.1:8080/winner
+
+The client can then send text messages of the format
+
+    name score
+
+and the server will remember the names and scores.
+If the client sends the text message "winner", the
+server will respond with the name with the highest score.
+
+E.g. the client sends the five messages
+
+    Bill 12
+    Steve 19
+    Linus 33
+    Ken 27
+    winner
+
+and the server responds
+
+    Linus
+
+*/
+
+int main(int , char *[]) {
+    EventLoop::runTask(new Winner("listen 8080"));
+    return 0;
+}
diff --git a/src/examples/005_websocket_server/winner.cpp b/src/examples/005_websocket_server/winner.cpp
new file mode 100644
index 0000000..106c601
--- /dev/null
+++ b/src/examples/005_websocket_server/winner.cpp
@@ -0,0 +1,43 @@
+#include "winner.h"
+
+bool Winner::newWsRequest(HttpServerConnection *,
+                  const std::string &uri) {
+    log() << "websocket request to " << uri;
+
+    if (uri == "/winner")
+        return true;
+    else
+        return false;
+}
+
+bool Winner::wsTextMessage(HttpConnection *conn,
+                           const std::string &msg) {
+    log() << "Got: " << msg;
+    auto p = leader.find(conn);
+    if (msg == "winner") {
+        if (p != leader.end()) {
+            log() << "Sending " << p->second.name;
+            conn->sendWsMessage(p->second.name);
+        }
+        return true;
+    }
+    auto pos = msg.find_last_of(" ");
+    if (pos == std::string::npos || !pos || pos+1 == msg.size())
+        return true;
+    if (msg.find_last_not_of("0123456789") != pos)
+        return true;
+    auto score = std::stoul(msg.substr(pos+1));
+    if (p == leader.end()) {
+        leader[conn] = { msg.substr(0, pos), score };
+    } else if (score > p->second.score) {
+        p->second.score = score;
+        p->second.name = msg.substr(0, pos);
+    } else if (score == p->second.score) {
+        (p->second.name += ", ") += msg.substr(0, pos);
+    }
+    return true;
+}
+
+void Winner::connRemoved(SocketConnection *conn) {
+    leader.erase(dynamic_cast<HttpConnection *>(conn));
+}
diff --git a/src/examples/005_websocket_server/winner.h b/src/examples/005_websocket_server/winner.h
new file mode 100644
index 0000000..8aedb62
--- /dev/null
+++ b/src/examples/005_websocket_server/winner.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <http/webservertask.h>
+#include <string>
+#include <map>
+
+struct Info {
+    std::string name;
+    unsigned long score;
+};
+
+class Winner : public WebServerTask {
+public:
+    Winner(const std::string &cfg) :
+        WebServerTask("Winner", cfg) {
+    }
+
+    // Client want's to open a websocket connection on uri.
+    // Return true to accept, false to close the connection.
+    bool newWsRequest(HttpServerConnection *conn,
+                      const std::string &uri) override;
+
+    // When a text message is sent from the client, we'll be notified here:
+    bool wsTextMessage(HttpConnection *conn,
+                       const std::string &msg) override;
+
+    void connRemoved(SocketConnection *conn) override;
+ private:
+    std::map<HttpConnection *, Info> leader;
+};
diff --git a/src/examples/006_websocket_client/Makefile b/src/examples/006_websocket_client/Makefile
new file mode 100644
index 0000000..30da498
--- /dev/null
+++ b/src/examples/006_websocket_client/Makefile
@@ -0,0 +1,7 @@
+TARGET = winnerclient
+DIRLEVEL = ../..
+LOGLEVEL = info
+GNUTLS = 0
+SOURCES = main.cpp winnerclient.cpp
+
+include $(DIRLEVEL)/http/mk.inc
diff --git a/src/examples/006_websocket_client/main.cpp b/src/examples/006_websocket_client/main.cpp
new file mode 100644
index 0000000..c358e1c
--- /dev/null
+++ b/src/examples/006_websocket_client/main.cpp
@@ -0,0 +1,13 @@
+#include <framework/eventloop.h>
+#include "winnerclient.h"
+
+/* Example 006
+
+A websocket client talking to the server of example 005.
+
+*/
+
+int main(int , char *[]) {
+    EventLoop::runTask(new WinnerClient("127.0.0.1", 8080, "/winner"));
+    return 0;
+}
diff --git a/src/examples/006_websocket_client/main2.cpp b/src/examples/006_websocket_client/main2.cpp
new file mode 100644
index 0000000..49f9846
--- /dev/null
+++ b/src/examples/006_websocket_client/main2.cpp
@@ -0,0 +1,37 @@
+#include <framework/eventloop.h>
+#include "winnerclient.h"
+
+/* Example 006
+
+A websocket client talking to the server of example 005.
+This is an alternative version of the main function, where you can start the
+client with the command line parameters
+
+    --logfile=
+    --host=
+    --port=
+    --url=
+
+To use this version, update the Makefile to use main2.cpp instead of main.cpp.
+
+*/
+
+int main(int argc, char *argv[]) {
+    TaskConfig cfg;
+
+    cfg.set("host", "127.0.0.1");
+    cfg.set("port", "8080");
+    cfg.set("url", "/winner");
+    cfg.parseArgs(argc, argv);
+
+    // Use value of parameter --logfile as filename to save the log if it exists
+    // and isn't equal to "-".
+    std::ofstream log;
+    cfg.openlog(log);
+
+    auto task = new WinnerClient(cfg.value("host"),
+                                 std::stoi(cfg.value("port")),
+                                 cfg.value("url"));
+    EventLoop::runTask(task);
+    return 0;
+}
diff --git a/src/examples/006_websocket_client/winnerclient.cpp b/src/examples/006_websocket_client/winnerclient.cpp
new file mode 100644
index 0000000..9edac16
--- /dev/null
+++ b/src/examples/006_websocket_client/winnerclient.cpp
@@ -0,0 +1,49 @@
+#include "winnerclient.h"
+
+WinnerClient::WinnerClient(const std::string &host, uint16_t port,
+                           const std::string &url) :
+    HttpClientTask("WinnerClient", HttpHost(host, port)),
+    _url(url) {
+}
+
+double WinnerClient::start() {
+    log() << "starting";
+    if (!createNewConnection()) {
+        log() << "Cannot connect to server\n";
+        setResult("error");
+    }
+    return 10;
+}
+
+void WinnerClient::connRemoved(SocketConnection *) {
+    if (!terminated()) {
+        log() << "Lost connection";
+        setResult("error");
+    }
+}
+
+void WinnerClient::newRequest(HttpClientConnection *conn) {
+    conn->ws_get(_url);
+}
+
+bool WinnerClient::requestComplete(HttpClientConnection *) {
+    // Server ignored websocket upgrade request
+    return false;
+}
+
+bool WinnerClient::websocketUpgrade(HttpClientConnection *conn) {
+    log() << "connected";
+    conn->sendWsMessage("Bill 12");
+    conn->sendWsMessage("Steve 19");
+    conn->sendWsMessage("Linus 33");
+    conn->sendWsMessage("Ken 27");
+    conn->sendWsMessage("winner");
+    return true;
+}
+
+bool WinnerClient::wsTextMessage(HttpConnection *,
+                                 const std::string &msg) {
+    log() << "Got " << msg;
+    setResult(msg);
+    return false;
+}
diff --git a/src/examples/006_websocket_client/winnerclient.h b/src/examples/006_websocket_client/winnerclient.h
new file mode 100644
index 0000000..44b91db
--- /dev/null
+++ b/src/examples/006_websocket_client/winnerclient.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <http/httpclienttask.h>
+
+class WinnerClient : public HttpClientTask {
+public:
+    WinnerClient(const std::string &host, uint16_t port,
+                 const std::string &url);
+    double start() override;
+    void connRemoved(SocketConnection *conn) override;
+    void newRequest(HttpClientConnection *conn) override;
+    bool requestComplete(HttpClientConnection *) override;
+    bool websocketUpgrade(HttpClientConnection *) override;
+    bool wsTextMessage(HttpConnection *conn,
+                       const std::string &msg) override;
+private:
+    std::string _url;
+};
diff --git a/src/examples/007_events/Makefile b/src/examples/007_events/Makefile
new file mode 100644
index 0000000..c1ac1df
--- /dev/null
+++ b/src/examples/007_events/Makefile
@@ -0,0 +1,10 @@
+TARGET = client
+DIRLEVEL = ../..
+LOGLEVEL = dbg
+GNUTLS = 0
+
+SOURCES = main.cpp
+
+CXXFLAGS += -g
+
+include $(DIRLEVEL)/http/mk.inc
diff --git a/src/examples/007_events/main.cpp b/src/examples/007_events/main.cpp
new file mode 100644
index 0000000..83ef792
--- /dev/null
+++ b/src/examples/007_events/main.cpp
@@ -0,0 +1,78 @@
+#include <framework/task.h>
+#include <http/singlerequest.h>
+#include <framework/eventloop.h>
+
+/* Example 007
+
+Simple demonstration of sending events (direct messages) between tasks.
+The SenderTask will send a message to ReceiverTask each second.
+The ReceiverTask will terminate after the third message.
+The SenderTask will terminate after the ReceiverTask has terminated.
+
+*/
+
+class ReceiverTask;
+
+class SenderTask : public Task {
+public:
+    SenderTask(ReceiverTask *task) : Task("SenderTask"), peer(task) {
+    }
+    double start() override;
+    double timerEvent() override;
+    void taskFinished(Task *task) override;
+
+private:
+    ReceiverTask *peer;
+};
+
+class ReceiverTask : public Task {
+public:
+    ReceiverTask() : Task("ReceiverTask") {
+    }
+
+    void handleExecution(Task *, const std::string &msg) override;
+private:
+    unsigned int msgCount = 0;
+};
+
+void ReceiverTask::handleExecution(Task *, const std::string &msg) {
+    log() << "Event: " << msg;
+    if (++msgCount == 3)
+        setResult("Got Event");
+}
+
+double SenderTask::start() {
+    // We have to register an "interest" in peer by calling the startObserving
+    // method, otherwise the messages we try to send to it will be ignored.
+    // Also, by doing this we will be notified (through taskFinished) if
+    // the peer task dies; that is important since we must not keep the pointer
+    // to the peer after it has been deleted.
+    if (!startObserving(peer)) {
+        log() << "Peer task does not exist.";
+        setResult("Fail");
+        return 0.0;
+    }
+    return 0.1;
+}
+
+double SenderTask::timerEvent() {
+    executeHandler(peer, "Hi there!");
+    return 1.0;
+}
+
+void SenderTask::taskFinished(Task *task) {
+    if (task == peer) {
+        peer = nullptr;
+        log() << "Peer task dead, will exit.";
+        setResult("Done.");
+    }
+}
+
+int main(int , char *[]) {
+    EventLoop eventloop("EventLoop");
+    ReceiverTask *it = new ReceiverTask();
+    eventloop.addTask(it);
+    eventloop.addTask(new SenderTask(it));
+    eventloop.runUntilComplete();
+    return 0;
+}
diff --git a/src/examples/008_workers/Makefile b/src/examples/008_workers/Makefile
new file mode 100644
index 0000000..a2f8e7d
--- /dev/null
+++ b/src/examples/008_workers/Makefile
@@ -0,0 +1,11 @@
+TARGET = boss
+DIRLEVEL = ../..
+LOGLEVEL = dbg
+GNUTLS = 0
+
+SOURCES = main.cpp
+
+CLEAN += w0.log w1.log w2.log
+CXXFLAGS += -g
+
+include $(DIRLEVEL)/framework/mk.inc
diff --git a/src/examples/008_workers/main.cpp b/src/examples/008_workers/main.cpp
new file mode 100644
index 0000000..04f65b9
--- /dev/null
+++ b/src/examples/008_workers/main.cpp
@@ -0,0 +1,103 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <fstream>
+
+#include <framework/task.h>
+#include <framework/socketreceiver.h>
+
+/* Example 008
+
+Demonstration of a task that creates workers (subprocesses).
+The Boss task creates three subprocesses, each running a Worker task.
+Each Worker will do some processing and then exit.
+The Boss will exit when all worker processes are done.
+
+This example does not work on Windows.
+
+*/
+
+
+class Worker : public Task {
+public:
+
+    Worker(const std::string label) : Task(label) {
+    }
+
+    ~Worker() override {
+        log() << "Goodbye from " << label();
+    }
+
+    double start() override;
+
+private:
+};
+
+double Worker::start() {
+    log() << "Worker PID " << getpid() << " started.";
+    srand(static_cast<unsigned int>(getpid()));
+    unsigned long count = 0;
+    while (true) {
+        int n = rand();
+        ++count;
+        if (n % 10000000 == 3333333) {
+            setResult(std::to_string(count) + " tries, result " +
+                      std::to_string(n));
+            break;
+        }
+    }
+    return 0.0;
+}
+
+class Boss : public Task {
+public:
+
+    Boss(unsigned int no_workers) :
+        Task("Boss"),
+        tot_no_workers(no_workers) {
+    }
+
+    ~Boss() override {
+    }
+
+    // After creating a child process, the eventloop will call our
+    // createWorkerTask method to get a task to run in the new process.
+    Task *createWorkerTask(unsigned int wno) override {
+        std::string name = "w" + std::to_string(wno);
+        log() << "Will create worker " << name;
+        return new Worker(name);
+    }
+
+    double start() override;
+
+    void processFinished(int pid, int wstatus) override {
+        log() << "OK, end of " << pid << " status " << wstatus;
+        if (++wdone == tot_no_workers)
+            setResult("all done");
+    }
+private:
+    const unsigned int tot_no_workers;
+    unsigned int wdone = 0;
+};
+
+double Boss::start() {
+    // Messages and sockets can be passed between parent and worker processes
+    // through "channels". We don't use channels in this example.
+
+    // The createWorker call instructs the eventloop to create a child process
+    // and run a new eventloop in that process. Our createWorkerTask method
+    // will be called in the child process to provide a task for the eventloop
+    // running in the child process.
+    // First parameter to createWorker is a file name for the worker's log.
+    // The second parameter is the number of channels between parent and worker.
+    for (unsigned int n=0; n < tot_no_workers; ++n)
+        createWorker("w" + std::to_string(n) + ".log", 0);
+
+    return 0;
+}
+
+int main(int , char *[]) {
+    EventLoop eventloop("EventLoop");
+    eventloop.addTask(new Boss(3));
+    eventloop.runUntilComplete();
+    return 0;
+}
diff --git a/src/examples/009_threads/Makefile b/src/examples/009_threads/Makefile
new file mode 100644
index 0000000..838be70
--- /dev/null
+++ b/src/examples/009_threads/Makefile
@@ -0,0 +1,12 @@
+TARGET = threadserver
+DIRLEVEL = ../..
+LOGLEVEL = dbg
+THREADS = 1
+GNUTLS = 0
+
+SOURCES = main.cpp
+
+CLEAN += main.log M8000.log M8080.log
+CXXFLAGS += -g
+
+include $(DIRLEVEL)/http/mk.inc
diff --git a/src/examples/009_threads/main.cpp b/src/examples/009_threads/main.cpp
new file mode 100644
index 0000000..1802b91
--- /dev/null
+++ b/src/examples/009_threads/main.cpp
@@ -0,0 +1,63 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <fstream>
+#include <algorithm>
+
+#include <http/webservertask.h>
+#include <framework/eventloop.h>
+
+/* Example 009
+
+Create two threads, each running a WebServer in its own eventloop.
+One will listen on port 8000, the other on 8080. To test, open URLs
+
+http://127.0.0.1:8000/getTime
+http://127.0.0.1:8080/getTime
+http://127.0.0.1:8000/getStats
+http://127.0.0.1:8080/getStats
+http://127.0.0.1:8000/stop
+http://127.0.0.1:8080/stop
+
+in a web browser. The /stop URL will tell each server to exit. The test program
+will exit when both servers have been stopped.
+
+*/
+
+class WebServer : public WebServerTask {
+public:
+    WebServer(const std::string &cfg, const std::string &name) :
+    WebServerTask(name, cfg) {
+    }
+
+    HttpState newGetRequest(HttpServerConnection *,
+                            const std::string &uri) override;
+ private:
+    unsigned long tot_no_requests = 0;
+};
+
+HttpState WebServer::newGetRequest(HttpServerConnection *conn,
+                                   const std::string &uri) {
+    ++tot_no_requests;
+    log() << "URI: " << uri << " #" << tot_no_requests;
+    if (uri == "/getTime")
+        conn->sendHttpResponse(headers("200 OK"), "text/plain", dateString());
+    else if (uri == "/getStats")
+        conn->sendHttpResponse(headers("200 OK"), "text/plain",
+                               std::to_string(tot_no_requests));
+    else if (uri == "/stop")
+        setResult("DONE");
+    else
+        conn->sendHttpResponse(headers("404 Not Found"), "text/plain",
+                               "unknown service");
+    return HttpState::WAITING_FOR_REQUEST;
+}
+
+int main(int , char *[]) {
+    std::ofstream my_log("main.log"), log1("M8000.log"), log2("M8080.log");
+    Logger::setLogFile(my_log);
+    EventLoop loop;
+    loop.spawnThread(new WebServer("listen 8000", "W8000"), "M8000", &log1);
+    loop.spawnThread(new WebServer("listen 8080", "W8080"), "M8080", &log2);
+    loop.runUntilComplete();
+    return 0;
+}
diff --git a/src/examples/010_echoserver/Makefile b/src/examples/010_echoserver/Makefile
new file mode 100644
index 0000000..90d5e3c
--- /dev/null
+++ b/src/examples/010_echoserver/Makefile
@@ -0,0 +1,10 @@
+TARGET = echoserver
+DIRLEVEL = ../..
+LOGLEVEL = dbg
+GNUTLS = 0
+
+SOURCES = echoserverconnection.cpp \
+	echoservertask.cpp \
+	echoserver.cpp
+
+include $(DIRLEVEL)/framework/mk.inc
diff --git a/src/examples/010_echoserver/echoserver.cpp b/src/examples/010_echoserver/echoserver.cpp
new file mode 100644
index 0000000..c777c8d
--- /dev/null
+++ b/src/examples/010_echoserver/echoserver.cpp
@@ -0,0 +1,23 @@
+#include <framework/eventloop.h>
+#include "echoservertask.h"
+
+/* Example 010
+
+Implement a server for the echo network protocol, i.e.
+just echo all received data back to the client.
+Write log to stderr.
+
+The class EchoServerTask takes a port number as a parameter.
+Will accept clients on that port number.
+
+To test it, start the server and open one or more other terminals.
+In each of the terminals, run the command
+   telnet 127.0.0.1 1400
+and type a few lines of text. The server should echo back the text.
+
+*/
+
+int main(int , char *[]) {
+    EventLoop::runTask(new EchoServerTask(1400));
+    return 0;
+}
diff --git a/src/examples/010_echoserver/echoserverconnection.cpp b/src/examples/010_echoserver/echoserverconnection.cpp
new file mode 100644
index 0000000..6f3cf49
--- /dev/null
+++ b/src/examples/010_echoserver/echoserverconnection.cpp
@@ -0,0 +1,39 @@
+#include "echoserverconnection.h"
+
+EchoServerConnection::EchoServerConnection(Task *task, int fd,
+                                           const char *ip, uint16_t port) :
+    SocketConnection("Echo Client Handler", task, fd, ip, port) {
+}
+
+PollState EchoServerConnection::connected() {
+    log() << "New client " << id() << ", waiting for data";
+    return PollState::READ;
+}
+
+PollState EchoServerConnection::readData(char *buf, size_t len) {
+    // Just send the data back to the client
+    asyncSendData(buf, len);
+
+    if (len > 20) {
+        dbg_log() << "Client " << id() << " said "
+                  << std::string(buf, 20) << "... (" << len << " bytes)";
+    } else {
+        dbg_log() << "Client " << id() << " said " << std::string(buf, len);
+    }
+
+    if (asyncBufferSize() > 1000000) {
+        // The client does not read data as fast as we receive it.
+        // We have to stop reading until the outgoing buffer
+        // has shrunk to a manageable size.
+        dbg_log() << "Send buffer too large: " << asyncBufferSize();
+        return PollState::READ_BLOCKED;
+    }
+    return PollState::READ;
+}
+
+PollState EchoServerConnection::checkReadBlock() {
+    dbg_log() << "Check send buffer: " << asyncBufferSize();
+    if (asyncBufferSize() > 100000)
+        return PollState::READ_BLOCKED;
+    return PollState::READ;
+}
diff --git a/src/examples/010_echoserver/echoserverconnection.h b/src/examples/010_echoserver/echoserverconnection.h
new file mode 100644
index 0000000..df1ecff
--- /dev/null
+++ b/src/examples/010_echoserver/echoserverconnection.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <framework/socketconnection.h>
+
+class EchoServerConnection : public SocketConnection {
+public:
+    EchoServerConnection(Task *task, int fd, const char *ip, uint16_t port);
+
+    // Called by the eventloop when a client connection has been established.
+    PollState connected() override;
+
+    // Called by the eventloop when data has arrived from the client.
+    PollState readData(char *buf, size_t len) override;
+
+    // Called regularly by the eventloop if we have blocked incoming data,
+    // i.e. if we have returned PollState::READ_BLOCKED from the above method.
+    PollState checkReadBlock() override;
+private:
+};
diff --git a/src/examples/010_echoserver/echoservertask.cpp b/src/examples/010_echoserver/echoservertask.cpp
new file mode 100644
index 0000000..0a818ec
--- /dev/null
+++ b/src/examples/010_echoserver/echoservertask.cpp
@@ -0,0 +1,52 @@
+#include "echoservertask.h"
+#include "echoserverconnection.h"
+#include <framework/serversocket.h>
+
+EchoServerTask::EchoServerTask(uint16_t port) :
+    Task("Echo Server"),
+    port_number(port) {
+}
+
+double EchoServerTask::start() {
+    // The ServerSocket object is owned by the eventloop and will be deleted
+    // by the eventloop when it's no longer needed.
+    if (addServer(new ServerSocket("Echo Listen Socket", this, port_number)))
+        return 2.0;
+    setResult("Failed, cannot start server");
+    return 0;
+}
+
+double EchoServerTask::timerEvent() {
+    log() << "Current number of clients: " << no_clients;
+    return 5.0;
+}
+
+SocketConnection *EchoServerTask::newClient(int fd, const char *ip,
+                                            uint16_t port, ServerSocket *) {
+    // The EchoServerConnection object is owned by the eventloop and will be
+    // deleted by the eventloop when it's no longer needed.
+    // Just before deleting it, the eventloop will notify us by calling the
+    // below connRemoved method.
+    // We really shoudn't keep local copies of the (pointers to the) connection
+    // objects, but if we still do so, we _must_ implement connRemoved to delete
+    // our local copies so we don't use them after the objects are deleted.
+    return new EchoServerConnection(this, fd, ip, port);
+}
+
+void EchoServerTask::connAdded(SocketConnection *) {
+    log() << "added client";
+    ++no_clients;
+}
+
+void EchoServerTask::connRemoved(SocketConnection *) {
+    log() << "lost client";
+    --no_clients;
+}
+
+void EchoServerTask::serverAdded(ServerSocket *) {
+    log() << "listen socket added";
+}
+
+void EchoServerTask::serverRemoved(ServerSocket *) {
+    setResult("Server hangup!");
+}
diff --git a/src/examples/010_echoserver/echoservertask.h b/src/examples/010_echoserver/echoservertask.h
new file mode 100644
index 0000000..f22316f
--- /dev/null
+++ b/src/examples/010_echoserver/echoservertask.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <framework/task.h>
+
+class EchoServerTask : public Task {
+public:
+    EchoServerTask(uint16_t port);
+
+    double start() override;
+
+    double timerEvent() override;
+
+    // Whenever a new client connects to our server socket, the eventloop
+    // will call the below method. To reject the connection, we could return
+    // nullptr. If we accept the connection we must create and return an object
+    // belonging to a subclass of SocketConnection.
+    SocketConnection *newClient(int fd, const char *ip,
+                                uint16_t port, ServerSocket *) override;
+
+    // The eventloop will call this method to notify us each time a new
+    // SocketConnection has been added, i.e. after the newClient call.
+    void connAdded(SocketConnection *conn) override;
+
+    // The eventloop will call this method to notify us each time an existing
+    // SocketConnection has been removed.
+    void connRemoved(SocketConnection *conn) override;
+
+    // The eventloop will call this method to notify us each time a new
+    // server (listening) socket has been added.
+    void serverAdded(ServerSocket *conn) override;
+
+    // The eventloop will call this method to notify us each time an existing
+    // server (listening) socket has been removed.
+    void serverRemoved(ServerSocket *conn) override;
+
+private:
+    uint16_t port_number;
+    unsigned int no_clients = 0;
+};
diff --git a/src/examples/011_echoclient/Makefile b/src/examples/011_echoclient/Makefile
new file mode 100644
index 0000000..9051206
--- /dev/null
+++ b/src/examples/011_echoclient/Makefile
@@ -0,0 +1,10 @@
+TARGET = echoclient
+DIRLEVEL = ../..
+LOGLEVEL = dbg
+GNUTLS = 0
+
+SOURCES = echoclientconnection.cpp \
+	echoclienttask.cpp \
+	echoclient.cpp
+
+include $(DIRLEVEL)/framework/mk.inc
diff --git a/src/examples/011_echoclient/echoclient.cpp b/src/examples/011_echoclient/echoclient.cpp
new file mode 100644
index 0000000..6213c77
--- /dev/null
+++ b/src/examples/011_echoclient/echoclient.cpp
@@ -0,0 +1,14 @@
+#include <framework/eventloop.h>
+#include "echoclienttask.h"
+
+/* Example 011
+
+Write a few messages to an echo server, check the result.
+Make sure the server from example 010 is running while you run this client.
+
+*/
+
+int main(int , char *[]) {
+    EventLoop::runTask(new EchoClientTask("127.0.0.1", 1400));
+    return 0;
+}
diff --git a/src/examples/011_echoclient/echoclientconnection.cpp b/src/examples/011_echoclient/echoclientconnection.cpp
new file mode 100644
index 0000000..eb92215
--- /dev/null
+++ b/src/examples/011_echoclient/echoclientconnection.cpp
@@ -0,0 +1,36 @@
+#include "echoclientconnection.h"
+#include "echoclienttask.h"
+
+EchoClientConnection::
+EchoClientConnection(EchoClientTask *task, const std::string &hostname,
+                     unsigned int port) :
+    SocketConnection("EchoClientConnection", task, hostname, port) {
+}
+
+PollState EchoClientConnection::connected() {
+    msg_out = "Hi ho, hi ho";
+    log() << "Socket connected, sending " << msg_out;
+    asyncSendData(msg_out);
+    return PollState::READ;
+}
+
+PollState EchoClientConnection::readData(char *buf, size_t len) {
+    log() << "Got data: " << std::string(buf, len);
+    msg_in.append(buf, len);
+    if (msg_in.size() == msg_out.size()) {
+        if (msg_in == msg_out) {
+            log() << "Full response read. Will take a short nap.";
+            if (EchoClientTask *t = dynamic_cast<EchoClientTask *>(owner()))
+                t->test_succeeded();
+        } else {
+            log() << "Unexpected response. Nevermind. Will try again soon.";
+        }
+        return PollState::KEEPALIVE;
+    } else if (msg_in.size() < msg_out.size()) {
+        log() << "More data needed";
+        return PollState::READ;
+    } else {
+        log() << "Got unexpected data: sent " << msg_out << ", got " << msg_in;
+        return PollState::CLOSE;
+    }
+}
diff --git a/src/examples/011_echoclient/echoclientconnection.h b/src/examples/011_echoclient/echoclientconnection.h
new file mode 100644
index 0000000..83e262f
--- /dev/null
+++ b/src/examples/011_echoclient/echoclientconnection.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <framework/socketconnection.h>
+
+class EchoClientTask;
+
+class EchoClientConnection : public SocketConnection {
+public:
+    EchoClientConnection(EchoClientTask *task, const std::string &hostname,
+                         unsigned int port);
+    PollState connected() override;
+
+    PollState readData(char *buf, size_t len) override;
+private:
+    size_t sent = 0;
+    std::string msg_in, msg_out;
+};
diff --git a/src/examples/011_echoclient/echoclienttask.cpp b/src/examples/011_echoclient/echoclienttask.cpp
new file mode 100644
index 0000000..0f16631
--- /dev/null
+++ b/src/examples/011_echoclient/echoclienttask.cpp
@@ -0,0 +1,20 @@
+#include "echoclienttask.h"
+#include "echoclientconnection.h"
+
+double EchoClientTask::start() {
+    log() << "Will create EchoClientConnection";
+    if (!addConnection(new EchoClientConnection(this, _hostname, _port)))
+        setError("Cannot find server");
+    return 1.0;
+}
+
+double EchoClientTask::timerEvent() {
+    if (elapsed() > 15.0) {
+        setResult("Timeout!");
+        return 0;
+    }
+    log() << "Create another EchoClientConnection";
+    if (!addConnection(new EchoClientConnection(this, _hostname, _port)))
+        setError("Cannot find server");
+    return 1.0;
+}
diff --git a/src/examples/011_echoclient/echoclienttask.h b/src/examples/011_echoclient/echoclienttask.h
new file mode 100644
index 0000000..7a5dcd8
--- /dev/null
+++ b/src/examples/011_echoclient/echoclienttask.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <framework/task.h>
+
+class EchoClientTask : public Task {
+public:
+    EchoClientTask(const std::string &host, unsigned int port) :
+        Task("EchoClientTask"),
+        _port(port),
+        _hostname(host) {
+    }
+
+    void test_succeeded() {
+        ++no_succeeded_requests;
+        if (no_succeeded_requests == 10)
+            setResult("All done!");
+    }
+
+    double start() override;
+
+    void connAdded(SocketConnection *) override {
+        log() << "connection added";
+    }
+
+    void connRemoved(SocketConnection *) override {
+        log() << "connection removed";
+    }
+
+    double timerEvent() override;
+
+private:
+    uint16_t _port;
+    std::string _hostname;
+    unsigned int no_succeeded_requests = 0;
+};
diff --git a/src/examples/020_cliclient/Makefile b/src/examples/020_cliclient/Makefile
new file mode 100644
index 0000000..599a367
--- /dev/null
+++ b/src/examples/020_cliclient/Makefile
@@ -0,0 +1,9 @@
+TARGET = cliclient
+DIRLEVEL = ../..
+LOGLEVEL = dbg
+GNUTLS = 0
+SOURCES = cliclient.cpp webserver.cpp
+
+CLEAN += log.txt
+
+include $(DIRLEVEL)/http/mk.inc
diff --git a/src/examples/020_cliclient/cliclient.cpp b/src/examples/020_cliclient/cliclient.cpp
new file mode 100644
index 0000000..caca97c
--- /dev/null
+++ b/src/examples/020_cliclient/cliclient.cpp
@@ -0,0 +1,98 @@
+#include <fstream>
+
+#include <framework/eventloop.h>
+#include <framework/synchronousbridge.h>
+
+#include "webserver.h"
+
+/* Example 020: Demonstration of the agent/bridge/client concept.
+
+This program contains a CLI (command line interface) to a WebServer task.
+It must be run in a terminal. The CLI is rather pointless, it just writes
+the latest URL fetched from the WebServer in a single line in the terminal.
+However, the same technique can be used to implement real user interfaces,
+e.g. a GUI or a web interface.
+
+A log is written to log.txt.
+
+The WebServer task is an _agent_, i.e. it can communicate with a client that
+does not run in the eventloop. The client is the CLI which is implemented by
+the MyClient class below.
+
+The communication between the agent and the client is facilitated by a _bridge_
+which is a task running in the eventloop. The bridge can pass messages from
+the agent to the client and from the client to the agent. Each message is a
+single string.
+
+The bridge class is a subclass of the BridgeTask class, specifying the API from
+the agent's point of view. Since the client is not a Task (it could be anything
+really), different BridgeTask sublasses have different means of communicating
+with the client. However, the agent code does not depend on what client is used.
+
+In this example, the agent and the client run in the same process. The most
+common case though is that the client runs in another process or at least not
+in the same thread as the eventloop.
+
+To test the CLI client, run it in a terminal. Then retrieve a few URLs from the
+agent, which runs on port 8080, e.g.
+
+  http://127.0.0.1:8080/getTime
+  http://127.0.0.1:8080/getStats
+  http://127.0.0.1:8080/hi
+
+The program will (as a demonstration) terminate after a few requests.
+
+*/
+
+class MyClient : public SynchronousClient {
+public:
+    // initial messages to the agent shall be pushed onto return_msgs.
+    void initialMsgToAgent(std::deque<std::string> &return_msgs) override;
+
+    // msg is a new message from the agent.
+    // push any return messages onto return_msgs.
+    void newEventFromAgent(std::deque<std::string> &return_msgs,
+                           const std::string &msg) override;
+private:
+    std::string last_msg;
+    unsigned int msgCount = 0;
+};
+
+void MyClient::initialMsgToAgent(std::deque<std::string> &return_msgs) {
+    return_msgs.push_back("client ready");
+}
+
+void MyClient::newEventFromAgent(std::deque<std::string> &return_msgs,
+                                  const std::string &msg) {
+    ++msgCount;
+
+    // Move back to leftmost position in the terminal
+    std::cerr << std::string(last_msg.size(), '\010') << msg;
+    if (last_msg.size() > msg.size()) {
+        // New message is shorter, erase last part of old message in terminal
+        size_t n = static_cast<size_t>(last_msg.size()-msg.size());
+        std::cerr << std::string(n, ' ') << std::string(n, '\010');
+    }
+    last_msg = msg;
+
+    // Just as a demonstration, we will send a termination request to the agent
+    // after having received a few messages.
+    if (msgCount == 4)
+        return_msgs.push_back("quit");
+
+    if (BridgeTask::isAgentTerminatedMessage(msg)) {
+        // Agent gone.
+        std::cerr << "\nBye." << std::endl;
+    }
+}
+
+int main(int , char *[]) {
+    std::ofstream log("log.txt");
+    Logger::setLogFile(log);
+    EventLoop eventloop("EventLoop");
+    WebServer *agent = new WebServer("listen 8080");
+    MyClient *client = new MyClient();
+    eventloop.addTask(new SynchronousBridge(agent, client));
+    eventloop.runUntilComplete();
+    return 0;
+}
diff --git a/src/examples/020_cliclient/webserver.cpp b/src/examples/020_cliclient/webserver.cpp
new file mode 100644
index 0000000..52343ae
--- /dev/null
+++ b/src/examples/020_cliclient/webserver.cpp
@@ -0,0 +1,57 @@
+#include "webserver.h"
+#include <framework/bridgetask.h>
+
+
+// Messages from the client arrive here:
+void WebServer::handleExecution(Task *sender, const std::string &message) {
+    dbg_log() << "Event " << message << " from " << sender->label();
+    if (BridgeTask *bridge = dynamic_cast<BridgeTask *>(sender)) {
+        if (the_bridge && bridge != the_bridge) {
+            // We already had a connected bridge and a new one tries to connect.
+            // We could allow several simultaneous clients, but normally one is
+            // enough.
+            log() << "Won't allow more than one client";
+            return;
+        }
+
+        // Here we can handle all kinds of messages from the client.
+        if (message == "client ready") {
+            // Client is ready to receive messages from us.
+            the_bridge=bridge;
+        } else if (message == "quit" ) {
+            setResult("Terminate by request from client");
+        }
+    }
+}
+
+void WebServer::taskFinished(Task *task) {
+    if (task == the_bridge) {
+        log() << "Client connection broken";
+        the_bridge = nullptr;
+        // We could call  setResult("")  to terminate
+        // but will wait for a new client instead.
+    }
+}
+
+HttpState WebServer::newGetRequest(HttpServerConnection *conn,
+                                   const std::string &uri) {
+    ++tot_no_requests;
+    log() << "URI: " << uri << " #" << tot_no_requests;
+    if (the_bridge) {
+        std::string msg = "Last request: " + uri + " (request #" +
+            std::to_string(tot_no_requests) + ")";
+        the_bridge->sendMsgToClient(msg);
+    }
+
+    if (uri == "/getTime")
+        conn->sendHttpResponse(headers("200 OK"), "text/plain", dateString());
+    else if (uri == "/getStats")
+        conn->sendHttpResponse(headers("200 OK"), "text/plain",
+                               std::to_string(tot_no_requests));
+    else if (uri == "/hi")
+        conn->sendHttpResponse(headers("200 OK"), "text/plain", "hello");
+    else
+        conn->sendHttpResponse(headers("404 Not Found"), "text/plain",
+                               "unknown service");
+    return HttpState::WAITING_FOR_REQUEST;
+}
diff --git a/src/examples/020_cliclient/webserver.h b/src/examples/020_cliclient/webserver.h
new file mode 100644
index 0000000..8b5b5d7
--- /dev/null
+++ b/src/examples/020_cliclient/webserver.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <http/webservertask.h>
+
+class BridgeTask;
+
+class WebServer : public WebServerTask {
+public:
+    WebServer(const std::string &cfg) :
+        WebServerTask("WebServer", cfg) {
+    }
+
+    HttpState newGetRequest(HttpServerConnection *,
+                            const std::string &uri) override;
+
+    void handleExecution(Task *sender, const std::string &message) override;
+    void taskFinished(Task *task) override;
+private:
+    unsigned long tot_no_requests = 0;
+
+    // We will only talk to one client.
+    BridgeTask *the_bridge = nullptr;
+};
diff --git a/src/examples/030_httpclient/Makefile b/src/examples/030_httpclient/Makefile
new file mode 100644
index 0000000..16a4c8b
--- /dev/null
+++ b/src/examples/030_httpclient/Makefile
@@ -0,0 +1,11 @@
+TARGET = client
+DIRLEVEL = ../..
+LOGLEVEL = dbg
+GNUTLS = 0
+THREADS = 0
+
+SOURCES = main.cpp
+
+CXXFLAGS += -g
+
+include $(DIRLEVEL)/http/mk.inc
diff --git a/src/examples/030_httpclient/main.cpp b/src/examples/030_httpclient/main.cpp
new file mode 100644
index 0000000..650bb48
--- /dev/null
+++ b/src/examples/030_httpclient/main.cpp
@@ -0,0 +1,76 @@
+#include <http/httprequestengine.h>
+#include <json11/json11.hpp>
+#include <framework/eventloop.h>
+
+class MainTask : public Task {
+public:
+    MainTask() : Task("Main") {
+        bot = new HttpRequestEngine("MyBot", HttpHost("127.0.0.1", 8080),
+                                    0, 3);
+        //bot = new HttpRequestEngine("MyBot", "lab04.bredbandskollen.se");
+    }
+
+    ~MainTask() {
+    }
+
+    double start() override {
+        dbg_log() << "starting";
+
+        addNewTask(bot, this);
+
+        bot->startObserving(this);
+        bot->getJob(this, "Ticks " + std::to_string(++request_no),
+                    "/chunk?ticks=10");
+        bot->getJob(this, "Count " + std::to_string(++request_no),
+                    "/getStats");
+        killChildTaskWhenFinished();
+        return 3.0;
+    }
+
+    double timerEvent() override {
+        dbg_log() << "timerEvent";
+        if (request_no < 10)
+            bot->getJob(this, "Ticks " + std::to_string(++request_no),
+                        "/chunk?ticks=10");
+        bot->getJob(this, "Count " + std::to_string(++request_no),
+                    "/getStats");
+        if (request_no < 20)
+            return 3.0;
+        else
+            return 0.0;
+    }
+
+    void taskFinished(Task *task) override {
+        log() << "Oops, task " << task->label() << " died.";
+        if (task == bot) {
+            bot = nullptr;
+            setResult("Failed");
+        }
+    }
+
+    void handleExecution(Task *task, const std::string &name) override {
+        log() << task->label() << " event: " << name;
+        if (task != bot)
+            return;
+        if (bot->httpStatus()) {
+            log() << "Exit job " << name << " result: " << bot->contents();
+            ++ok_jobs;
+            if (ok_jobs == 20)
+                setResult("All done.");
+        } else {
+            log() << "Exit job " << name << " failed, will retry";
+            bot->redoJob();
+        }
+    }
+private:
+    unsigned int request_no = 0, ok_jobs = 0;
+    HttpRequestEngine *bot = nullptr;
+    std::string _ticket;
+};
+
+int main(int , char *[]) {
+    EventLoop eventloop("EventLoop");
+    eventloop.addTask(new MainTask());
+    eventloop.runUntilComplete();
+    return 0;
+}
diff --git a/src/examples/Makefile b/src/examples/Makefile
new file mode 100644
index 0000000..85f1951
--- /dev/null
+++ b/src/examples/Makefile
@@ -0,0 +1,15 @@
+# These can't be built in parallel since there's a race when creating
+# the dependency files, so "make" / "make -j1" is needed.
+
+SUBDIRS := $(wildcard [0-9][0-9][0-9]_*)
+
+all: $(SUBDIRS)
+
+$(SUBDIRS):
+	$(MAKE) -C $@ clean # needed because of conflicting obj instrumentations
+	$(MAKE) -C $@ -j    # internal parallel build is ok
+
+clean:
+	@$(foreach dir,$(SUBDIRS),$(MAKE) -C$(dir) clean;)
+
+.PHONY: $(SUBDIRS) clean all
diff --git a/src/framework/bridgetask.cpp b/src/framework/bridgetask.cpp
new file mode 100644
index 0000000..d5ace70
--- /dev/null
+++ b/src/framework/bridgetask.cpp
@@ -0,0 +1,20 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "../json11/json11.hpp"
+
+#include "bridgetask.h"
+
+BridgeTask::~BridgeTask() {
+}
+
+double BridgeTask::start() {
+    if (the_agent) {
+        addNewTask(the_agent, this);
+        the_agent->startObserving(this);
+    } else {
+        err_log() << "You must call setAgent before starting bridge";
+        setError("no agent");
+    }
+    return 0;
+}
diff --git a/src/framework/bridgetask.h b/src/framework/bridgetask.h
new file mode 100644
index 0000000..3d29bbb
--- /dev/null
+++ b/src/framework/bridgetask.h
@@ -0,0 +1,142 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <string>
+#include "task.h"
+
+/// \brief
+/// Tasks may use a bridge to communicate with an application running
+/// outside the event loop.
+///
+/// This class provides an abstract interface for a _bridge_ which facilitates
+/// communication between a task and code running outside the event loop.
+/// The code might run in another process or thread. The actual
+/// means of communication might be sockets or pipes, or shared variables in
+/// the case of threads, or something else entirely.
+///
+/// The task running in the event loop is called the _agent_, and the outside
+/// aplication is called the _client_.
+///
+/// To use this class, you must
+///    - derive from this class
+///    - implement the sendMessageToClient method
+///    - implement a way for the client to send messages back, and pass those
+///      messages through the sendMsgToAgent method
+///    - if you override the start() method, call BridgeTask::start() first
+///    - create an agent object and a bridge object
+///    - add the bridge object to the event loop
+/// The agent task will be aborted when the bridge task is finished.
+/// If you need timers (e.g. for polling), you must override the start() method
+/// below and your start() method must call BridgeTask::start().
+///
+/// When there is a message from the client to the agent, the agent's
+/// Task::handleExecution method will be called with two parameters:
+/// the bridge object and a message.
+///
+/// Typically, the agent's Task::handleExecution method checks if the
+/// first parameter can be cast to a BridgeTask pointer.
+/// If so, the second parameter is a message from the client.
+/// When the first message from the client arrives, the agent stores
+/// the pointer to the bridge in case it needs to send messages back.
+class BridgeTask : public Task {
+
+public:
+    /// \brief
+    /// Create a bridge to the given agent task.
+    ///
+    /// If the agent task isn't available yet, it must be added using
+    /// BridgeTask::setAgent before the bridge is added to the EventLoop.
+    BridgeTask(Task *agent = nullptr) : Task("Bridge"), the_agent(agent) {
+        killChildTaskWhenFinished();
+    }
+
+    /// \brief
+    /// Will add the agent task to the EventLoop.
+    ///
+    /// *Note!* If you override this method, it should be called explicitly by
+    /// the overriding method!
+    double start() override;
+
+    /// If the agent dies, a special message will be sent to notify the client.
+    void taskFinished(Task *task) override {
+        if (task == the_agent) {
+            if (!task->result().empty()) {
+                log() << "Agent terminated";
+                sendMsgToClient(agentTerminatedMessage(task->result()));
+                the_agent = nullptr;
+            }
+            die();
+        }
+    }
+
+    /// If the agent task was created after the bridge, it must be added using
+    /// this method _before_ the bridge is added to the EventLoop.
+    void setAgent(Task *agent) {
+        if (!the_agent && !hasStarted())
+            the_agent = agent;
+        else
+            err_log() << "cannot set agent";
+    }
+
+    /// Terminate the bridge task.
+    void die() {
+        setResult("");
+    }
+
+    /// The agent will call this to pass messages to the client.
+    virtual void sendMsgToClient(const std::string &msg) = 0;
+
+    /// \brief Format a message to the agent.
+    ///
+    /// Recommended way to format messages to the agent: a method name,
+    /// and "arguments" stored in a JSON object.
+    ///
+    /// *Note!* The method name must not contain any special chararcters.
+    static std::string msgToAgent(const std::string &method,
+                                  const std::string &jsonobj = "{}") {
+        return "{\"method\": \"" + method + "\", \"args\": " + jsonobj + "}";
+    }
+
+    /// Return true if msg is formatted as a note that the agent has terminated
+    /// and that there will be no more messages.
+    static bool isAgentTerminatedMessage(const std::string &msg) {
+        return (msg.substr(0, 12) == "AGENT EXIT: ");
+    }
+
+    /// Format a message to signal that the Agent is gone.
+    static std::string agentTerminatedMessage(const std::string &err_msg) {
+        return "AGENT EXIT: " + err_msg;
+    }
+
+    /// \brief Format a message to the client.
+    ///
+    /// Recommended way to format messages to the client: an event (or method)
+    /// name, and "arguments" stored in a JSON object.
+    ///
+    /// *Note!* The method name must not contain any special chararcters.
+    void sendMsgToClient(const std::string &method, const std::string &jsonobj) {
+        sendMsgToClient("{\"event\": \"" + method +
+                        "\", \"args\": " + jsonobj + "}");
+    }
+
+    virtual ~BridgeTask() override;
+
+protected:
+    /// Send message to the agent.
+    void sendMsgToAgent(const std::string &msg) {
+        executeHandler(the_agent, msg);
+        if (msg.substr(0, terminate_msg.size()) == terminate_msg)
+            die();
+    }
+
+    /// Format and send message to the agent.
+    void sendMsgToAgent(const std::string &method, const std::string &jsonobj) {
+        sendMsgToAgent(msgToAgent(method, jsonobj));
+    }
+private:
+    Task *the_agent;
+    //const std::string quit_msg = "quit";
+    const std::string terminate_msg = "{\"method\": \"terminate\"";
+};
diff --git a/src/framework/engine.cpp b/src/framework/engine.cpp
new file mode 100644
index 0000000..93db75b
--- /dev/null
+++ b/src/framework/engine.cpp
@@ -0,0 +1,644 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <string.h>
+#ifdef _WIN32
+#include <winsock2.h>
+#else
+#include <sys/socket.h>
+#include <netdb.h>
+#endif
+
+#ifdef _WIN32
+#include <ws2tcpip.h>
+#else
+#include <sys/select.h>
+#endif
+
+#include <set>
+#include <stdexcept>
+
+#include "engine.h"
+#include "socketconnection.h"
+#include "serversocket.h"
+#ifndef _WIN32
+#include <arpa/inet.h>
+#endif
+
+Engine::Engine(std::string label) :
+    Logger(label) {
+#ifdef USE_GNUTLS
+    x509_cred.resize(1);
+    if (gnutls_global_init() < 0 ||
+        gnutls_certificate_allocate_credentials(&x509_cred[0]) < 0 ||
+        gnutls_priority_init(&priority_cache,
+                             "PERFORMANCE:%SERVER_PRECEDENCE",
+                             nullptr) < 0)
+        throw std::runtime_error("cannot enable TLS");
+#if GNUTLS_VERSION_NUMBER >= 0x030506
+        /* only available since GnuTLS 3.5.6, on previous versions see
+         * gnutls_certificate_set_dh_params(). */
+        gnutls_certificate_set_known_dh_params(x509_cred[0], GNUTLS_SEC_PARAM_MEDIUM);
+#endif
+#endif
+}
+
+Engine::~Engine() {
+
+    terminate(0);
+    Socket::clearCache();
+
+#ifdef USE_GNUTLS
+    for (auto &cred : x509_cred)
+        gnutls_certificate_free_credentials(cred);
+    gnutls_priority_deinit(priority_cache);
+    gnutls_global_deinit();
+#endif
+
+}
+
+#ifdef USE_GNUTLS
+
+bool Engine::setCABundle(const std::string &path) {
+    if (path.empty())
+        return true;
+    ca_bundle = path;
+    if (gnutls_certificate_set_x509_trust_file(x509_cred[0], ca_bundle.c_str(),
+                                               GNUTLS_X509_FMT_PEM) < 0)
+        return false;
+    return true;
+}
+
+bool Engine::tlsSetKey(ServerSocket *conn, const std::string &crt_path,
+                       const std::string &key_path,
+                       const std::string &password) {
+    if (key_path.empty() && crt_path.empty())
+        return 0;
+
+    unsigned int index;
+    auto it = tls_crt_map.find(crt_path);
+    if (it != tls_crt_map.end()) {
+        index = it->second;
+    } else {
+        index = static_cast<unsigned int>(x509_cred.size());
+        x509_cred.resize(index+1);
+        if (gnutls_certificate_allocate_credentials(&x509_cred[index]) < 0) {
+            x509_cred.resize(index);
+            return false;
+        }
+        int ret = gnutls_certificate_set_x509_key_file2(x509_cred[index],
+                                                        crt_path.c_str(),
+                                                        key_path.c_str(),
+                                                        GNUTLS_X509_FMT_PEM,
+                                                        password.c_str(), 0);
+        if (ret < 0) {
+            err_log() << "Cannot add TLS server certificate: "
+                      << gnutls_strerror(ret);
+            return false;
+        }
+        tls_crt_map[crt_path] = index;
+    }
+    conn->tlsSetKey(index);
+    return true;
+}
+
+#endif
+
+// Hand the SocketConnection object over to us.
+// Will delete the object and return false on immediate failure.
+// If the object already has a socket, i.e. conn->socket()>=0,
+// it will be used.
+// Otherwise we will listen on the given port number and
+// local ip number (port 0 means any available port,
+// leave ip_number empty to listen on all local ip numbers).
+bool Engine::addServer(ServerSocket *conn) {
+    if (!conn)
+        return false;
+    if (conn->socket()<0 && !conn->createServerSocket()) {
+        err_log() << "cannot add ServerSocket "
+              << conn->hostname() << ':' << conn->port();
+        delete conn;
+        return false;
+    }
+    dbg_log() << "addServer fd " << conn->socket();
+    connectionStore[conn->socket()] = conn;
+    return true;
+}
+
+// Hand the SocketConnection object over to us.
+// Will delete the object and return false on immediate failure.
+// Otherwise return true; then either connected or connectionFailed
+// will be called on conn.
+bool Engine::addClient(SocketConnection *conn) {
+    if (!conn)
+        return false;
+
+#ifndef _WIN32
+    if (conn->socket() >= 0) {
+        if (connectionStore.find(conn->socket()) != connectionStore.end()) {
+            err_log() << "Socket " << conn->socket() << " host "
+                      << conn->hostname() << " already exists";
+            return false;
+        }
+        if (conn->hostname() != "UnixDomain" || !conn->socket()) {
+            err_log() << "Socket " << conn->socket() << " host "
+                      << conn->hostname() << " not accepted";
+            return false;
+        }
+
+        // Unix Domain socket, socket already created and connected
+        addConnected(conn);
+        return true;
+    }
+#endif
+    std::string label = conn->cacheLabel();
+    auto p = keepaliveCache.find(label);
+    if (!label.empty() &&
+        p != keepaliveCache.end()) {
+        log() << "Using cached socket " << p->second << " label " << label;
+        conn->setSocket(p->second);
+#ifdef USE_GNUTLS
+        auto it = tls_session_cache.find(p->second);
+        if (it != tls_session_cache.end()) {
+            conn->insert_cached_session(it->second);
+            tls_session_cache.erase(it);
+        }
+#endif
+        keepaliveCache.erase(p);
+        //log() << "Cache size is " << keepaliveCache.size();
+        conn->setState(conn->connected());
+    } else if (!conn->asyncConnect()) {
+        delete conn;
+        return false;
+    }
+
+    connectionStore[conn->socket()] = conn;
+    return true;
+}
+
+void Engine::childProcessCloseSockets() {
+    for (auto p : connectionStore)
+        Socket::closeSocket(p.first);
+    for (auto p : keepaliveCache)
+        Socket::closeSocket(p.second);
+}
+
+void Engine::terminate(unsigned int ) {
+    while (!connectionStore.empty())
+        killConnection(connectionStore.cbegin()->first);
+    for (auto p : keepaliveCache)
+        Socket::closeSocket(p.second);
+#ifdef USE_GNUTLS
+    for (auto p : tls_session_cache)
+        gnutls_deinit(p.second);
+#endif
+}
+
+bool Engine::reclaimConnections() {
+    std::set<int> fds_to_remove;
+    for (auto p : connectionStore)
+        switch (p.second->state()) {
+        case PollState::CLOSE:
+        case PollState::KILL:
+        case PollState::KEEPALIVE:
+            fds_to_remove.insert(p.first);
+            break;
+        case PollState::NONE:
+        case PollState::READ_BLOCKED:
+#ifdef USE_GNUTLS
+        case PollState::TLS_HANDSHAKE:
+#endif
+        case PollState::CONNECTING:
+        case PollState::WRITE:
+        case PollState::READ_WRITE:
+        case PollState::READ:
+            break;
+        }
+    if (fds_to_remove.empty())
+        return false;
+    for (auto fd : fds_to_remove)
+        killConnection(fd);
+    return true;
+}
+
+int Engine::setFds(fd_set &r, fd_set &w, fd_set &e) {
+    int max = -1;
+    FD_ZERO(&r);
+    FD_ZERO(&w);
+    FD_ZERO(&e);
+
+    // Check what to do with each connection.
+    // Note! We cannot do anything non-trivial while looping
+    // over connectionStore since elements might be added or
+    // removed, invalidating iterators.
+    for (auto p : connectionStore) {
+        int fd = p.first;
+        Socket *c = p.second;
+        switch (c->state()) {
+        case PollState::CLOSE:
+        case PollState::KILL:
+        case PollState::KEEPALIVE:
+            continue;
+        case PollState::CONNECTING:
+        case PollState::WRITE:
+        case PollState::READ_WRITE:
+            FD_SET(fd, &w);
+            break;
+        case PollState::READ:
+            if (c->wantToSend())
+                FD_SET(fd, &w);
+            break;
+#ifdef USE_GNUTLS
+        case PollState::TLS_HANDSHAKE:
+#endif
+        case PollState::NONE:
+            break;
+        case PollState::READ_BLOCKED:
+            c->setState(c->checkReadBlock());
+            if (c->wantToSend())
+                FD_SET(fd, &w);
+            FD_SET(fd, &e);
+            if (fd > max)
+                max = fd;
+            continue;
+        }
+
+        // Always check for readability (if closed by peer) and error:
+        FD_SET(fd, &r);
+        FD_SET(fd, &e);
+
+        if (fd > max)
+            max = fd;
+    }
+
+    // Check keep-alive connection since they may be closed by peer.
+    for (auto p : keepaliveCache) {
+        FD_SET(p.second, &r);
+        FD_SET(p.second, &e);
+        if (p.second > max)
+            max = p.second;
+    }
+
+    return max;
+}
+
+#ifdef USE_THREADS
+thread_local
+#endif
+volatile bool Engine::yield_called = false;
+bool Engine::max_open_fd_reached = false;
+
+void Engine::handleMaxOpenFdReached() {
+    // TODO thread safe
+    if (!keepaliveCache.empty()) {
+        auto it = keepaliveCache.begin();
+        Socket::closeSocket(it->second);
+#ifdef USE_GNUTLS
+        auto p = tls_session_cache.find(it->second);
+        if (p != tls_session_cache.end())
+            tls_session_cache.erase(p);
+#endif
+        keepaliveCache.erase(it);
+        max_open_fd_reached = false;
+        return;
+    }
+    if (connectionStore.size() > 100) {
+        // Try to find a client socket to remove
+        for (auto &p : connectionStore)
+            if (auto s = dynamic_cast<SocketConnection *>(p.second)) {
+                warn_log() << "Out of file descriptors, will remove "
+                           << s->id();
+                s->closeMe();
+                max_open_fd_reached = false;
+                return;
+            }
+    }
+    // Close some random file descriptor
+    warn_log() << "Out of file descriptors, possible fd leak";
+    static int fd_to_remove = 10;
+    while (++fd_to_remove < 65536) {
+        if (connectionStore.find(fd_to_remove) == connectionStore.end()) {
+            if (!Socket::closeSocket(fd_to_remove)) {
+                warn_log() << "Possible fd leak, closed fd " << fd_to_remove;
+                max_open_fd_reached = false;
+                return;
+            }
+        }
+    }
+    warn_log() << "Out of file descriptors, cannot recover";
+    fd_to_remove = 10;
+}
+
+// Handle network events for max_time seconds or until yield is called.
+bool Engine::run(double max_time) {
+    deadline = timeAfter(max_time);
+    yield_called = false;
+
+    {
+        // Find sockets that will expire and delete them.
+        // Can't delete them while looping over connectionStore since
+        // connectionStore gets modified when Socket objects are deleted.
+        std::vector<int> expired;
+        for (auto p : connectionStore)
+            if (p.second->hasExpired(deadline))
+                expired.push_back(p.first);
+
+        for (auto fd : expired)
+            killConnection(fd);
+    }
+
+    while (!yield_called) {
+
+        if (reclaimConnections())
+            continue; // Recheck after callbacks
+
+        fd_set readFds, writeFds, errFds;
+        int max_fd = setFds(readFds, writeFds, errFds);
+
+        struct timeval timeout;
+        {
+            double time_left = secondsTo(deadline);
+            long us = static_cast<long>(1e6*time_left);
+            if (us <= 0)
+                return true;
+            timeout.tv_sec = us/1000000;
+            timeout.tv_usec = us%1000000;
+        }
+
+        int res = select(max_fd + 1, &readFds, &writeFds, &errFds, &timeout);
+        if (res < 0) {
+            if (fatalSelectError())
+                return false;
+        } else {
+            doFds(readFds, writeFds, errFds, max_fd);
+            if (max_open_fd_reached)
+                handleMaxOpenFdReached();
+        }
+    }
+    reclaimConnections();
+    return true;
+}
+
+void Engine::doFds(const fd_set &r, const fd_set &w, const fd_set &e, int max) {
+
+    for (auto it=keepaliveCache.begin(); it != keepaliveCache.end(); ) {
+        int fd = it->second;
+        if (FD_ISSET(fd, &r) || FD_ISSET(fd, &e)) {
+            log() << "close keepalive socket " << fd;
+#ifdef USE_GNUTLS
+            auto p = tls_session_cache.find(fd);
+            if (p != tls_session_cache.end()) {
+                gnutls_deinit(p->second);
+                tls_session_cache.erase(p);
+            }
+#endif
+            Socket::closeSocket(fd);
+            it = keepaliveCache.erase(it);
+        } else
+            ++it;
+    }
+
+    for (int fd=0; fd<=max; ++fd) {
+        // We cannot loop over connectionStore since it may
+        // be modified in all sorts of ways within the loop.
+        auto p = connectionStore.find(fd);
+        if (p == connectionStore.end())
+            continue;
+
+        if (FD_ISSET(fd, &e)) {
+            err_log() << "socket error " << fd;
+            killConnection(fd);
+            continue;
+        }
+        Socket *conn = p->second;
+
+        bool readable = FD_ISSET(fd, &r);
+        bool writable = FD_ISSET(fd, &w);
+
+        if (!readable && !writable)
+            continue;
+
+        SocketConnection *c = dynamic_cast<SocketConnection *>(conn);
+
+        if (!c) {
+            // Is it a server connection?
+            if (ServerSocket *srv =
+                dynamic_cast<ServerSocket *>(conn)) {
+                // New connection on listen socket
+                handleIncoming(srv);
+                continue;
+            }
+            err_log() << "event on non-client connection";
+            killConnection(fd);
+            continue;
+        }
+
+        if (readable && (c->state() == PollState::READ ||
+                         c->state() == PollState::READ_WRITE)) {
+            // React to reading before considering writing:
+            c->setState(c->doRead(fd));
+            // If it switches to sending, we'll probably be able to send some data
+            // immediately, saving us a select roundtrip.
+            if (c->state() == PollState::WRITE) {
+                writable = true;
+            } else {
+                continue;
+            }
+        }
+
+        if (writable) {
+            PollState s;
+            if (c->state() == PollState::CONNECTING) {
+                if (c->inError()) {
+                    err_log() << "async connect failed";
+                    killConnection(fd);
+                    continue;
+                }
+#ifdef USE_GNUTLS
+                if (c->use_tls) {
+                    if (!c->init_tls_client(x509_cred[0], !ca_bundle.empty())) {
+                        log() << "cannot enable TLS" << fd;
+                        killConnection(fd);
+                        continue;
+                    }
+                    int ret = c->try_tls_handshake();
+                    if (ret >= 0) {
+                        s = c->connected();
+                    } else if (gnutls_error_is_fatal(ret)) {
+                        err_log() << "TLS handshake failure: " << gnutls_strerror(ret);
+                        killConnection(fd);
+                        continue;
+                    } else {
+                        s = PollState::TLS_HANDSHAKE;
+                    }
+                } else
+#endif
+                s = c->connected();
+            } else {
+                s = c->doWrite();
+            }
+            c->setState(s);
+            continue;
+        }
+
+#ifdef USE_GNUTLS
+        if (c->state() == PollState::TLS_HANDSHAKE) {
+            int ret = c->try_tls_handshake();
+            if (ret >= 0) {
+                c->setState(c->connected());
+            } else if (gnutls_error_is_fatal(ret)) {
+                err_log() << "TLS handshake failure: " << gnutls_strerror(ret);
+                killConnection(fd);
+            }
+            continue;
+        }
+#endif
+
+        // The socket is readable, but we don't want to read it
+        // since state is neither READ nor READ_WRITE.
+        // The connection may have been closed by peer.
+        PollState s = c->doRead(fd);
+        c->setState(s);
+    }
+
+}
+
+bool Engine::fatalSelectError() {
+    if (Socket::isTempError()) {
+        errno_log() << "select interrupt";
+        return false;
+    }
+
+    // Oops, we've done something really wrong: an invalid
+    // filedescriptor may have been added to the poll set.
+    // Find it and remove it, then try again.
+    errno_log() << "select error";
+
+    for (auto p : connectionStore)
+        if (p.second->inError()) {
+            p.second->setState(PollState::CLOSE);
+            killConnection(p.first);
+            return false;
+        }
+
+    for (auto p=keepaliveCache.begin(); p != keepaliveCache.end(); ++p)
+        if (Socket::socketInError(p->second)) {
+#ifdef USE_GNUTLS
+            auto it = tls_session_cache.find(p->second);
+            if (it != tls_session_cache.end()) {
+                gnutls_deinit(it->second);
+                tls_session_cache.erase(it);
+            }
+#endif
+            Socket::closeSocket(p->second);
+            keepaliveCache.erase(p);
+            return false;
+        }
+
+    // Don't know what's wrong, cannot recover.
+    return true;
+}
+
+void Engine::killConnection(int fd) {
+    auto p = connectionStore.find(fd);
+    if (p != connectionStore.end()) {
+        Socket *conn = p->second;
+        SocketConnection *c = dynamic_cast<SocketConnection *>(conn);
+        if (conn->state() == PollState::KEEPALIVE) {
+            std::string label = conn->cacheLabel();
+            if (!label.empty()) {
+                log() << "keep-alive socket " << fd << " to " << label;
+                keepaliveCache.insert(std::make_pair(label, fd));
+#ifdef USE_GNUTLS
+                if (c && c->is_tls())
+                    tls_session_cache[fd] = c->cache_session();
+#endif
+                // Otherwise the socket will get closed when conn is deleted:
+                conn->setSocket(-1);
+            }
+        }
+        if (Task *task = conn->owner()) {
+            if (c)
+                task->connRemoved(c);
+            else if (ServerSocket *srv = dynamic_cast<ServerSocket *>(conn))
+                task->serverRemoved(srv);
+        }
+        delete conn;
+        connectionStore.erase(p);
+    }
+}
+
+std::set<Socket *> Engine::findSockByTask(const Task *t) const {
+    std::set<Socket *> cset;
+    for (auto p : connectionStore)
+        if (p.second->owner() == t)
+            cset.insert(p.second);
+    return cset;
+}
+
+void Engine::wakeUpByTask(Task *t) {
+    for (auto p : connectionStore)
+        if (SocketConnection *c = dynamic_cast<SocketConnection *>(p.second))
+            if (c->owner() == t && c->state() == PollState::NONE)
+                c->setState(c->connected());
+}
+
+bool Engine::wakeUpConnection(SocketConnection *s) {
+    if (s->state() != PollState::NONE)
+        return false;
+    s->setState(s->connected());
+    return true;
+}
+
+void Engine::deleteConnByTask(const Task *task) {
+    std::set<int> toRemove;
+    for (auto p : connectionStore)
+        if (p.second->owner() == task)
+            toRemove.insert(p.first);
+    for (auto fd : toRemove)
+        killConnection(fd);
+}
+
+void Engine::cancelConnection(SocketConnection *s) {
+    killConnection(s->socket());
+}
+
+void Engine::handleIncoming(ServerSocket *server) {
+    SocketConnection *client = server->incoming();
+    if (!client) {
+        return;
+    }
+    int newfd = client->socket();
+
+#ifdef USE_GNUTLS
+    log() << "Socket " << newfd << " TLS=" << server->tlsKey();
+    if (server->tlsKey()) {
+        if (!client->init_tls_server(x509_cred[server->tlsKey()], priority_cache)) {
+            log() << "cannot enable TLS" << newfd;
+            delete client;
+            return;
+        }
+        client->enableTLS();
+        int ret = client->try_tls_handshake();
+        if (ret >= 0) {
+            client->setState(client->connected());
+        } else if (gnutls_error_is_fatal(ret)) {
+            err_log() << "TLS handshake has failed: " << gnutls_strerror(ret);
+            delete client;
+            return;
+        } else {
+            client->setState(PollState::TLS_HANDSHAKE);
+        }
+    } else
+#endif
+    client->setState(client->connected());
+    connectionStore[newfd] = client;
+    server->owner()->connAdded(client);
+}
+
+void Engine::addConnected(SocketConnection *conn) {
+    dbg_log() << "addConnected " << conn->socket();
+    connectionStore[conn->socket()] = conn;
+    conn->owner()->connAdded(conn);
+    conn->setState(conn->connected());
+}
diff --git a/src/framework/engine.h b/src/framework/engine.h
new file mode 100644
index 0000000..ac33e31
--- /dev/null
+++ b/src/framework/engine.h
@@ -0,0 +1,151 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+// This class implements a network engine, managing sockets.
+// It is only used by the EventLoop class.
+
+#pragma once
+
+#include <thread>
+#include <map>
+#include <vector>
+#include <string>
+#include <sys/types.h>
+
+#include "logger.h"
+
+#ifdef _WIN32
+#include <winsock2.h>
+#endif
+
+class Socket;
+class SocketConnection;
+class ServerSocket;
+class Task;
+
+#ifdef USE_GNUTLS
+#include <gnutls/gnutls.h>
+#endif
+
+/// \brief
+/// The network engine.
+///
+/// Cannot be used directly. Will be managed by the EventLoop class.
+class Engine : public Logger {
+public:
+    bool addClient(SocketConnection *conn);
+    void addConnected(SocketConnection *conn);
+    bool addServer(ServerSocket *conn);
+
+    Engine(std::string label);
+
+    /// Will kill all remaining connections.
+    ~Engine();
+
+    /// Close all connections, giving them at most
+    /// max_time_ms milliseconds to finish what's
+    /// already written to them.
+    void terminate(unsigned int max_time_ms);
+
+    /// Call this in child process to close all redundant sockets after fork.
+    void childProcessCloseSockets();
+
+    /// \brief
+    /// Run the "event loop" for at most `max_time` seconds.
+    ///
+    /// Will return when all connections have been closed,
+    /// when a fatal error has occurred, or when max_time has passed.
+    /// Return value is false on fatal error, otherwise true.
+    /// You should call this function repetedly until you're done.
+    ///
+    /// Don't set max_time > 2000 on 32-bit platforms.
+    bool run(double max_time);
+
+    /// Remove all connections owned by the task.
+    void deleteConnByTask(const Task *task);
+
+    /// Call this to make the Engine::run method return prematurely.
+    static void yield() {
+        yield_called = true;
+    }
+
+    /// \brief
+    /// Call this to enter a recovery mode if no more file descriptors
+    /// could be created.
+    static void notifyOutOfFds() {
+        // TODO: thread safe
+        max_open_fd_reached = true;
+    }
+    std::set<Socket *> findSockByTask(const Task *t) const;
+
+    /// Wake up all idle connections belonging to t:
+    void wakeUpByTask(Task *t);
+
+    /// Wake up connection s if it is idle, return false otherwise.
+    bool wakeUpConnection(SocketConnection *s);
+    void cancelConnection(SocketConnection *s);
+
+    /// Return true if connection still exists.
+    /// *Note!* We cannot _use_ conn if it has been deleted!
+    bool connActive(const Socket *conn) const {
+        for (auto it : connectionStore)
+            if (it.second == conn)
+                return true;
+        return false;
+    }
+
+    /// Call this to make the Engine::run method return earlier.
+    void resetDeadline(const TimePoint &t) {
+        if (deadline > t)
+            deadline = t;
+    }
+
+#ifdef USE_GNUTLS
+    /// Set path to file containing chain of trust for SSL certificate.
+    bool setCABundle(const std::string &path);
+
+    /// Use SSL certificate for a listening socket.
+    bool tlsSetKey(ServerSocket *conn, const std::string &crt_path,
+                   const std::string &key_path, const std::string &password);
+#endif
+
+private:
+
+    TimePoint deadline;
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static volatile bool yield_called;
+    static bool max_open_fd_reached;
+    void handleMaxOpenFdReached();
+    void killConnection(int fd);
+    void handleIncoming(ServerSocket *server);
+    // Check all connections, remove closed, reclaim keepalive,
+    // return false if none was removed:
+    bool reclaimConnections();
+
+    // Prepare for select, return largest fd or -1:
+    int setFds(fd_set &r, fd_set &w, fd_set &e);
+    // Check error from select, return false if fatal:
+    bool fatalSelectError();
+    // Take care of all network events:
+    void doFds(const fd_set &r, const fd_set &w, const fd_set &e, int max);
+
+    // Map socket number to Socket object:
+    std::map<int, Socket *> connectionStore;
+
+    // Cache of open connections that may be reused.
+    // Value is socket number. Key is some kind of label,
+    // chosen by the tasks owning the connections,
+    // that should identify the type of connection.
+    std::multimap<std::string, int> keepaliveCache;
+#ifdef USE_GNUTLS
+    std::map<int, gnutls_session_t> tls_session_cache;
+    std::string ca_bundle;
+    std::map<std::string, unsigned int> tls_crt_map;
+    // Index 0 is used for outgoing connection, containing trust store.
+    // At index > 0 certificates for server sockets are stored.
+    std::vector<gnutls_certificate_credentials_t> x509_cred;
+    gnutls_priority_t priority_cache;
+#endif
+};
diff --git a/src/framework/eventloop.cpp b/src/framework/eventloop.cpp
new file mode 100644
index 0000000..6bf20e5
--- /dev/null
+++ b/src/framework/eventloop.cpp
@@ -0,0 +1,726 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <algorithm>
+#include <stdexcept>
+#include <csignal>
+
+#include "eventloop.h"
+#include "engine.h"
+#include "task.h"
+#include "socketconnection.h"
+#include "serversocket.h"
+
+#ifdef USE_THREADS
+//thread_local
+#endif
+volatile int EventLoop::got_signal = 0;
+
+#ifdef _WIN32
+void EventLoop::signalHandler(int signum) {
+    EventLoop::interrupt();
+    got_signal = signum;
+}
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+#include "socketreceiver.h"
+#include "workerprocess.h"
+
+#ifdef USE_THREADS
+thread_local
+#endif
+std::map<int, int> EventLoop::terminatedPIDs;
+#ifdef USE_THREADS
+thread_local
+#endif
+volatile int EventLoop::terminatedPIDtmp[100] = { 0 };
+#ifdef USE_THREADS
+thread_local
+#endif
+std::string EventLoop::openFileOnSIGHUP;
+
+void EventLoop::signalHandler(int signum) {
+    EventLoop::interrupt();
+    if (signum != SIGCHLD) {
+        got_signal = signum;
+        return;
+    }
+    while (true) {
+        int wstatus;
+        pid_t pid = waitpid(-1, &wstatus, WNOHANG);
+        if (pid <= 0)
+            break;
+        //Logger::log("signalHandler") << "Child PID " << pid
+        //                             << " terminated, status " << wstatus;
+        for (size_t i=0; i<sizeof(terminatedPIDtmp)/sizeof(int); i+=2)
+            if (!terminatedPIDtmp[i]) {
+                terminatedPIDtmp[i] = pid;
+                terminatedPIDtmp[++i] = wstatus;
+                return;
+            }
+        // Bad, shouldn't use terminatedPIDs asynchronously. Won't happen if
+        // terminatedPIDtmp is large enough, i.e. twice number of chldren.
+        EventLoop::terminatedPIDs[pid] = wstatus;
+    }
+}
+
+int EventLoop::externalCommand(Task *owner, const char *const argv[]) {
+    if (!argv[0])
+        return false;
+    pid_t chld = fork();
+    if (chld < 0) {
+        errno_log() << "cannot fork";
+        return -1;
+    }
+    if (!chld) {
+        // TODO: Close all file descriptors in child!
+        int ret = execvp( argv[0], const_cast<char **>(argv) );
+        exit(ret);
+    }
+    pidOwner[chld] = owner;
+    return chld;
+}
+
+void EventLoop::daemonize() {
+    if (fork() != 0)
+        exit(0); // Close original process
+
+    setsid(); // Detach from shell
+
+    if (int fd = open("/dev/null", O_RDWR, 0) != -1) {
+        dup2(fd, STDIN_FILENO);
+        dup2(fd, STDOUT_FILENO);
+        dup2(fd, STDERR_FILENO);
+        if (fd > STDERR_FILENO)
+            close(fd);
+    }
+}
+
+WorkerProcess *EventLoop::createWorker(Task *parent,
+                                       const std::string &log_file_name,
+                                       unsigned int channels,
+                                       unsigned int wno) {
+    auto old = openFileOnSIGHUP;
+    setLogFilename(log_file_name);
+    auto logfile = new std::ofstream(log_file_name, std::ios::app);
+    auto ret = createWorker(parent, logfile, channels, wno);
+    openFileOnSIGHUP = old;
+    return ret;
+}
+
+WorkerProcess *EventLoop::createWorker(Task *parent, std::ostream *log_file,
+                                       unsigned int channels,
+                                       unsigned int wno) {
+    if (aborted())
+        return nullptr;
+    std::vector<int> array(2 * channels);
+    int *pair_sd = array.data();
+    for (unsigned int i = 0; i<channels; ++i)
+        if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair_sd+2*i) < 0) {
+            if (errno == EMFILE)
+                Engine::notifyOutOfFds();
+            errno_log() << "cannot create socketpair";
+            return nullptr;
+        }
+
+    // TODO: second parameter: unsigned int noSocketReceivers, default 1
+    //       different class for communication channels
+    int ppid = getpid();
+
+    pid_t wpid = fork();
+    if (wpid < 0)
+        return nullptr;
+
+    if (wpid > 0) {
+        // In parent (original) process
+        log() << "started worker " << wpid;
+        if (log_file)
+            delete log_file;
+        std::vector<SocketReceiver *> receivers;
+        for (unsigned int i = 0; i<2*channels; i+=2) {
+            close(pair_sd[i+1]);
+            fcntl(pair_sd[i], F_SETFL, O_NONBLOCK);
+            SocketReceiver *conn = new SocketReceiver(parent, pair_sd[i], wpid);
+            if (!addServer(conn)) {
+                err_log() << "Cannot create worker channel";
+                while (i < 2*channels)
+                    close(pair_sd[i++]);
+                return nullptr;
+            }
+            log() << "Worker channel fd " << pair_sd[i];
+            receivers.push_back(conn);
+        }
+        pidOwner[wpid] = parent;
+        return new WorkerProcess(wpid, receivers);
+    }
+
+    // In worker (new child process)
+
+    engine.childProcessCloseSockets();
+    Task::supervisor = nullptr;
+
+    // Set new log file for child process
+    if (!log_file) {
+        log_file = new std::ostringstream();
+        log_file->clear(std::istream::eofbit);
+    }
+    setLogFile(*log_file);
+
+    EventLoop eventloop("Worker");
+    Task *worker = parent->createWorkerTask(wno);
+    if (!worker) {
+        err_log() << "Cannot create worker " << wno << ", will exit";
+        exit(1);
+    }
+    eventloop.addTask(worker);
+    for (unsigned int i = 0; i<2*channels; i+=2) {
+        close(pair_sd[i]);
+        fcntl(pair_sd[i+1], F_SETFL, O_NONBLOCK);
+        SocketReceiver *chan = new SocketReceiver(worker, pair_sd[i+1], ppid);
+        worker->newWorkerChannel(chan, i/2);
+        worker->addServer(chan);
+    }
+    eventloop.runUntilComplete();
+    parent->finishWorkerTask(wno);
+    log() << "Exit" << std::endl;
+    delete log_file;
+    exit(0);
+}
+
+void EventLoop::killChildProcesses(int signum) {
+    for (auto p : pidOwner)
+        kill(p.first, signum);
+}
+
+#endif
+
+EventLoop::~EventLoop() {
+    removeAllTasks();
+    Task::supervisor = nullptr;
+    log() << "EventLoop finished.\n";
+}
+
+#ifdef USE_THREADS
+void EventLoop::do_init(EventLoop *parent) {
+    parent_loop = parent;
+#else
+void EventLoop::do_init() {
+#endif
+    if (Task::supervisor) {
+        throw std::runtime_error("eventloop already exists");
+    }
+    Task::supervisor = this;
+    got_signal = 0;
+#ifdef USE_THREADS
+    if (parent_loop)
+        return;
+#endif
+#ifdef _WIN32
+    // Windows specific sockets initialization
+    WSADATA wsaData;
+    int result = WSAStartup(MAKEWORD(2, 2), &wsaData);
+    if (result != 0)
+        throw std::runtime_error("cannot initialize network");
+    signal(SIGTERM, signalHandler);
+    signal(SIGABRT, signalHandler);
+#else
+    terminatedPIDs.clear();
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = signalHandler;
+    sigfillset(&sa.sa_mask);
+    if (sigaction(SIGCHLD, &sa, nullptr) ||
+        sigaction(SIGTERM, &sa, nullptr) ||
+        sigaction(SIGINT, &sa, nullptr) ||
+        sigaction(SIGHUP, &sa, nullptr) ||
+        sigaction(SIGQUIT, &sa, nullptr) ||
+        sigaction(SIGABRT, &sa, nullptr) ||
+        sigaction(SIGPIPE, &sa, nullptr))
+        errno_log() << "cannot add signal handler";
+#endif
+}
+
+void EventLoop::addSignalHandler(int signum, void (*handler)(int, EventLoop &)) {
+#ifdef _WIN32
+    if (signal(signum, signalHandler) == SIG_ERR) {
+        errno_log() << "cannot add handler for signal " << signum;
+        return;
+    }
+#else
+    if (signum == SIGCHLD) {
+        err_log() << "must not set custom handler for SIGCHLD";
+        return;
+    }
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = signalHandler;
+    if (sigaction(signum, &sa, nullptr)) {
+        errno_log() << "cannot add handler for signal " << signum ;
+        return;
+    }
+#endif
+    userSignalHandler.insert(std::make_pair(signum, handler));
+}
+
+void EventLoop::addTask(Task *task, Task *parent) {
+    if (task && tasks.find(task) == tasks.end()) {
+        tasks[task] = parent;
+        if (parent)
+            startObserving(parent, task);
+        if (task->terminated()) {
+            // Task finished when executing its constructor
+            notifyTaskFinished(task);
+            return;
+        }
+        double ts = task->begin();
+        log() << "Task " << task->label() << " timeout " << ts;
+        if (ts > 0) {
+            TimePoint t = timeAfter(ts);
+            timer_queue.insert(std::make_pair(t, task));
+            // Make sure we get back here when the timer expires:
+            engine.resetDeadline(t);
+        }
+    } else {
+        err_log() << "cannot add task";
+    }
+}
+
+bool EventLoop::addConnection(SocketConnection *conn) {
+    if (!conn)
+        return false;
+
+    if (tasks.find(conn->owner()) != tasks.end() &&
+        engine.addClient(conn)) {
+        conn->owner()->connAdded(conn);
+        return true;
+    }
+
+    err_log() << "cannot add connection";
+    return false;
+}
+
+bool EventLoop::addConnected(SocketConnection *conn) {
+    if (!conn)
+        return false;
+
+    if (tasks.find(conn->owner()) != tasks.end()) {
+        engine.addConnected(conn);
+        return true;
+    }
+
+    err_log() << "cannot add connection";
+    delete conn;
+    return false;
+}
+
+bool EventLoop::addServer(ServerSocket *conn) {
+    if (!conn)
+        return false;
+
+    if (tasks.find(conn->owner()) != tasks.end() &&
+        engine.addServer(conn)) {
+        conn->owner()->serverAdded(conn);
+        return true;
+    }
+
+    err_log() << "cannot add server connection";
+    return false;
+}
+
+// This is just a safeguard against buggy clients.
+// Will be called _after_ object pointed to by task
+// has been deleted, so don't dereference the pointer.
+void EventLoop::taskDeleted(Task *task) {
+    auto p = tasks.find(task);
+    if (p != tasks.end()) {
+        err_log() << "task owned by me deleted by client!";
+        tasks.erase(p);
+        engine.deleteConnByTask(task);
+    }
+}
+
+bool EventLoop::startObserving(Task *from, Task *to) {
+    if (tasks.find(from) == tasks.end() ||
+        tasks.find(to) == tasks.end()) {
+        err_log() << "startObserving: no such task";
+        return false;
+    }
+    {
+        auto p = observing.find(to);
+        if (p == observing.end()) {
+            std::set<Task *> tset { from };
+            observing.insert(std::make_pair(to, tset));
+        } else {
+            p->second.insert(from);
+        }
+    }
+    {
+        auto p = observed_by.find(from);
+        if (p == observed_by.end()) {
+            std::set<Task *> tset { to };
+            observed_by.insert(std::make_pair(from, tset));
+        } else {
+            p->second.insert(to);
+        }
+    }
+
+    return true;
+}
+
+void EventLoop::getChildTasks(std::set<Task *> &tset, Task *parent) const {
+    // parent is observing its children.
+    auto p = observed_by.find(parent);
+    if (p == observed_by.end())
+        return;
+
+    for (auto task : p->second)
+        // task is observed by parent but isn't necessarily a child task.
+        if (tasks.at(task) == parent)
+            tset.insert(task);
+}
+
+void EventLoop::abortChildTasks(Task *parent) {
+    std::set<Task *> tset;
+    getChildTasks(tset, parent);
+    for (auto task : tset) {
+        task->was_killed = true;
+        finishedTasks.insert(task);
+    }
+    engine.yield();
+}
+
+void EventLoop::abortTask(Task *task) {
+    task->was_killed = true;
+    finishedTasks.insert(task);
+    engine.yield();
+}
+
+void EventLoop::wakeUpTask(Task *t) {
+    engine.wakeUpByTask(t);
+}
+
+std::set<Socket *> EventLoop::findConnByTask(const Task *t) const {
+    return engine.findSockByTask(t);
+}
+
+bool EventLoop::running(Task *task) {
+    return tasks.find(task) != tasks.end();
+}
+
+void EventLoop::resetTimer(Task *task, double s) {
+    _removeTimer(task);
+    if (s < 0)
+        return;
+    if (s == 0)
+        s = task->timerEvent();
+    if (s > 0) {
+        auto t = toUs(s);
+        timer_queue.insert(std::make_pair(timeNow()+t, task));
+    }
+}
+
+void EventLoop::_removeTimer(Task *task) {
+    for (auto it : timer_queue)
+        if (it.second == task) {
+            timer_queue.erase(it.first);
+            break;
+        }
+}
+
+void EventLoop::_removeTask(Task *task, bool killed) {
+    {
+        auto p = tasks.find(task);
+        if (p == tasks.end())
+            return; // Task already removed.
+        tasks.erase(p);
+    }
+
+    task->setTerminated();
+    task->was_killed = killed;
+    log() << "remove task " << task->label();
+
+    // Remove the task's connections
+    engine.deleteConnByTask(task);
+
+    // Remove the task's timer
+    for (auto it : timer_queue)
+        if (it.second == task) {
+            timer_queue.erase(it.first);
+            break;
+        }
+
+    // The dying task may be an observer:
+    auto p1 = observed_by.find(task);
+    if (p1 != observed_by.end()) {
+        for (auto t : p1->second) {
+            // task must no longer be observing t
+            observing[t].erase(task);
+            auto p = tasks.find(t);
+            if (p->second == task) {
+                // t is a child of the dying task. Mark it as an orphan:
+                p->second = nullptr;
+                if (task->kill_children)
+                    abortTask(t);
+            }
+        }
+        observed_by.erase(p1);
+    }
+
+    // Other tasks may be observing the dying task:
+    auto p2 = observing.find(task);
+    if (p2 != observing.end()) {
+        for (auto t : p2->second) {
+            // t must no longer be observing task
+            observed_by[t].erase(task);
+            // Notify t that an observed task has died
+            t->taskFinished(task);
+        }
+        observing.erase(p2);
+    }
+
+#ifdef USE_THREADS
+    if (task->is_child_thread)
+        finished_threads.push(task);
+    else
+#endif
+        delete task;
+}
+
+Task *EventLoop::nextTimerToExecute() {
+    if (!timer_queue.empty() &&
+        timer_queue.cbegin()->first <= timeNow()) {
+        Task *task = timer_queue.cbegin()->second;
+        timer_queue.erase(timer_queue.begin());
+        return task;
+    }
+    return nullptr;
+}
+
+bool EventLoop::run(double timeout_s) {
+    TimePoint deadline = timeAfter(timeout_s);
+    while (true) {
+        // First run timers, regardless of deadline:
+        while (Task *task = nextTimerToExecute()) {
+            double ts = task->timerEvent();
+            if (ts > 0) {
+                auto t = toUs(ts);
+                timer_queue.insert(std::make_pair(timeNow()+t, task));
+            }
+        }
+        check_finished();
+
+#ifdef USE_THREADS
+        if ( (tasks.empty() && threads.empty()) ||
+            timeNow() > deadline || aborted())
+#else
+        if (tasks.empty() || timeNow() > deadline || aborted())
+#endif
+            break;
+
+        double time_left;
+        if (timer_queue.empty()) {
+            time_left = secondsTo(deadline);
+        } else {
+            auto next_timer = timer_queue.cbegin()->first;
+            time_left = secondsTo(std::min(next_timer, deadline));
+        }
+
+        if (time_left <= 0) {
+            log() << "Timeout passed, will not poll connections";
+            break;
+        }
+        if (!engine.run(time_left)) {
+            err_log() << "fatal engine failure";
+            do_abort = true;
+            break;
+        }
+        check_finished();
+    }
+    if (do_abort)
+        removeAllTasks();
+#ifdef USE_THREADS
+    return (!tasks.empty() || !threads.empty());
+#else
+    return (!tasks.empty());
+#endif
+}
+
+void EventLoop::runUntilComplete() {
+    while (run(1.5)) {
+        // for (auto &p : tasks)
+        //     log() << "REM: " << p.first->label();
+    }
+#ifdef USE_THREADS
+    dbg_log() << "End Loop; Threads left: " << threads.size();
+    waitForThreadsToFinish();
+#endif
+    flushLogFile();
+}
+
+#ifdef USE_THREADS
+void EventLoop::runTask(Task *task, const std::string &name,
+                        std::ostream *log_file, EventLoop *parent) {
+#else
+void EventLoop::runTask(Task *task, const std::string &name,
+                        std::ostream *log_file) {
+#endif
+    if (log_file)
+        setLogFile(*log_file);
+#ifdef USE_THREADS
+    if (task->is_child_thread)
+        parent = nullptr;
+    EventLoop loop(name, parent);
+#else
+    EventLoop loop(name);
+#endif
+    loop.addTask(task);
+    loop.runUntilComplete();
+    flushLogFile();
+}
+
+#ifdef USE_THREADS
+
+void EventLoop::spawnThread(Task *task, const std::string &name,
+                            std::ostream *log_file, Task *parent) {
+    if (parent_loop)
+        throw std::runtime_error("not in main loop");
+    if (parent)
+        threadTaskObserver.insert(std::make_pair(task, parent));
+    task->is_child_thread = true;
+
+    threads.insert(std::make_pair(task, std::thread(runTask, task, name,
+                                                    log_file, this)));
+    dbg_log() << "Added thread, now have " << threads.size();
+}
+
+MsgQueue<Task *>  EventLoop::finished_threads;
+
+void EventLoop::collect_thread(Task *t) {
+    if (parent_loop)
+        return;
+    log() << "Thread task " << t->label() << " finished";
+    auto p = threads.find(t);
+    if (p != threads.end()) {
+        p->second.join();
+        threads.erase(p);
+    }
+
+    // Notify parent?
+    auto it = threadTaskObserver.find(t);
+
+    // TODO: make sure to erase (task, parent) from
+    // threadTaskObserver if parent dies first
+    if (it != threadTaskObserver.end()) {
+        Task *parent = it->second;
+        if (tasks.find(parent) != tasks.end())
+            parent->taskFinished(t);
+        threadTaskObserver.erase(it);
+    }
+
+    delete t;
+}
+
+void EventLoop::waitForThreadsToFinish() {
+    while (!threads.empty()) {
+        dbg_log() << "Threads left: " << threads.size();
+        Task *t = finished_threads.pop_blocking();
+        collect_thread(t);
+    }
+}
+
+#endif
+
+void EventLoop::removeAllTasks() {
+    while (!tasks.empty())
+        _removeTask(tasks.begin()->first, true);
+}
+
+void EventLoop::check_finished() {
+    if (got_signal) {
+        int signum = got_signal;
+        auto p = userSignalHandler.lower_bound(signum);
+        auto to = userSignalHandler.upper_bound(signum);
+        if (p == to) {
+            // No user defined handler for signal, will abort
+#ifdef _WIN32
+            err_log() << "got signal " << signum << ", will exit";
+            abort();
+#else
+            if (signum == SIGPIPE) {
+                warn_log() << "got SIGPIPE";
+            } else if (signum == SIGHUP) {
+                Logger::reopenLogFile(openFileOnSIGHUP);
+                Logger::setLogLimit();
+                log() << "got SIGHUP";
+                killChildProcesses(signum);
+            } else if (signum == SIGTERM) {
+                err_log() << "got SIGTERM, exit immediately" << std::endl;
+                killChildProcesses(signum);
+                exit(0);
+            } else {
+                err_log() << "got signal " << signum << ", will exit";
+                killChildProcesses(signum);
+                abort();
+            }
+#endif
+        } else {
+            for (; p != to; ++p) {
+                void (*handler)(int, EventLoop &) = p->second;
+                (*handler)(got_signal, *this);
+            }
+        }
+        got_signal = 0;
+    }
+#ifndef _WIN32
+    size_t i = 0;
+    while (terminatedPIDtmp[i] && i<sizeof(terminatedPIDtmp)/sizeof(int)) {
+        int pid = terminatedPIDtmp[i], wstatus = terminatedPIDtmp[i+1];
+        log() << "PID " << pid << " finished, status=" << wstatus;
+        terminatedPIDs[pid] = wstatus;
+        terminatedPIDtmp[i] = 0;
+        i += 2;
+    }
+    while (!terminatedPIDs.empty()) {
+        auto it = terminatedPIDs.begin();
+        int pid = it->first;
+        int wstatus = it->second;
+        log() << "Terminated PID " << pid << " status " << wstatus;
+        terminatedPIDs.erase(it);
+        auto it2 = pidOwner.find(pid);
+        if (it2 != pidOwner.end()) {
+            Task *task = it2->second;
+            if (tasks.find(task) != tasks.end()) {
+                task->processFinished(pid, wstatus);
+            }
+            pidOwner.erase(it2);
+        }
+    }
+#endif
+#ifdef USE_THREADS
+    Task *t;
+    while (!threads.empty() && finished_threads.fetch(t))
+        collect_thread(t);
+#endif
+    while (!messageTasks.empty() || !finishedTasks.empty()) {
+        if (!messageTasks.empty()) {
+            auto p = tasks.find(*messageTasks.begin());
+            messageTasks.erase(messageTasks.begin());
+            if (p != tasks.end()) {
+                if (Task *parent = p->second)
+                    parent->taskMessage(p->first);
+            }
+        }
+        if (!finishedTasks.empty()) {
+            auto p = tasks.find(*finishedTasks.begin());
+            finishedTasks.erase(finishedTasks.begin());
+            if (p != tasks.end())
+                _removeTask(p->first);
+        }
+    }
+}
diff --git a/src/framework/eventloop.h b/src/framework/eventloop.h
new file mode 100644
index 0000000..4e572a4
--- /dev/null
+++ b/src/framework/eventloop.h
@@ -0,0 +1,308 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <set>
+#include <map>
+
+#include "logger.h"
+#include "engine.h"
+#ifdef USE_THREADS
+#include "msgqueue.h"
+#endif
+
+class Task;
+class SocketConnection;
+class ServerSocket;
+class WorkerProcess;
+
+/// \brief Manage timers and tasks.
+///
+/// This class manages Task objects and their timers. It also manages
+/// all network connections through an Engine object. The Engine is an
+/// "inner event loop" used to manage low-level network events.
+///
+/// Your code must create an EventLoop object, add one or more Task objects
+/// to it, and then run the event loop, either "forever" using the method
+///     EventLoop::runUntilComplete()
+/// or by regularly calling the method
+///     EventLoop::run(double timeout_s)
+class EventLoop : public Logger {
+public:
+    /// Create a new EventLoop. Normally, the application should have at most
+    /// one EventLoop in each thread.
+    EventLoop(std::string log_label = "MainLoop") :
+        Logger(log_label),
+        engine("NetworkEngine"),
+        name(log_label) {
+#ifdef USE_THREADS
+        do_init(nullptr);
+#else
+        do_init();
+#endif
+    }
+
+    ~EventLoop();
+
+    /// Add a task to be managed by the EventLoop. The value of the task
+    /// parameter must be an object of a subclass of Task. You _must_ create
+    /// the object with new; it cannot be an object on the stack.
+    /// The EventLoop will take ownership of the object and will delete it
+    /// when the task has finished. Before it is deleted, the parent's
+    /// taskFinished method will be called unless the parent is nullptr.
+    void addTask(Task *task, Task *parent = nullptr);
+
+    /// Run for at most timeout_s seconds.
+    /// Returns false if all done, otherwise true:
+    bool run(double timeout_s);
+
+    /// Run until all task are done.
+    void runUntilComplete();
+
+#ifdef USE_THREADS
+    /// Create an EventLoop object that runs the task until it's finished.
+    /// You cannot use this if you have created your own EventLoop object.
+    ///
+    /// The "parent" parameter is used if the main thread (the parent) should
+    /// be notified when the thread running the task is finished.
+    static void runTask(Task *task, const std::string &name = "MainLoop",
+                        std::ostream *log_file = nullptr,
+                        EventLoop *parent = nullptr);
+#else
+    static void runTask(Task *task, const std::string &name = "MainLoop",
+                        std::ostream *log_file = nullptr);
+#endif
+
+    /// Block current thread until all spawned threads have finished.
+    void waitForThreadsToFinish();
+
+    /// Remove the given task.
+    void abortTask(Task *task);
+
+    /// Remove all tasks.
+    void abort() {
+        interrupt();
+        do_abort = true;
+    }
+
+    /// Get all tasks with the given parent.
+    void getChildTasks(std::set<Task *> &tset, Task *parent) const;
+
+    /// Remove all tasks with the given parent.
+    void abortChildTasks(Task *parent);
+
+    /// Restart idle connections owned by the given task.
+    void wakeUpTask(Task *t);
+
+    /// Restart an idle connection.
+    bool wakeUpConnection(SocketConnection *s) {
+        return engine.wakeUpConnection(s);
+    }
+
+    /// Remove a connection.
+    void cancelConnection(SocketConnection *s) {
+        engine.cancelConnection(s);
+    }
+
+    /// Return all connetcions owned by the given task.
+    std::set<Socket *> findConnByTask(const Task *t) const;
+
+    /// Return true if conn still exists.
+    bool isActive(const Socket *conn) const {
+        return engine.connActive(conn);
+    }
+
+    /// Remove previous timer, run after s seconds instead.
+    /// If s = 0, run timer immediately. If s < 0, remove timer.
+    void resetTimer(Task *task, double s);
+
+    /// Create a new socket connection, and add it to the loop.
+    /// Returns false (and deletes conn) on failure.
+    /// On success, returns true and calls connAdded on owner task.
+    /// A connection to the server will be initiated. When connected, the
+    /// connected() method will be called on conn to get initial state.
+    bool addConnection(SocketConnection *conn);
+
+    /// Use this if conn contains a socket that has already been connected.
+    /// Returns false (and deletes conn) on failure.
+    /// On success, returns true and calls connAdded on owner task,
+    /// then calls connected() on conn to get initial state.
+    bool addConnected(SocketConnection *conn);
+
+    /// Returns false (and deletes conn) on failure.
+    /// On success, returns true and calls serverAdded on owner task.
+    bool addServer(ServerSocket *conn);
+#ifdef USE_GNUTLS
+    /// Use SSL certificate for a listening socket.
+    bool tlsSetKey(ServerSocket *conn, const std::string &crt_path,
+                   const std::string &key_path, const std::string &password) {
+        return engine.tlsSetKey(conn, crt_path, key_path, password);
+    }
+
+    /// Set path to file containing chain of trust for SSL certificate.
+    bool setCABundle(const std::string &path) {
+        return engine.setCABundle(path);
+    }
+#endif
+
+    /// Return true if task is running.
+    bool running(Task *task);
+
+    /// \brief
+    /// Notify EventLoop that a task object it ows has been deleted.
+    ///
+    /// This is just a safeguard against buggy clients.
+    /// Only the EventLoop is allowed to delete tasks is owns.
+    void taskDeleted(Task *task);
+
+    /// Call this to make the network engine yield control
+    /// to me (the task supervisor).
+    static void interrupt() {
+        Engine::yield();
+    }
+
+#ifdef USE_THREADS
+    /// Create a new thread and run task in its own loop in that thread.
+    void spawnThread(Task *task, const std::string &name="ThreadLoop",
+                     std::ostream *log_file = nullptr,
+                     Task *parent = nullptr);
+#endif
+#ifdef _WIN32
+    int externalCommand(Task *owner, const char *const argv[]) {
+        // Not implemented
+        exit(1);
+    }
+#else
+    /// Asynchronously execute an external command.
+    /// Return false on immediate failure.
+    int externalCommand(Task *owner, const char *const argv[]);
+
+    /// Fork into background, detach from shell.
+    static void daemonize();
+
+    /// Create a child process. Return child's PID. Channels can be
+    /// used to pass sockets and messages between parent and child.
+    WorkerProcess *createWorker(Task *parent, std::ostream *log_file,
+                                unsigned int channels, unsigned int wno);
+
+    /// Create a child process. Return child's PID. Channels can be
+    /// used to pass sockets and messages between parent and child.
+    WorkerProcess *createWorker(Task *parent, const std::string &log_file_name,
+                                unsigned int channels, unsigned int wno);
+
+    /// Send signal to all child processes
+    void killChildProcesses(int signum);
+
+    /// \brief
+    /// Set path to log file.
+    ///
+    /// The new log file will be activated upon receiving
+    /// the SIGHUP signal.
+    static void setLogFilename(const std::string &filename) {
+        openFileOnSIGHUP = filename;
+    }
+#endif
+
+    /// \brief
+    /// Mark the given task as finished.
+    ///
+    /// Don't call this method directly. Use Task::setResult instead.
+    void notifyTaskFinished(Task *task) {
+        auto ret = finishedTasks.insert(task);
+        if (ret.second)
+            engine.yield();
+    }
+
+    /// \brief
+    /// Notify the EventLoop that the given task has a message to deliver.
+    ///
+    /// Don't call this method directly. Use Task::setMessage instead.
+    void notifyTaskMessage(Task *task) {
+        auto ret = messageTasks.insert(task);
+        if (ret.second)
+            engine.yield();
+    }
+
+    /// Return true if the EventLoop is about to be terminated.
+    bool aborted() const {
+        return do_abort;
+    }
+
+    /// Add handler for the given OS signal.
+    void addSignalHandler(int signum, void (*handler)(int, EventLoop &));
+
+    /// Enable events from task "from" to task "to". I.e. "from" will be able to
+    /// call executeHandler with "to" as a parameter. If  "to" dies before
+    /// "from", "from" will be notified through a call to taskFinished.
+    /// Will return false unless both tasks still exist.
+    bool startObserving(Task *from, Task *to);
+
+    /// Return true if observer is observing task.
+    bool isObserving(Task *observer, Task *task) const {
+        auto p = observed_by.find(observer);
+        return p != observed_by.end() &&
+            p->second.find(task) != p->second.end();
+    }
+
+private:
+#ifndef _WIN32
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static std::map<int, int> terminatedPIDs;
+    std::map<int, Task *> pidOwner;
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static std::string openFileOnSIGHUP;
+#endif
+#ifdef USE_THREADS
+    void do_init(EventLoop *parent);
+
+    EventLoop(std::string log_label, EventLoop *parent) :
+        Logger(log_label),
+        engine("NetworkEngine"),
+        name(log_label) {
+        do_init(parent);
+    }
+    std::map<Task *, std::thread> threads;
+    static MsgQueue<Task *> finished_threads;
+    std::map<Task *, Task *> threadTaskObserver;
+    void collect_thread(Task *t);
+    EventLoop *parent_loop;
+#else
+    void do_init();
+#endif
+
+#ifdef USE_THREADS
+    //thread_local
+#endif
+    static volatile int got_signal;
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static volatile int terminatedPIDtmp[100];
+
+    static void signalHandler(int signum);
+    void removeAllTasks();
+    void check_finished();
+    Task *nextTimerToExecute();
+    void _removeTimer(Task *task);
+    void _removeTask(Task *task, bool killed = false);
+    Engine engine;
+
+    // Map each task to its parent (or, if it has no parent, to nullptr)
+    std::map<Task *, Task *> tasks;
+
+    // These are used to keep track of "observation" between tasks.
+    // E.g. a parent task is observing its children.
+    std::map<Task *, std::set<Task *> > observed_by;
+    std::map<Task *, std::set<Task *> > observing;
+
+    std::set<Task *> finishedTasks, messageTasks;
+    std::multimap<int, void (*)(int, EventLoop &)> userSignalHandler;
+    std::multimap<TimePoint, Task *> timer_queue;
+    std::string name;
+    bool do_abort = false;
+};
diff --git a/src/framework/loadbalancer.cpp b/src/framework/loadbalancer.cpp
new file mode 100644
index 0000000..41ac703
--- /dev/null
+++ b/src/framework/loadbalancer.cpp
@@ -0,0 +1,161 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <signal.h>
+#include "loadbalancer.h"
+#include "socketreceiver.h"
+#include "workerprocess.h"
+
+LoadBalancer::LoadBalancer(const TaskConfig &tc) :
+    Task("LoadBalancer"), my_config(tc) {
+    try {
+        tot_no_workers = std::stoul(my_config.value("workers"));
+    } catch (...) {
+        tot_no_workers = 0;
+    }
+    auto range = tc.cfg().equal_range("workercfg");
+    for (auto p=range.first; p!=range.second; ++p)
+        (worker_config += p->second) += "\n";
+}
+
+LoadBalancer::~LoadBalancer() {
+    for (WorkerProcess *wp : worker_proc)
+        if (wp)
+            delete wp;
+}
+
+#ifdef USE_GNUTLS
+bool LoadBalancer::tlsSetKey(ServerSocket *conn, const std::string &crt_path,
+                             const std::string &key_path,
+                             const std::string &password) {
+    portMap[conn] = no_channels;
+    worker_config += "channel" + std::to_string(no_channels) + " tls " +
+        crt_path + " " + key_path + " " + password + "\n";
+    ++no_channels;
+    return true;
+}
+#endif
+
+double LoadBalancer::start() {
+    if (!tot_no_workers) {
+        setError("Internal error, no workers");
+        return 0.0;
+    }
+
+    worker_proc.resize(tot_no_workers);
+    worker_proc_health.resize(tot_no_workers);
+    if (parseListen(my_config, "LoadBalancerSocket")) {
+        for (size_t i=0; i<tot_no_workers; ++i)
+            new_worker(i);
+    } else {
+        setResult("Failed, cannot start server");
+    }
+    return 0.0;
+}
+
+SocketConnection *LoadBalancer::newClient(int fd, const char *, uint16_t,
+                                          ServerSocket *srv) {
+    doPass(fd, nextWorker(), srv);
+    rotateNextWorker();
+    return nullptr;
+}
+
+void LoadBalancer::serverRemoved(ServerSocket *s) {
+    log() << "Server removed socket " << s;
+    if (SocketReceiver *conn = dynamic_cast<SocketReceiver *>(s)) {
+        if (pid_t peer = conn->peerPid()) {
+            removeWorker(peer);
+            log() << "Kill process " << peer;
+            kill(peer, SIGKILL);
+        }
+    } else {
+        log() << "Not a receiver";
+    }
+}
+
+#ifdef USE_GNUTLS
+void LoadBalancer::doPass(int fd, size_t wid, ServerSocket *srv) {
+#else
+void LoadBalancer::doPass(int fd, size_t wid, ServerSocket *) {
+#endif
+    if (wid >= worker_proc.size() || !worker_proc[wid]) {
+        err_log() << "Worker " << wid << " dead, dropping socket " << fd;
+        return;
+    }
+#ifdef USE_GNUTLS
+    unsigned int ch = portMap.find(srv) != portMap.end() ? portMap[srv] : 0;
+#else
+    unsigned int ch = 0;
+#endif
+    SocketReceiver *channel = worker_proc[wid]->channel(ch);
+    dbg_log() << "New connection fd=" << fd << " pass to worker " << wid;
+    int ret = channel->passSocketToPeer(fd);
+    if (!ret) {
+        worker_proc_health[wid] = TimePoint();
+    } else if (ret == EAGAIN) {
+        // The peer might be broken. Or we have a burst of new connections.
+        // If the peer stays broken for more than 5 seconds, we'll kill it.
+        if (worker_proc_health[wid] == TimePoint()) {
+            warn_log() << "Worker " << wid << " not responding, give it 5s to recover.";
+            worker_proc_health[wid] = timeNow();
+        } else if (secondsSince(worker_proc_health[wid]) > 5) {
+            err_log() << "job queue full, worker " << wid << " will be restarted";
+            removeWorker(worker_proc[wid]->pid());
+            worker_proc_health[wid] = TimePoint();
+        } else {
+            err_log() << "worker " << wid << " busy, cannot pass socket";
+        }
+    } else {
+        err_log() << "cannot pass socket to worker " << wid << " " << strerror(ret);
+    }
+}
+
+void LoadBalancer::processFinished(int pid, int wstatus) {
+    log() << "End of PID " << pid << ", status " << wstatus;
+    removeWorker(pid);
+}
+
+void LoadBalancer::new_worker(size_t i) {
+    if (worker_proc[i]) {
+        delete worker_proc[i];
+        worker_proc[i] = nullptr;
+    }
+
+    if (terminated())
+        return;
+
+    std::string logfilename = my_config.value("workerlog");
+    if (logfilename.empty()) {
+        worker_proc[i] = createWorker(nullptr, no_channels,
+                                      static_cast<unsigned int>(i));
+    } else {
+        // In logfilename, replace all %d with worker number (i.e. i),
+        // adjusting to fixed width by filling with zeroes.
+        auto len = std::to_string(tot_no_workers).size();
+        auto wno = std::to_string(i);
+        wno = std::string(len-wno.size(), '0') + wno;
+        while (true) {
+            auto pos = logfilename.find("%d");
+            if (pos == std::string::npos)
+                break;
+            logfilename.replace(pos, 2, wno);
+        }
+        worker_proc[i] = createWorker(logfilename, no_channels,
+                                      static_cast<unsigned int>(i));
+    }
+    if (worker_proc[i])
+        log() << "Created worker " << i << ", pid: " << worker_proc[i]->pid();
+}
+
+void LoadBalancer::removeWorker(pid_t pid) {
+    for (size_t i=0; i<worker_proc.size(); ++i)
+        if (worker_proc[i] && worker_proc[i]->pid() == pid) {
+            if (max_retries) {
+                --max_retries;
+            } else {
+                setResult("Too many failures");
+            }
+            new_worker(i);
+            break;
+        }
+}
diff --git a/src/framework/loadbalancer.h b/src/framework/loadbalancer.h
new file mode 100644
index 0000000..ca08dd4
--- /dev/null
+++ b/src/framework/loadbalancer.h
@@ -0,0 +1,78 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include "task.h"
+#include "socketreceiver.h"
+#include "workerprocess.h"
+
+/// \brief
+/// Create worker (child) processes, and pass new connections
+/// evenly among them.
+///
+/// New clients are passed to the worker processes using a round-robin
+/// algorithm. Override the Task::newClient method to use a more
+/// sophisticated algorithm.
+class LoadBalancer : public Task {
+public:
+
+    LoadBalancer(const TaskConfig &tc);
+
+    ~LoadBalancer() override;
+
+    SocketConnection *newClient(int fd, const char *, uint16_t,
+                                ServerSocket *) override;
+
+    double start() override;
+#ifdef USE_GNUTLS
+    bool tlsSetKey(ServerSocket *conn, const std::string &crt_path,
+                   const std::string &key_path,
+                   const std::string &password) override;
+#endif
+    void serverRemoved(ServerSocket *s) override;
+    void processFinished(int pid, int wstatus) override;
+protected:
+    /// Return a worker number.
+    size_t nextWorker() const {
+        return next_worker;
+    }
+
+    /// Move on to next worker (in a round-robin fashion) for
+    /// LoadBalancer::nextWorker.
+    void rotateNextWorker() {
+        if (++next_worker >= worker_proc.size())
+            next_worker = 0;
+    }
+
+    /// Pass a connection to a worker process.
+    void doPass(int fd, size_t wid, ServerSocket *srv);
+
+    /// Create a new worker process.
+    void new_worker(size_t i);
+
+    /// Remove a worker process.
+    void removeWorker(pid_t pid);
+
+    /// Return configuration of a worker process.
+    std::string workerConfig(unsigned int i=0) const {
+        return worker_config + "\nworker_number " + std::to_string(i);
+    }
+
+    /// Max number of times to restart failed worker processes.
+    void setMaxRetries(unsigned int n) {
+        max_retries = n;
+    }
+private:
+#ifdef USE_GNUTLS
+    std::map<ServerSocket *, unsigned int> portMap;
+#endif
+    unsigned int max_retries = 100;
+    unsigned int no_channels = 1;
+    std::vector<WorkerProcess *> worker_proc;
+    std::vector<TimePoint> worker_proc_health;
+    size_t next_worker = 0;
+    TaskConfig my_config;
+    std::string worker_config;
+    size_t tot_no_workers;
+};
diff --git a/src/framework/logger.cpp b/src/framework/logger.cpp
new file mode 100644
index 0000000..3375647
--- /dev/null
+++ b/src/framework/logger.cpp
@@ -0,0 +1,179 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <iostream>
+#include <fstream>
+
+#include "logger.h"
+#include <iomanip>
+#include <chrono>
+#include <random>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#endif
+
+double Logger::secondsSince(const TimePoint &t) {
+    auto now = timeNow();
+    std::chrono::duration<double> d = now - t;
+    return d.count();
+}
+
+double Logger::secondsTo(const TimePoint &t) {
+    auto now = timeNow();
+    std::chrono::duration<double> d = t - now;
+    return d.count();
+}
+
+int64_t Logger::msSince(const TimePoint &t) {
+    auto now = timeNow();
+    return std::chrono::duration_cast<std::chrono::milliseconds>
+        (now - t).count();
+}
+
+int64_t Logger::msTo(const TimePoint &t) {
+    auto now = timeNow();
+    return std::chrono::duration_cast<std::chrono::milliseconds>
+        (t - now).count();
+}
+
+std::string Logger::dateString(time_t t) {
+    // put_time might not be available in older libs.
+    char dstr[200];
+    if (!t)
+        t = time(nullptr);
+    struct tm *dtm = localtime(&t);
+    size_t len = strftime(dstr, sizeof(dstr), "%FT%T%z", dtm);
+    return std::string(dstr, len);
+}
+
+std::string Logger::dateString2(time_t t) {
+    // put_time might not be available in older libs.
+    char dstr[200];
+    if (!t)
+        t = time(nullptr);
+    struct tm *dtm = localtime(&t);
+    size_t len = strftime(dstr, sizeof(dstr), "%a, %d %b %Y %H:%M:%S", dtm);
+    return std::string(dstr, len);
+}
+
+std::string Logger::createHashKey(unsigned int length) {
+    std::random_device rng;
+    std::ostringstream s;
+    std::uniform_int_distribution<unsigned short> dist;
+    while (s.str().size() < length)
+        s << std::setw(sizeof(unsigned short)*2) << std::uppercase
+          << std::hex << std::setfill('0') << dist(rng);
+    return s.str();
+}
+
+#ifdef USE_THREADS
+thread_local
+#endif
+bool Logger::in_error = false;
+#ifdef USE_THREADS
+thread_local
+#endif
+TimePoint Logger::global_start_time(timeNow());
+#ifdef USE_THREADS
+thread_local
+#endif
+std::ostream *Logger::_logFile = &std::cerr;
+#ifdef USE_THREADS
+thread_local
+#endif
+unsigned int Logger::log_count = 100000;
+#ifdef USE_THREADS
+thread_local
+#endif
+unsigned int Logger::warn_count = 10000;
+#ifdef USE_THREADS
+thread_local
+#endif
+unsigned int Logger::err_count = 10000;
+#ifdef USE_THREADS
+thread_local
+#endif
+unsigned int Logger::log_count_saved = 100000;
+#ifdef USE_THREADS
+thread_local
+#endif
+unsigned int Logger::warn_count_saved = 10000;
+#ifdef USE_THREADS
+thread_local
+#endif
+unsigned int Logger::err_count_saved = 10000;
+
+DummyStream Logger::_dummyLog;
+
+#ifdef USE_THREADS
+thread_local
+#endif
+std::ostringstream Logger::_blackHole;
+
+DummyStream::~DummyStream() {
+}
+
+void Logger::setLogLimit(unsigned int loglines, unsigned int warnlines,
+                         unsigned int errlines) {
+    if (loglines)
+        log_count_saved = loglines;
+    if (warnlines)
+        warn_count_saved = warnlines;
+    if (errlines)
+        err_count_saved = errlines;
+
+    log_count = log_count_saved;
+    warn_count = warn_count_saved;
+    err_count = err_count_saved;
+}
+
+void Logger::sayTime(std::ostream &stream) {
+    std::time_t t = std::time(nullptr);
+    std::tm *tm = std::localtime(&t);
+    stream << tm->tm_year+1900 << '-'
+           << std::setfill('0') << std::setw(2) << tm->tm_mon+1 << '-'
+           << std::setfill('0') << std::setw(2) << tm->tm_mday << ' '
+           << std::setfill('0') << std::setw(2) << tm->tm_hour << ':'
+           << std::setfill('0') << std::setw(2) << tm->tm_min << ':'
+           << std::setfill('0') << std::setw(2) << tm->tm_sec;
+}
+
+#ifdef TASKRUNNER_LOGERR
+std::ostream &Logger::errno_log() const {
+    if (err_count) {
+        in_error = true;
+        --err_count;
+        *_logFile << "\n" << global_elapsed_ms() << ' ' << _label << "*** "
+                  << (err_count ? "ERROR ***: " :  "LAST ERR ***: ")
+#ifdef _WIN32
+                  << std::to_string(WSAGetLastError())
+#else
+                  << strerror(errno)
+#endif
+                  << ": ";
+        return *_logFile;
+    } else {
+        return _blackHole;
+    }
+}
+#else
+DummyStream &Logger::errno_log() const {
+    return _dummyLog;
+}
+#endif
+
+void Logger::setLogFile(std::ostream &stream) {
+    _logFile = &stream;
+    in_error = false;
+    global_start_time = timeNow();
+    sayTime(stream);
+}
+
+void Logger::reopenLogFile(const std::string &filename) {
+    if (std::ofstream *the_log = dynamic_cast<std::ofstream *>(_logFile)) {
+        *the_log << "\n";
+        the_log->close();
+        the_log->open(filename, std::ios::app);
+    }
+}
diff --git a/src/framework/logger.h b/src/framework/logger.h
new file mode 100644
index 0000000..dbca61a
--- /dev/null
+++ b/src/framework/logger.h
@@ -0,0 +1,382 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#ifdef _WIN32
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#ifdef max
+#undef max
+#endif
+#else
+#include <string.h>
+#endif
+
+#ifndef DEBUG
+#define DEBUG 0
+#endif
+#ifndef TARGET_OS_IPHONE
+#define TARGET_OS_IPHONE 0
+#endif
+
+#include <iostream>
+#include <sstream>
+#include <chrono>
+#include <thread>
+
+#ifdef __ANDROID_API__
+#include <android/log.h>
+#endif
+
+/// This class is used to optionally disable logging operations at compile time.
+class DummyStream {
+public:
+    /// Do nothing, emulating the << stream operator.
+    template<class T>
+    DummyStream &operator<<(T ) { return *this; }
+#ifdef __ANDROID_API__
+    DummyStream &operator<<(const char *s) {
+        __android_log_print(ANDROID_LOG_VERBOSE, "BBK", "%s", s);
+        return *this; }
+    DummyStream &operator<<(std::string s) {
+        __android_log_print(ANDROID_LOG_VERBOSE, "BBK", "%s", s.c_str());
+        return *this; }
+    DummyStream &operator<<(int i) {
+        __android_log_print(ANDROID_LOG_VERBOSE, "BBK", "%d", i);
+        return *this; }
+    DummyStream &operator<<(double x) {
+        __android_log_print(ANDROID_LOG_VERBOSE, "BBK", "%f", x);
+        return *this; }
+#endif
+    /// Do nothing, emulating the << stream operator.
+    DummyStream& operator<<(std::ostream &(*)(std::ostream &) ) {
+        return *this;
+    }
+    virtual ~DummyStream();
+private:
+};
+
+/// \class TimePoint
+/// \brief
+/// Measure elapsed time during execution,
+/// for example by timer events.
+///
+/// It is simply a typedef to std::chrono::steady_clock::time_point.
+///
+/// Example:
+///
+///     TimePoint start = Logger::timeNow();
+///     // Do stuff...
+///     std::cout << Logger::secondsSince(start) << " seconds have elapsed.";
+///     // 2.00042 seconds have elapsed.
+typedef std::chrono::steady_clock::time_point TimePoint;
+
+/// \brief
+/// A simple logger. All classes that want to write to the global log
+/// file should inherit from this class.
+///
+/// By default, logs will be written to cerr. To log elsewhere, you must
+/// call the static function Logger::setLogFile with a stream object (e.g. an
+/// std::ofstream or an std::ostringstream) which the logs will be written to.
+/// The stream will be used globally. You must make sure the global stream
+/// is never destroyed, at least not before Logger::setLogFile has been called
+/// with another stream.
+class Logger {
+public:
+    /// Each object of the Logger class (or its subclasses) have a log label,
+    /// which will often be thought of as the name of the object.
+    Logger(std::string label) :
+        _label(label) {
+        // TODO: single initialisation
+        _blackHole.clear(std::istream::eofbit);
+    }
+
+    /// \brief Set global log destination.
+    ///
+    /// The given stream will be the destination of all subsequent log calls
+    /// globally. You must make sure the global stream never is destroyed, at
+    /// least not until Logger::setLogFile is called with another stream.
+    static void setLogFile(std::ostream &stream);
+
+    /// If current log is a file (ofstream), reopen it with new filename:
+    static void reopenLogFile(const std::string &filename);
+
+    /// \brief Set max number of lines of info/warn/err log.
+    ///
+    /// If 0, reset to previous (non-zero) max number of lines.
+    /// After the limit has been reached, no more lines for that log level
+    /// will be printed until the limit has been reset.
+    static void setLogLimit(unsigned int loglines = 0,
+                            unsigned int warnlines = 0,
+                            unsigned int errlines = 0);
+
+    /// Write current local time to the given stream
+    static void sayTime(std::ostream &stream);
+
+    /// Return true if any error has been logged (globally since start)
+    static bool inError() {
+        return in_error;
+    }
+
+    /// \brief Write a line of error log.
+    ///
+    /// Access the current global error log stream. A line feed and a preamble
+    /// will be written to the stream. Then send whetever you want to the log
+    /// stream using the standard std::ostream API.
+    ///
+    /// In non-static members of subclasses to Logger, the method
+    /// Logger::err_log() should be used instead of this function.
+    static std::ostream &err_log(const std::string &label) {
+        if (err_count) {
+            in_error = true;
+            --err_count;
+            *_logFile << "\n" << global_elapsed_ms() << ' ' << label << " *** "
+                      << (err_count ? "ERROR ***: " :  "LAST ERR ***: ");
+            return *_logFile;
+        } else {
+            return _blackHole;
+        }
+    }
+
+    /// \brief Write a line of warning log.
+    ///
+    /// Access the current global warning log stream. A line feed and a preamble
+    /// will be written to the stream. Then send whetever you want to the log
+    /// stream using the standard std::ostream API.
+    ///
+    /// In non-static members of subclasses to Logger, the method
+    /// Logger::warn_log() should be used instead of this function.
+    static std::ostream &warn_log(const std::string &label) {
+        if (warn_count) {
+            --warn_count;
+            *_logFile << "\n" << global_elapsed_ms() << ' ' << label << " *** "
+                      << (warn_count ? "WARNING ***: " : "LAST WARN ***: ");
+            return *_logFile;
+        } else {
+            return _blackHole;
+        }
+    }
+
+    /// \brief Write a line of info log.
+    ///
+    /// Access the current global info log stream. A line feed and a preamble
+    /// will be written to the stream. Then send whetever you want to the log
+    /// stream using the standard std::ostream API.
+    ///
+    /// In non-static members of subclasses to Logger, the method
+    /// Logger::warn_log() should be used instead of this function.
+    static std::ostream &log(const std::string &label) {
+        if (log_count) {
+            --log_count;
+            *_logFile << "\n" << global_elapsed_ms() << ' ' << label << ": ";
+            if (!log_count)
+                *_logFile << "LAST LOG: ";
+            return *_logFile;
+        } else {
+            return _blackHole;
+        }
+    }
+
+    /// Anything written to the global log may be buffered for quite some time,
+    /// and thus not visible in the destination file. This method will flush
+    /// the buffer and write an extra empty line.
+    ///
+    /// Calling this often may be bad for performance.
+    static void flushLogFile() {
+        *_logFile << std::endl;
+    }
+
+    /// Disable all log output until next call to Logger::setLogFile.
+    static void pauseLogging() {
+        _logFile = &_blackHole;
+    }
+
+    /// Return number of seconds since the given TimePoint.
+    /// The returned value might be negative.
+    static double secondsSince(const TimePoint &t);
+
+    /// Return number of seconds until the given TimePoint.
+    /// The returned value might be negative.
+    static double secondsTo(const TimePoint &t);
+
+    /// Return number of milliseconds since the given TimePoint.
+    /// The returned value might be negative.
+    static int64_t msSince(const TimePoint &t);
+
+    /// Return number of milliseconds until the given TimePoint.
+    /// The returned value might be negative.
+    static int64_t msTo(const TimePoint &t);
+
+    /// Return true if current time is after the given TimePoint.
+    static bool hasExpired(const TimePoint &t) {
+        return secondsSince(t) >= 0;
+    }
+
+    /// Return current time.
+    static TimePoint timeNow() {
+        return std::chrono::steady_clock::now();
+    }
+
+    /// Return current time plus s seconds.
+    static TimePoint timeAfter(double s) {
+        return timeNow() + std::chrono::microseconds(toUs(s));
+    }
+
+    /// Return a very distant time.
+    static TimePoint timeMax() {
+        return TimePoint::max();
+    }
+
+    /// Convert s (seconds) to std::chrono::microseconds
+    static std::chrono::microseconds toUs(double t) {
+        auto us = static_cast<std::chrono::microseconds::rep>(1e6*t);
+	return std::chrono::microseconds(us);
+    }
+
+    /// Return local time, formatted as 2023-10-14T09:38:47+0200
+    static std::string dateString(time_t t = 0);
+
+    /// Return local time, formatted as Sat, 14 Oct 2023 09:38:47
+    static std::string dateString2(time_t t = 0);
+
+    /// \brief Return a random string.
+    ///
+    /// Create string of length random hex chars from system's random number
+    /// generator. The length should be a multiple of 4.
+    static std::string createHashKey(unsigned int length = 20);
+
+    /// Return the object's log label.
+    std::string label() const {
+        return _label;
+    }
+
+    /// Modify the object's log label
+    void resetLabel(const std::string &new_label) {
+        _label = new_label;
+    }
+
+protected:
+
+#if DEBUG
+#define TASKRUNNER_LOGERR
+#define TASKRUNNER_LOGWARN
+#define TASKRUNNER_LOGINFO
+#define TASKRUNNER_LOGBDG
+#endif
+
+#ifdef TASKRUNNER_LOGERR
+    /// \brief Write a line of error log after a failed system call
+    /// has set the global errno to a non-zero value.
+    ///
+    /// Access the current global error log stream. A line feed and a preamble,
+    /// including the latest OS error, will be written to the stream.
+    ///
+    /// *Note!* The global error stream will be "disabled" (i.e. set to a dummy stream)
+    /// unless compiler macro TASKRUNNER_LOGERR is defined.
+    std::ostream &errno_log() const;
+
+    /// \brief Write a line of error log.
+    ///
+    /// Access the current global error log stream. A line feed and a preamble
+    /// will be written to the stream. Then send whetever you want to the log
+    /// stream using the standard std::ostream API.
+    ///
+    /// *Note!* The global error log stream will be "disabled" (i.e. set to a
+    /// dummy stream) unless compiler macro TASKRUNNER_LOGERR is defined.
+    ///
+    /// May be used in any non-static member of any subclass. Example:
+    ///
+    ///     err_log() << "Child task " << t->label() << " failed.";
+    std::ostream &err_log() const {
+        return err_log(_label);
+    }
+#else
+    DummyStream &errno_log() const;
+    static DummyStream &err_log() {
+        return _dummyLog;
+    }
+#endif
+
+#ifdef TASKRUNNER_LOGWARN
+    /// \brief Write a line of warning log.
+    ///
+    /// Access the current global warning log stream. A line feed and a
+    /// preamble will be written to the stream. Then send whetever you want to
+    /// the log stream using the standard std::ostream API.
+    ///
+    /// *Note!* The global warning log stream will be "disabled" (i.e. set to a
+    /// dummy stream) unless compiler macro TASKRUNNER_LOGWARN is defined.
+    std::ostream &warn_log() const {
+        return warn_log(_label);
+    }
+#else
+    static DummyStream &warn_log() {
+        return _dummyLog;
+    }
+#endif
+#ifdef TASKRUNNER_LOGINFO
+    /// \brief Write a line of info log.
+    ///
+    /// Access the current global info log stream. A line feed and a preamble
+    /// will be written to the stream. Then send whetever you want to the log
+    /// stream using the standard std::ostream API.
+    ///
+    /// *Note!* The global info log stream will be "disabled" (i.e. set to a
+    /// dummy stream) unless compiler macro TASKRUNNER_LOGINFO is defined.
+    std::ostream &log() const {
+        return log(_label);
+    }
+#else
+    static DummyStream &log() {
+        return _dummyLog;
+    }
+#endif
+#ifdef TASKRUNNER_LOGDBG
+    /// \brief Write a line of debug log.
+    ///
+    /// Access the current global debug log stream. A line feed and a preamble
+    /// will be written to the stream. Then send whetever you want to the log
+    /// stream using the standard std::ostream API.
+    ///
+    /// *Note!* The global debug log stream will be "disabled" (i.e. set to a
+    /// dummy stream) unless compiler macro TASKRUNNER_LOGDBG is defined.
+    std::ostream &dbg_log() const {
+        *_logFile << "\n" << global_elapsed_ms() << ' ' << _label << ": ";
+        return *_logFile;
+    }
+#else
+    static DummyStream &dbg_log() {
+        return _dummyLog;
+    }
+#endif
+private:
+    static int64_t global_elapsed_ms() {
+        return msSince(global_start_time);
+    }
+    std::string _label;
+
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static bool in_error;
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static TimePoint global_start_time;
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static std::ostream *_logFile;
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static std::ostringstream _blackHole;
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static unsigned int log_count, warn_count, err_count,
+                        log_count_saved, warn_count_saved, err_count_saved;
+    static DummyStream _dummyLog;
+};
diff --git a/src/framework/mk.inc b/src/framework/mk.inc
new file mode 100644
index 0000000..2819fd7
--- /dev/null
+++ b/src/framework/mk.inc
@@ -0,0 +1,140 @@
+ALL += $(TARGET) $(PROGRAMS)
+
+all: $(ALL)
+
+OS:=$(shell uname)
+
+CXXFLAGS += -O2 -W -Wall -I$(DIRLEVEL)
+
+GLIB_COMPILE_RESOURCES = glib-compile-resources
+
+ifeq ($(OS),Linux)
+CXX = g++
+endif
+
+ifeq ($(OS),Darwin)
+CXX = c++
+CXXFLAGS += -x objective-c++
+LIBS += -framework Foundation -framework ApplicationServices
+endif
+
+ifeq ($(OS),OpenBSD)
+#CXX = ec++
+CXX = clang++
+endif
+
+ifeq ($(OS),FreeBSD)
+CXX = c++
+endif
+
+ifeq ($(OS),NetBSD)
+CXX = clang++
+CXXFLAGS += -I/usr/pkg/include
+LIBS += -Wl,-R/usr/pkg/lib -L/usr/pkg/lib
+endif
+
+CXXFLAGS += -std=c++14
+
+LINK ?= $(CXX)
+
+ifeq ($(STATIC),1)
+LDFLAGS += -static-libstdc++
+endif
+
+ifeq ($(STATIC),2)
+LDFLAGS += -static -static-libstdc++
+endif
+
+ifneq ($(findstring clang,$(CXX)),)
+CXXFLAGS += -Weverything -Wno-c++98-compat -Wno-exit-time-destructors \
+	 -Wno-global-constructors -Wno-padded -Wno-disabled-macro-expansion \
+	 -Wno-float-equal
+endif
+
+ifeq ($(CXX),g++)
+CXXFLAGS += --pedantic -Wextra
+endif
+
+ifeq ($(GNUTLS),1)
+CXXFLAGS += -DUSE_GNUTLS -I/usr/local/include
+LIBS += -L/usr/local/lib -lgnutls
+endif
+ifeq ($(THREADS),1)
+CXXFLAGS += -DUSE_THREADS
+LIBS += -pthread
+endif
+ifeq ($(LOGLEVEL),)
+LOGLEVEL=info
+endif
+ifeq ($(LOGLEVEL),err)
+CXXFLAGS += -DTASKRUNNER_LOGERR
+endif
+ifeq ($(LOGLEVEL),warn)
+CXXFLAGS += -DTASKRUNNER_LOGWARN -DTASKRUNNER_LOGERR
+endif
+ifeq ($(LOGLEVEL),info)
+CXXFLAGS += -DTASKRUNNER_LOGERR -DTASKRUNNER_LOGWARN -DTASKRUNNER_LOGINFO
+endif
+ifeq ($(LOGLEVEL),dbg)
+CXXFLAGS += -DTASKRUNNER_LOGERR -DTASKRUNNER_LOGWARN
+CXXFLAGS += -DTASKRUNNER_LOGINFO -DTASKRUNNER_LOGDBG
+endif
+ifeq ($(SANDBOXED),1)
+CXXFLAGS += -DIS_SANDBOXED
+endif
+
+SOURCES += \
+	$(DIRLEVEL)/framework/task.cpp \
+	$(DIRLEVEL)/framework/taskconfig.cpp \
+	$(DIRLEVEL)/framework/engine.cpp \
+	$(DIRLEVEL)/framework/eventloop.cpp \
+	$(DIRLEVEL)/framework/socket.cpp \
+	$(DIRLEVEL)/framework/socketconnection.cpp \
+	$(DIRLEVEL)/framework/serversocket.cpp \
+	$(DIRLEVEL)/framework/socketreceiver.cpp \
+	$(DIRLEVEL)/framework/logger.cpp \
+	$(DIRLEVEL)/framework/bridgetask.cpp \
+	$(DIRLEVEL)/framework/synchronousbridge.cpp \
+	$(DIRLEVEL)/json11/json11.cpp
+
+OPT_SOURCES += \
+	$(DIRLEVEL)/framework/shortmessageconnection.cpp \
+	$(DIRLEVEL)/framework/threadbridge.cpp \
+	$(DIRLEVEL)/framework/unixdomainbridge.cpp \
+	$(DIRLEVEL)/framework/unixdomainclient.cpp \
+	$(DIRLEVEL)/framework/loadbalancer.cpp
+
+OBJ=$(SOURCES:.cpp=.o)
+EXTRA_OBJ=$(EXTRA_SOURCES:.cpp=.o)
+OPT_OBJ=$(OPT_SOURCES:.cpp=.o)
+RC_OBJ=$(RC_SOURCES:.rc.xml=.rc.o)
+RC_DEPS=$(RC_SOURCES:.rc.xml=.rc_d)
+RC_DEPS+=$(RC_SOURCES:.rc.xml=.rc.d)
+RC_INTERMEDIATE+=$(RC_SOURCES:.rc.xml=.rc.cpp)
+
+%.d: %.cpp
+	$(CXX) -MM $(CXXFLAGS) -MT $(@:.d=.o) $< > $@
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+%.rc_d: %.rc.xml
+	$(GLIB_COMPILE_RESOURCES) --generate-dependencies --dependency-file=$@ $<
+
+%.rc.cpp: %.rc.xml
+	$(GLIB_COMPILE_RESOURCES) --generate-source $< --target=$@
+
+$(TARGET): $(OBJ) $(RC_OBJ)
+	$(CXX) $(LDFLAGS) -o $@ $^ $(LIBS)
+
+$(PROGRAMS):
+	$(CXX) $(LDFLAGS) -o $@ $^ $(LIBS)
+
+ifneq ($(MAKECMDGOALS),clean)
+include $(SOURCES:.cpp=.d) $(RC_DEPS) $(EXTRA_SOURCES:.cpp=.d)
+endif
+
+clean:
+	$(RM) $(CLEAN) $(TARGET) $(OBJ) $(OPT_OBJ) $(EXTRA_OBJ) *~ \
+	  $(SOURCES:.cpp=.d) $(EXTRA_SOURCES:.cpp=.d) \
+	  $(RC_OBJ) $(RC_DEPS) $(RC_INTERMEDIATE) $(PROGRAMS)
diff --git a/src/framework/msgqueue.h b/src/framework/msgqueue.h
new file mode 100644
index 0000000..7a88347
--- /dev/null
+++ b/src/framework/msgqueue.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <queue>
+#include <mutex>
+#include <condition_variable>
+
+/// \brief
+/// Thread safe queue.
+///
+/// By design, there is no method named `pop`.
+/// To retrieve an object from the queue, you must
+/// use either the non-blocking MsgQueue::fetch
+/// or the blocking MsgQueue::pop_blocking method.
+template <class T>
+class MsgQueue {
+public:
+    MsgQueue() :
+        queue(),
+        mutex(),
+        cond() {
+    }
+
+    ~MsgQueue() {
+    }
+
+    /// Add object at the end of the queue.
+    void push(T t) {
+        std::lock_guard<std::mutex> lock(mutex);
+        queue.push(t);
+        cond.notify_one();
+    }
+
+    /// Return true if the queue is empty.
+    bool empty() {
+        std::unique_lock<std::mutex> lock(mutex);
+        return queue.empty();
+    }
+
+    /// \brief
+    /// Wait until there is an object in the queue, then
+    /// remove and return the first object.
+    T pop_blocking() {
+        std::unique_lock<std::mutex> lock(mutex);
+        while (queue.empty()) {
+            cond.wait(lock);
+        }
+        T val = queue.front();
+        queue.pop();
+        return val;
+    }
+
+    /// \brief
+    /// A non-blocking pop.
+    ///
+    /// If the queue is empty, return false.
+    /// Otherwise remove the first object from the queue,
+    /// assign it to `val`, and return true.
+    bool fetch(T &val)
+    {
+        std::unique_lock<std::mutex> lock(mutex);
+        if (queue.empty())
+            return false;
+        val = queue.front();
+        queue.pop();
+        return true;
+    }
+
+private:
+    std::queue<T> queue;
+    mutable std::mutex mutex;
+    std::condition_variable cond;
+};
diff --git a/src/framework/pollstate.h b/src/framework/pollstate.h
new file mode 100644
index 0000000..ca5ea99
--- /dev/null
+++ b/src/framework/pollstate.h
@@ -0,0 +1,25 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+/*! \file */
+
+/// \enum PollState
+/// After doing an operation on a socket, a PollState must be returned to the
+/// network engine to describe what you want it to do next with the socket.
+enum class PollState {
+    NONE, /**< Do nothing right now, but keep socket open for later. */
+    READ_BLOCKED, /**< Don't check for incoming data/close, but check for
+                       writability if wantToSend(). */
+    CONNECTING, /**< Wait for asynchronous connect to complete. */
+#ifdef USE_GNUTLS
+    TLS_HANDSHAKE, /**< Wait for TLS handshake to complete. */
+#endif
+    CLOSE, /**< Close the socket gracefully. */
+    KEEPALIVE, /**< Put the connected socket in keep-alive cache. */
+    KILL, /**< Terminate connection immediately, discarding buffers. */
+    READ, /**< Check for incoming data/close. */
+    WRITE, /**< Check for close, and for writability. */
+    READ_WRITE /**< Check for incoming data/close, and for writability. */
+};
diff --git a/src/framework/serversocket.cpp b/src/framework/serversocket.cpp
new file mode 100644
index 0000000..93c0b09
--- /dev/null
+++ b/src/framework/serversocket.cpp
@@ -0,0 +1,51 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#ifdef _WIN32
+#include <WS2tcpip.h>
+#else
+#include <unistd.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#include "serversocket.h"
+class Task;
+
+ServerSocket::ServerSocket(const std::string &label, Task *task,
+                           uint16_t port, const std::string &ip) :
+    Socket(label, task, ip, port) {
+}
+
+ServerSocket::~ServerSocket() {
+}
+
+SocketConnection *ServerSocket::incoming() {
+    struct sockaddr_storage remoteaddr; // client address
+    socklen_t addrlen = sizeof(remoteaddr);
+    int fd = accept(socket(),
+                    reinterpret_cast<sockaddr *>(&remoteaddr), &addrlen);
+    if (fd < 0) {
+        if (errno == EMFILE)
+            Engine::notifyOutOfFds();
+        errno_log() << "accept failure on socket " << socket();
+        return nullptr;
+    }
+    if (!setNonBlocking(fd)) {
+        log() << "cannot set non-blocking " << fd;
+        closeSocket(fd);
+        return nullptr;
+    }
+    uint16_t port;
+    const char *ip = getIp(reinterpret_cast<sockaddr *>(&remoteaddr), &port);
+    log() << "Incoming socket " << fd << " from " << ip << " port " << port;
+
+    SocketConnection *conn = owner()->newClient(fd, ip, port, this);
+    if (!conn)
+        closeSocket(fd);
+    return conn;
+}
diff --git a/src/framework/serversocket.h b/src/framework/serversocket.h
new file mode 100644
index 0000000..1e77733
--- /dev/null
+++ b/src/framework/serversocket.h
@@ -0,0 +1,58 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include "socket.h"
+#include "task.h"
+
+class SocketConnection;
+
+/// \brief
+/// Listen on a single socket for incoming connections.
+///
+/// The owner task decides what to do when someone tries to connect.
+class ServerSocket : public Socket {
+public:
+    /// \brief
+    /// Create a new server socket.
+    ///
+    /// Will listen on the given ip address and port number.
+    ///
+    /// *Note!* If ip is an empty string, the socket will listen
+    /// on all local IPv4 and IPv6 addresses.
+    ServerSocket(const std::string &label, Task *task,
+                 uint16_t port, const std::string &ip = "127.0.0.1");
+
+    /// \brief
+    /// Create a new server to listen on an existing file descriptor.
+    ServerSocket(int fd, const std::string &label, Task *owner) :
+        Socket(label, owner, fd) {
+    }
+
+    virtual ~ServerSocket() override;
+
+    /// Server sockets shall not be cached.
+    std::string cacheLabel() override {
+        return std::string();
+    }
+
+    /// Schedule listen socket for removal.
+    void stopListening() {
+        closeMe();
+    }
+
+    /// Return Connection object if new client available, else return nullptr.
+    virtual SocketConnection *incoming();
+
+#ifdef USE_GNUTLS
+    void tlsSetKey(unsigned int i) {
+        tlsKeyIndex = i;
+    }
+    unsigned int tlsKey() const {
+        return tlsKeyIndex;
+    }
+private:
+    unsigned int tlsKeyIndex = 0;
+#endif
+};
diff --git a/src/framework/shortmessageconnection.cpp b/src/framework/shortmessageconnection.cpp
new file mode 100644
index 0000000..089ac4c
--- /dev/null
+++ b/src/framework/shortmessageconnection.cpp
@@ -0,0 +1,68 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "task.h"
+#include "shortmessageconnection.h"
+
+ShortMessageConnection::
+ShortMessageConnection(const std::string &label, Task *owner,
+                       const std::string &hostname, uint16_t port) :
+    SocketConnection(label, owner, hostname, port) {
+}
+
+
+ShortMessageConnection::
+ShortMessageConnection(const std::string &label, Task *owner, int fd,
+                       const char *ip, uint16_t port) :
+    SocketConnection(label, owner, fd, ip, port) {
+}
+
+PollState ShortMessageConnection::connected() {
+    return owner()->connectionReady(this);
+}
+
+PollState ShortMessageConnection::readData(char *buf, size_t len) {
+
+    if (reading_header) {
+        while (len && *buf >= '0' && *buf <= '9') {
+            (bytes_left *= 10) += (*buf++ - '0');
+            --len;
+        }
+        if (!len)
+            return PollState::READ;
+        if (!bytes_left || *buf != '\n') {
+            err_log() << "Got unexpected data";
+            return PollState::CLOSE;
+        }
+        reading_header = false;
+        ++buf;
+        --len;
+    }
+
+    if (len < bytes_left) {
+        msg.append(std::string(buf, len));
+        bytes_left -= len;
+        return PollState::READ;
+    }
+
+    msg.append(std::string(buf, bytes_left));
+    len -= bytes_left;
+    buf += bytes_left;
+    bytes_left = 0;
+
+    if (tellOwner(msg) == PollState::CLOSE)
+        return PollState::CLOSE;
+
+    msg.clear();
+    reading_header = true;
+
+    if (len)
+        return readData(buf, len);
+
+    return PollState::READ;
+}
+
+void ShortMessageConnection::sendMessage(const std::string &msg) {
+    std::string s = std::to_string(msg.size()) + '\n';
+    asyncSendData(s + msg);
+}
diff --git a/src/framework/shortmessageconnection.h b/src/framework/shortmessageconnection.h
new file mode 100644
index 0000000..bc1c92e
--- /dev/null
+++ b/src/framework/shortmessageconnection.h
@@ -0,0 +1,47 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include "socketconnection.h"
+
+/// \brief
+/// Simple protocol for exchanging messages.
+///
+/// Use sendMessage to send a message to peer.
+///
+/// When a message has been received from peer, it will be passed to
+/// the owner task's msgFromConnection method.
+/// When the connection is ready (connected), the owner task's connectionReady
+/// method will be called.
+/// The connectionReady and msgFromConnection methods must return
+/// PollState::READ to keep the connection, or PollState::CLOSE to close it.
+class ShortMessageConnection : public SocketConnection {
+public:
+    /// For client sockets, connecting to a server.
+    ShortMessageConnection(const std::string &label, Task *owner,
+                         const std::string &hostname, uint16_t port);
+
+    /// For already connected sockets, i.e. in a server.
+    ShortMessageConnection(const std::string &label, Task *owner, int fd,
+                           const char *ip = "unknown", uint16_t port = 0);
+
+    /// Will notify owner task that a new connection is available.
+    PollState connected() override;
+
+    /// Will notify owner when a complete message has been retrieved.
+    PollState readData(char *buf, size_t len) override;
+
+    /// Send message to peer.
+    void sendMessage(const std::string &msg);
+
+private:
+    // Message we're currently receiving, or empty.
+    std::string msg;
+
+    // Bytes left for the above message to be complete,
+    // or 0 if we're not currently receiving a message
+    size_t bytes_left = 0;
+
+    bool reading_header = true;
+};
diff --git a/src/framework/socket.cpp b/src/framework/socket.cpp
new file mode 100644
index 0000000..b2c90a7
--- /dev/null
+++ b/src/framework/socket.cpp
@@ -0,0 +1,370 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#ifdef _WIN32
+#include <ws2tcpip.h>
+#include <time.h>
+#define NOMINMAX
+#include <windows.h>
+#include <winsock2.h>
+#pragma comment(lib, "ws2_32.lib")
+#else
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netdb.h>
+#include <net/if.h>
+#endif
+#ifdef __linux
+#include <netinet/tcp.h>
+#endif
+
+#include <fcntl.h>
+#include <sys/types.h>
+
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <cctype>
+#include <cerrno>
+
+#include <string>
+#include <iomanip>
+#include <sstream>
+#include <map>
+
+#include "socket.h"
+#include "task.h"
+
+Socket::Socket(const std::string &label, Task *owner,
+               const std::string &hostname, uint16_t port) :
+    Logger(label),
+    _owner(owner),
+    _hostname(hostname),
+    _port(port),
+    _state(PollState::NONE)
+{
+#ifndef _WIN32
+    if (!port && hostname == "UnixDomain") {
+        int pair_sd[2];
+        if (socketpair(AF_UNIX, SOCK_STREAM, 0, pair_sd) < 0) {
+            errno_log() << "cannot create socket pair";
+            _socket = 0;
+        } else {
+            _socket = pair_sd[0];
+            unix_domain_peer = pair_sd[1];
+            fcntl(pair_sd[0], F_SETFL, O_NONBLOCK|O_CLOEXEC);
+            fcntl(pair_sd[1], F_SETFL, O_NONBLOCK);
+        }
+        return;
+    }
+#endif
+    _socket = -1;
+    _peer_label = _hostname + ":" + std::to_string(_port);
+}
+
+// TODO: take initial state as a parameter, default PollState::READ.
+Socket::Socket(const std::string &label, Task *owner, int fd) :
+    Logger(label),
+    _owner(owner),
+    _socket(fd),
+    _hostname(""),
+    _port(0),
+    _state(PollState::READ)
+{
+}
+
+Socket::~Socket() {
+    if (_socket >= 0) {
+        closeSocket(_socket);
+        log() << "closed socket " << _socket;
+    }
+}
+
+namespace {
+#ifdef USE_THREADS
+    thread_local
+#endif
+    std::map<std::string, struct addrinfo *> dns_cache;
+}
+
+void Socket::clearCache() {
+    for (auto p : dns_cache)
+        freeaddrinfo(p.second);
+    dns_cache.clear();
+}
+
+struct addrinfo *Socket::getAddressInfo(uint16_t iptype) {
+    auto it = dns_cache.find(_peer_label);
+    if (it == dns_cache.end()) {
+        struct addrinfo hints, *addressInfo;
+        memset(&hints, 0, sizeof hints);
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_STREAM;
+        hints.ai_flags = AI_ADDRCONFIG;
+
+        const char *hostaddr;
+        if (_hostname.empty()) {
+            hints.ai_family = AF_INET6;
+            hints.ai_flags |= AI_PASSIVE;
+            log() << "wildcard address *:" << _port;
+            hostaddr = nullptr;
+        } else if (_hostname.find_first_not_of("1234567890.:") ==
+                   std::string::npos) {
+            hints.ai_flags |= AI_NUMERICHOST;
+            log() << "numeric address " << _hostname;
+            hostaddr = _hostname.c_str();
+        } else {
+            log() << "dns lookup " << _hostname;
+            hostaddr = _hostname.c_str();
+        }
+
+        int res = getaddrinfo(hostaddr, std::to_string(_port).c_str(),
+                              &hints, &addressInfo);
+        if (res != 0) {
+            err_log() << "lookup failed: " << gai_strerror(res);
+            return nullptr;
+        } else if (!addressInfo) {
+            err_log() << "no valid address found";
+            return nullptr;
+        }
+        if (!(hints.ai_flags & AI_NUMERICHOST)) {
+            char ip[INET6_ADDRSTRLEN];
+            struct sockaddr *addr = addressInfo->ai_addr;
+            if (addressInfo->ai_family == AF_INET) {
+                struct sockaddr_in *s = reinterpret_cast<sockaddr_in *>(addr);
+                inet_ntop(AF_INET, &s->sin_addr, ip, sizeof ip);
+            } else {
+                struct sockaddr_in6 *s = reinterpret_cast<sockaddr_in6 *>(addr);
+                inet_ntop(AF_INET6, &s->sin6_addr, ip, sizeof ip);
+            }
+            log() << "lookup done: " << ip;
+        }
+
+        auto p2 = dns_cache.insert(std::make_pair(_peer_label, addressInfo));
+        it = p2.first;
+    }
+    if (iptype) {
+        int fam = (iptype == 6) ? AF_INET6 : AF_INET;
+        struct addrinfo *ai = it->second;
+        while (ai) {
+            if (ai->ai_family == fam)
+                return ai;
+            ai = ai->ai_next;
+        }
+    }
+    return it->second;
+}
+
+void Socket::createNonBlockingSocket(struct addrinfo *addressEntry,
+                                     struct addrinfo *localAddr) {
+    if (_socket >= 0) {
+        err_log() << "socket already exists";
+        return;
+    }
+    int fd = ::socket(addressEntry->ai_family, addressEntry->ai_socktype,
+                      addressEntry->ai_protocol);
+    if (fd == -1) {
+        errno_log() << "cannot create socket";
+        return;
+    }
+    if (!setNonBlocking(fd)) {
+        closeSocket(fd);
+        return;
+    }
+
+    if (localAddr && bind(fd, localAddr->ai_addr, localAddr->ai_addrlen) != 0) {
+        errno_log() << "cannot bind to local address";
+        return;
+    }
+
+    int res = connect(fd, addressEntry->ai_addr, addressEntry->ai_addrlen);
+    if (res == -1 && !isTempError()) {
+        errno_log() << "connect error";
+        closeSocket(fd);
+        return;
+    }
+
+    // All good, let's keep the socket:
+    _socket = fd;
+    _state = PollState::CONNECTING;
+}
+
+int Socket::closeSocket(int fd) {
+#ifdef _WIN32
+     return closesocket(fd);
+#else
+     return close(fd);
+#endif
+}
+
+bool Socket::socketInError(int fd) {
+    int res;
+    socklen_t res_len = sizeof(res);
+#ifdef _WIN32
+    if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (char *)&res, &res_len) < 0)
+#else
+    if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &res, &res_len) < 0)
+#endif
+        return true;
+    if (!res)
+        return false;
+    errno = res;
+    return !isTempError();
+}
+
+bool Socket::setNonBlocking(int fd) {
+#ifdef __APPLE__
+    // SO_NOSIGPIPE only for OS X
+    int value = 1;
+    int status = setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE,
+                            &value, sizeof(value));
+    if (status != 0) {
+        errno_log() << "cannot set SO_NOSIGPIPE";
+    }
+#endif
+
+#ifdef _WIN32
+    u_long enabledParameter = 1;
+    int nonBlockingResult = ioctlsocket(fd, FIONBIO, &enabledParameter);
+
+    if (nonBlockingResult == -1) {
+        errno_log() << "cannot set socket non-blocking";
+        closesocket(fd);
+        return false;
+    }
+#else
+    int nonBlockingResult = fcntl(fd, F_SETFL, O_NONBLOCK);
+    if (nonBlockingResult == -1) {
+        errno_log() << "cannot set socket non-blocking";
+        close(fd);
+        return false;
+    }
+#endif
+#ifdef __linux
+    int flag = 1;
+    int result = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY,
+                            reinterpret_cast<char *>(&flag), sizeof(int));
+    if (result < 0)
+        errno_log() << "cannot set TCP_NODELAY";
+#endif
+    return true;
+}
+
+const char *Socket::getIp(struct sockaddr *address, uint16_t *port) {
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static char client_ip[INET6_ADDRSTRLEN];
+    if (address->sa_family == AF_INET) {
+        struct sockaddr_in *s = reinterpret_cast<sockaddr_in *>(address);
+        inet_ntop(AF_INET, &s->sin_addr, client_ip, INET6_ADDRSTRLEN);
+        if (port)
+            *port = ntohs(s->sin_port);
+    } else {
+        struct sockaddr_in6 *s = reinterpret_cast<sockaddr_in6 *>(address);
+        inet_ntop(AF_INET6, &s->sin6_addr, client_ip, INET6_ADDRSTRLEN);
+        if (port)
+            *port = ntohs(s->sin6_port);
+    }
+    if (strncmp(client_ip, "::ffff:", 7) == 0)
+        return client_ip+7;
+    else
+        return client_ip;
+}
+
+const char *Socket::getIp(struct addrinfo *address, uint16_t *port) {
+    return getIp(address->ai_addr, port);
+}
+
+const char *Socket::getIp(int fd, uint16_t *port, bool peer) {
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static char client_ip[INET6_ADDRSTRLEN];
+    static const char *no_ip = "unknown IP";
+
+    struct sockaddr_storage address;
+    memset(&address, 0, sizeof address);
+    socklen_t addrlen = sizeof(address);
+
+    int ret = peer ?
+        getpeername(fd, reinterpret_cast<sockaddr *>(&address), &addrlen) :
+        getsockname(fd, reinterpret_cast<sockaddr *>(&address), &addrlen);
+
+    if (ret < 0) {
+        return no_ip;
+    } else {
+        if (address.ss_family == AF_INET) {
+            struct sockaddr_in *s = reinterpret_cast<sockaddr_in *>(&address);
+            inet_ntop(AF_INET, &s->sin_addr, client_ip, INET6_ADDRSTRLEN);
+            if (port)
+                *port = ntohs(s->sin_port);
+        } else {
+            struct sockaddr_in6 *s = reinterpret_cast<sockaddr_in6 *>(&address);
+            inet_ntop(AF_INET6, &s->sin6_addr, client_ip, INET6_ADDRSTRLEN);
+            if (port)
+                *port = ntohs(s->sin6_port);
+        }
+        if (strncmp(client_ip, "::ffff:", 7) == 0)
+            return client_ip+7;
+        else
+            return client_ip;
+    }
+}
+
+bool Socket::createServerSocket() {
+    std::string ip = _hostname;
+
+    if (_socket >= 0)
+        return false; // Already in use!!
+
+    log() << "Listen on " << port() << " ip " << ip;
+
+    struct addrinfo *addr = getAddressInfo();
+    if (!addr)
+        return false;
+
+    int fd = ::socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
+    if (fd < 0) {
+        errno_log() << "cannot create listen socket";
+        return false;
+    }
+#ifndef _WIN32
+    int reuse = 1;
+    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse,
+                   sizeof(reuse)) < 0) {
+        errno_log() << "cannot reuse listen socket";
+        return false;
+    }
+#endif
+
+    if (bind(fd, addr->ai_addr, addr->ai_addrlen) != 0) {
+        errno_log() << "cannot bind listen socket";
+        return false;
+    }
+
+    if (listen(fd, 20) != 0) {
+        errno_log() << "cannot listen";
+        return false;
+    }
+
+    // Socket will be -1, and state will be UNDEFINED, unless we get here:
+    _socket = fd;
+    _state = PollState::READ;
+
+    // Check port number
+    struct sockaddr_in6 address;
+    socklen_t len = sizeof(address);
+    if (getsockname(fd, reinterpret_cast<sockaddr *>(&address), &len) == -1)
+        errno_log() << "getsockname failed";
+    else {
+        _port = ntohs(address.sin6_port);
+        log() << "server socket " << fd << " listening on port " << _port;
+    }
+
+    return true;
+}
diff --git a/src/framework/socket.h b/src/framework/socket.h
new file mode 100644
index 0000000..92cbde0
--- /dev/null
+++ b/src/framework/socket.h
@@ -0,0 +1,237 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#ifdef _WIN32
+#include <winsock2.h>
+#endif
+
+#include "pollstate.h"
+#include "logger.h"
+
+class Task;
+
+/// \brief
+/// This is a slave to the Engine class. You can't use it directly,
+/// only through its subclasses, SocketConnection or ServerSocket.
+class Socket : public Logger {
+    friend class Engine;
+public:
+    Socket(const std::string &label, Task *owner,
+           const std::string &hostname, uint16_t port);
+
+    Socket(const std::string &label, Task *owner, int fd);
+
+    /// Return task owning the socket.
+    Task *owner() const {
+        return _owner;
+    }
+
+    /// Return name of the host to which the socket is supposed to connect.
+    std::string hostname() const {
+        return _hostname;
+    }
+
+    /// Return port number to which the socket is supposed to connect.
+    uint16_t port() const {
+        return _port;
+    }
+
+    /// \brief
+    /// Return current socket state.
+    PollState state() const {
+        return _state;
+    }
+
+#ifndef _WIN32
+    /// \brief
+    /// Return the peer socket descriptor.
+    ///
+    /// If this is a Unix Domain socket, return the peer socket descriptor.
+    /// If not, return 0.
+    ///
+    /// May be used in another thread or process.
+    int getUnixDomainPeer() const {
+        return unix_domain_peer;
+    }
+#endif
+
+    virtual ~Socket();
+
+    /// \brief
+    /// Return the socket's cache group, or an empty string.
+    ///
+    /// By default, if we have a keepalive (cached) connection to the same
+    /// host and port, it will be used instead of creating a
+    /// new connection. Override this method to disable keepalive
+    /// (returning empty string) or to use only a special type of
+    /// cached connection (returning a label for that special type).
+    virtual std::string cacheLabel() {
+        return _hostname + std::to_string(_port);
+    }
+
+    /// \brief
+    /// Return unique connection ID if connected.
+    ///
+    /// Return a positive number that is unique to this connection if it is
+    /// active, otherwise -1.
+    int id() const {
+        return _socket;
+    }
+
+    /// Set the given task as owner of the socket.
+    virtual void setOwner(Task *t) {
+        _owner = t;
+    }
+
+    /// \brief
+    /// Set a time to live for the socket.
+    ///
+    /// Call this to have the socket removed automatically before a given number
+    /// of seconds. Note: the network engine might remove the socket 1-2 seconds
+    /// before the timeout, so adjust the timeout value accordingly!
+    void setExpiry(double s) {
+        expiry = timeAfter(s);
+    }
+
+    /// Return true if the given TimePoint is after the socket's expiry.
+    bool hasExpired(const TimePoint &when) const {
+        return (expiry < when);
+    }
+
+    /// Return local IP address in static buffer.
+    const char *localIp() const {
+        const char *ip = getIp(socket(), nullptr, false);
+        return ip;
+    }
+
+    /// \brief
+    /// Return IP address of connected socket in static buffer.
+    ///
+    /// Return the local IP address if peer==false, otherwise the peer IP.
+    static const char *getIp(int fd, uint16_t *port = nullptr,
+                             bool peer = true);
+
+    /// Return IP address in static buffer.
+    static const char *getIp(struct sockaddr *address, uint16_t *port=nullptr);
+
+    /// Return IP address in static buffer.
+    static const char *getIp(struct addrinfo *address, uint16_t *port=nullptr);
+
+    /// Perform DNS lookup of remote host.
+    struct addrinfo *getAddressInfo(uint16_t iptype = 0);
+protected:
+    /// Return true unless last syscall encountered a fatal error.
+    static bool isTempError() {
+#ifdef _WIN32
+        if (WSAGetLastError() == WSAEWOULDBLOCK ||
+            WSAGetLastError() == WSAEINPROGRESS ||
+            WSAGetLastError() == WSAENOTCONN ||
+            !WSAGetLastError())
+#else
+        if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINPROGRESS
+            || errno == EINTR || !errno)
+#endif
+            return true;
+        else
+            return false;
+    }
+
+    /// Return true if socket is watched for writeability.
+    virtual bool wantToSend() {
+        return false;
+    }
+
+    /// \brief
+    /// This will be called regularly on READ_BLOCKED sockets to check if the
+    /// block can be lifted.
+    ///
+    /// If your subclass ever returns READ_BLOCKED,
+    /// it should override this method to return the new state when the block
+    /// should be removed.
+    virtual PollState checkReadBlock() {
+        return PollState::READ_BLOCKED;
+    }
+
+    /// \brief
+    /// Notify intention of sending large amounts of data.
+    ///
+    /// Normally, this is done simply by returning PollState::READ_WRITE
+    /// from a scoket callback.
+    /// This method is useful if you're not inside such a callback when you
+    /// find out you need to send (large amounts of) data.
+    void setWantToSend() {
+        if (_state != PollState::CLOSE)
+            _state = PollState::READ_WRITE;
+    }
+
+    /// Return file descriptor.
+    int socket() const {
+        return _socket;
+    }
+
+    /// Close a file descriptor.
+    static int closeSocket(int fd);
+
+    /// Tell the network engine that the connection should be closed.
+    void closeMe() {
+        _state = PollState::CLOSE;
+    }
+
+    /// \brief
+    /// Create socket and initiate the connection.
+    ///
+    /// Will do no nothing if socket has already been created.
+    /// On error, socket() will return -1.
+    void createNonBlockingSocket(struct addrinfo *addressEntry,
+                                 struct addrinfo *localAddr=nullptr);
+
+    /// Set socket as non-blocking.
+    bool setNonBlocking(int fd);
+
+    /// Return true if the file descriptor has encountered a fatal error.
+    static bool socketInError(int fd);
+
+    /// Return true if the socket has encountered a fatal error.
+    bool inError() const {
+        if (!socketInError(_socket))
+            return false;
+        errno_log() << "failed socket " << _socket;
+        return true;
+    }
+private:
+    void setState(PollState state) {
+        if (_state != PollState::CLOSE)
+            _state = state;
+    }
+
+    // Return false on failure:
+    bool createServerSocket();
+
+    static void clearCache();
+
+    void killMe() {
+        _state = PollState::KILL;
+    }
+
+    // Internal identifier used as key in dns_cache:
+    std::string _peer_label;
+
+    void setSocket(int fd) {
+        _socket = fd;
+    }
+
+    Socket(const Socket &);
+    Task *_owner;
+    int _socket;
+#ifndef _WIN32
+    // If this is a Unix Domain socket, the peer socket descriptor will be
+    // stored here:
+    int unix_domain_peer = 0;
+#endif
+    std::string _hostname;
+    uint16_t _port;
+    PollState _state;
+    TimePoint expiry = timeMax();
+};
diff --git a/src/framework/socketconnection.cpp b/src/framework/socketconnection.cpp
new file mode 100644
index 0000000..e135244
--- /dev/null
+++ b/src/framework/socketconnection.cpp
@@ -0,0 +1,327 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#ifdef _WIN32
+#define NOMINMAX
+#include <WS2tcpip.h>
+#include <Windows.h>
+#include <winsock2.h>
+#pragma comment(lib, "ws2_32.lib")
+typedef long ssize_t;
+#else
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#endif
+
+#include "socketconnection.h"
+#include "task.h"
+#include <sys/types.h>
+#ifdef USE_GNUTLS
+#include <gnutls/x509.h>
+#endif
+
+SocketConnection::
+SocketConnection(const std::string &label, Task *owner,
+                 const std::string &hostname, uint16_t port,
+                 uint16_t iptype, struct addrinfo *local_addr) :
+    Socket(label, owner, hostname, port) {
+    peer_ip = hostname;
+    peer_port = port;
+    local_ip = local_addr;
+    if (local_ip)
+        prefer_ip_type = (local_ip->ai_family == AF_INET6 ? 6 : 4);
+    else
+        prefer_ip_type = iptype;
+
+}
+
+#ifdef USE_THREADS
+thread_local
+#endif
+uint64_t SocketConnection::tot_bytes_sent = 0;
+#ifdef USE_THREADS
+thread_local
+#endif
+uint64_t SocketConnection::tot_bytes_received = 0;
+
+SocketConnection::SocketConnection(const std::string &label, Task *owner,
+                                   int fd, const char *ip, uint16_t port) :
+    Socket(label, owner, fd) {
+    peer_ip = ip;
+    peer_port = port;
+}
+
+void SocketConnection::closedByPeer() {
+    log() << "connection closed by peer";
+}
+
+PollState SocketConnection::doRead(int fd) {
+    ssize_t n;
+#ifdef USE_GNUTLS
+    if (is_tls()) {
+        n = gnutls_record_recv(session, socket_buffer, sizeof socket_buffer);
+        if (n < 0) {
+            if (gnutls_error_is_fatal(static_cast<int>(n))) {
+                // Probably client terminated the connection abruptly
+                dbg_log() << "TLS error on socket " << fd;
+                return PollState::CLOSE;
+            }
+            //warn_log() << "TLS recv interrupt on socket " << fd;
+            return state();
+        }
+    } else
+#endif
+    n = recv(fd, socket_buffer, sizeof socket_buffer, 0);
+    if (debugging)
+        log() << "socket " << socket() << " doRead " << n;
+    if (n == 0) {
+        log() << "socket closed by peer " << fd;
+        return PollState::CLOSE;
+    } else if (n < 0) {
+        if (isTempError()) {
+            warn_log() << "recv interrupt on socket " << fd;
+            return state();
+        } else {
+            errno_log() << "recv error on socket " << fd;
+            return PollState::CLOSE;
+        }
+    }
+    if (debugging && n < 1000)
+        log() << "socket " << socket() << "doRead <"
+              << std::string(socket_buffer, static_cast<size_t>(n));
+#ifdef USE_GNUTLS
+    // For SSL sockets, it's the tls_pull method that counts the actual number
+    // of bytes fetched from the network
+    if (!is_tls())
+#endif
+    {
+        tot_bytes_received += static_cast<uint64_t>(n);
+        owner()->notifyBytesReceived(static_cast<uint64_t>(n));
+    }
+
+    // Now let the subclass take care of what we read:
+    if (state() == PollState::READ || state() == PollState::READ_WRITE) {
+        PollState ret = readData(socket_buffer, static_cast<size_t>(n));
+        // If there's more to read, do it immediately instead of after
+        // next select call:
+        if (ret == PollState::READ &&
+            static_cast<size_t>(n) == sizeof socket_buffer)
+            return doRead(fd);
+        return ret;
+    }
+    return unexpectedData(socket_buffer, static_cast<size_t>(n));
+}
+
+// Must not be called more than once on the same object!
+bool SocketConnection::asyncConnect() {
+    if (socket() >= 0) {
+        log() << "internal error, connect called twice on socket" << socket();
+        return false;
+    }
+
+    struct addrinfo *addr = getAddressInfo(prefer_ip_type);
+    if (!addr)
+        return false;
+
+    createNonBlockingSocket(addr, local_ip);
+    if (socket() < 0)
+        return false;
+
+    return true;
+}
+
+PollState SocketConnection::unexpectedData(char *buf, size_t len) {
+    err_log() << "unexpected data arrived; will close connection: "
+              << std::string(buf, std::min(len, static_cast<size_t>(30)));
+    return PollState::CLOSE;
+}
+
+size_t SocketConnection::sendData(const char *buf, size_t len) {
+    ssize_t n;
+#ifdef USE_GNUTLS
+    if (is_tls()) {
+        n = gnutls_record_send(session, buf, len);
+        if (n < 0) {
+            if (gnutls_error_is_fatal(static_cast<int>(n))) {
+                errno_log() << "TLS write error";
+                closeMe();
+            } else {
+                if (!tls_send_pending) {
+                    warn_log() << "Socket " << socket()
+                               << " TLS write failure: "
+                               << gnutls_strerror(static_cast<int>(n));
+                    tls_send_pending = true;
+                }
+            }
+            return 0;
+        }
+        // To reenable the GNUTLS_E_AGAIN warning, do this:
+        // tls_send_pending = false;
+        if (debugging && n < 1000)
+            log() << "socket " << socket() << "sendData <"
+                  << std::string(buf, static_cast<size_t>(n)) << ">";
+        // For SSL sockets, it's the tls_push method that counts the actual
+        // number of bytes sent over the network
+        return static_cast<size_t>(n);
+    }
+#endif
+#ifdef __APPLE__
+    n = send(socket(), buf, len, 0);
+#elif defined(_WIN32)
+    n = send(socket(), buf, len, 0);
+#else
+    n = send(socket(), buf, len, MSG_NOSIGNAL);
+#endif
+    if (debugging)
+        log() << "socket " << socket() << "sendData " << n << " of " << len;
+    if (n < 0) {
+        if (!isTempError()) {
+            errno_log() << "cannot write";
+            closeMe();
+        }
+        return 0;
+    }
+    if (debugging && n < 1000)
+        log() << "socket " << socket() << "sendData <"
+              << std::string(buf, static_cast<size_t>(n)) << ">";
+    // Global count
+    tot_bytes_sent += static_cast<uint64_t>(n);
+    // Per task count
+    owner()->notifyBytesSent(static_cast<uint64_t>(n));
+    return static_cast<size_t>(n);
+}
+
+#ifdef USE_WEBROOT
+size_t SocketConnection::sendFileData(int fd, size_t len) {
+    static char buf[50000];
+    if (len > sizeof buf)
+        len = sizeof buf;
+    ssize_t n = read(fd, buf, len);
+    log() << "Read " << n << " bytes from file";
+    if (n <= 0) {
+        errno_log() << "cannot read from file";
+        closeMe();
+        return 0;
+    }
+    return sendData(buf, static_cast<size_t>(n));
+}
+#endif
+
+void SocketConnection::asyncSendData(const char *buf, size_t len) {
+    if (to_send.empty()) {
+        size_t sent = sendData(buf, len);
+        if (sent == len)
+            return;
+        to_send = std::string(buf+sent, len-sent);
+    } else {
+        to_send.append(buf, len);
+    }
+}
+
+PollState SocketConnection::tellOwner(const std::string &msg) {
+    return owner()->msgFromConnection(this, msg);
+}
+
+#ifdef USE_GNUTLS
+
+bool SocketConnection::
+init_tls_client(gnutls_certificate_credentials_t &x509_cred, bool verify_cert) {
+    dbg_log() << "Enable TLS on socket " << socket();
+
+    if (gnutls_init(&session, GNUTLS_CLIENT | GNUTLS_NONBLOCK) < 0)
+        return false;
+    setSessionInitialized();
+    if (gnutls_set_default_priority(session) < 0)
+        return false;
+    if (gnutls_server_name_set(session, GNUTLS_NAME_DNS, peer_ip.c_str(),
+                               peer_ip.size()) < 0)
+        return false;
+
+    if (gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE,
+                               x509_cred) < 0)
+        return false;
+
+    if (verify_cert) {
+        log() << "verify cert";
+        gnutls_session_set_verify_cert(session, peer_ip.c_str(), 0);
+    }
+
+    gnutls_certificate_set_verify_flags (x509_cred,
+                                         GNUTLS_VERIFY_ALLOW_BROKEN);
+
+    gnutls_handshake_set_timeout(session,
+                                 GNUTLS_DEFAULT_HANDSHAKE_TIMEOUT);
+
+    // gnutls_transport_set_int(session, socket());
+    // We use custom send/recv functions in order to be able to count the
+    // number of bytes sent and received:
+    {
+        gnutls_transport_set_ptr(session,
+                                 static_cast<gnutls_transport_ptr_t>(this));
+        gnutls_transport_set_push_function(session, tls_push_static);
+        gnutls_transport_set_pull_function(session, tls_pull_static);
+    }
+    return true;
+}
+
+ssize_t SocketConnection::tls_pull(void *buf, size_t len) {
+    ssize_t n = recv(socket(), buf, len, 0);
+    //dbg_log() << "tls_pull " << n << " bytes of " << len;
+    if (n > 0) {
+        owner()->notifyBytesReceived(static_cast<uint64_t>(n));
+        tot_bytes_received += static_cast<uint64_t>(n);
+    }
+    return n;
+}
+
+ssize_t SocketConnection::tls_push(const void *buf, size_t len) {
+#ifdef __APPLE__
+    ssize_t n = send(socket(), buf, len, 0);
+#elif defined(_WIN32)
+    ssize_t n = send(socket(), buf, len, 0);
+#else
+    ssize_t n = send(socket(), buf, len, MSG_NOSIGNAL);
+#endif
+    //dbg_log() << "tls_push " << n << " bytes of " << len;
+    if (n > 0) {
+        owner()->notifyBytesSent(static_cast<uint64_t>(n));
+        tot_bytes_sent += static_cast<uint64_t>(n);
+    }
+    return n;
+}
+
+bool SocketConnection::
+init_tls_server(gnutls_certificate_credentials_t &x509_cred,
+                gnutls_priority_t &priority_cache) {
+    dbg_log() << "Enable TLS on incoming socket " << socket();
+
+    if (gnutls_init(&session, GNUTLS_SERVER | GNUTLS_NONBLOCK) < 0) {
+        err_log() << "Cannot initialise TLS session";
+        return false;
+    }
+    setSessionInitialized();
+
+    if (gnutls_priority_set(session, priority_cache) < 0 ||
+        gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE,
+                               x509_cred) < 0)
+        return false;
+
+    gnutls_certificate_server_set_request(session,
+                                          GNUTLS_CERT_IGNORE);
+    gnutls_handshake_set_timeout(session,
+                                 GNUTLS_DEFAULT_HANDSHAKE_TIMEOUT);
+    // gnutls_transport_set_int(session, socket());
+    // We use custom send/recv functions in order to be able to count the
+    // number of bytes sent and received:
+    {
+        gnutls_transport_set_ptr(session,
+                                 static_cast<gnutls_transport_ptr_t>(this));
+        gnutls_transport_set_push_function(session, tls_push_static);
+        gnutls_transport_set_pull_function(session, tls_pull_static);
+    }
+
+    return true;
+}
+
+#endif
diff --git a/src/framework/socketconnection.h b/src/framework/socketconnection.h
new file mode 100644
index 0000000..44f2197
--- /dev/null
+++ b/src/framework/socketconnection.h
@@ -0,0 +1,327 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <algorithm>
+#include "socket.h"
+
+#ifdef USE_GNUTLS
+#include <gnutls/gnutls.h>
+#endif
+
+/// \brief
+/// This class implements low-level socket connection operations.
+/// Inherit from it to implement protocols like HTTP.
+///
+/// A SocketConnection object represents a socket connection. Inherit from this
+/// class to implement a "protocol" for the connection, i.e. when/what to
+/// read/write through the connection.
+///
+/// Each SocketConnection is owned by a Task object. SocketConnection objects
+/// will be added to the network Engine (a part of the EventLoop) through the
+/// task's addConnection method.
+///
+/// The subclass will be notified through callback functions when
+/// anything happens on the socket, i.e. if the socket has been closed, if data
+/// has arrived, or if the socket is writable.
+/// You define the callback functions by overloading the below virtual functions.
+/// All operations will be performed asynchronously (non-blocking) except for
+/// dns lookups, which are performed synchronously (blocking).
+///
+/// Note! You _must_ create the SocketConnection objects with new. The ownership
+/// will then be passed to the network engine.
+/// You are not allowed to delete a SocketConnection object.
+/// We will delete it when the connection has been closed, which will be
+///
+///  1) If you order us to close it by returning CLOSE, KEEPALIVE or KILL from
+///     a callback, or
+///
+///  2) After the closedByPeer callback, if the connection has been
+///     closed by peer.
+///
+///  3) After the connectionFailed callback, if the connection couldn't
+///     be established in the first place.
+///
+/// The owner task will be notified before the object is deleted.
+class SocketConnection : public Socket {
+    friend class Engine;
+public:
+    /// Create a SocketConnection owned by the given Task. The network Engine
+    /// will connect to the given hostname/port, and notify through the below
+    /// method when the connection is ready.
+    /// If iptype is 4, prefer ipv4. If iptype is 6, prefer ipv6.
+    SocketConnection(const std::string &label, Task *owner,
+                     const std::string &hostname, uint16_t port,
+                     uint16_t iptype = 0, struct addrinfo *local_addr=nullptr);
+
+#ifdef USE_GNUTLS
+    virtual ~SocketConnection() override {
+        if (tlsInitialized()) {
+            gnutls_deinit(session);
+        }
+    }
+
+    /// Notify that the connection will be encrypted (SSL).
+    void enableTLS() {
+        use_tls = true;
+    }
+
+    /// Return true if the connection will be encrypted (SSL).
+    bool is_tls() const {
+        return use_tls;
+    }
+
+    /// Store SSL session in cache.
+    gnutls_session_t cache_session() {
+        session_initialized = false;
+        return session;
+    }
+
+    /// Reuse cached SSL session.
+    void insert_cached_session(gnutls_session_t &old_session) {
+        session_initialized = true;
+        use_tls = true;
+        session = old_session;
+        gnutls_transport_set_ptr(session,
+                                 static_cast<gnutls_transport_ptr_t>(this));
+    }
+#endif
+
+    /// \brief
+    /// Will be called when the connection is established.
+    ///
+    /// Override it to start sending data when the connection is ready.
+    ///
+    /// If a connection couldn't be established,
+    /// SocketConnection::connectionFailed will be called instead.
+    /// You must not return PollState::CONNECTING.
+    virtual PollState connected() {
+        return PollState::CLOSE;
+    }
+
+    /// Will be called if the connection couldn't be established.
+    virtual void connectionFailed(const std::string &err_msg) {
+        log() << "connection failed: " << err_msg;
+    }
+
+    /// Called when the socket has been closed by peer:
+    /// May be called in states READ, WRITE, READ_WRITE
+    virtual void closedByPeer();
+
+    /// \brief
+    /// Callback, called when data has arrived; len > 0.
+    ///
+    /// May be called in states READ, READ_WRITE. Override this method to
+    /// handle the data. Return value should be the new state.
+    ///
+    /// The buffer is owned by the implementation. However, you are allowed
+    /// to modify the contents of the buffer and you may also use
+    /// it in the asyncSendData call.
+    virtual PollState readData(char *, size_t ) {
+        return PollState::CLOSE;
+    }
+
+    /// \brief
+    /// Peer has sent data when it wasn't supposed to.
+    ///
+    /// If peer sends data when we're not in state READ/READ_WRITE, this
+    /// function will be called. Default is for the socket to be closed.
+    /// If you return READ, any remaining async_send data will be discarded.
+    virtual PollState unexpectedData(char *buf, size_t len);
+
+    /// \brief
+    /// Callback, called when socket is writable.
+    ///
+    /// May be called in states PollState::WRITE and PollState::READ_WRITE.
+    /// Override it to write data.
+    /// Return value should be the new state. Do not return PollState::WRITE or
+    /// PollState::READ_WRITE except after a write operation where
+    /// all data couldn't be sent immediately.
+    virtual PollState writeData() {
+        return PollState::CLOSE;
+    }
+
+    /// \brief
+    /// Try to send len bytes from the given buffer. Return the amount sent.
+    ///
+    /// More accurately, this method will return the number of bytes that
+    /// could be copied into the socket's send buffer.
+    ///
+    /// Please understand that the return value might be < len.
+    /// To safely get all data sent, you should use the
+    /// SocketConnection::asyncSendData
+    /// function instead. However, if you need to send large
+    /// amounts of data ("large" as in "no upper limit") as fast
+    /// as possible, this is the function to use.
+    size_t sendData(const char *buf, size_t len);
+
+#ifdef USE_WEBROOT
+    size_t sendFileData(int fd, size_t len);
+#endif
+
+    /// \brief
+    /// Send data to peer as soon as possible.
+    ///
+    /// Helper function which you may call only during the
+    /// execution of the callbacks SocketConnection::connected,
+    /// SocketConnection::readData, and SocketConnection::writeData.
+    ///
+    /// Send len bytes from the given buffer.
+    /// The callback SocketConnection::closedByPeer
+    /// might be executed before all data was sent.
+    ///
+    /// If you need to send "unlimited" amounts of data, you cant use
+    /// this method; instead you must use SocketConnection::sendData.
+    void asyncSendData(const char *buf, size_t len);
+
+    /// \brief
+    /// Send data to peer as soon as possible.
+    ///
+    /// Helper function which you may call only during the
+    /// execution of the callbacks SocketConnection::connected,
+    /// SocketConnection::readData, and SocketConnection::writeData.
+    ///
+    /// Send len bytes from the given buffer.
+    /// The callback SocketConnection::closedByPeer
+    /// might be executed before all data was sent.
+    ///
+    /// If you need to send "unlimited" amounts of data, you cant use
+    /// this method; instead you must use SocketConnection::sendData.
+    void asyncSendData(const std::string data) {
+        asyncSendData(data.c_str(), data.size());
+    }
+
+    /// \brief
+    /// Return number of bytes left to send after calling
+    /// SocketConnection::asyncSendData.
+    size_t asyncBufferSize() const {
+        return to_send.size();
+    }
+
+    /// Number of bytes sent by current thread
+    static uint64_t totBytesSent() {
+        return tot_bytes_sent;
+    }
+
+    /// Number of bytes recieved by current thread
+    static uint64_t totBytesReceived() {
+        return tot_bytes_received;
+    }
+
+    /// \brief
+    /// Reset counter for SocketConnection::totBytesSent
+    /// and SocketConnection::totBytesReceived.
+    static void resetByteCounter() {
+        tot_bytes_sent = 0;
+        tot_bytes_received = 0;
+    }
+
+    /// Return peer's IP address.
+    const std::string &peerIp() const {
+        return peer_ip;
+    }
+
+    /// Return peer's port number.
+    uint16_t peerPort() const {
+        return peer_port;
+    }
+
+    /// Enable debug output of data sent and received.
+    void dbgOn(bool b = true) {
+        debugging = b;
+    }
+
+    /// Return true if socket debugging is enabled.
+    bool dbgIsOn() {
+        return debugging;
+    }
+protected:
+
+    /// If fd is the socket descriptor of an already established connection,
+    /// you may let us manage the connection by calling this constructor.
+    /// fd will probably be a client socket connected through a ServerSocket.
+    SocketConnection(const std::string &label, Task *owner, int fd,
+                     const char *ip, uint16_t port);
+
+    /// Send a "message" to owner task. It will be executed as
+    /// Task::msgFromConnection(this, msg) in the owner task.
+    /// This is useful if you want to create SocketConnection
+    /// subclasseses that work with any Task.
+    PollState tellOwner(const std::string &msg);
+
+private:
+    // Create a connection to the given host. Will be executed asynchronously,
+    // then one of the callbacks connected / connectionFailed will be called.
+    SocketConnection(Task *owner, const std::string &hostname,
+                     unsigned int port);
+
+    SocketConnection(const SocketConnection &);
+
+    // Will return false if connection fails immediately, e.g. if DNS
+    // lookup fails. Otherwise callback "connected" or "connectionFailed"
+    // will be called - perhaps even before this call returns:
+    bool asyncConnect();
+
+    PollState doRead(int fd);
+
+    // In states READ and READ_BLOCKED, this will be called to check if
+    // we the connection should be checked for writability too.
+    // If you override this, make sure to return true if asyncBufferSize() > 0.
+    bool wantToSend() override {
+        return !to_send.empty();
+    }
+
+    PollState doWrite() {
+        if (to_send.empty())
+            return this->writeData();
+        if (size_t written = sendData(to_send.c_str(), to_send.size()))
+            to_send.erase(0, written);
+        return state();
+    }
+
+    std::string to_send;
+    char socket_buffer[100000];
+
+    std::string peer_ip;
+    struct addrinfo *local_ip;
+    uint16_t peer_port;
+    uint16_t prefer_ip_type;
+
+#ifdef USE_THREADS
+    thread_local
+#endif
+    // Per thread byte counters.
+    static uint64_t tot_bytes_sent, tot_bytes_received;
+    bool debugging = false;
+#ifdef USE_GNUTLS
+    bool use_tls = false;
+    bool session_initialized = false;
+    bool tls_send_pending = false;
+    void setSessionInitialized() {
+        session_initialized = true;
+    }
+    bool tlsInitialized() {
+        return session_initialized;
+    }
+    bool init_tls_server(gnutls_certificate_credentials_t &x509_cred,
+                         gnutls_priority_t &priority_cache);
+    bool init_tls_client(gnutls_certificate_credentials_t &x509_cred,
+                         bool verify_cert);
+    int try_tls_handshake() {
+        dbg_log() << "TLS handshake socket " << socket();
+        return gnutls_handshake(session);
+    }
+    static ssize_t tls_pull_static(gnutls_transport_ptr_t self,
+                                   void *buf, size_t len) {
+        return static_cast<SocketConnection *>(self)->tls_pull(buf, len);
+    }
+    static ssize_t tls_push_static(gnutls_transport_ptr_t self,
+                                   const void *buf, size_t len) {
+        return static_cast<SocketConnection *>(self)->tls_push(buf, len);
+    }
+    ssize_t tls_pull(void *buf, size_t len);
+    ssize_t tls_push(const void *buf, size_t len);
+    gnutls_session_t session;
+#endif
+};
diff --git a/src/framework/socketreceiver.cpp b/src/framework/socketreceiver.cpp
new file mode 100644
index 0000000..a5c255b
--- /dev/null
+++ b/src/framework/socketreceiver.cpp
@@ -0,0 +1,103 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#ifndef _WIN32
+
+#include "socketreceiver.h"
+
+SocketReceiver::SocketReceiver(Task *task, int sock, pid_t peer_pid) :
+    ServerSocket(sock, "SocketReceiver", task),
+    peer(peer_pid) {
+
+    empty_data.iov_base = nullptr;
+    empty_data.iov_len = 0;
+
+    memset(&fdpass_msg, 0, sizeof(fdpass_msg));
+    fdpass_msg.msg_iov = &empty_data;
+    fdpass_msg.msg_iovlen = 1;
+
+    fdpass_msg.msg_control = cmsgbuf;
+    fdpass_msg.msg_controllen = sizeof(cmsgbuf);
+    cmsg = CMSG_FIRSTHDR(&fdpass_msg);
+    cmsg->cmsg_level = SOL_SOCKET;
+    cmsg->cmsg_type = SCM_RIGHTS;
+    cmsg->cmsg_len = CMSG_LEN(sizeof(int));
+    fdpass_msg.msg_controllen = cmsg->cmsg_len;
+
+    memset(&parent_msg, 0, sizeof(parent_msg));
+    parent_msg.msg_iov = &msg_data;
+    parent_msg.msg_iovlen = 1;
+}
+
+SocketConnection *SocketReceiver::incoming() {
+    //log() << "SocketReceiver::new_client_socket()";
+    struct msghdr child_msg;
+
+    memset(&child_msg, 0, sizeof(child_msg));
+    child_msg.msg_control = cmsgbuf;
+    child_msg.msg_controllen = sizeof(cmsgbuf);
+
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static char buf[10000];
+#ifdef USE_THREADS
+thread_local
+#endif
+    static struct iovec data = { buf, sizeof(buf) };
+
+    child_msg.msg_iov = &data;
+    child_msg.msg_iovlen = 1;
+
+    ssize_t len = recvmsg(socket(), &child_msg, MSG_DONTWAIT);
+    if (len < 0) {
+        log() << "recvmsg() failed: " << strerror(errno);
+        return nullptr;
+    }
+    cmsg = CMSG_FIRSTHDR(&child_msg);
+    if (cmsg == nullptr || cmsg->cmsg_type != SCM_RIGHTS) {
+        //log() << "Error: not a file descriptor";
+        if (child_msg.msg_iovlen && owner()) {
+            struct iovec data1 = child_msg.msg_iov[0];
+            auto addr = reinterpret_cast<const char *>(data1.iov_base);
+            owner()->workerMessage(this, addr, static_cast<size_t>(len));
+        }
+        return nullptr;
+    }
+
+    int newfd;
+    memcpy(&newfd, CMSG_DATA(cmsg), sizeof(newfd));
+
+    uint16_t port;
+    const char *ip = Socket::getIp(newfd, &port);
+    dbg_log() << "Received socket " << newfd << " from " << ip
+              << " port " << port;
+
+    SocketConnection *conn = owner()->newClient(newfd, ip, port, this);
+    if (!conn)
+        closeSocket(newfd);
+    return conn;
+}
+
+int SocketReceiver::passSocketToPeer(int fd) {
+    memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd));
+
+    log() << "passing fd " << fd << " to peer";
+    int ret;
+    if (sendmsg(socket(), &fdpass_msg, MSG_DONTWAIT) < 0)
+        ret = errno;
+    else
+        ret = 0;
+    return ret;
+}
+
+ssize_t SocketReceiver::passMessageToPeer(const char *buf, size_t len) {
+    msg_data.iov_base = const_cast<char *>(buf);
+    msg_data.iov_len = len;
+    ssize_t sent = sendmsg(socket(), &parent_msg, 0);
+    if (sent != static_cast<ssize_t>(len))
+        log() << "only sent " << sent << " of total " << len;
+    return sent;
+}
+
+#endif
diff --git a/src/framework/socketreceiver.h b/src/framework/socketreceiver.h
new file mode 100644
index 0000000..ffe007d
--- /dev/null
+++ b/src/framework/socketreceiver.h
@@ -0,0 +1,59 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <sys/socket.h>
+#include "serversocket.h"
+class SocketConnection;
+
+/// \brief
+/// Pass sockets and messages between processes.
+///
+/// Typical use is to have a master process listen on a port,
+/// passing any new connections to child processes.
+///
+/// Both sockets and messages (data) may be passsed between processes.
+///
+/// A pair of Unix domain sockets must be created in the parent process,
+/// to be used by one SocketReceiver in the parent and one SocketReceiver
+/// in the child process.
+class SocketReceiver : public ServerSocket {
+public:
+    /// Add a SocketReceiver to the given Task.
+    /// The `sock` parameter shall be one of a pair of Unix domain sockets.
+    /// The `peer_pid` parameter is used only for logging.
+    SocketReceiver(Task *task, int sock, pid_t peer_pid);
+
+    /// Return connection object if new client available, else return nullptr.
+    virtual SocketConnection *incoming() override;
+
+    /// Return 0 for success, errno on failure
+    int passSocketToPeer(int fd);
+
+    /// Send data to peer. Return amount sent, or < 0 for error.
+    ssize_t passMessageToPeer(const char *buf, size_t len);
+
+    /// Return PID of the peer process.
+    pid_t peerPid() const {
+        return peer;
+    }
+
+    /// Stop communication with peer process and terminate as soon as possible.
+    void peerDead() {
+        peer = 0;
+        closeMe();
+    }
+private:
+    pid_t peer;
+
+    // Used when passing file descriptors to peer:
+    struct msghdr fdpass_msg;
+    struct iovec empty_data;
+    char cmsgbuf[CMSG_SPACE(sizeof(int))];
+    struct cmsghdr *cmsg;
+
+    // Used when sending data to peer:
+    struct msghdr parent_msg;
+    struct iovec msg_data;
+};
diff --git a/src/framework/synchronousbridge.cpp b/src/framework/synchronousbridge.cpp
new file mode 100644
index 0000000..5c43ea9
--- /dev/null
+++ b/src/framework/synchronousbridge.cpp
@@ -0,0 +1,27 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <queue>
+
+#include "synchronousbridge.h"
+
+void SynchronousClient::initialMsgToAgent(std::deque<std::string> &) {
+    // Override this to push messages onto the queue.
+}
+
+double SynchronousBridge::start() {
+    dbg_log() << "starting";
+    BridgeTask::start();
+    the_client->initialMsgToAgent(incoming_messages);
+    clear_queue();
+    return 0;
+}
+
+SynchronousBridge::~SynchronousBridge() {
+}
+
+void SynchronousBridge::sendMsgToClient(const std::string &msg) {
+    // The client executes code only from within the below call.
+    the_client->newEventFromAgent(incoming_messages, msg);
+    clear_queue();
+}
diff --git a/src/framework/synchronousbridge.h b/src/framework/synchronousbridge.h
new file mode 100644
index 0000000..2be3b1b
--- /dev/null
+++ b/src/framework/synchronousbridge.h
@@ -0,0 +1,69 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <deque>
+#include <map>
+
+#include "../framework/bridgetask.h"
+
+/// \brief
+/// Client that only exists (or, rather, executes code) from within the bridge.
+///
+/// This way, it's trivial to create a non-interactive interface to the agent.
+///
+/// Shall be used with a SynchronousBridge.
+class SynchronousClient {
+public:
+    /// \brief
+    /// Send initial messages to the agent.
+    ///
+    /// Override this to push messages onto the queue.
+    virtual void initialMsgToAgent(std::deque<std::string> &return_msgs);
+
+    /// \brief
+    /// Retrieve a new message from the agent.
+    ///
+    /// The client will only execute code from within its implementation
+    /// of this method.
+    ///
+    /// The client must push any return messages onto return_msgs.
+    virtual void newEventFromAgent(std::deque<std::string> &return_msgs,
+                                   const std::string &msg) = 0;
+
+    virtual ~SynchronousClient() { }
+};
+
+/// \brief
+/// A bridge that "owns" the client.
+///
+/// The client only exists (or, rather, executes code) from within the bridge.
+///
+/// Shall be used with a SynchronousClient.
+class SynchronousBridge : public BridgeTask {
+public:
+    SynchronousBridge(Task *agent, SynchronousClient *client) :
+        BridgeTask(agent),
+        the_client(client) {
+    }
+
+    /// See Task::start.
+    double start() override;
+
+    /// Will call the client's SynchronousClient::newEventFromAgent method.
+    void sendMsgToClient(const std::string &msg) override;
+
+    virtual ~SynchronousBridge() override;
+private:
+    void clear_queue() {
+        while (!incoming_messages.empty()) {
+            std::string msg = incoming_messages.front();
+            incoming_messages.pop_front();
+            log() << "sendMsgToAgent " << msg;
+            sendMsgToAgent(msg);
+        }
+    }
+    SynchronousClient *the_client;
+    std::deque<std::string> incoming_messages;
+};
diff --git a/src/framework/task.cpp b/src/framework/task.cpp
new file mode 100644
index 0000000..bf4bccb
--- /dev/null
+++ b/src/framework/task.cpp
@@ -0,0 +1,146 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "task.h"
+#include "socketconnection.h"
+#include "serversocket.h"
+
+#ifdef USE_THREADS
+thread_local
+#endif
+EventLoop *Task::supervisor = nullptr;
+
+Task::Task(const std::string &task_name) :
+    Logger(task_name) {
+    log() << "Task " << task_name << " created";
+}
+
+void Task::setResult(const std::string &res) {
+    if (is_finished) {
+        dbg_log() << "result already set, ignoring " << res;
+    } else {
+        dbg_log() << "setResult " << res;
+        is_finished = true;
+        the_result = res;
+        if (has_started)
+            supervisor->notifyTaskFinished(this);
+    }
+}
+
+void Task::setMessage(const std::string &msg) {
+    the_message = msg;
+    supervisor->notifyTaskMessage(this);
+}
+
+PollState Task::connectionReady(SocketConnection * /* conn */) {
+    log() << "connectionReady not implemented";
+    return PollState::CLOSE;
+}
+
+PollState Task::msgFromConnection(SocketConnection * /* conn */,
+                            const std::string & /* msg */) {
+    log() << "msgFromConnection not implemented";
+    return PollState::CLOSE;
+}
+
+bool Task::addConnection(SocketConnection *conn) {
+    if (terminated()) {
+        if (conn)
+            delete conn;
+        return false;
+    }
+    return supervisor->addConnection(conn);
+}
+
+bool Task::addConnected(SocketConnection *conn) {
+    if (terminated()) {
+        if (conn)
+            delete conn;
+        return false;
+    }
+    return supervisor->addConnected(conn);
+}
+
+bool Task::adoptConnection(Socket *conn) {
+    conn->setOwner(this);
+    return true;
+}
+
+std::set<Socket *> Task::getMyConnections() const {
+    return supervisor->findConnByTask(this);
+}
+
+void Task::wakeUp() {
+    supervisor->wakeUpTask(this);
+}
+
+Task::~Task() {
+    supervisor->taskDeleted(this);
+}
+
+bool Task::addServer(ServerSocket *conn) {
+    if (terminated()) {
+        if (conn)
+            delete conn;
+        return false;
+    }
+    return supervisor->addServer(conn);
+}
+
+int Task::runProcess(const char *const argv[]) {
+    return supervisor->externalCommand(this, argv);
+}
+
+void Task::processFinished(int pid, int wstatus) {
+    log() << "Process " << pid << " finished, status " << wstatus;
+}
+
+bool Task::parseListen(const TaskConfig &tc, const std::string &log_label) {
+    auto to = tc.cfg().upper_bound("listen");
+    for (auto p=tc.cfg().lower_bound("listen"); p!=to; ++p) {
+        std::istringstream s(p->second);
+        uint16_t port;
+        std::string ip;
+        s >> port;
+        if (!s) {
+            err_log() << "Bad configuration directive: listen " << p->second;
+            setError("bad configuration directive");
+            return false;
+        }
+        s >> ip;
+        bool tls;
+        if (ip.empty()) {
+            tls = false;
+        } else if (ip == "tls") {
+            ip.clear();
+            tls = true;
+        } else {
+            std::string tmp;
+            s >> tmp;
+            tls = (tmp == "tls");
+        }
+        auto sock = new ServerSocket(log_label, this, port, ip);
+#ifdef USE_GNUTLS
+        if (tls) {
+            std::string cert, key, password;
+            s >> cert >> key >> password;
+            if (key.empty() || !tlsSetKey(sock, cert, key, password)) {
+                err_log() << "Bad configuration: " << p->second;
+                setError("cannot use TLS certificate");
+                return false;
+            }
+            log() << "Port " << port << " enable TLS";
+        }
+#else
+        if (tls) {
+            err_log() << "cannot enable TLS, will not listen on port " << port;
+            return false;
+        }
+#endif
+        if (!addServer(sock)) {
+            setError("cannot listen");
+            return false;
+        }
+    }
+    return true;
+}
diff --git a/src/framework/task.h b/src/framework/task.h
new file mode 100644
index 0000000..31e7a7f
--- /dev/null
+++ b/src/framework/task.h
@@ -0,0 +1,519 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <set>
+#include <fstream>
+#include "logger.h"
+#include "taskconfig.h"
+#include "eventloop.h"
+
+class Socket;
+class ServerSocket;
+class SocketConnection;
+enum class PollState;
+class SocketReceiver;
+class WorkerProcess;
+
+/// \brief
+/// The purpose of a task is to manage socket connections, and/or to execute
+/// timers.
+///
+/// This is essentially an abstract base class. You must create subclasses and
+/// pass subclass objects to the EventLoop's addTask method.
+///
+/// Timers are very simple; the start method must return the number of seconds
+/// until the timerEvent method should be called. The overridden timerEvent can
+/// do whatever it needs and then return the number of seconds until it should
+/// be called again. A value <= 0 means it will never be called again.
+///
+/// Note that the application will be single threaded. Thus, timers (and other
+/// callbacks) must avoid blocking and generally try do be as quick as possible,
+/// otherwise all subsequent timers will be delayed.
+///
+/// The Task may create SocketConnection objects and add them using the
+/// addConnection method. It may also create ServerSocket objects and
+/// add them with addServer; whenever a client connects to the server,
+/// you will be notified through the newClient method.
+class Task : public Logger {
+public:
+    /// \brief Create a task with the given name.
+    ///
+    /// The name will be used as a log label
+    /// and may be retrieved using the inherited Logger::label method.
+    ///
+    /// The EventLoop might not be available when the constructor is run, so
+    /// do not use it in the constructor of any subclass. Any asynchronous
+    /// initialization should be performed in the Task::start() method.
+    Task(const std::string &task_name);
+
+    /// A Task object will be deleted by the EventLoop after it has finished
+    /// and its parent task has been notified.
+    virtual ~Task();
+
+    /// When the EventLoop starts executing a task, it will call its start
+    /// method. All non-trivial initialization, e.g. creating new socket
+    /// connections, should be performed in the start method.
+    ///
+    /// If the task needs a timer, the start method must return the number of
+    /// seconds until timerEvent should
+    /// be called, or <= 0 if you don't want it to be called.
+    virtual double start() {
+        dbg_log() << "Task starting. No timer.";
+        return 0;
+    }
+
+    /// Return number of seconds until this method should be
+    /// called again, or <= 0 if you don't want it to be called again.
+    virtual double timerEvent() {
+        dbg_log() << "Default timerEvent: will kill task.";
+        setTimeout();
+        return 0;
+    }
+
+    /// Run timerEvent after s seconds instead of previous value.
+    void resetTimer(double s) {
+        supervisor->resetTimer(this, s);
+    }
+
+    /// \brief
+    /// Return true if the task has finished normally.
+    ///
+    /// This method is meant to be used in the taskFinished callback.
+    bool finishedOK() const {
+        return (has_started && is_finished && !was_killed &&
+                !was_error && !was_timeout);
+    }
+
+    /// \brief
+    /// Return true if the task is finished and was aborted by another task.
+    ///
+    /// This method is meant to be used in the taskFinished callback.
+    bool wasKilled() const {
+        return was_killed;
+    }
+
+    /// \brief
+    /// Return true if the task terminated with an error.
+    ///
+    /// This method is meant to be used in the taskFinished callback.
+    bool wasError() const {
+        return was_error;
+    }
+
+    /// \brief
+    /// Return true if the task terminated with a timeout.
+    ///
+    /// This method is meant to be used in the taskFinished callback.
+    bool wasTimeout() const {
+        return was_timeout;
+    }
+
+    /// Return true if the task has been added to the EventLoop and its
+    /// Task::start() method has been executed.
+    bool hasStarted() const {
+        return has_started;
+    }
+
+    /// Call this in the start() callback if you want all child tasks to be
+    /// killed when this task is finished.
+    void killChildTaskWhenFinished() {
+        kill_children = true;
+    }
+
+    /// Ignore this unless the task is a server task.
+    /// If a new remote connection is made through any ServerSocket object
+    /// owned by us, the client socket, ip address and port number will
+    /// be passed to the below method. Override it to create and return
+    /// an object of a subclass to SocketConnection, otherwise the client
+    /// socket will be closed. The object will be owned by the implementation
+    /// and will be deleted when the connection has been closed. You _must_
+    /// create the object with new.
+    virtual SocketConnection *newClient(int, const char *, uint16_t,
+                                        ServerSocket *) {
+        return nullptr;
+    }
+
+    /// Request for me to adopt a socket owned by some other task.
+    /// Return false to reject. Otherwise set me as owner and return true.
+    virtual bool adoptConnection(Socket *conn);
+
+    /// This will be called to notify us when a new client socket object
+    /// has been successfully added to this task.
+    /// If you need to know that, override this method.
+    virtual void connAdded(SocketConnection *) {
+    }
+
+    /// This will be called when a client socket object has been removed from
+    /// this task, just before it is deleted.
+    /// If you need to know that, override this method.
+    virtual void connRemoved(SocketConnection *) {
+    }
+
+    /// This will be called to notify us when a new server (listening) socket
+    /// object has been successfully added to this task.
+    /// If you need to know that, override this method.
+    virtual void serverAdded(ServerSocket *) {
+    }
+
+    /// This will be called when a server socket object has been removed from
+    /// this task, just before it is deleted.
+    /// If you need to know that, override this method.
+    virtual void serverRemoved(ServerSocket *) {
+    }
+
+    /// To get the "result" of the task after it has finished.
+    std::string result() const {
+        return the_result;
+    }
+
+    /// Return all current connections.
+    std::set<Socket *> getMyConnections() const;
+
+    /// Return true if the connection still exists.
+    bool isActive(Socket *conn) const {
+        return supervisor->isActive(conn);
+    }
+
+    /// Restart all idle connections
+    void wakeUp();
+
+    /// If s is idle, restart it and return true. Otherwise return false.
+    bool wakeUpConnection(SocketConnection *s) {
+        return supervisor->wakeUpConnection(s);
+    }
+
+    /// Terminate and remove a connection.
+    void cancelConnection(SocketConnection *s) {
+        supervisor->cancelConnection(s);
+    }
+
+    /// Return the current (outgoing) message.
+    std::string message() const {
+        return the_message;
+    }
+
+    /// Notify that this task will be observing task "to". This task will be
+    /// notified through a call to taskFinished if "to" terminates before me.
+    /// (A parent task is observing its child tasks by default.)
+    bool startObserving(Task *to) {
+        return supervisor->startObserving(this, to);
+    }
+
+    /// Execute receiver's Task::handleExecution method immediately. The call
+    /// will be ignored unless this task is observing the receiver.
+    /// Note that you could also call `receiver->handleExecution()` (or any
+    /// other method in receiver) directly. However, that might be dangerous
+    /// since your pointer to the receiver is a _weak reference_ and you
+    /// must somehow make sure that the receiver still exists.
+    /// The advantages of using this API instead of directly calling
+    /// methods in the receiver task are:
+    ///   1. Safer; the call will be ignored if the receiver task doesn't exist.
+    ///   2. The sender and receiver classes do not have to know each other.
+    ///   3. Since you are observing the receiver, you will be notified
+    ///      when the receiver task terminates.
+    ///
+    /// *Note*:
+    /// Essentially, the receiver's Task::handleExecution method executes from
+    /// within the sender's method (event handler). If the receiver in any
+    /// way modifies the sender from within its Task::handleExecution method,
+    /// bad things may happen. Code the Task::handleExecution methods carefully.
+    void executeHandler(Task *receiver, const std::string &message) {
+        if (supervisor->isObserving(this, receiver) && !receiver->terminated())
+            receiver->handleExecution(this, message);
+        else
+            log() << "Will not call handleExecution since task isn't observed.";
+    }
+
+    /// \brief
+    /// Return number of seconds since the task was started.
+    ///
+    /// The start time of a task is when the Task::start method is executed.
+    /// Do not call this method until the task has been added to the EventLoop.
+    double elapsed() const {
+        return secondsSince(start_time);
+    }
+#ifndef _WIN32
+    /// Override this if you intend to start child processes with
+    /// createWorker(). It will be executed in the child process.
+    /// wno is the argument last parameter you supplied to createWorker().
+    /// You must create a Task with new and return its address.
+    virtual Task *createWorkerTask(unsigned int wno) {
+        log() << "missing createWorkerTask, cannot create worker " << wno;
+        return nullptr;
+    }
+
+    /// This will be called in child process directly before exit.
+    /// Override if you need to clean up after createWorkerTask.
+    virtual void finishWorkerTask(unsigned int ) {
+    }
+
+    /// Called during startup of worker process, once for each SocketReceiver
+    /// object. Will be called before serverAdded with the same SocketReceiver.
+    /// Overload this if your worker process has two or more SocketReceiver
+    /// objects with different confguration (i.e. different SSL keys).
+    virtual void newWorkerChannel(SocketReceiver *, unsigned int ) {
+    }
+
+    /// Called if parent/worker sends a message through a SocketReceiver:
+    virtual void workerMessage(SocketReceiver *, const char *buf, size_t len) {
+        log() << "Worker message: " << std::string(buf, len);
+    }
+#endif
+
+    /// Normally, SocketConnection objects are designed for a specific type of
+    /// Task, i.e. a HttpServerConnection might be designed for a WebServerTask.
+    /// However, some SocketConnection subclasses are "generic" and meant to
+    /// work with any Task object as owner. When such SocketConnection objects
+    /// want to contact the owner, they may use this method to signal that the
+    /// socket has been connetced.
+    ///
+    /// Return PollState::READ to keep the connection,
+    /// or PollState::CLOSE to close it.
+    virtual PollState connectionReady(SocketConnection * /* conn */);
+
+
+    /// Normally, SocketConnection objects are designed for a specific type of
+    /// Task, i.e. a HttpServerConnection might be designed for a WebServerTask.
+    /// However, some SocketConnection subclasses are "generic" and meant to
+    /// work with any Task object as owner. When such SocketConnection objects
+    /// have a message for their owner, they may use this method.
+    ///
+    /// Return PollState::READ to keep the connection,
+    /// or PollState::CLOSE to close it.
+    virtual PollState msgFromConnection(SocketConnection * /* conn */,
+                                        const std::string & /* msg */);
+
+    /// Number of bytes sent through SocketConnection objects owned by me.
+    uint64_t bytesSent() const {
+        return tot_bytes_sent;
+    }
+
+    /// Number of bytes received through SocketConnection objects owned by me.
+    uint64_t bytesReceived() const {
+        return tot_bytes_received;
+    }
+
+    /// \brief
+    /// Reset the values for the methods Task::bytesSent
+    /// and Task::bytesReceived.
+    void resetByteCount() {
+        tot_bytes_sent = 0;
+        tot_bytes_received = 0;
+    }
+
+    /// \brief
+    /// Notify the task that data has been sent on its behalf.
+    ///
+    /// For use *only* by custom SocketConnection subclasses after calling send
+    /// directly on a socket.
+    /// Don't call the this methods unless you know what you're doing.
+    void notifyBytesSent(uint64_t n) {
+        tot_bytes_sent += n;
+    }
+
+    /// \brief
+    /// Notify the task that data has been received on its behalf.
+    ///
+    /// For use *only* by custom SocketConnection subclasses after calling recv
+    /// directly on a socket.
+    /// Don't call the this methods unless you know what you're doing.
+    void notifyBytesReceived(uint64_t n) {
+        tot_bytes_received += n;
+    }
+
+protected:
+
+    /// To add a new client connection. Will delete conn and return false
+    /// on immediate failure. connRemoved will not be called in that case.
+    ///
+    /// The connection must belong to a _running_ task (probably this one).
+    /// I.e. the task must have been added to the EventLoop and the start()
+    /// method must have been called. You can't do this in the constructor!
+    ///
+    /// If successfully added, we will call connAdded and return true.
+    /// The EventLoop takes ownership of the SocketConnection object and
+    /// will call connRemoved and then delete it if the connection fails or
+    /// is closed or when the task is finished.
+    bool addConnection(SocketConnection *conn);
+
+    /// Use this if conn contains a socket that has already been connected.
+    /// Returns false (and deletes conn) on failure.
+    /// On success, returns true and calls connAdded on owner task,
+    /// then calls connected() on conn to get initial state.
+    bool addConnected(SocketConnection *conn);
+
+    /// As Task::addConnected, but with a server connection.
+    bool addServer(ServerSocket *conn);
+
+    /// Check config file for listening (server) sockets. The sockets
+    /// are added to the task, with the given log_label. E.g.
+    ///
+    ///     listen 80 192.36.30.2
+    ///     listen 8080
+    ///     listen 443 tls /etc/ssl/fd.crt /etc/ssl/fd.key 4lEGyLax
+    ///
+    /// The value of the listen parameter is either a port number,
+    /// e.g. "8080", or a port number followed by a space and an ip address,
+    /// e.g. "8080 192.168.0.1". The address is either ipv4 or ipv6.
+    /// If connections are to be encrypted, add "tls" followed by
+    /// paths to your SSL certificate and private key, optionally followed
+    /// by the password (if the key is protected by a password).
+    bool parseListen(const TaskConfig &tc, const std::string &log_label);
+
+#ifdef USE_GNUTLS
+    /// Use SSL certificate for a listening socket.
+    virtual bool tlsSetKey(ServerSocket *conn, const std::string &crt_path,
+                   const std::string &key_path, const std::string &password) {
+        return supervisor->tlsSetKey(conn, crt_path, key_path, password);
+    }
+#endif
+
+    /// When the task is done, it should notify the EventLoop by calling the
+    /// Task::setResult method. Then the task's parent will be notified and the
+    /// task will be deleted. The "result" of the task should be a non-empty
+    /// string on success, and an empty string on timeout or error.
+    /// Of course, subclasses can calculate more complex custom "results" in
+    /// addition to this simple string.
+    void setResult(const std::string &res);
+
+    /// Called to signal fatal error. May be overridden to "catch" errors.
+    /// It should always call Task::setResult with an empty string.
+    virtual void setError(const std::string &msg) {
+        log() << "Task failure: " << msg;
+        was_error = true;
+        setResult("");
+    }
+
+    /// Called to signal timeout. May be overridden to "catch" timeouts.
+    /// It should always call Task::setResult with an empty string.
+    virtual void setTimeout() {
+        was_timeout = true;
+        setResult("");
+    }
+
+    /// Call to signal that the task has a "message" to deliver. The parent
+    /// will be notified using the taskMessage method. Only the last message
+    /// will be stored, and it may be retrieved using the message method.
+    void setMessage(const std::string &msg);
+
+    /// Called when an observed task, e.g. a child task, terminates.
+    /// Override this method to handle such events.
+    virtual void taskFinished(Task *task) {
+        dbg_log() << "Task " << task->label() << " died, no handler defined.";
+    }
+
+    /// Called when an a child task has (set/sent) a message.
+    /// Override this method to handle such events.
+    virtual void taskMessage(Task *task) {
+        dbg_log() << "No taskMessage handler implemented for " << task->label();
+    }
+
+    /// Callback to execute code on behalf of another Task.
+    virtual void handleExecution(Task *sender, const std::string &message) {
+        dbg_log() << "Event " << message << " from "
+                  << (sender ? sender->label() : "unknown")
+                  << ", no handler implemented";
+    }
+
+    /// \brief
+    /// Return true if task is finished.
+    ///
+    /// By default, this will return true if the task has called
+    /// the Task::setResult method.
+    ///
+    /// The task will be deleted very soon unless return value is false. So
+    /// this method is mostly useful within the Task subclass itself, checking
+    /// if it is about to be removed.
+    bool terminated() const {
+        return is_finished;
+    }
+
+    /// Insert another Task for execution by the EventLoop.
+    void addNewTask(Task *task, Task *parent = nullptr) {
+        supervisor->addTask(task, parent);
+    }
+
+#ifdef USE_THREADS
+    /// Run task in a new thread.
+    void addNewThread(Task *task, const std::string &name="ThreadLoop",
+                      std::ostream *log_file = nullptr,
+                      Task *parent = nullptr) {
+        supervisor->spawnThread(task, name, log_file, parent);
+    }
+#endif
+
+    /// Add all my child tasks to the given set.
+    void getMyTasks(std::set<Task *> &tset) {
+        supervisor->getChildTasks(tset, this);
+    }
+
+    /// Terminate all my child tasks.
+    void abortMyTasks() {
+        supervisor->abortChildTasks(this);
+    }
+
+    /// Terminate a task.
+    void abortTask(Task *task) {
+        supervisor->abortTask(task);
+    }
+
+    /// Terminate all tasks and exit the EventLoop.
+    void abortAllTasks() {
+        supervisor->abort();
+    }
+
+    /// Start execution of external command, return an ID.
+    /// On immediate failure, return value is -1.
+    int runProcess(const char *const argv[]);
+
+    /// Will be called to notify when an external process has terminated.
+    virtual void processFinished(int pid, int wstatus);
+
+#ifndef _WIN32
+    /// \brief
+    /// Run task returned by this->createWorkerTask in a child process.
+    /// Return nullptr on failure.
+    WorkerProcess *createWorker(std::ostream *log_file = nullptr,
+                                unsigned int channels = 1,
+                                unsigned int wno = 0) {
+        return supervisor->createWorker(this, log_file, channels, wno);
+    }
+
+    /// \brief
+    /// Run task returned by this->createWorkerTask in a child process.
+    /// Return nullptr on failure.
+    WorkerProcess *createWorker(const std::string &log_file_name,
+                                unsigned int channels = 1,
+                                unsigned int wno = 0) {
+        return supervisor->createWorker(this, log_file_name, channels, wno);
+    }
+#endif
+
+private:
+    friend class EventLoop;
+    void setTerminated() {
+        is_finished = true;
+    }
+    // Called by EventLoop when task is scheduled for execution:
+    double begin() {
+        has_started = true;
+        start_time = timeNow();
+        return this->start();
+    }
+
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static EventLoop *supervisor;
+    TimePoint start_time;
+    std::string the_result;
+    std::string the_message;
+    uint64_t tot_bytes_sent = 0, tot_bytes_received = 0;
+    bool is_finished = false;
+    bool has_started = false;
+    bool was_killed = false, was_error = false, was_timeout = false;
+    bool kill_children = false;
+    bool is_child_thread = false;
+};
diff --git a/src/framework/taskconfig.cpp b/src/framework/taskconfig.cpp
new file mode 100644
index 0000000..b00c2cc
--- /dev/null
+++ b/src/framework/taskconfig.cpp
@@ -0,0 +1,196 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <sstream>
+#include <fstream>
+#include <iostream>
+#include "taskconfig.h"
+#include "eventloop.h"
+#include "../json11/json11.hpp"
+
+TaskConfig::TaskConfig(std::istream &cfg_stream) {
+    _load(cfg_stream);
+}
+
+TaskConfig::TaskConfig(const std::string &cfg_text) {
+    std::istringstream cfg_stream(cfg_text);
+    _load(cfg_stream);
+}
+const char *BadTaskConfig::what() const noexcept {
+    return err_msg.c_str();
+}
+
+BadTaskConfig::~BadTaskConfig() noexcept {
+}
+
+TaskConfig TaskConfig::load(const std::string &filename) {
+    std::ifstream cfg_stream(filename);
+    return TaskConfig(cfg_stream);
+}
+
+std::string TaskConfig::value(const std::string &key, const std::string &default_value) const {
+    auto range = the_config.equal_range(key);
+    if (range.first == range.second)
+        return default_value;
+    --range.second;
+    return range.second->second;
+}
+
+void TaskConfig::openlog(std::ofstream &logger, bool append) const {
+    auto p = the_config.find("logfile");
+    if (p != the_config.end() && p->second != "-") {
+        logger.open(p->second, append ? std::ios::app : std::ios::trunc);
+        if (logger) {
+            Logger::setLogFile(logger);
+#ifndef _WIN32
+            EventLoop::setLogFilename(p->second);
+#endif
+        }
+    }
+}
+
+void TaskConfig::add(const std::string &key, const std::string &val) {
+    the_config.insert(std::make_pair(key, val));
+}
+
+void TaskConfig::addLine(const std::string &line) {
+    size_t pos = line.find('#');
+    if (pos != std::string::npos) {
+        addLine(line.substr(0, pos));
+        return;
+    }
+    if (line.empty())
+        return;
+    pos = line.find(" ");
+    if (pos == std::string::npos)
+        the_config.insert(std::make_pair(line, std::string()));
+    else
+        the_config.insert(std::make_pair(line.substr(0, pos),
+                                         line.substr(pos+1)));
+}
+
+void TaskConfig::workerAttributes(const std::set<std::string> &attrs) {
+    std::vector<std::string> to_add;
+    for (auto &p : the_config)
+        if (attrs.find(p.first) != attrs.end())
+            to_add.push_back(p.first + " " + p.second);
+    for (auto &line : to_add)
+        add("workercfg", line);
+}
+
+void TaskConfig::_load(std::istream &cfg_stream) {
+    std::string line;
+    while (getline(cfg_stream, line)) {
+        addLine(line);
+    }
+    if (!cfg_stream.eof())
+        throw BadTaskConfig();
+}
+
+std::ostream &operator<<(std::ostream &out, const TaskConfig &tc) {
+    out << "[ ";
+    for (auto &p : tc)
+        out << p.first << " --> " << p.second << " ";
+    out << ']';
+    return out;
+}
+
+std::set<std::string>
+TaskConfig::parseList(const std::string &category) const {
+    std::string val;
+    std::set<std::string> res;
+    auto to = the_config.upper_bound(category);
+    for (auto p=the_config.lower_bound(category); p!=to; ++p) {
+        std::istringstream s(p->second);
+        while (s >> val)
+            res.insert(val);
+    }
+    return res;
+}
+
+void TaskConfig::parseArgs(int &argc, char **&argv) {
+    int apos = 0;
+    while (++apos < argc) {
+        std::string arg = argv[apos];
+        if (arg.substr(0, 2) != "--")
+            break;
+        arg.erase(0, 2);
+        if (arg.empty()) {
+            ++apos;
+            break;
+        }
+        auto pos = arg.find('=');
+        if (pos == std::string::npos)
+            the_config.insert(std::make_pair(arg, std::string()));
+        else if (pos)
+            the_config.insert(std::make_pair(arg.substr(0, pos),
+                                             arg.substr(pos+1)));
+        // else ignore
+    }
+    if (--apos) {
+        argc -= apos;
+        argv[apos] = argv[0];
+        argv += apos;
+    }
+}
+
+std::map<std::string, std::string>
+TaskConfig::parseKeyVal(const std::string &category) const {
+    std::string key, val;
+    std::map<std::string, std::string> res;
+    auto to = the_config.upper_bound(category);
+    for (auto p=the_config.lower_bound(category); p!=to; ++p) {
+        std::istringstream s(p->second);
+        if (s >> key >> val)
+            res.insert(std::make_pair(key, val));
+    }
+    return res;
+}
+
+/*Preconditions: New configs set with method "saveConfigurationOption"
+Old config options loaded into the_config in MeasurementAgent() (loadJsonFromFile).
+Postconditions: Configuration options transferred onto file */
+bool TaskConfig::saveJsonToFile(const std::string &filename) {
+    std::fstream cfgOptionsFile;
+
+    //Create file if not existing. Write the updated config in json-format to file.
+    cfgOptionsFile.open(filename, std::fstream::out);
+    if (cfgOptionsFile.is_open()) {
+        cfgOptionsFile << json11::Json(the_config).dump();
+    } else {
+        Logger::log("TaskConfig") << "Unable to open config file";
+    }
+
+    cfgOptionsFile.close();
+    return bool(cfgOptionsFile);
+}
+
+/*
+Used to load preexisting configuration options from file into json-object for further use.
+*/
+TaskConfig TaskConfig::loadJsonFromFile(const std::string &filename){
+    std::string fileContent;
+    std::ifstream inFile;
+    std::string err;
+    TaskConfig cfg;
+
+    inFile.open(filename);
+
+    if (inFile.is_open() && inFile) {
+        //consume entire inFile, from beginning to end.
+        fileContent.assign( (std::istreambuf_iterator<char>(inFile)),
+                                 (std::istreambuf_iterator<char>()) );
+    } else {
+        Logger::log("TaskConfig") << "Unable to open config file";
+    }
+
+    json11::Json JsonObj = json11::Json::parse(fileContent, err);
+
+    inFile.close();
+
+    for (auto p : JsonObj.object_items()) {
+        cfg.add(p.first, p.second.string_value());
+    }
+
+    return cfg;
+}
diff --git a/src/framework/taskconfig.h b/src/framework/taskconfig.h
new file mode 100644
index 0000000..421e758
--- /dev/null
+++ b/src/framework/taskconfig.h
@@ -0,0 +1,161 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <map>
+#include <set>
+#include <string>
+#include <stdexcept>
+#include <iostream>
+#include <fstream>
+
+/// Exception thrown on syntax errors in task config
+class BadTaskConfig : public std::exception {
+public:
+    BadTaskConfig(const std::string &msg = "cannot read config file") :
+        err_msg(msg) {
+    }
+    const char *what() const noexcept override;
+    BadTaskConfig(const BadTaskConfig &old) : err_msg(old.err_msg) {
+    }
+    ~BadTaskConfig() noexcept override;
+    std::string err_msg;
+};
+
+/// \brief
+/// Read configuration from file or string
+///
+/// Empty lines are ignored.
+///
+/// A # character means the rest of the line is a comment.
+///
+/// All other lines must contain a configuration directive.
+/// If the line contains a space, the directive ends at the first space,
+/// and the rest of the line is the value of the directive.
+///
+/// Example:
+///
+///     logfile /var/log/my_service.log
+///     name My Service  # Will be printed in greeting message
+///
+///     listen 80
+///     listen 443 tls /etc/pki/tls/certs/mycert.pem /etc/pki/tls/private/mycert.pem
+class TaskConfig {
+public:
+    /// Empty configuration.
+    TaskConfig() {}
+
+    /// Load configuration from file.
+    TaskConfig(std::istream &cfg_stream);
+
+    /// Load configuration from string.
+    TaskConfig(const std::string &cfg_text);
+
+    /// Add a directive to the config.
+    void add(const std::string &key, const std::string &val);
+
+    /// Replace value(s) of a directive with a new one.
+    void set(const std::string &key, const std::string &val) {
+        the_config.erase(key);
+        add(key, val);
+    }
+
+    /// Remove value(s) of a directive.
+    void erase(const std::string &key) {
+        the_config.erase(key);
+    }
+
+    /// Set value of a directive unless already set.
+    void setDefault(const std::string &key, const std::string &val) {
+        if (the_config.find(key) == the_config.end())
+            add(key, val);
+    }
+
+    /// Incrementally add to the config.
+    void addLine(const std::string &line);
+
+    /// Start iterator to loop over the config.
+    std::multimap<std::string, std::string>::iterator begin() {
+        return the_config.begin();
+    }
+
+    /// End iterator to loop over the config.
+    std::multimap<std::string, std::string>::iterator end() {
+        return the_config.end();
+    }
+
+    /// Start const iterator to loop over the config.
+    std::multimap<std::string, std::string>::const_iterator begin() const {
+        return the_config.begin();
+    }
+
+    /// End const iterator to loop over the config.
+    std::multimap<std::string, std::string>::const_iterator end() const {
+        return the_config.end();
+    }
+
+    /// Make a set of directives available to worker processes.
+    void workerAttributes(const std::set<std::string> &attrs);
+
+    /// Read config from file.
+    static TaskConfig load(const std::string &filename);
+
+    /// Return the parsed configuration.
+    const std::multimap<std::string, std::string> &cfg() const {
+        return the_config;
+    }
+
+    /// Return value of last occurence of key. Return default_value if key does not exist.
+    std::string value(const std::string &key, const std::string &default_value = "") const;
+
+    /// Return true if key exists, otherwise false:
+    bool hasKey(const std::string &key) const {
+        return the_config.find(key) != the_config.end();
+    }
+
+    /// Return a range of the key/value paris for the given key.
+    std::pair<std::multimap<std::string, std::string>::const_iterator,
+        std::multimap<std::string, std::string>::const_iterator>
+        range(const std::string &key) const {
+        return the_config.equal_range(key);
+    }
+
+    /// \brief
+    /// Log to the file specified by the `logfile` directive.
+    ///
+    /// If the `logfile` key exists, and its value is not "-", try to use the
+    /// value as a file name for the log.
+    void openlog(std::ofstream &logger, bool append = false) const;
+
+    /// \brief
+    /// Split config value into non-blank strings.
+    ///
+    /// Return set of all non-whitespace strings listed after the configuration
+    /// directive given by second parameter.
+    std::set<std::string>
+        parseList(const std::string &category = "whitelist") const;
+
+    /// Parse command line arguments starting with "--":
+    void parseArgs(int &argc, char **&argv);
+
+    /// Return map of all key-value pairs of strings listed after the
+    /// configuration directive given by second parameter.
+    std::map<std::string, std::string>
+        parseKeyVal(const std::string &category = "user") const;
+
+    /// Store contents as a JSON object. Return false on failure.
+    bool saveJsonToFile(const std::string &filename);
+
+    /// \brief Load key/value pairs from JSON object.
+    ///
+    /// Values that are not strings will
+    /// be ignored. Return empty object on failure.
+    static TaskConfig loadJsonFromFile(const std::string &filename);
+
+private:
+    void _load(std::istream &cfg_stream);
+    std::multimap<std::string, std::string> the_config;
+};
+
+std::ostream &operator<<(std::ostream &out, const TaskConfig &tc);
diff --git a/src/framework/threadbridge.cpp b/src/framework/threadbridge.cpp
new file mode 100644
index 0000000..d4915f9
--- /dev/null
+++ b/src/framework/threadbridge.cpp
@@ -0,0 +1,42 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "threadbridge.h"
+#include <iostream>
+
+ThreadBridge::ThreadBridge(Task *agent, double tick) :
+    BridgeTask(agent),
+    tick_len(tick) {
+}
+
+double ThreadBridge::start() {
+    BridgeTask::start();
+    return tick_len;
+}
+
+double ThreadBridge::timerEvent() {
+    std::string msg;
+    while (true) {
+        method_queue.fetch(msg);
+        if (msg.empty())
+            return tick_len;
+        sendMsgToAgent(msg);
+        msg.clear();
+    }
+}
+
+void ThreadBridge::pushToAgent(const std::string &msg) {
+    dbg_log() << "To agent: " << msg;
+    method_queue.push(msg);
+}
+
+std::string ThreadBridge::popFromAgent() {
+    std::string msg;
+    event_queue.fetch(msg);
+    return msg;
+}
+
+void ThreadBridge::sendMsgToClient(const std::string &msg) {
+    dbg_log() << "To client: " << msg;
+    event_queue.push(msg);
+}
diff --git a/src/framework/threadbridge.h b/src/framework/threadbridge.h
new file mode 100644
index 0000000..53212b4
--- /dev/null
+++ b/src/framework/threadbridge.h
@@ -0,0 +1,37 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include "bridgetask.h"
+#include "msgqueue.h"
+
+/// \brief
+/// Bridge using a thread safe queue to enable communication
+/// between agent and client.
+class ThreadBridge : public BridgeTask {
+public:
+    ThreadBridge(Task *agent = nullptr, double tick=0.05);
+
+    /// API for client to send message to the agent.
+    void pushToAgent(const std::string &msg)
+
+    /// \brief
+    /// API for client to retrieve next message from agent.
+    ///
+    /// If no messages are available, an empty string will be returned.
+    /// Client shoud call this regularly.
+    std::string popFromAgent();
+
+    /// Pass message to the client.
+    void sendMsgToClient(const std::string &msg) override;
+
+    /// Initiate timer to be called after `tick` seconds.
+    double start() override;
+
+    /// Push queued messages for the agent. Called every `tick` seconds.
+    double timerEvent() override;
+private:
+    MsgQueue<std::string> method_queue, event_queue;
+    double tick_len;
+};
diff --git a/src/framework/unixdomainbridge.cpp b/src/framework/unixdomainbridge.cpp
new file mode 100644
index 0000000..61e45fa
--- /dev/null
+++ b/src/framework/unixdomainbridge.cpp
@@ -0,0 +1,42 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "unixdomainbridge.h"
+#include "shortmessageconnection.h"
+
+UnixDomainBridge::UnixDomainBridge(Task *agent) :
+    BridgeTask(agent),
+    msg_conn(new ShortMessageConnection("UDBridgeConn", this, "UnixDomain", 0)) {
+}
+
+double UnixDomainBridge::start() {
+    BridgeTask::start();
+    addConnected(msg_conn);
+    return 0;
+}
+
+void UnixDomainBridge::sendMsgToClient(const std::string &msg) {
+    msg_conn->sendMessage(msg);
+}
+
+int UnixDomainBridge::getClientSocket() const {
+    if (!msg_conn)
+        return 0;
+    return msg_conn->getUnixDomainPeer();
+}
+
+int UnixDomainBridge::getAgentSocket() const {
+    if (!msg_conn || msg_conn->id() < 0)
+        return 0;
+    return msg_conn->id();
+}
+
+PollState UnixDomainBridge::connectionReady(SocketConnection * /* conn */) {
+    return PollState::READ;
+}
+
+PollState UnixDomainBridge::msgFromConnection(SocketConnection *,
+                                              const std::string &msg) {
+    sendMsgToAgent(msg);
+    return PollState::READ;
+}
diff --git a/src/framework/unixdomainbridge.h b/src/framework/unixdomainbridge.h
new file mode 100644
index 0000000..97ceb2f
--- /dev/null
+++ b/src/framework/unixdomainbridge.h
@@ -0,0 +1,49 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include "bridgetask.h"
+class ShortMessageConnection;
+
+/// \brief
+/// Bridge using a pair of Unix domain sockets to enable communication
+/// between agent and client.
+class UnixDomainBridge : public BridgeTask {
+public:
+
+    /// \brief
+    /// Create a bridge to the given agent task.
+    ///
+    /// A pair of Unix domain sockets will be used to enable communication
+    /// between agent and client.
+    UnixDomainBridge(Task *agent = nullptr);
+
+    /// Pass message to the client.
+    void sendMsgToClient(const std::string &msg) override;
+
+    /// \brief
+    /// Get client's socket descriptor.
+    ///
+    /// Return 0 on failure.
+    ///
+    /// *Note:* client may run in another thread or process.
+    /// Use in child, close in parent after fork.
+    int getClientSocket() const;
+
+    /// Close in child after fork.
+    int getAgentSocket() const;
+
+    /// See Task::connectionReady.
+    PollState connectionReady(SocketConnection * /* conn */) override;
+
+    /// Will be called when client has sent a message.
+    PollState msgFromConnection(SocketConnection * /* conn */,
+                                const std::string &msg) override;
+
+    /// See Task::start.
+    double start() override;
+
+private:
+    ShortMessageConnection *msg_conn;
+};
diff --git a/src/framework/unixdomainclient.cpp b/src/framework/unixdomainclient.cpp
new file mode 100644
index 0000000..74a35dd
--- /dev/null
+++ b/src/framework/unixdomainclient.cpp
@@ -0,0 +1,87 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/select.h>
+
+#include "unixdomainclient.h"
+#include "bridgetask.h"
+
+void UnixDomainClient::pushToAgent(const std::string &msg) {
+    to_agent += std::to_string(msg.size());
+    to_agent += '\n';
+    to_agent += msg;
+    auto n = send(client_socket, to_agent.c_str(), to_agent.size(), 0);
+    if (n > 0)
+        to_agent.erase(0, n);
+}
+
+std::string UnixDomainClient::pollAgent() {
+    ssize_t n;
+    while (true) {
+        char buffer[50000];
+        n = recv(client_socket, buffer, sizeof buffer, 0);
+        if (n <= 0)
+            break;
+        to_client.append(buffer, n);
+        // Maybe we should have a max size for a single message.
+    }
+    auto err = errno;
+
+    auto pos = to_client.find('\n');
+    if (pos != std::string::npos) {
+        // Check if a new (complete) message has arrived.
+        try {
+            auto msg_len = std::stoul(to_client.substr(0, pos));
+            if (to_client.size() > pos + msg_len) {
+                ++pos;
+                std::string result = to_client.substr(pos, msg_len);
+                to_client.erase(0, pos+msg_len);
+                return result;
+            }
+        } catch (...) {
+            return BridgeTask::agentTerminatedMessage("bad data");
+        }
+    }
+
+    if (n == 0)
+        return BridgeTask::agentTerminatedMessage("lost connection");
+    if (err && err != EAGAIN && err != EWOULDBLOCK &&
+        err != EINPROGRESS && err != EINTR) {
+        return BridgeTask::agentTerminatedMessage("connection error");
+    }
+    return "";
+}
+
+bool UnixDomainClient::flushToAgent() {
+    if (to_agent.empty())
+        return true;
+    auto n = send(client_socket, to_agent.c_str(), to_agent.size(), 0);
+    if (n > 0) {
+        to_agent.erase(0, n);
+        return to_agent.empty();
+    }
+    return false;
+}
+
+std::string UnixDomainClient::waitForMsgFromAgent(unsigned long timeout_us) {
+
+    std::string msg = pollAgent();
+    if (!msg.empty())
+        return msg;
+
+    struct timeval timeout;
+    timeout.tv_sec = timeout_us/1000000;
+    timeout.tv_usec = timeout_us%1000000;
+
+    fd_set readFds, errFds;
+    FD_ZERO(&readFds);
+    FD_ZERO(&errFds);
+    FD_SET(client_socket, &readFds);
+    FD_SET(client_socket, &errFds);
+    select(client_socket + 1, &readFds, nullptr, &errFds,
+           timeout_us ? &timeout : nullptr);
+
+    return pollAgent();
+}
diff --git a/src/framework/unixdomainclient.h b/src/framework/unixdomainclient.h
new file mode 100644
index 0000000..b184fd4
--- /dev/null
+++ b/src/framework/unixdomainclient.h
@@ -0,0 +1,62 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <string>
+
+/// \brief
+/// Client communicating with an agent task using a UnixDomainBridge.
+///
+/// This class is meant to be used only _outside_ the event loop, i.e. from some
+/// other thread or process. It is used together with a UnixDomainBridge, which
+/// runs in the event loop. After creating the UnixDomainBridge object, call
+/// getClientSocket() on it to get a file descriptor which should be used as
+/// an argument to the constructor of this class. Then make sure the
+/// UnixDomainBridge object runs in an event loop, but not in the same thread or
+/// process as this class.
+class UnixDomainClient {
+public:
+    /// Create client using one of a pair of Unix domain sockets.
+    UnixDomainClient(int peer_fd) :
+        client_socket(peer_fd) {
+    }
+
+    /// \brief
+    /// Return a line of data from the agent.
+    ///
+    /// Will return an empty string if no message is available.
+    ///
+    /// Poll regularly or monitor the socket descriptor.
+    std::string pollAgent();
+
+    /// As UnixDomainClient::pollAgent, but block until a message is available
+    /// or until timeout_us
+    /// microseconds have passed (or forever, if timeout_us is 0).
+    std::string waitForMsgFromAgent(unsigned long timeout_us = 0);
+
+    /// \brief
+    /// Send message to agent.
+    ///
+    /// *Note:* If the message is large (perhaps >200KB),
+    /// it's likely that the complete message can't be delivered to the agent
+    /// immediately. In that case, it will be buffered and you may have to
+    /// call pushToAgent (with new messages) or flushToAgent() repeatedly until
+    /// the buffer is drained. (Of course, unless the agent actively reads the
+    /// messages, the buffer can't be drained.)
+    void pushToAgent(const std::string &msg);
+
+    /// \brief If there is unsent data, retry sending it to the agent.
+    ///
+    /// Return true if agent has received all messages we sent.
+    ///
+    /// If the return value is false,
+    /// you must call flushToAgent again at a later time (e.g.
+    /// after 50ms, or preferably when the socket is found to be writable.)
+    bool flushToAgent();
+
+private:
+    std::string to_agent;
+    std::string to_client;
+    int client_socket;
+};
diff --git a/src/framework/workerprocess.h b/src/framework/workerprocess.h
new file mode 100644
index 0000000..5957f81
--- /dev/null
+++ b/src/framework/workerprocess.h
@@ -0,0 +1,52 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <vector>
+
+class SocketReceiver;
+
+/// \brief
+/// Used by LoadBalancer to manage child processes.
+///
+/// One or more SocketReceiver objects may be used to pass sockets
+/// (and/or messages) between master and child processes.
+///
+/// Each SocketReceiver will be called _a channel_, and they will be
+/// referenced using integers starting with 0.
+///
+/// The point of using channels is to pass different types of connections
+/// (e.g. with or without SSL encryption) on different channels.
+class WorkerProcess {
+public:
+    /// Create worker to run in newly forked process `pid`.
+    WorkerProcess(pid_t pid, std::vector<SocketReceiver *> &receivers) :
+        worker_pid(pid),
+        channels(receivers) {
+    }
+
+    ~WorkerProcess() {
+        for (auto &conn : channels)
+            conn->peerDead();
+    }
+
+    /// Return the PID of the worker process.
+    pid_t pid() const {
+        return worker_pid;
+    }
+
+    /// Return a channel.
+    SocketReceiver *channel(unsigned int n=0) const {
+        return channels.at(n);
+    }
+
+    /// Return number of channels.
+    size_t noChannels() const {
+        return channels.size();
+    }
+
+private:
+    pid_t worker_pid;
+    std::vector<SocketReceiver *> channels;
+};
diff --git a/src/gtkgui/.gitignore b/src/gtkgui/.gitignore
new file mode 100644
index 0000000..ee87bda
--- /dev/null
+++ b/src/gtkgui/.gitignore
@@ -0,0 +1 @@
+bredbandskollen
diff --git a/src/gtkgui/Makefile b/src/gtkgui/Makefile
new file mode 100644
index 0000000..d7c46dd
--- /dev/null
+++ b/src/gtkgui/Makefile
@@ -0,0 +1,26 @@
+TARGET = bredbandskollen
+DIRLEVEL = ..
+
+# Possible LOGLEVEL values: dbg, info, warn, err, none
+LOGLEVEL=info
+
+# We will use Logger in more than one thread:
+THREADS=1
+
+# Uncomment if GnuTLS version 3.5 or later is available
+# GNUTLS=1
+
+SOURCES=../http/cookiefile.cpp \
+	../framework/unixdomainbridge.cpp \
+	../framework/unixdomainclient.cpp \
+	../framework/shortmessageconnection.cpp \
+	main.cpp \
+	gtkclient.cpp \
+	../cli/utils.cpp
+
+CXXFLAGS=$(shell pkg-config --cflags gtk+-3.0)
+LIBS=$(shell pkg-config --libs gtk+-3.0)
+
+#CXXFLAGS += -g
+
+include $(DIRLEVEL)/measurement/mk.inc
diff --git a/src/gtkgui/gtkclient.cpp b/src/gtkgui/gtkclient.cpp
new file mode 100644
index 0000000..e3ea415
--- /dev/null
+++ b/src/gtkgui/gtkclient.cpp
@@ -0,0 +1,407 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <stdio.h>
+
+#include "gtkclient.h"
+#include <glib-unix.h>
+
+void GtkClient::run() {
+    app = gtk_application_new("bbk.iis.se", G_APPLICATION_DEFAULT_FLAGS);
+    g_signal_connect(app, "activate",
+                     G_CALLBACK(GtkClient::activate), this);
+    g_application_run(G_APPLICATION(app), 0, nullptr);
+    g_object_unref(app);
+}
+
+void GtkClient::newEventFromAgent(const std::string &msg) {
+    log() << "Got: " << msg;
+
+    std::string jsonerr;
+    auto obj = json11::Json::parse(msg, jsonerr);
+    if (!jsonerr.empty()) {
+        if (BridgeTask::isAgentTerminatedMessage(msg))
+            setLabel(label_message, msg);
+        else {
+            setLabel(label_message, "JSON error: got " + msg);
+            err_log() << "JSON error";
+        }
+        pushToAgent("terminate");
+        return;
+    }
+
+    std::string event = obj["event"].string_value();
+    auto arg_obj = obj["args"];
+
+    while (state == MState::MEASURING) {
+        if (event == "taskProgress") {
+            std::string tst = arg_obj["task"].string_value();
+            double val = arg_obj["result"].number_value();
+            std::string p = myStrFormat(val) + " Mbit/s";
+            if (tst == "download")
+                setLabel(label_download, p);
+            else if (tst == "upload" || tst == "uploadinfo")
+                setLabel(label_upload, p);
+        } else if (event == "taskStart") {
+        } else if (event == "taskComplete") {
+            gotTaskComplete(arg_obj);
+        } else if (event == "report") {
+            gotReport(arg_obj);
+        } else if (event == "measurementInfo") {
+            std::string id = arg_obj["MeasurementID"].string_value();
+        } else {
+            break;
+        }
+        return;
+    }
+
+    if (event == "configuration") {
+        gotSettings(arg_obj);
+    } else if (event == "agentReady") {
+        if (state == MState::IDLE)
+            pushToAgent("getConfiguration");
+        else if (state == MState::RESTARTING)
+            doStartMeasurement();
+    } else if (event == "measurementList") {
+    } else if (event == "setInfo") {
+        gotInfo(arg_obj);
+    }
+}
+
+void GtkClient::reset() {
+    pushToAgent("resetTest");
+    setLabel(label_message, "");
+    got_ticket = false;
+    user_abort = false;
+    setLabel(label_ticket, "");
+    setLabel(label_latency, "");
+    setLabel(label_download, "");
+    setLabel(label_upload, "");
+    setLabel(label_evaluation, "");
+}
+
+std::string GtkClient::myStrFormat(double x) {
+    char strBuf[80];
+    snprintf(strBuf, sizeof(strBuf), "%7.2f", x);
+    return std::string(strBuf);
+}
+
+void GtkClient::gotReport(const json11::Json &obj) {
+    setLabel(label_pip, obj["localip"].string_value());
+}
+
+void GtkClient::gotTaskComplete(const json11::Json &obj) {
+    std::string tst = obj["task"].string_value();
+    auto res = obj["result"].number_value();
+    if (tst == "global") {
+        if (got_ticket || user_abort) {
+            setState(MState::FINISHED);
+        } else {
+            setState(MState::ERROR);
+            pushToAgent("resetTest");
+        }
+    } else if (tst == "latency")
+        setLabel(label_latency, myStrFormat(res) + " ms");
+    else if (tst == "download")
+        setLabel(label_download, myStrFormat(res) + " Mbit/s");
+    else if (tst == "upload")
+        setLabel(label_upload, myStrFormat(res) + " Mbit/s");
+}
+
+void GtkClient::gotInfo(const json11::Json &obj) {
+    for (auto &p : obj.object_items()) {
+        std::string attr = p.first;
+        std::string value = p.second.string_value();
+        if (attr == "error") {
+            if (!value.empty())
+                setLabel(label_message, "Error: " + value);
+        } else if (attr == "ticket") {
+            setLabel(label_ticket, value);
+            got_ticket = true;
+        } else if (attr == "logText") {
+        } else if (attr == "msgToUser") {
+            setLabel(label_message, value);
+        }
+    }
+}
+
+void GtkClient::gotSettings(const json11::Json &obj) {
+    if (state == MState::ERROR) {
+        setState(MState::IDLE);
+    }
+    settings = obj;
+    setLabel(label_date, dateString());
+    setLabel(label_isp, settings["ispname"].string_value());
+    setLabel(label_ip, settings["ip"].string_value());
+    updateServerBox();
+}
+
+void GtkClient::setLabel(GtkWidget *widget, const std::string &label) {
+    gtk_label_set_text(GTK_LABEL(widget), label.c_str());
+}
+
+void GtkClient::updateServerBox() {
+
+    gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(server_box));
+
+    std::set<std::string> srvName;
+    std::string mtype(gtk_combo_box_text_get_active_text
+                      (GTK_COMBO_BOX_TEXT(iptype_box)));
+    bool tls = false;
+    for (auto srv : settings["servers"].array_items()) {
+        if (srv["type"].string_value() != mtype)
+            continue;
+        if (tls && srv["tlsport"].int_value() == 0)
+            continue;
+        std::string name = srv["name"].string_value();
+        if (srvName.find(name) != srvName.end())
+            continue;
+        srvName.insert(name);
+        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(server_box),
+                                       name.c_str());
+    }
+
+    if (srvName.empty())
+        gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(server_box),
+                                       "No Server");
+
+    gtk_combo_box_set_active(GTK_COMBO_BOX(server_box), 0);
+}
+
+gboolean GtkClient::poll_agent(gint , GIOCondition c, gpointer data) {
+    auto self = reinterpret_cast<GtkClient *>(data);
+    if (c & G_IO_HUP) {
+        // Agent gone
+        self->doQuit();
+        return FALSE;
+    }
+    while (true) {
+        auto msg = self->pollAgent();
+        if (msg.empty())
+            break;
+        self->newEventFromAgent(msg);
+    }
+    return TRUE;
+}
+
+GtkClient::GtkClient(const TaskConfig &config, int unix_domain_peer) :
+    Logger("GUI"),
+    peer_fd(unix_domain_peer),
+    ud_client(peer_fd),
+    the_config(config) {
+    pushToAgent("clientReady");
+}
+
+GtkClient::~GtkClient() {
+    pushToAgent("terminate");
+}
+
+void GtkClient::start_measurement(GtkWidget *, gpointer data) {
+    auto self = reinterpret_cast<GtkClient *>(data);
+    self->doStartMeasurement();
+}
+
+void GtkClient::update_serverlist(GtkWidget *, gpointer data) {
+    auto self = reinterpret_cast<GtkClient *>(data);
+    self->updateServerBox();
+}
+
+void GtkClient::doStartMeasurement() {
+    if (state == MState::MEASURING) {
+        pushToAgent("abortTest");
+        user_abort = true;
+        return;
+    } else if (state == MState::FINISHED) {
+        setState(MState::RESTARTING);
+        return;
+    } else if (state == MState::ERROR) {
+        pushToAgent("getConfiguration");
+        return;
+    }
+    setLabel(label_date, dateString());
+
+    setState(MState::MEASURING);
+    std::string mtype(gtk_combo_box_text_get_active_text
+                      (GTK_COMBO_BOX_TEXT(iptype_box)));
+    bool tls = false;
+
+    std::string server_name(gtk_combo_box_text_get_active_text
+                            (GTK_COMBO_BOX_TEXT(server_box)));
+
+    int server_port = 80;
+    std::string hostname;
+    std::set<std::string> srvName;
+    for (auto srv : settings["servers"].array_items()) {
+        if (srv["type"].string_value() != mtype)
+            continue;
+        if ( srv["name"].string_value() != server_name)
+            continue;
+        if (tls && srv["tlsport"].int_value() == 0)
+            continue;
+        hostname = srv["url"].string_value();
+        auto pos = hostname.find(':');
+        if (pos != std::string::npos) {
+            server_port = std::stoi(hostname.substr(pos+1));
+            hostname.resize(pos);
+        }
+        if (tls)
+            server_port = srv["tlsport"].int_value();
+        break;
+    }
+
+    std::string key = settings["hashkey"].string_value();
+    json11::Json out_args = json11::Json::object {
+        { "serverUrl", hostname },
+        { "serverPort", server_port },
+        { "userKey", key },
+        { "tls", tls },
+    };
+    pushToAgent("startTest", out_args.dump());
+}
+
+void GtkClient::setState(MState newState) {
+
+    if (state == MState::FINISHED) {
+        reset();
+    }
+
+    switch (newState) {
+    case MState::IDLE:
+        setLabel(label_message, "");
+        gtk_button_set_label(GTK_BUTTON(start_button), "Start Measurement");
+        break;
+    case MState::RESTARTING:
+    case MState::MEASURING:
+        gtk_button_set_label(GTK_BUTTON(start_button), "ABORT");
+        break;
+    case MState::FINISHED:
+        gtk_button_set_label(GTK_BUTTON(start_button), "New Measurement");
+        break;
+    case MState::ERROR:
+        gtk_button_set_label(GTK_BUTTON(start_button), "RETRY");
+        break;
+    }
+
+    state = newState;
+}
+
+void GtkClient::activate(GtkApplication *app,
+                         gpointer user_data) {
+    auto self = reinterpret_cast<GtkClient *>(user_data);
+    self->doActivate(app);
+}
+
+GtkWidget *GtkClient::staticLabel(const char *text, GtkAlign align) {
+    GtkWidget *label = gtk_label_new(text);
+    gtk_widget_set_halign(label, align);
+    gtk_widget_set_name(label, "static-label");
+    return label;
+}
+
+GtkWidget *GtkClient::dynamicLabel(GtkAlign align) {
+    GtkWidget *label = gtk_label_new("");
+    gtk_widget_set_halign(label, align);
+    gtk_widget_set_name(label, "dynamic-label");
+    return label;
+}
+
+void GtkClient::doActivate(GtkApplication *app) {
+    main_window = gtk_application_window_new(app);
+    gtk_window_set_title(GTK_WINDOW(main_window), "Bandwidth Measurement");
+    gtk_window_set_default_size(GTK_WINDOW(main_window), 700, 300);
+
+    GdkDisplay *display = gdk_display_get_default();
+    GdkScreen *screen = gdk_display_get_default_screen(display);
+    GtkCssProvider *cssProvider = gtk_css_provider_new();
+    if (gtk_css_provider_load_from_path(cssProvider, "gtkclient.css", nullptr))
+        gtk_style_context_add_provider_for_screen(screen,
+                              GTK_STYLE_PROVIDER(cssProvider),
+                              GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+
+    GtkWidget *mw = gtk_grid_new();
+    gtk_widget_set_hexpand(mw, TRUE);
+    gtk_grid_set_column_homogeneous(GTK_GRID(mw), TRUE);
+    gtk_container_add(GTK_CONTAINER(main_window), mw);
+
+    gtk_grid_set_row_spacing(GTK_GRID(mw), 10);
+    gtk_grid_set_column_spacing(GTK_GRID(mw), 2);
+
+    auto label_ticket1 = staticLabel("Suport ID: ");
+    gtk_widget_set_halign(label_ticket1, GTK_ALIGN_END);
+    gtk_grid_attach(GTK_GRID(mw), label_ticket1, 0, 0, 1, 1);
+    label_ticket = dynamicLabel();
+    gtk_grid_attach(GTK_GRID(mw), label_ticket, 1, 0, 1, 1);
+    label_date = dynamicLabel();
+    gtk_grid_attach(GTK_GRID(mw), label_date, 2, 0, 2, 1);
+
+    auto label_isp1 = staticLabel("ISP: ");
+    gtk_grid_attach(GTK_GRID(mw), label_isp1, 0, 1, 1, 1);
+    label_isp = dynamicLabel();
+    gtk_grid_attach(GTK_GRID(mw), label_isp, 1, 1, 3, 1);
+
+    GtkWidget *label_ip1 = staticLabel("IP: ");
+    gtk_grid_attach(GTK_GRID(mw), label_ip1, 0, 2, 1, 1);
+    label_ip = dynamicLabel();
+    gtk_grid_attach(GTK_GRID(mw), label_ip, 1, 2, 1, 1);
+
+    GtkWidget *label_ip2 = staticLabel("Local IP: ");
+    gtk_grid_attach(GTK_GRID(mw), label_ip2, 2, 2, 1, 1);
+    label_pip = dynamicLabel();
+    gtk_grid_attach(GTK_GRID(mw), label_pip, 3, 2, 1, 1);
+
+    int res_line = 3;
+
+    label_message = dynamicLabel(GTK_ALIGN_CENTER);
+    gtk_grid_attach(GTK_GRID(mw), label_message, 0, res_line, 4, 1);
+
+    ++res_line;
+
+    GtkWidget *label_x2 = staticLabel("Latency: ");
+    label_latency = dynamicLabel();
+    GtkWidget *label_x3 = staticLabel("Evaluation: ");
+    label_evaluation = dynamicLabel();
+
+    gtk_grid_attach(GTK_GRID(mw), label_x2, 0, res_line, 1, 1);
+    gtk_grid_attach(GTK_GRID(mw), label_latency, 1, res_line, 1, 1);
+    gtk_grid_attach(GTK_GRID(mw), label_x3, 2, res_line, 1, 1);
+    gtk_grid_attach(GTK_GRID(mw), label_evaluation, 3, res_line, 1, 1);
+
+    ++res_line;
+
+    GtkWidget *label_x0 = staticLabel("Download: ");
+    label_download = dynamicLabel();
+    GtkWidget *label_x1 = staticLabel("Upload: ");
+    label_upload = dynamicLabel();
+    gtk_grid_attach(GTK_GRID(mw), label_x0, 0, res_line, 1, 1);
+    gtk_grid_attach(GTK_GRID(mw), label_download, 1, res_line, 1, 1);
+    gtk_grid_attach(GTK_GRID(mw), label_x1, 2, res_line, 1, 1);
+    gtk_grid_attach(GTK_GRID(mw), label_upload, 3, res_line, 1, 1);
+
+    ++res_line;
+
+    start_button = gtk_button_new_with_label("Start Measurement");
+    gtk_grid_attach(GTK_GRID(mw), start_button, 1, res_line+4, 2, 1);
+    g_signal_connect(start_button, "clicked",
+                     G_CALLBACK(start_measurement), this);
+
+    GtkWidget *label_server1 = staticLabel("Measurement server: ");
+    gtk_grid_attach(GTK_GRID(mw), label_server1, 0, res_line+5, 1, 1);
+    server_box = gtk_combo_box_text_new();
+    gtk_grid_attach(GTK_GRID(mw), server_box, 1, res_line+5, 1, 1);
+
+    iptype_box = gtk_combo_box_text_new();
+    gtk_grid_attach(GTK_GRID(mw), iptype_box, 2, res_line+5, 1, 1);
+
+    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(iptype_box),
+                                   "ipv4");
+    gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(iptype_box),
+                                   "ipv6");
+    gtk_combo_box_set_active(GTK_COMBO_BOX(iptype_box), 0);
+    g_signal_connect(iptype_box, "changed",
+                     G_CALLBACK(update_serverlist), this);
+
+    auto cond = static_cast<GIOCondition>(G_IO_IN | G_IO_HUP | G_IO_ERR);
+    g_unix_fd_add(peer_fd, cond, poll_agent, this);
+
+    gtk_widget_show_all(main_window);
+}
diff --git a/src/gtkgui/gtkclient.css b/src/gtkgui/gtkclient.css
new file mode 100644
index 0000000..efa5aeb
--- /dev/null
+++ b/src/gtkgui/gtkclient.css
@@ -0,0 +1,11 @@
+window {
+}
+
+#dynamic-label {
+    background-color: #ffffff;
+    font-family: monospace;
+}
+
+#static-label {
+    font-weight: bold;    
+}
diff --git a/src/gtkgui/gtkclient.h b/src/gtkgui/gtkclient.h
new file mode 100644
index 0000000..c234d8f
--- /dev/null
+++ b/src/gtkgui/gtkclient.h
@@ -0,0 +1,73 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#include "../json11/json11.hpp"
+#include "../framework/unixdomainclient.h"
+#include "../framework/bridgetask.h"
+#include "../framework/logger.h"
+
+class GtkClient : public Logger {
+public:
+    GtkClient(const TaskConfig &config, int unix_domain_peer);
+    ~GtkClient();
+
+    void run();
+    void doQuit() {
+        pushToAgent("terminate");
+        g_application_quit(G_APPLICATION(app));
+    }
+    static void activate(GtkApplication *app, gpointer user_data);
+    static gboolean poll_agent(gint fd, GIOCondition c, gpointer data);
+    static void start_measurement(GtkWidget *widget, gpointer data);
+    static void update_serverlist(GtkWidget *widget, gpointer data);
+
+    void doActivate(GtkApplication *app);
+    void doStartMeasurement();
+
+    GtkWidget *staticLabel(const char *label, GtkAlign align = GTK_ALIGN_END);
+    GtkWidget *dynamicLabel(GtkAlign align = GTK_ALIGN_START);
+    void setLabel(GtkWidget *widget, const std::string &label);
+    void pushToAgent(const std::string &method, const std::string &arg = "{}") {
+        if (arg.size() > 2)
+            log() << "Send: " << method << " " << arg;
+        else
+            log() << "Send: " << method;
+        ud_client.pushToAgent(BridgeTask::msgToAgent(method, arg));
+    }
+
+    std::string myStrFormat(double x);
+    void gotSettings(const json11::Json &obj);
+    void gotInfo(const json11::Json &obj);
+    void gotReport(const json11::Json &obj);
+    void gotTaskComplete(const json11::Json &obj);
+    void newEventFromAgent(const std::string &msg);
+    std::string pollAgent() {
+        return ud_client.pollAgent();
+    }
+private:
+    enum class MState {
+        IDLE, RESTARTING, MEASURING, FINISHED, ERROR
+    };
+    void setState(MState newState);
+    void updateServerBox();
+    void reset();
+    MState state = MState::IDLE;
+    bool got_ticket = false;
+    bool user_abort = false;
+    GtkApplication *app;
+    GtkWidget *main_window;
+    GtkWidget *start_button;
+    GtkWidget *label_isp, *label_ticket, *label_date,
+        *label_ip, *label_pip, *label_id,
+        *label_download, *label_upload, *label_latency,
+        *label_ipsmsg, *label_evaluation, *label_message;
+    GtkWidget *server_box, *iptype_box;
+    int peer_fd;
+    UnixDomainClient ud_client;
+    json11::Json settings;
+    const TaskConfig the_config;
+};
diff --git a/src/gtkgui/main.cpp b/src/gtkgui/main.cpp
new file mode 100644
index 0000000..6bc2b70
--- /dev/null
+++ b/src/gtkgui/main.cpp
@@ -0,0 +1,57 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "gtkclient.h"
+
+#include "../measurement/measurementagent.h"
+#include "../cli/utils.h"
+#include "../framework/unixdomainbridge.h"
+
+namespace {
+    void runAgent(BridgeTask *bridge, const TaskConfig &cfg,
+                  const std::string &cfgfile, const std::string &logfile) {
+        std::ofstream log_file;
+        if (logfile != "-") {
+            log_file.open(logfile);
+            Logger::setLogFile(log_file);
+        }
+        CookieFile cf(cfgfile);
+        HttpHost webserver(cfg.value("Measure.Webserver"), 80, "", 0, &cf);
+        EventLoop loop;
+        bridge->setAgent(new MeasurementAgent(cfg, webserver));
+        loop.addTask(bridge);
+        loop.runUntilComplete();
+    }
+}
+
+int main(int argc, char *argv[]) {
+
+    TaskConfig agent_cfg, config;
+    if (!parseArgs(argc, argv, config, agent_cfg))
+        return 1;
+    agent_cfg.set("Measure.AutoSaveReport", "true");
+
+    std::ofstream log_file;
+    if (config.value("logfile") != "-") {
+        log_file.open(config.value("app_dir") + "gtk_last_log");
+        Logger::setLogFile(log_file);
+    }
+
+    UnixDomainBridge *bridge = new UnixDomainBridge();
+    int client_socket = bridge->getClientSocket();
+    if (!client_socket)
+        exit(1);
+
+    std::thread agent_thread(runAgent, bridge, agent_cfg,
+                             config.value("config_file"), config.value("logfile"));
+
+    {
+        GtkClient client(config, client_socket);
+        client.run();
+    }
+
+    close(client_socket);
+    agent_thread.join();
+
+    return 0;
+}
diff --git a/src/http/cookiefile.cpp b/src/http/cookiefile.cpp
new file mode 100644
index 0000000..6e2ecb4
--- /dev/null
+++ b/src/http/cookiefile.cpp
@@ -0,0 +1,98 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <fstream>
+#include <iterator>
+
+#include "cookiefile.h"
+#include "../http/http_common.h"
+
+CookieFile::~CookieFile() {
+    if (isDirty())
+        writeCookiesFile();
+}
+
+void CookieFile::readCookiesFile() {
+    if (filename.empty())
+        return;
+    std::ifstream cookieFile(filename);
+    if (!cookieFile) {
+        // Failed, but who cares?
+        log() << "cannot read cookie file " << filename;
+        return;
+    }
+
+    log() << "reading cookie file " << filename;
+    std::string domain;
+    std::string line;
+    auto it = cookies().end();
+    while (std::getline(cookieFile, line)) {
+        if (line.size() < 10) {
+            continue;
+        } else if (line[0] == '*') {
+            if (line.substr(0, 5) == "**** " &&
+                line.substr(line.size()-5) == " ****") {
+                domain = line.substr(5, line.size()-10);
+                it = cookies().find(domain);
+            } else {
+                err_log() << "bad cookie file";
+                domain.clear();
+            }
+            continue;
+        } else if (domain.empty()) {
+            continue;
+        } else {
+            // name, value, domain, expires, path, secure, httponly
+            std::vector<std::string> vec = HttpCommon::split(line, ";");
+            if (vec.size() != Field::field_len)
+                continue;
+            if (it == cookies().end()) {
+                std::vector<std::string> v(Cache::cache_len);
+                auto p = cookies().insert(std::make_pair(domain, v));
+                it = p.first;
+            }
+            auto &v = it->second;
+            std::move(vec.begin(), vec.end(), back_inserter(v));
+        }
+    }
+
+    clearDirty();
+}
+
+void CookieFile::writeCookiesFile() {
+    if (filename.empty()) {
+        log() << "missing name of cookie file";
+        return;
+    }
+
+    std::ofstream cookieFile(filename, std::ofstream::trunc);
+    for (auto p : cookies()) {
+        const std::string &domain = p.first;
+        const std::vector<std::string> &v = p.second;
+        bool said_domain = false;
+        std::size_t i=Cache::cache_len;
+        while (i+Field::field_len <= v.size()) {
+            if (v[i+Field::expires].empty() ||
+                isExpired(v[i+Field::expires])) {
+                // Session cookie or expired, don't persist.
+                i += Field::field_len;
+                continue;
+            } else if (!said_domain) {
+                cookieFile << "**** " << domain << " ****\n";
+                said_domain = true;
+            }
+            cookieFile << v[i++];
+            for (std::size_t j=1; j<Field::field_len; ++j)
+                cookieFile << ';' << v[i++];
+            cookieFile << '\n';
+        }
+    }
+    cookieFile.close();
+
+    if (cookieFile) {
+        clearDirty();
+    } else {
+        // Failed, but who cares?
+        log() << "cannot write cookie file";
+    }
+}
diff --git a/src/http/cookiefile.h b/src/http/cookiefile.h
new file mode 100644
index 0000000..d818a2e
--- /dev/null
+++ b/src/http/cookiefile.h
@@ -0,0 +1,37 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <map>
+
+#include "../http/cookiemanager.h"
+
+class CookieFile : public CookieManager {
+public:
+    CookieFile(const std::string &cookie_filename = "") :
+    CookieManager("CookieFile"),
+    filename(cookie_filename) {
+        readCookiesFile();
+    }
+
+    // By default, we try to save cookies in the destructor. However, if
+    // the save operation fails, all updates are lost. If you can't afford to
+    // lose cookies, call save() and check the return value.
+    ~CookieFile() override;
+
+    // Write to disk, return false on failure.
+    bool save() override {
+        if (isDirty())
+            writeCookiesFile();
+        return isDirty();
+    }
+
+    // Default move constructor is OK despite us having a destructor:
+    CookieFile(CookieFile &&) = default;
+
+private:
+    void readCookiesFile();
+    void writeCookiesFile();
+    std::string filename;
+};
diff --git a/src/http/cookiemanager.cpp b/src/http/cookiemanager.cpp
new file mode 100644
index 0000000..e619e5f
--- /dev/null
+++ b/src/http/cookiemanager.cpp
@@ -0,0 +1,288 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "cookiemanager.h"
+#include "http_common.h"
+#include <algorithm>
+#include <stdexcept>
+#include <iterator>
+
+CookieManager::~CookieManager() {
+}
+
+bool CookieManager::save() {
+    return false;
+}
+
+// timeval contains only digits 0-9, doesn't start with 0.
+bool CookieManager::isExpired(const std::string &timeval) {
+    if (timeval.empty())
+        return false; // No expiry - a session cookie.
+
+    if (time_t d = time(nullptr) - t_now) {
+        t_now += d;
+        s_now = std::to_string(t_now);
+    }
+
+    return !less(s_now, timeval);
+}
+
+// line is the remainder of a header line starting with "Set-Cookie: ", e.g.
+//   previous_isp=23; expires=Wed, 07-Jun-2017 11:34:59 GMT; path=/;
+//   domain=.bredbandskollen.se
+void CookieManager::setCookie(const std::string &line,
+                              std::string domain, std::string uri) {
+    std::vector<std::string> cookie_av = cookieSplit(line);
+    if (cookie_av.empty())
+        return;
+
+    const std::string &cdomain = cookie_av[Field::domain];
+    // Disallow third-party cookies and cookies for top-level domains.
+    // TODO: should disallow all public suffixes, e.g. ".co.uk".
+    if (cdomain.find('.') != std::string::npos &&
+        HttpCommon::isSubdomain(domain, cdomain))
+        domain = cdomain;
+    auto it = store.find(domain);
+    if (it == store.end()) {
+        std::vector<std::string> v(Cache::cache_len);
+        auto p = store.insert(std::make_pair(domain, v));
+        it = p.first;
+    } else {
+        // Invalidate cache, also for subdomains.
+        it->second[Cache::cookie_header].clear();
+        for (auto p : store)
+            if (HttpCommon::isSubdomain(p.first, domain))
+                p.second[Cache::cookie_header].clear();
+    }
+
+    auto &v = it->second;
+    bool expired = isExpired(cookie_av[Field::expires]);
+    if (!expired)
+        if (cookie_av[Field::path].empty() || cookie_av[Field::path][0] != '/')
+            cookie_av[Field::path] = HttpCommon::uriPath(uri); // default-path
+
+    // Check if the new cookie replaces an existing
+    for (size_t i=Cache::cache_len; i<v.size(); i+=Field::field_len) {
+        if (v[i+Field::name] == cookie_av[Field::name] &&
+            v[i+Field::path] == cookie_av[Field::path]) {
+            if (expired) {
+                v.erase(v.begin() + static_cast<long>(i),
+                        v.begin() + static_cast<long>(i+Field::field_len));
+            } else {
+                std::move(cookie_av.begin(), cookie_av.end(),
+                          v.begin() + static_cast<long>(i));
+                dirty = true;
+                cookie_av.clear();
+                return;
+            }
+            break;
+        }
+    }
+    if (!expired) {
+        std::move(cookie_av.begin(), cookie_av.end(),
+                  back_inserter(v));
+        dirty = true;
+    }
+}
+
+// line is the remainder of a header line starting with "Set-Cookie: ", e.g.
+//   previous_isp=23; expires=Wed, 07-Jun-2017 11:34:59 GMT; path=/;
+//   domain=.bredbandskollen.se
+
+// Return vector with Field::field_len elements if OK:
+//   name, value, domain, expires, path, secure, httponly
+// Return empty vector if bad.
+std::vector<std::string> CookieManager::cookieSplit(const std::string &line) {
+    std::vector<std::string> v = HttpCommon::split(line, "; "), cookie_av;
+    for (auto av : v) {
+        std::string lcname, value, avlc;
+        auto eqpos = av.find('=');
+        if (!cookie_av.empty()) {
+            // Make a lower-case copy:
+            std::transform(av.begin(), av.end(), back_inserter(avlc), tolower);
+            HttpCommon::trimWSP(lcname = avlc.substr(0, eqpos));
+            if (eqpos != std::string::npos)
+                HttpCommon::trimWSP(value = av.substr(eqpos+1));
+        } else {
+            if (eqpos == std::string::npos)
+                break; // Bad line
+        }
+
+        if (cookie_av.empty()) {
+            cookie_av.resize(Field::field_len);
+            HttpCommon::trimWSP(cookie_av[Field::name] = av.substr(0, eqpos));
+            HttpCommon::trimWSP(cookie_av[Field::value] = av.substr(eqpos+1));
+        } else if (eqpos == 6 && lcname == "domain") {
+            ++eqpos;
+            if (av[eqpos] == '.')
+                ++eqpos; // Ignore leading dot.
+            cookie_av[Field::domain] = avlc.substr(eqpos);
+        } else if (eqpos == 8 && lcname == "_expires") {
+            // Our internal format, unix timestamp value.
+            ++eqpos;
+            if (av.find_first_not_of("0123456789", eqpos) == std::string::npos)
+                cookie_av[Field::expires] = av.substr(eqpos);
+            else // Corrupt cookie file?
+                cookie_av[Field::expires] = "0";
+        } else if (eqpos == 7 && lcname == "expires") {
+            // max-age has precedence, so ignore if already set.
+            if (cookie_av[Field::expires].empty()) {
+                time_t val = HttpCommon::parseDateRfc1123(av.substr(eqpos+1));
+                if (val >= 0) {
+                    cookie_av[Field::expires] = std::to_string(val);
+                } else if (val == -1) {
+                    // Ignore bad date
+                } else {
+                    // Expired.
+                    cookie_av[Field::expires] = "0";
+                }
+            }
+        } else if (eqpos == 4 && lcname == "path") {
+            cookie_av[Field::path] = av.substr(eqpos+1);
+        } else if (eqpos == 7 && lcname == "max-age") {
+            ++eqpos;
+            if (av.size() == eqpos) {
+                // Ignore?
+            } else if (av[eqpos] == '-') {
+                if (av.find_first_not_of("0123456789", ++eqpos)
+                    == std::string::npos)
+                    cookie_av[Field::expires] = "0"; // Mark as expired
+                // Else ignore!
+            } else if (av.find_first_not_of("0123456789", eqpos) ==
+                       std::string::npos) {
+                time_t res, maxv = std::numeric_limits<time_t>::max();
+                try {
+                    long secs = std::stol(av.substr(eqpos));
+                    res = time(nullptr);
+                    if (secs >= maxv-res)
+                        res = maxv;
+                    else
+                        res += secs;
+                } catch (std::out_of_range &) {
+                    // Too large
+                    res = maxv;
+                }
+                cookie_av[Field::expires] = std::to_string(res);
+            }
+        } else if (avlc == "secure") {
+            cookie_av[Field::secure] = avlc;
+        } else if (avlc == "httponly") {
+            cookie_av[Field::secure] = avlc;
+        } else {
+            // Unknown attribute; ignore.
+        }
+    }
+    return cookie_av;
+}
+
+std::string CookieManager::httpHeaderLine(const std::string &domain,
+                                          const std::string &uri) {
+    auto cit = store.find(domain);
+    if (cit == store.end()) {
+        // Make room for cache!
+        std::vector<std::string> v(Cache::cache_len);
+        auto p = store.insert(std::make_pair(domain, v));
+        cit = p.first;
+    } else {
+        // Check if cached value exists and hasn't expired:
+        const std::vector<std::string> &v = cit->second;
+        if (!v.empty() && !v[Cache::cookie_header].empty() &&
+            !isExpired(v[Cache::expiry])) {
+            // Cached value exists, no part of it has expired.
+            if (v[Cache::cookie_header].size() == 1)
+                return "";
+            else
+                return v[Cache::cookie_header];
+        }
+    }
+
+    // We'll set this to true if we can't cache the result, e.g.
+    // if it depends on path:
+    bool dont_cache = false;
+
+    // Find all subdomains for which we have cookies:
+    std::vector<std::map<std::string, std::vector<std::string>>::iterator>
+        subdomains;
+    std::string subdomain = domain;
+    auto it = cit;
+    while (true) {
+        if (it != store.end())
+            subdomains.push_back(it);
+        auto pos = subdomain.find('.');
+        if (pos == std::string::npos)
+            break; // We don't accept top level domains.
+        subdomain.erase(0, pos+1);
+        it = store.find(subdomain);
+    }
+
+    // Get all cookie values, starting from least significant subdomain:
+    std::string cache_expiry;
+    std::map<std::string, std::string> cookieVal;
+    while (!subdomains.empty()) {
+        // Reevaluate:
+        auto &v = subdomains.back()->second;
+        for (size_t i=Cache::cache_len; i<v.size(); ) {
+            const std::string &expiry = v[i+Field::expires];
+            if (!expiry.empty() &&
+                (cache_expiry.empty() || less(expiry, cache_expiry))) {
+                if (isExpired(expiry)) {
+                    v.erase(v.begin()+static_cast<long>(i),
+                            v.begin()+static_cast<long>(i+Field::field_len));
+                    continue;
+                } else
+                    cache_expiry = expiry;
+            }
+            if (v[i+Field::path] != "/") {
+                dont_cache = true;
+                if (HttpCommon::isWithinPath(uri, v[i+Field::path]))
+                    cookieVal[v[i+Field::name]] = v[i+Field::value];
+            } else
+                cookieVal[v[i+Field::name]] = v[i+Field::value];
+            i += Field::field_len;
+        }
+        subdomains.pop_back();
+    }
+
+    auto p = cookieVal.begin();
+    if (p == cookieVal.end()) {
+        cit->second[Cache::cookie_header] = "-";
+        cit->second[Cache::expiry].clear();
+        return "";
+    }
+    std::string cval = "Cookie: " + p->first + "=" + p->second;
+    while (++p != cookieVal.end()) {
+        cval += ("; " + p->first + "=" + p->second);
+    }
+
+    cval += "\r\n";
+    if (!dont_cache) {
+        cit->second[Cache::cookie_header] = cval;
+        cit->second[Cache::expiry] = cache_expiry;
+    }
+    return cval;
+}
+
+void CookieManager::eraseCookies(const std::string &domain) {
+    auto cit = store.find(domain);
+    if (cit == store.end())
+        return;
+    store.erase(cit);
+    dirty = true;
+}
+
+std::string CookieManager::getCookieVal(const std::string &name,
+                                        std::string domain) {
+    while (true) {
+        auto cit = store.find(domain);
+        if (cit != store.end()) {
+            const auto &v = cit->second;
+            for (unsigned i=Cache::cache_len; i<v.size(); i+=Field::field_len)
+                if (v[i+Field::name] == name && v[i+Field::path] == "/")
+                    return v[i+Field::value];
+        }
+        auto pos = domain.find('.');
+        if (pos == std::string::npos)
+            return std::string();
+        domain.erase(0, pos+1);
+    }
+}
diff --git a/src/http/cookiemanager.h b/src/http/cookiemanager.h
new file mode 100644
index 0000000..9e302ac
--- /dev/null
+++ b/src/http/cookiemanager.h
@@ -0,0 +1,95 @@
+// Copyright (c) 2019 The Swedish Internet Foundation
+// Written by Göran Andersson <goran@init.se>
+
+// This class stores cookies in memory only.
+// Create a subclass if you want persistent cookies.
+
+#pragma once
+
+#include <map>
+#include <vector>
+
+#include "../framework/logger.h"
+
+class CookieManager : public Logger {
+public:
+    CookieManager(const std::string &name = "CookieManager") :
+        Logger(name) {
+    }
+
+    virtual ~CookieManager();
+
+    void setCookie(const std::string &line, std::string domain,
+                   std::string uri);
+
+    // Return empty string if no cookies exist, or a HTTP header line
+    //   "Cookie: name1=val1; name2=val2\r\n"
+    std::string httpHeaderLine(const std::string &domain,
+                               const std::string &uri);
+
+    // Return cookie value for domain and name; return empty if not found.
+    std::string getCookieVal(const std::string &name, std::string domain);
+
+    // Return true if no cookies have been set.
+    bool empty() const {
+        return store.empty();
+    }
+
+    void eraseCookies(const std::string &domain);
+
+    // Store persistently, return true on success
+    virtual bool save();
+
+protected:
+    bool isDirty() const {
+        return dirty;
+    }
+    void clearDirty() {
+        dirty = false;
+    }
+
+    // timeval contains only digits 0-9, doesn't start with 0.
+    bool isExpired(const std::string &timeval);
+
+    // both must be non-empty, only digits, no leading zeroes.
+    static bool less(const std::string &tv1, const std::string &tv2) {
+        if (tv1.size() < tv2.size())
+            return true;
+        if (tv1.size() > tv2.size())
+            return false;
+        return tv1 < tv2;
+    }
+
+    // Access to all cookies, to serialise/deserialise.
+    // The key is the domain for which the cookie is valid (also subdomains).
+    // The value is a vector with elements as follows:
+    // The first Cache::cache_len elements are used to cache values and must be
+    // ignored. The remaining elements are 0 or more groups of Field::field_len
+    // elements; each group describes the properties of a single cookie.
+    std::map<std::string, std::vector<std::string> > &cookies() {
+        return store;
+    }
+    enum Cache {
+        cookie_header, expiry, cache_len
+    };
+    enum Field {
+        name, value, domain, expires, path, secure, httponly, field_len
+    };
+private:
+    // Map domain to cookie strings:
+    // First element of each store vector is a cache for httpHeaderLine():
+    //   - empty string means nothing is cached
+    //   - string of length 1 means there are no cookies for the domain
+    //   - string of length > 1 is the cookie header line
+    //   - NOTE! We only cache for path=/
+    // Second element is cache expiry time, empty for no expiry.
+    std::map<std::string, std::vector<std::string> > store;
+    // TODO: Store time of creation / last use?
+    //       last use may ignore cache.
+
+    static std::vector<std::string> cookieSplit(const std::string &line);
+    TimePoint expire_date;
+    bool dirty = false;
+    time_t t_now = 0;
+    std::string s_now = "0";
+};
diff --git a/src/http/http_common.cpp b/src/http/http_common.cpp
new file mode 100644
index 0000000..1190559
--- /dev/null
+++ b/src/http/http_common.cpp
@@ -0,0 +1,173 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "http_common.h"
+#include <stdlib.h>
+#include <time.h>
+
+bool HttpCommon::parseHeaders(const std::string &header, std::string &r,
+                              std::multimap<std::string, std::string> &res) {
+    std::string::size_type start, end=0;
+    while (true) {
+        start = end;
+        end = header.find("\r\n", start);
+        if (end == std::string::npos)
+            return false;
+        std::string line = header.substr(start, end-start);
+        if (line.empty()) {
+            break;
+        } else {
+            // Remove trailing spaces
+            std::size_t n = line.find_last_not_of(' ');
+            if (n != std::string::npos)
+                line.resize(n+1);
+        }
+        end += std::strlen("\r\n");
+
+        if (!start) {
+            r = line;
+            continue;
+        }
+        std::string::size_type separator = line.find(": ");
+        if (separator == std::string::npos)
+            return false;
+        std::string attribute = line.substr(0, separator);
+        for (std::string::size_type i=0; i<attribute.size(); ++i)
+            if (attribute[i] >= 'A' && attribute[i] <= 'Z')
+                attribute[i] += ('a' - 'A');
+        res.insert(std::make_pair(attribute, line.substr(separator+2)));
+    }
+    return true;
+}
+
+namespace {
+    std::map<std::string, const char *> mime_db = {
+        { "txt", "text/plain; charset=utf-8" },
+        { "html", "text/html; charset=utf-8" },
+        { "css", "text/css" },
+        { "js", "text/javascript" },
+        { "pdf", "application/pdf" },
+        { "xml", "application/xml" },
+        { "json", "application/json" },
+    };
+}
+
+const char *HttpCommon::mime_type(const std::string &file_name) {
+    auto pos = file_name.find_last_of('.');
+    if (pos == std::string::npos)
+        pos = 0;
+    else
+        ++pos;
+    auto p = mime_db.find(file_name.substr(pos));
+    if (p != mime_db.end())
+        return p->second;
+    return "application/octet-stream";
+}
+
+namespace {
+    inline int toInt(char p1, char p2) {
+        if (!isdigit(p1) || !isdigit(p2))
+            return -1;
+        return 10*(p1-'0') + (p2-'0');
+    }
+}
+
+// Return -1 on failure.
+time_t HttpCommon::parseDateRfc1123(const std::string &date) {
+    time_t ret = -1;
+
+    // Date format:
+    // Wed, 07-Jun-2017 11:34:59 GMT
+    // 012345678901234567890123456789
+
+    if (date.size() != 29)
+        return ret;
+    static const std::string wdays("Sun, Mon, Tue, Wed, Thu, Fri, Sat, ");
+    auto wday_pos = wdays.find(date.substr(0, 5));
+    if (wday_pos == std::string::npos || wday_pos%5)
+        return ret;
+
+    static const std::string months("-Jan-Feb-Mar-Apr-May-Jun-Jul-Aug-Sep-Oct-Nov-Dec-");
+    auto mon_pos = months.find(date.substr(7, 5));
+    if (mon_pos == std::string::npos || mon_pos%4)
+        return ret;
+
+    if (date[16] != ' ' || date[19] != ':' || date[22] != ':' ||
+        date.substr(25) != " GMT")
+        return ret;
+
+    struct tm timespec;
+    timespec.tm_sec = toInt(date[23], date[24]);
+    timespec.tm_min = toInt(date[20], date[21]);
+    timespec.tm_hour = toInt(date[17], date[18]);
+    int mday = toInt(date[5], date[6]);
+    timespec.tm_mday = mday;
+    if (timespec.tm_sec < 0 || timespec.tm_sec > 59 ||
+        timespec.tm_min < 0 || timespec.tm_min > 59 ||
+        timespec.tm_hour < 0 || timespec.tm_hour > 23 || mday < 0)
+        return ret;
+    timespec.tm_mon = static_cast<int>(mon_pos / 4);
+    timespec.tm_year = toInt(date[14], date[15]);
+    int yy = toInt(date[12], date[13]) - 19;
+    if (timespec.tm_year < 0 || yy < 0)
+        return ret;
+    timespec.tm_year += yy*100;
+    //timespec.tm_wday = 0;
+    //timespec.tm_yday = 0;
+    timespec.tm_isdst = -1;
+
+    // mktime depends on current timezone, so we must
+    // temporarily reset timezone.
+    char *tz = getenv("TZ");
+#ifdef _WIN32
+    _putenv("TZ=UTC");
+    _tzset();
+    ret = mktime(&timespec);
+    if (tz) {
+        char buf[255];
+        snprintf(buf, sizeof(buf), "TZ=%s", tz);
+        _putenv(buf);
+    } else {
+        _putenv("TZ=");
+    }
+    _tzset();
+#else
+    setenv("TZ", "", 1);
+    tzset();
+    ret = mktime(&timespec);
+    if (tz)
+        setenv("TZ", tz, 1);
+    else
+        unsetenv("TZ");
+    tzset();
+    if (timespec.tm_wday*5 != static_cast<int>(wday_pos)
+        || timespec.tm_mday != mday)
+        return -1;
+#endif
+
+    return ret;
+}
+
+void HttpCommon::trimWSP(std::string &s) {
+    auto pos = s.find_first_not_of(" \t\r\n\v");
+    if (pos && pos != std::string::npos)
+        s.erase(0, pos);
+
+    pos = s.find_last_not_of(" \t\r\n\v");
+    if (pos != std::string::npos)
+        s.erase(++pos);
+}
+
+std::vector<std::string> HttpCommon::split(const std::string &s,
+                                           const std::string &sep) {
+    std::vector<std::string> v;
+    std::string::size_type pos = 0;
+    while (true) {
+        auto epos = s.find(sep, pos);
+        v.push_back(s.substr(pos, epos-pos));
+        if (epos == std::string::npos)
+            break;
+        pos = epos + sep.size();
+    }
+    return v;
+}
diff --git a/src/http/http_common.h b/src/http/http_common.h
new file mode 100644
index 0000000..5025f4a
--- /dev/null
+++ b/src/http/http_common.h
@@ -0,0 +1,62 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <string>
+#include <cstring>
+#include <ctime>
+#include <vector>
+#include <map>
+
+class HttpCommon {
+public:
+    // Return true on success.
+    static bool parseHeaders(const std::string &header, std::string &r,
+                             std::multimap<std::string, std::string> &res);
+
+    // Guess mime type, e.g. "text/html", from url/filename
+    static const char *mime_type(const std::string &file_name);
+
+    // Return -1 on failure.
+    static time_t parseDateRfc1123(const std::string &date);
+
+    // Remove leading and trailing whitespace:
+    static void trimWSP(std::string &s);
+
+    // Split s into fields sepatared by sep:
+    static std::vector<std::string> split(const std::string &s,
+                                          const std::string &sep);
+    static bool isSubdomain(const std::string &subdomain,
+                            const std::string &domain) {
+        auto s = domain.size();
+        return (subdomain.size() > s &&
+                subdomain[subdomain.size()-s-1] == '.' &&
+                subdomain.substr(subdomain.size()-s) == domain);
+    }
+    static bool isWithinPath(const std::string &uri,
+                             const std::string &path) {
+        if (path.empty())
+            return (!uri.empty() && uri[0] == '/');
+        if (path != uri.substr(0, path.size()))
+            return false;
+        if (path.size() < uri.size()) {
+            return path[path.size()-1] == '/' ||
+                uri[path.size()] == '/';
+        } else if (path.size() == uri.size()) {
+            return true; // Identical.
+        } else {
+            return false;
+        }
+    }
+    // Return the path part of an uri.
+    static std::string uriPath(std::string uri) {
+        auto qpos = uri.find('?');
+        if (qpos != std::string::npos)
+            uri.erase(qpos);
+        qpos = uri.rfind('/');
+        if (qpos != std::string::npos)
+            uri.erase(qpos+1);
+        return uri;
+    }
+};
diff --git a/src/http/httpclientconnection.cpp b/src/http/httpclientconnection.cpp
new file mode 100644
index 0000000..9303c6b
--- /dev/null
+++ b/src/http/httpclientconnection.cpp
@@ -0,0 +1,397 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#ifdef _WIN32
+#define NOMINMAX
+#endif
+
+#include <iomanip>
+#include <cctype>
+#include <stdexcept>
+
+#include "httpclientconnection.h"
+#include "httpclienttask.h"
+#include "http_common.h"
+#include "sha1.h"
+
+HttpClientConnection::HttpClientConnection(const std::string &label,
+                                           HttpClientTask *task,
+                                           const std::string &hostname,
+                                           uint16_t port,
+                                           const std::string &http_hostname,
+                                           uint16_t iptype,
+                                           struct addrinfo *local_addr) :
+    HttpConnection(label, task, hostname, port, iptype, local_addr),
+    real_hostname(http_hostname.empty() ? hostname : http_hostname),
+    owner_task(task) {
+    if (!http_hostname.empty())
+        proto_hostname = "http://" + http_hostname;
+}
+
+PollState HttpClientConnection::connected() {
+    owner_task->newRequest(this);
+    if (current_request == "pass")
+        return PollState::NONE;
+    if (current_request.empty())
+        return PollState::KEEPALIVE;
+    //dbg_log() << "HttpClientConnection::connected() request: " << current_request;
+    asyncSendData(current_request);
+    if (bytes_left_to_post)
+        return PollState::WRITE;
+    else
+        return PollState::READ;
+}
+
+bool HttpClientConnection::parseChunkedEncodingLength(char *&buf, size_t &len) {
+    // Between chunks, there is \r\n, a hex number, and \r\n again.
+    // The number gives the size of next chunk.
+    // The last size is 0, and then an extra \r\n to terminate the request.
+
+    size_t oldlen = chunked_info.size();
+    chunked_info += std::string(buf, len<20 ? len : 20);
+
+    if (final_chunk) {
+        len = 0;
+        // We're waiting for the trailing \r\n.
+        if (chunked_info == "\r\n") {
+            // OK, all done!
+            response_is_chunked = false;
+            return true;
+        }
+        return (chunked_info == "\r");
+    }
+
+    if (chunked_info.size() < 5) {
+        // Wait for more, keeping the fragment in chunked_info
+        len = 0;
+        return true;
+    }
+    if (chunked_info.substr(0, 2) != "\r\n")
+        return false;
+
+    size_t endOfSizePos = chunked_info.find("\r\n", 2);
+    if (endOfSizePos == std::string::npos) {
+        // Haven't got terminating \r\n yet.
+        // Wait for more if len < 20, otherwise fail.
+        len = 0;
+        return chunked_info.size() < 20;
+    }
+
+    size_t to_skip = endOfSizePos + 2 - oldlen;
+    buf += to_skip;
+    len -= to_skip;
+
+    try {
+        std::size_t count;
+        std::string num = "0x"+ chunked_info.substr(2);
+        bytes_left_to_read = std::stoul(num, &count, 16);
+        if (count != endOfSizePos)
+            return false;
+    } catch (...) {
+        return false;
+    }
+
+    if (!bytes_left_to_read) {
+        final_chunk = true;
+    }
+
+    chunked_info.clear();
+    return true;
+}
+
+PollState HttpClientConnection::readData(char *buf, size_t len) {
+    if (dbgIsOn()) {
+        log() << socket() << "HttpClientConnection  <" << std::string(buf, len) << ">";
+    }
+    if (!response_header_complete) {
+        std::string::size_type old_length = response_header.size();
+        std::string::size_type to_append = len;
+        if (old_length + to_append > max_header_length)
+            to_append = max_header_length - old_length;
+        response_header.append(buf, to_append);
+        std::string::size_type pos = response_header.find("\r\n\r\n");
+        if (pos == std::string::npos) {
+            if (response_header.size() >= max_header_length)
+                return PollState::KILL;
+            else
+                return PollState::READ;
+        }
+        response_header.resize(pos + strlen("\r\n\r\n"));
+        if (!parseResponseHeaders())
+            return PollState::CLOSE;
+        len -= (response_header.size() - old_length);
+        if (len)
+            buf += (response_header.size() - old_length);
+        else if (!response_header_complete) {
+            response_header.clear();
+            http_response_headers.clear();
+            return PollState::READ; // e.g. after PROXY CONNECT
+        }
+    }
+
+    if (is_websocket)
+        return wsReadData(buf, len);
+
+    if (dbgIsOn()) {
+        dbg_log() << socket() << " HEADER OK, PAYLOAD <"
+                  << std::string(buf, len) << "> LEFT: "
+                  << bytes_left_to_read << " CH: " << response_is_chunked;
+    }
+    // Reading payload
+    if (len) {
+        if (response_is_chunked && !bytes_left_to_read) {
+            if (!parseChunkedEncodingLength(buf, len)) {
+                err_log() << "content encoding error";
+                return PollState::KILL;
+            }
+        }
+        if (bytes_left_to_read) {
+            size_t to_read = std::min(len, bytes_left_to_read);
+            if (buffer_response)
+                buffer.append(buf, to_read);
+            else
+                owner_task->payload(this, buf, to_read);
+            bytes_left_to_read -= to_read;
+            len -= to_read;
+            buf += to_read;
+        }
+    }
+
+    if (response_is_chunked) {
+        if (len > 0)
+            return readData(buf, len);
+        else
+            return PollState::READ;
+    }
+
+    if (bytes_left_to_read > 0)
+        return PollState::READ;
+
+    bool to_continue = owner_task->requestComplete(this);
+
+    if (len) {
+        // Error
+        err_log() << "got " << len << " bytes after request complete";
+        return PollState::KILL;
+    }
+    if (to_continue) {
+        current_request.clear();
+        current_uri.clear();
+        response_header.clear();
+        response_header_complete = false;
+        response_http_status = 0;
+        buffer.clear();
+        http_response_headers.clear();
+        return connected(); // New request or close.
+    } else {
+        return PollState::KEEPALIVE;
+    }
+}
+
+bool HttpClientConnection::parseResponseHeaders() {
+    if (response_http_status) {
+        err_log() << "internal error: headers already parsed";
+        return false;
+    }
+    response_header_complete = true;
+
+    std::string response_first_line;
+    if (!HttpCommon::parseHeaders(response_header, response_first_line,
+                                  http_response_headers)) {
+        log() << "Bad HTTP headers: " << response_header;
+        return false;
+    }
+
+    {
+        // HTTP/1.1 200 OK
+        unsigned int major, minor, status;
+        int pos = sscanf(response_first_line.c_str(), "HTTP/%u.%u %u",
+                         &major, &minor, &status);
+        if (pos != 3 || !status)
+            return false;
+
+        set_http_version(major, minor);
+        response_http_status = status;
+    }
+
+    for (auto p = http_response_headers.lower_bound("set-cookie");
+         p!=http_response_headers.upper_bound("set-cookie"); ++p)
+        owner_task->setCookie(p->second, current_uri);
+
+    if (!websocket_rkey.empty()) {
+        if (websocket_rkey == "CONNECT") {
+            // Doing HTTP CONNECT through a proxy
+            log() << "PROXY CONNECT status " << response_http_status;
+            websocket_rkey.clear();
+            proto_hostname.clear(); // No more proxy calls
+            if (response_http_status < 200 || response_http_status >= 300)
+                return false;
+            response_header_complete = false;
+            response_http_status = 0;
+            current_request.clear();
+            ws_get(current_uri);
+            asyncSendData(current_request);
+            return true;
+        }
+
+        auto p = http_response_headers.find("sec-websocket-accept");
+        if (p == http_response_headers.end() || p->second != websocket_rkey) {
+            err_log() << "wrong Sec-WebSocket-Accept";
+            return false;
+        }
+        is_websocket = true;
+        response_is_chunked = false;
+        bytes_left_to_read = 0;
+        return owner_task->websocketUpgrade(this);
+    }
+
+    try {
+        auto p = http_response_headers.find("transfer-encoding");
+        if (p != http_response_headers.end() && p->second == "chunked") {
+            response_is_chunked = true;
+            chunked_info = "\r\n";
+            final_chunk = false;
+            bytes_left_to_read = 0;
+        } else {
+            p = http_response_headers.find("content-length");
+            if (p == http_response_headers.end()) {
+                err_log() << "cannot find Content-Length";
+                return false;
+            }
+            response_is_chunked = false;
+            bytes_left_to_read = std::stoul(p->second);
+        }
+    } catch (std::exception &err) {
+        err_log() << "Exception when parsing HTTP response: " << err.what();
+        return false;
+    }
+
+    return owner_task->headerComplete(this);
+}
+
+PollState HttpClientConnection::writeData() {
+    if (is_websocket)
+        return wsWriteData();
+
+    bytes_left_to_post -= owner_task->doPost(this, bytes_left_to_post);
+    if (bytes_left_to_post)
+        return PollState::WRITE;
+    else
+        return PollState::READ;
+}
+
+std::string HttpClientConnection::urlencode(const std::string &val) {
+    std::ostringstream res;
+    res.fill('0');
+    res << std::hex;
+
+    for (auto i=val.cbegin(); i!=val.cend(); ++i) {
+        std::string::value_type c = *i;
+
+        if (std::isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
+            res << c;
+        } else {
+            res << '%' << std::setw(2)
+                << std::uppercase << int(static_cast<unsigned char>(c))
+                << std::nouppercase;
+        }
+    }
+
+    return res.str();
+}
+
+void HttpClientConnection::
+addUrlPars(std::string &url, const std::map<std::string, std::string> &pars) {
+    auto p = pars.begin();
+    if (p == pars.end())
+        return;
+    if (url.find('?') == std::string::npos)
+        url += "?";
+    else
+        url += "&";
+    ((url += p->first) += "=") += urlencode(p->second);
+    while (++p != pars.end())
+        (((url += "&") += p->first) += "=") += urlencode(p->second);
+}
+
+void HttpClientConnection::get(const std::string &url) {
+    if (!idle()) {
+        err_log() << "previous request not complete: " << current_request;
+        return;
+    }
+    current_uri = url;
+    current_request = "GET " + proto_hostname +
+        url + " HTTP/1.1\r\nHost: " + real_hostname +
+        "\r\n" + owner_task->httpHeaderLines(url) + "\r\n";
+}
+
+void HttpClientConnection::ws_get(const std::string &url) {
+    if (!idle()) {
+        err_log() << "previous request not complete: " << current_request;
+        return;
+    }
+    if (!proto_hostname.empty()) {
+        current_uri = url;
+        websocket_rkey = "CONNECT";
+        current_request = "CONNECT " + real_hostname + " HTTP/1.1\r\n"
+            "Hostname: " + real_hostname + "\r\n\r\n";
+        return;
+    }
+    // The first 24 chars will be filled with random base64 chars,
+    // the rest is the websocket uuid.
+    static char dst[] {
+        "01234567890123456789====258EAFA5-E914-47DA-95CA-C5AB0DC85B11" };
+
+    // 16 byte random data, convert to 24 base64 chars:
+    int32_t rnd[4] = { rand(), rand(), rand(), rand() };
+    const unsigned char *src = reinterpret_cast<const unsigned char *>(rnd);
+    base64_encode(src, sizeof(rnd), dst);
+
+    current_uri = url;
+    current_request = "GET " + proto_hostname +
+        url + " HTTP/1.1\r\nHost: " + real_hostname +
+        "\r\nSec-WebSocket-Key: " + std::string(dst, 24) +
+        "\r\nSec-WebSocket-Version: 13\r\nUpgrade: websocket"
+        "\r\nConnection: Upgrade"
+        "\r\n" + owner_task->httpHeaderLines(url) + "\r\n";
+    static char rkey[] = "012345678901234567890123456=";
+    static SHA1 sha1(rkey);
+    sha1.update(dst);
+    // The server's response is supposed to contain this string:
+    websocket_rkey = std::string(rkey, 28);
+}
+
+void HttpClientConnection::post(const std::string &url,
+                                const std::string &data) {
+    if (!idle()) {
+        err_log() << "previous request not complete: " << current_request;
+        return;
+    }
+    current_uri = url;
+    current_request = "POST " + proto_hostname + url + " HTTP/1.1\r\nHost: " +
+        real_hostname + "\r\n" + owner_task->httpHeaderLines(url) +
+        "Content-Length: " + std::to_string(data.size()) + "\r\n\r\n" + data;
+}
+
+void HttpClientConnection::post(const std::string &url, size_t len) {
+    if (!idle()) {
+        err_log() << "previous request not complete: " << current_request;
+        return;
+    }
+    current_uri = url;
+    current_request = "POST " + proto_hostname + url + " HTTP/1.1\r\nHost: " +
+        real_hostname + "\r\n" + owner_task->httpHeaderLines(url) +
+        "Content-Length: " + std::to_string(len) + "\r\n\r\n";
+    bytes_left_to_post = len;
+}
+
+std::string HttpClientConnection::cacheLabel() {
+    return owner_task->cacheLabel();
+}
+
+void HttpClientConnection::setOwner(Task *new_owner) {
+    owner_task = dynamic_cast<HttpClientTask *>(new_owner);
+    if (!owner_task)
+        throw std::logic_error("expected HttClientTask");
+    Socket::setOwner(new_owner);
+}
diff --git a/src/http/httpclientconnection.h b/src/http/httpclientconnection.h
new file mode 100644
index 0000000..46e6b31
--- /dev/null
+++ b/src/http/httpclientconnection.h
@@ -0,0 +1,160 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <map>
+#include <sstream>
+
+#include "httpconnection.h"
+
+class HttpClientTask;
+
+/// \brief
+/// HTTP/1.1 client protocol.
+///
+/// This class implements a small subset of the HTTP/1.1 client protocol.
+/// A connection will be made to the given hostname/port.
+/// When the connection is ready for a new HTTP request, the owner
+/// task's method newRequest(HttpClientConnection *conn) will be called.
+/// To use this class, you must derive from HttpClientTask and implement the
+/// newRequest method to perform HTTP requests over the HttpClientConnection.
+///
+/// A call to the owner task's headerComplete will be made when response
+/// headers are read. If headerComplete returns false the connection
+/// will be dropped.
+///
+/// Within headerComplete you may call conn->doStreamResponse()
+/// if you want the respone to be "streamed" to you, i.e. to be notified
+/// (by a call to the owner task's payload method) whenever a part of the
+/// response arrives. The default is for this class to buffer the response
+/// and only notify the ower task when the complete response has been received.
+///
+/// A call to the owner task's requestComplete will be made when the complete
+/// response has been read. If requestComplete returns false the connection
+/// will be dropped. Otherwise, the newRequest will be called again so that
+/// a new HTTP request can be made.
+/// Within requestComplete, you can call contents() to get the HTTP response
+/// unless doStreamResponse() was called before.
+class HttpClientConnection : public HttpConnection {
+public:
+    // TODO: take a HttpHost as a parameter!
+    HttpClientConnection(const std::string &label, HttpClientTask *task,
+                         const std::string &hostname, uint16_t port,
+                         const std::string &http_hostname = std::string(),
+                         uint16_t iptype = 0,
+                         struct addrinfo *local_addr = nullptr);
+
+    PollState connected() final;
+    PollState readData(char *buf, size_t len) final;
+
+    /// For HTTP POST.
+    PollState writeData() final;
+
+    /// The owner task should call this in the header_complete
+    /// callback if it wants to get partial contents immediately when it
+    /// arrives. The default is for this class to buffer the response and
+    /// pass it to the owner task when the complete response has arrived.
+    void doStreamResponse() {
+        buffer_response = false;
+    }
+
+    /// The owner task may call the below functions in the header_complete
+    /// callback or the response_complete callback.
+    unsigned int httpStatus() const {
+        return response_http_status;
+    }
+
+    /// Return value of first Content-Type header, empty string on failure.
+    std::string contentType() const {
+        auto p = http_response_headers.find("content-type");
+        if (p == http_response_headers.end())
+            return std::string();
+        else
+            return p->second;
+    }
+
+    const std::string &rawHttpHeader() const {
+        return response_header;
+    }
+
+    const std::multimap<std::string, std::string> &responseHeaders() const {
+        return http_response_headers;
+    }
+
+    size_t remainingContentLength() const {
+        return bytes_left_to_read;
+    }
+
+    std::string contents() const {
+        return buffer;
+    }
+
+    /// May be called in the newRequest callback:
+    void get(const std::string &url);
+
+    /// May be called in the newRequest callback:
+    /// The owner task's doPost method will be called repeatedly until it
+    /// returns false, which means there is no more data to post.
+    void post(const std::string &url, size_t len);
+
+    // As above, but with first chunk of data available. Using this method
+    // may save one call to doPost(), i.e. one less send system call.
+    /*
+    void post(const std::string &url, size_t len,
+              const char *buf, size_t buffer_len, size_t lspace = 0);
+    */
+
+    /// May be called in the newRequest callback:
+    /// If data is very large, you should use the above method instead.
+    void post(const std::string &url, const std::string &data);
+
+    /// May be called in the newRequest callback to open a websocket.
+    void ws_get(const std::string &url);
+
+    /// Call in the newRequest callback if you want to keep
+    /// the connection but not do any new request at this time.
+    void pass() {
+        current_request = "pass";
+    }
+    bool idle() const {
+        return current_request.empty() ||
+            current_request == "pass";
+    }
+
+    static std::string urlencode(const std::string &val);
+    static void addUrlPars(std::string &url,
+                           const std::map<std::string, std::string> &pars);
+    std::string cacheLabel() override;
+
+    void setOwner(Task *new_owner) override;
+private:
+    std::string real_hostname;
+    // A weak pointer to the owner task. Dangerous. However, the EventLoop will
+    // kill all connections (i.e. us) before killing the owner task.
+    HttpClientTask *owner_task;
+    std::string proto_hostname;
+    std::string current_request, current_uri;
+
+    // Set if this is a websocket connection:
+    std::string websocket_rkey;
+
+    // Used when reading response headers:
+    std::string response_header;
+
+    const std::string::size_type max_header_length = 20000;
+
+    bool response_header_complete = false;
+    // Set when response headers are parsed:
+    bool response_is_chunked;
+    bool final_chunk;
+    bool buffer_response = true;
+    size_t bytes_left_to_read = 0;
+    size_t bytes_left_to_post = 0;
+    unsigned int response_http_status = 0;
+    std::string chunked_info;
+
+    bool parseResponseHeaders();
+    std::multimap<std::string, std::string> http_response_headers;
+    bool parseChunkedEncodingLength(char *&buf, size_t &len);
+};
diff --git a/src/http/httpclienttask.cpp b/src/http/httpclienttask.cpp
new file mode 100644
index 0000000..4a34ac7
--- /dev/null
+++ b/src/http/httpclienttask.cpp
@@ -0,0 +1,52 @@
+#include <stdexcept>
+
+#include "httpclienttask.h"
+
+HttpClientTask::HttpClientTask(const std::string &name,
+                               const HttpHost &httpserver) :
+    HttpTask(name),
+    peer(httpserver) {
+    if (!peer.proxyHost.empty()) {
+        real_server = peer.hostname + ":" + std::to_string(peer.port);
+    }
+}
+
+bool HttpClientTask::createNewConnection() {
+    HttpClientConnection *conn = real_server.empty() ?
+        new HttpClientConnection(label(), this, peer.hostname, peer.port, "",
+                                 peer.iptype, local_ip) :
+        new HttpClientConnection(label(), this,
+                                 peer.proxyHost, peer.proxyPort,
+                                 real_server, peer.iptype, local_ip);
+#ifdef USE_GNUTLS
+    if (peer.is_tls)
+        conn->enableTLS();
+#endif
+    return addConnection(conn);
+}
+
+bool HttpClientTask::headerComplete(HttpClientConnection *) {
+    return true;
+}
+
+size_t HttpClientTask::doPost(HttpClientConnection *, size_t ) {
+    throw std::runtime_error("doPost method not implemented");
+}
+
+bool HttpClientTask::websocketUpgrade(HttpClientConnection *) {
+    return true;
+}
+
+std::string HttpClientTask::local_address;
+struct addrinfo *HttpClientTask::local_ip = nullptr;
+
+bool HttpClientTask::setLocalAddress(const std::string &addr, uint16_t iptype) {
+    local_address = addr;
+    if (local_address.empty()) {
+        local_ip = nullptr;
+        return true;
+    }
+    Socket sobj("temp", nullptr, local_address, 0);
+    local_ip = sobj.getAddressInfo(iptype);
+    return (local_ip != nullptr);
+}
diff --git a/src/http/httpclienttask.h b/src/http/httpclienttask.h
new file mode 100644
index 0000000..29d684e
--- /dev/null
+++ b/src/http/httpclienttask.h
@@ -0,0 +1,122 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include "httptask.h"
+#include "cookiemanager.h"
+#include "httpclientconnection.h"
+
+/// API for HTTP clients.
+class HttpClientTask : public HttpTask {
+public:
+    HttpClientTask(const std::string &name, const HttpHost &httpserver);
+
+    /// Initiate next request, or ignore to close connection.
+    virtual void newRequest(HttpClientConnection *) {
+    }
+
+    /// \brief
+    /// Called when response headers are fully read and parsed,
+    /// except for websocket upgrades, where websocketUpgrade is called instead.
+    ///
+    /// Override it to send a HTTP request to the server.
+    ///
+    /// Return false to close the connection, true to continue.
+    /// If not overridden, it will always return true.
+    virtual bool headerComplete(HttpClientConnection *);
+
+    /// \brief
+    /// Called after succesful websocket upgrade.
+    ///
+    /// Override it to start sending websocket messages to the server.
+    ///
+    /// Return false to close the connection, true to continue.
+    ///
+    /// If not overridden, it will always return true.
+    virtual bool websocketUpgrade(HttpClientConnection *);
+
+    /// Called when response has been fully read.
+    virtual bool requestComplete(HttpClientConnection *) = 0;
+
+    /// \brief
+    /// Data has arrived from the server.
+    ///
+    /// Called whenever some part of the content arrives, *if* you
+    /// asked for it by calling doStreamResponse() on conn
+    /// in the HttpClientConnection::headerComplete callback.
+    virtual void payload(HttpClientConnection *, char *, size_t ) {
+    }
+
+    /// \brief
+    /// Send POST data, return number of bytes sent.
+    ///
+    /// You _must_ override this method if you intend to stream post requests.
+    /// Typically, you simply do this:
+    ///
+    ///     return conn->sendData(my_buffer, std::min(my_buffer_len, len));
+    virtual size_t doPost(HttpClientConnection *conn, size_t len);
+
+    /// Return server's host name.
+    std::string serverHost() const {
+        return peer.hostname;
+    }
+
+    /// \brief
+    /// Extra header lines to be added to outgoing requests.
+    ///
+    /// If you override this, return zero or more lines ending with "\r\n".
+    /// Unless you want to disable cookies, append the return value of
+    ///
+    ///     cookiemgr->httpHeaderLine(server, uri)
+    virtual std::string httpHeaderLines(const std::string &uri) const {
+        if (!peer.cmgr)
+            return user_agent_header;
+        return peer.cmgr->httpHeaderLine(peer.hostname, uri) +
+            user_agent_header;
+    }
+
+    void setCookie(const std::string &header_line, const std::string &uri) {
+        if (peer.cmgr)
+            peer.cmgr->setCookie(header_line, peer.hostname, uri);
+    }
+    virtual std::string cacheLabel() {
+        return peer.hostname + std::to_string(peer.port);
+    }
+    void setUserAgentString(const std::string &s) {
+        if (s.find_first_of("\r\n") == std::string::npos)
+            user_agent_header = "User-Agent: " + s + "\r\n";
+    }
+
+    /// \brief
+    /// Bind all subsequent client sockets to the given local ip address
+    ///
+    /// Don't call simultaneously from more than one thread
+    static bool setLocalAddress(const std::string &addr, uint16_t iptype);
+
+    static const std::string &getLocalAddress() {
+        return local_address;
+    }
+protected:
+    bool createNewConnection();
+
+    std::string proxyHost() const {
+        return peer.proxyHost;
+    }
+    uint32_t proxyPort() const {
+        return peer.proxyPort;
+    }
+    CookieManager *cookieMgr() const {
+        return peer.cmgr;
+    }
+    void setServer(const std::string hostname, uint16_t port_number = 80) {
+        peer.hostname = hostname;
+        peer.port = port_number;
+    }
+private:
+    HttpHost peer;
+    std::string user_agent_header;
+    std::string real_server;
+    static std::string local_address;
+    static struct addrinfo *local_ip;
+};
diff --git a/src/http/httpconnection.cpp b/src/http/httpconnection.cpp
new file mode 100644
index 0000000..c98f7aa
--- /dev/null
+++ b/src/http/httpconnection.cpp
@@ -0,0 +1,359 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#else
+#include <arpa/inet.h>
+#endif
+
+#include "httpconnection.h"
+#include "sha1.h"
+#include "webservertask.h"
+
+void HttpConnection::send_ws_handshake(const std::string &key) {
+    static const std::string resp = "HTTP/1.1 101 Switching Protocols\r\n"
+        "Connection: Upgrade\r\n"
+        "Upgrade: websocket\r\n"
+        "Sec-WebSocket-Accept: ";
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static char rkey[] = "012345678901234567890123456=";
+#ifdef USE_THREADS
+    thread_local
+#endif
+    static SHA1 sha1(rkey);
+
+    sha1.update((key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").c_str());
+
+    asyncSendData(resp + rkey + "\r\n\r\n");
+}
+
+PollState HttpConnection::wsReadData(const char *buf, size_t len) {
+    //log() << "wsReadData L=" << len << ", RCV: " << receiving_message;
+    if (receiving_message) {
+        if (!stream_incoming)
+            return incoming_ws_data(buf, len);
+        size_t count;
+        if (len >= bytes_to_receive) {
+            len -= bytes_to_receive;
+            count = bytes_to_receive;
+            bytes_to_receive = 0;
+            receiving_message = false;
+        } else {
+            bytes_to_receive -= len;
+            count = len;
+            len = 0;
+        }
+        HttpTask *owner_task = dynamic_cast<HttpTask *>(owner());
+        if (!owner_task)
+            return PollState::CLOSE;
+        bool ret;
+        if (incoming_is_binary)
+            ret = owner_task->wsBinData(this, buf, count);
+        else
+            ret = owner_task->wsTextData(this, buf, count);
+        if (!ret)
+            return PollState::CLOSE;
+        if (!len)
+            return (sending_message ? PollState::READ_WRITE :  PollState::READ);
+        buf += count;
+    }
+    if (buffer.empty())
+        return incoming_ws_header(buf, len);
+    std::string tmp = buffer;
+    tmp.append(buf, len);
+    buffer.clear();
+    return incoming_ws_header(tmp.data(), tmp.size());
+}
+
+PollState HttpConnection::incoming_ws_data(const char *buf, size_t len) {
+    // Unmask, append to buffer (up to bytes_to_receive)
+    size_t count;
+    if (len >= bytes_to_receive) {
+        count = bytes_to_receive;
+        len -= bytes_to_receive;
+        bytes_to_receive = 0;
+    } else {
+        count = len;
+        bytes_to_receive -= len;
+        len = 0;
+    }
+    if (incoming_is_masked) {
+        const unsigned char *msg =
+            reinterpret_cast<const unsigned char *>(buf);
+        buf += count;
+        while (count) {
+            unsigned char c = *msg++ ^ incoming_mask[buffer.size()%4];
+            buffer.push_back(static_cast<char>(c));
+            --count;
+        }
+    } else {
+        buffer.append(buf, count);
+        buf += count;
+    }
+    if (!bytes_to_receive) {
+        HttpTask *owner_task = dynamic_cast<HttpTask *>(owner());
+        if (!owner_task)
+            return PollState::CLOSE;
+        bool ret;
+        if (incoming_is_binary)
+            ret = owner_task->wsBinMessage(this, buffer);
+        else
+            ret = owner_task->wsTextMessage(this, buffer);
+        if (!ret)
+            return PollState::CLOSE;
+        buffer.clear();
+        receiving_message = false;
+    }
+    if (len)
+        return wsReadData(buf, len);
+    return (sending_message ? PollState::READ_WRITE :  PollState::READ);
+}
+
+PollState HttpConnection::incoming_ws_header(const char *buf, size_t buffer_pos) {
+    if (buffer_pos < 2) {
+        buffer.append(buf, buffer_pos);
+        return (sending_message ? PollState::READ_WRITE :  PollState::READ);
+    }
+
+    const unsigned char *msg =
+        reinterpret_cast<const unsigned char *>(buf);
+    size_t hdr_len;
+    size_t msg_len = msg[1] & 0x7f;
+    if (msg_len < 126) {
+        hdr_len = 2;
+    } else if (msg_len == 126) {
+        // 2 bytes message length
+        hdr_len = 4;
+        if (buffer_pos >= hdr_len)
+            msg_len = ntohs(*reinterpret_cast<const uint16_t *>(msg+2));
+    } else {
+        // msg_len == 127, 8 byte message length
+        hdr_len = 10;
+        /* Will not support message size > 4GB
+           msg_len = (((uint64_t) ntohl(*(uint32_t *) (msg+2))) << 32) +
+           ntohl(*(uint32_t *) (msg+6));
+        */
+        if (buffer_pos >= hdr_len)
+            msg_len = ntohl(*reinterpret_cast<const uint32_t *>(msg+6));
+    }
+
+    incoming_is_masked = msg[1] & 0x80;
+    if (incoming_is_masked)
+        hdr_len += 4;
+
+    if (buffer_pos < hdr_len) {
+        buffer.append(buf, buffer_pos);
+        return (sending_message ? PollState::READ_WRITE :  PollState::READ);
+    }
+
+    if (incoming_is_masked)
+        memcpy(incoming_mask, msg + hdr_len - 4, 4);
+
+    unsigned char opcode = msg[0] & 0xf;
+    bool is_final = (msg[0] & 0x80);
+    if (opcode)
+        current_opcode = is_final ? 0 : opcode;
+    else
+        opcode = current_opcode;
+
+    HttpTask *owner_task = dynamic_cast<HttpTask *>(owner());
+    if (!owner_task)
+        return PollState::CLOSE;
+
+    switch (opcode) {
+    case 1:
+        stream_incoming = false;
+        receiving_message = true;
+        incoming_is_binary = false;
+        bytes_to_receive = msg_len;
+        tot_to_receive = msg_len;
+        if (!owner_task->wsTextHeader(this, msg_len))
+            return PollState::CLOSE;
+        break;
+    case 2:
+        bytes_to_receive = msg_len;
+        tot_to_receive = msg_len;
+        stream_incoming = false;
+        receiving_message = true;
+        incoming_is_binary = true;
+        if (!owner_task->wsBinHeader(this, msg_len))
+            return PollState::CLOSE;
+        break;
+    case 8:
+        // Closed by client
+        log() << "ws closed by peer";
+        return PollState::CLOSE;
+    case 9:
+        // Ping
+        send_ws_pong();
+        break;
+    case 10:
+        // Pong, ignore.
+        break;
+    default:
+        err_log() << "Bad websocket opcode " << static_cast<int>(msg[0])
+                  << ' ' << static_cast<int>(msg[1]);
+        return PollState::CLOSE;
+    }
+    buffer_pos -= hdr_len;
+    if (buffer_pos)
+        return wsReadData(buf+hdr_len, buffer_pos);
+    return (sending_message ? PollState::READ_WRITE :  PollState::READ);
+}
+
+void HttpConnection::send_ws_bin_header(size_t len) {
+    if (sending_message) {
+        log() << "Internal error: sending message while streaming";
+        closeMe();
+        return;
+    }
+    unsigned char hdr[11];
+    size_t pos = 0;
+    hdr[pos++] = 0x80 | 0x02;  // Final fragment, type binary
+    if (len > 65535) {
+        hdr[pos++] = 127;
+        uint32_t l = 0;
+        memcpy(&hdr[pos], &l, 4);
+        pos += 4;
+        l = htonl(static_cast<uint32_t>(len));
+        memcpy(&hdr[pos], &l, 4);
+        pos += 4;
+    } else {
+        hdr[pos++] = 126;
+        uint16_t l = htons(static_cast<uint16_t>(len));
+        memcpy(&hdr[pos], &l, 2);
+        pos += 2;
+    }
+    asyncSendData(reinterpret_cast<const char *>(hdr), pos);
+}
+
+void HttpConnection::send_ws_txt_header(size_t len) {
+    if (sending_message) {
+        log() << "Internal error: sending message while streaming";
+        closeMe();
+        return;
+    }
+    // TODO: support for masking the message.
+    unsigned char hdr[11];
+    unsigned int pos = 0;
+    hdr[pos++] = 0x80 | 0x01;  // Final fragment, type text
+    if (len < 126) {
+        hdr[pos++] = static_cast<unsigned char>(len);
+    } else if (len < 65536) {
+        hdr[pos++] = 126;
+        uint16_t l = htons(static_cast<uint16_t>(len));
+        memcpy(&hdr[pos], &l, 2);
+        pos += 2;
+    } else {
+        hdr[pos++] = 127;
+        uint32_t l = 0;
+        memcpy(&hdr[pos], &l, 4);
+        pos += 4;
+        l = htonl(static_cast<uint32_t>(len));
+        memcpy(&hdr[pos], &l, 4);
+        pos += 4;
+    }
+    asyncSendData(reinterpret_cast<char *>(hdr), pos);
+}
+
+void HttpConnection::sendWsMessage(const std::string &msg) {
+
+    size_t len = msg.size();
+
+    if (sending_message) {
+        log() << "Internal error: sending message while streaming";
+        closeMe();
+        return;
+    }
+    // TODO: support for masking the message.
+    unsigned char hdr[11];
+    unsigned int pos = 0;
+    hdr[pos++] = 0x80 | 0x01;  // Final fragment, type text
+    if (len < 126) {
+        hdr[pos++] = static_cast<unsigned char>(len);
+    } else if (len < 65536) {
+        hdr[pos++] = 126;
+        uint16_t l = htons(static_cast<uint16_t>(len));
+        memcpy(&hdr[pos], &l, 2);
+        pos += 2;
+    } else {
+        hdr[pos++] = 127;
+        uint32_t l = 0;
+        memcpy(&hdr[pos], &l, 4);
+        pos += 4;
+        l = htonl(static_cast<uint32_t>(len));
+        memcpy(&hdr[pos], &l, 4);
+        pos += 4;
+    }
+
+    asyncSendData(std::string(reinterpret_cast<char *>(hdr), pos) + msg);
+}
+
+void HttpConnection::sendWsBinary(const char *buf, size_t len) {
+    send_ws_bin_header(len);
+    asyncSendData(buf, len);
+}
+
+void HttpConnection::sendWsClose(uint16_t code, std::string msg) {
+
+    if (msg.size() > 124)
+        msg.resize(124);  // Will only allow a very short message.
+
+    unsigned char hdr[4];
+
+    hdr[0] = 0x80 | 0x08;  // Final fragment, opcode CLOSE
+    // Will send 2 byte error code, then the msg:
+    hdr[1] = static_cast<unsigned char>(2 + msg.size());
+
+    // The error code:
+    uint16_t l = htons(code + 2);
+    memcpy(hdr+2, &l, 2);
+
+    asyncSendData(std::string(reinterpret_cast<char *>(hdr), 4) + msg);
+    closeMe();
+}
+
+void HttpConnection::send_ws_pong() {
+    unsigned char hdr[2];
+
+    hdr[0] = 0x80 | 0x0a;  // Final fragment, opcode PONG
+    hdr[1] = 0;  // No payload, length 0.
+
+    asyncSendData(reinterpret_cast<char *>(hdr), 2);
+}
+
+void HttpConnection::startWsStream(size_t len, bool is_binary) {
+    // TODO: also text
+    log() << "startWsStream " << len;
+    if (is_binary)
+        send_ws_bin_header(len);
+    else
+        send_ws_txt_header(len);
+    bytes_to_send = len;
+    tot_to_send = len;
+    sending_message = true;
+    output_is_binary = is_binary;
+    setWantToSend();
+}
+
+PollState HttpConnection::wsWriteData() {
+    if (!sending_message)
+        return PollState::READ;
+    HttpTask *owner_task = dynamic_cast<HttpTask *>(owner());
+    if (!owner_task)
+        return PollState::CLOSE;
+    size_t sent = owner_task->sendWsData(this);
+    if (sent > bytes_to_send)
+        return PollState::CLOSE;
+    bytes_to_send -= sent;
+    if (bytes_to_send)
+        return PollState::READ_WRITE;
+    sending_message = false;
+    return PollState::READ;
+}
+
+void HttpConnection::setOwner(Task *) {
+}
diff --git a/src/http/httpconnection.h b/src/http/httpconnection.h
new file mode 100644
index 0000000..329f0f9
--- /dev/null
+++ b/src/http/httpconnection.h
@@ -0,0 +1,112 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+// This class implements HTTP functionality common to server and client,
+// mainly the websocket protocol.
+
+#pragma once
+
+#include "../framework/socketconnection.h"
+
+class HttpConnection : public SocketConnection {
+public:
+
+    // 10 for HTTP/1.0, 11 for 1.1, 20 for 2.0 etc.
+    unsigned int httpVersion() {
+        return http_version;
+    }
+
+    void sendWsMessage(const std::string &msg);
+    void sendWsBinary(const char *buf, size_t len);
+
+    // Initiate sending a very large message. The owner task's sendWsData will
+    // be called repetedly until all data has been sent.
+    void startWsBinStream(size_t len) {
+        startWsStream(len, true);
+    }
+    void startWsTxtStream(size_t len) {
+        startWsStream(len, false);
+    }
+    void abortWsStream() {
+        closeMe();
+    }
+    void sendWsClose(uint16_t code, std::string msg);
+    void setOwner(Task *new_owner) override;
+
+    // By default, incoming messages will be buffered and not delivered (through
+    // wsBinMessage or wsTextMessage) until the complete message has arrived.
+    // Call this from within the owner task's wsBinHeader or wsTextHeader
+    // callback to get the response "streamed", i.e. the response will be
+    // delivered in "chunks" to wsBinData/wsTextData as they arrive. Note that
+    // the data may be masked, and you will have to unmask it yourself.
+    void streamWsResponse() {
+        stream_incoming = true;
+    }
+    // Returns pointer to 4 byte incoming mask,
+    // or nullptr if the response isn't masked.
+    const unsigned char *responseMask() const {
+        if (incoming_is_masked)
+            return incoming_mask;
+        else
+            return nullptr;
+    }
+
+    size_t wsIncomingBytesLeft() const {
+        return bytes_to_receive;
+    }
+    size_t wsBytesReceived() const {
+        return tot_to_receive-bytes_to_receive;
+    }
+    size_t wsOutgoingBytesLeft() const {
+        return bytes_to_send;
+    }
+    size_t wsBytesSent() const {
+        return tot_to_send-bytes_to_send;
+    }
+    bool isWebsocket() const {
+        return is_websocket;
+    }
+protected:
+    HttpConnection(const std::string &label, Task *owner,
+                   const std::string &hostname, uint16_t port,
+                   uint16_t iptype = 0, struct addrinfo *local_addr = nullptr) :
+    SocketConnection(label, owner, hostname, port, iptype, local_addr) {
+    }
+    HttpConnection(const std::string &label, Task *owner, int fd,
+                   const char *ip, uint16_t port) :
+        SocketConnection(label, owner, fd, ip, port) {
+    }
+
+    void set_http_version(unsigned int major, unsigned int minor) {
+        http_version = 10U*major + minor;
+    }
+
+    void send_ws_handshake(const std::string &key);
+    void send_ws_bin_header(size_t len);
+    void send_ws_txt_header(size_t len);
+    void send_ws_pong();
+    PollState incoming_ws_data(const char *buf, size_t len);
+    PollState incoming_ws_header(const char *buf, size_t len);
+    PollState wsReadData(const char *buf, size_t len);
+    PollState wsWriteData();
+
+    // Incoming buffer
+    std::string buffer;
+
+    // Everything below is websocket stuff:
+    bool is_websocket = false;
+private:
+    void startWsStream(size_t len, bool is_binary = true);
+    // For fragmented messages:
+    unsigned char current_opcode = 0;
+    bool receiving_message = false;
+    bool sending_message = false;
+    bool output_is_binary = false;
+    bool stream_incoming = false;
+    bool incoming_is_masked = false;
+    bool incoming_is_binary = false;
+    size_t bytes_to_send, tot_to_send;
+    size_t bytes_to_receive, tot_to_receive;
+    unsigned char incoming_mask[4];
+    unsigned int http_version = 11; // 11 for 1.1, 20 for 2.0 etc.
+};
diff --git a/src/http/httphost.h b/src/http/httphost.h
new file mode 100644
index 0000000..adf80cc
--- /dev/null
+++ b/src/http/httphost.h
@@ -0,0 +1,47 @@
+// Copyright (c) 2017 The Swedish Internet Foundation
+// Written by Göran Andersson <goran@init.se>
+
+#pragma once
+
+#include <string>
+#include <cstdint>
+
+class CookieManager;
+
+/// \brief
+/// The host name and port number of a HTTP host.
+///
+/// May also contain a pointer to a cookie jar.
+/// The same CookieManager should
+/// be used for all objects with the same hostname.
+class HttpHost {
+public:
+    /// You create and own the cookie manager.
+    HttpHost(const std::string &hName = std::string(),
+             uint16_t sPort = 80,
+             const std::string &pHost = std::string(),
+             uint16_t pPort = 0,
+             CookieManager *cMgr = nullptr) :
+        hostname(hName), proxyHost(pHost),
+        port(sPort), proxyPort(pPort), cmgr(cMgr) {
+#ifdef USE_GNUTLS
+        is_tls = (sPort == 443);
+#endif
+    }
+    HttpHost(const char *hName, uint16_t sPort = 80) :
+        hostname(hName), port(sPort) {
+#ifdef USE_GNUTLS
+        is_tls = (sPort == 443);
+#endif
+        cmgr = nullptr;
+    }
+    std::string hostname;
+    std::string proxyHost;
+    uint16_t port;
+    uint16_t proxyPort;
+    CookieManager *cmgr;
+    uint16_t iptype = 0; // 4 for ipv4, 6 for ipv6, 0 for any.
+#ifdef USE_GNUTLS
+    bool is_tls;
+#endif
+};
diff --git a/src/http/httprequestengine.cpp b/src/http/httprequestengine.cpp
new file mode 100644
index 0000000..0c179dc
--- /dev/null
+++ b/src/http/httprequestengine.cpp
@@ -0,0 +1,220 @@
+#include "httprequestengine.h"
+
+void HttpRequestEngine::postJob(Task *task, const std::string &event_name,
+                                const std::string &url,
+                                const std::string &data) {
+    auto job = new HREJob({ task, nullptr, event_name, url, data });
+    incoming_jobs.push_back(job);
+
+    dbg_log() << "JOB " << url << " Q=" << incoming_jobs.size()
+              << " I=" << idle_connections.size()
+              << " C=" << no_connections;
+    checkQueue();
+}
+
+void HttpRequestEngine::checkQueue() {
+    if (incoming_jobs.empty())
+        return;
+
+    while (!idle_connections.empty()) {
+        auto p = idle_connections.begin();
+        SocketConnection *s = *p;
+        idle_connections.erase(p);
+        if (wakeUpConnection(s))
+            return;
+    }
+
+    dbg_log() << "No idle connection available, have " << no_connections
+              << " max=" << max_connections;
+
+    if (no_connections < max_connections) {
+        // Increase number of simultaneous connections
+        ++no_connections;
+        checkConnectionCount();
+    }
+
+    // We'll have to wait for an existing connection to become available.
+}
+
+double HttpRequestEngine::start() {
+    log() << "start()";
+    if (incoming_jobs.size() > min_connections) {
+        if (incoming_jobs.size() > max_connections)
+            no_connections = max_connections;
+        else
+            no_connections = static_cast<unsigned int>(incoming_jobs.size());
+    }
+    checkConnectionCount();
+    return tick;
+}
+
+double HttpRequestEngine::timerEvent() {
+    if (no_connections > min_connections) {
+        unsigned int n = static_cast<unsigned int>(active_jobs.size() +
+                                                   incoming_jobs.size());
+        // Will only need n simultaneous connections
+        if (n < no_connections)
+            no_connections = std::max(n, min_connections);
+    }
+
+    // There may be failed jobs waiting to be restarted:
+    checkQueue();
+
+    return tick;
+}
+
+void HttpRequestEngine::newRequest(HttpClientConnection *conn) {
+    dbg_log() << "Ready for a new request, queue size=" << incoming_jobs.size();
+
+    auto p = active_jobs.find(conn);
+    if (p != active_jobs.end()) {
+        HREJob *job = p->second;
+        if (job->data.empty())
+            conn->get(job->url);
+        else
+            conn->post(job->url, job->data);
+        return;
+    }
+
+    while (!incoming_jobs.empty()) {
+        HREJob *job = incoming_jobs.front();
+        incoming_jobs.pop_front();
+        if (!job)
+            continue;
+        log() << "Job " << job->event_name << ": " << job->url;
+        job->connection = conn;
+        if (job->data.empty())
+            conn->get(job->url);
+        else
+            conn->post(job->url, job->data);
+        active_jobs[conn] = job;
+        return;
+    }
+
+    //dbg_log() << "nothing to do";
+    idle_connections.insert(conn);
+    conn->pass();
+}
+
+bool HttpRequestEngine::requestComplete(HttpClientConnection *conn) {
+    dbg_log() << "HttpRequestEngine::requestComplete " << conn->httpStatus()
+              << " --> " << conn->contents();
+
+    {
+        auto p = active_jobs.find(conn);
+        if (p == active_jobs.end())
+            return true;
+
+        last_completed = conn;
+        current_job = p->second;
+    }
+
+    HREJob *job = current_job;
+    redo_job = nullptr;
+
+    if (!current_job->event_name.empty())
+        executeHandler(current_job->task, current_job->event_name);
+    if (redo_job == job) {
+        // User has asked for a new request, let conn stay in active_jobs.
+        redo_job = nullptr;
+    } else {
+        delete job;
+        active_jobs.erase(conn);
+    }
+    last_completed = nullptr;
+    return true;
+}
+
+void HttpRequestEngine::taskFinished(Task *task) {
+    dbg_log() << "Client task " << task->label() << " died.";
+    cancelRequestsByTask(task);
+}
+
+void HttpRequestEngine::cancelRequestsByTask(Task *task) {
+
+    // Cancel active jobs
+    dbg_log() << "Cancel active jobs";
+
+    std::set<HttpClientConnection *> to_remove;
+    for (auto p : active_jobs)
+        if (p.second->task == task) {
+            // Clear event_name to stop handler from being executed:
+            p.second->event_name.clear();
+            to_remove.insert(p.first);
+        }
+
+    for (auto &conn : to_remove)
+        cancelConnection(conn);
+
+    dbg_log() << "Cancel pending jobs";
+
+    // Cancel pending jobs
+    for (auto &job : incoming_jobs) {
+        if (job && job->task == task) {
+            delete job;
+            job = nullptr;
+        }
+    }
+}
+
+void HttpRequestEngine::connAdded(SocketConnection *c) {
+    ++active_connections;
+    dbg_log() << "conn added: " << c << " now have " << active_connections;
+}
+
+void HttpRequestEngine::connRemoved(SocketConnection *c) {
+    --active_connections;
+    dbg_log() << "conn removed: " << c << " now have " << active_connections;
+
+    if (idle_connections.erase(c)) {
+        // An idle connection was closed, perhaps due to keep-alive timeout.
+        if (no_connections > min_connections)
+            --no_connections; // Don't restart the connection now.
+        return;
+    }
+
+    HttpClientConnection *conn = dynamic_cast<HttpClientConnection *>(c);
+    auto p = active_jobs.find(conn);
+    if (p == active_jobs.end())
+        return;
+
+    HREJob *job = p->second;
+    active_jobs.erase(p);
+    if (job->event_name.empty())
+        return;
+
+    // Notify user that request failed
+    last_completed = nullptr;
+    redo_job = nullptr;
+    current_job = job;
+    executeHandler(current_job->task, current_job->event_name);
+    if (redo_job == job) {
+        redo_job = nullptr;
+        // Probably better to wait a little while before restarting.
+        // Put it last in queue, and don't do checkQueue(); now.
+        incoming_jobs.push_back(job);
+    } else {
+        delete current_job;
+    }
+}
+
+void HttpRequestEngine::checkConnectionCount() {
+    if (!hasStarted() || terminated()) {
+        dbg_log() << "FAIL! HttpRequestEngine not active!";
+        return;
+    }
+
+    dbg_log() << "checkConnectionCount: act=" << active_connections
+              << " want=" << no_connections
+              << " max=" << max_connections
+              << " Q=" << incoming_jobs.size()
+              << " I=" << idle_connections.size();
+
+    for (unsigned int i = active_connections; i < no_connections; ++i) {
+        if (!createNewConnection())
+            log() << "couldn't add connection";
+    }
+
+    if (no_connections && !active_connections)
+        connectionLost();
+}
diff --git a/src/http/httprequestengine.h b/src/http/httprequestengine.h
new file mode 100644
index 0000000..d2e8293
--- /dev/null
+++ b/src/http/httprequestengine.h
@@ -0,0 +1,137 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <queue>
+#include <vector>
+#include <map>
+#include <set>
+#include <functional>
+
+#include "httpclienttask.h"
+
+struct HttpRequestEngineEvent {
+    const std::string &url;
+    unsigned int http_status;
+    const std::string &response;
+};
+
+class HttpRequestEngine : public HttpClientTask {
+public:
+    HttpRequestEngine(const std::string &name, const HttpHost &host,
+                      unsigned int min_conn = 0, unsigned int max_conn = 10,
+                      double tick_duration = 0.5) :
+        HttpClientTask(name, host),
+        min_connections(std::min(min_conn, max_conn)),
+        max_connections(max_conn),
+        no_connections(min_connections),
+        active_connections(0),
+        tick(tick_duration > 0.0 ? tick_duration : 0.5) {
+    }
+
+    // Will call task's handleExecution when done, if task has told me to
+    // observe it. I.e. task must have done engine->startObserving(this);
+    // Also, if event_name is an empty string, handleExecution won't be called.
+    void getJob(Task *task, const std::string &event_name,
+                const std::string &url) {
+        postJob(task, event_name, url, "");
+    }
+
+    void postJob(Task *task, const std::string &event_name,
+                 const std::string &url, const std::string &data);
+
+    // Return HTTP status of last completed request, 0 for failure.
+    // Should only be called in the handleExecution callback.
+    unsigned int httpStatus() const {
+        return last_completed ? last_completed->httpStatus() : 0;
+    }
+
+    // Return MIME type of last completed request, empty on failure.
+    // Should only be called in the handleExecution callback.
+    std::string contentType() const {
+        return last_completed ? last_completed->contentType() : "";
+    }
+
+    // Return the payload of the last completed request, empty on failure.
+    // Should only be called in the handleExecution callback.
+    const std::string contents() const {
+        return last_completed ? last_completed->contents() : "";
+    }
+
+    // Return the URL of the last completed request, empty on failure.
+    // Should only be called in the handleExecution callback.
+    const std::string &currentUrl() const {
+        static std::string dummy;
+        return current_job ? current_job->url : dummy;
+    }
+
+    // Perform the same request again.
+    // Should only be called in the handleExecution callback.
+    void redoJob() {
+        redo_job = current_job;
+    }
+
+
+    // Perform another GET request, but with updated url.
+    void redoJob(const std::string &url) {
+        if (current_job) {
+            current_job->url = url;
+            current_job->data.clear();
+        }
+    }
+
+    // Perform another POST request, but with updated url/data.
+    void redoJob(const std::string &url, const std::string &data) {
+        if (current_job) {
+            current_job->url = url;
+            current_job->data = data;
+        }
+    }
+
+    // If a task terminates, release ongoing jobs
+    void taskFinished(Task *t) override;
+
+    // Will be called if all connections have failed.
+    // Default is to try again after next tick.
+    virtual void connectionLost() {
+        dbg_log() << "connectionLost() not implemented";
+    }
+private:
+    struct HREJob {
+        Task *task;
+        HttpClientConnection *connection;
+        std::string event_name, url, data;
+    };
+
+    double start() final;
+
+    double timerEvent() final;
+
+    // Cancel all request owned by task. Handlers won't be executed.
+    void cancelRequestsByTask(Task *task);
+
+    void newRequest(HttpClientConnection *conn) final;
+    bool requestComplete(HttpClientConnection *conn) final;
+    void connAdded(SocketConnection *) final;
+    void connRemoved(SocketConnection *) final;
+    void checkConnectionCount();
+    void checkQueue();
+
+    unsigned int min_connections, max_connections;
+    unsigned int no_connections, active_connections;
+    double tick;
+
+    HttpClientConnection *last_completed = nullptr;
+    HREJob *current_job;
+
+    HREJob *redo_job;
+
+    //size_t max_response_size = 10000000;
+
+    // Jobs waiting to be started
+    std::deque<HREJob *> incoming_jobs;
+
+    std::set<SocketConnection *> idle_connections;
+    std::map<HttpClientConnection *, HREJob *>  active_jobs;
+};
diff --git a/src/http/httpserverconnection.cpp b/src/http/httpserverconnection.cpp
new file mode 100644
index 0000000..d36a2d5
--- /dev/null
+++ b/src/http/httpserverconnection.cpp
@@ -0,0 +1,468 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#ifdef _WIN32
+#define NOMINMAX
+#include <ws2tcpip.h>
+#else
+#include <arpa/inet.h>
+#endif
+
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <cerrno>
+#include <fcntl.h>
+
+#ifdef _WIN32
+#include <time.h>
+#include <windows.h>
+#include <winsock2.h>
+#pragma comment(lib, "ws2_32.lib")
+#else
+#include <unistd.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netdb.h>
+#endif
+#include <sys/stat.h>
+
+#include <sstream>
+#include <algorithm>
+#include "sha1.h"
+
+#include "httpserverconnection.h"
+#include "http_common.h"
+#include "webservertask.h"
+
+HttpServerConnection::
+HttpServerConnection(const std::string &label, WebServerTask *task,
+                     int fd, const char *ip, uint16_t port) :
+    HttpConnection(label, task, fd, ip, port),
+    owner_task(task) {
+}
+
+void HttpServerConnection::setOwner(Task *new_owner) {
+    owner_task = dynamic_cast<WebServerTask *>(new_owner);
+    if (!owner_task)
+        throw std::logic_error("expected WebServerTask");
+    Socket::setOwner(new_owner);
+}
+
+PollState HttpServerConnection::got_post_data(const char *buf, size_t len) {
+    //log() << "got_post_data " << len << " bytes, " << remaining_post_data
+    // << " left\n" << std::string(buf, len);
+    size_t length = std::min(remaining_post_data, len);
+    remaining_post_data -= length;
+    if (remaining_post_data) {
+        if (!buffer_post_data)
+            if (!owner_task->partialPostData(this, buf, length))
+                return PollState::CLOSE;
+    } else {
+        if (buffer_post_data)
+            state = owner_task->lastPostData(this, buffer.c_str(),
+                                             buffer.size());
+        else
+            state = owner_task->lastPostData(this, buf, len);
+        if (len > length) {
+            err_log() << "too much post data sent";
+            return PollState::CLOSE;
+        }
+        if (state == HttpState::SENDING_RESPONSE)
+            return PollState::WRITE;
+        else if (state == HttpState::CLOSE)
+            return PollState::CLOSE;
+    }
+    return PollState::READ;
+}
+
+#ifdef USE_WEBROOT
+bool HttpServerConnection::prepareFileResponse(const std::string &url) {
+
+    if (url.find("../") != std::string::npos)
+        return false;
+
+    std::string webroot = owner_task->webRoot();
+    if (webroot.empty())
+        return false;
+
+    static_file_fd = open( (webroot + url).c_str(), O_RDONLY );
+    if (static_file_fd < 0)
+        return false;
+
+    struct stat sbuf;
+    if (fstat(static_file_fd, &sbuf) < 0 || !S_ISREG(sbuf.st_mode)) {
+        close(static_file_fd);
+        return false;
+    }
+
+    remaining_bytes = static_cast<size_t>(sbuf.st_size);
+    sending_static_file = true;
+    return true;
+}
+
+HttpState HttpServerConnection::sendHttpFileResponse(const std::string &hdrs,
+                                                     const std::string &mime) {
+    if (!sending_static_file || state != HttpState::WAITING_FOR_REQUEST) {
+        err_log() << "internal error, prepareFileResponse not called";
+        return HttpState::CLOSE;
+    }
+
+    sendHttpResponseHeader(hdrs, mime, remaining_bytes);
+
+    if (remaining_bytes)
+        remaining_bytes -= sendFileData(static_file_fd, remaining_bytes);
+
+    if (remaining_bytes)
+        return HttpState::SENDING_RESPONSE;
+    else
+        return HttpState::WAITING_FOR_REQUEST;
+}
+#endif
+
+PollState HttpServerConnection::writeData() {
+    if (is_websocket)
+        return wsWriteData();
+    if (state == HttpState::SENDING_RESPONSE) {
+        // TODO: don't give conn to the owner, too much that can go wrong.
+
+        size_t sent;
+#ifdef USE_WEBROOT
+        if (sending_static_file)
+            sent = sendFileData(static_file_fd, remaining_bytes);
+        else
+#endif
+            sent = owner_task->sendResponseData(this, remaining_bytes);
+
+        remaining_bytes -= sent;
+        if (remaining_bytes)
+            return PollState::WRITE;
+#ifdef USE_WEBROOT
+        if (sending_static_file) {
+            close(static_file_fd);
+            sending_static_file = false;
+        }
+#endif
+        state = HttpState::WAITING_FOR_REQUEST;
+        return PollState::READ;
+    }
+    err_log() << "HttpServerConnection::writeData() called";
+    return PollState::CLOSE;
+}
+
+PollState HttpServerConnection::readData(char *buf, size_t len) {
+    if (is_websocket)
+        return wsReadData(buf, len);
+    if (state == HttpState::READING_POST_DATA && !buffer_post_data)
+        return got_post_data(buf, len);
+    buffer.append(buf, len);
+    return check_buffer();
+}
+
+PollState HttpServerConnection::check_buffer() {
+    if (state == HttpState::WAITING_FOR_REQUEST) {
+        size_t end_of_request = buffer.find("\r\n\r\n");
+        if (end_of_request == std::string::npos) {
+            if (buffer.size() > 20000) {
+                log() << "error: no end of request";
+                return PollState::CLOSE;
+            }
+            return PollState::READ;
+        }
+        //log() << "Got request: " << buffer;
+        current_request = buffer.substr(0, end_of_request+strlen("\r\n\r\n"));
+        buffer.erase(0, current_request.size());
+        if (!parse_request()) {
+            err_log() << "bad request";
+            return PollState::CLOSE;
+        }
+        if (current_method == "GET") {
+            auto p = http_request_headers.find("sec-websocket-key");
+            if (p == http_request_headers.end()) {
+                state = owner_task->newGetRequest(this, current_uri);
+            } else {
+                if (!owner_task->newWsRequest(this, current_uri))
+                    return PollState::CLOSE;
+                state = HttpState::WEBSOCKET;
+                is_websocket = true;
+                send_ws_handshake(p->second);
+                if (notify_after_ws_handshake)
+                    owner_task->wsHandshakeFinished(this, current_uri);
+            }
+            if (buffer.size()) {
+                log() << "unexpected data after GET request";
+                return PollState::CLOSE;
+            }
+        } else if (current_method == "POST") {
+            try {
+                auto p = http_request_headers.find("content-length");
+                if (p == http_request_headers.end()) {
+                    err_log() << "cannot find Content-Length";
+                    // Just assume a very large post:
+                    remaining_post_data = std::string::npos;
+                } else {
+                    remaining_post_data = std::stoul(p->second);
+                }
+            } catch (std::exception &) {
+                err_log() << "cannot parse Content-Length";
+                return PollState::CLOSE;
+            }
+            buffer_post_data = false;
+            state = owner_task->newPostRequest(this, current_uri);
+        } else if (current_method == "OPTIONS") {
+            state = owner_task->preflightRequest(this, current_uri);
+        } else {
+            return PollState::CLOSE;
+        }
+    }
+    if (state == HttpState::CLOSE)
+        return PollState::CLOSE;
+    if (state == HttpState::SENDING_RESPONSE)
+        return PollState::WRITE;
+    if (buffer.empty())
+        return PollState::READ;
+    if (state == HttpState::READING_POST_DATA) {
+        PollState ret = got_post_data(buffer.c_str(), buffer.size());
+        if (!buffer_post_data || !remaining_post_data)
+            buffer.clear();
+        return ret;
+    }
+    return check_buffer();
+}
+
+namespace {
+    inline int hexval(std::string::value_type c) {
+        if (c >= '0' && c <= '9')
+            return c-'0';
+        else if (c >= 'A' && c <= 'F')
+            return (c - 'A' + 10);
+        else if (c >= 'a' && c <= 'f')
+            return (c - 'a' + 10);
+        else
+            return -1000;
+    }
+}
+
+void HttpServerConnection::get_all_parameters(const char *qpos,
+                                              std::multimap<std::string,
+                                              std::string> &pars) {
+    const char *ppos = qpos; // Start of parameter name
+    while (*qpos) {
+        if (*qpos == '&') {
+            // Epmty value:
+            pars.insert(std::make_pair(std::string(ppos, qpos), std::string()));
+            ++qpos;
+            ppos = qpos;
+        } else if (*qpos == '=') {
+            // Urldecode value:
+            std::string par_name = std::string(ppos, qpos);
+            ++qpos; // Start of value
+            std::ostringstream res;
+            while (char c = *qpos) {
+                if (c == '&') {
+                    ++qpos;
+                    break;
+                } else if (c == '+') {
+                    ++qpos;
+                    c = ' ';
+                } else if (c == '%') {
+                    // Should be two hex digits after %,
+                    // but if not, ignore errors and just keep the %
+                    if (*++qpos) {
+                        char c1 = *qpos, c2;
+                        if (*++qpos) {
+                            c2 = *qpos;
+                            if (c2) {
+                                ++qpos;
+                                int n = hexval(c1)*16+hexval(c2);
+                                if (n >= 0)
+                                    c = static_cast<char>(n);
+                            }
+                        }
+                    }
+                } else {
+                    ++qpos;
+                }
+                res << c;
+            }
+            pars.insert(std::make_pair(par_name, res.str()));
+            ppos = qpos;
+        } else {
+            ++qpos;
+        }
+    }
+}
+
+bool HttpServerConnection::parse_request() {
+    std::string first_line;
+    http_request_headers.clear();
+    if (!HttpCommon::parseHeaders(current_request, first_line,
+                                  http_request_headers))
+        return false;
+    size_t eom = first_line.find(' ');
+    if (eom == std::string::npos)
+        return false;
+    size_t eor = first_line.find(' ', eom+1);
+    if (eor == std::string::npos)
+        return false;
+    current_method = first_line.substr(0, eom);
+    current_uri = first_line.substr(eom+1, eor-eom-1);
+    {
+        // HTTP/1.1
+        unsigned int major, minor;
+        int pos = sscanf(first_line.substr(eor+1).c_str(), "HTTP/%u.%u",
+                         &major, &minor);
+        if (pos != 2)
+            return false;
+
+        set_http_version(major, minor);
+    }
+    current_query_pars.clear();
+    size_t qpos = current_uri.find("?");
+    if (qpos != std::string::npos) {
+        current_query_string = current_uri.substr(qpos+1);
+        current_uri.resize(qpos);
+        get_all_parameters(current_query_string.c_str(), current_query_pars);
+    } else {
+        current_query_string.clear();
+    }
+
+    // uri might be given as http://some.domain/blah
+    if (current_uri.substr(0, 4) == "http") {
+        if (current_uri.substr(0, 7) == "http://")
+            qpos = current_uri.find('/', 7);
+        else if (current_uri.substr(0, 8) == "https://")
+            qpos = current_uri.find('/', 8);
+        else
+            return true;
+        if (qpos == std::string::npos)
+            current_uri = "/";
+        else
+            current_uri.erase(0, qpos);
+    }
+    return true;
+}
+
+size_t HttpServerConnection::
+sendHttpResponse(const std::string &headers,
+                 const std::string &mime,
+                 const std::string &contents) {
+    std::ostringstream response;
+    response << headers << "Content-Length: " << contents.size()
+             << "\r\nContent-Type: " << mime << "\r\n\r\n" << contents;
+    size_t len = response.str().size();
+    asyncSendData(response.str());
+    return len;
+}
+
+size_t HttpServerConnection::
+sendHttpResponseHeader(const std::string &headers,
+                       const std::string &mime,
+                       size_t content_length) {
+    std::ostringstream response;
+    response << headers << "Content-Length: " << content_length
+             << "\r\nContent-Type: " << mime << "\r\n\r\n";
+    size_t len = response.str().size();
+    asyncSendData(response.str());
+    remaining_bytes = content_length;
+    return len;
+}
+
+size_t HttpServerConnection::
+sendChunkedResponseHeader(const std::string &headers,
+                          const std::string &mime) {
+    sending_chunked_response = true;
+    std::ostringstream response;
+    response << headers << "Transfer-Encoding: chunked"
+             << "\r\nContent-Type: " << mime << "\r\n\r\n";
+    size_t len = response.str().size();
+    asyncSendData(response.str());
+    return len;
+}
+
+size_t HttpServerConnection::sendChunk(const std::string &content) {
+    if (!sending_chunked_response) {
+        err_log("response encoding is not chunked");
+        return 0;
+    }
+    std::ostringstream chunk;
+    chunk << std::hex << content.size() << "\r\n" << content << "\r\n";
+    asyncSendData(chunk.str());
+    return chunk.str().size();
+}
+
+size_t HttpServerConnection::chunkedResponseComplete() {
+    if (!sending_chunked_response) {
+        err_log("response encoding is not chunked");
+        return 0;
+    }
+    std::string last_chunk = "0\r\n\r\n";
+    sending_chunked_response = false;
+    asyncSendData(last_chunk);
+    return last_chunk.size();
+}
+
+bool HttpServerConnection::hasQueryPar(const std::string &name) const {
+    return (current_query_pars.find(name) != current_query_pars.end());
+}
+
+std::string HttpServerConnection::getQueryVal(const std::string &name) const {
+    auto p = current_query_pars.find(name);
+    if (p != current_query_pars.end())
+        return p->second;
+    return std::string();
+}
+
+std::string HttpServerConnection::getHeaderVal(const std::string &name) const {
+    auto p = http_request_headers.find(name);
+    if (p != http_request_headers.end())
+        return p->second;
+    return std::string();
+}
+
+std::map<std::string, std::string>
+HttpServerConnection::currentRequestCookies() const {
+    std::map<std::string, std::string> c;
+    auto r = getHeaderVals("cookie");
+    for (auto p=r.first; p!=r.second; ++p) {
+        std::string s = p->second;
+        while (!s.empty()) {
+            auto pos1 = s.find('=');
+            if (pos1 == std::string::npos)
+                break;
+            auto pos2 = s.find(';');
+            c[s.substr(0, pos1)] = s.substr(pos1+1, pos2-pos1-1);
+            if (pos2 == std::string::npos)
+                break;
+            s.erase(0, s.find_first_not_of(" \t\r", pos2+1));
+        }
+    }
+    return c;
+}
+
+std::string HttpServerConnection::cookieVal(const std::string &name) const {
+    if (name.find_first_of(" =;,\t") != std::string::npos)
+        return "";
+    auto r = getHeaderVals("cookie");
+    for (auto p=r.first; p!=r.second; ++p) {
+        auto pos = (" " + p->second).find(" " + name + "=");
+        if (pos != std::string::npos) {
+            auto first = p->second.find('=', pos);
+            auto last = p->second.find(';', pos);
+            if (last > first) {
+                return p->second.substr(first+1, last-first-1);
+            }
+        }
+    }
+    return "";
+}
+
+HttpServerConnection::~HttpServerConnection() {
+    dbg_log() << "client connection closed";
+#ifdef USE_WEBROOT
+    if (sending_static_file)
+        close(static_file_fd);
+#endif
+}
diff --git a/src/http/httpserverconnection.h b/src/http/httpserverconnection.h
new file mode 100644
index 0000000..8c575fc
--- /dev/null
+++ b/src/http/httpserverconnection.h
@@ -0,0 +1,189 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <map>
+
+#include "httpconnection.h"
+
+class WebServerTask;
+
+enum class HttpState {
+    CLOSE,
+    WAITING_FOR_REQUEST, SENDING_RESPONSE,
+    READING_POST_DATA, WEBSOCKET
+};
+
+/// \brief
+/// HTTP/1.1 server protocol.
+///
+/// This class implements a small subset of the HTTP/1.1 server protocol.
+/// When a new HTTP GET or POST request is made, the owner task's method
+/// newGetRequest or newPostRequest will be called. If a websocket connection
+/// is made, the owner task's method newWsRequest will be called.
+///
+/// To use this class, you must derive from WebServerTask and implement
+/// at least one of newGetRequest, newPostRequest, or newWsRequest.
+class HttpServerConnection : public HttpConnection {
+public:
+    HttpServerConnection(const std::string &label, WebServerTask *task, int fd,
+                         const char *ip, uint16_t port);
+    virtual ~HttpServerConnection() override;
+    PollState connected() final {
+        return PollState::READ;
+    }
+    PollState readData(char *buf, size_t len) final;
+    //PollState unexpectedData(char *, size_t ) override;
+    PollState writeData() override;
+
+    /// Return true if query string in current request has parameter name:
+    bool hasQueryPar(const std::string &name) const;
+
+    void eraseQueryPar(const std::string &name) {
+        current_query_pars.erase(name);
+    }
+
+    /// If query string in current request has parameter "name",
+    /// return the value of its first occurrence.
+    /// Otherwise return empty string.
+    std::string getQueryVal(const std::string &name) const;
+
+    const std::multimap<std::string, std::string> &currentQueryPars() const {
+        return current_query_pars;
+    }
+
+    std::map<std::string, std::string> currentRequestCookies() const;
+
+    /// Return value of cookie if it exists, otherwise empty string.
+    std::string cookieVal(const std::string &name) const;
+
+    /// If HTTP headers in current request has attribute "name",
+    /// return the value of its first occurrence.
+    /// Otherwise return empty string.
+    /// Note: use only lower-case letters in "name", e.g. "content-length".
+    std::string getHeaderVal(const std::string &name) const;
+
+    typedef std::multimap<std::string, std::string>::const_iterator Hit;
+    std::pair<Hit, Hit> getHeaderVals(const std::string &name) const {
+            return http_request_headers.equal_range(name);
+    }
+
+    /// Async send response. Return length of what's to be sent.
+    size_t sendHttpResponse(const std::string &headers,
+                            const std::string &mime,
+                            const std::string &contents);
+
+    /// Async send response headers. Return length of what's to be sent:
+    size_t sendHttpResponseHeader(const std::string &headers,
+                                  const std::string &mime,
+                                  size_t content_length);
+
+    /// Async send response headers with the "chunked" encoding.
+    /// Return length of what's to be sent.
+    size_t sendChunkedResponseHeader(const std::string &headers,
+                                     const std::string &mime);
+
+    /// Send chunk. May only be used if we sent chunked headers.
+    size_t sendChunk(const std::string &content);
+
+    /// To notify that all chunks have been sent.
+    size_t chunkedResponseComplete();
+
+    bool sendingChunkedResponse() const {
+        return sending_chunked_response;
+    }
+
+#ifdef USE_WEBROOT
+    /// Can only be called in the newGetRequest method.
+    /// Return true if url is a file that can be sent; then you should call the
+    /// sendHttpFileResponse method; otherwise you'd want to send a 404 reply.
+    ///
+    /// *Warning!* Call might be blocking!
+    bool prepareFileResponse(const std::string &url);
+
+    HttpState sendHttpFileResponse(const std::string &headers,
+                                   const std::string &mime);
+
+#endif
+
+    const std::string &currentUri() const {
+        return current_uri;
+    }
+
+    const std::string currentFullUrl() const {
+        if (current_query_string.empty())
+            return current_uri;
+        return current_uri + '?' + current_query_string;
+    }
+
+    const std::string &currentQueryString() const {
+        return current_query_string;
+    }
+
+    /// Number of bytes left of the current HTTP POST.
+    size_t remainingPostData() const {
+        return remaining_post_data;
+    }
+
+    /// The owner task may call this in the newPostRequest handler and return
+    /// HttpState::READING_POST_DATA.
+    /// In that case, the owner task will not get partialPostData calls,
+    /// but only a lastPostData call when the user has posted all data.
+    ///
+    /// Hint: Check first that remainingPostData() isn't too large.
+    void bufferPostData() {
+        buffer_post_data = true;
+    }
+
+    /// Call this if the owner is to be notified after handshake:
+    void notifyWsHandshake() {
+        notify_after_ws_handshake = true;
+    }
+
+    /// Override this to make sure we're not transfered to an owner Task that
+    /// is not a WebServerTask (or subclass).
+    void setOwner(Task *new_owner) override;
+
+    /// Current request (first line and headers) in raw form.
+    std::string currentRequest() const {
+        return current_request;
+    }
+private:
+    // A weak pointer to the owner task. Dangerous. However, the EventLoop will
+    // kill all connections (i.e. us) before killing the owner task.
+    WebServerTask *owner_task;
+    HttpState state = HttpState::WAITING_FOR_REQUEST;
+    std::string current_request;
+    std::multimap<std::string, std::string> http_request_headers;
+    std::string current_method, current_uri;
+    std::string current_query_string;
+    std::multimap<std::string, std::string> current_query_pars;
+    static void get_all_parameters(const char *qpos,
+        std::multimap<std::string, std::string> &pars);
+
+    // Will be set when sending a response with known Content-Length:
+    size_t remaining_bytes;
+
+#ifdef USE_WEBROOT
+    // Will be set if sending_static_file is true:
+    int static_file_fd;
+
+    // Will be true when sending a static file:
+    bool sending_static_file = false;
+#endif
+
+    // Will be true when sending chunked response:
+    bool sending_chunked_response = false;
+
+    // If set to true, the owner will be notified after handshake:
+    bool notify_after_ws_handshake = false;
+
+    // Will be set in state READING_POST_DATA:
+    bool buffer_post_data;
+    size_t remaining_post_data;
+
+    bool parse_request();
+    PollState got_post_data(const char *buf, size_t len);
+    PollState check_buffer();
+};
diff --git a/src/http/httptask.cpp b/src/http/httptask.cpp
new file mode 100644
index 0000000..31d3120
--- /dev/null
+++ b/src/http/httptask.cpp
@@ -0,0 +1,22 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "httptask.h"
+#include "httpconnection.h"
+
+// New websocket text message
+bool HttpTask::wsTextMessage(HttpConnection *,
+                             const std::string &msg) {
+    log() << "ignoring websocket text message: " << msg;
+    return false;
+}
+bool HttpTask::wsBinMessage(HttpConnection *,
+                            const std::string &msg) {
+    log() << "ignoring websocket bin message, length " << msg.size();
+    return false;
+}
+
+size_t HttpTask::sendWsData(HttpConnection *conn) {
+    conn->abortWsStream();
+    return 0;
+}
diff --git a/src/http/httptask.h b/src/http/httptask.h
new file mode 100644
index 0000000..ec5c6cb
--- /dev/null
+++ b/src/http/httptask.h
@@ -0,0 +1,75 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include "../framework/task.h"
+#include "httphost.h"
+
+class HttpConnection;
+
+/// Common API for HTTP server and client tasks.
+class HttpTask : public Task {
+public:
+    HttpTask(const std::string &name) :
+        Task(name) {
+    }
+
+    /// Incoming websocket text message. Return false to kill connection.
+    virtual bool wsTextMessage(HttpConnection *,
+                               const std::string &msg);
+
+    /// Incoming websocket binary message. Return false to kill connection.
+    virtual bool wsBinMessage(HttpConnection *,
+                              const std::string &msg);
+
+    /// \brief
+    /// Called when headers of a binary message are read.
+    ///
+    /// Return false to kill connection. Unless
+    /// you call streamWsResponse, the message will be buffered until complete,
+    /// and then delivered throughwsBinMessage.
+    /// If you call conn->streamWsResponse, the message will be streamed
+    /// through wsBinData.
+    virtual bool wsBinHeader(HttpConnection *, size_t ) {
+        return true;
+    }
+
+    /// \brief
+    /// Called when headers of a text message are read.
+    ///
+    /// Return false to kill connection. Unless
+    /// you call streamWsResponse, the message will be buffered until complete,
+    /// and then delivered through wsTextMessage.
+    /// If you call conn->streamWsResponse, the message will be streamed
+    /// through wsBinData / wsTextData.
+    virtual bool wsTextHeader(HttpConnection *, size_t ) {
+        return true;
+    }
+
+    /// \brief
+    /// Incoming partial websocket binary message.
+    ///
+    /// Return false to kill connection.
+    virtual bool wsBinData(HttpConnection *, const char *, size_t ) {
+        return false;
+    }
+
+    /// \brief
+    /// Incoming partial websocket text message.
+    ///
+    /// Return false to kill connection.
+    virtual bool wsTextData(HttpConnection *, const char *, size_t ) {
+        return false;
+    }
+
+    /// If you have called conn->startWsBinStream, sendWsData will be called
+    /// repetedly (as fast as the network allows) until all data has been sent.
+    /// Override this to return the number of bytes you sent. You may return 0
+    /// if you have a temporary error, but it's really bad to keep returning 0.
+    /// So don't use this feature unless the data to send is readily available.
+    /// To give up, call conn->abortWsStream() and return 0.
+    virtual size_t sendWsData(HttpConnection *conn);
+protected:
+private:
+};
diff --git a/src/http/mk.inc b/src/http/mk.inc
new file mode 100644
index 0000000..e8af855
--- /dev/null
+++ b/src/http/mk.inc
@@ -0,0 +1,25 @@
+ifeq ($(WEBROOT),1)
+CXXFLAGS += -DUSE_WEBROOT
+endif
+
+SOURCES += \
+	$(DIRLEVEL)/http/sha1.cpp \
+	$(DIRLEVEL)/http/httptask.cpp \
+	$(DIRLEVEL)/http/httpclienttask.cpp \
+	$(DIRLEVEL)/http/singlerequest.cpp \
+	$(DIRLEVEL)/http/webservertask.cpp \
+	$(DIRLEVEL)/http/http_common.cpp \
+	$(DIRLEVEL)/http/httpconnection.cpp \
+	$(DIRLEVEL)/http/httpclientconnection.cpp \
+	$(DIRLEVEL)/http/cookiemanager.cpp \
+	$(DIRLEVEL)/http/httpserverconnection.cpp \
+	$(DIRLEVEL)/http/httprequestengine.cpp \
+	$(DIRLEVEL)/http/websocketbridge.cpp
+
+OPT_SOURCES += \
+	$(DIRLEVEL)/http/cookiefile.cpp
+
+# Note: we don't add $(DIRLEVEL)/http/cookiefile.cpp by default
+#       since it uses the file system, which not all clients may want.
+
+include $(DIRLEVEL)/framework/mk.inc
diff --git a/src/http/sha1.cpp b/src/http/sha1.cpp
new file mode 100644
index 0000000..58d43fb
--- /dev/null
+++ b/src/http/sha1.cpp
@@ -0,0 +1,306 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Based on public domain code.
+// Modified by Göran Andersson <initgoran@gmail.com>
+
+#include <sstream>
+#include <iomanip>
+#include <fstream>
+#include <string.h>
+
+#include "sha1.h"
+
+static char base64(unsigned int value_in) {
+    static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    if (value_in > 63)
+        return '=';
+    return encoding[static_cast<int>(value_in)];
+}
+
+// encode len bytes starting at src, write to dst.
+// number of bytes written will be 4 times the smallest integer >= len/3.
+void base64_encode(const unsigned char *src, size_t len, char *destination) {
+    char *p = destination;
+    while (len >= 3) {
+        len -= 3;
+        *p++ = base64(src[0] >> 2);
+        *p++ = base64(static_cast<unsigned char>((src[0] & 0x3) << 4) + (src[1] >> 4));
+        *p++ = base64(static_cast<unsigned char>((src[1] & 0xf) << 2) + (src[2] >> 6));
+        *p++ = base64(src[2] & 0x3f);
+        src += 3;
+    }
+    switch (len) {
+    case 2:
+        *p++ = base64(src[0] >> 2);
+        *p++ = base64(static_cast<unsigned char>((src[0] & 0x3) << 4) + (src[1] >> 4));
+        *p++ = base64(static_cast<unsigned char>((src[1] & 0xf) << 2));
+        break;
+    case 1:
+        *p++ = base64(src[0] >> 2);
+        *p++ = base64(static_cast<unsigned char>((src[0] & 0x3) << 4));
+        break;
+    }
+    switch ((p-destination)%4) {
+    case 3:
+        *p++ = '=';
+#ifdef __clang__
+        [[clang::fallthrough]];
+#elif defined __GNUC__
+#if __GNUC__ > 6
+        [[gnu::fallthrough]];
+#endif
+        // -Wimplicit-fallthrough=0
+#endif
+    case 2:
+        *p++ = '=';
+#ifdef __clang__
+        [[clang::fallthrough]];
+#elif defined __GNUC__
+#if __GNUC__ > 6
+        [[gnu::fallthrough]];
+#endif
+        // -Wimplicit-fallthrough=0
+#endif
+    case 1:
+        *p++ = '=';
+        break;
+    }
+}
+
+namespace {
+    int _one = 1;
+}
+
+bool SHA1::is_big_endian = (*(reinterpret_cast<int8_t *>(&_one)) == 0);
+
+/* Help macros */
+#define SHA1_ROL(value, bits) (((value) << (bits)) | (((value) & 0xffffffff) >> (32 - (bits))))
+#define SHA1_BLK(i) (block[i&15] = SHA1_ROL(block[(i+13)&15] ^ block[(i+8)&15] ^ block[(i+2)&15] ^ block[i&15],1))
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define SHA1_R0(v,w,x,y,z,i) z += ((w&(x^y))^y)     + block[i]    + 0x5a827999 + SHA1_ROL(v,5); w=SHA1_ROL(w,30)
+#define SHA1_R1(v,w,x,y,z,i) z += ((w&(x^y))^y)     + SHA1_BLK(i) + 0x5a827999 + SHA1_ROL(v,5); w=SHA1_ROL(w,30)
+#define SHA1_R2(v,w,x,y,z,i) z += (w^x^y)           + SHA1_BLK(i) + 0x6ed9eba1 + SHA1_ROL(v,5); w=SHA1_ROL(w,30)
+#define SHA1_R3(v,w,x,y,z,i) z += (((w|x)&y)|(w&x)) + SHA1_BLK(i) + 0x8f1bbcdc + SHA1_ROL(v,5); w=SHA1_ROL(w,30)
+#define SHA1_R4(v,w,x,y,z,i) z += (w^x^y)           + SHA1_BLK(i) + 0xca62c1d6 + SHA1_ROL(v,5); w=SHA1_ROL(w,30)
+
+SHA1::SHA1(char *buf) :
+    the_res(buf) {
+}
+
+void SHA1::update(const char *key) {
+    std::istringstream is(key);
+
+    /* SHA1 initialization constants */
+    digest[0] = 0x67452301;
+    digest[1] = 0xefcdab89;
+    digest[2] = 0x98badcfe;
+    digest[3] = 0x10325476;
+    digest[4] = 0xc3d2e1f0;
+
+    /* Reset counters */
+    transforms = 0;
+    std::string buffer;
+
+    std::string rest_of_buffer;
+    read(is, rest_of_buffer, static_cast<int>(BLOCK_BYTES) - static_cast<int>(buffer.size()));
+    buffer += rest_of_buffer;
+
+    while (is) {
+        uint32_t block[BLOCK_INTS];
+        buffer_to_block(buffer, block);
+        transform(block);
+        read(is, buffer, BLOCK_BYTES);
+    }
+
+    /* Total number of hashed bits */
+    uint64_t total_bits = (transforms*BLOCK_BYTES + buffer.size()) * 8;
+
+    /* Padding */
+    buffer += static_cast<char>(0x80);
+    unsigned int orig_size = static_cast<unsigned int>(buffer.size());
+    while (buffer.size() < BLOCK_BYTES) {
+        buffer += static_cast<char>(0x00);
+    }
+
+    uint32_t block[BLOCK_INTS];
+    buffer_to_block(buffer, block);
+
+    if (orig_size > BLOCK_BYTES - 8) {
+        transform(block);
+        for (unsigned int i = 0; i < BLOCK_INTS - 2; i++) {
+            block[i] = 0;
+        }
+    }
+
+    /* Append total_bits, split this uint64_t into two uint32_t */
+    block[BLOCK_INTS - 1] = static_cast<uint32_t>(total_bits);
+    block[BLOCK_INTS - 2] = (total_bits >> 32);
+    transform(block);
+
+    /* Base64 */
+    unsigned char *pp = reinterpret_cast<unsigned char *>(digest);
+    unsigned int pos = 0;
+    if (is_big_endian) {
+        base64_encode(pp, 20, the_res);
+        return;
+    }
+
+    // Byte order is 3, 2, 1, 0, 7, 6, 5, 4, 11, ...
+
+    the_res[pos++] = base64(pp[3] >> 2);
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[3] & 0x3) << 4) + (pp[2] >> 4));
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[2] & 0xf) << 2) + (pp[1] >> 6));
+    the_res[pos++] = base64(pp[1] & 0x3f);
+
+    the_res[pos++] = base64(pp[0] >> 2);
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[0] & 0x3) << 4) + (pp[7] >> 4));
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[7] & 0xf) << 2) + (pp[6] >> 6));
+    the_res[pos++] = base64(pp[6] & 0x3f);
+
+    the_res[pos++] = base64(pp[5] >> 2);
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[5] & 0x3) << 4) + (pp[4] >> 4));
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[4] & 0xf) << 2) + (pp[11] >> 6));
+    the_res[pos++] = base64(pp[11] & 0x3f);
+
+    the_res[pos++] = base64(pp[10] >> 2);
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[10] & 0x3) << 4) + (pp[9] >> 4));
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[9] & 0xf) << 2) + (pp[8] >> 6));
+    the_res[pos++] = base64(pp[8] & 0x3f);
+
+    the_res[pos++] = base64(pp[15] >> 2);
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[15] & 0x3) << 4) + (pp[14] >> 4));
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[14] & 0xf) << 2) + (pp[13] >> 6));
+    the_res[pos++] = base64(pp[13] & 0x3f);
+
+    the_res[pos++] = base64(pp[12] >> 2);
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[12] & 0x3) << 4) + (pp[19] >> 4));
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[19] & 0xf) << 2) + (pp[18] >> 6));
+    the_res[pos++] = base64(pp[18] & 0x3f);
+
+    the_res[pos++] = base64(pp[17] >> 2);
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[17] & 0x3) << 4) + (pp[16] >> 4));
+    the_res[pos++] = base64(static_cast<unsigned char>((pp[16] & 0xf) << 2));
+}
+
+/*
+ * Hash a single 512-bit block. This is the core of the algorithm.
+ */
+
+void SHA1::transform(uint32_t block[BLOCK_BYTES])
+{
+    /* Copy digest[] to working vars */
+    uint32_t a = digest[0];
+    uint32_t b = digest[1];
+    uint32_t c = digest[2];
+    uint32_t d = digest[3];
+    uint32_t e = digest[4];
+
+    /* 4 rounds of 20 operations each. Loop unrolled. */
+    SHA1_R0(a,b,c,d,e, 0);
+    SHA1_R0(e,a,b,c,d, 1);
+    SHA1_R0(d,e,a,b,c, 2);
+    SHA1_R0(c,d,e,a,b, 3);
+    SHA1_R0(b,c,d,e,a, 4);
+    SHA1_R0(a,b,c,d,e, 5);
+    SHA1_R0(e,a,b,c,d, 6);
+    SHA1_R0(d,e,a,b,c, 7);
+    SHA1_R0(c,d,e,a,b, 8);
+    SHA1_R0(b,c,d,e,a, 9);
+    SHA1_R0(a,b,c,d,e,10);
+    SHA1_R0(e,a,b,c,d,11);
+    SHA1_R0(d,e,a,b,c,12);
+    SHA1_R0(c,d,e,a,b,13);
+    SHA1_R0(b,c,d,e,a,14);
+    SHA1_R0(a,b,c,d,e,15);
+    SHA1_R1(e,a,b,c,d,16);
+    SHA1_R1(d,e,a,b,c,17);
+    SHA1_R1(c,d,e,a,b,18);
+    SHA1_R1(b,c,d,e,a,19);
+    SHA1_R2(a,b,c,d,e,20);
+    SHA1_R2(e,a,b,c,d,21);
+    SHA1_R2(d,e,a,b,c,22);
+    SHA1_R2(c,d,e,a,b,23);
+    SHA1_R2(b,c,d,e,a,24);
+    SHA1_R2(a,b,c,d,e,25);
+    SHA1_R2(e,a,b,c,d,26);
+    SHA1_R2(d,e,a,b,c,27);
+    SHA1_R2(c,d,e,a,b,28);
+    SHA1_R2(b,c,d,e,a,29);
+    SHA1_R2(a,b,c,d,e,30);
+    SHA1_R2(e,a,b,c,d,31);
+    SHA1_R2(d,e,a,b,c,32);
+    SHA1_R2(c,d,e,a,b,33);
+    SHA1_R2(b,c,d,e,a,34);
+    SHA1_R2(a,b,c,d,e,35);
+    SHA1_R2(e,a,b,c,d,36);
+    SHA1_R2(d,e,a,b,c,37);
+    SHA1_R2(c,d,e,a,b,38);
+    SHA1_R2(b,c,d,e,a,39);
+    SHA1_R3(a,b,c,d,e,40);
+    SHA1_R3(e,a,b,c,d,41);
+    SHA1_R3(d,e,a,b,c,42);
+    SHA1_R3(c,d,e,a,b,43);
+    SHA1_R3(b,c,d,e,a,44);
+    SHA1_R3(a,b,c,d,e,45);
+    SHA1_R3(e,a,b,c,d,46);
+    SHA1_R3(d,e,a,b,c,47);
+    SHA1_R3(c,d,e,a,b,48);
+    SHA1_R3(b,c,d,e,a,49);
+    SHA1_R3(a,b,c,d,e,50);
+    SHA1_R3(e,a,b,c,d,51);
+    SHA1_R3(d,e,a,b,c,52);
+    SHA1_R3(c,d,e,a,b,53);
+    SHA1_R3(b,c,d,e,a,54);
+    SHA1_R3(a,b,c,d,e,55);
+    SHA1_R3(e,a,b,c,d,56);
+    SHA1_R3(d,e,a,b,c,57);
+    SHA1_R3(c,d,e,a,b,58);
+    SHA1_R3(b,c,d,e,a,59);
+    SHA1_R4(a,b,c,d,e,60);
+    SHA1_R4(e,a,b,c,d,61);
+    SHA1_R4(d,e,a,b,c,62);
+    SHA1_R4(c,d,e,a,b,63);
+    SHA1_R4(b,c,d,e,a,64);
+    SHA1_R4(a,b,c,d,e,65);
+    SHA1_R4(e,a,b,c,d,66);
+    SHA1_R4(d,e,a,b,c,67);
+    SHA1_R4(c,d,e,a,b,68);
+    SHA1_R4(b,c,d,e,a,69);
+    SHA1_R4(a,b,c,d,e,70);
+    SHA1_R4(e,a,b,c,d,71);
+    SHA1_R4(d,e,a,b,c,72);
+    SHA1_R4(c,d,e,a,b,73);
+    SHA1_R4(b,c,d,e,a,74);
+    SHA1_R4(a,b,c,d,e,75);
+    SHA1_R4(e,a,b,c,d,76);
+    SHA1_R4(d,e,a,b,c,77);
+    SHA1_R4(c,d,e,a,b,78);
+    SHA1_R4(b,c,d,e,a,79);
+
+    /* Add the working vars back into digest[] */
+    digest[0] += a;
+    digest[1] += b;
+    digest[2] += c;
+    digest[3] += d;
+    digest[4] += e;
+
+    /* Count the number of transformations */
+    transforms++;
+}
+
+void SHA1::buffer_to_block(const std::string &buffer, uint32_t block[BLOCK_BYTES])
+{
+    /* Convert the std::string (byte buffer) to a uint32_t array (MSB) */
+    for (unsigned int i = 0; i < BLOCK_INTS; i++) {
+        block[i] = (buffer[4*i+3] & 0xff)
+            | static_cast<uint32_t>(buffer[4*i+2] & 0xff)<<8
+            | static_cast<uint32_t>(buffer[4*i+1] & 0xff)<<16
+            | static_cast<uint32_t>(buffer[4*i+0] & 0xff)<<24;
+    }
+}
+
+void SHA1::read(std::istream &is, std::string &s, int max) {
+    char sbuf[BLOCK_BYTES];
+    is.read(sbuf, max);
+    s.assign(sbuf, static_cast<size_t>(is.gcount()));
+}
diff --git a/src/http/sha1.h b/src/http/sha1.h
new file mode 100644
index 0000000..b3792ae
--- /dev/null
+++ b/src/http/sha1.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2017 The Swedish Internet Foundation
+// Based on public domain code.
+// Modified by Göran Andersson <goran@init.se>
+
+#pragma once
+
+#include <iostream>
+#include <string>
+#include <cstdint>
+
+void base64_encode(const unsigned char *src, size_t len, char *destination);
+
+class SHA1 {
+public:
+    // You provide a buffer, at least 27 bytes large.
+    SHA1(char *buf);
+
+    // Result (base64 encoded) will be stored in buf, no nul termination.
+    void update(const char *key);
+
+private:
+    static bool is_big_endian;
+    char *the_res;
+
+    static const uint32_t DIGEST_INTS = 5;  // number of 32bit integers per SHA1 digest
+    static const unsigned int BLOCK_INTS = 16;  // number of 32bit integers per SHA1 block
+    static const unsigned int BLOCK_BYTES = BLOCK_INTS * 4;
+
+    uint32_t digest[DIGEST_INTS];
+    uint64_t transforms;
+
+    void transform(uint32_t block[BLOCK_BYTES]);
+
+    static void buffer_to_block(const std::string &buffer, uint32_t block[BLOCK_BYTES]);
+    static void read(std::istream &is, std::string &s, int max);
+};
diff --git a/src/http/singlerequest.cpp b/src/http/singlerequest.cpp
new file mode 100644
index 0000000..cc24286
--- /dev/null
+++ b/src/http/singlerequest.cpp
@@ -0,0 +1,19 @@
+#include "singlerequest.h"
+
+double SingleRequest::start() {
+    if (!createNewConnection())
+        setError("SingleRequest Failure");
+    return _timeout;
+}
+
+double SingleRequest::timerEvent() {
+    if (!terminated())
+        setError("SingleRequest Timeout");
+    return 0.0;
+}
+
+bool SingleRequest::requestComplete(HttpClientConnection *conn) {
+    setResult(conn->contents());
+    _status = conn->httpStatus();
+    return false;
+}
diff --git a/src/http/singlerequest.h b/src/http/singlerequest.h
new file mode 100644
index 0000000..5b800d5
--- /dev/null
+++ b/src/http/singlerequest.h
@@ -0,0 +1,49 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include "httpclienttask.h"
+
+class SingleRequest : public HttpClientTask {
+public:
+    // GET url
+    SingleRequest(const std::string &name, const HttpHost &host,
+                  const std::string &url, double timeout = 0.0) :
+        HttpClientTask(name, host), _url(url), _timeout(timeout) {
+    }
+    // POST post_data to url.
+    SingleRequest(const std::string &name, const HttpHost &host,
+                  const std::string &url, const std::string &post_data,
+                  double timeout = 0.0) :
+        HttpClientTask(name, host), _url(url),
+        _post_data(post_data), _timeout(timeout) {
+    }
+
+    double start() override;
+
+    double timerEvent() override;
+
+    void newRequest(HttpClientConnection *conn) override {
+        if (_post_data.empty())
+            conn->get(_url);
+        else
+            conn->post(_url, _post_data);
+    }
+
+    bool requestComplete(HttpClientConnection *conn) override;
+
+    void connRemoved(SocketConnection *) override {
+        if (!terminated())
+            setError("SingleRequest Failure");
+    }
+
+    unsigned int httpStatus() const {
+        return _status;
+    }
+private:
+    std::string _url;
+    std::string _post_data;
+    double _timeout;
+    unsigned int _status = 0;
+};
diff --git a/src/http/webservertask.cpp b/src/http/webservertask.cpp
new file mode 100644
index 0000000..b27e177
--- /dev/null
+++ b/src/http/webservertask.cpp
@@ -0,0 +1,122 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <sstream>
+#include <fstream>
+
+#include "../framework/serversocket.h"
+#include "webservertask.h"
+#include "httpserverconnection.h"
+
+WebServerTask::WebServerTask(const std::string &name, const TaskConfig &cfg) :
+    HttpTask(name),
+    the_config(cfg),
+    server_name(name) {
+    setFixedHeaders("");
+}
+
+double WebServerTask::start() {
+    log() << "WebServerTask::start()";
+    parseListen(the_config, "Web server");
+    webroot = the_config.value("webroot");
+    return 0;
+}
+
+std::string WebServerTask::setCookie(const std::string &name,
+                                     const std::string &val,
+                                     long expiry,
+                                     const std::string &path,
+                                     std::string domain) const {
+    std::string line = "Set-Cookie: " + name + "=";
+    if (expiry >= 0)
+        line += val;
+
+    if (!expiry)  // Session cookie
+        return line + "\r\n";
+
+    if (domain.empty()) {
+        domain = the_config.value("cookie_domain");
+        if (domain.empty())
+            return "";
+    }
+
+    std::string date = dateString2(expiry < 0 ? 1 : time(nullptr) + expiry);
+
+    // Set-Cookie: previous_isp=23; expires=Wed, 07-Jun-2017 11:34:59 GMT;
+    // path=/; domain=.bredbandskollen.se
+    return line + "; expires=" + date + " GMT; path=" + path +
+        "; domain=" + domain + "\r\n";
+}
+
+SocketConnection *WebServerTask::
+newClient(int fd, const char *ip, uint16_t port, ServerSocket *) {
+    return new HttpServerConnection("Web client", this, fd, ip, port);
+}
+
+HttpState WebServerTask::newPostRequest(HttpServerConnection *,
+                                        const std::string &uri) {
+    log() << "POST: " << uri;
+    return HttpState::READING_POST_DATA;
+}
+
+// Return true to continue, false to close the connection.
+bool WebServerTask::partialPostData(HttpServerConnection *,
+                                    const char *, size_t ) {
+    return true;
+}
+
+HttpState WebServerTask::lastPostData(HttpServerConnection *,
+                                      const char *, size_t ) {
+    return HttpState::CLOSE;
+}
+
+bool WebServerTask::newWsRequest(HttpServerConnection *,
+                                 const std::string &uri) {
+    log() << "WS url: " << uri;
+    return true;
+}
+
+void WebServerTask::wsHandshakeFinished(HttpServerConnection *,
+                                        const std::string &) {
+}
+
+// Origin: http://www.mydomain.com:9001
+// Origin: https://www.mydomain.com
+// domain should be "mydomain.com" or "www.mydomain.com"
+std::string WebServerTask::corsHeader(HttpServerConnection *conn,
+                                      const std::string &domain) {
+    if (domain.empty())
+        return "Access-Control-Allow-Origin: *\r\n";
+    std::string origin = conn->getHeaderVal("origin");
+    auto pos = origin.find(domain);
+    if (pos == std::string::npos)
+        return std::string();
+
+    if (pos && origin[pos-1] != '/' && origin[pos-1] != '.')
+        return std::string();
+
+    if (origin.size() != pos + domain.size() &&
+        origin[pos + domain.size()] != ':')
+        return std::string();
+
+    return "Access-Control-Allow-Origin: " + origin + "\r\n";
+}
+
+#ifdef USE_GNUTLS
+#include "../framework/socketreceiver.h"
+
+void WebServerTask::newWorkerChannel(SocketReceiver *srv, unsigned int chan) {
+    std::string cfg = the_config.value("channel" + std::to_string(chan));
+    if (cfg.empty())
+        return;
+    std::istringstream s(cfg);
+    std::string tls, cert, key, password;
+    s >> tls >> cert >> key >> password;
+    if (tls != "tls")
+        return;
+    if (key.empty() || !tlsSetKey(srv, cert, key, password)) {
+        err_log() << "cannot load TLS certificate " << cert;
+        setError("cannot use TLS certificate");
+    }
+}
+#endif
diff --git a/src/http/webservertask.h b/src/http/webservertask.h
new file mode 100644
index 0000000..758da22
--- /dev/null
+++ b/src/http/webservertask.h
@@ -0,0 +1,141 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <stdexcept>
+#include <map>
+
+#include "httptask.h"
+#include "httpserverconnection.h"
+#ifdef USE_GNUTLS
+class SocketReceiver;
+#endif
+
+/// API for HTTP servers.
+class WebServerTask : public HttpTask {
+public:
+    WebServerTask(const std::string &name, const TaskConfig &cfg=TaskConfig());
+
+    double start() override;
+
+    std::string headers(const std::string &code) {
+        return "HTTP/1.1 " + code + "\r\n" + fixed_response_headers;
+    }
+
+    /// \brief
+    /// Return a string that may be inserted into the HTTP response headers.
+    ///
+    /// Let expiry be 0 for a session cookie, < 0 to delete cookie, otherwise
+    /// expiry should be the cookie's max-time in seconds.
+    /// If domain is empty, the cookie_domain config parameter will be used.
+    /// Example:
+    ///
+    ///     conn->sendHttpResponse(headers("200 OK",
+    ///                                    setCookie("lang", "en", 86400)),
+    //                             "text/plain", data)
+    std::string setCookie(const std::string &name, const std::string &val,
+                          long expiry = 0, const std::string &path = "/",
+                          std::string domain = "") const;
+
+    /// When you overload this, call sendHttpResponse and return
+    /// WAITING_FOR_REQUEST (or CLOSE), or
+    /// call sendHttpResponseHeader and return SENDING_RESPONSE.
+    /// In the latter case, your overloaded sendResponseData method will be
+    /// called regularly until all is sent.
+    virtual HttpState newGetRequest(HttpServerConnection *,
+                                    const std::string &) {
+        return HttpState::CLOSE;
+    }
+
+    /// Overload this if you really have to take control over how the response
+    /// is sent. Send up to bytes_left bytes through conn, return _exactly_ the
+    /// number of bytes written. To get it correct, you should just do
+    ///
+    ///     return conn->sendData(...)
+    virtual size_t sendResponseData(HttpServerConnection * /* conn */,
+                                    size_t /* bytes_left */) {
+        // Essentially, your overloaded code should do this:
+        // my_buffer = ...
+        // size_t sent = conn->sendData(my_buffer,
+        //                              std::min(bytes_left, sizeof my_buffer));
+        // return sent;
+        throw std::logic_error("sendResponseData not implemented");
+    }
+
+    virtual HttpState newPostRequest(HttpServerConnection *conn,
+                                     const std::string &uri);
+
+    /// \brief
+    /// Retrieve part of a post message from client.
+    ///
+    /// Return true to continue, false to close the connection.
+    virtual bool partialPostData(HttpServerConnection *conn,
+                                 const char *buffer, size_t len);
+
+    /// \brief
+    /// Retrieve last part of a post message from client.
+    virtual HttpState lastPostData(HttpServerConnection *conn,
+                                   const char *buffer, size_t len);
+
+    /// \brief
+    /// Request from client for a websocket upgrade.
+    ///
+    /// Return true to accept, false to close.
+    virtual bool newWsRequest(HttpServerConnection *conn,
+                              const std::string &uri);
+
+    /// If you want to send data immediately after a websocket connection
+    /// has been established (i.e. before the client has asked for
+    /// anything), call conn->notifyWsHandshake() in the newWsRequest method;
+    /// then the below method will be called after the handshake:
+    virtual void wsHandshakeFinished(HttpServerConnection *conn,
+                                     const std::string &uri);
+
+    /// Override this to implement a response to a preflight (OPTIONS) request.
+    virtual HttpState preflightRequest(HttpServerConnection * /* conn */,
+                                       const std::string & /* uri */) {
+        return HttpState::CLOSE;
+    }
+
+    void connAdded(SocketConnection *conn) override {
+        log() << "new connection id=" << conn->id();
+    }
+
+    void connRemoved(SocketConnection *conn) override {
+        log() << "dropped connection " << conn->id();
+    }
+
+    /// \brief
+    /// One or more HTTP response header lines that always should be sent.
+    ///
+    /// Terminate each line with \r\n.
+    void setFixedHeaders(const std::string &hdr) {
+        fixed_response_headers = "Server: " + server_name + "\r\n" + hdr;
+    }
+    SocketConnection *newClient(int fd, const char *ip, uint16_t port,
+                                ServerSocket *) final;
+
+    /// Return Access-Control-Allow-Origin header if the conn's current request
+    /// originates from domain (or a subdomain to it), otherwise return "".
+    static std::string corsHeader(HttpServerConnection *conn,
+                                  const std::string &domain);
+
+    std::string webRoot() const {
+        return webroot;
+    }
+
+    void setWebRoot(const std::string &path) {
+        webroot = path;
+    }
+
+#ifdef USE_GNUTLS
+    void newWorkerChannel(SocketReceiver *srv, unsigned int chan) override;
+#endif
+
+protected:
+    TaskConfig the_config;
+private:
+    std::string server_name, fixed_response_headers;
+    std::string webroot;
+};
diff --git a/src/http/websocketbridge.cpp b/src/http/websocketbridge.cpp
new file mode 100644
index 0000000..fda0659
--- /dev/null
+++ b/src/http/websocketbridge.cpp
@@ -0,0 +1,239 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <string>
+#include "../json11/json11.hpp"
+#include "websocketbridge.h"
+#include "../http/httpclientconnection.h"
+
+#if defined(__APPLE__)
+#include <CoreFoundation/CFBundle.h>
+#if !TARGET_OS_IPHONE
+#include <ApplicationServices/ApplicationServices.h>
+#endif
+#endif
+
+class WSBlistener : public WebServerTask {
+public:
+    WSBlistener(Task *bridge, const TaskConfig &cfg);
+
+    bool newWsRequest(HttpServerConnection *conn,
+                      const std::string &uri) override;
+
+    bool wsTextMessage(HttpConnection *conn,
+                       const std::string &msg) override;
+    void sendMsgToClient(const std::string &msg) {
+        dbg_log() << "Send to client: " << msg;
+        if (client)
+            client->sendWsMessage(msg);
+    }
+
+    void connAdded(SocketConnection *s) override;
+    void serverAdded(ServerSocket *s) override;
+    void connRemoved(SocketConnection *s) override;
+    void serverRemoved(ServerSocket *s) override;
+
+    uint16_t listenPort() const {
+        if (server)
+            return server->port();
+        return 0;
+    }
+
+#if !TARGET_OS_IPHONE
+    void run_browser(const std::string &url);
+#endif
+
+    void processFinished(int pid, int wstatus) override;
+
+    // Returns empty string unless ready:
+    std::string url() const {
+        return connect_url;
+    }
+
+    // Return true if client is connected:
+    bool clientConnected() const {
+        return client != nullptr;
+    }
+
+private:
+
+    void notify_url() {
+        std::cerr << "\nOPEN URL: " << connect_url << std::endl;
+    }
+    Task *parent;
+    int external_browser_pid = 0;
+    std::string connect_url;
+    HttpServerConnection *client = nullptr;
+    ServerSocket *server = nullptr;
+    TaskConfig config;
+};
+
+WebsocketBridge::WebsocketBridge(Task *agent, const TaskConfig &cfg) :
+    BridgeTask(agent),
+    listen_task(new WSBlistener(this, cfg)) {
+    killChildTaskWhenFinished();
+}
+
+WebsocketBridge::~WebsocketBridge() {
+}
+
+double WebsocketBridge::start() {
+    dbg_log() << "WebsocketBridge::start()";
+    double x = BridgeTask::start();
+    addNewTask(listen_task, this);
+    listen_port.store(listen_task->listenPort());
+    listen_task->startObserving(this);
+    dbg_log() << "Listening on port " << listen_port.load();
+    return x;
+}
+
+void WebsocketBridge::handleExecution(Task *sender, const std::string &msg) {
+    log() << "Got msg: " << msg;
+    if (sender == listen_task)
+        sendMsgToAgent(msg);
+}
+
+void WebsocketBridge::taskFinished(Task *task) {
+    if (task == listen_task) {
+        log() << "Listen task dead";
+        // We will not be able to talk to the client anymore.
+        listen_task = nullptr;
+        setResult("");
+    } else {
+        log() << "Agent task dead";
+        BridgeTask::taskFinished(task);
+    }
+}
+
+std::string WebsocketBridge::url() const {
+    if (!listen_task || !listen_port.load())
+        return std::string();
+    return listen_task->url();
+}
+
+std::string WebsocketBridge::port() const {
+    if (!listen_task || !listen_port.load())
+        return std::string();
+    return std::to_string(listen_port.load());
+}
+
+bool WebsocketBridge::clientConnected() const {
+    return (listen_task && listen_task->clientConnected());
+}
+
+WSBlistener::WSBlistener(Task *bridge, const TaskConfig &cfg) :
+    WebServerTask("WSB", "listen " + cfg.value("listen") +
+                  " " + cfg.value("listen_addr")),
+    parent(bridge),
+    config(cfg) {
+}
+
+void WebsocketBridge::sendMsgToClient(const std::string &msg) {
+    log() << "Send msg " << msg;
+    if (listen_task)
+        listen_task->sendMsgToClient(msg);
+}
+
+#if !TARGET_OS_IPHONE
+void WSBlistener::run_browser(const std::string &url) {
+#if defined(__APPLE__)
+    CFURLRef url2 = CFURLCreateWithBytes(nullptr, (UInt8 *)url.c_str(),
+                                         url.size(), kCFStringEncodingASCII,
+                                         nullptr);
+    LSOpenCFURLRef(url2, 0);
+    CFRelease(url2);
+#elif defined(_WIN32)
+    ShellExecuteA(NULL, "open", url.c_str(), NULL, NULL, SW_SHOWNORMAL);
+#else
+    const char *const argv[] = { "xdg-open", url.c_str(), nullptr };
+    external_browser_pid = runProcess(argv);
+#endif
+}
+#endif
+
+void WSBlistener::processFinished(int pid, int wstatus) {
+    log() << "Process " << pid << " finished, status: " << wstatus;
+    if (pid == external_browser_pid && wstatus)
+        notify_url();
+}
+
+bool WSBlistener::newWsRequest(HttpServerConnection *conn,
+                               const std::string &uri) {
+    if (client) {
+        log() << "error: already have a client";
+        return false;
+    }
+
+    if (uri != "/wsbridge") {
+        log() << "bad uri: " << uri;
+        return false;
+    }
+    if (config.value("listen_pw") != conn->getQueryVal("pwd")) {
+        log() << "bad password";
+        return false;
+    }
+
+    client = conn;
+
+    // Accept only one client:
+    if (server)
+        server->stopListening();
+
+    return true;
+}
+
+bool WSBlistener::wsTextMessage(HttpConnection *,
+                                const std::string &msg) {
+    log() << "Got msg " << msg;
+    executeHandler(parent, msg);
+    return true;
+}
+
+void WSBlistener::connAdded(SocketConnection *) {
+    log() << "WebsocketBridge client connected";
+}
+
+void WSBlistener::serverAdded(ServerSocket *socket) {
+    log() << "WebsocketBridge listening on port " << socket->port();
+    server = socket;
+    std::map<std::string, std::string> pars;
+    if (config.value("browser") == "3") {
+        connect_url = "http://webview.bredbandskollen.se/";
+        pars["bridge"] = "ws";
+        pars["wsport"] = std::to_string(socket->port());
+        pars["backend"] = "frontend-beta.bredbandskollen.se";
+        pars["env"] = "generic";
+        if (!config.value("listen_pw").empty())
+            pars["wspwd"] = config.value("listen_pw");
+    } else {
+        connect_url = config.value("url");
+        pars["bridge"] = "ws";
+        pars["port"] = std::to_string(socket->port());
+        if (socket->hostname() != "127.0.0.1")
+            pars["ip"] = socket->hostname();
+        if (!config.value("listen_pw").empty())
+            pars["pwd"] = config.value("listen_pw");
+    }
+    HttpClientConnection::addUrlPars(connect_url, pars);
+    log() << "Browser: " << connect_url;
+#if !TARGET_OS_IPHONE
+    if (config.value("browser") == "1") {
+        run_browser(connect_url);
+    } else if (config.value("browser") == "0") {
+        notify_url();
+    }
+#endif
+}
+
+void WSBlistener::connRemoved(SocketConnection *s) {
+    if (dynamic_cast<HttpServerConnection *>(s) == client) {
+        log() << "WebsocketBridge client disconnected";
+        client = nullptr;
+        setResult("");
+    }
+}
+
+void WSBlistener::serverRemoved(ServerSocket *socket) {
+    log() << "WebsocketBridge listening port closed: " << socket->port();
+    server = nullptr;
+}
diff --git a/src/http/websocketbridge.h b/src/http/websocketbridge.h
new file mode 100644
index 0000000..cb363bf
--- /dev/null
+++ b/src/http/websocketbridge.h
@@ -0,0 +1,65 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <deque>
+#include <atomic>
+
+#include "../framework/bridgetask.h"
+#include "../http/webservertask.h"
+#include "../framework/serversocket.h"
+
+class WSBlistener;
+
+// Open a web server, wait for one (and only one) client to open a websocket
+// connection to the server. The websocket connection will then be used to
+// pass text messages between the agent and the client.
+// The client must connect to the URL /wsbridge
+//
+// Config parameter - ValIT
+//
+//   listen - port number for the web server (0 to use a random port)
+//   listen_addr - IP number to listen on, e.g. 127.0.0.1 (or 0.0.0.0 for any)
+//   listen_pw - (optional) password; cilent must supply the password as value
+//               of URL parameter pwd when connecting to /wsbridge
+//   browser - (optional) value 0, 1, 2, or 3. If 0, write an URL to stderr;
+//             user may open the URL in a browser to load a web interface.
+//             If 1, an attempt to fire up the web interface in a new browser
+//             tab will be made. If that fails, write the URL to stderr.
+//             If 2, only generate the URL to the web interface. The client
+//             program must open the URL in a web view.
+//             If 3, generate the URL to the next generation web interface. The
+//             client program must open the URL in a web view. The web interface
+//             uses HTTPS, but must connect using an unencrypted web socket.
+//             Note that most webview components will refuse to do so.
+//   url - (optional) domain name to the server containing the legacy web
+//         interface; ignored if value of "browser" is "3".
+
+class WebsocketBridge : public BridgeTask {
+public:
+    WebsocketBridge(Task *agent, const TaskConfig &cfg);
+
+    virtual ~WebsocketBridge() override;
+
+    double start() override;
+
+    void sendMsgToClient(const std::string &msg) override;
+
+    void handleExecution(Task *sender, const std::string &msg) override;
+
+    void taskFinished(Task *task) override;
+
+    // Returns empty string unless ready. Thread safe.
+    std::string url() const;
+    std::string port() const;
+
+    // Return true if client is connected:
+    bool clientConnected() const;
+
+private:
+    WSBlistener *listen_task = nullptr;
+    std::atomic<uint16_t> listen_port;
+
+
+};
diff --git a/src/json11/CMakeLists.txt b/src/json11/CMakeLists.txt
new file mode 100644
index 0000000..ba8edd5
--- /dev/null
+++ b/src/json11/CMakeLists.txt
@@ -0,0 +1,21 @@
+project(json11)
+
+cmake_minimum_required(VERSION 2.8)
+
+enable_testing()
+
+add_definitions(
+    -std=c++11
+    -fno-rtti
+    -fno-exceptions
+    -Wall
+    -Wextra
+    -Werror)
+
+set(json11_SRCS json11.cpp)
+
+add_library(json11 STATIC ${json11_SRCS})
+
+add_test(json11_test json11_test)
+
+add_executable(json11_test ${json11_SRCS} test.cpp)
diff --git a/src/json11/LICENSE.txt b/src/json11/LICENSE.txt
new file mode 100644
index 0000000..691742e
--- /dev/null
+++ b/src/json11/LICENSE.txt
@@ -0,0 +1,19 @@
+Copyright (c) 2013 Dropbox, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/src/json11/Makefile b/src/json11/Makefile
new file mode 100644
index 0000000..5a6adc6
--- /dev/null
+++ b/src/json11/Makefile
@@ -0,0 +1,7 @@
+test: json11.cpp json11.hpp test.cpp
+	$(CXX) -O -std=c++11 json11.cpp test.cpp -o test -fno-rtti -fno-exceptions
+
+clean:
+	if [ -e test ]; then rm test; fi
+
+.PHONY: clean
diff --git a/src/json11/README.md b/src/json11/README.md
new file mode 100644
index 0000000..21f4e8b
--- /dev/null
+++ b/src/json11/README.md
@@ -0,0 +1,42 @@
+json11
+------
+
+json11 is a tiny JSON library for C++11, providing JSON parsing and serialization.
+
+The core object provided by the library is json11::Json. A Json object represents any JSON
+value: null, bool, number (int or double), string (std::string), array (std::vector), or
+object (std::map).
+
+Json objects act like values. They can be assigned, copied, moved, compared for equality or
+order, and so on. There are also helper methods Json::dump, to serialize a Json to a string, and
+Json::parse (static) to parse a std::string as a Json object.
+
+It's easy to make a JSON object with C++11's new initializer syntax:
+
+    Json my_json = Json::object {
+        { "key1", "value1" },
+        { "key2", false },
+        { "key3", Json::array { 1, 2, 3 } },
+    };
+    std::string json_str = my_json.dump();
+
+There are also implicit constructors that allow standard and user-defined types to be
+automatically converted to JSON. For example:
+
+    class Point {
+    public:
+        int x;
+        int y;
+        Point (int x, int y) : x(x), y(y) {}
+        Json to_json() const { return Json::array { x, y }; }
+    };
+
+    std::vector<Point> points = { { 1, 2 }, { 10, 20 }, { 100, 200 } };
+    std::string points_json = Json(points).dump();
+
+JSON values can have their values queried and inspected:
+
+    Json json = Json::array { Json::object { { "k", "v" } } };
+    std::string str = json[0]["k"].string_value();
+
+More documentation is still to come. For now, see json11.hpp.
diff --git a/src/json11/json11.cpp b/src/json11/json11.cpp
new file mode 100644
index 0000000..56ae4e8
--- /dev/null
+++ b/src/json11/json11.cpp
@@ -0,0 +1,808 @@
+/* Copyright (c) 2013 Dropbox, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// Modified by Göran Andersson <goran@init.se>
+
+#include "json11.hpp"
+#include <cassert>
+#include <cmath>
+#include <cstdlib>
+#include <cstdio>
+#include <sstream>
+#include <clocale>
+#include <limits>
+
+namespace json11 {
+
+static const int max_depth = 200;
+
+using std::string;
+using std::vector;
+using std::map;
+using std::make_shared;
+using std::initializer_list;
+using std::move;
+
+/* Helper for representing null - just a do-nothing struct, plus comparison
+ * operators so the helpers in JsonValue work. We can't use nullptr_t because
+ * it may not be orderable.
+ */
+struct NullStruct {
+    bool operator==(NullStruct) const { return true; }
+    bool operator<(NullStruct) const { return false; }
+};
+
+/* * * * * * * * * * * * * * * * * * * *
+ * Serialization
+ */
+
+static void dump(NullStruct, string &out) {
+    out += "null";
+}
+
+static void dump(double value, string &out) {
+    if (std::isfinite(value)) {
+        char buf[32];
+        snprintf(buf, sizeof buf, "%.17g", value);
+        out += buf;
+    } else {
+        out += "null";
+    }
+}
+
+static void dump(int value, string &out) {
+    char buf[32];
+    snprintf(buf, sizeof buf, "%d", value);
+    out += buf;
+}
+
+static void dump(bool value, string &out) {
+    out += value ? "true" : "false";
+}
+
+static void dump(const string &value, string &out) {
+    out += '"';
+    for (size_t i = 0; i < value.length(); i++) {
+        const char ch = value[i];
+        if (ch == '\\') {
+            out += "\\\\";
+        } else if (ch == '"') {
+            out += "\\\"";
+        } else if (ch == '\b') {
+            out += "\\b";
+        } else if (ch == '\f') {
+            out += "\\f";
+        } else if (ch == '\n') {
+            out += "\\n";
+        } else if (ch == '\r') {
+            out += "\\r";
+        } else if (ch == '\t') {
+            out += "\\t";
+        } else if (static_cast<uint8_t>(ch) <= 0x1f) {
+            char buf[8];
+            snprintf(buf, sizeof buf, "\\u%04x", ch);
+            out += buf;
+        } else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i+1]) == 0x80
+                   && static_cast<uint8_t>(value[i+2]) == 0xa8) {
+            out += "\\u2028";
+            i += 2;
+        } else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i+1]) == 0x80
+                   && static_cast<uint8_t>(value[i+2]) == 0xa9) {
+            out += "\\u2029";
+            i += 2;
+        } else {
+            out += ch;
+        }
+    }
+    out += '"';
+}
+
+static void dump(const Json::array &values, string &out) {
+    bool first = true;
+    out += "[";
+    for (const auto &value : values) {
+        if (!first)
+            out += ", ";
+        value.dump(out);
+        first = false;
+    }
+    out += "]";
+}
+
+static void dump(const Json::object &values, string &out) {
+    bool first = true;
+    out += "{";
+    for (const auto &kv : values) {
+        if (!first)
+            out += ", ";
+        dump(kv.first, out);
+        out += ": ";
+        kv.second.dump(out);
+        first = false;
+    }
+    out += "}";
+}
+
+void Json::dump(string &out) const {
+    m_ptr->dump(out);
+}
+
+/* * * * * * * * * * * * * * * * * * * *
+ * Value wrappers
+ */
+
+template <Json::Type tag, typename T>
+class Value : public JsonValue {
+protected:
+
+    // Constructors
+    explicit Value(const T &value) : m_value(value) {}
+    explicit Value(T &&value)      : m_value(move(value)) {}
+
+    // Get type tag
+    Json::Type type() const override {
+        return tag;
+    }
+
+    // Comparisons
+    bool equals(const JsonValue * other) const override {
+        return m_value == static_cast<const Value<tag, T> *>(other)->m_value;
+    }
+    bool less(const JsonValue * other) const override {
+        return m_value < static_cast<const Value<tag, T> *>(other)->m_value;
+    }
+
+    const T m_value;
+    void dump(string &out) const override { json11::dump(m_value, out); }
+};
+
+class JsonDouble final : public Value<Json::NUMBER, double> {
+    double number_value() const override;
+    int int_value() const override { return static_cast<int>(m_value); }
+    bool equals(const JsonValue * other) const override { return m_value == other->number_value(); }
+    bool less(const JsonValue * other)   const override { return m_value <  other->number_value(); }
+public:
+    explicit JsonDouble(double value) : Value(value) {}
+};
+
+double JsonDouble::number_value() const { return m_value; }
+
+class JsonInt final : public Value<Json::NUMBER, int> {
+    double number_value() const override;
+    int int_value() const override { return m_value; }
+    bool equals(const JsonValue * other) const override { return m_value == other->number_value(); }
+    bool less(const JsonValue * other)   const override { return m_value <  other->number_value(); }
+public:
+    explicit JsonInt(int value) : Value(value) {}
+};
+
+double JsonInt::number_value() const { return m_value; }
+
+class JsonBoolean final : public Value<Json::BOOL, bool> {
+    bool bool_value() const override;
+public:
+    explicit JsonBoolean(bool value) : Value(value) {}
+};
+
+bool JsonBoolean::bool_value() const { return m_value; }
+
+class JsonString final : public Value<Json::STRING, string> {
+    const string &string_value() const override;
+public:
+    explicit JsonString(const string &value) : Value(value) {}
+    explicit JsonString(string &&value)      : Value(move(value)) {}
+};
+
+const string &JsonString::string_value() const { return m_value; }
+
+
+class JsonArray final : public Value<Json::ARRAY, Json::array> {
+    const Json::array &array_items() const override { return m_value; }
+    const Json & operator[](size_t i) const override;
+public:
+    explicit JsonArray(const Json::array &value) : Value(value) {}
+    explicit JsonArray(Json::array &&value)      : Value(move(value)) {}
+};
+
+class JsonObject final : public Value<Json::OBJECT, Json::object> {
+    const Json::object &object_items() const override { return m_value; }
+    const Json & operator[](const string &key) const override;
+public:
+    explicit JsonObject(const Json::object &value) : Value(value) {}
+    explicit JsonObject(Json::object &&value)      : Value(move(value)) {}
+};
+
+class JsonNull final : public Value<Json::NUL, NullStruct> {
+public:
+    JsonNull() : Value({}) {}
+    ~JsonNull() override;
+};
+
+JsonNull::~JsonNull() {}
+
+/* * * * * * * * * * * * * * * * * * * *
+ * Static globals - static-init-safe
+ */
+struct Statics {
+    const std::shared_ptr<JsonValue> null = make_shared<JsonNull>();
+    const std::shared_ptr<JsonValue> t = make_shared<JsonBoolean>(true);
+    const std::shared_ptr<JsonValue> f = make_shared<JsonBoolean>(false);
+    const string empty_string;
+    const vector<Json> empty_vector;
+    const map<string, Json> empty_map;
+    Statics() {}
+};
+
+static const Statics & statics() {
+    static const Statics s {};
+    return s;
+}
+
+static const Json & static_null() {
+    // This has to be separate, not in Statics, because Json() accesses statics().null.
+    static const Json json_null;
+    return json_null;
+}
+
+/* * * * * * * * * * * * * * * * * * * *
+ * Constructors
+ */
+
+Json::Json() noexcept                  : m_ptr(statics().null) {}
+Json::Json(std::nullptr_t) noexcept    : m_ptr(statics().null) {}
+Json::Json(double value)               : m_ptr(make_shared<JsonDouble>(value)) {}
+Json::Json(int value)                  : m_ptr(make_shared<JsonInt>(value)) {}
+Json::Json(bool value)                 : m_ptr(value ? statics().t : statics().f) {}
+Json::Json(const string &value)        : m_ptr(make_shared<JsonString>(value)) {}
+Json::Json(string &&value)             : m_ptr(make_shared<JsonString>(move(value))) {}
+Json::Json(const char * value)         : m_ptr(make_shared<JsonString>(value)) {}
+Json::Json(const Json::array &values)  : m_ptr(make_shared<JsonArray>(values)) {}
+Json::Json(Json::array &&values)       : m_ptr(make_shared<JsonArray>(move(values))) {}
+Json::Json(const Json::object &values) : m_ptr(make_shared<JsonObject>(values)) {}
+Json::Json(Json::object &&values)      : m_ptr(make_shared<JsonObject>(move(values))) {}
+
+/* * * * * * * * * * * * * * * * * * * *
+ * Accessors
+ */
+
+Json::Type Json::type()                           const { return m_ptr->type();         }
+double Json::number_value()                       const { return m_ptr->number_value(); }
+int Json::int_value()                             const { return m_ptr->int_value();    }
+bool Json::bool_value()                           const { return m_ptr->bool_value();   }
+const string & Json::string_value()               const { return m_ptr->string_value(); }
+const vector<Json> & Json::array_items()          const { return m_ptr->array_items();  }
+const map<string, Json> & Json::object_items()    const { return m_ptr->object_items(); }
+const Json & Json::operator[] (size_t i)          const { return (*m_ptr)[i];           }
+const Json & Json::operator[] (const string &key) const { return (*m_ptr)[key];         }
+
+double                    JsonValue::number_value()              const { return 0; }
+int                       JsonValue::int_value()                 const { return 0; }
+bool                      JsonValue::bool_value()                const { return false; }
+const string &            JsonValue::string_value()              const { return statics().empty_string; }
+const vector<Json> &      JsonValue::array_items()               const { return statics().empty_vector; }
+const map<string, Json> & JsonValue::object_items()              const { return statics().empty_map; }
+const Json &              JsonValue::operator[] (size_t)         const { return static_null(); }
+const Json &              JsonValue::operator[] (const string &) const { return static_null(); }
+
+const Json & JsonObject::operator[] (const string &key) const {
+    auto iter = m_value.find(key);
+    return (iter == m_value.end()) ? static_null() : iter->second;
+}
+const Json & JsonArray::operator[] (size_t i) const {
+    if (i >= m_value.size()) return static_null();
+    else return m_value[i];
+}
+
+/* * * * * * * * * * * * * * * * * * * *
+ * Comparison
+ */
+
+bool Json::operator== (const Json &other) const {
+    if (m_ptr == other.m_ptr)
+        return true;
+    if (m_ptr->type() != other.m_ptr->type())
+        return false;
+
+    return m_ptr->equals(other.m_ptr.get());
+}
+
+bool Json::operator< (const Json &other) const {
+    if (m_ptr == other.m_ptr)
+        return false;
+    if (m_ptr->type() != other.m_ptr->type())
+        return m_ptr->type() < other.m_ptr->type();
+
+    return m_ptr->less(other.m_ptr.get());
+}
+
+/* * * * * * * * * * * * * * * * * * * *
+ * Parsing
+ */
+
+/* esc(c)
+ *
+ * Format char c suitable for printing in an error message.
+ */
+static inline string esc(char c) {
+    char buf[12];
+    if (static_cast<uint8_t>(c) >= 0x20 && static_cast<uint8_t>(c) <= 0x7f) {
+        snprintf(buf, sizeof buf, "'%c' (%d)", c, c);
+    } else {
+        snprintf(buf, sizeof buf, "(%d)", c);
+    }
+    return string(buf);
+}
+
+static inline bool in_range(long x, long lower, long upper) {
+    return (x >= lower && x <= upper);
+}
+
+namespace {
+/* JsonParser
+ *
+ * Object that tracks all state of an in-progress parse.
+ */
+struct JsonParser final {
+
+    /* State
+     */
+    const string &str;
+    size_t i;
+    string &err;
+    bool failed;
+    const JsonParse strategy;
+
+    /* fail(msg, err_ret = Json())
+     *
+     * Mark this parse as failed.
+     */
+    Json fail(string &&msg) {
+        return fail(move(msg), Json());
+    }
+
+    template <typename T>
+    T fail(string &&msg, const T err_ret) {
+        if (!failed)
+            err = std::move(msg);
+        failed = true;
+        return err_ret;
+    }
+
+    /* consume_whitespace()
+     *
+     * Advance until the current character is non-whitespace.
+     */
+    void consume_whitespace() {
+        while (str[i] == ' ' || str[i] == '\r' || str[i] == '\n' || str[i] == '\t')
+            i++;
+    }
+
+    /* consume_comment()
+     *
+     * Advance comments (c-style inline and multiline).
+     */
+    bool consume_comment() {
+      bool comment_found = false;
+      if (str[i] == '/') {
+        i++;
+        if (i == str.size())
+          return fail("unexpected end of input after start of comment", false);
+        if (str[i] == '/') { // inline comment
+          i++;
+          // advance until next line, or end of input
+          while (i < str.size() && str[i] != '\n') {
+            i++;
+          }
+          comment_found = true;
+        }
+        else if (str[i] == '*') { // multiline comment
+          i++;
+          if (i > str.size()-2)
+            return fail("unexpected end of input inside multi-line comment", false);
+          // advance until closing tokens
+          while (!(str[i] == '*' && str[i+1] == '/')) {
+            i++;
+            if (i > str.size()-2)
+              return fail(
+                "unexpected end of input inside multi-line comment", false);
+          }
+          i += 2;
+          comment_found = true;
+        }
+        else
+          return fail("malformed comment", false);
+      }
+      return comment_found;
+    }
+
+    /* consume_garbage()
+     *
+     * Advance until the current character is non-whitespace and non-comment.
+     */
+    void consume_garbage() {
+      consume_whitespace();
+      if(strategy == JsonParse::COMMENTS) {
+        bool comment_found = false;
+        do {
+          comment_found = consume_comment();
+          if (failed) return;
+          consume_whitespace();
+        }
+        while(comment_found);
+      }
+    }
+
+    /* get_next_token()
+     *
+     * Return the next non-whitespace character. If the end of the input is reached,
+     * flag an error and return 0.
+     */
+    char get_next_token() {
+        consume_garbage();
+        if (failed) return static_cast<char>(0);
+        if (i == str.size())
+            return fail("unexpected end of input", static_cast<char>(0));
+
+        return str[i++];
+    }
+
+    /* encode_utf8(pt, out)
+     *
+     * Encode pt as UTF-8 and add it to out.
+     */
+    void encode_utf8(long pt, string & out) {
+        if (pt < 0)
+            return;
+
+        if (pt < 0x80) {
+            out += static_cast<char>(pt);
+        } else if (pt < 0x800) {
+            out += static_cast<char>((pt >> 6) | 0xC0);
+            out += static_cast<char>((pt & 0x3F) | 0x80);
+        } else if (pt < 0x10000) {
+            out += static_cast<char>((pt >> 12) | 0xE0);
+            out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
+            out += static_cast<char>((pt & 0x3F) | 0x80);
+        } else {
+            out += static_cast<char>((pt >> 18) | 0xF0);
+            out += static_cast<char>(((pt >> 12) & 0x3F) | 0x80);
+            out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
+            out += static_cast<char>((pt & 0x3F) | 0x80);
+        }
+    }
+
+    /* parse_string()
+     *
+     * Parse a string, starting at the current position.
+     */
+    string parse_string() {
+        string out;
+        long last_escaped_codepoint = -1;
+        while (true) {
+            if (i == str.size())
+                return fail("unexpected end of input in string", "");
+
+            char ch = str[i++];
+
+            if (ch == '"') {
+                encode_utf8(last_escaped_codepoint, out);
+                return out;
+            }
+
+            if (in_range(ch, 0, 0x1f))
+                return fail("unescaped " + esc(ch) + " in string", "");
+
+            // The usual case: non-escaped characters
+            if (ch != '\\') {
+                encode_utf8(last_escaped_codepoint, out);
+                last_escaped_codepoint = -1;
+                out += ch;
+                continue;
+            }
+
+            // Handle escapes
+            if (i == str.size())
+                return fail("unexpected end of input in string", "");
+
+            ch = str[i++];
+
+            if (ch == 'u') {
+                // Extract 4-byte escape sequence
+                string esc = str.substr(i, 4);
+                // Explicitly check length of the substring. The following loop
+                // relies on std::string returning the terminating NUL when
+                // accessing str[length]. Checking here reduces brittleness.
+                if (esc.length() < 4) {
+                    return fail("bad \\u escape: " + esc, "");
+                }
+                for (size_t j = 0; j < 4; j++) {
+                    if (!in_range(esc[j], 'a', 'f') && !in_range(esc[j], 'A', 'F')
+                            && !in_range(esc[j], '0', '9'))
+                        return fail("bad \\u escape: " + esc, "");
+                }
+
+                long codepoint = strtol(esc.data(), nullptr, 16);
+
+                // JSON specifies that characters outside the BMP shall be encoded as a pair
+                // of 4-hex-digit \u escapes encoding their surrogate pair components. Check
+                // whether we're in the middle of such a beast: the previous codepoint was an
+                // escaped lead (high) surrogate, and this is a trail (low) surrogate.
+                if (in_range(last_escaped_codepoint, 0xD800, 0xDBFF)
+                        && in_range(codepoint, 0xDC00, 0xDFFF)) {
+                    // Reassemble the two surrogate pairs into one astral-plane character, per
+                    // the UTF-16 algorithm.
+                    encode_utf8((((last_escaped_codepoint - 0xD800) << 10)
+                                 | (codepoint - 0xDC00)) + 0x10000, out);
+                    last_escaped_codepoint = -1;
+                } else {
+                    encode_utf8(last_escaped_codepoint, out);
+                    last_escaped_codepoint = codepoint;
+                }
+
+                i += 4;
+                continue;
+            }
+
+            encode_utf8(last_escaped_codepoint, out);
+            last_escaped_codepoint = -1;
+
+            if (ch == 'b') {
+                out += '\b';
+            } else if (ch == 'f') {
+                out += '\f';
+            } else if (ch == 'n') {
+                out += '\n';
+            } else if (ch == 'r') {
+                out += '\r';
+            } else if (ch == 't') {
+                out += '\t';
+            } else if (ch == '"' || ch == '\\' || ch == '/') {
+                out += ch;
+            } else {
+                return fail("invalid escape character " + esc(ch), "");
+            }
+        }
+    }
+
+    /* parse_number()
+     *
+     * Parse a double.
+     */
+    Json parse_number() {
+        size_t start_pos = i;
+
+        if (str[i] == '-')
+            i++;
+
+        // Integer part
+        if (str[i] == '0') {
+            i++;
+            if (in_range(str[i], '0', '9'))
+                return fail("leading 0s not permitted in numbers");
+        } else if (in_range(str[i], '1', '9')) {
+            i++;
+            while (in_range(str[i], '0', '9'))
+                i++;
+        } else {
+            return fail("invalid " + esc(str[i]) + " in number");
+        }
+
+        if (str[i] != '.' && str[i] != 'e' && str[i] != 'E'
+                && (i - start_pos) <= static_cast<size_t>(std::numeric_limits<int>::digits10)) {
+            return std::atoi(str.c_str() + start_pos);
+        }
+
+        // Decimal part
+        if (str[i] == '.') {
+            i++;
+            if (!in_range(str[i], '0', '9'))
+                return fail("at least one digit required in fractional part");
+
+            while (in_range(str[i], '0', '9'))
+                i++;
+        }
+
+        // Exponent part
+        if (str[i] == 'e' || str[i] == 'E') {
+            i++;
+
+            if (str[i] == '+' || str[i] == '-')
+                i++;
+
+            if (!in_range(str[i], '0', '9'))
+                return fail("at least one digit required in exponent");
+
+            while (in_range(str[i], '0', '9'))
+                i++;
+        }
+
+        std::istringstream s(str.substr(start_pos, i-start_pos));
+        s.imbue(std::locale("C"));
+        double res;
+        s >> res;
+        return res;
+    }
+
+    /* expect(str, res)
+     *
+     * Expect that 'str' starts at the character that was just read. If it does, advance
+     * the input and return res. If not, flag an error.
+     */
+    Json expect(const string &expected, Json res) {
+        assert(i != 0);
+        i--;
+        if (str.compare(i, expected.length(), expected) == 0) {
+            i += expected.length();
+            return res;
+        } else {
+            return fail("parse error: expected " + expected + ", got " + str.substr(i, expected.length()));
+        }
+    }
+
+    /* parse_json()
+     *
+     * Parse a JSON object.
+     */
+    Json parse_json(int depth) {
+        if (depth > max_depth) {
+            return fail("exceeded maximum nesting depth");
+        }
+
+        char ch = get_next_token();
+        if (failed)
+            return Json();
+
+        if (ch == '-' || (ch >= '0' && ch <= '9')) {
+            i--;
+            return parse_number();
+        }
+
+        if (ch == 't')
+            return expect("true", true);
+
+        if (ch == 'f')
+            return expect("false", false);
+
+        if (ch == 'n')
+            return expect("null", Json());
+
+        if (ch == '"')
+            return parse_string();
+
+        if (ch == '{') {
+            map<string, Json> data;
+            ch = get_next_token();
+            if (ch == '}')
+                return data;
+
+            while (1) {
+                if (ch != '"')
+                    return fail("expected '\"' in object, got " + esc(ch));
+
+                string key = parse_string();
+                if (failed)
+                    return Json();
+
+                ch = get_next_token();
+                if (ch != ':')
+                    return fail("expected ':' in object, got " + esc(ch));
+
+                data[std::move(key)] = parse_json(depth + 1);
+                if (failed)
+                    return Json();
+
+                ch = get_next_token();
+                if (ch == '}')
+                    break;
+                if (ch != ',')
+                    return fail("expected ',' in object, got " + esc(ch));
+
+                ch = get_next_token();
+            }
+            return data;
+        }
+
+        if (ch == '[') {
+            vector<Json> data;
+            ch = get_next_token();
+            if (ch == ']')
+                return data;
+
+            while (1) {
+                i--;
+                data.push_back(parse_json(depth + 1));
+                if (failed)
+                    return Json();
+
+                ch = get_next_token();
+                if (ch == ']')
+                    break;
+                if (ch != ',')
+                    return fail("expected ',' in list, got " + esc(ch));
+
+                ch = get_next_token();
+                (void)ch;
+            }
+            return data;
+        }
+
+        return fail("expected value, got " + esc(ch));
+    }
+};
+}//namespace {
+
+Json Json::parse(const string &in, string &err, JsonParse strategy) {
+    JsonParser parser { in, 0, err, false, strategy };
+    Json result = parser.parse_json(0);
+
+    // Check for any trailing garbage
+    parser.consume_garbage();
+    if (parser.failed)
+        return Json();
+    if (parser.i != in.size())
+        return parser.fail("unexpected trailing " + esc(in[parser.i]));
+
+    return result;
+}
+
+// Documented in json11.hpp
+vector<Json> Json::parse_multi(const string &in,
+                               std::string::size_type &parser_stop_pos,
+                               string &err,
+                               JsonParse strategy) {
+    JsonParser parser { in, 0, err, false, strategy };
+    parser_stop_pos = 0;
+    vector<Json> json_vec;
+    while (parser.i != in.size() && !parser.failed) {
+        json_vec.push_back(parser.parse_json(0));
+        if (parser.failed)
+            break;
+
+        // Check for another object
+        parser.consume_garbage();
+        if (parser.failed)
+            break;
+        parser_stop_pos = parser.i;
+    }
+    return json_vec;
+}
+
+/* * * * * * * * * * * * * * * * * * * *
+ * Shape-checking
+ */
+
+bool Json::has_shape(const shape & types, string & err) const {
+    if (!is_object()) {
+        err = "expected JSON object, got " + dump();
+        return false;
+    }
+
+    for (auto & item : types) {
+        if ((*this)[item.first].type() != item.second) {
+            err = "bad type for " + item.first + " in " + dump();
+            return false;
+        }
+    }
+
+    return true;
+}
+
+} // namespace json11
diff --git a/src/json11/json11.hpp b/src/json11/json11.hpp
new file mode 100644
index 0000000..0c47d05
--- /dev/null
+++ b/src/json11/json11.hpp
@@ -0,0 +1,232 @@
+/* json11
+ *
+ * json11 is a tiny JSON library for C++11, providing JSON parsing and serialization.
+ *
+ * The core object provided by the library is json11::Json. A Json object represents any JSON
+ * value: null, bool, number (int or double), string (std::string), array (std::vector), or
+ * object (std::map).
+ *
+ * Json objects act like values: they can be assigned, copied, moved, compared for equality or
+ * order, etc. There are also helper methods Json::dump, to serialize a Json to a string, and
+ * Json::parse (static) to parse a std::string as a Json object.
+ *
+ * Internally, the various types of Json object are represented by the JsonValue class
+ * hierarchy.
+ *
+ * A note on numbers - JSON specifies the syntax of number formatting but not its semantics,
+ * so some JSON implementations distinguish between integers and floating-point numbers, while
+ * some don't. In json11, we choose the latter. Because some JSON implementations (namely
+ * Javascript itself) treat all numbers as the same type, distinguishing the two leads
+ * to JSON that will be *silently* changed by a round-trip through those implementations.
+ * Dangerous! To avoid that risk, json11 stores all numbers as double internally, but also
+ * provides integer helpers.
+ *
+ * Fortunately, double-precision IEEE754 ('double') can precisely store any integer in the
+ * range +/-2^53, which includes every 'int' on most systems. (Timestamps often use int64
+ * or long long to avoid the Y2038K problem; a double storing microseconds since some epoch
+ * will be exact for +/- 275 years.)
+ */
+
+/* Copyright (c) 2013 Dropbox, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+#include <initializer_list>
+
+#ifdef _MSC_VER
+    #if _MSC_VER <= 1800 // VS 2013
+        #ifndef noexcept
+            #define noexcept throw()
+        #endif
+
+        #ifndef snprintf
+            #define snprintf _snprintf_s
+        #endif
+    #endif
+#endif
+
+namespace json11 {
+
+enum JsonParse {
+    STANDARD, COMMENTS
+};
+
+class JsonValue;
+
+class Json final {
+public:
+    // Types
+    enum Type {
+        NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT
+    };
+
+    // Array and object typedefs
+    typedef std::vector<Json> array;
+    typedef std::map<std::string, Json> object;
+
+    // Constructors for the various types of JSON value.
+    Json() noexcept;                // NUL
+    Json(std::nullptr_t) noexcept;  // NUL
+    Json(double value);             // NUMBER
+    Json(int value);                // NUMBER
+    Json(bool value);               // BOOL
+    Json(const std::string &value); // STRING
+    Json(std::string &&value);      // STRING
+    Json(const char * value);       // STRING
+    Json(const array &values);      // ARRAY
+    Json(array &&values);           // ARRAY
+    Json(const object &values);     // OBJECT
+    Json(object &&values);          // OBJECT
+
+    // Implicit constructor: anything with a to_json() function.
+    template <class T, class = decltype(&T::to_json)>
+    Json(const T & t) : Json(t.to_json()) {}
+
+    // Implicit constructor: map-like objects (std::map, std::unordered_map, etc)
+    template <class M, typename std::enable_if<
+        std::is_constructible<std::string, decltype(std::declval<M>().begin()->first)>::value
+        && std::is_constructible<Json, decltype(std::declval<M>().begin()->second)>::value,
+            int>::type = 0>
+    Json(const M & m) : Json(object(m.begin(), m.end())) {}
+
+    // Implicit constructor: vector-like objects (std::list, std::vector, std::set, etc)
+    template <class V, typename std::enable_if<
+        std::is_constructible<Json, decltype(*std::declval<V>().begin())>::value,
+            int>::type = 0>
+    Json(const V & v) : Json(array(v.begin(), v.end())) {}
+
+    // This prevents Json(some_pointer) from accidentally producing a bool. Use
+    // Json(bool(some_pointer)) if that behavior is desired.
+    Json(void *) = delete;
+
+    // Accessors
+    Type type() const;
+
+    bool is_null()   const { return type() == NUL; }
+    bool is_number() const { return type() == NUMBER; }
+    bool is_bool()   const { return type() == BOOL; }
+    bool is_string() const { return type() == STRING; }
+    bool is_array()  const { return type() == ARRAY; }
+    bool is_object() const { return type() == OBJECT; }
+
+    // Return the enclosed value if this is a number, 0 otherwise. Note that json11 does not
+    // distinguish between integer and non-integer numbers - number_value() and int_value()
+    // can both be applied to a NUMBER-typed object.
+    double number_value() const;
+    int int_value() const;
+
+    // Return the enclosed value if this is a boolean, false otherwise.
+    bool bool_value() const;
+    // Return the enclosed string if this is a string, "" otherwise.
+    const std::string &string_value() const;
+    // Return the enclosed std::vector if this is an array, or an empty vector otherwise.
+    const array &array_items() const;
+    // Return the enclosed std::map if this is an object, or an empty map otherwise.
+    const object &object_items() const;
+
+    // Return a reference to arr[i] if this is an array, Json() otherwise.
+    const Json & operator[](size_t i) const;
+    // Return a reference to obj[key] if this is an object, Json() otherwise.
+    const Json & operator[](const std::string &key) const;
+
+    // Serialize.
+    void dump(std::string &out) const;
+    std::string dump() const {
+        std::string out;
+        dump(out);
+        return out;
+    }
+
+    // Parse. If parse fails, return Json() and assign an error message to err.
+    static Json parse(const std::string & in,
+                      std::string & err,
+                      JsonParse strategy = JsonParse::STANDARD);
+    static Json parse(const char * in,
+                      std::string & err,
+                      JsonParse strategy = JsonParse::STANDARD) {
+        if (in) {
+            return parse(std::string(in), err, strategy);
+        } else {
+            err = "null input";
+            return nullptr;
+        }
+    }
+    // Parse multiple objects, concatenated or separated by whitespace
+    static std::vector<Json> parse_multi(
+        const std::string & in,
+        std::string::size_type & parser_stop_pos,
+        std::string & err,
+        JsonParse strategy = JsonParse::STANDARD);
+
+    static inline std::vector<Json> parse_multi(
+        const std::string & in,
+        std::string & err,
+        JsonParse strategy = JsonParse::STANDARD) {
+        std::string::size_type parser_stop_pos;
+        return parse_multi(in, parser_stop_pos, err, strategy);
+    }
+
+    bool operator== (const Json &rhs) const;
+    bool operator<  (const Json &rhs) const;
+    bool operator!= (const Json &rhs) const { return !(*this == rhs); }
+    bool operator<= (const Json &rhs) const { return !(rhs < *this); }
+    bool operator>  (const Json &rhs) const { return  (rhs < *this); }
+    bool operator>= (const Json &rhs) const { return !(*this < rhs); }
+
+    /* has_shape(types, err)
+     *
+     * Return true if this is a JSON object and, for each item in types, has a field of
+     * the given type. If not, return false and set err to a descriptive message.
+     */
+    typedef std::initializer_list<std::pair<std::string, Type>> shape;
+    bool has_shape(const shape & types, std::string & err) const;
+
+private:
+    std::shared_ptr<JsonValue> m_ptr;
+};
+
+// Internal class hierarchy - JsonValue objects are not exposed to users of this API.
+class JsonValue {
+protected:
+    friend class Json;
+    friend class JsonInt;
+    friend class JsonDouble;
+    virtual Json::Type type() const = 0;
+    virtual bool equals(const JsonValue * other) const = 0;
+    virtual bool less(const JsonValue * other) const = 0;
+    virtual void dump(std::string &out) const = 0;
+    virtual double number_value() const;
+    virtual int int_value() const;
+    virtual bool bool_value() const;
+    virtual const std::string &string_value() const;
+    virtual const Json::array &array_items() const;
+    virtual const Json &operator[](size_t i) const;
+    virtual const Json::object &object_items() const;
+    virtual const Json &operator[](const std::string &key) const;
+    virtual ~JsonValue() {}
+};
+
+} // namespace json11
diff --git a/src/json11/test.cpp b/src/json11/test.cpp
new file mode 100644
index 0000000..bd60705
--- /dev/null
+++ b/src/json11/test.cpp
@@ -0,0 +1,205 @@
+#include <string>
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include "json11.hpp"
+#include <cassert>
+#include <list>
+#include <set>
+#include <unordered_map>
+
+using namespace json11;
+using std::string;
+
+// Check that Json has the properties we want.
+#include <type_traits>
+#define CHECK_TRAIT(x) static_assert(std::x::value, #x)
+CHECK_TRAIT(is_nothrow_constructible<Json>);
+CHECK_TRAIT(is_nothrow_default_constructible<Json>);
+CHECK_TRAIT(is_copy_constructible<Json>);
+CHECK_TRAIT(is_nothrow_move_constructible<Json>);
+CHECK_TRAIT(is_copy_assignable<Json>);
+CHECK_TRAIT(is_nothrow_move_assignable<Json>);
+CHECK_TRAIT(is_nothrow_destructible<Json>);
+
+void parse_from_stdin() {
+    string buf;
+    string line;
+    while (std::getline(std::cin, line)) {
+        buf += line + "\n";
+    }
+
+    string err;
+    auto json = Json::parse(buf, err);
+    if (!err.empty()) {
+        printf("Failed: %s\n", err.c_str());
+    } else {
+        printf("Result: %s\n", json.dump().c_str());
+    }
+}
+
+int main(int argc, char **argv) {
+    if (argc == 2 && argv[1] == string("--stdin")) {
+        parse_from_stdin();
+        return 0;
+    }
+
+    const string simple_test =
+        R"({"k1":"v1", "k2":42, "k3":["a",123,true,false,null]})";
+
+    string err;
+    auto json = Json::parse(simple_test, err);
+
+    std::cout << "k1: " << json["k1"].string_value() << "\n";
+    std::cout << "k3: " << json["k3"].dump() << "\n";
+
+    for (auto &k : json["k3"].array_items()) {
+        std::cout << "    - " << k.dump() << "\n";
+    }
+
+    const string comment_test = R"({
+      // comment /* with nested comment */
+      "a": 1,
+      // comment
+      // continued
+      "b": "text",
+      /* multi
+         line
+         comment */
+      // and single-line comment
+      "c": [1, 2, 3]
+    })";
+
+    string err_comment;
+    auto json_comment = Json::parse(
+      comment_test, err_comment, JsonParse::COMMENTS);
+    if (!err_comment.empty()) {
+        printf("Failed: %s\n", err_comment.c_str());
+    } else {
+        printf("Result: %s\n", json_comment.dump().c_str());
+    }
+
+    string failing_comment_test = R"({
+      /* bad comment
+      "a": 1,
+    })";
+
+    string err_failing_comment;
+    auto json_failing_comment = Json::parse(
+      failing_comment_test, err_failing_comment, JsonParse::COMMENTS);
+    if (!err_failing_comment.empty()) {
+        printf("Failed: %s\n", err_failing_comment.c_str());
+    } else {
+        printf("Result: %s\n", json_failing_comment.dump().c_str());
+    }
+
+    failing_comment_test = R"({
+      / / bad comment })";
+
+    json_failing_comment = Json::parse(
+      failing_comment_test, err_failing_comment, JsonParse::COMMENTS);
+    if (!err_failing_comment.empty()) {
+        printf("Failed: %s\n", err_failing_comment.c_str());
+    } else {
+        printf("Result: %s\n", json_failing_comment.dump().c_str());
+    }
+
+    failing_comment_test = R"({// bad comment })";
+
+    json_failing_comment = Json::parse(
+      failing_comment_test, err_failing_comment, JsonParse::COMMENTS);
+    if (!err_failing_comment.empty()) {
+        printf("Failed: %s\n", err_failing_comment.c_str());
+    } else {
+        printf("Result: %s\n", json_failing_comment.dump().c_str());
+    }
+
+    failing_comment_test = R"({
+          "a": 1
+        }/)";
+
+    json_failing_comment = Json::parse(
+      failing_comment_test, err_failing_comment, JsonParse::COMMENTS);
+    if (!err_failing_comment.empty()) {
+        printf("Failed: %s\n", err_failing_comment.c_str());
+    } else {
+        printf("Result: %s\n", json_failing_comment.dump().c_str());
+    }
+
+    failing_comment_test = R"({/* bad
+                                  comment *})";
+
+    json_failing_comment = Json::parse(
+      failing_comment_test, err_failing_comment, JsonParse::COMMENTS);
+    if (!err_failing_comment.empty()) {
+        printf("Failed: %s\n", err_failing_comment.c_str());
+    } else {
+        printf("Result: %s\n", json_failing_comment.dump().c_str());
+    }
+
+    std::list<int> l1 { 1, 2, 3 };
+    std::vector<int> l2 { 1, 2, 3 };
+    std::set<int> l3 { 1, 2, 3 };
+    assert(Json(l1) == Json(l2));
+    assert(Json(l2) == Json(l3));
+
+    std::map<string, string> m1 { { "k1", "v1" }, { "k2", "v2" } };
+    std::unordered_map<string, string> m2 { { "k1", "v1" }, { "k2", "v2" } };
+    assert(Json(m1) == Json(m2));
+
+    // Json literals
+    Json obj = Json::object({
+        { "k1", "v1" },
+        { "k2", 42.0 },
+        { "k3", Json::array({ "a", 123.0, true, false, nullptr }) },
+    });
+
+    std::cout << "obj: " << obj.dump() << "\n";
+
+    assert(Json("a").number_value() == 0);
+    assert(Json("a").string_value() == "a");
+    assert(Json().number_value() == 0);
+
+    assert(obj == json);
+    assert(Json(42) == Json(42.0));
+    assert(Json(42) != Json(42.1));
+
+    const string unicode_escape_test =
+        R"([ "blah\ud83d\udca9blah\ud83dblah\udca9blah\u0000blah\u1234" ])";
+
+    const char utf8[] = "blah" "\xf0\x9f\x92\xa9" "blah" "\xed\xa0\xbd" "blah"
+                        "\xed\xb2\xa9" "blah" "\0" "blah" "\xe1\x88\xb4";
+
+    Json uni = Json::parse(unicode_escape_test, err);
+    assert(uni[0].string_value().size() == (sizeof utf8) - 1);
+    assert(std::memcmp(uni[0].string_value().data(), utf8, sizeof utf8) == 0);
+
+    // Demonstrates the behavior change in Xcode 7 / Clang 3.7 described
+    // here: https://llvm.org/bugs/show_bug.cgi?id=23812
+    Json nested_array = Json::array { Json::array { 1, 2, 3 } };
+    assert(nested_array.is_array());
+    assert(nested_array.array_items().size() == 1);
+    assert(nested_array.array_items()[0].is_array());
+    assert(nested_array.array_items()[0].array_items().size() == 3);
+
+    Json my_json = Json::object {
+        { "key1", "value1" },
+        { "key2", false },
+        { "key3", Json::array { 1, 2, 3 } },
+    };
+    std::string json_str = my_json.dump();
+    printf("%s\n", json_str.c_str());
+
+    class Point {
+    public:
+        int x;
+        int y;
+        Point (int x, int y) : x(x), y(y) {}
+        Json to_json() const { return Json::array { x, y }; }
+    };
+
+    std::vector<Point> points = { { 1, 2 }, { 10, 20 }, { 100, 200 } };
+    std::string points_json = Json(points).dump();
+    printf("%s\n", points_json.c_str());
+}
diff --git a/src/measurement/defs.cpp b/src/measurement/defs.cpp
new file mode 100644
index 0000000..fdbe36d
--- /dev/null
+++ b/src/measurement/defs.cpp
@@ -0,0 +1,237 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#ifdef __APPLE__
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#import <Foundation/Foundation.h>
+#endif
+#ifndef _WIN32
+#include <unistd.h>
+#else
+#include <intrin.h>
+#endif
+
+#include <cstdio>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <fstream>
+
+#include "defs.h"
+#include "../http/httpclientconnection.h"
+
+namespace {
+
+#ifdef __APPLE__
+#elif defined(NO_EXTERNAL_CMD)
+    std::string get_shell_value(std::string filename, std::string key) {
+        std::ifstream file(filename);
+        if (file) {
+            key += "=";
+            std::string line;
+            while (std::getline(file, line)) {
+                if (line.find(key) == 0) {
+                    std::string value = line.substr(key.size());
+                    if (value.size() > 1 && value[0] == '"' &&
+                        value[value.size() - 1] == '"') {
+                        return value.substr(1, value.size() - 2);
+                    }
+                    return value;
+                }
+            }
+        }
+        return std::string();
+    }
+
+    std::string get_os_identifier() {
+        std::string os_name = get_shell_value("/etc/os-release", "NAME");
+        if (!os_name.empty()) {
+            std::string os_version = get_shell_value("/etc/os-release", "VERSION");
+            if (!os_version.empty()) {
+                os_name += " " + os_version;
+            }
+        }
+        return os_name;
+    }
+
+    std::string get_arch_identifier() {
+#if defined(__aarch64__)
+        return "aarch64";
+#elif defined(__arm__) || defined(_M_ARM)
+        return "arm";
+#elif defined(__amd64__) || defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64)
+        return "x86_64";
+#elif defined(__i386) || defined(_M_IX86) || defined(__X86__) || defined(_X86_)
+        return "i386";
+#elif defined(mips) || defined(__mips__) || defined(__mips)
+        return "mips";
+#elif defined(__PPC64__) || defined(__ppc64__) || defined(_ARCH_PPC64)
+        return "powerpc64"
+#elif defined(__powerpc) || defined(__powerpc__) || defined(__powerpc64__) || defined(__POWERPC__) || defined(__ppc__) || defined(__PPC__) || defined(_ARCH_PPC)
+        return "powerpc";
+#else
+        return std::string();
+#endif
+    }
+#else
+    std::string external_cmd(const char *cmd) {
+        char buffer[200];
+        std::string result;
+#ifdef _WIN32
+        std::shared_ptr<FILE> pipe(_popen(cmd, "r"), _pclose);
+#else
+        std::shared_ptr<FILE> pipe(popen(cmd, "r"), pclose);
+#endif
+        if (pipe) {
+            while (!feof(pipe.get()))
+                if (fgets(buffer, sizeof buffer, pipe.get()) != nullptr)
+                    result += buffer;
+            auto pos = result.find_last_not_of(" \t\r\n");
+            if (pos != std::string::npos)
+                result.resize(pos+1);
+        }
+        return result;
+    }
+#endif
+
+    std::string app_name() {
+
+        std::string appName = "Bredbandskollen";
+
+#ifdef _WIN32
+        appName += " Windows";
+#elif defined(__ANDROID__)
+        appName += " Android";
+#elif defined(__APPLE__)
+        appName += " Mac";
+#elif defined(__FreeBSD__)
+        appName += " FreeBSD";
+#elif defined(__NetBSD__)
+        appName += " NetBSD";
+#elif defined(__OpenBSD__)
+        appName += " OpenBSD";
+#elif defined(__bsdi__)
+        appName += " BSDi";
+#elif defined(__DragonFly__)
+        appName += " DragonFly";
+#else
+        appName += " Linux";
+#endif
+
+#ifdef __arm__
+        return appName + " ARM";
+#elif defined(_M_ARM)
+        return appName + " ARM";
+#elif defined(__aarch64__)
+        return appName + " ARM64";
+#elif defined(__i386)
+        return appName + " i386";
+#elif defined(_M_IX86)
+        return appName + " i386";
+#elif defined(__X86__)
+        return appName + " i386";
+#elif defined(_X86_)
+        return appName + " i386";
+#elif defined(__amd64__)
+        return appName + " amd64";
+#elif defined(__x86_64__)
+        return appName + " amd64";
+#elif defined(_M_X64)
+        return appName + " amd64";
+#elif defined(_M_AMD64)
+        return appName + " amd64";
+#elif defined(__mips__)
+        return appName + " mips";
+#elif defined(__mips)
+        return appName + " mips";
+#else
+        return appName;
+#endif
+    }
+
+    std::string getHWModel() {
+#ifdef __APPLE__
+        size_t size;
+        char array[1000];
+        sysctlbyname("hw.model", NULL, &size, NULL, 0);
+        sysctlbyname("hw.model", &array, &size, NULL, 0);
+        return array;
+#elif defined(_WIN32)
+        // Get extended ids.
+        int CPUInfo[4] = { -1 };
+        __cpuid(CPUInfo, 0x80000000);
+        unsigned int nExIds = CPUInfo[0];
+
+        // Get the information associated with each extended ID.
+        char CPUBrandString[0x40] = { 0 };
+        for (unsigned int i = 0x80000000; i <= nExIds; ++i) {
+            __cpuid(CPUInfo, i);
+            // Interpret CPU brand string and cache information.
+            if (i == 0x80000002)
+                memcpy(CPUBrandString, CPUInfo, sizeof(CPUInfo));          // "Intel(R) Core(TM)"
+            else if (i == 0x80000003)
+                memcpy(CPUBrandString + 16, CPUInfo, sizeof(CPUInfo));     // "i7-4710HQ CPU"
+            else if (i == 0x80000004)
+                memcpy(CPUBrandString + 32, CPUInfo, sizeof(CPUInfo));     // "@ 2.50GHz"
+        }
+        return CPUBrandString;
+#elif defined(NO_EXTERNAL_CMD)
+        return get_arch_identifier();
+#else
+        return external_cmd("uname -m").substr(0, 50);
+#endif
+    }
+
+    std::string getOSInfo() {
+        std::string osInfo = "";
+#ifdef _WIN32
+        osInfo = "Windows ";
+
+        NTSTATUS(WINAPI *RtlGetVersion)(LPOSVERSIONINFOEXW);
+        OSVERSIONINFOEXW osVerInfo;
+
+        *(FARPROC*)&RtlGetVersion = GetProcAddress(GetModuleHandleA("ntdll"), "RtlGetVersion");
+
+        if (NULL != RtlGetVersion) {
+            osVerInfo.dwOSVersionInfoSize = sizeof(osVerInfo);
+            RtlGetVersion(&osVerInfo);
+            osInfo += std::to_string(osVerInfo.dwMajorVersion) + "." + std::to_string(osVerInfo.dwMinorVersion);
+            if (osVerInfo.szCSDVersion[0] != 0) {
+                osInfo += " ";
+                int i = 0;
+                while (osVerInfo.szCSDVersion[i] != 0) {
+                    osInfo += osVerInfo.szCSDVersion[i];
+                    i++;
+                }
+            }
+            if (osVerInfo.wSuiteMask | VER_SUITE_PERSONAL) {
+                osInfo += " Home";
+            }
+            osInfo += " (Build " + std::to_string(osVerInfo.dwBuildNumber) + ")";
+        }
+        else {
+            osInfo += "unknown";
+        }
+
+#elif defined(__APPLE__)
+        osInfo = [[[NSProcessInfo processInfo] operatingSystemVersionString] UTF8String];
+
+#elif defined(NO_EXTERNAL_CMD)
+        osInfo = get_os_identifier();
+
+#else
+        osInfo = external_cmd("uname -sr").substr(0, 50);
+#endif
+        return osInfo;
+    }
+}
+
+const std::string measurement::appName = app_name();
+#if defined(__ANDROID__)
+const std::string measurement::hw_info = "Android Device";
+const std::string measurement::os_version = "Android OS";
+#else
+const std::string measurement::hw_info = getHWModel();
+const std::string measurement::os_version = getOSInfo();
+#endif
diff --git a/src/measurement/defs.h b/src/measurement/defs.h
new file mode 100644
index 0000000..5b28216
--- /dev/null
+++ b/src/measurement/defs.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <string>
+
+namespace measurement {
+    extern const std::string appName;
+    const std::string appVersion = "1.2.2";
+    // buildVersion 15 released to App Store in 2016.
+    const unsigned int buildVersion = 16;
+    extern const std::string hw_info;
+    extern const std::string os_version;
+}
diff --git a/src/measurement/downloadtask.cpp b/src/measurement/downloadtask.cpp
new file mode 100644
index 0000000..5f84c2d
--- /dev/null
+++ b/src/measurement/downloadtask.cpp
@@ -0,0 +1,68 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "downloadtask.h"
+
+DownloadTask::DownloadTask(const std::string &ticket, const HttpHost &server,
+                           unsigned int no_conn, unsigned int max_conn,
+                           double duration, double max_time, double tick_s) :
+    ProgressTask("download", ticket, server, no_conn, max_conn, duration, max_time),
+    tick_duration_s(tick_s>0 ? tick_s : 0.1) {
+    dynamic_conn_limit = 0.5 * duration + 0.5;
+}
+
+double DownloadTask::start() {
+    log() << "DownloadTask starting";
+    notifyStarted();
+    checkConnectionCount();
+    return tick_duration_s;
+}
+
+double DownloadTask::timerEvent() {
+    double time = elapsed();
+
+    if (time >= timeout_s()) {
+        log() << "DownloadTask timeout after " << time << " seconds";
+        setResult("-1");
+        return 0;
+    }
+
+    if (time > 0.05) {
+        // log() << "Check: " << byteCount() << " and " << threadRecvCount();
+        double speed = addOverheadMbps(threadRecvCount(), time);
+        if (time < dynamic_conn_limit && speed >= 50.0) {
+            unsigned int no_conn = (speed < 250.0) ?
+                ((speed < 100) ? 12 : 24) :
+                ((speed < 500) ? 32 : 48);
+            if (no_conn < currentNoConnections())
+                no_conn = currentNoConnections();
+            doTestProgress(speed, time, no_conn);
+            setNoConnections(no_conn);
+        } else {
+            doTestProgress(speed, time, currentNoConnections());
+        }
+    }
+    return tick_duration_s;
+}
+
+void DownloadTask::newRequest(HttpClientConnection *conn) {
+    if (size_t size = loadSize()) {
+        conn->get("/bigfile.bin?t=" + t() + "&len=" + std::to_string(size));
+    } else if (soonFinished()) {
+        // Delete the Connection object but let socket go to keep-alive cache.
+    } else {
+        // Keep the connection but don't make a new request at this point.
+        // Perhaps due to a speed limit.
+        conn->pass();
+    }
+}
+
+bool DownloadTask::headerComplete(HttpClientConnection *conn) {
+    conn->doStreamResponse();
+    notifyBytesLoaded(conn->rawHttpHeader().size());
+    return true;
+}
+
+void DownloadTask::payload(HttpClientConnection *, char *, size_t len) {
+    notifyBytesLoaded(len);
+}
diff --git a/src/measurement/downloadtask.h b/src/measurement/downloadtask.h
new file mode 100644
index 0000000..11b637c
--- /dev/null
+++ b/src/measurement/downloadtask.h
@@ -0,0 +1,22 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include "progresstask.h"
+
+class DownloadTask : public ProgressTask {
+public:
+    DownloadTask(const std::string &ticket, const HttpHost &server,
+                 unsigned int no_conn = 10, unsigned int max_conn = 100,
+                 double duration = 10.0, double max_time = 25.0,
+                 double tick_s = 0.1);
+    double start() override;
+    double timerEvent() override;
+    void newRequest(HttpClientConnection *) override;
+    bool headerComplete(HttpClientConnection *) override;
+    void payload(HttpClientConnection *, char *, size_t len) override;
+private:
+    double tick_duration_s;
+    double dynamic_conn_limit;
+};
diff --git a/src/measurement/infotask.cpp b/src/measurement/infotask.cpp
new file mode 100644
index 0000000..5cdbaa4
--- /dev/null
+++ b/src/measurement/infotask.cpp
@@ -0,0 +1,45 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "infotask.h"
+
+void InfoTask::newRequest(HttpClientConnection *conn) {
+    conn->ws_get("/minfo?t=" + t() + "&key=" + key);
+}
+
+bool InfoTask::wsTextMessage(HttpConnection *,
+                             const std::string &msg) {
+    log() << "MEASUREMENT INFO: " << msg;
+    setMessage(msg);
+    return true;
+}
+
+double InfoTask::timerEvent() {
+    double time = elapsed();
+    log() << "IT TimerEvent " << elapsed();
+    if (time >= timeout_s()) {
+        log() << "InfoTask timeout after " << time << " seconds";
+        setResult("");
+        return 0;
+    }
+
+    if (upload_deadline > 0.0) {
+        log() << "waiting for server upload, t=" << time << ", max="
+              << upload_deadline;
+        if (time >= upload_deadline) {
+            setMessage("server upload timeout");
+            upload_deadline = -1.0;
+        }
+        return 0.1;
+    } else if (info_deadline > 0.0) {
+        log() << "waiting for measurement info, t=" << time << ", max="
+              << info_deadline;
+        if (time >= info_deadline) {
+            setResult("");
+            info_deadline = -1.0;
+        }
+        return 0.1;
+    }
+
+    return 1.0;
+}
diff --git a/src/measurement/infotask.h b/src/measurement/infotask.h
new file mode 100644
index 0000000..419ab2a
--- /dev/null
+++ b/src/measurement/infotask.h
@@ -0,0 +1,46 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include "measurementtask.h"
+
+class InfoTask : public MeasurementTask {
+public:
+    InfoTask(const std::string &label, const std::string &ticket_string,
+             const std::string &hash_key, const HttpHost &server,
+             unsigned int no_conn = 1, unsigned int max_conn = 3,
+             double duration = 300.0) :
+        MeasurementTask(label, ticket_string, server,
+                        no_conn, max_conn, duration),
+        key(hash_key)
+    {
+    }
+    void newRequest(HttpClientConnection *) override;
+    bool requestComplete(HttpClientConnection *) override {
+        return false;
+    }
+    bool wsTextMessage(HttpConnection *,
+                       const std::string &msg) override;
+    double timerEvent() override;
+
+    // Stop waiting for upload result after at most t seconds:
+    void setUploadDeadline(double t) {
+        if (t > 0.0)
+            upload_deadline = elapsed() + t;
+        else
+            upload_deadline = t;
+    }
+
+    // Stop waiting for measurement ID after at most t seconds:
+    void setInfoDeadline(double t) {
+        if (t > 0.0)
+            info_deadline = elapsed() + t;
+        else
+            info_deadline = t;
+    }
+private:
+    std::string key;
+    double upload_deadline = -1.0;
+    double info_deadline = -1.0;
+};
diff --git a/src/measurement/latencytask.cpp b/src/measurement/latencytask.cpp
new file mode 100644
index 0000000..8ee08b6
--- /dev/null
+++ b/src/measurement/latencytask.cpp
@@ -0,0 +1,34 @@
+#include <algorithm>
+#include "../json11/json11.hpp"
+#include "latencytask.h"
+
+LatencyTask::LatencyTask(const std::string &ticket, const HttpHost &server) :
+    MeasurementTask("httplatency", ticket, server, 1, 15) {
+}
+
+void LatencyTask::newRequest(HttpClientConnection *conn) {
+    std::string lbl = std::to_string(++serial_no);
+    current_request[lbl + " ok"] = timeNow();
+    conn->get("/pingpong/" + lbl + "?t=" + t());
+}
+
+bool LatencyTask::requestComplete(HttpClientConnection *conn) {
+    auto p = current_request.find(conn->contents());
+    if (p == current_request.end()) {
+        log() << "unexpected response: " << conn->contents();
+    } else {
+        double latency = secondsSince(p->second);
+        log() << "got " << conn->contents() << " after " << latency << " sec";
+        samples.push_back(latency);
+    }
+
+    if (samples.size() < 12)
+        return true;
+
+    if (!terminated()) {
+        log() << "Samples: " << json11::Json(samples).dump();
+        setResult(calculateLatency(samples));
+    }
+
+    return false;
+}
diff --git a/src/measurement/latencytask.h b/src/measurement/latencytask.h
new file mode 100644
index 0000000..2c87e82
--- /dev/null
+++ b/src/measurement/latencytask.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <vector>
+#include "measurementtask.h"
+
+class LatencyTask : public MeasurementTask {
+public:
+    LatencyTask(const std::string &ticket, const HttpHost &server);
+    void newRequest(HttpClientConnection *) override;
+    bool requestComplete(HttpClientConnection *conn) override;
+private:
+    std::vector<double> samples;
+    // Maps expected response to start time of request:
+    std::map<std::string, TimePoint> current_request;
+    unsigned int serial_no = static_cast<unsigned int>(rand());
+};
diff --git a/src/measurement/measurementagent.cpp b/src/measurement/measurementagent.cpp
new file mode 100644
index 0000000..8e57b0e
--- /dev/null
+++ b/src/measurement/measurementagent.cpp
@@ -0,0 +1,604 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <clocale>
+#include <sstream>
+#include <iomanip>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <sstream>
+
+#include "speedtest.h"
+
+#include "defs.h"
+#include "singlerequesttask.h"
+#include "../http/singlerequest.h"
+#include "pingsweeptask.h"
+#include "measurementagent.h"
+
+MeasurementAgent::MeasurementAgent(const TaskConfig &config,
+                                   const HttpHost &webserver) :
+    Task("MeasurementAgent"),
+    wserv(webserver) {
+
+    killChildTaskWhenFinished();
+
+    key_store = wserv.cmgr ? wserv.cmgr : new CookieManager();
+
+    // Default values; could be changed by the client app (gui):
+    report_template["appname"] = measurement::appName;
+    report_template["appver"] = measurement::appVersion;
+    report_template["dlength"] = "10";
+    report_template["ulength"] = "10";
+
+    options_filename = config.value("options_file");
+    if (!options_filename.empty()) {
+        // Load preexisting configuration options
+        cfgOptions = cfgOptions.loadJsonFromFile(options_filename);
+        //if (cfgOptions.hasKey("Client.hashkey"))
+        //    handleConfigurationOption("Client.hashkey",
+        //                              cfgOptions.value("Client.hashkey"));
+    }
+
+    for (auto p : config.cfg())
+        handleConfigurationOption(p.first, p.second);
+}
+
+void MeasurementAgent::taskMessage(Task *task) {
+    // std::string name = task->label(), message = task->message();
+    if (PingSweepTask *ptask = dynamic_cast<PingSweepTask *>(task)) {
+        while (true) {
+            std::string res = ptask->getResult();
+            if (res.empty())
+                break;
+            sendToClient("setInfo", MeasurementTask::
+                         json_obj("approxLatency", res));
+        }
+    }
+}
+
+void MeasurementAgent::taskFinished(Task *task) {
+    std::string name = task->label(),
+        result = task->result();
+
+    if (task->wasKilled())
+        log() << "Task " << name << " killed";
+    else
+        log() << "Task " << name << " finished, result: " << result;
+
+    if (task == bridge) {
+        bridge = nullptr;
+        state = MeasurementState::ABORTED;
+        setResult("");
+        return;
+    }
+
+    if (task == current_test) {
+        current_test = nullptr;
+        state = MeasurementState::FINISHED;
+        sendTaskComplete("global");
+        return;
+    }
+
+    if (task->wasKilled() || !bridge || state == MeasurementState::ABORTED)
+        return;
+
+    if (name == "msettings") {
+        // Check that the result is valid JSON:
+        std::string err;
+        auto obj = json11::Json::parse(result, err);
+        if (result.empty() || !err.empty()) {
+            settings_result = getDefaultConfig();
+        } else {
+            if (result[result.size()-1] == '}') {
+                std::string newkey = obj["hashkey"].string_value();
+                std::string hashkey = !force_key.empty() ? force_key :
+                    key_store->getCookieVal("hash_key", wserv.hostname);
+                if (newkey == hashkey) {
+                    // Nothing changed.
+                } else if (isValidHashkey(hashkey)) {
+                    // We already had a key. Try to insert it into settings.
+                    if (newkey.empty()) {
+                        result.resize(result.size()-1);
+                        ((result += ",\"hashkey\":\"") += hashkey) += "\"}";
+                    } else {
+                        auto pos = result.find('"' + newkey + '"');
+                        if (pos != std::string::npos)
+                            result.replace(pos+1, newkey.size(), hashkey);
+                    }
+                } else if (isValidHashkey(newkey)) {
+                    // We had no valid key. Save the one we got.
+                    std::string domain = wserv.hostname;
+                    if (domain.size() >= 18 && domain.substr(domain.size() - 18)
+                        == "bredbandskollen.se")
+                        domain = ".bredbandskollen.se";
+                    std::string line = "hash_key=" + newkey +
+                        "; max-age=999999999; domain=" + domain;
+                    key_store->setCookie(line, wserv.hostname, "/");
+                    log() << "SET COOKIE " << line;
+                }
+            }
+            settings_result = result;
+            if (!obj["x_bbk"].string_value().empty())
+                report_template["x_bbk"] = obj["x_bbk"].string_value();
+        }
+        sendToClient("configuration", settings_result);
+        key_store->save();
+    } else if (name == "contents") {
+        sendToClient("setInfo", "{\"contents\": " +
+                                result + "}");
+    } else if (name == "pingsweep") {
+        log() << "Best server: " << result;
+        sendToClient("setInfo", "{\"bestServer\": \"" + result + "\"}");
+    } else if (name == "list_measurements") {
+        sendToClient("measurementList", result);
+    } else if (name == "checkHost") {
+        if (HttpClientTask *t = dynamic_cast<HttpClientTask *>(task)) {
+            sendToClient("hostCheck", MeasurementTask::
+                json_obj(t->serverHost(), result.empty() ? "" : "1"));
+            log() << "checkHost: " << result;
+        }
+    } else if (name == "measurementStart") {
+        std::string err;
+        auto obj = json11::Json::parse(result, err);
+
+        if (err.empty()) {
+            sendToClient("setInfo", result);
+            log() << "measurementStart: " << result;
+        } else {
+            sendToClient("setInfo", "{}");
+            warn_log() << "invalid measurementStart: " << result;
+        }
+    } else if (name == "setSubscription") {
+        log() << "setSubscription done";
+    } else if (name == "sendLogToServer") {
+        std::string err;
+        auto obj = json11::Json::parse(result, err);
+        std::string res = "NOK";
+        if (err.empty() && obj["status"].number_value() != 0)
+            res = "OK";
+        sendToClient("setInfo", "{\"logSent\": \"" +
+                     res + "\"}");
+    } else {
+        log() << "unknown task, ignoring";
+    }
+
+}
+
+void MeasurementAgent::pollBridge(const std::string &msg) {
+    if (msg.empty())
+        return;
+    std::string err;
+    auto obj = json11::Json::parse(msg, err);
+    if (!err.empty()) {
+        err_log() << "JSON error, ignoring message: " << msg;
+        return;
+    }
+    std::string method = obj["method"].string_value();
+    const json11::Json &args = obj["args"];
+    handleMsgFromClient(method, args);
+}
+
+void MeasurementAgent::sendTaskComplete(const std::string &t,
+                                        const std::string &res) {
+    if (!bridge)
+        return;
+    std::string args = "{\"task\": \"" + t + "\"";
+    if (!res.empty())
+        args += ", \"result\": " + res;
+    sendToClient("taskComplete", args + "}");
+}
+
+bool MeasurementAgent::isValidHashkey(const std::string &key) {
+    if (key.size() >= 12 && key.size() <= 40 && std::string::npos ==
+        key.find_first_not_of("0123456789ABCDEFabcdef-"))
+        return true;
+    return false;
+}
+
+void  MeasurementAgent::sendLogToServer() {
+    std::string url = "/api/devlog";
+    addNewTask(new SingleRequest("sendLogToServer", "frontend-beta.bredbandskollen.se",
+                                 url, accumulated_log.str(), 10.0), this);
+    setLogLimit();
+    log() << "Sent " << accumulated_log.str().size() << " bytes.";
+    accumulated_log.str("");
+}
+
+std::string MeasurementAgent::getDefaultConfig() {
+    // Either the client doesn't want settings to be fetched
+    // (wserv.hostname is "none"), or we failed to fetch settings.
+    // If the client has supplied a measurement server, or if the domain is
+    // bredbandskollen.se, we can create a valid config.
+
+    std::string mserver4 = mserv.hostname, mserver6 = mserv.hostname,
+        domain = wserv.hostname;
+    if (domain == "none") {
+        domain = mserv.hostname;
+    } else if (domain.size() >= 18 && domain.substr(domain.size() - 18)
+               == "bredbandskollen.se" && mserver4.empty()) {
+        // Perhaps a client dns failure.
+        mserver4 = "192.36.30.2";
+        mserver6 = "2001:67c:2ff4::2";
+    }
+    std::string hashkey = !force_key.empty() ? force_key :
+        key_store->getCookieVal("hash_key", domain);
+    if (hashkey.empty()) {
+        hashkey = createHashKey();
+        key_store->setCookie("hash_key="+hashkey+"; max-age=999999999",
+                             domain, "/");
+    }
+
+    if (mserver4.empty()) {
+        json11::Json settings = json11::Json::object {
+            { "ispname", "" },
+            { "hashkey", hashkey }
+        };
+        return settings.dump();
+    }
+
+    json11::Json settings = json11::Json::object {
+        { "servers", json11::Json::array {
+                json11::Json::object {
+                    { "url", mserver4 },
+                    { "name", mserver4 },
+                    { "type", "ipv4" }
+                },
+                json11::Json::object {
+                    { "url", mserver6 },
+                    { "name", mserver6 },
+                    { "type", "ipv6" }
+                }
+            }
+        },
+        { "ispname", "" },
+        { "hashkey", hashkey }
+    };
+    return settings.dump();
+}
+
+void MeasurementAgent::handleMsgFromClient(const std::string &method,
+                                           const json11::Json &args) {
+    log() << "handleMsgFromClient " << method;
+    if (method == "clientReady") {
+        std::string savedConfig;
+        savedConfig =  json11::Json(cfgOptions).dump();
+        sendToClient("agentReady", savedConfig);
+    } else if (method == "getConfiguration") {
+        dbg_log() << "Webserver: " << wserv.hostname;
+        if (wserv.hostname == "none") {
+            settings_result = getDefaultConfig();
+            sendToClient("configuration", settings_result);
+        } else {
+            std::map<std::string, std::string> attrs;
+            std::string hashkey = !force_key.empty() ? force_key :
+                key_store->getCookieVal("hash_key", wserv.hostname);
+#ifdef USE_GNUTLS
+            if (mserv.is_tls)
+                attrs["ssl"] = "1";
+#endif
+            if (isValidHashkey(hashkey))
+                attrs["key"] = hashkey; // attrs["nokey"] = "";
+            if (!args["consent"].string_value().empty())
+                attrs["consent"] = args["consent"].string_value();
+            std::string url = wserv_settingsurl;
+            HttpClientConnection::addUrlPars(url, attrs);
+            log() << wserv.hostname << ':' << wserv.port
+                  << " " << url;
+            addNewTask(new SingleRequestTask(url, "msettings",
+                                             "", wserv), this);
+        }
+    } else if (method == "getContent") {
+        std::map<std::string, std::string> attrs;
+        for (auto p : args.object_items())
+            if (!p.second.string_value().empty())
+                attrs[p.first] = p.second.string_value();
+        std::string url = wserv_contentsurl;
+        HttpClientConnection::addUrlPars(url, attrs);
+        addNewTask(new SingleRequestTask(url, "contents",
+                                         "", wserv), this);
+    } else if (method == "setConfigurationOption") {
+        for (auto p : args.object_items())
+            handleConfigurationOption(p.first, p.second.string_value());
+
+    } else if (method =="saveConfigurationOption") {
+        for (auto p : args.object_items()) {
+            auto key = p.first, value = p.second.string_value();
+            if (key == "Client.hashkey") {
+                std::string url = wserv_settingsurl;
+
+                if (value.empty()) {
+                    key_store->eraseCookies(wserv.hostname);
+                    key_store->eraseCookies("bredbandskollen.se");
+                    key_store->save();
+                    addNewTask(new SingleRequestTask(url, "msettings",
+                                                     "", wserv), this);
+                    //value = createHashKey();
+                } else if (isValidHashkey(value)) {
+                    key_store->setCookie("hash_key="+value+"; max-age=999999999"
+                                         "; path=/; domain=.bredbandskollen.se",
+                                         "bredbandskollen.se", "/");
+                    if (key_store->save())
+                        err_log() << "cannot save cookies";
+                    else
+                        cfgOptions.erase(key);
+
+                    std::map<std::string, std::string> attrs;
+                    attrs["key"] = value;
+                    HttpClientConnection::addUrlPars(url, attrs);
+                    addNewTask(new SingleRequestTask(url, "msettings",
+                                                     "", wserv), this);
+                } else {
+                    err_log() << "invalid Client.hashkey: " << value;
+                    sendToClient("setInfo", MeasurementTask::
+                                 json_obj("keyRejected", value));
+
+                }
+                //handleConfigurationOption(key, value);
+            }
+            if (value.empty()) {
+                cfgOptions.erase(key);
+            } else {
+                cfgOptions.set(key, value);
+            }
+        }
+        if (!options_filename.empty()) {
+            if (!cfgOptions.saveJsonToFile(options_filename))
+                sendToClient("setInfo", MeasurementTask::json_obj("error",
+                                        "cannot save configuration options"));
+        }
+    } else if (method == "saveReport") {
+        if (current_test)
+            current_test->doSaveReport(args);
+    } else if (method == "checkHost") {
+        std::string hostname = args["server"].string_value();
+        HttpHost tmpServer(wserv);
+        tmpServer.hostname = hostname;
+        addNewTask(new SingleRequestTask("/pingsweep/check", "checkHost",
+                                         "", tmpServer), this);
+    } else if (method == "startTest") {
+        log() << "Args: " << args.dump();
+        if (state == MeasurementState::IDLE) {
+            std::string mserver = args["serverUrl"].string_value();
+            std::string key = args["userKey"].string_value();
+#ifdef USE_GNUTLS
+            mserv.is_tls = static_cast<bool>(args["tls"].int_value());
+            mserv.port = mserv.is_tls ? 443 : 80;
+#else
+            mserv.port = 80;
+#endif
+            if (args.object_items().find("serverPort") !=
+                args.object_items().end()) {
+                int p = args["serverPort"].int_value();
+                if (p && p > 0 && p < 65536) {
+                    mserv.port = static_cast<uint16_t>(p);
+                    log() << "measurement server port number " << p;
+                } else
+                    err_log() << "invalid port number, will use default";
+            }
+            if (mserver.empty() || !isValidHashkey(key)) {
+                json11::Json obj = json11::Json::object {
+                    { "error",
+                      "startTest requires parameters serverUrl and userKey" },
+                    { "errno", "X01" }
+                };
+                sendToClient("setInfo", obj.dump());
+                state = MeasurementState::FINISHED;
+                sendTaskComplete("global");
+                return;
+            }
+            log() << "got measurement server " << mserver;
+            mserv.hostname = mserver;
+            report_template["host"] = wserv.hostname;
+            report_template["key"] = key;
+            current_test = new SpeedTest(this, mserv, report_template);
+            state = MeasurementState::STARTED;
+            addNewTask(current_test, this);
+        } else {
+            err_log() << "Must do resetTest before starting a new test";
+        }
+    } else if (method == "abortTest") {
+        if (state == MeasurementState::STARTED) {
+            if (current_test) {
+                state = MeasurementState::ABORTED;
+                abortTask(current_test);
+            } else {
+                state = MeasurementState::FINISHED;
+            }
+        } else {
+            err_log("got abortTest when not in measurement");
+        }
+    } else if (method == "resetTest") {
+        switch (state) {
+        case MeasurementState::FINISHED:
+            state = MeasurementState::IDLE;
+            sendToClient("agentReady");
+            mserv.hostname.clear();
+            current_ticket.clear();
+            break;
+        case MeasurementState::IDLE:
+            break;
+        case MeasurementState::ABORTED:
+        case MeasurementState::STARTED:
+            err_log("got resetTest during measurement");
+            json11::Json obj = json11::Json::object {
+                { "error", "got resetTest during measurement" },
+                { "errno", "X02" }
+            };
+            sendToClient("setInfo", obj.dump());
+            break;
+        }
+    } else if (method == "setSubscription") {
+        if (current_ticket.empty()) {
+            err_log() << "cannot set subscription: latest measurement missing";
+            return;
+        }
+        std::string id = args["speedId"].string_value();
+        if (id.empty()) {
+            long n = args["speedId"].int_value();
+            if (n <= 0) {
+                err_log() << "cannot set subscription: no speedId";
+                return;
+            }
+            id = std::to_string(n);
+        }
+        std::string url = "/setSubscription?t=" + current_ticket + "&key=" +
+            report_template["key"] + "&speed=" + id;
+        addNewTask(new SingleRequestTask(url, "setSubscription",
+                                         current_ticket, mserv), this);
+    } else if (method == "listMeasurements") {
+        std::map<std::string, std::string> uargs;
+        uargs["key"] = !force_key.empty() ? force_key :
+            key_store->getCookieVal("hash_key", wserv.hostname);
+        for (auto p : args.object_items())
+            uargs[p.first] = p.second.string_value();
+        if (isValidHashkey(uargs["key"])) {
+            std::string url = wserv_measurementsurl;
+            HttpClientConnection::addUrlPars(url, uargs);
+            log() << "Get URL: " << url;
+            addNewTask(new SingleRequestTask(url, "list_measurements",
+                                             "lmtask", wserv), this);
+        } else {
+            sendToClient("measurementList", "{\"measurements\":[]}");
+        }
+    } else if (method == "pingSweep") {
+        addNewTask(new PingSweepTask(settings_result, wserv), this);
+    } else if (method == "accumulateLog") {
+        accumulateLog();
+    } else if (method == "appendLog") {
+        std::string l = args["logText"].string_value();
+        if (!l.empty())
+            appendLog(l);
+    } else if (method == "sendLogToServer") {
+        sendLogToServer();
+    } else if (method == "terminate") {
+        bridge = nullptr;
+        setResult("");
+    } else if (method == "quit") {
+        bridge = nullptr;
+        setResult("");
+    } else {
+        log() << "unknown command";
+    }
+}
+
+void MeasurementAgent::handleExecution(Task *sender, const std::string &msg) {
+    if (sender == bridge) {
+        pollBridge(msg);
+    } else if (sender == current_test) {
+        current_ticket = msg;
+        dbg_log() << "current ticket: " << current_ticket;
+    } else if (!bridge) {
+        if (BridgeTask *bt = dynamic_cast<BridgeTask *>(sender)) {
+            log() << "Bridge connected";
+            bridge = bt;
+            pollBridge(msg);
+        }
+    }
+}
+
+void MeasurementAgent::sendTaskProgress(const std::string &taskname,
+                                        double speed, double progress) {
+    // We can't use locale dependent number formating in JSON!
+    std::ostringstream json;
+    json.imbue(std::locale("C"));
+    json << "{\"task\": \"" << taskname
+         << "\", \"result\": " << speed
+         << ", \"progress\": " << progress << "}";
+    sendToClient("taskProgress", json.str());
+}
+
+void MeasurementAgent::handleConfigurationOption(const std::string &name,
+                                                 const std::string &value) {
+    log() << "option: " << name << " value: " << value;
+    if (name == "Logging.LogToConsole") {
+        if (!value.empty()) {
+            Logger::setLogFile(std::cerr);
+        }
+    } else if (name.substr(0, 7) == "Client.") {
+        std::string attr = name.substr(7);
+        if (!attr.empty() && attr.size() <= 20 && std::string::npos ==
+            attr.find_first_not_of("abcdefghijklmnopqrstuvwxyz")) {
+            // TODO: check not reserved!
+            if (attr == "hashkey")
+                force_key = value;
+            else
+                report_template[attr] = value;
+        } else {
+            log() << "will ignore option " << name;
+        }
+    } else if (name.substr(0, 7) == "Report.") {
+        std::string attr = name.substr(7);
+        if (!attr.empty() && attr.size() <= 20 && std::string::npos ==
+            attr.find_first_not_of("abcdefghijklmnopqrstuvwxyz") &&
+            current_test)
+            // TODO: check not reserved!
+            current_test->addToReport(attr, value);
+        else
+            log() << "will ignore option " << name;
+    } else if (name == "Measure.IpType") {
+        wserv.iptype = (value == "ipv6") ? 6 : 4;
+        std::string s = MeasurementTask::getLocalAddress();
+        if (!s.empty())
+            HttpClientTask::setLocalAddress(s, wserv.iptype);
+    } else if (name == "Measure.Webserver") {
+        wserv.hostname = value;
+    } else if (name == "Measure.Server") {
+        mserv.hostname = value;
+    } else if (name == "Measure.LocalAddress") {
+        if (!HttpClientTask::setLocalAddress(value, wserv.iptype))
+            setError("cannot use local address");
+#ifdef USE_GNUTLS
+    } else if (name == "Measure.TLS") {
+        if (value == "1") {
+            mserv.is_tls = true;
+            wserv.is_tls = true;
+            wserv.port = 443;
+        } else {
+            mserv.is_tls = false;
+            wserv.is_tls = false;
+            wserv.port = 80;
+        }
+#endif
+    } else if (name == "Measure.ProxyServerUrl") {
+        wserv.proxyHost = value;
+        mserv.proxyHost = value;
+    } else if (name == "Measure.ProxyServerPort") {
+        try {
+            wserv.proxyPort = static_cast<uint16_t>(stoi(value));
+        } catch (...) {
+            wserv.proxyPort = 80;
+        }
+        mserv.proxyPort = wserv.proxyPort;
+    } else if (name == "Measure.LoadDuration") {
+        double duration = 10.0;
+        try {
+            duration = stod(value);
+        } catch (...) {
+        }
+        if (duration < 2.0)
+            duration = 2.0;
+        else if (duration > 10.0)
+            duration = 10.0;
+        report_template["dlength"] = std::to_string(duration);
+        report_template["ulength"] = std::to_string(duration);
+    } else if (name == "Measure.SpeedLimit") {
+        if (value.empty())
+            report_template.erase("speedlimit");
+        else
+            report_template["speedlimit"] = value;
+    } else if (name == "Measure.AutoSaveReport") {
+        report_template["autosave"] = value;
+    } else if (name == "Measure.SettingsUrl") {
+        wserv_settingsurl = value;
+    } else if (name == "Measure.ContentsUrl") {
+        wserv_contentsurl = value;
+    } else if (name == "Measure.MeasurementsUrl") {
+        wserv_measurementsurl = value;
+    } else if (name == "options_file") {
+        // Ignore.
+    } else {
+        log() << name << ": unknown option";
+    }
+}
diff --git a/src/measurement/measurementagent.h b/src/measurement/measurementagent.h
new file mode 100644
index 0000000..55ff183
--- /dev/null
+++ b/src/measurement/measurementagent.h
@@ -0,0 +1,88 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include <string>
+#include <map>
+#include <sstream>
+
+#include "../framework/bridgetask.h"
+#include "../json11/json11.hpp"
+#include "../http/httphost.h"
+#include "../http/cookiefile.h"
+
+class SpeedTest;
+
+class MeasurementAgent : public Task {
+public:
+    MeasurementAgent(const TaskConfig &config, const HttpHost &webserver);
+    void taskMessage(Task *task) override;
+    void taskFinished(Task *task) override;
+
+    void handleExecution(Task *sender, const std::string &msg) override;
+    void sendToClient(const std::string &method,
+                      const std::string &jsonobj = "{}") {
+        if (bridge)
+            bridge->sendMsgToClient(method, jsonobj);
+    }
+    void sendTaskComplete(const std::string &t, const std::string &res = "");
+    void sendTaskProgress(const std::string &taskname,
+                          double speed, double progress);
+    void accumulateLog() {
+        setLogFile(accumulated_log);
+    }
+    void appendLog(const std::string &str) {
+        accumulated_log << "\nAppend " << str.size() << "\n" << str;
+    }
+    void sendLogToServer();
+private:
+    std::string getDefaultConfig();
+    bool isValidHashkey(const std::string &key);
+    void pollBridge(const std::string &msg);
+    static bool isValidJson(const std::string &s) {
+        std::string err;
+        auto obj = json11::Json::parse(s, err);
+        return err.empty();
+    }
+
+    void handleMsgFromClient(const std::string &method,
+                             const json11::Json &args);
+    void handleConfigurationOption(const std::string &name,
+                                   const std::string &value);
+    void uploadComplete();
+    void doSaveReport();
+    void resetCurrentTest();
+    BridgeTask *bridge = nullptr;
+    SpeedTest *current_test = nullptr;
+    std::string current_ticket;
+    std::ostringstream accumulated_log;
+
+    // Initial state is IDLE. When client says "startTest", state becomes
+    // STARTED. When test is done, we send "testComplete global" to client
+    // and set state to FINISHED. When client sends resetTest, state will
+    // be reset to IDLE.
+    // If client sends abortTest in state STARTED, state becomes ABORTED.
+    enum class MeasurementState { IDLE, STARTED, FINISHED, ABORTED };
+    MeasurementState state = MeasurementState::IDLE;
+
+    // If the client doesn't manage keys, we store them here:
+    CookieManager *key_store;
+
+    std::string force_key;
+
+    // The web server and the measurement server:
+    HttpHost wserv, mserv;
+
+    // Default value, might be modified by the client
+    std::string wserv_contentsurl = "/api/content";
+    std::string wserv_measurementsurl = "/api/measurements";
+    std::string wserv_settingsurl = "/api/servers";
+    std::string settings_result;
+
+    // Info to be included each time measurement result is sent:
+    std::map<std::string, std::string> report_template;
+
+    TaskConfig cfgOptions;
+    std::string options_filename;
+};
diff --git a/src/measurement/measurementtask.cpp b/src/measurement/measurementtask.cpp
new file mode 100644
index 0000000..76eb728
--- /dev/null
+++ b/src/measurement/measurementtask.cpp
@@ -0,0 +1,62 @@
+#include <numeric>
+
+#include "measurementtask.h"
+#include "../json11/json11.hpp"
+
+#ifdef _WIN32
+typedef long ssize_t;
+#endif
+
+void MeasurementTask::checkConnectionCount() {
+    if (terminated())
+        return;
+
+    if (active_connections < no_connections)
+        dbg_log() << "checkConnectionCount: act=" << active_connections
+                  << " want=" << no_connections
+                  << " max=" << max_connections;
+
+    while (active_connections < no_connections && max_connections) {
+        --max_connections;
+        if (!createNewConnection())
+            log() << "couldn't add http connection, " << max_connections
+                  << " attempts remain";
+    }
+
+    if (no_connections && !active_connections)
+        connectionLost();
+}
+
+void MeasurementTask::connAdded(SocketConnection *c) {
+    ++active_connections;
+    log() << "conn added: " << c << " now have " << active_connections;
+}
+
+void MeasurementTask::connRemoved(SocketConnection *c) {
+    --active_connections;
+    log() << "conn removed: " << c << " now have " << active_connections;
+    if (!terminated()) {
+        checkConnectionCount();
+    }
+}
+
+std::string MeasurementTask::json_obj(const std::string &attr,
+                                      const std::string &value) {
+    json11::Json obj = json11::Json::object {
+        { attr, value },
+    };
+    return obj.dump();
+}
+
+std::string MeasurementTask::calculateLatency(std::vector<double> &samples) {
+    if (samples.size() < 5)
+        return std::string(); // Too few samples
+
+    // Keep the best 60%
+    std::sort(samples.begin(), samples.end());
+    ssize_t n = static_cast<ssize_t>(samples.size() * 3 / 5);
+
+    double latency_sum = std::accumulate(samples.cbegin(),
+                                         samples.cbegin()+n, 0.0);
+    return fValue(1000.0 * latency_sum / static_cast<double>(n));
+}
diff --git a/src/measurement/measurementtask.h b/src/measurement/measurementtask.h
new file mode 100644
index 0000000..a878a82
--- /dev/null
+++ b/src/measurement/measurementtask.h
@@ -0,0 +1,115 @@
+#pragma once
+
+#include "../http/httpclienttask.h"
+#include "../http/httphost.h"
+#include "defs.h"
+#include <clocale>
+#include <sstream>
+
+class MeasurementTask : public HttpClientTask {
+public:
+    MeasurementTask(const std::string &name, const std::string &ticket,
+                    const HttpHost &httpserver,
+                    unsigned int no_conn = 1, unsigned int max_conn = 3,
+                    double timeout = 25.0) :
+    HttpClientTask(name, httpserver),
+        no_connections(no_conn),
+        active_connections(0),
+        max_connections(max_conn),
+        timeout_sec(timeout),
+        ticket_string(ticket) {
+        setUserAgentString(measurement::appName + " " + measurement::appVersion);
+    }
+
+    std::string t() {
+        return ticket_string;
+    }
+
+    // Only use keep-alive within the same measurement:
+    std::string cacheLabel() override {
+        return ticket_string;
+    }
+
+    // If you override this, you must call checkConnectionCount().
+    // Return value is number of seconds until timerEvent
+    // should be called, <= 0 for never.
+    double start() override {
+        checkConnectionCount();
+        return timeout_sec;
+    }
+
+    // If you override timerEvent(), you'll have to check for timeout.
+    /*
+    double timerEvent() override {
+        if (timeout())
+            setResult("");
+        return 0;
+    }
+    */
+
+    // Will be called if checkConnectionCount fails.
+    // Default is to terminate task with an empty result.
+    virtual void connectionLost() {
+        log() << "connectionLost()";
+        setResult("");
+    }
+
+    // Returns a JSON object with a single attribute-value pair
+    static std::string json_obj(const std::string &attr,
+                                const std::string &value);
+
+    // Return floating point value as string.
+    // We don't want to use to_string since it's locale dependent,
+    // which may break JSON.
+    static std::string fValue(double x) {
+        std::ostringstream s;
+        s.imbue(std::locale("C"));
+        s << x;
+        return s.str();
+    }
+
+    static std::string calculateLatency(std::vector<double> &samples);
+protected:
+    // Tries to make sure we have at least no_connections simultaneous
+    // HTTP connections. Will not try more than max_connection times.
+    // Will call connectionLost on fatal failure.
+    void checkConnectionCount();
+
+    // Will not kill already created connections.
+    void setNoConnections(unsigned int no) {
+        no_connections = no;
+        checkConnectionCount();
+    }
+
+    unsigned int getNoConnections() const {
+        return no_connections;
+    }
+
+    unsigned int currentNoConnections() const {
+        return active_connections;
+    }
+
+    void noMoreConnections() {
+        max_connections = 0;
+    }
+
+    bool timeout() {
+        if (timeout_sec < 0)
+            return false;
+        if (elapsed() < timeout_sec)
+            return false;
+        log() << "Task timeout.";
+        return true;
+    }
+
+    double timeout_s() {
+        return timeout_sec;
+    }
+private:
+    void connAdded(SocketConnection *) final;
+    void connRemoved(SocketConnection *) final;
+
+    unsigned int no_connections, active_connections, max_connections;
+    double timeout_sec;
+    std::string ticket_string;
+};
diff --git a/src/measurement/mk.inc b/src/measurement/mk.inc
new file mode 100644
index 0000000..5d58981
--- /dev/null
+++ b/src/measurement/mk.inc
@@ -0,0 +1,18 @@
+SOURCES += \
+	$(DIRLEVEL)/measurement/defs.cpp \
+	$(DIRLEVEL)/measurement/speedtest.cpp \
+	$(DIRLEVEL)/measurement/measurementtask.cpp \
+	$(DIRLEVEL)/measurement/singlerequesttask.cpp \
+	$(DIRLEVEL)/measurement/rpingtask.cpp \
+	$(DIRLEVEL)/measurement/latencytask.cpp \
+	$(DIRLEVEL)/measurement/pingsweeptask.cpp \
+	$(DIRLEVEL)/measurement/warmuptask.cpp \
+	$(DIRLEVEL)/measurement/tickettask.cpp \
+	$(DIRLEVEL)/measurement/infotask.cpp \
+	$(DIRLEVEL)/measurement/progresstask.cpp \
+	$(DIRLEVEL)/measurement/downloadtask.cpp \
+	$(DIRLEVEL)/measurement/uploadtask.cpp \
+	$(DIRLEVEL)/measurement/measurementagent.cpp \
+	$(DIRLEVEL)/measurement/uploadinfotask.cpp
+
+include $(DIRLEVEL)/http/mk.inc
diff --git a/src/measurement/pingsweeptask.cpp b/src/measurement/pingsweeptask.cpp
new file mode 100644
index 0000000..e115d56
--- /dev/null
+++ b/src/measurement/pingsweeptask.cpp
@@ -0,0 +1,57 @@
+#include "pingsweeptask.h"
+
+PingSweepTask::PingSweepTask(const std::string &cfg,
+                             const HttpHost &server) :
+    HttpClientTask("pingsweep", server),
+    config(json11::Json::parse(cfg, json_err)) {
+}
+
+double PingSweepTask::start() {
+    unsigned int no_calls = 0;
+    for (auto srv : config["servers"].array_items()) {
+        //log() << "Ping " << srv["url"].string_value();
+        setServer(srv["url"].string_value());
+        if (createNewConnection())
+            ++no_calls;
+    }
+    if (no_calls)
+        return 5.0;
+    setResult("");
+    return 0.0;
+}
+
+double PingSweepTask::timerEvent() {
+    setResult(best_host);
+    return 0;
+}
+
+void PingSweepTask::newRequest(HttpClientConnection *conn) {
+    //log() << "newRequest " << conn->hostname();
+    auto p = requests.find(conn->hostname());
+    if (p != requests.end())
+        return; // Ignore host since we already have made a request to it.
+
+    requests[conn->hostname()] = timeNow();
+    conn->get("/pingsweep/req" + std::to_string(requests.size()));
+}
+
+bool PingSweepTask::requestComplete(HttpClientConnection *conn) {
+    //log() << "requestComplete " << conn->hostname() << " size " << requests.size();
+    auto p = requests.find(conn->hostname());
+    if (p != requests.end()) {
+        double t = 1000 * secondsSince(p->second);
+        std::string r = conn->hostname() + " " + std::to_string(t) + " ms";
+        log() << r;
+        if (results.empty())
+            setMessage("ping info");
+        results.push_back(r);
+        requests.erase(p);
+        if (t < best_time) {
+            best_time = t;
+            best_host = conn->hostname();
+        }
+    }
+    if (requests.empty())
+        setResult(best_host);
+    return false;
+}
diff --git a/src/measurement/pingsweeptask.h b/src/measurement/pingsweeptask.h
new file mode 100644
index 0000000..663102c
--- /dev/null
+++ b/src/measurement/pingsweeptask.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <vector>
+#include <deque>
+#include "../json11/json11.hpp"
+#include "../http/httpclienttask.h"
+
+class PingSweepTask : public HttpClientTask {
+public:
+    PingSweepTask(const std::string &obj, const HttpHost &server);
+    double start() override;
+    double timerEvent() override;
+    void newRequest(HttpClientConnection *) override;
+    bool requestComplete(HttpClientConnection *conn) override;
+    std::string cacheLabel() override {
+        return std::string(); // Don't store in keep-alive cache
+    }
+    std::string getResult() {
+        if (results.empty())
+            return std::string();
+        std::string res = results.front();
+        results.pop_front();
+        return res;
+    }
+private:
+    std::string json_err;
+    json11::Json config;
+    std::map<std::string, TimePoint> requests;
+    std::string best_host;
+    std::deque<std::string> results;
+    double best_time = 1e6;
+};
diff --git a/src/measurement/progresstask.cpp b/src/measurement/progresstask.cpp
new file mode 100644
index 0000000..76de81d
--- /dev/null
+++ b/src/measurement/progresstask.cpp
@@ -0,0 +1,79 @@
+#include "progresstask.h"
+
+void ProgressTask::doTestProgress(double mbps, double duration,
+                                  unsigned int no_conn) {
+    if (duration <= current_duration || terminated())
+        return;
+
+    current_duration = duration;
+
+    // Don't let the speed decrease the last half second:
+    if (duration < tot_duration-0.5 || mbps > current_mbps)
+        current_mbps = mbps;
+
+    if (duration >= tot_duration) {
+        setResult(fValue(current_mbps));
+        return;
+    }
+
+    setMessage("progress");
+    log() << "task progress " << current_mbps << ' ' << duration/tot_duration;
+
+    if (duration > tot_duration-0.35) {
+        // Less than 0.35 seconds left, don't make any new requests
+        // (but let existing requests keep going).
+        noMoreConnections();
+        current_load_size = 0;
+        soon_finished = true;
+        return;
+    }
+
+    // Calculate appropriate load size for subsequent requests
+
+    //unsigned int n = getNoConnections();
+    if (!no_conn)
+        return;
+
+    double time_left = tot_duration - duration;
+
+    // We'll probably load this number of bytes during the time_left:
+    double exp_bytes;
+    if (speedlimit_mbps > 0.0)
+        exp_bytes = std::min(speedlimit_mbps, mbps) * std::min(time_left, 0.3) / 0.000008;
+    else
+        exp_bytes = mbps * time_left / 0.000008;
+
+    current_load_size = static_cast<size_t>(exp_bytes / 4.0 / no_conn);
+    if (current_load_size > 40000000)
+        current_load_size = 40000000;
+    else if (current_load_size < 6000)
+        current_load_size = 6000;
+
+    if (speedlimit_mbps > mbps) {
+        dbg_log() << "We're going too slow, wake up the passive connections";
+        wakeUp();
+    }
+}
+
+size_t ProgressTask::loadSize() {
+    // For very fast network, speed up even before first doTestProgress:
+    if (++no_started_loads == load_size_check && current_duration<=0) {
+        double time = elapsed();
+        double speed = addOverheadMbps(byteCount(), time);
+        doTestProgress(speed, time, currentNoConnections());
+    }
+    if (speedlimit_mbps > 0.0) {
+        double time = elapsed();
+        double speed = addOverheadMbps(byteCount(), time);
+        if (speed > speedlimit_mbps) {
+            log() << "going too fast, will pause";
+            return 0;
+        }
+    }
+
+    return current_load_size;
+}
+
+bool ProgressTask::requestComplete(HttpClientConnection *) {
+    return true;
+}
diff --git a/src/measurement/progresstask.h b/src/measurement/progresstask.h
new file mode 100644
index 0000000..d3e40f1
--- /dev/null
+++ b/src/measurement/progresstask.h
@@ -0,0 +1,108 @@
+#pragma once
+
+#include "measurementtask.h"
+
+class ProgressTask : public MeasurementTask {
+public:
+    ProgressTask(const std::string &label, const std::string &ticket_string,
+                 const HttpHost &server,
+                 unsigned int no_conn = 4, unsigned int max_conn = 20,
+                 double duration = 10.0, double timeout = 25.0) :
+        MeasurementTask(label, ticket_string, server, no_conn, max_conn, timeout),
+        byte_count(0),
+        current_load_size(50000),
+        load_size_check(no_conn + 2),
+        current_duration(0.0),
+        current_mbps(0.0) {
+            if (duration < 2.0)
+                tot_duration = 2.0;
+            else if (duration > 20.0)
+                tot_duration = 20.0;
+            else
+                tot_duration = duration;
+    }
+
+    bool requestComplete(HttpClientConnection *) override;
+
+    void notifyBytesAndDuration(uint64_t count, double duration) {
+        double mbps = addOverheadMbps(count, duration);
+        doTestProgress(mbps, duration, currentNoConnections());
+    }
+
+    void notifyBytesLoaded(size_t n) {
+        byte_count += n;
+    }
+
+    // If you want to use the threadSendCount/threadRecvCount methods, you
+    // should call the below method in your start() method:
+    void notifyStarted() {
+        thread_send_count = SocketConnection::totBytesSent();
+        thread_recv_count = SocketConnection::totBytesReceived();
+    }
+
+    void connectionLost() override {
+        // We're dead. If more than half the test was completed,
+        // we keep the result.
+        if (current_duration > tot_duration*0.5)
+            setResult(fValue(current_mbps));
+        else
+            setResult("-1");
+    }
+
+    void set_speedlimit(double limit_mbps) {
+        speedlimit_mbps = (limit_mbps < 0.5) ? 0.5 : limit_mbps;
+        if (speedlimit_mbps < 5.0)
+            current_load_size = 5000;
+    }
+
+    size_t loadSize();
+
+    double currentDuration() const {
+        return current_duration;
+    }
+    double currentProgress() const {
+        return current_duration/tot_duration;
+    }
+    double currentMbps() const {
+        return current_mbps;
+    }
+protected:
+    uint64_t byteCount() {
+        return byte_count;
+    }
+
+    // Return total number of bytes sent through all sockets in the current
+    // thread since last call to notifyStarted():
+    uint64_t threadSendCount() {
+        return SocketConnection::totBytesSent() - thread_send_count;
+    }
+
+    // Return total number of bytes received from all sockets in the current
+    // thread since last call to notifyStarted():
+    uint64_t threadRecvCount() {
+        return SocketConnection::totBytesReceived() - thread_recv_count;
+    }
+
+    static double addOverheadMbps(uint64_t n, double s) {
+        if (s <= 0.0)
+            return 0.0;
+
+        double mbps = static_cast<double>(n) / s * 0.000008;
+        if (mbps > 8.0)
+            return (mbps * 1.02 + 0.16);
+        else
+            return mbps * 1.04;
+    }
+    void doTestProgress(double mbps, double duration, unsigned int no_conn);
+    bool soonFinished() const {
+        return soon_finished;
+    }
+
+private:
+    uint64_t byte_count, thread_send_count = 0, thread_recv_count = 0;
+    size_t current_load_size;
+    unsigned int load_size_check, no_started_loads = 0;
+    double tot_duration, current_duration, current_mbps;
+    double speedlimit_mbps = 0.0;
+    bool soon_finished = false;
+};
diff --git a/src/measurement/rpingtask.cpp b/src/measurement/rpingtask.cpp
new file mode 100644
index 0000000..dcc41e0
--- /dev/null
+++ b/src/measurement/rpingtask.cpp
@@ -0,0 +1,61 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <sstream>
+#include "rpingtask.h"
+
+void RpingTask::newRequest(HttpClientConnection *conn) {
+    conn->ws_get("/ws?t=" + t());
+}
+
+bool RpingTask::wsTextMessage(HttpConnection *conn,
+                             const std::string &msg) {
+    if (!max_roundtrips) {
+        setResult("");
+        return false;
+    }
+    --max_roundtrips;
+
+    std::istringstream line(msg);
+    std::string cmd, challenge;
+    double val;
+    line >> cmd;
+    if (sent_challenge) {
+        line >> val;
+        if (cmd == "latency_result") {
+            setResult(fValue(val));
+            return false;
+        } else if (line && val > 0.0) {
+            samples.push_back(val);
+        }
+    }
+
+    if (cmd != "challenge") {
+        err_log() << "unknown message: " << msg;
+        return false;
+    }
+    log() << "Received " << msg;
+
+    line >> challenge;
+    if (!line || challenge.size() > 10) {
+        err_log() << "Bad rping challenge";
+        return false;
+    }
+
+    if (samples.size() >= 12) {
+        conn->sendWsMessage("rping end");
+        log() << "Sending rping end";
+        return true;
+    }
+
+    conn->sendWsMessage("rping " + challenge);
+    log() << "Sending rping " << challenge;
+    sent_challenge = true;
+    return true;
+}
+
+bool RpingTask::websocketUpgrade(HttpClientConnection *conn) {
+    conn->sendWsMessage("rping start");
+    log() << "Sending rping start";
+    return true;
+}
diff --git a/src/measurement/rpingtask.h b/src/measurement/rpingtask.h
new file mode 100644
index 0000000..4379112
--- /dev/null
+++ b/src/measurement/rpingtask.h
@@ -0,0 +1,30 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include "measurementtask.h"
+
+class RpingTask : public MeasurementTask {
+public:
+    RpingTask(const std::string &label, const std::string &ticket_string,
+              const HttpHost &server,
+              unsigned int no_conn = 1, unsigned int max_conn = 20,
+              double duration = 25.0) :
+        MeasurementTask(label, ticket_string, server,
+                        no_conn, max_conn, duration)
+    {
+    }
+    void newRequest(HttpClientConnection *) override;
+    bool requestComplete(HttpClientConnection *) override {
+        return false;
+    }
+    bool websocketUpgrade(HttpClientConnection *) override;
+    bool wsTextMessage(HttpConnection *conn,
+                       const std::string &msg) override;
+    void calc_local_result();
+private:
+    std::vector<double> samples;
+    unsigned int max_roundtrips = 100;
+    bool sent_challenge = false;
+};
diff --git a/src/measurement/singlerequesttask.cpp b/src/measurement/singlerequesttask.cpp
new file mode 100644
index 0000000..3ac8f04
--- /dev/null
+++ b/src/measurement/singlerequesttask.cpp
@@ -0,0 +1,19 @@
+#include "singlerequesttask.h"
+
+SingleRequestTask::SingleRequestTask(const std::string &url,
+                                     const std::string &name,
+                                     const std::string &ticket,
+                                     const HttpHost &server) :
+    MeasurementTask(name, ticket, server),
+    _url(url) {
+}
+
+void SingleRequestTask::newRequest(HttpClientConnection *conn) {
+    conn->get(_url);
+}
+
+bool SingleRequestTask::requestComplete(HttpClientConnection *conn) {
+    if (conn->httpStatus() == 200)
+        setResult(conn->contents());
+    return false;
+}
diff --git a/src/measurement/singlerequesttask.h b/src/measurement/singlerequesttask.h
new file mode 100644
index 0000000..83150ea
--- /dev/null
+++ b/src/measurement/singlerequesttask.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "measurementtask.h"
+
+class SingleRequestTask : public MeasurementTask {
+public:
+    SingleRequestTask(const std::string &url, const std::string &name,
+                      const std::string &ticket, const HttpHost &server);
+    void newRequest(HttpClientConnection *conn) override;
+    bool requestComplete(HttpClientConnection *conn) override;
+private:
+    std::string _url;
+};
diff --git a/src/measurement/speedtest.cpp b/src/measurement/speedtest.cpp
new file mode 100644
index 0000000..8f50092
--- /dev/null
+++ b/src/measurement/speedtest.cpp
@@ -0,0 +1,358 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include <iomanip>
+
+#include "../http/sha1.h"
+
+#include "speedtest.h"
+
+#include "measurementagent.h"
+#include "rpingtask.h"
+// Alternative latency measurement:
+#include "latencytask.h"
+#include "warmuptask.h"
+#include "tickettask.h"
+#include "infotask.h"
+#include "downloadtask.h"
+// Alternative download measurement:
+#include "wsdownloadtask.h"
+#include "uploadtask.h"
+// Alternative upload measurement: #include "wsuploadtask.h"
+// Alternative to some parts of infotask:
+#include "uploadinfotask.h"
+
+SpeedTest::SpeedTest(MeasurementAgent *agent, const HttpHost &mserver,
+                     const std::map<std::string, std::string> &report_data) :
+    Task("SpeedTest"),
+    the_agent(agent),
+    mserv(mserver),
+    report(report_data)
+{
+    bytesSentAtStart = SocketConnection::totBytesSent();
+    bytesRecAtStart = SocketConnection::totBytesReceived();
+    killChildTaskWhenFinished();
+    upload_duration = std::stod(report["ulength"]);
+    download_duration = std::stod(report["dlength"]);
+    try {
+        auto p = report.find("speedlimit");
+        if (p != report.end()) {
+            log() << "speedlimit " << p->second;
+            speed_limit = std::stod(p->second);
+            if (speed_limit < 0.5)
+                speed_limit = 0.5;
+            if (speed_limit <= 10.0) {
+                initial_no_dconn = 2;
+                max_no_dconn = 10;
+                initial_no_uconn = 2;
+                max_no_uconn = 4;
+            }
+        } else {
+            log() << "no speedlimit";
+        }
+    } catch (...) {
+        the_agent->sendToClient("setInfo", MeasurementTask::
+                                json_obj("warning", "cannot parse SpeedLimit value"));
+    }
+
+}
+
+double SpeedTest::start() {
+    startObserving(the_agent);
+    addNewTask(new TicketTask(mserv, report["key"], report["host"]), this);
+    return 0.0;
+}
+
+void SpeedTest::taskMessage(Task *task) {
+    if (!the_agent)
+        return;
+
+    std::string name = task->label(),
+        message = task->message();
+
+    if (task == info_task) {
+        log() << "GOT INFO: " << message;
+        if (message == "server upload timeout") {
+            uploadComplete();
+            return;
+        }
+        std::string err;
+        auto obj = json11::Json::parse(message, err);
+        if (!err.empty()) {
+            err_log() << "JSON error, ignoring message";
+            return;
+        }
+        std::string event = obj["event"].string_value();
+        const json11::Json &args = obj["args"];
+        // {"event": "measurementInfo",
+        //    "args": {
+        //       "ispname":"Telia","date":"Thu, 30 Nov 2017 15:25:31 +0000",
+        //        "rating":"GOOD","MeasurementID":"109"
+        //    }
+        // }
+        if (event == "measurementInfo") {
+            the_agent->sendToClient("measurementInfo", args.dump());
+            setResult("");
+        } else if (event == "uploadInfo") {
+            /* {
+                   "event": "uploadInfo",
+                   "args": {
+                       "duration": 1.506616427,
+                       "speed": 37348.559901815221
+                   }
+               }
+            */
+            double speed = args["speed"].number_value();
+            double duration = args["duration"].number_value();
+
+            log() << "uploadInfo Duration: " << duration
+                  << " Speed: " << speed;
+            if (duration >= upload_duration) {
+                server_upload_speed = MeasurementTask::fValue(speed);
+                uploadComplete();
+            } else if (duration > 0)
+                the_agent->sendTaskProgress("upload", speed,
+                                            duration/upload_duration);
+        } else {
+            log() << "unknown event: " << event;
+        }
+    } else if (ProgressTask *ptask = dynamic_cast<ProgressTask *>(task)) {
+        double speed = ptask->currentMbps();
+        double progress = ptask->currentProgress();
+        if (name != "upload")
+            the_agent->sendTaskProgress(name, speed, progress);
+        log() << name << " speed " << speed << " Mbit/s, progress " << progress;
+    } else {
+        log() << name << " message: " << message;
+    }
+}
+
+void SpeedTest::taskFinished(Task *task) {
+    std::string name = task->label(),
+        result = task->result();
+
+    if (task->wasKilled())
+        log() << "Task " << name << " killed";
+    else
+        log() << "Task " << name << " finished, result: " << result;
+
+    if (task == the_agent) {
+        the_agent = nullptr;
+        log() << "Agent gone, will exit";
+        setResult("");
+    } else if (task == info_task) {
+        info_task = nullptr;
+        if (report_sent_to_server)
+            setResult("");
+        return;
+    }
+
+    if (!the_agent)
+        return;
+
+    if (name == "ticket") {
+        if (result.empty()) {
+            json11::Json obj = json11::Json::object {
+                { "error", "no network access to server" },
+                { "errno", "C01" }
+            };
+            the_agent->sendToClient("setInfo", obj.dump());
+            setResult("");
+        } else {
+            tstr = result;
+            if (TicketTask *ttask = dynamic_cast<TicketTask *>(task))
+                report["localip"] = ttask->localIp();
+
+            the_agent->sendToClient("setInfo", MeasurementTask::
+                                    json_obj("ticket", tstr));
+            the_agent->sendToClient("taskStart", MeasurementTask::
+                                    json_obj("task", "latency"));
+            info_task = new InfoTask("measurement info", tstr,
+                                     report["key"], mserv);
+
+            addNewTask(info_task, this);
+            RpingTask *t = new RpingTask("rping", tstr, mserv);
+            addNewTask(t, this);
+
+            // Send the ticket to the agent. The agent may use it to update
+            // subscription into or fetch logs after the measurement is done.
+            executeHandler(the_agent, tstr);
+        }
+    } else if (name == "measurementStart") {
+        std::string err;
+        auto obj = json11::Json::parse(result, err);
+        if (!result.empty() && err.empty()) {
+            std::string ip = obj["ip"].string_value();
+            if (!ip.empty())
+                log() << "Client external ip number: " << ip;
+            if (local_latency) {
+                double latency = obj["latency"].number_value();
+                if (latency > 0) {
+                    local_latency = false;
+                    report["latency"] = std::to_string(latency);
+                    log() << "Adjusted latency: " << latency;
+                }
+            }
+        }
+    } else if (name == "rping" || name == "httplatency") {
+        if (name == "rping") {
+            if (result.size()) {
+                websocket_works = true;
+            } else {
+                addNewTask(new LatencyTask(tstr, mserv), this);
+                return;
+            }
+        } else {
+            local_latency = true;
+            if (!result.size())
+                result = "-1";
+        }
+        report["latency"] = result;
+        the_agent->sendTaskComplete("latency", result);
+        std::string url = "/measurementStarted?t=" + tstr;
+        //url += "&uptick=120";
+
+        HttpClientConnection::addUrlPars(url, report);
+        log() << "measurementStart: " << mserv.hostname << url;
+        addNewTask(new SingleRequestTask(url, "measurementStart",
+                                                tstr, mserv), this);
+        addNewTask(new WarmUpTask(tstr, mserv, initial_no_dconn, 3.0),
+                          this);
+    } else if (name == "download") {
+        if (!result.size())
+            result = "-1";
+        the_agent->sendTaskComplete("download", result);
+        report["download"] = result;
+        the_agent->sendToClient("taskStart", MeasurementTask::
+                                json_obj("task", "upload"));
+        // UploadInfoTask fetches upload speed/progress from the server.
+        // If the final speed sill hasn't arrived 3.0 seconds after the end of
+        // the upload measurement, we give up and use the local upload speed
+        // estimate which is lower since we can only count confirmed data.
+        if (!websocket_works)
+            addNewTask(new UploadInfoTask(tstr, mserv, upload_duration,
+                                          upload_duration+3.0), this);
+        UploadTask *t = new UploadTask(tstr, mserv, initial_no_uconn,
+                                       max_no_uconn, upload_duration);
+        if (speed_limit > 0)
+            t->set_speedlimit(speed_limit);
+        addNewTask(t, this);
+    } else if (name == "saveReport") {
+        uint64_t totBytesSent = SocketConnection::totBytesSent() - bytesSentAtStart;
+        uint64_t totBytesReceived = SocketConnection::totBytesReceived() - bytesRecAtStart;
+
+        json11::Json bytesInfo = json11::Json::object {
+            { "totBytesReceived", std::to_string(totBytesReceived)},
+            { "totBytesSent", std::to_string(totBytesSent) }
+        };
+
+        the_agent->sendToClient("setInfo", bytesInfo.dump());
+
+        std::string err;
+        auto obj = json11::Json::parse(result, err);
+        if (!result.empty() && err.empty()) {
+            the_agent->sendToClient("report", result);
+            if (report["host"] == "none") {
+                // Local measurement, no more info will arrive.
+                setResult("");
+                return;
+            }
+            log() << "INFO: " << result;
+            // Wait at most 3 seconds for final info from server.
+            if (info_task) {
+                info_task->setInfoDeadline(3.0);
+                info_task->resetTimer(0.1);
+            } else {
+                std::string url = "/getUpdate?t=" + tstr +
+                    "&key=" + report["key"];
+                addNewTask(new SingleRequestTask(url, "getUpdate", tstr,
+                                                 mserv), this);
+            }
+        } else {
+            the_agent->sendToClient("report", "{}");
+            log() << "invalid saveReport: " << result;
+            setResult("");
+        }
+    } else if (name == "warmup") {
+        the_agent->sendToClient("taskStart", MeasurementTask::
+                                json_obj("task", "download"));
+        //WsDownloadTask *t = new WsDownloadTask(tstr, mserv, initial_no_dconn,
+        DownloadTask *t = new DownloadTask(tstr, mserv, initial_no_dconn,
+                                           max_no_dconn, download_duration);
+        log() << "t->set_speedlimit " << speed_limit;
+        if (speed_limit > 0)
+            t->set_speedlimit(speed_limit);
+        addNewTask(t, this);
+    } else if (name == "upload") {
+        local_upload_speed = result.size() ? result : "0";
+        if (server_upload_speed.empty()) {
+            if (info_task) {
+                // Wait for up to 3 seconds for server upload speed:
+                info_task->setUploadDeadline(3.0);
+                info_task->resetTimer(0.1);
+            } else {
+                // Pointless to wait for server upload info.
+                uploadComplete();
+            }
+        }
+    } else if (name == "getUpdate") {
+        std::string err;
+        auto obj = json11::Json::parse(result, err);
+        std::string event = obj["event"].string_value();
+        if (err.empty() && event == "measurementInfo") {
+            const json11::Json &args = obj["args"];
+            the_agent->sendToClient("measurementInfo", args.dump());
+
+        } else {
+            err_log() << "JSON error, ignoring message";
+            the_agent->sendToClient("measurementInfo", "{}");
+        }
+        setResult("");
+    } else {
+        log() << "unknown task, ignoring";
+    }
+}
+
+void SpeedTest::uploadComplete() {
+    if (report.find("upload") != report.end()) {
+        log() << "Upload already set: " << report["upload"];
+        return;
+    }
+
+    // Local and server speed calculations are complete.
+    // Use local calculation only if server calculation failed:
+    std::string result = server_upload_speed;
+    if (result.empty() || (result == "0" && !local_upload_speed.empty()))
+        result = local_upload_speed;
+    report["upload"] = result;
+    the_agent->sendTaskComplete("upload", result);
+    auto p = report.find("autosave");
+    if (p == report.end() || p->second != "false")
+        doSaveReport();
+    else
+        log() << "Wait for client to be ready for saving report";
+    if (info_task)
+        info_task->setUploadDeadline(-1.0);
+}
+
+void SpeedTest::addToReport(const std::string &attr, const std::string &val) {
+    report[attr] = val;
+}
+
+void SpeedTest::doSaveReport(const json11::Json &args) {
+    if (report_sent_to_server)
+        return;
+    report_sent_to_server = true;
+    std::string url("/saveReport?t=" + tstr);
+
+    for (auto p : args.object_items()) {
+        const std::string &attr = p.first;
+        if (report.find(attr) == report.end())
+            report[attr] = p.second.string_value();
+    }
+    HttpClientConnection::addUrlPars(url, report);
+
+    log() << "saveReport " << url;
+    addNewTask(new SingleRequestTask(url, "saveReport",
+                                     tstr, mserv), this);
+}
diff --git a/src/measurement/speedtest.h b/src/measurement/speedtest.h
new file mode 100644
index 0000000..067b86e
--- /dev/null
+++ b/src/measurement/speedtest.h
@@ -0,0 +1,48 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+// Perform a standard speed test, measuring latency, download speed, and upload
+// speed.
+
+#include "../json11/json11.hpp"
+#include "../framework/task.h"
+#include "../http/httphost.h"
+
+class MeasurementAgent;
+class InfoTask;
+
+class SpeedTest : public Task {
+public:
+    SpeedTest(MeasurementAgent *agent, const HttpHost &mserver,
+              const std::map<std::string, std::string> &report_data);
+    double start() override;
+    void taskMessage(Task *task) override;
+    void taskFinished(Task *task) override;
+    void uploadComplete();
+    void doSaveReport(const json11::Json &args = json11::Json::object());
+    void addToReport(const std::string &attr, const std::string &val);
+private:
+    MeasurementAgent *the_agent = nullptr;
+    InfoTask *info_task = nullptr;
+    HttpHost mserv;
+    std::map<std::string, std::string> report;
+    std::string tstr;
+    double upload_duration, download_duration;
+    std::string server_upload_speed, local_upload_speed;
+
+    bool report_sent_to_server = false;
+    bool websocket_works = false;
+    // Normally, the server should calculate the latency result.
+    // If that failed and we have a locally calculated latency result,
+    // this will be set to true:
+    bool local_latency = false;
+
+    double speed_limit = 0.0;
+    unsigned int initial_no_dconn = 10, initial_no_uconn = 4;
+    unsigned int max_no_dconn = 100, max_no_uconn = 100;
+
+    uint64_t bytesSentAtStart;
+    uint64_t bytesRecAtStart;
+};
diff --git a/src/measurement/tickettask.cpp b/src/measurement/tickettask.cpp
new file mode 100644
index 0000000..ab291f5
--- /dev/null
+++ b/src/measurement/tickettask.cpp
@@ -0,0 +1,28 @@
+#include "../json11/json11.hpp"
+#include "tickettask.h"
+
+TicketTask::TicketTask(const HttpHost &server, const std::string &key,
+                       const std::string &host) :
+    SingleRequestTask("/ticket?key=" + key + "&host=" + host, "ticket", "",
+                      server) {
+}
+
+bool TicketTask::requestComplete(HttpClientConnection *conn) {
+    if (conn->httpStatus() == 200) {
+        std::string err;
+        json11::Json ticket_obj = json11::Json::parse(conn->contents(), err);
+        if (err.empty()) {
+            _ticket = ticket_obj["ticket"].string_value();
+            if (!_ticket.empty()) {
+                _localIp = conn->localIp();
+                setResult(_ticket);
+            } else {
+                err_log() << "no ticket found";
+            }
+        } else {
+            err_log() << "cannot parse ticket: " << err;
+        }
+
+    }
+    return false;
+}
diff --git a/src/measurement/tickettask.h b/src/measurement/tickettask.h
new file mode 100644
index 0000000..c40d7b8
--- /dev/null
+++ b/src/measurement/tickettask.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "singlerequesttask.h"
+
+class TicketTask : public SingleRequestTask {
+public:
+    TicketTask(const HttpHost &server, const std::string &key,
+               const std::string &host);
+
+    std::string cacheLabel() override {
+        return _ticket;
+    }
+
+    bool requestComplete(HttpClientConnection *conn) override;
+    const std::string &localIp() const {
+        return _localIp;
+    }
+private:
+    std::string _ticket, _localIp;
+};
diff --git a/src/measurement/uploadinfotask.cpp b/src/measurement/uploadinfotask.cpp
new file mode 100644
index 0000000..03aa353
--- /dev/null
+++ b/src/measurement/uploadinfotask.cpp
@@ -0,0 +1,41 @@
+#include "uploadinfotask.h"
+
+UploadInfoTask::
+UploadInfoTask(const std::string &ticket, const HttpHost &server,
+               double duration, double max_time) :
+    ProgressTask("uploadinfo", ticket, server, 1, 3, duration, max_time) {
+}
+
+double UploadInfoTask::start() {
+    checkConnectionCount();
+    return timeout_s();
+}
+
+void UploadInfoTask::newRequest(HttpClientConnection *conn) {
+    conn->get("/ulinfo/1.txt?t=" + t());
+}
+
+
+bool UploadInfoTask::headerComplete(HttpClientConnection *conn) {
+    conn->doStreamResponse();
+    return true;
+}
+
+void UploadInfoTask::payload(HttpClientConnection *, char *buf, size_t len) {
+    buffer.append(buf, len);
+    while (true) {
+        std::string::size_type pos = buffer.find("\r\n");
+        if (pos == std::string::npos)
+            return;
+        std::istringstream line(buffer.substr(0, pos));
+        uint64_t byte_count;
+        double duration;
+        if (line >> byte_count >> duration) {
+            log() << "server upload info " << byte_count << ' ' << duration;
+            notifyBytesAndDuration(byte_count, duration);
+        } else if (pos) {
+            err_log() << "bad server info line: " << buffer.substr(0, pos);
+        }
+        buffer.erase(0, pos+2);
+    }
+}
diff --git a/src/measurement/uploadinfotask.h b/src/measurement/uploadinfotask.h
new file mode 100644
index 0000000..e5134d6
--- /dev/null
+++ b/src/measurement/uploadinfotask.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "progresstask.h"
+
+class UploadInfoTask : public ProgressTask {
+public:
+    UploadInfoTask(const std::string &ticket, const HttpHost &server,
+                   double duration = 10.0, double max_time = 25.0);
+    double start() override;
+    void newRequest(HttpClientConnection *) override;
+    bool headerComplete(HttpClientConnection *) override;
+    void payload(HttpClientConnection *, char *, size_t ) override;
+private:
+    std::string buffer;
+};
diff --git a/src/measurement/uploadtask.cpp b/src/measurement/uploadtask.cpp
new file mode 100644
index 0000000..bb22b1b
--- /dev/null
+++ b/src/measurement/uploadtask.cpp
@@ -0,0 +1,83 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "uploadtask.h"
+#include <vector>
+
+UploadTask::UploadTask(const std::string &ticket, const HttpHost &server,
+                       unsigned int no_conn, unsigned int max_conn,
+                       double duration, double max_time, double tick_s) :
+    ProgressTask("upload", ticket, server, no_conn, max_conn, duration, max_time),
+    tick_duration_s(tick_s>0 ? tick_s : 0.1) {
+}
+
+double UploadTask::start() {
+    log() << "UploadTask starting";
+    notifyStarted();
+    checkConnectionCount();
+    return tick_duration_s;
+}
+
+void UploadTask::newRequest(HttpClientConnection *conn) {
+    if (size_t to_write = loadSize()) {
+        conn->post("/cgi/upload.cgi?t=" + t() + "&id=1", to_write);
+        post_size[conn] = to_write;
+    } else {
+        conn->pass();
+    }
+}
+
+bool UploadTask::requestComplete(HttpClientConnection *conn) {
+    if (conn->httpStatus() == 200) {
+        // Now we know for sure that all posted data has arrived at the server
+        notifyBytesLoaded(post_size[conn]);
+    }
+    return true;
+}
+
+double UploadTask::timerEvent() {
+    double time = elapsed();
+
+    if (time >= timeout_s()) {
+        log() << "UploadTask timeout after " << time << " seconds";
+        setResult("-1");
+        return 0;
+    }
+
+    if (time > 0.05) {
+        // log() << "Check: " << byteCount() << " and " << threadSendCount();
+
+        // Note: byteCount() is the number of bytes we know for sure have
+        // arrived at the server, threadSendCount() is the number of bytes
+        // we've put into socket buffers. We have to be careful and use the
+        // lower value, i.e. byteCount(), which is too low, instead of the
+        // higher value, i.e. threadSendCount(), which is too large.
+        // However, the server knows the correct value and will send it to
+        // us regularly through the InfoTask.
+
+        double mbps = addOverheadMbps(byteCount(), time);
+        doTestProgress(mbps, time, currentNoConnections());
+    }
+
+    return tick_duration_s;
+}
+
+namespace {
+    std::vector<char> getUploadBuffer(size_t len) {
+        std::vector<char> buf;
+        // Fill the buffer with dummy data that cannot cause data compression
+        while (len) {
+            buf.push_back(static_cast<char>(rand()));
+            --len;
+        }
+        return buf;
+    }
+}
+
+size_t UploadTask::doPost(HttpClientConnection *conn, size_t len) {
+    static std::vector<char> buffer = getUploadBuffer(post_buffer_len);
+    size_t to_write = std::min(len, post_buffer_len);
+    return conn->sendData(buffer.data(), to_write);
+}
+
+const size_t UploadTask::post_buffer_len;
diff --git a/src/measurement/uploadtask.h b/src/measurement/uploadtask.h
new file mode 100644
index 0000000..b54b44f
--- /dev/null
+++ b/src/measurement/uploadtask.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "progresstask.h"
+
+class UploadTask : public ProgressTask {
+public:
+    UploadTask(const std::string &ticket, const HttpHost &server,
+               unsigned int no_conn = 4, unsigned int max_conn = 20,
+               double duration = 10.0, double max_time = 25.0,
+               double tick_s = 0.1);
+    double start() override;
+    double timerEvent() override;
+    void newRequest(HttpClientConnection *conn) override;
+    bool requestComplete(HttpClientConnection *conn) override;
+    size_t doPost(HttpClientConnection *conn, size_t len) override;
+private:
+    double tick_duration_s;
+    static const size_t post_buffer_len = 131072;
+    std::map<HttpClientConnection *, size_t> post_size;
+};
diff --git a/src/measurement/warmuptask.cpp b/src/measurement/warmuptask.cpp
new file mode 100644
index 0000000..afbcb0f
--- /dev/null
+++ b/src/measurement/warmuptask.cpp
@@ -0,0 +1,9 @@
+#include "warmuptask.h"
+
+void WarmUpTask::newRequest(HttpClientConnection *conn) {
+    conn->get(url);
+}
+
+bool WarmUpTask::requestComplete(HttpClientConnection *) {
+    return false;
+}
diff --git a/src/measurement/warmuptask.h b/src/measurement/warmuptask.h
new file mode 100644
index 0000000..2fb8e74
--- /dev/null
+++ b/src/measurement/warmuptask.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "measurementtask.h"
+
+class WarmUpTask : public MeasurementTask {
+public:
+    WarmUpTask(const std::string &ticket, const HttpHost &server,
+               unsigned int no_conn, double timeout) :
+        MeasurementTask("warmup", ticket, server, no_conn, no_conn, timeout),
+        url("/pingpong/warmup?t=" + ticket) {
+    }
+    void newRequest(HttpClientConnection *conn) override;
+    bool requestComplete(HttpClientConnection *conn) override;
+private:
+    std::string url;
+};
diff --git a/src/measurement/wsdownloadtask.cpp b/src/measurement/wsdownloadtask.cpp
new file mode 100644
index 0000000..5f64a2a
--- /dev/null
+++ b/src/measurement/wsdownloadtask.cpp
@@ -0,0 +1,97 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "wsdownloadtask.h"
+
+WsDownloadTask::
+WsDownloadTask(const std::string &ticket, const HttpHost &server,
+               unsigned int no_conn, unsigned int max_conn,
+               double duration, double max_time,
+               double tick_s) :
+    ProgressTask("download", ticket, server, no_conn, max_conn, duration, max_time),
+    tick_duration_s(tick_s>0 ? tick_s : 0.1) {
+    dynamic_conn_limit = 0.5 * duration + 0.5;
+}
+
+double WsDownloadTask::start() {
+    log() << "WsDownloadTask starting";
+    checkConnectionCount();
+    return tick_duration_s;
+}
+
+double WsDownloadTask::timerEvent() {
+    double time = elapsed();
+
+    if (time >= timeout_s()) {
+        log() << "WsDownloadTask timeout after " << time << " seconds";
+        setResult("-1");
+        return 0;
+    }
+
+    if (time > 0.05) {
+        double speed = addOverheadMbps(byteCount(), time);
+        if (time < dynamic_conn_limit && speed >= 50.0) {
+            unsigned int no_conn = (speed < 250.0) ?
+                ((speed < 100) ? 12 : 24) :
+                ((speed < 500) ? 32 : 48);
+            if (no_conn < currentNoConnections())
+                no_conn = currentNoConnections();
+            doTestProgress(speed, time, no_conn);
+            setNoConnections(no_conn);
+        } else {
+            doTestProgress(speed, time, currentNoConnections());
+        }
+    }
+    return tick_duration_s;
+}
+
+void WsDownloadTask::newRequest(HttpClientConnection *conn) {
+        conn->ws_get("/ws?t=" + t());
+        //conn->dbgOn();
+}
+
+#include <unistd.h>
+bool WsDownloadTask::nextRequest(HttpConnection *conn) {
+    if (size_t size = loadSize()) {
+        conn->sendWsMessage("download " + std::to_string(size));
+        //log() << "nextRequest " << size;
+        return true;
+    } else if (soonFinished()) {
+        log() << "nextRequest no more";
+        return false;
+    } else {
+        log() << "nextRequest idle";
+        // Keep the connection but don't make a new request at this point.
+        // Perhaps due to a speed limit.
+        //conn->pass();
+        return true;
+    }
+}
+
+bool WsDownloadTask::requestComplete(HttpClientConnection *) {
+    return false;
+}
+
+bool WsDownloadTask::websocketUpgrade(HttpClientConnection *conn) {
+    return nextRequest(conn);
+}
+
+bool WsDownloadTask::wsBinMessage(HttpConnection *conn,
+                                  const std::string &msg) {
+    log() << "Got BIN: " << msg.size();
+    notifyBytesLoaded(msg.size());
+    return nextRequest(conn);
+}
+
+bool WsDownloadTask::wsBinData(HttpConnection *conn, const char *, size_t count) {
+    notifyBytesLoaded(count);
+    if (conn->wsIncomingBytesLeft())
+        return true;
+    return nextRequest(conn);
+}
+
+bool WsDownloadTask::wsTextMessage(HttpConnection *,
+                                   const std::string &msg) {
+    log() << "Unexpected ws text message: " << msg;
+    return false;
+}
diff --git a/src/measurement/wsdownloadtask.h b/src/measurement/wsdownloadtask.h
new file mode 100644
index 0000000..7a6d0ab
--- /dev/null
+++ b/src/measurement/wsdownloadtask.h
@@ -0,0 +1,32 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include "progresstask.h"
+
+class WsDownloadTask : public ProgressTask {
+public:
+    WsDownloadTask(const std::string &ticket, const HttpHost &server,
+                   unsigned int no_conn = 10, unsigned int max_conn = 100,
+                   double duration = 10.0, double max_time = 25.0,
+                   double tick_s = 0.1);
+    double start() override;
+    double timerEvent() override;
+    void newRequest(HttpClientConnection *) override;
+    bool requestComplete(HttpClientConnection *) override;
+    bool websocketUpgrade(HttpClientConnection *) override;
+    bool wsBinMessage(HttpConnection *conn,
+                       const std::string &msg) override;
+    bool wsTextMessage(HttpConnection *conn,
+                       const std::string &msg) override;
+    bool wsBinHeader(HttpConnection *conn, size_t ) override {
+        conn->streamWsResponse();
+        return true;
+    }
+    bool wsBinData(HttpConnection *conn, const char *, size_t count) override;
+private:
+    bool nextRequest(HttpConnection *conn);
+    double tick_duration_s;
+    double dynamic_conn_limit;
+};
diff --git a/src/measurement/wsuploadtask.cpp b/src/measurement/wsuploadtask.cpp
new file mode 100644
index 0000000..b093e62
--- /dev/null
+++ b/src/measurement/wsuploadtask.cpp
@@ -0,0 +1,93 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#include "wsuploadtask.h"
+#include <vector>
+
+WsUploadTask::WsUploadTask(const std::string &ticket, const HttpHost &server,
+                       unsigned int no_conn, unsigned int max_conn,
+                       double duration, double max_time, double tick_s) :
+    ProgressTask("upload", ticket, server, no_conn, max_conn, duration, max_time),
+    tick_duration_s(tick_s>0 ? tick_s : 0.1) {
+}
+
+double WsUploadTask::start() {
+    log() << "WsUploadTask starting";
+    checkConnectionCount();
+    return tick_duration_s;
+}
+
+void WsUploadTask::newRequest(HttpClientConnection *conn) {
+    // conn->dbgOn();
+    conn->ws_get("/ws?t=" + t());
+}
+
+namespace {
+    std::vector<char> getUploadBuffer(size_t len) {
+        std::vector<char> buf;
+        // Fill the buffer with dummy data that cannot cause data compression
+        while (len) {
+            buf.push_back(static_cast<char>(rand()));
+            --len;
+        }
+        return buf;
+    }
+}
+
+bool WsUploadTask::nextRequest(HttpConnection *conn) {
+    size_t len = loadSize();
+    if (!len)
+        return false;
+    conn->startWsBinStream(len);
+    return true;
+}
+
+size_t WsUploadTask::sendWsData(HttpConnection *conn) {
+    static std::vector<char> buffer = getUploadBuffer(post_buffer_len);
+
+    size_t to_write = std::min(conn->wsOutgoingBytesLeft(), post_buffer_len);
+    //log() << "sendWsData " << to_write;
+    return conn->sendData(buffer.data(), to_write);
+}
+
+double WsUploadTask::timerEvent() {
+    double time = elapsed();
+
+    if (time >= timeout_s()) {
+        log() << "UploadTask timeout after " << time << " seconds";
+        setResult("-1");
+        return 0;
+    }
+
+    if (time > 0.05) {
+        double mbps = addOverheadMbps(byteCount(), time);
+        doTestProgress(mbps, time, currentNoConnections());
+    }
+
+    return tick_duration_s;
+}
+
+bool WsUploadTask::websocketUpgrade(HttpClientConnection *conn) {
+    return nextRequest(conn);
+}
+
+bool WsUploadTask::wsBinMessage(HttpConnection *,
+                                const std::string &msg) {
+    log() << "Unexpected ws bin message, size=" << msg.size();
+    return false;
+}
+
+bool WsUploadTask::wsTextMessage(HttpConnection *conn,
+                                 const std::string &msg) {
+    //log() << "WsUploadTask got ws text message: " << msg;
+    std::istringstream ss(msg);
+    std::string op;
+    size_t count;
+    if (ss >> op >> count && op == "upload") {
+        notifyBytesLoaded(count);
+        return nextRequest(conn);
+    }
+    return false;
+}
+
+const size_t WsUploadTask::post_buffer_len;
diff --git a/src/measurement/wsuploadtask.h b/src/measurement/wsuploadtask.h
new file mode 100644
index 0000000..0f43e2b
--- /dev/null
+++ b/src/measurement/wsuploadtask.h
@@ -0,0 +1,28 @@
+// Copyright (c) 2018 The Swedish Internet Foundation
+// Written by Göran Andersson <initgoran@gmail.com>
+
+#pragma once
+
+#include "progresstask.h"
+
+class WsUploadTask : public ProgressTask {
+public:
+    WsUploadTask(const std::string &ticket, const HttpHost &server,
+               unsigned int no_conn = 4, unsigned int max_conn = 20,
+               double duration = 10.0, double max_time = 25.0,
+               double tick_s = 0.1);
+    double start() override;
+    double timerEvent() override;
+    void newRequest(HttpClientConnection *conn) override;
+    bool websocketUpgrade(HttpClientConnection *conn) override;
+    bool wsBinMessage(HttpConnection *conn,
+                       const std::string &msg) override;
+    bool wsTextMessage(HttpConnection *conn,
+                       const std::string &msg) override;
+    size_t sendWsData(HttpConnection *conn) override;
+private:
+    bool nextRequest(HttpConnection *conn);
+    double tick_duration_s;
+    static const size_t post_buffer_len = 131072;
+    std::map<HttpClientConnection *, size_t> bytes_left_to_post, post_size;
+};
diff --git a/src/qt5gui/.gitignore b/src/qt5gui/.gitignore
new file mode 100644
index 0000000..8fe4cd2
--- /dev/null
+++ b/src/qt5gui/.gitignore
@@ -0,0 +1,3 @@
+.qmake.stash
+Makefile
+bredbandskollen
diff --git a/src/qt5gui/bredbandskollen.pro b/src/qt5gui/bredbandskollen.pro
new file mode 100644
index 0000000..c9b25c8
--- /dev/null
+++ b/src/qt5gui/bredbandskollen.pro
@@ -0,0 +1,89 @@
+QT          +=  webenginewidgets
+TARGET       =  bredbandskollen
+TEMPLATE     =  app
+QMAKE_CXXFLAGS += -std=c++11 -DBBK_WEBVIEW
+
+# To enable logging:
+QMAKE_CXXFLAGS += -DTASKRUNNER_LOGERR
+QMAKE_CXXFLAGS += -DTASKRUNNER_LOGWARN
+QMAKE_CXXFLAGS += -DTASKRUNNER_LOGINFO
+# QMAKE_CXXFLAGS += -DTASKRUNNER_LOGDBG
+
+SOURCES += main.cpp \
+        ../cli/utils.cpp \
+        ../measurement/defs.cpp \
+        ../framework/logger.cpp \
+	../framework/socket.cpp \
+	../framework/engine.cpp \
+	../framework/task.cpp \
+	../framework/taskconfig.cpp \
+	../framework/bridgetask.cpp \
+	../framework/socketconnection.cpp \
+	../framework/serversocket.cpp \
+	../framework/socketreceiver.cpp \
+	../framework/eventloop.cpp \
+	../http/httptask.cpp \
+	../http/httpconnection.cpp \
+        ../http/cookiemanager.cpp \
+        ../http/cookiefile.cpp \
+        ../http/websocketbridge.cpp \
+        ../http/sha1.cpp \
+        ../http/httpclienttask.cpp \
+        ../http/webservertask.cpp \
+        ../http/http_common.cpp \
+        ../http/httpclientconnection.cpp \
+        ../http/httpserverconnection.cpp \
+        ../http/singlerequest.cpp \
+	../json11/json11.cpp \
+	../measurement/measurementtask.cpp \
+	../measurement/singlerequesttask.cpp \
+	../measurement/infotask.cpp \
+	../measurement/latencytask.cpp \
+	../measurement/rpingtask.cpp \
+	../measurement/pingsweeptask.cpp \
+	../measurement/warmuptask.cpp \
+	../measurement/tickettask.cpp \
+	../measurement/progresstask.cpp \
+	../measurement/downloadtask.cpp \
+	../measurement/uploadtask.cpp \
+	../measurement/measurementagent.cpp \
+	../measurement/speedtest.cpp \
+	../measurement/uploadinfotask.cpp
+
+HEADERS += ../cli/utils.h \
+        ../measurement/defs.h \
+        ../framework/logger.h \
+	../framework/socket.h \
+	../framework/engine.h \
+	../framework/task.h \
+	../framework/taskconfig.h \
+	../framework/bridgetask.h \
+	../framework/socketconnection.h \
+	../framework/serversocket.h \
+	../framework/eventloop.h \
+	../http/httptask.h \
+	../http/httpconnection.h \
+	../http/cookiemanager.h \
+        ../http/cookiefile.h \
+        ../http/websocketbridge.h \
+        ../http/sha1.h \
+        ../http/httpclienttask.h \
+        ../http/webservertask.h \
+        ../http/http_common.h \
+        ../http/httpclientconnection.h \
+        ../http/httpserverconnection.h \
+	../json11/json11.hpp \
+	../measurement/measurementtask.h \
+	../measurement/singlerequesttask.h \
+	../measurement/infotask.h \
+	../measurement/latencytask.h \
+	../measurement/pingsweeptask.h \
+	../measurement/rpingtask.h \
+	../measurement/warmuptask.h \
+	../measurement/tickettask.h \
+	../measurement/progresstask.h \
+	../measurement/downloadtask.h \
+	../measurement/uploadtask.h \
+	../measurement/measurementagent.h \
+	../measurement/speedtest.h \
+	../measurement/uploadinfotask.h
diff --git a/src/qt5gui/main.cpp b/src/qt5gui/main.cpp
new file mode 100644
index 0000000..13c890d
--- /dev/null
+++ b/src/qt5gui/main.cpp
@@ -0,0 +1,67 @@
+#include <QApplication>
+#include <QWebEngineView>
+
+#include <fstream>
+#include <thread>
+#include <chrono>
+
+#include "../measurement/measurementagent.h"
+#include "../cli/utils.h"
+#include "../http/websocketbridge.h"
+
+namespace {
+
+    void runAgent(BridgeTask *bridge, const TaskConfig &cfg) {
+        CookieFile cf(cfg.value("config_file"));
+        HttpHost webserver(cfg.value("Measure.Webserver"), 80, "", 0, &cf);
+        EventLoop loop;
+        bridge->setAgent(new MeasurementAgent(cfg, webserver));
+        loop.addTask(bridge);
+        loop.runUntilComplete();
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    TaskConfig agent_cfg, config;
+    if (!parseArgs(argc, argv, config, agent_cfg))
+        return 1;
+    agent_cfg.set("Measure.AutoSaveReport", "true");
+    std::ofstream log_file;
+    if (config.value("logfile") != "-") {
+        log_file.open(config.value("logfile"));
+        Logger::setLogFile(log_file);
+    }
+
+    config.set("listen_pw", MeasurementAgent::createHashKey(12));
+    config.set("listen", "0");
+    config.set("listen_addr", "127.0.0.1");
+    config.set("browser",  "2");
+    agent_cfg.set("config_file", config.value("config_file"));
+
+    WebsocketBridge *bridge = new WebsocketBridge(nullptr, config);
+    std::thread agent_thread(runAgent, bridge, agent_cfg);
+
+    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
+    QApplication app(argc, argv);
+    QWebEngineView view;
+    view.resize(700, 950);
+    view.show();
+
+    // Wait for a few seconds for the agent to start listening on a port
+    for (unsigned int i = 0; bridge->url().empty() && i < 400; ++i)
+        std::this_thread::sleep_for(std::chrono::milliseconds(1+i/10));
+
+    int ret;
+    if (bridge->url().empty()) {
+        std::cerr << "cannot start measurement engine";
+        ret = 1;
+    } else {
+        view.setUrl(QUrl(bridge->url().c_str()));
+        ret = app.exec();
+    }
+
+    bridge->die();
+    agent_thread.join();
+    return ret;
+}
diff --git a/src/test/.gitignore b/src/test/.gitignore
new file mode 100644
index 0000000..fa04c8c
--- /dev/null
+++ b/src/test/.gitignore
@@ -0,0 +1,2 @@
+runtest
+log.txt
diff --git a/src/test/Makefile b/src/test/Makefile
new file mode 100644
index 0000000..65821fa
--- /dev/null
+++ b/src/test/Makefile
@@ -0,0 +1,11 @@
+SUBDIRS := task
+
+test: $(SUBDIRS)
+
+$(SUBDIRS):
+	$(MAKE) -C $@ clean
+	$(MAKE) -C $@ $(MAKECMDGOALS)
+
+clean all: $(SUBDIRS)
+
+.PHONY: subdirs $(SUBDIRS) clean all
diff --git a/src/test/README.md b/src/test/README.md
new file mode 100644
index 0000000..7e08142
--- /dev/null
+++ b/src/test/README.md
@@ -0,0 +1,14 @@
+# Unit tests
+
+To run all unit tests, do
+
+    make test
+
+To run the test cases for a single class, change to a subdirectory and do
+
+    make clean
+    make test
+
+The GoogleTest framework must be installed. On Ubuntu Linux, it can be installed using the command
+
+    sudo apt install libgtest-dev
diff --git a/src/test/task/Makefile b/src/test/task/Makefile
new file mode 100644
index 0000000..0d6bc8b
--- /dev/null
+++ b/src/test/task/Makefile
@@ -0,0 +1,21 @@
+TARGET = runtest
+DIRLEVEL = ../..
+LOGLEVEL = dbg
+GNUTLS = 0
+THREADS = 0
+CXXFLAGS += -g
+LIBS += -lgtest -lgtest_main
+
+SOURCES = task.cpp
+
+include $(DIRLEVEL)/framework/mk.inc
+
+test: all
+	./runtest
+
+clean: localclean
+
+localclean:
+	$(RM) log.txt
+
+.PHONY: test localclean
diff --git a/src/test/task/task.cpp b/src/test/task/task.cpp
new file mode 100644
index 0000000..bd1c629
--- /dev/null
+++ b/src/test/task/task.cpp
@@ -0,0 +1,76 @@
+#include <gtest/gtest.h>
+
+#include <framework/eventloop.h>
+#include <framework/task.h>
+
+namespace {
+
+    std::string global_string;
+
+    class BbkEnvironment : public ::testing::Environment {
+    public:
+	BbkEnvironment() : global_log("log.txt") {
+	}
+
+	void SetUp() override {
+	    Logger::setLogFile(global_log);
+	}
+    private:
+	std::ofstream global_log;
+    };
+
+    testing::Environment* const foo_env =
+	testing::AddGlobalTestEnvironment(new BbkEnvironment);
+
+    class Task1 : public Task {
+    public:
+	Task1(const std::string &name, const std::string &secret) :
+	    Task(name),
+	    start_secret(secret) {
+	}
+	double start() override {
+	    global_string = start_secret;
+	    setResult("Task1 done");
+	    return 0.0;
+	}
+    private:
+	std::string start_secret;
+    };
+
+    class Task2 : public Task {
+    public:
+	Task2(const std::string &secret) :
+	    Task("Task2"),
+	    timer_secret(secret) {
+	}
+	double start() override {
+	    return 1.0;
+	}
+	double timerEvent() override {
+	    global_string = timer_secret;
+	    setResult("Task2 done");
+	    return 0.0;
+	}
+    private:
+	std::string timer_secret;
+    };
+
+}
+
+TEST(TaskTest, start1) {
+    const std::string taskname = "test-start1";
+    const std::string secret = "secret-start1";
+    Task *t = new Task1(taskname, secret);
+    ASSERT_EQ(t->label(), taskname);
+    global_string.clear();
+    EventLoop::runTask(t);
+    ASSERT_EQ(global_string, secret);
+}
+
+TEST(TaskTest, timer1) {
+    const std::string secret = "secret-timer1";
+    Task *t = new Task2(secret);
+    global_string.clear();
+    EventLoop::runTask(t);
+    ASSERT_EQ(global_string, secret);
+}
diff --git a/src/wincli/targetver.h b/src/wincli/targetver.h
new file mode 100644
index 0000000..87c0086
--- /dev/null
+++ b/src/wincli/targetver.h
@@ -0,0 +1,8 @@
+#pragma once
+
+// Including SDKDDKVer.h defines the highest available Windows platform.
+
+// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
+// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
+
+#include <SDKDDKVer.h>
diff --git a/src/wincli/wincli.sln b/src/wincli/wincli.sln
new file mode 100644
index 0000000..868a53e
--- /dev/null
+++ b/src/wincli/wincli.sln
@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.13.35828.75 d17.13
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "wincli", "wincli.vcxproj", "{AFDCBCD7-E513-4D46-A468-C750B5A2FDE2}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{AFDCBCD7-E513-4D46-A468-C750B5A2FDE2}.Debug|x64.ActiveCfg = Release|Win32
+		{AFDCBCD7-E513-4D46-A468-C750B5A2FDE2}.Debug|x64.Build.0 = Release|Win32
+		{AFDCBCD7-E513-4D46-A468-C750B5A2FDE2}.Debug|x86.ActiveCfg = Debug|Win32
+		{AFDCBCD7-E513-4D46-A468-C750B5A2FDE2}.Debug|x86.Build.0 = Debug|Win32
+		{AFDCBCD7-E513-4D46-A468-C750B5A2FDE2}.Release|x64.ActiveCfg = Release|x64
+		{AFDCBCD7-E513-4D46-A468-C750B5A2FDE2}.Release|x64.Build.0 = Release|x64
+		{AFDCBCD7-E513-4D46-A468-C750B5A2FDE2}.Release|x86.ActiveCfg = Release|Win32
+		{AFDCBCD7-E513-4D46-A468-C750B5A2FDE2}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {8659D84F-6B61-43FD-A972-66510372892C}
+	EndGlobalSection
+EndGlobal
diff --git a/src/wincli/wincli.vcxproj b/src/wincli/wincli.vcxproj
new file mode 100644
index 0000000..2d8c946
--- /dev/null
+++ b/src/wincli/wincli.vcxproj
@@ -0,0 +1,252 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{AFDCBCD7-E513-4D46-A468-C750B5A2FDE2}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>wincli</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);..\bbk;</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+      <UndefinePreprocessorDefinitions>
+      </UndefinePreprocessorDefinitions>
+      <AdditionalIncludeDirectories>
+      </AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <Text Include="ReadMe.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\cli\cliclient.h" />
+    <ClInclude Include="..\cli\cookiemanager.h" />
+    <ClInclude Include="..\cli\utils.h" />
+    <ClInclude Include="..\framework\bridgetask.h" />
+    <ClInclude Include="..\framework\engine.h" />
+    <ClInclude Include="..\framework\eventloop.h" />
+    <ClInclude Include="..\framework\logger.h" />
+    <ClInclude Include="..\framework\pollstate.h" />
+    <ClInclude Include="..\framework\serversocket.h" />
+    <ClInclude Include="..\framework\socket.h" />
+    <ClInclude Include="..\framework\socketconnection.h" />
+    <ClInclude Include="..\framework\synchronousbridge.h" />
+    <ClInclude Include="..\framework\task.h" />
+    <ClInclude Include="..\framework\taskconfig.h" />
+    <ClInclude Include="..\http\cookiefile.h" />
+    <ClInclude Include="..\http\cookiemanager.h" />
+    <ClInclude Include="..\http\httpclientconnection.h" />
+    <ClInclude Include="..\http\httpclienttask.h" />
+    <ClInclude Include="..\http\httpconnection.h" />
+    <ClInclude Include="..\http\httphost.h" />
+    <ClInclude Include="..\http\httprequestengine.h" />
+    <ClInclude Include="..\http\httpserverconnection.h" />
+    <ClInclude Include="..\http\httptask.h" />
+    <ClInclude Include="..\http\http_common.h" />
+    <ClInclude Include="..\http\sha1.h" />
+    <ClInclude Include="..\http\singlerequest.h" />
+    <ClInclude Include="..\http\webservertask.h" />
+    <ClInclude Include="..\http\websocketbridge.h" />
+    <ClInclude Include="..\json11\json11.hpp" />
+    <ClInclude Include="..\measurement\defs.h" />
+    <ClInclude Include="..\measurement\downloadtask.h" />
+    <ClInclude Include="..\measurement\infotask.h" />
+    <ClInclude Include="..\measurement\latencytask.h" />
+    <ClInclude Include="..\measurement\measurementagent.h" />
+    <ClInclude Include="..\measurement\measurementtask.h" />
+    <ClInclude Include="..\measurement\pingsweeptask.h" />
+    <ClInclude Include="..\measurement\progresstask.h" />
+    <ClInclude Include="..\measurement\rpingtask.h" />
+    <ClInclude Include="..\measurement\singlerequesttask.h" />
+    <ClInclude Include="..\measurement\speedtest.h" />
+    <ClInclude Include="..\measurement\tickettask.h" />
+    <ClInclude Include="..\measurement\uploadinfotask.h" />
+    <ClInclude Include="..\measurement\uploadtask.h" />
+    <ClInclude Include="..\measurement\warmuptask.h" />
+    <ClInclude Include="resource.h" />
+    <ClInclude Include="targetver.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\cli\cliclient.cpp" />
+    <ClCompile Include="..\cli\main.cpp" />
+    <ClCompile Include="..\cli\utils.cpp" />
+    <ClCompile Include="..\framework\bridgetask.cpp" />
+    <ClCompile Include="..\framework\engine.cpp" />
+    <ClCompile Include="..\framework\eventloop.cpp" />
+    <ClCompile Include="..\framework\logger.cpp" />
+    <ClCompile Include="..\framework\serversocket.cpp" />
+    <ClCompile Include="..\framework\socket.cpp" />
+    <ClCompile Include="..\framework\socketconnection.cpp" />
+    <ClCompile Include="..\framework\synchronousbridge.cpp" />
+    <ClCompile Include="..\framework\task.cpp" />
+    <ClCompile Include="..\framework\taskconfig.cpp" />
+    <ClCompile Include="..\http\cookiefile.cpp" />
+    <ClCompile Include="..\http\cookiemanager.cpp" />
+    <ClCompile Include="..\http\httpclientconnection.cpp" />
+    <ClCompile Include="..\http\httpclienttask.cpp" />
+    <ClCompile Include="..\http\httpconnection.cpp" />
+    <ClCompile Include="..\http\httprequestengine.cpp" />
+    <ClCompile Include="..\http\httpserverconnection.cpp" />
+    <ClCompile Include="..\http\httptask.cpp" />
+    <ClCompile Include="..\http\http_common.cpp" />
+    <ClCompile Include="..\http\sha1.cpp" />
+    <ClCompile Include="..\http\singlerequest.cpp" />
+    <ClCompile Include="..\http\webservertask.cpp" />
+    <ClCompile Include="..\http\websocketbridge.cpp" />
+    <ClCompile Include="..\json11\json11.cpp" />
+    <ClCompile Include="..\measurement\defs.cpp" />
+    <ClCompile Include="..\measurement\downloadtask.cpp" />
+    <ClCompile Include="..\measurement\infotask.cpp" />
+    <ClCompile Include="..\measurement\latencytask.cpp" />
+    <ClCompile Include="..\measurement\measurementagent.cpp" />
+    <ClCompile Include="..\measurement\measurementtask.cpp" />
+    <ClCompile Include="..\measurement\pingsweeptask.cpp" />
+    <ClCompile Include="..\measurement\progresstask.cpp" />
+    <ClCompile Include="..\measurement\rpingtask.cpp" />
+    <ClCompile Include="..\measurement\singlerequesttask.cpp" />
+    <ClCompile Include="..\measurement\speedtest.cpp" />
+    <ClCompile Include="..\measurement\tickettask.cpp" />
+    <ClCompile Include="..\measurement\uploadinfotask.cpp" />
+    <ClCompile Include="..\measurement\uploadtask.cpp" />
+    <ClCompile Include="..\measurement\warmuptask.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file