diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..d9a3f85
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,69 @@
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled headers
+*.gch
+*.pch
+
+# Libraries
+*.a
+*.lib
+*.la
+*.lo
+
+# Shared objects
+*.so
+*.dll
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.com
+*.app
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Vi/Vim
+*.vim
+
+# Emacs
+*~
+\#*\#
+.\#*
+
+# VS Code
+.vscode/
+
+# vi
+[._]*.s[a-v][a-z]
+[._]*.sw[a-p]
+[._]s[a-rt-v][a-z]
+[._]ss[a-gi-z]
+[._]sw[a-p]
+
+# macOS/Windows
+*.DS_Store
+._*
+Thumbs.db
+*.lnk
+
+# Files specific to this project
+student/results.txt
+student/tests
+
diff --git a/.travis.yml b/.travis.yml
index fadcc52..8375967 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,6 +1,18 @@
-language: c
+language: python
+
+python:
+- '3.6'
+
+services:
+- mongodb
+- docker
 
 before_install:
 - sudo apt-get install libcunit1 libcunit1-dev
+- pip3 install git+https://github.com/Maxmawt/INGInious # Until UCL-INGI/INGInious has fixed his part ;-)
+- docker pull ingi/inginious-c-base
+- docker pull ingi/inginious-c-default
+- docker pull ingi/inginious-c-cpp
+- docker pull ingi/inginious-c-pyjavacpp
 
 script: ci/run_ci
diff --git a/ci/courses/LSINF1252 b/ci/courses/LSINF1252
new file mode 100755
index 0000000..f74eea6
--- /dev/null
+++ b/ci/courses/LSINF1252
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+# Assume we're in the correct directory
+
+case $1 in
+	init)
+		echo "Git clone"
+        git clone https://github.com/UCL-INGI/LSINF1252.git
+		;;
+	before_autotest)
+		echo "Before autotest"
+		# Patch the advanced_queue task's run file
+		sed -i '/ret = run/i \ \ \ \ subprocess.run(shlex.split("sed -i '"'"'s|\\$(sort \\$(wildcard \\*\\.c))|$(wildcard *.c)|'"'"' student/Makefile"))' advanced_queue/run && echo -e 'Patched advanced_queue'
+#		cp $2/LSINF1252_advanced_queue_run ./advanced_queue/run
+		# Patch the three tasks with test submissions to remove the
+		# "no-use-fifty" option
+		for i in advanced_queue order_relation_linked_list strcpy;
+		do
+			sed -i 's/--no-use-fifty//' $i/run && echo -e 'Patched' $i
+		done
+		;;
+esac
+
+# That's all
+
diff --git a/ci/run_ci b/ci/run_ci
index 0df5267..4482025 100755
--- a/ci/run_ci
+++ b/ci/run_ci
@@ -1,7 +1,8 @@
 #!/bin/bash
 
-declare -a tests=("test-simple-success" "test-simple-fail")
-cd "$(dirname "$0")"
+_term() {
+    kill -TERM "$child" 2>/dev/null
+}
 
 exec_test() {
     mkdir env/
@@ -11,22 +12,24 @@ exec_test() {
     pushd env
 
     make
-    echo "### $1: executing ..."
-    ./tests
+    echo -e "##### $1: executing ...\n"
+    ./tests &
+    child=$!
+    wait "$child"
 
     if [ -f ./results.txt ]; then
         cmp --silent results.txt expected_results.txt
         if [ $? -eq 0 ]; then
-            echo '###' $1 ': OK'
+            echo -e "\n#####" $1 ": OK"
             pushd
             rm -rf env
             return 1
         else
-            echo '###' $1 ': results.txt diverges from the expected output:'
+            echo -e "\n#####" $1 ": results.txt diverges from the expected output:"
             diff results.txt expected_results.txt
         fi
     else
-        echo '###' $1 ': CTester did not create a results.txt file'
+        echo -e "\n#####" $1 ": CTester did not create a results.txt file"
     fi
 
     popd
@@ -34,23 +37,66 @@ exec_test() {
     return 0
 }
 
+cd "$(dirname "$0")"
+
+trap _term SIGTERM
+
+if [ "$#" -eq "1" ]; then
+    # Execute only the specified test
+    echo -e "##### Executing test" $1
+    exec_test $1
+    if [ $? -eq '1' ]; then
+        echo -e "##### Successful test"
+        exit 0
+    else
+        exit 1
+    fi
+fi
+
+declare -a tests=()
+while IFS= read -r -d $'\0'; do
+    tests+=("$REPLY")
+done < <(find . ! -path "." -type d ! -name "courses" -print0)
 
-echo '### Executing tests'
+if ((${#tests[@]} == 0)); then
+    echo -e "No tests found!" >&2
+    exit 1
+fi
+
+echo -e "Found following tests: " ${tests[@]}
+
+echo -e "##### Executing tests"
 tests_ok=0
 
 for i in "${tests[@]}"
 do
-    echo '##########' $i
+    echo -e "\n####################" $i
     exec_test $i
     if [ $? -eq '1' ]; then
         tests_ok=$((tests_ok+1))
     fi
-
+    echo -e "####################"
 done
 
-echo '###' $tests_ok '/' ${#tests[@]} 'tests succeeded'
+echo -e "\n####################"
+echo -e "### End of tests ###"
+echo -e "####################"
+echo -e "#####" $tests_ok "/" ${#tests[@]} "tests succeeded"
 if ((tests_ok != ${#tests[@]})); then
-    exit 1
+    exitval=1
 else
-    exit 0
+    exitval=0
+fi
+
+
+echo -e "\n####################"
+echo -e "## Testing courses #"
+echo -e "####################"
+
+./run_course
+
+if (($? == 0)); then
+    exit $exitval
+else
+    exit 1
 fi
diff --git a/ci/run_course b/ci/run_course
new file mode 100755
index 0000000..5922773
--- /dev/null
+++ b/ci/run_course
@@ -0,0 +1,232 @@
+#!/bin/bash
+
+# ADDING MORE COURSE TO THE TESTS
+# Simply put a script with the course name inside the ci/courses/ folder.
+# Note that after running this script, this test script expects the course
+# to have the same name as the folder in which it is located; you should
+# change the folder name to match the course name if it is not the case.
+# Also, it is recommanded that no task matches the course name ;-)
+# If a task uses a full custom version of CTester, put a file named
+#     no_ctester_test
+# inside the task. This test script will not modify anything inside of this task.
+# This test script updates the CTester files in the following way:
+# - If the full CTester is present (run.py, student/Makefile, student/CTester),
+#   removes all to let the task use the common one, and updates the run file.
+# - If the CTester folder is present, but one of the other two is missing,
+#   updates the run file.
+# - If no CTester folder is present, then if the run file contains allusions
+#   to CTester, it will be replaced.
+# The script will be called at various time in the process:
+# - init: at the start. Should download/install the course, perform some modifs.
+#   It happens moments before we copy the course, create test folders, and call
+#   the first inginious-autotest.
+# - before_autotest: This is just after we've replaced CTester, and before
+#   we call inginious-autotest for the second time. Perform there any patching.
+#   Note: we're located in the course folder. The second parameter is the "ci"
+#   folder. Note: you can also use it to restore some tasks, if this script
+#   messed up.
+
+_term() {
+    kill -TERM "$child" 2>/dev/null
+}
+
+prepare_course() {
+    if [ "$2" == "mkdir" ]; then
+        domkdir='-true'
+    else
+        domkdir='-false'
+    fi
+    test -f $1 && echo "WARNING: found a task with the same name as the course" >&2
+    mkdir $1
+    find . -type d ! -path "*/$1/*" -exec test -f {}/task.yaml \; \
+        -print \
+        \( \( $domkdir -exec mkdir {}/test \; \) -o -true \) \
+        -exec cp -r {} $1/$(basename {}) \;
+    find . -name "course.yml" -o -name "course.yaml" -print -exec cp {} $1/{} \; -quit
+}
+
+exec_course() {
+    # $1: name of course, should match the folder name
+    mkdir env
+    pushd env
+    # We're in CTester/ci/env
+    # Call course script, so that it downloads itself
+    # Note: this script should also tweak the tasks that use a full custom version of CTester,
+    # by adding a ".no_ctester_test" file in the top directory
+    echo -e "Initializing folder using custom script"
+    ../courses/$1 init
+    echo -e "Done initializing"
+    mv $1 _$1
+    pushd _$1
+    # We're in CTester/ci/env/_<course_name>
+
+    # Test the course in its default configuration:
+    # if it fails, skip the new CTester, as we don't want to check errors
+    # that don't come from us.
+    echo -e "Preparing course"
+    prepare_course $1 mkdir
+
+    echo -e "First autotest, testing if course is OK"
+    inginious-autotest . $1 -l
+    if [ $? -ne '0' ]; then
+        echo -e "Course is already failing; skipping it"
+        popd
+        popd
+        rm -rf env
+        retval=1
+        return $retval
+    fi
+
+    echo -e "Preparing course for second run"
+    # Cleanup
+    rm -r $1
+    prepare_course $1 nomkdir
+
+    echo -e "Creating local copy of CTester"
+    mkdir -p CTester/student
+    cp -r ../../../run ../../../run.py CTester/
+    cp -r ../../../student/Makefile ../../../student/CTester CTester/student/
+
+    echo -e "Patching local copy of CTester"
+    # Patch the Makefile to be less strict
+    sed -i 's/-Wshadow// ; s/-Wextra//' CTester/student/Makefile
+    # Remove the "sort" as it causes bugs in the current version. NOTE: moved to custom
+    # Patch the run file to be less strict too. NOTE: moved to custom
+
+    pushd $1
+    # We're in CTester/ci/env/_<course_name>/<course_name>
+    # CTester's root is at ../../../../
+    # Our patched copy is at ../CTester/
+
+    echo -e "Replacing CTester in each valid task"
+    # Remove $common/CTester and $common/student/CTester, as we don't need them.
+    rm -rf \$common/CTester
+    rm -rf \$common/student/CTester
+    # Find and replace all versions of CTester in each task
+    # Only replace CTester if it's fully there.
+    # If a task only has two of either student/CTester/, student/Makefile,
+    # or run.py, do not replace (by deleting), as CTester allows to provide
+    # custom versions of these files;
+    # the new copy of CTester will be provided upon run.
+
+    # Tasks with none of the three use the default CTester, or no CTester at all:
+    # replace only the run file.
+    # Tasks with only one or two of the three probably use CTester,
+    # with custom modifications: replace only the run file
+    # If there is a CTester folder, then it is surely CTester
+    find . -name "student" -type d \
+        ! -path "*/\$common/*" \
+        -exec test ! -f {}/../no_ctester_test \; \
+        -exec test -d {}/CTester \; \
+        \( \( -exec cp ../CTester/run {}/../run \; -printf "%p:\t\tUpdated folder, case 1\n" \) \
+        -o -printf "%p:\t\tFAILED updating folder, case 1\n" \)
+    # If there is no CTester folder, then the presence of a run file
+    # or a Makefile doesn't guarantee that it uses CTester.
+    # So we check the content of the run file
+    find . -name "run" \
+        \( -exec grep -iq "CTester" {} \; -o -exec grep -iq "BAN_FUNC" {} \; \) \
+        -execdir test ! -f no_ctester_test \; \
+        \( \( -exec cp ../CTester/run {} \; -printf "%p:\t\tUpdated folder, case 2\n" \) \
+        -o -printf "%p:\t\tFAILED updating folder, case 2\n" \)
+
+    # Tasks with all three use a local CTester: we can test this by overwriting all files with the new ones
+    find . -name "student" \
+        ! -path "*/\$common/*" \
+        -exec test -f {}/Makefile \; \
+        -exec test -d {}/CTester \; \
+        -exec test ! -f {}/../no_ctester_test \; \
+        \( \( -exec rm -f {}/../run.py {}/Makefile \; \
+        -exec rm -r {}/CTester \; \
+        -printf "%p:\t\tUpdated folder, case 3\n" \) \
+        -o -printf "%p:\t\tFAILED updating folder, case 3\n" \)
+    # No need to copy the run file, it has been taken care of before
+    # It also remove the CTester folder, so we completely replace it.
+    # Note: for backward compatibility reasons, we don't check if the task
+    # contains run.py; the following lines were removed.
+#        -exec test -f {}/../run.py \; \
+#        -printf "%p: OK1 " \
+
+    # Put CTester into common
+    mkdir -p \$common/CTester/student/ || true
+    cp ../CTester/run ../CTester/run.py \$common/CTester/
+    cp ../CTester/student/Makefile \$common/CTester/student/
+    cp -r ../CTester/student/CTester \$common/CTester/student/
+
+    echo -e "Calling custom script before autotest, and after replacing CTester"
+    ../../../courses/$1 before_autotest
+
+    popd
+    # We're in CTester/ci/env/_<course_name>
+
+    echo -e "Second run of inginious-autotest"
+    sleep 5
+    inginious-autotest . $1 -l
+    if [ $? -eq 0 ]; then
+        echo -e "\n#####" $1 ": OK"
+        retval=1
+    else
+        echo -e "\n#####" $1 ": course test failed"
+        retval=0
+    fi
+
+    popd
+    popd
+    # We're in CTester/ci
+    rm -rf env
+    return $retval
+}
+
+cd "$(dirname "$0")"
+
+rm -rf env/
+
+trap _term SIGTERM
+
+if [ "$#" -eq "1" ]; then
+    echo -e "##### Executing test of course" $1
+    exec_course $1
+    if [ $? -eq '1' ]; then
+        echo -e "##### Successfully tested course"
+        exit 0
+    else
+        echo -e "##### Failed testing course"
+        exit 1
+    fi
+fi
+
+shopt -s nullglob
+pushd courses
+declare -a courses=(*)
+popd
+shopt -u nullglob
+
+if ((${#courses[@]} == 0)); then
+    echo -e "No courses found! Skip testing"
+    exit 0
+fi
+
+echo -e "Found following courses: " ${courses[@]}
+
+echo -e "##### Executing tests of courses"
+courses_ok=0
+
+for i in "${courses[@]}"
+do
+    echo -e "\n####################" $i
+    exec_course $i
+    if [ $? -eq '1' ]; then
+        courses_ok=$((courses_ok+1))
+    fi
+    echo -e "####################"
+done
+
+echo -e "\n################################"
+echo -e "### End of tests for courses ###"
+echo -e "################################"
+echo -e "#####" $courses_ok "/" ${#courses[@]} "courses succeeded"
+if ((courses_ok != ${#courses[@]})); then
+    exit 1
+else
+    exit 0
+fi
+
diff --git a/ci/test_network_dns/expected_results.txt b/ci/test_network_dns/expected_results.txt
new file mode 100644
index 0000000..d05ee31
--- /dev/null
+++ b/ci/test_network_dns/expected_results.txt
@@ -0,0 +1,3 @@
+substitute_gai#SUCCESS#Test if the substitution functions etc work correctly#1#
+checked_freeaddrinfo#SUCCESS#Tests the checked freeaddrinfo#1#
+simple_gai_fai#SUCCESS#Tests simple_gai and simple_fai#1#
diff --git a/ci/test_network_dns/student_code.c b/ci/test_network_dns/student_code.c
new file mode 100644
index 0000000..2a60980
--- /dev/null
+++ b/ci/test_network_dns/student_code.c
@@ -0,0 +1,215 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <errno.h>
+
+#include "student_code.h"
+
+/**
+ * This is the simple example from the BeeJ guide.
+ */
+void run_student_tests_wrapper_stats_1(struct f1_stats *stats)
+{
+	memset(stats, 0, sizeof(*stats));
+	struct addrinfo hints, *rep, *rp;
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = AF_UNSPEC;
+	hints.ai_socktype = SOCK_DGRAM;
+	hints.ai_flags = 0;
+	hints.ai_protocol = 0;
+	int s = getaddrinfo("inginious.info.ucl.ac.be", "443", &hints, &rep);
+	if (s != 0) {
+		fprintf(stderr, "%s\n", gai_strerror(s));
+		return;
+	}
+	stats->getaddrinfo_success = true;
+	int sfd = -1;
+	for (rp = rep; rp != NULL; rp = rp->ai_next) {
+		stats->nb_addr_tried++;
+		sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+		if (sfd == -1) {
+			perror("socket");
+			continue;
+		}
+		stats->nb_connect++;
+		if (connect(sfd, rp->ai_addr, rp->ai_addrlen) == 0)
+			break;
+		perror("connect");
+		close(sfd);
+		sfd = -1;
+	}
+	freeaddrinfo(rep);
+	if (sfd != -1) {
+		char coucou[] = "coucou";
+		ssize_t nsent;
+		do {
+			nsent = send(sfd, coucou, sizeof(coucou), 0);
+			stats->nb_send++;
+			if (nsent != -1) {
+				stats->nb_bytes += nsent;
+			} else {
+				perror("send");
+			}
+			if (nsent != sizeof(coucou)) {
+				break;
+			}
+		} while (nsent != -1 && stats->nb_bytes < 42);
+	}
+}
+
+/*
+ * The following two codes are adapted from the Linux man pages
+ * for getaddrinfo
+ */
+void run_student_tests_wrapper_stats_2_client(struct stats2_client *stats)
+{
+	errno = 0;
+	memset(stats, 0, sizeof(*stats));
+	struct addrinfo hints, *rep, *rp;
+	int sfd = -1, s;
+	ssize_t nread;
+	char buf[500];
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = AF_INET;
+	hints.ai_socktype = SOCK_DGRAM;
+	hints.ai_protocol = 0;
+	hints.ai_flags = 0;
+	s = getaddrinfo(NULL, "1618", &hints, &rep);
+	stats->ngai = 1;
+	if (s == -1) {
+		fprintf(stderr, "%s\n", gai_strerror(s));
+		return;
+	}
+	for (rp = rep; rp != NULL; rp = rp->ai_next) {
+		sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+		stats->nsocket++;
+		if (sfd == -1) {
+			perror("socket");
+			continue;
+		}
+		if (connect(sfd, rp->ai_addr, rp->ai_addrlen) == 0) {
+			stats->nconnect++;
+			break;
+		}
+		perror("connect");
+		stats->nconnect++;
+		close(sfd);
+		sfd = -1;
+	}
+	if (rp == NULL || sfd == -1)
+		return;
+	freeaddrinfo(rep);
+	char *words[3];
+	words[0] = "coucou";
+	words[1] = "salut";
+	words[2] = "STOP";
+	for (int i = 0; i < 3; i++) {
+		// Send the three messages
+		int len = strlen(words[i]) + 1;
+		// Let's use a struct msghdr to see if it works
+		struct msghdr msg;
+		msg.msg_name = NULL;
+		msg.msg_namelen = 0;
+		struct iovec msg_iov[1];
+		msg_iov[0].iov_base = words[i];
+		msg_iov[0].iov_len = len;
+		msg.msg_iov = msg_iov;
+		msg.msg_iovlen = 1;
+		msg.msg_control = NULL;
+		msg.msg_controllen = 0;
+		msg.msg_flags = 0;
+		ssize_t nsent = sendmsg(sfd, &msg, 0);
+		if (nsent == -1)
+			perror("send");
+		stats->nsend++;
+		if (nsent != len) {
+			fprintf(stderr, "ACouldn't write\n");
+			continue;
+		}
+		// Let's read the data again
+		memset(buf, 0, sizeof(buf));
+		nread = recv(sfd, buf, 500, 0);
+		stats->nrecv++;
+		if (nread == -1) {
+			perror("Arecv");
+			continue;
+		}
+		if (strcmp(buf, words[i]) != 0) {
+			fprintf(stderr, "AMessage don't match\n");
+			continue;
+		}
+	}
+}
+
+void run_student_tests_wrapper_stats_2_server(struct stats2_server *stats)
+{
+	errno = 0;
+	memset(stats, 0, sizeof(*stats));
+	struct addrinfo hints, *rep, *rp;
+	int sfd = -1, s;
+	struct sockaddr_storage peer_addr;
+	socklen_t peer_addrlen;
+	ssize_t nread;
+	char buf[500];
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = AF_INET;
+	hints.ai_socktype = SOCK_DGRAM;
+	hints.ai_protocol = 0;
+	hints.ai_flags = AI_PASSIVE;
+	s = getaddrinfo(NULL, "1618", &hints, &rep);
+	stats->ngai = 1;
+	if (s == -1) {
+		fprintf(stderr, "%s\n", gai_strerror(s));
+		return;
+	}
+	for (rp = rep; rp != NULL; rp = rp->ai_next) {
+		sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+		stats->nsocket++;
+		if (sfd == -1) {
+			perror("Bsocket");
+			continue;
+		}
+		if (bind(sfd, rp->ai_addr, rp->ai_addrlen) == 0) {
+			stats->nbind++;
+			break;
+		}
+		perror("Bbind");
+		stats->nbind++;
+		close(sfd);
+		sfd = -1;
+	}
+	if (rp == NULL || sfd == -1)
+		return;
+	freeaddrinfo(rep);
+	for (int failures = 0; failures < 10;) {
+		memset(buf, 0, sizeof(buf));
+		// Stops at the reception of "stop"
+		peer_addrlen = sizeof(peer_addr);
+		nread = recvfrom(sfd, buf, 500, 0, (struct sockaddr*) &peer_addr, &peer_addrlen);
+		stats->nrecvfrom++;
+		if (nread == -1)
+			perror("recvfrom");
+		if (nread == -1) {
+			failures++;
+			continue;
+		}
+		// Let's skip the printing here
+		ssize_t nsent = sendto(sfd, buf, nread, 0, (struct sockaddr*) &peer_addr, peer_addrlen);
+		stats->nsendto++;
+		if (nsent != nread) {
+			failures++;
+		}
+		if (nsent == -1) {
+			perror("Bsent");
+		}
+		if (strcmp(buf, "STOP") == 0) {
+			break;
+		}
+	}
+}
+
diff --git a/ci/test_network_dns/student_code.h b/ci/test_network_dns/student_code.h
new file mode 100644
index 0000000..342c2d1
--- /dev/null
+++ b/ci/test_network_dns/student_code.h
@@ -0,0 +1,31 @@
+#include <stdbool.h>
+struct f1_stats {
+	bool getaddrinfo_success;
+	int nb_addr_tried;
+	int nb_connect;
+	int nb_send;
+	ssize_t nb_bytes;
+};
+struct stats2_server {
+	int ngai;
+	int nsocket;
+	int nbind;
+	int nrecvfrom;
+	int nsendto;
+};
+struct stats2_client {
+	int ngai;
+	int nsocket;
+	int nconnect;
+	int nsend;
+	int nrecv;
+};
+
+void run_student_tests_wrapper_stats_1(struct f1_stats *stats);
+
+void run_student_tests_wrapper_stats_2_client(struct stats2_client *stats);
+
+void run_student_tests_wrapper_stats_2_server(struct stats2_server *stats);
+
+// void run_student_tests_wrapper_stats_3();
+
diff --git a/ci/test_network_dns/tests.c b/ci/test_network_dns/tests.c
new file mode 100644
index 0000000..16a11ea
--- /dev/null
+++ b/ci/test_network_dns/tests.c
@@ -0,0 +1,890 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/wait.h>
+#include <arpa/inet.h>
+
+#include "CTester/CTester.h"
+#include "student_code.h"
+
+int __real_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);
+int __real_getnameinfo(const struct sockaddr *addr, socklen_t addrlen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags);
+void __real_freeaddrinfo(struct addrinfo *res);
+const char *__real_gai_strerror(int errcode);
+
+const char gai1_cname[] = "CGAI1";
+const char gai2_cname[] = "CGAI2";
+struct custom_gai1_stats_t {
+	int called;
+	const char *node;
+	const char *serv;
+	const struct addrinfo *hints;
+	struct addrinfo **res;
+} custom_gai1_stats;
+int custom_gai1(const char *node, const char *serv, const struct addrinfo *hints, struct addrinfo **res)
+{
+	custom_gai1_stats.called++;
+	custom_gai1_stats.node = node;
+	custom_gai1_stats.serv = serv;
+	custom_gai1_stats.hints = hints;
+	custom_gai1_stats.res = res;
+	*res = calloc(1, sizeof(struct addrinfo));
+	(*res)->ai_family = AF_INET;
+	(*res)->ai_socktype = SOCK_DGRAM;
+	(*res)->ai_protocol = 0;
+	(*res)->ai_addrlen = 0;
+	(*res)->ai_addr = NULL;
+	(*res)->ai_canonname = NULL;
+	(*res)->ai_next = NULL;
+	if (node != NULL) {
+		return 0;
+	} else if (serv == NULL) {
+		return 1;
+	} else {
+		return 2;
+	}
+}
+
+struct custom_gai2_stats_t {
+	int called;
+	const char *node;
+	const char *serv;
+	const struct addrinfo *hints;
+	struct addrinfo **res;
+} custom_gai2_stats;
+int custom_gai2(const char *node, const char *serv, const struct addrinfo *hints, struct addrinfo **res)
+{
+	custom_gai2_stats.called++;
+	custom_gai2_stats.node = node;
+	custom_gai2_stats.serv = serv;
+	custom_gai2_stats.hints = hints;
+	custom_gai2_stats.res = res;
+	return __real_getaddrinfo(node, serv, hints, res);
+}
+
+struct custom_fai1_stats_t {
+	int called;
+	struct addrinfo *res;
+	struct addrinfo *no_free;
+} custom_fai1_stats;
+void custom_fai1(struct addrinfo *res)
+{
+	custom_fai1_stats.called++;
+	custom_fai1_stats.res = res;
+	if (custom_fai1_stats.no_free != res) {
+		free(res);
+	}
+}
+void custom_fai1_prevent_free(struct addrinfo *res)
+{
+	custom_fai1_stats.no_free = res;
+}
+
+struct custom_fai2_stats_t {
+	int called;
+	struct addrinfo *res;
+} custom_fai2_stats;
+void custom_fai2(struct addrinfo *res)
+{
+	custom_fai2_stats.called++;
+	custom_fai2_stats.res = res;
+	__real_freeaddrinfo(res);
+}
+
+struct custom_gni1_stats_t {
+	int called;
+	const struct sockaddr *addr;
+	socklen_t addrlen;
+	socklen_t hostlen;
+	socklen_t servlen;
+	int flags;
+	char *host;
+	char *serv;
+} custom_gni1_stats;
+int custom_gn1(const struct sockaddr *addr, socklen_t addrlen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags)
+{
+	custom_gni1_stats.called++;
+	custom_gni1_stats.addr = addr;
+	custom_gni1_stats.addrlen = addrlen;
+	custom_gni1_stats.host = host;
+	custom_gni1_stats.hostlen = hostlen;
+	custom_gni1_stats.serv = serv;
+	custom_gni1_stats.servlen = servlen;
+	custom_gni1_stats.flags = flags;
+	char *s1 = "Hello";
+	char *s2 = "world";
+	memcpy(host, s1, 6);
+	memcpy(serv, s2, 6);
+	return 0;
+}
+
+struct custom_gni2_stats_t {
+	int called;
+	const struct sockaddr *addr;
+	socklen_t addrlen;
+	socklen_t hostlen;
+	socklen_t servlen;
+	int flags;
+	char *host;
+	char *serv;
+} custom_gni2_stats;
+int custom_gn2(const struct sockaddr *addr, socklen_t addrlen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags)
+{
+	custom_gni2_stats.called++;
+	custom_gni2_stats.addr = addr;
+	custom_gni2_stats.addrlen = addrlen;
+	custom_gni2_stats.host = host;
+	custom_gni2_stats.hostlen = hostlen;
+	custom_gni2_stats.serv = serv;
+	custom_gni2_stats.servlen = servlen;
+	custom_gni2_stats.flags = flags;
+	return __real_getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags);
+}
+
+struct custom_fai_reporter_stats_t {
+	int called;
+} custom_fair_stats;
+void custom_checked_fai_reporter()
+{
+	custom_fair_stats.called++;
+}
+
+struct custom_gse1_stats_t {
+	int called;
+	int code;
+} custom_gse1_stats;
+const char *custom_gai_strerror1(int code)
+{
+	custom_gse1_stats.called++;
+	custom_gse1_stats.code = code;
+	char *s1 = "GSE1";
+	return s1;
+}
+
+struct custom_gse2_stats_t {
+	int called;
+	int code;
+} custom_gse2_stats;
+const char *custom_gai_strerror2(int code)
+{
+	custom_gse2_stats.called++;
+	custom_gse2_stats.code = code;
+	char *s2 = "GSE2";
+	return s2;
+}
+
+/*
+What to test:
+- set_gai works, as well as none (from none)
+- set_gais all, gai, fai, none (null) work
+- set_gai and then reset it works
+- set_gais and then reset both works
+- set_gni works, both set and reset
+- set_gai_strerror should work, as well as reset
+- checked freeaddrinfo should work: activate, pass a correct, pass an incorrect, deactivate, pass an incorrect
+- the reporter for the checked fai should also work, both set and reset.
+ */
+void test_gai_substitutes()
+{
+	set_test_metadata("substitute_gai", _("Test if the substitution functions etc work correctly"), 1);
+	reinit_all_monitored();
+	reinit_all_stats();
+	reset_gai_fai_gstr_gni_methods();
+	memset(&custom_gai1_stats, 0, sizeof(custom_gai1_stats));
+	memset(&custom_gai2_stats, 0, sizeof(custom_gai2_stats));
+	memset(&custom_fai1_stats, 0, sizeof(custom_fai1_stats));
+	memset(&custom_fai2_stats, 0, sizeof(custom_fai2_stats));
+	memset(&custom_gni1_stats, 0, sizeof(custom_gni1_stats));
+	memset(&custom_gni2_stats, 0, sizeof(custom_gni2_stats));
+	memset(&custom_fair_stats, 0, sizeof(custom_fair_stats));
+	memset(&custom_gse1_stats, 0, sizeof(custom_gse1_stats));
+	memset(&custom_gse2_stats, 0, sizeof(custom_gse2_stats));
+	set_check_freeaddrinfo(false); // Disable it for all tests
+
+	int i1=-1, i2=-1, i3=-1, i4=-1, i5=-1, i6=-1, i7=-1, i8=-1, i9=-1;
+	struct addrinfo hints1, *res1, *res2, *res3, *res4, *res5, *res6, *res7, *res8, *res9;
+	memset(&hints1, 0, sizeof(hints1));
+	hints1.ai_family = AF_INET;
+	hints1.ai_socktype = SOCK_DGRAM;
+	hints1.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV;
+	char h1[]="0.0.0.1", h2[]="0.0.0.2", h3[]="0.0.0.3", h4[]="0.0.0.4";
+	char h5[]="0.0.0.5", h6[]="0.0.0.6", h7[]="0.0.0.7", h8[]="0.0.0.8";
+	(void)h8;
+	(void)res8;
+	(void)res9;
+	(void)i9;
+	monitored.getaddrinfo = monitored.freeaddrinfo = false;
+	SANDBOX_BEGIN;
+	i1 = getaddrinfo(h1, "80", &hints1, &res1);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(i1, 0);
+	CU_ASSERT_PTR_NOT_NULL(res1);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 0); // Not enabled yet
+	SANDBOX_BEGIN;
+	freeaddrinfo(res1);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 0); // Not enabled yet
+	monitored.getaddrinfo = monitored.freeaddrinfo = true;
+	i1=-1;
+	res1 = NULL;
+	SANDBOX_BEGIN;
+	i1 = getaddrinfo(h2, "80", &hints1, &res1);
+	freeaddrinfo(res1);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 1);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.last_params.res, &res1);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.last_params.hints, &hints1);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.last_params.node, h2);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 1);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.last_param, res1);
+	// Now, let's set getaddrinfo to someone else
+	set_getaddrinfo_method(custom_gai2); // That's just a wrapper, compatible with __real_freeaddrinfo
+	SANDBOX_BEGIN;
+	i2 = getaddrinfo(h3, "80", &hints1, &res2);
+	freeaddrinfo(res2);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 2);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.last_params.node, h3);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.last_params.hints, &hints1);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.last_params.res, &res2);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 2);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.last_param, res2);
+	CU_ASSERT_EQUAL(custom_gai2_stats.called, 1);
+	CU_ASSERT_EQUAL(custom_gai2_stats.node, h3);
+	CU_ASSERT_EQUAL(custom_gai2_stats.res, &res2);
+	res2 = NULL;
+	CU_ASSERT_EQUAL(getaddrinfo(h3, "80", &hints1, &res2), 0);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 2); // No change
+	CU_ASSERT_EQUAL(custom_gai2_stats.called, 1); // Neither
+	set_getaddrinfo_method(NULL);
+	SANDBOX_BEGIN;
+	i3 = getaddrinfo(h4, "80", &hints1, &res3);
+	freeaddrinfo(res3);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 3);
+	CU_ASSERT_EQUAL(custom_gai2_stats.called, 1);
+	CU_ASSERT_EQUAL(custom_fai2_stats.called, 0);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 3);
+	set_gai_methods(custom_gai1, custom_fai1);
+	SANDBOX_BEGIN;
+	i4 = getaddrinfo(h5, "80", &hints1, &res4);
+	freeaddrinfo(res4);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(i4, 0);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 4);
+	CU_ASSERT_EQUAL(custom_gai1_stats.called, 1);
+	CU_ASSERT_EQUAL(custom_gai1_stats.node, h5);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 4);
+	CU_ASSERT_EQUAL(custom_fai1_stats.called, 1);
+	CU_ASSERT_EQUAL(custom_fai1_stats.res, res4);
+	CU_ASSERT_EQUAL(getaddrinfo(h4, "80", &hints1, &res3), 0);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 4);
+	CU_ASSERT_EQUAL(custom_gai1_stats.called, 1);
+	freeaddrinfo(res3);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 4);
+	CU_ASSERT_EQUAL(custom_fai1_stats.called, 1);
+	set_gai_methods(custom_gai2, custom_fai2);
+	SANDBOX_BEGIN;
+	i5 = getaddrinfo(h6, "80", &hints1, &res5);
+	freeaddrinfo(res5);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(i5, 0);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 5);
+	CU_ASSERT_EQUAL(custom_gai2_stats.called, 2);
+	CU_ASSERT_EQUAL(custom_fai2_stats.called, 1);
+	set_gai_methods(NULL, custom_fai2);
+	SANDBOX_BEGIN;
+	i6 = getaddrinfo(h5, "80", &hints1, &res6);
+	freeaddrinfo(res6);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(i6, 0);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 6);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 6);
+	CU_ASSERT_EQUAL(custom_gai2_stats.called, 2);
+	CU_ASSERT_EQUAL(custom_fai2_stats.called, 2);
+	set_gai_methods(custom_gai2, NULL);
+	i5=-1;
+	SANDBOX_BEGIN;
+	i5 = getaddrinfo(h6, "80", &hints1, &res5);
+	freeaddrinfo(res5);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(i5, 0);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 7);
+	CU_ASSERT_EQUAL(custom_gai2_stats.called, 3);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 7);
+	CU_ASSERT_EQUAL(custom_fai2_stats.called, 2);
+	set_gai_methods(custom_gai2, custom_fai2);
+	monitored.getaddrinfo = false;
+	monitored.freeaddrinfo = true;
+	SANDBOX_BEGIN;
+	i6 = getaddrinfo(h5, "80", &hints1, &res6);
+	freeaddrinfo(res6);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(i6, 0);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 7);
+	CU_ASSERT_EQUAL(custom_gai2_stats.called, 3);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 8);
+	CU_ASSERT_EQUAL(custom_fai2_stats.called, 3);
+	monitored.getaddrinfo = true;
+	monitored.freeaddrinfo = false;
+	SANDBOX_BEGIN;
+	i7 = getaddrinfo(h7, "80", &hints1, &res7);
+	freeaddrinfo(res7);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 8);
+	CU_ASSERT_EQUAL(custom_gai2_stats.called, 4);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 8);
+	CU_ASSERT_EQUAL(custom_fai2_stats.called, 3)	;
+	// TODO should also test that it doesn't do anything else
+
+	// Testing getnameinfo
+	CU_ASSERT_EQUAL(stats.getnameinfo.called, 0);
+	i1 = i2 = i3 = i4 = i5 = i6 = i7 = i8 = -1;
+	int flags = NI_NUMERICHOST;
+	struct sockaddr_in s1, s2, s3, s4;
+	memset(&s1, 0, sizeof(s1));
+	memset(&s2, 0, sizeof(s2));
+	memset(&s3, 0, sizeof(s3));
+	memset(&s4, 0, sizeof(s4));
+	s1.sin_family = s2.sin_family = s3.sin_family = s4.sin_family = AF_INET;
+	s1.sin_port = s2.sin_port = s3.sin_port = s4.sin_port = htons(80);
+	inet_pton(AF_INET, "0.0.0.1", &(s1.sin_addr));
+	inet_pton(AF_INET, "0.0.0.2", &(s2.sin_addr));
+	inet_pton(AF_INET, "0.0.0.3", &(s3.sin_addr));
+	inet_pton(AF_INET, "0.0.0.4", &(s4.sin_addr));
+	CU_ASSERT_EQUAL(s1.sin_addr.s_addr, htonl(1));
+	CU_ASSERT_EQUAL(s2.sin_addr.s_addr, htonl(2));
+	CU_ASSERT_EQUAL(s3.sin_addr.s_addr, htonl(3));
+	CU_ASSERT_EQUAL(s4.sin_addr.s_addr, htonl(4));
+	char rh1[10]={0}, rh2[10]={0}, rh3[10]={0}, rh4[10]={0};
+	char rs1[10]={0}, rs2[10]={0}, rs3[10]={0}, rs4[10]={0};
+	// Tests
+	i1 = getnameinfo((struct sockaddr*)&s1, sizeof(s1), rh1, sizeof(rh1), rs1, sizeof(rs1), flags);
+	CU_ASSERT_EQUAL(stats.getnameinfo.called, 0);
+	CU_ASSERT_EQUAL(strcmp(rh1, "0.0.0.1"), 0);
+	SANDBOX_BEGIN;
+	i2 = getnameinfo((struct sockaddr*)&s2, sizeof(s2), rh2, sizeof(rh2), rs2, sizeof(rs2), flags);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.getnameinfo.called, 0);
+	CU_ASSERT_EQUAL(strcmp(rh2, "0.0.0.2"), 0);
+	monitored.getnameinfo = true;
+	SANDBOX_BEGIN;
+	i3 = getnameinfo((struct sockaddr*)&s3, sizeof(s3), rh3, sizeof(rh3), rh4, sizeof(rh4), flags);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.getnameinfo.called, 1);
+	CU_ASSERT_EQUAL(strcmp(rh3, "0.0.0.3"), 0);
+	set_getnameinfo_method(custom_gn1);
+	CU_ASSERT_EQUAL(custom_gni1_stats.called, 0);
+	SANDBOX_BEGIN;
+	i4 = getnameinfo((struct sockaddr*)&s4, sizeof(s4), rh4, sizeof(rh4), rs4, sizeof(rs4), flags);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.getnameinfo.called, 2);
+	CU_ASSERT_EQUAL(custom_gni1_stats.called, 1);
+	CU_ASSERT_EQUAL(custom_gni1_stats.addr, &s4);
+	CU_ASSERT_EQUAL(strcmp(rh4, "Hello"), 0);
+	monitored.getnameinfo = false;
+	SANDBOX_BEGIN;
+	i5 = getnameinfo((struct sockaddr*)&s1, sizeof(s1), rh1, sizeof(rh1), rs1, sizeof(rs1), flags);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.getnameinfo.called, 2);
+	CU_ASSERT_EQUAL(custom_gni1_stats.called, 1);
+	CU_ASSERT_EQUAL(custom_gni1_stats.addr, &s4);
+	monitored.getnameinfo = true;
+	SANDBOX_BEGIN;
+	i6 = getnameinfo((struct sockaddr*)&s2, sizeof(s2), rh2, sizeof(rh2), rs2, sizeof(rs2), flags);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.getnameinfo.called, 3);
+	CU_ASSERT_EQUAL(stats.getnameinfo.last_params.addr, &s2);
+	CU_ASSERT_EQUAL(custom_gni1_stats.called, 2);
+	CU_ASSERT_EQUAL(custom_gni1_stats.addr, &s2);
+	set_getnameinfo_method(NULL);
+	SANDBOX_BEGIN;
+	i7 = getnameinfo((struct sockaddr*)&s3, sizeof(s3), rh3, sizeof(rh3), rs3, sizeof(rs3), flags);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.getnameinfo.called, 4);
+	CU_ASSERT_EQUAL(stats.getnameinfo.last_params.addr, &s3);
+	CU_ASSERT_EQUAL(custom_gni1_stats.called, 2);
+	CU_ASSERT_EQUAL(custom_gni1_stats.addr, &s2);
+	set_getnameinfo_method(custom_gn2);
+	CU_ASSERT_EQUAL(custom_gni2_stats.called, 0);
+	SANDBOX_BEGIN;
+	i8 = getnameinfo((struct sockaddr*)&s4, sizeof(s4), rh4, sizeof(rh4), rs4, sizeof(rs4), flags);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.getnameinfo.called, 5);
+	CU_ASSERT_EQUAL(custom_gni2_stats.called, 1);
+	set_getnameinfo_method(custom_gn1);
+	SANDBOX_BEGIN;
+	i1 = getnameinfo((struct sockaddr*)&s1, sizeof(s1), rh1, sizeof(rh1), rs1, sizeof(rs1), flags);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.getnameinfo.called, 6);
+	CU_ASSERT_EQUAL(custom_gni2_stats.called, 1);
+	CU_ASSERT_EQUAL(custom_gni1_stats.called, 3);
+	// TODO should also test that it doesn't cause any other problem
+
+	// Testing gai_strerror
+	CU_ASSERT_EQUAL(monitored.gai_strerror, false);
+	CU_ASSERT_EQUAL(stats.gai_strerror.called, 0);
+	const char *r1, *r2, *r3, *r4, *r5;
+	r1 = gai_strerror(EAI_MEMORY);
+	CU_ASSERT_EQUAL(stats.gai_strerror.called, 0);
+	SANDBOX_BEGIN;
+	r2 = gai_strerror(EAI_MEMORY);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.gai_strerror.called, 0);
+	CU_ASSERT_EQUAL(strcmp(r1, r2), 0);
+	monitored.gai_strerror = true;
+	r3 = gai_strerror(EAI_MEMORY);
+	CU_ASSERT_EQUAL(stats.gai_strerror.called, 0);
+	CU_ASSERT_EQUAL(strcmp(r1, r3), 0);
+	SANDBOX_BEGIN;
+	r4 = gai_strerror(EAI_MEMORY);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.gai_strerror.called, 1);
+	CU_ASSERT_EQUAL(stats.gai_strerror.last_params, EAI_MEMORY);
+	CU_ASSERT_EQUAL(strcmp(r1, r4), 0);
+	CU_ASSERT_EQUAL(custom_gse1_stats.called, 0);
+	CU_ASSERT_EQUAL(custom_gse2_stats.called, 0);
+	set_gai_strerror_method(custom_gai_strerror1);
+	r5 = gai_strerror(EAI_MEMORY);
+	CU_ASSERT_EQUAL(strcmp(r1, r5), 0); // Actually, they are strictly identical...
+	SANDBOX_BEGIN;
+	r2 = gai_strerror(EAI_MEMORY);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(stats.gai_strerror.called, 2);
+	CU_ASSERT_EQUAL(custom_gse1_stats.called, 1);
+	CU_ASSERT_EQUAL(strcmp(r2, "GSE1"), 0);
+	set_gai_strerror_method(NULL);
+	SANDBOX_BEGIN;
+	r3 = gai_strerror(EAI_MEMORY);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(strcmp(r3, r1), 0);
+	CU_ASSERT_EQUAL(custom_gse1_stats.called, 1);
+	set_gai_strerror_method(custom_gai_strerror2);
+	SANDBOX_BEGIN;
+	r4 = gai_strerror(EAI_MEMORY);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(custom_gse2_stats.called, 1);
+	CU_ASSERT_EQUAL(strcmp(r4, "GSE2"), 0);
+	set_gai_strerror_method(custom_gai_strerror1);
+	SANDBOX_BEGIN;
+	r5 = gai_strerror(EAI_MEMORY);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(custom_gse1_stats.called, 2);
+	CU_ASSERT_EQUAL(strcmp(r5, "GSE1"), 0);
+	monitored.gai_strerror = false;
+	SANDBOX_BEGIN;
+	r2 = gai_strerror(EAI_MEMORY);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(custom_gse1_stats.called, 2);
+	CU_ASSERT_EQUAL(strcmp(r2, r1), 0);
+}
+
+void test_checked_freeaddrinfo()
+{
+	set_test_metadata("checked_freeaddrinfo", _("Tests the checked freeaddrinfo"), 1);
+	reinit_all_monitored();
+	reinit_all_stats();
+	set_check_freeaddrinfo(false);
+	reset_gai_fai_gstr_gni_methods();
+	memset(&custom_gai1_stats, 0, sizeof(custom_gai1_stats));
+	memset(&custom_gai2_stats, 0, sizeof(custom_gai2_stats));
+	memset(&custom_fai1_stats, 0, sizeof(custom_fai1_stats));
+	memset(&custom_fai2_stats, 0, sizeof(custom_fai2_stats));
+	memset(&custom_gni1_stats, 0, sizeof(custom_gni1_stats));
+	memset(&custom_gni2_stats, 0, sizeof(custom_gni2_stats));
+	memset(&custom_fair_stats, 0, sizeof(custom_fair_stats));
+	memset(&custom_gse1_stats, 0, sizeof(custom_gse1_stats));
+	memset(&custom_gse2_stats, 0, sizeof(custom_gse2_stats));
+
+	set_freeaddrinfo_badarg_report(custom_checked_fai_reporter);
+	set_gai_methods(custom_gai1, custom_fai1);
+	set_gai_strerror_method(custom_gai_strerror1);
+	// First, let's check that it is not called if we don't activate the check,
+	// or if we don't activate monitoring for freeaddrinfo
+	// TODO check that its results are consistent only if we
+	int i1=-1, i2=-1, i3=-1, i4=-1;
+	struct addrinfo hints1, *res1, hints2, *res2, *res3, *res4, *res5, *res6, *res7, *res8;
+	memset(&hints1, 0, sizeof(hints1));
+	memset(&hints2, 0, sizeof(hints2));
+	hints2.ai_family = AF_INET;
+	hints2.ai_flags = AI_NUMERICHOST;
+	hints2.ai_socktype = SOCK_DGRAM;
+	monitored.freeaddrinfo = monitored.getaddrinfo = true;
+	SANDBOX_BEGIN;
+	i1 = getaddrinfo("127.0.0.1", "80", &hints1, &res1);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(custom_gai1_stats.called, 1);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 1);
+	CU_ASSERT_PTR_NULL(stats.getaddrinfo.addrinfo_list);
+	CU_ASSERT_EQUAL(i1, 0);
+	CU_ASSERT_EQUAL(res1->ai_family, AF_INET);
+	CU_ASSERT_EQUAL(custom_gai1("127.0.0.2", "80", &hints1, &res2), 0); // This shouldn't hurt
+	CU_ASSERT_EQUAL(custom_gai1_stats.called, 2);
+	(void)i4;
+	(void)res7;
+	(void)res8;
+	SANDBOX_BEGIN;
+	freeaddrinfo(res2); // Never seen before, so should call the correct method, but will not
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(custom_fai1_stats.called, 1); // Called
+	CU_ASSERT_EQUAL(custom_fair_stats.called, 0); // Not called
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 1);
+	monitored.freeaddrinfo = false;
+	CU_ASSERT_EQUAL(getaddrinfo("127.0.0.3", "80", &hints2, &res3), 0); // Use the real one
+	set_check_freeaddrinfo(true);
+	SANDBOX_BEGIN;
+	freeaddrinfo(res3);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(custom_fai1_stats.called, 1); // Custom not called
+	CU_ASSERT_EQUAL(custom_fair_stats.called, 0);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 1);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.status, 0);
+	// Now, let's see what happens if we activate it.
+	set_check_freeaddrinfo(true);
+	monitored.getaddrinfo = monitored.freeaddrinfo = true;
+	SANDBOX_BEGIN;
+	i2 = getaddrinfo("127.0.0.4", "80", &hints1, &res4);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(custom_gai1_stats.called, 3);
+	CU_ASSERT_EQUAL(stats.getaddrinfo.called, 2);
+	CU_ASSERT_PTR_NOT_NULL(stats.getaddrinfo.addrinfo_list);
+	if (stats.getaddrinfo.addrinfo_list) {
+		struct addrinfo_node_t *list = stats.getaddrinfo.addrinfo_list;
+		CU_ASSERT_PTR_EQUAL(list->addr_list, res4);
+		CU_ASSERT_PTR_NULL(list->next);
+	}
+	CU_ASSERT_EQUAL(i2, 0);
+	CU_ASSERT_EQUAL(custom_gai1("127.0.0.5", "80", &hints1, &res5), 0);
+	SANDBOX_BEGIN;
+	freeaddrinfo(res4);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(custom_fair_stats.called, 0); // Not called because OK
+	CU_ASSERT_EQUAL(custom_fai1_stats.called, 2); // Called
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 2);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.status, 0);
+	CU_ASSERT_PTR_NULL(stats.getaddrinfo.addrinfo_list);
+	SANDBOX_BEGIN;
+	freeaddrinfo(res5);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(custom_fair_stats.called, 1); // Called because fail
+	CU_ASSERT_EQUAL(custom_fai1_stats.called, 3); // Called
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 3);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.status, 1);
+	custom_fai1_prevent_free(res4);
+	SANDBOX_BEGIN;
+	freeaddrinfo(res4); // Double free
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(custom_fair_stats.called, 2); // Called because fail
+	CU_ASSERT_EQUAL(custom_fai1_stats.called, 4); // Called
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 4);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.status, 1);
+	// Disabling getaddrinfo should also cause problems...
+	// Warning, we need to set gais to default as gai will be library
+	set_gai_methods(NULL, NULL);
+	monitored.getaddrinfo = false;
+	SANDBOX_BEGIN;
+	i3 = getaddrinfo("127.0.0.6", "80", &hints2, &res6);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(i3, 0);
+	SANDBOX_BEGIN;
+	freeaddrinfo(res6);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(custom_fair_stats.called, 3);
+	CU_ASSERT_EQUAL(custom_fai1_stats.called, 4);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 5);
+	set_check_freeaddrinfo(true);
+	SANDBOX_BEGIN;
+	freeaddrinfo(res1); // Should still disappear, but with error
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(custom_fair_stats.called, 4);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 6);
+	CU_ASSERT_EQUAL(custom_fai1_stats.called, 4);
+	CU_ASSERT_EQUAL(custom_gai1("127.0.0.7", "80", &hints1, &res7), 0);
+	CU_ASSERT_PTR_NULL(stats.getaddrinfo.addrinfo_list);
+	set_gai_methods(NULL, custom_fai1);
+	set_freeaddrinfo_badarg_report(NULL); // Disable it
+	SANDBOX_BEGIN;
+	freeaddrinfo(res7);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(custom_fai1_stats.called, 5);
+	CU_ASSERT_EQUAL(stats.freeaddrinfo.called, 7);
+	CU_ASSERT_EQUAL(custom_fair_stats.called, 4); // Disabled, so not called
+}
+
+void test_simple_getaddrinfo()
+{
+	set_test_metadata("simple_gai_fai", _("Tests simple_gai and simple_fai"), 1);
+	reinit_all_monitored();
+	reinit_all_stats();
+	set_check_freeaddrinfo(false);
+	reset_gai_fai_gstr_gni_methods();
+	set_gai_methods(simple_getaddrinfo, simple_freeaddrinfo);
+
+	int i1=1, i2=1, i3=1, i4=1, i5=1, i6=1, i7=1, i8=1, i9=1;
+	int i10=0, i11=0, i12=0, i13=0, i14=0, i15=0;
+	struct addrinfo hints1, *res1, hints2, *res2, hints3, *res3, hints4, *res4;
+	struct addrinfo hints5, *res5, hints6, *res6, hints7, *res7, hints8, *res8, *res9;
+	struct addrinfo hints10, *res10=NULL, hints11, *res11=NULL, hints12, *res12=NULL;
+	struct addrinfo hints13, *res13=NULL, hints14, *res14=NULL, hints15, *res15=NULL;
+	memset(&hints1, 0, sizeof(hints1));
+	memset(&hints2, 0, sizeof(hints2));
+	memset(&hints3, 0, sizeof(hints3));
+	memset(&hints4, 0, sizeof(hints4));
+	memset(&hints5, 0, sizeof(hints5));
+	memset(&hints6, 0, sizeof(hints6));
+	memset(&hints7, 0, sizeof(hints7));
+	memset(&hints8, 0, sizeof(hints8));
+	memset(&hints10, 0, sizeof(hints10));
+
+	hints1.ai_flags = AI_NUMERICHOST | AI_CANONNAME;
+	hints1.ai_family = AF_INET;
+	hints1.ai_socktype = SOCK_STREAM;
+	hints2.ai_flags = AI_NUMERICHOST | AI_PASSIVE; // Should ignore the AI_PASSIVE
+	hints2.ai_family = AF_INET;
+	hints2.ai_socktype = SOCK_DGRAM;
+	hints3.ai_flags = AI_NUMERICHOST;
+	hints3.ai_family = AF_INET;
+	hints3.ai_socktype = SOCK_DGRAM;
+	hints4.ai_flags = AI_PASSIVE;
+	hints4.ai_family = AF_INET;
+	hints4.ai_socktype = SOCK_DGRAM;
+	hints5.ai_flags = AI_PASSIVE;
+	hints5.ai_family = AF_INET6;
+	hints5.ai_socktype = 0;
+	hints6.ai_flags = AI_CANONNAME;
+	hints6.ai_family = AF_UNSPEC;
+	hints6.ai_socktype = SOCK_STREAM;
+	hints7.ai_flags = AI_NUMERICHOST;
+	hints7.ai_family = AF_INET6;
+	hints7.ai_socktype = SOCK_DGRAM;
+	hints8.ai_flags = AI_NUMERICHOST;
+	hints8.ai_family = AF_INET6;
+	hints8.ai_socktype = SOCK_STREAM;
+
+	hints10.ai_flags = AI_NUMERICHOST;
+	hints10.ai_family = AF_INET6;
+	hints10.ai_socktype = SOCK_DGRAM;
+	hints11.ai_flags = AI_NUMERICHOST;
+	hints11.ai_family = AF_UNSPEC;
+	hints11.ai_socktype = 0;
+	hints12.ai_flags = AI_NUMERICHOST;
+	hints12.ai_family = AF_UNSPEC;
+	hints12.ai_socktype = 0;
+	hints13.ai_flags = AI_NUMERICHOST;
+	hints13.ai_family = AF_INET;
+	hints13.ai_socktype = 0;
+	hints14.ai_flags = AI_NUMERICHOST;
+	hints14.ai_family = AF_INET;
+	hints14.ai_socktype = SOCK_DGRAM;
+	hints15.ai_flags = AI_NUMERICHOST | AI_CANONNAME;
+	hints15.ai_family = AF_INET;
+	hints15.ai_socktype = SOCK_DGRAM;
+
+	monitored.getaddrinfo = true;
+	monitored.freeaddrinfo = true;
+
+	SANDBOX_BEGIN;
+	i1 = getaddrinfo("127.0.0.1", "80", &hints1, &res1); // ACTIVE, loopback, IPv4, canon name
+	i2 = getaddrinfo("192.168.1.1", "443", &hints2, &res2); // ACTIVE, IPv4, false passive
+	i3 = getaddrinfo(NULL, "80", &hints3, &res3); // ACTIVE, implicit loopback, IPv4
+	i4 = getaddrinfo(NULL, "80", &hints4, &res4); // PASSIVE, IPv4
+	i5 = getaddrinfo(NULL, "22", &hints5, &res5); // PASSIVE, IPv6
+	i6 = getaddrinfo("::1", "22", &hints6, &res6); // ACTIVE, loopback, IPv6
+	i7 = getaddrinfo("::2", NULL, &hints7, &res7); // ACTIVE, IPv6, no port
+	i8 = getaddrinfo(NULL, "443", &hints8, &res8); // ACTIVE, implicit loopback, IPv6
+	i9 = getaddrinfo("1.2.3.4", "80", NULL, &res9); // ACTIVE, IPv4, no hint
+	// Errors
+	i10 = getaddrinfo("123.45.67.89", "80", &hints10, &res10); // IPv4 vs IPv6
+	i11 = getaddrinfo("www.example.com", "80", &hints11, &res11); // non-numeric host
+	i12 = getaddrinfo("::1", "http", &hints12, &res12); // non-numeric serv
+	i13 = getaddrinfo("1::1", "80", &hints13, &res13); // IPv6 vs IPv4
+	i14 = getaddrinfo(NULL, NULL, &hints14, &res14); // both NULL
+	i15 = getaddrinfo(NULL, "80", &hints15, &res15); // canon name without host
+	SANDBOX_END;
+
+	CU_ASSERT_EQUAL(i1, 0);
+	CU_ASSERT_PTR_NOT_NULL(res1);
+	if (res1) {
+		CU_ASSERT_EQUAL(res1->ai_family, AF_INET);
+		CU_ASSERT_EQUAL(res1->ai_socktype, SOCK_STREAM);
+		CU_ASSERT_EQUAL(res1->ai_addrlen, sizeof(struct sockaddr_in));
+		struct sockaddr_in *addr = (struct sockaddr_in*)(res1->ai_addr);
+		CU_ASSERT_PTR_NOT_NULL(addr);
+		if (addr) {
+			CU_ASSERT_EQUAL(addr->sin_family, AF_INET);
+			CU_ASSERT_EQUAL(addr->sin_port, htons(80));
+			struct in_addr ipaddr;
+			inet_pton(AF_INET, "127.0.0.1", &ipaddr);
+			CU_ASSERT_EQUAL(addr->sin_addr.s_addr, ipaddr.s_addr);
+		}
+		CU_ASSERT_PTR_NOT_NULL(res1->ai_canonname);
+		if (res1->ai_canonname) {
+			CU_ASSERT_EQUAL(strcmp(res1->ai_canonname, "C127.0.0.1"), 0);
+		}
+	}
+	CU_ASSERT_EQUAL(i2, 0);
+	CU_ASSERT_PTR_NOT_NULL(res2);
+	if (res2) {
+		CU_ASSERT_EQUAL(res2->ai_family, AF_INET);
+		CU_ASSERT_EQUAL(res2->ai_socktype, SOCK_DGRAM);
+		CU_ASSERT_EQUAL(res2->ai_addrlen, sizeof(struct sockaddr_in));
+		struct sockaddr_in *addr = (struct sockaddr_in*)(res2->ai_addr);
+		CU_ASSERT_PTR_NOT_NULL(addr);
+		if (addr) {
+			CU_ASSERT_EQUAL(addr->sin_family, AF_INET);
+			CU_ASSERT_EQUAL(addr->sin_port, htons(443));
+			struct in_addr ipaddr;
+			inet_pton(AF_INET, "192.168.1.1", &ipaddr);
+			CU_ASSERT_EQUAL(addr->sin_addr.s_addr, ipaddr.s_addr);
+		}
+		CU_ASSERT_PTR_NULL(res2->ai_canonname);
+	}
+	CU_ASSERT_EQUAL(i3, 0);
+	CU_ASSERT_PTR_NOT_NULL(res3);
+	if (res3) {
+		CU_ASSERT_EQUAL(res3->ai_family, AF_INET);
+		CU_ASSERT_EQUAL(res3->ai_socktype, SOCK_DGRAM);
+		CU_ASSERT_EQUAL(res3->ai_addrlen, sizeof(struct sockaddr_in));
+		struct sockaddr_in *addr = (struct sockaddr_in*)(res3->ai_addr);
+		CU_ASSERT_PTR_NOT_NULL(addr);
+		if (addr) {
+			CU_ASSERT_EQUAL(addr->sin_family, AF_INET);
+			CU_ASSERT_EQUAL(addr->sin_port, htons(80));
+			struct in_addr ipaddr;
+			inet_pton(AF_INET, "127.0.0.1", &ipaddr);
+			CU_ASSERT_EQUAL(addr->sin_addr.s_addr, ipaddr.s_addr);
+		}
+		CU_ASSERT_PTR_NULL(res3->ai_canonname);
+	}
+	CU_ASSERT_EQUAL(i4, 0);
+	CU_ASSERT_PTR_NOT_NULL(res4);
+	if (res4) {
+		CU_ASSERT_EQUAL(res4->ai_family, AF_INET);
+		CU_ASSERT_EQUAL(res4->ai_socktype, SOCK_DGRAM);
+		CU_ASSERT_EQUAL(res4->ai_addrlen, sizeof(struct sockaddr_in));
+		struct sockaddr_in *addr = (struct sockaddr_in*)(res4->ai_addr);
+		CU_ASSERT_PTR_NOT_NULL(addr);
+		if (addr) {
+			CU_ASSERT_EQUAL(addr->sin_family, AF_INET);
+			CU_ASSERT_EQUAL(addr->sin_port, htons(80));
+			CU_ASSERT_EQUAL(addr->sin_addr.s_addr, INADDR_ANY);
+		}
+		CU_ASSERT_PTR_NULL(res4->ai_canonname);
+	}
+	CU_ASSERT_EQUAL(i5, 0);
+	CU_ASSERT_PTR_NOT_NULL(res5);
+	if (res5) {
+		CU_ASSERT_EQUAL(res5->ai_family, AF_INET6);
+		CU_ASSERT_EQUAL(res5->ai_addrlen, sizeof(struct sockaddr_in6));
+		struct sockaddr_in6 *addr = (struct sockaddr_in6*)(res5->ai_addr);
+		CU_ASSERT_PTR_NOT_NULL(addr);
+		if (addr) {
+			CU_ASSERT_EQUAL(addr->sin6_family, AF_INET6);
+			CU_ASSERT_EQUAL(addr->sin6_port, htons(22));
+			CU_ASSERT_EQUAL(memcmp(&(addr->sin6_addr), &(in6addr_any), sizeof(struct in6_addr)), 0);
+		}
+		CU_ASSERT_PTR_NULL(res5->ai_canonname);
+	}
+	CU_ASSERT_EQUAL(i6, 0);
+	CU_ASSERT_PTR_NOT_NULL(res6);
+	if (res6) {
+		CU_ASSERT_EQUAL(res6->ai_family, AF_INET6);
+		CU_ASSERT_EQUAL(res6->ai_socktype, SOCK_STREAM);
+		CU_ASSERT_EQUAL(res6->ai_addrlen, sizeof(struct sockaddr_in6));
+		struct sockaddr_in6 *addr = (struct sockaddr_in6*)(res6->ai_addr);
+		CU_ASSERT_PTR_NOT_NULL(addr);
+		if (addr) {
+			CU_ASSERT_EQUAL(addr->sin6_family, AF_INET6);
+			CU_ASSERT_EQUAL(addr->sin6_port, htons(22));
+			struct in6_addr addr6;
+			inet_pton(AF_INET6, "::1", &addr6);
+			CU_ASSERT_EQUAL(memcmp(&(addr->sin6_addr), &(addr6), sizeof(addr6)), 0);
+		}
+		CU_ASSERT_PTR_NOT_NULL(res6->ai_canonname);
+		if (res6->ai_canonname) {
+			CU_ASSERT_EQUAL(strcmp(res6->ai_canonname, "C::1"), 0);
+		}
+	}
+	CU_ASSERT_EQUAL(i7, 0);
+	CU_ASSERT_PTR_NOT_NULL(res7);
+	if (res7) {
+		CU_ASSERT_EQUAL(res7->ai_family, AF_INET6);
+		CU_ASSERT_EQUAL(res7->ai_socktype, SOCK_DGRAM);
+		CU_ASSERT_EQUAL(res7->ai_addrlen, sizeof(struct sockaddr_in6));
+		struct sockaddr_in6 *addr = (struct sockaddr_in6*)(res7->ai_addr);
+		CU_ASSERT_PTR_NOT_NULL(addr);
+		if (addr) {
+			CU_ASSERT_EQUAL(addr->sin6_family, AF_INET6);
+			struct in6_addr addr6;
+			inet_pton(AF_INET6, "::2", &addr6);
+			CU_ASSERT_EQUAL(memcmp(&(addr->sin6_addr), &(addr6), sizeof(addr6)), 0);
+		}
+		CU_ASSERT_PTR_NULL(res7->ai_canonname);
+	}
+	CU_ASSERT_EQUAL(i8, 0);
+	CU_ASSERT_PTR_NOT_NULL(res8);
+	if (res8) {
+		CU_ASSERT_EQUAL(res8->ai_family, AF_INET6);
+		CU_ASSERT_EQUAL(res8->ai_socktype, SOCK_STREAM);
+		CU_ASSERT_EQUAL(res8->ai_addrlen, sizeof(struct sockaddr_in6));
+		struct sockaddr_in6 *addr = (struct sockaddr_in6*)(res8->ai_addr);
+		CU_ASSERT_PTR_NOT_NULL(addr);
+		if (addr) {
+			CU_ASSERT_EQUAL(addr->sin6_family, AF_INET6);
+			CU_ASSERT_EQUAL(addr->sin6_port, htons(443));
+			struct in6_addr addr6;
+			inet_pton(AF_INET6, "::1", &addr6);
+			CU_ASSERT_EQUAL(memcmp(&(addr->sin6_addr), &(addr6), sizeof(addr6)), 0);
+		}
+		CU_ASSERT_PTR_NULL(res8->ai_canonname);
+	}
+	CU_ASSERT_EQUAL(i9, 0);
+	CU_ASSERT_PTR_NOT_NULL(res9);
+	if (res9) {
+		CU_ASSERT_EQUAL(res9->ai_family, AF_INET);
+		CU_ASSERT_EQUAL(res9->ai_socktype, SOCK_DGRAM);
+		CU_ASSERT_EQUAL(res9->ai_addrlen, sizeof(struct sockaddr_in));
+		struct sockaddr_in *addr = (struct sockaddr_in*)(res9->ai_addr);
+		CU_ASSERT_PTR_NOT_NULL(addr);
+		if (addr) {
+			CU_ASSERT_EQUAL(addr->sin_family, AF_INET);
+			CU_ASSERT_EQUAL(addr->sin_port, htons(80));
+			struct in_addr addr4;
+			inet_pton(AF_INET, "1.2.3.4", &addr4);
+			CU_ASSERT_EQUAL(addr->sin_addr.s_addr, addr4.s_addr);
+		}
+		CU_ASSERT_PTR_NULL(res9->ai_canonname);
+	}
+	// The failed ones
+	CU_ASSERT_EQUAL(i10, EAI_FAMILY);
+	CU_ASSERT_EQUAL(i11, EAI_NONAME);
+	CU_ASSERT_EQUAL(i12, EAI_NONAME);
+	CU_ASSERT_EQUAL(i13, EAI_FAMILY);
+	CU_ASSERT_EQUAL(i14, EAI_NONAME);
+	CU_ASSERT_EQUAL(i15, EAI_BADFLAGS);
+
+	SANDBOX_BEGIN;
+	// Check freeaddrinfo
+	freeaddrinfo(res1);
+	freeaddrinfo(res2);
+	freeaddrinfo(res3);
+	freeaddrinfo(res4);
+	freeaddrinfo(res5);
+	freeaddrinfo(res6);
+	freeaddrinfo(res7);
+	freeaddrinfo(res8);
+	freeaddrinfo(res9);
+	// The following should still work
+	freeaddrinfo(res10);
+	freeaddrinfo(res11);
+	freeaddrinfo(res12);
+	freeaddrinfo(res13);
+	freeaddrinfo(res14);
+	SANDBOX_END;
+}
+
+int main(int argc, char **argv)
+{
+	RUN(test_gai_substitutes, test_checked_freeaddrinfo, test_simple_getaddrinfo);
+}
+
diff --git a/ci/test_network_gai_simple_socket/expected_results.txt b/ci/test_network_gai_simple_socket/expected_results.txt
new file mode 100644
index 0000000..9637098
--- /dev/null
+++ b/ci/test_network_gai_simple_socket/expected_results.txt
@@ -0,0 +1 @@
+wrapper_stats#SUCCESS#Tests that the wrapper functions correctly remembers the stats#1#
diff --git a/ci/test_network_gai_simple_socket/student_code.c b/ci/test_network_gai_simple_socket/student_code.c
new file mode 100644
index 0000000..948b53a
--- /dev/null
+++ b/ci/test_network_gai_simple_socket/student_code.c
@@ -0,0 +1,215 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <errno.h>
+
+#include "student_code.h"
+
+/**
+ * This is the simple example from the BeeJ guide.
+ */
+void run_student_tests_wrapper_stats_1(struct f1_stats *stats)
+{
+	memset(stats, 0, sizeof(*stats));
+	struct addrinfo hints, *rep, *rp;
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = AF_UNSPEC;
+	hints.ai_socktype = SOCK_DGRAM;
+	hints.ai_flags = 0;
+	hints.ai_protocol = 0;
+	int s = getaddrinfo("inginious.info.ucl.ac.be", "443", &hints, &rep);
+	if (s != 0) {
+		fprintf(stderr, "%s\n", gai_strerror(s));
+		return;
+	}
+	stats->getaddrinfo_success = true;
+	int sfd = -1;
+	for (rp = rep; rp != NULL; rp = rp->ai_next) {
+		stats->nb_addr_tried++;
+		sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+		if (sfd == -1) {
+			perror("socket");
+			continue;
+		}
+		stats->nb_connect++;
+		if (connect(sfd, rp->ai_addr, rp->ai_addrlen) == 0)
+			break;
+		perror("connect");
+		close(sfd);
+		sfd = -1;
+	}
+	freeaddrinfo(rep);
+	if (sfd != -1) {
+		char coucou[] = "coucou";
+		ssize_t nsent;
+		do {
+			nsent = send(sfd, coucou, sizeof(coucou), 0);
+			stats->nb_send++;
+			if (nsent != -1) {
+				stats->nb_bytes += nsent;
+			} else {
+				perror("send");
+			}
+			if (nsent != sizeof(coucou)) {
+				break;
+			}
+		} while (nsent != -1 && stats->nb_bytes < 42);
+	}
+}
+
+/*
+ * The following two codes are adapted from the Linux man pages
+ * for getaddrinfo
+ */
+void run_student_tests_wrapper_stats_2_client(struct stats2_client *stats)
+{
+	errno = 0;
+	memset(stats, 0, sizeof(*stats));
+	struct addrinfo hints, *rep, *rp;
+	int sfd = -1, s;
+	ssize_t nread;
+	char buf[500];
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = AF_INET;
+	hints.ai_socktype = SOCK_DGRAM;
+	hints.ai_protocol = 0;
+	hints.ai_flags = 0;
+	s = getaddrinfo(NULL, "1618", &hints, &rep);
+	stats->ngai = 1;
+	if (s == -1) {
+		fprintf(stderr, "%s\n", gai_strerror(s));
+		return;
+	}
+	for (rp = rep; rp != NULL; rp = rp->ai_next) {
+		sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+		stats->nsocket++;
+		if (sfd == -1) {
+			perror("socket");
+			continue;
+		}
+		if (connect(sfd, rp->ai_addr, rp->ai_addrlen) == 0) {
+			stats->nconnect++;
+			break;
+		}
+		perror("connect");
+		stats->nconnect++;
+		close(sfd);
+		sfd = -1;
+	}
+	if (rp == NULL || sfd == -1)
+		return;
+	freeaddrinfo(rep);
+	char *words[3];
+	words[0] = "coucou";
+	words[1] = "salut";
+	words[2] = "STOP";
+	for (int i = 0; i < 3; i++) {
+		// Send the three messages
+		int len = strlen(words[i]) + 1;
+		// Let's use a struct msghdr to see if it works
+		struct msghdr msg;
+		msg.msg_name = NULL;
+		msg.msg_namelen = 0;
+		struct iovec msg_iov[1];
+		msg_iov[0].iov_base = words[i];
+		msg_iov[0].iov_len = len;
+		msg.msg_iov = msg_iov;
+		msg.msg_iovlen = 1;
+		msg.msg_control = NULL;
+		msg.msg_controllen = 0;
+		msg.msg_flags = 0;
+		ssize_t nsent = sendmsg(sfd, &msg, 0);
+		if (nsent == -1)
+			perror("send");
+		stats->nsend++;
+		if (nsent != len) {
+			fprintf(stderr, "ACouldn't write\n");
+			continue;
+		}
+		// Let's read the data again
+		memset(buf, 0, sizeof(buf));
+		nread = recv(sfd, buf, 500, 0);
+		stats->nrecv++;
+		if (nread == -1) {
+			perror("recv");
+			continue;
+		}
+		if (strcmp(buf, words[i]) != 0) {
+			fprintf(stderr, "AMessage don't match\n");
+			continue;
+		}
+	}
+}
+
+void run_student_tests_wrapper_stats_2_server(struct stats2_server *stats)
+{
+	errno = 0;
+	memset(stats, 0, sizeof(*stats));
+	struct addrinfo hints, *rep, *rp;
+	int sfd = -1, s;
+	struct sockaddr_storage peer_addr;
+	socklen_t peer_addrlen;
+	ssize_t nread;
+	char buf[500];
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = AF_INET;
+	hints.ai_socktype = SOCK_DGRAM;
+	hints.ai_protocol = 0;
+	hints.ai_flags = AI_PASSIVE;
+	s = getaddrinfo(NULL, "1618", &hints, &rep);
+	stats->ngai = 1;
+	if (s == -1) {
+		fprintf(stderr, "%s\n", gai_strerror(s));
+		return;
+	}
+	for (rp = rep; rp != NULL; rp = rp->ai_next) {
+		sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+		stats->nsocket++;
+		if (sfd == -1) {
+			perror("Bsocket");
+			continue;
+		}
+		if (bind(sfd, rp->ai_addr, rp->ai_addrlen) == 0) {
+			stats->nbind++;
+			break;
+		}
+		perror("Bbind");
+		stats->nbind++;
+		close(sfd);
+		sfd = -1;
+	}
+	if (rp == NULL || sfd == -1)
+		return;
+	freeaddrinfo(rep);
+	for (int failures = 0; failures < 10;) {
+		memset(buf, 0, sizeof(buf));
+		// Stops at the reception of "stop"
+		peer_addrlen = sizeof(peer_addr);
+		nread = recvfrom(sfd, buf, 500, 0, (struct sockaddr*) &peer_addr, &peer_addrlen);
+		stats->nrecvfrom++;
+		if (nread == -1)
+			perror("recvfrom");
+		if (nread == -1) {
+			failures++;
+			continue;
+		}
+		// Let's skip the printing here
+		ssize_t nsent = sendto(sfd, buf, nread, 0, (struct sockaddr*) &peer_addr, peer_addrlen);
+		stats->nsendto++;
+		if (nsent != nread) {
+			failures++;
+		}
+		if (nsent == -1) {
+			perror("Bsent");
+		}
+		if (strcmp(buf, "STOP") == 0) {
+			break;
+		}
+	}
+}
+
diff --git a/ci/test_network_gai_simple_socket/student_code.h b/ci/test_network_gai_simple_socket/student_code.h
new file mode 100644
index 0000000..342c2d1
--- /dev/null
+++ b/ci/test_network_gai_simple_socket/student_code.h
@@ -0,0 +1,31 @@
+#include <stdbool.h>
+struct f1_stats {
+	bool getaddrinfo_success;
+	int nb_addr_tried;
+	int nb_connect;
+	int nb_send;
+	ssize_t nb_bytes;
+};
+struct stats2_server {
+	int ngai;
+	int nsocket;
+	int nbind;
+	int nrecvfrom;
+	int nsendto;
+};
+struct stats2_client {
+	int ngai;
+	int nsocket;
+	int nconnect;
+	int nsend;
+	int nrecv;
+};
+
+void run_student_tests_wrapper_stats_1(struct f1_stats *stats);
+
+void run_student_tests_wrapper_stats_2_client(struct stats2_client *stats);
+
+void run_student_tests_wrapper_stats_2_server(struct stats2_server *stats);
+
+// void run_student_tests_wrapper_stats_3();
+
diff --git a/ci/test_network_gai_simple_socket/tests.c b/ci/test_network_gai_simple_socket/tests.c
new file mode 100644
index 0000000..554b389
--- /dev/null
+++ b/ci/test_network_gai_simple_socket/tests.c
@@ -0,0 +1,185 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+#include "CTester/CTester.h"
+#include "student_code.h"
+
+void __real_exit(int status); // Needed as otherwise we'll get a segfault
+
+void test_wrapper_stats()
+{
+	// Let's enable the stats for all functions
+	set_test_metadata("wrapper_stats", _("Tests that the wrapper functions correctly remembers the stats"), 1);
+	CU_ASSERT_EQUAL(stats.accept.called, 0);
+	CU_ASSERT_EQUAL(stats.bind.called, 0);
+	CU_ASSERT_EQUAL(stats.connect.called, 0);
+	CU_ASSERT_EQUAL(stats.listen.called, 0);
+	CU_ASSERT_EQUAL(stats.recv.called, 0);
+	CU_ASSERT_EQUAL(stats.recvfrom.called, 0);
+	CU_ASSERT_EQUAL(stats.recvmsg.called, 0);
+	CU_ASSERT_EQUAL(stats.recv_all.called, 0);
+	CU_ASSERT_EQUAL(stats.send.called, 0);
+	CU_ASSERT_EQUAL(stats.sendto.called, 0);
+	CU_ASSERT_EQUAL(stats.sendmsg.called, 0);
+	CU_ASSERT_EQUAL(stats.send_all.called, 0);
+	CU_ASSERT_EQUAL(stats.socket.called, 0);
+
+	CU_ASSERT_EQUAL(stats.accept.last_return, 0);
+	CU_ASSERT_EQUAL(stats.bind.last_return, 0);
+	CU_ASSERT_EQUAL(stats.connect.last_return, 0);
+	CU_ASSERT_EQUAL(stats.listen.last_return, 0);
+	CU_ASSERT_EQUAL(stats.recv.last_return, 0);
+	CU_ASSERT_EQUAL(stats.recvfrom.last_return, 0);
+	CU_ASSERT_EQUAL(stats.recvmsg.last_return, 0);
+	CU_ASSERT_EQUAL(stats.send.last_return, 0);
+	CU_ASSERT_EQUAL(stats.sendto.last_return, 0);
+	CU_ASSERT_EQUAL(stats.sendmsg.last_return, 0);
+	CU_ASSERT_EQUAL(stats.socket.last_return, 0);
+
+	monitored.getaddrinfo = monitored.freeaddrinfo = true;
+	monitored.accept = monitored.bind = monitored.connect = monitored.listen = monitored.socket = true;
+	MONITOR_ALL_RECV(monitored, true);
+	MONITOR_ALL_SEND(monitored, true);
+	CU_ASSERT_EQUAL(monitored.recv, true);
+	CU_ASSERT_EQUAL(monitored.recvfrom, true);
+	CU_ASSERT_EQUAL(monitored.recvmsg, true);
+	CU_ASSERT_EQUAL(monitored.send, true);
+	CU_ASSERT_EQUAL(monitored.sendto, true);
+	CU_ASSERT_EQUAL(monitored.sendmsg, true);
+
+	// wrap_monitoring is set to true inside the sandbox, and set to false at the end of it.
+	struct f1_stats stats1;
+	SANDBOX_BEGIN;
+	run_student_tests_wrapper_stats_1(&stats1);
+	SANDBOX_END;
+
+	CU_ASSERT_EQUAL(stats.accept.called, 0);
+	CU_ASSERT_EQUAL(stats.bind.called, 0);
+	CU_ASSERT_EQUAL(stats.connect.called, stats1.nb_connect);
+	CU_ASSERT_EQUAL(stats.listen.called, 0);
+	CU_ASSERT_EQUAL(stats.recv.called, 0);
+	CU_ASSERT_EQUAL(stats.recvfrom.called, 0);
+	CU_ASSERT_EQUAL(stats.recvmsg.called, 0);
+	CU_ASSERT_EQUAL(stats.recv_all.called, 0);
+	CU_ASSERT_EQUAL(stats.send.called, stats1.nb_send);
+	CU_ASSERT_EQUAL(stats.sendto.called, 0);
+	CU_ASSERT_EQUAL(stats.sendmsg.called, 0);
+	CU_ASSERT_EQUAL(stats.send_all.called, stats1.nb_send);
+	CU_ASSERT_EQUAL(stats.socket.called, stats1.nb_addr_tried);
+
+	reinit_stats_network_dns();
+	reinit_network_socket_stats(); // Simpler for the next calls
+
+	int pid;
+	pid = fork();
+	if (pid == 0) {
+		struct stats2_server statss;
+		SANDBOX_BEGIN;
+		run_student_tests_wrapper_stats_2_server(&statss);
+		SANDBOX_END;
+		// I must exit to let the other process terminate. No test here !
+		__real_exit(0);
+	} else if (pid != -1) {
+		struct stats2_client statss;
+		memset(&statss, 0, sizeof(statss));
+		sleep(1); // Strangely extremely important FIXME
+		SANDBOX_BEGIN;
+		run_student_tests_wrapper_stats_2_client(&statss);
+		SANDBOX_END;
+		int status = 0;
+		waitpid(pid, &status, 0);
+		// Let's have a look at the statistics for the client
+		CU_ASSERT_EQUAL(stats.socket.called, statss.nsocket);
+		CU_ASSERT_EQUAL(stats.connect.called, statss.nconnect);
+		CU_ASSERT_EQUAL(stats.getaddrinfo.called, statss.ngai);
+		CU_ASSERT_EQUAL(stats.freeaddrinfo.called, (statss.ngai > 0 && statss.nsocket > 0));
+		CU_ASSERT_EQUAL(stats.sendmsg.called, statss.nsend);
+		CU_ASSERT_EQUAL(stats.send_all.called, statss.nsend);
+		CU_ASSERT_EQUAL(stats.recv.called, statss.nrecv);
+		CU_ASSERT_EQUAL(stats.recv_all.called, statss.nrecv);
+	} else {
+		CU_FAIL();
+	}
+
+	reinit_stats_network_dns();
+	reinit_network_socket_stats();
+
+	pid = fork();
+	if (pid == 0) {
+		struct stats2_client statss;
+		SANDBOX_BEGIN;
+		run_student_tests_wrapper_stats_2_client(&statss);
+		SANDBOX_END;
+		// I must exit to let the other process terminate. No test here !
+		__real_exit(0);
+	} else if (pid != -1) {
+		struct stats2_server statss;
+		memset(&statss, 0, sizeof(statss));
+		SANDBOX_BEGIN;
+		run_student_tests_wrapper_stats_2_server(&statss);
+		SANDBOX_END;
+		int status = 0;
+		waitpid(pid, &status, 0);
+		// Let's have a look at the statistics for the server
+		CU_ASSERT_EQUAL(stats.bind.called, statss.nbind);
+		CU_ASSERT_EQUAL(stats.socket.called, statss.nsocket);
+		CU_ASSERT_EQUAL(stats.getaddrinfo.called, statss.ngai);
+		CU_ASSERT_EQUAL(stats.sendto.called, statss.nsendto);
+		CU_ASSERT_EQUAL(stats.recvfrom.called, statss.nrecvfrom);
+		CU_ASSERT_EQUAL(stats.recv_all.called, statss.nrecvfrom);
+		CU_ASSERT_EQUAL(stats.send_all.called, statss.nsendto);
+	} else {
+		CU_FAIL();
+	}
+
+	monitored.getaddrinfo = monitored.freeaddrinfo = false;
+	monitored.accept = monitored.bind = monitored.connect = monitored.listen = monitored.socket = false;
+	MONITOR_ALL_RECV(monitored, false);
+	MONITOR_ALL_SEND(monitored, false);
+	CU_ASSERT_EQUAL(monitored.recv, false);
+	CU_ASSERT_EQUAL(monitored.recvfrom, false);
+	CU_ASSERT_EQUAL(monitored.recvmsg, false);
+	CU_ASSERT_EQUAL(monitored.send, false);
+	CU_ASSERT_EQUAL(monitored.sendto, false);
+	CU_ASSERT_EQUAL(monitored.sendmsg, false);
+
+	reinit_stats_network_dns();
+	reinit_network_socket_stats();
+	CU_ASSERT_EQUAL(stats.accept.called, 0);
+	CU_ASSERT_EQUAL(stats.bind.called, 0);
+	CU_ASSERT_EQUAL(stats.connect.called, 0);
+	CU_ASSERT_EQUAL(stats.listen.called, 0);
+	CU_ASSERT_EQUAL(stats.recv.called, 0);
+	CU_ASSERT_EQUAL(stats.recvfrom.called, 0);
+	CU_ASSERT_EQUAL(stats.recvmsg.called, 0);
+	CU_ASSERT_EQUAL(stats.recv_all.called, 0);
+	CU_ASSERT_EQUAL(stats.send.called, 0);
+	CU_ASSERT_EQUAL(stats.sendto.called, 0);
+	CU_ASSERT_EQUAL(stats.sendmsg.called, 0);
+	CU_ASSERT_EQUAL(stats.send_all.called, 0);
+	CU_ASSERT_EQUAL(stats.socket.called, 0);
+
+	CU_ASSERT_EQUAL(stats.accept.last_return, 0);
+	CU_ASSERT_EQUAL(stats.bind.last_return, 0);
+	CU_ASSERT_EQUAL(stats.connect.last_return, 0);
+	CU_ASSERT_EQUAL(stats.listen.last_return, 0);
+	CU_ASSERT_EQUAL(stats.recv.last_return, 0);
+	CU_ASSERT_EQUAL(stats.recvfrom.last_return, 0);
+	CU_ASSERT_EQUAL(stats.recvmsg.last_return, 0);
+	CU_ASSERT_EQUAL(stats.send.last_return, 0);
+	CU_ASSERT_EQUAL(stats.sendto.last_return, 0);
+	CU_ASSERT_EQUAL(stats.sendmsg.last_return, 0);
+	CU_ASSERT_EQUAL(stats.socket.last_return, 0);
+}
+
+// Check failures:
+// Recall we must use the failures struct, and assign its (call), (call)_ret and (call)_errno fields.
+// And we have the fileds FAIL_ALWAYS, FAIL_NEVER, FAIL_FIRST, FAIL_SECOND, FAIL_THIRD and FAIL_TWICE
+
+int main(int argc, char **argv)
+{
+	RUN(test_wrapper_stats);
+}
+
diff --git a/ci/test_network_recv/expected_results.txt b/ci/test_network_recv/expected_results.txt
new file mode 100644
index 0000000..e0b0e17
--- /dev/null
+++ b/ci/test_network_recv/expected_results.txt
@@ -0,0 +1,4 @@
+fragmented_recv#SUCCESS#Tests the use of a fragmented recv#1#
+fragmented_recv_before#SUCCESS#Tests the use of before-intervals#1#
+fragmented_recv_after#SUCCESS#Tests the use of after-intervals#1#
+fragmented_recv_realtime#SUCCESS#Tests the use of real-time-intervals#1#
diff --git a/ci/test_network_recv/tests.c b/ci/test_network_recv/tests.c
new file mode 100644
index 0000000..0dec8b9
--- /dev/null
+++ b/ci/test_network_recv/tests.c
@@ -0,0 +1,965 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <string.h>
+#include <errno.h>
+
+#include "CTester/CTester.h"
+#include "CTester/read_write.h"
+
+#define BILLION (1000*1000*1000)
+
+#define TOL_INF_D 0.3
+#define TOL_SUP_D 2.0
+#define TOL_SUP_A (1000*1000)
+#define TOL_INF_A 0
+
+#define TIMESPEC_ZERO(ts) \
+	struct timespec ts; \
+	memset(&ts, 0, sizeof(ts));
+#define TS_ZERO(ts) \
+	ts.tv_sec = 0; ts.tv_nsec = 0;
+
+void __real_exit(int status); // Needed as otherwise we'll get a segfault
+
+struct read_fd_table_t {
+	size_t n;
+	struct read_item *items;
+};
+struct read_item {
+	int fd;
+	const struct read_buffer_t *buf;
+	unsigned int chunk_id;
+	size_t bytes_read;
+	struct timespec last_time;
+	int64_t interval;
+};
+
+bool timespec_is_between(const struct timespec *a, const struct timespec *min, const struct timespec *max)
+{
+	int64_t mint = min->tv_sec;
+	mint *= BILLION;
+	mint += min->tv_nsec;
+	int64_t at = a->tv_sec;
+	at *= BILLION;
+	at += a->tv_nsec;
+	int64_t maxt = max->tv_sec;
+	maxt *= BILLION;
+	maxt += max->tv_nsec;
+	return (mint <= at && at <= maxt);
+}
+
+extern struct read_fd_table_t read_fd_table;
+
+struct read_item;
+
+extern bool fd_is_read_buffered(int fd);
+
+extern ssize_t read_handle_buffer(int fd, void *buf, size_t len, int flags);
+
+extern int64_t get_time_interval(const struct timespec *pasttime, const struct timespec *curtime);
+
+extern void getnanotime(struct timespec *res);
+
+bool is_quasi_equal(int64_t a, int64_t b)
+{
+	double aa = a, bb = b;
+	if (a != 0 && b != 0) {
+		double cc = aa/bb;
+		return (TOL_INF_D <= cc  && cc <= TOL_SUP_D);
+	} else {
+		if (a == 0) {
+			return (TOL_INF_A <= b && b <= TOL_SUP_A);
+		} else {
+			return (TOL_INF_A <= a && a <= TOL_SUP_A);
+		}
+	}
+}
+
+extern bool wrap_monitoring;
+
+void test_fragmented_recv()
+{
+	int64_t MILLION = 1000*1000;
+	set_test_metadata("fragmented_recv", _("Tests the use of a fragmented recv"), 1);
+	MONITOR_ALL_RECV(monitored, true);
+	reinit_network_socket_stats();
+	reinit_read_fd_table();
+	CU_ASSERT_EQUAL(read_fd_table.n, 0); // "read_fd_table is not empty"
+	CU_ASSERT_EQUAL(read_fd_table.items, NULL); // "read_fd_table is not empty"
+	size_t tab1len = 1000;
+	char *tab1 = malloc(tab1len);
+	if (!tab1)
+		CU_FAIL_FATAL("Couldn't allocate memory");
+	for (int i = 0; i < 1000; i++) {
+		tab1[i] = (char)i;
+	}
+	struct read_buffer_t rbuf1, rbuf2, rbuf3;
+	rbuf1.mode = READ_WRITE_BEFORE_INTERVAL;
+	rbuf1.nchunks = 4;
+	rbuf1.chunks = malloc(rbuf1.nchunks * sizeof(struct read_bufchunk_t));
+	if (!rbuf1.chunks) {
+		free(tab1);
+		CU_FAIL_FATAL("Couldn't allocate memory");
+	}
+	rbuf1.chunks[0] = (struct read_bufchunk_t) {
+		.buf = tab1,
+		.buflen = 200,
+		.interval = 2000
+	};
+	rbuf1.chunks[1] = (struct read_bufchunk_t) {
+		.buf = (tab1 + 200),
+		.buflen = 200,
+		.interval = 3000
+	};
+	rbuf1.chunks[2] = (struct read_bufchunk_t) {
+		.buf = (tab1 + 200 + 200),
+		.buflen = 350,
+		.interval = 2000
+	};
+	rbuf1.chunks[3] = (struct read_bufchunk_t) {
+		.buf = (tab1 + 200 + 200 + 350),
+		.buflen = 250,
+		.interval = 2500
+	};
+	rbuf2.mode = READ_WRITE_AFTER_INTERVAL;
+	rbuf2.nchunks = 1;
+	rbuf2.chunks = malloc(rbuf2.nchunks * sizeof(struct read_bufchunk_t));
+	if (!rbuf2.chunks) {
+		free(rbuf1.chunks);
+		free(tab1);
+		CU_FAIL_FATAL("Couldn't allocate memory");
+	}
+	rbuf2.chunks[0] = (struct read_bufchunk_t) {
+		.buf = tab1,
+		.buflen = tab1len,
+		.interval = 0
+	};
+	rbuf3.mode = READ_WRITE_REAL_INTERVAL;
+	rbuf3.nchunks = 2;
+	rbuf3.chunks = malloc(rbuf3.nchunks * sizeof(struct read_bufchunk_t));
+	if (!rbuf3.chunks) {
+		free(rbuf2.chunks);
+		free(rbuf1.chunks);
+		free(tab1);
+		CU_FAIL_FATAL("Couldn't allocate memory");
+	}
+	rbuf3.chunks[0] = (struct read_bufchunk_t) {
+		.buf = tab1,
+		.buflen = tab1len,
+		.interval = 4242
+	};
+	rbuf3.chunks[1] = (struct read_bufchunk_t) {
+		.buf = tab1,
+		.buflen = 0,
+		.interval = 0
+	};
+	int fd1 = 17, fd2 = 42, fd3 = 0;
+	CU_ASSERT_EQUAL(set_read_buffer(fd1, &rbuf1), 0);
+	CU_ASSERT_EQUAL(read_fd_table.n, 1);
+	CU_ASSERT_TRUE(fd_is_read_buffered(fd1));
+	CU_ASSERT_EQUAL(set_read_buffer(fd2, NULL), 0);
+	CU_ASSERT_EQUAL(read_fd_table.n, 1);
+	CU_ASSERT_TRUE(fd_is_read_buffered(fd1));
+	CU_ASSERT_FALSE(fd_is_read_buffered(fd2));
+	CU_ASSERT_EQUAL(set_read_buffer(fd1, NULL), 1);
+	CU_ASSERT_EQUAL(read_fd_table.n, 0);
+	CU_ASSERT_FALSE(fd_is_read_buffered(fd1));
+	CU_ASSERT_FALSE(fd_is_read_buffered(fd2));
+
+	struct timespec beforets1, afterts1, beforets2, afterts2, beforets3, afterts3;
+	CU_ASSERT_EQUAL_FATAL(clock_gettime(CLOCK_REALTIME, &beforets1), 0);
+	CU_ASSERT_EQUAL_FATAL(set_read_buffer(fd1, &rbuf1), 0);
+	CU_ASSERT_EQUAL_FATAL(clock_gettime(CLOCK_REALTIME, &afterts1), 0);
+	CU_ASSERT_EQUAL(read_fd_table.n, 1);
+	CU_ASSERT_TRUE(fd_is_read_buffered(fd1));
+
+	CU_ASSERT_EQUAL(set_read_buffer(fd2, &rbuf1), 0);
+	CU_ASSERT_TRUE(fd_is_read_buffered(fd2));
+	CU_ASSERT_EQUAL(read_fd_table.n, 2);
+	CU_ASSERT_EQUAL(read_fd_table.items[0].buf, &rbuf1);
+	CU_ASSERT_EQUAL(read_fd_table.items[0].fd, fd1);
+	CU_ASSERT_EQUAL(read_fd_table.items[1].buf, &rbuf1);
+	CU_ASSERT_EQUAL(read_fd_table.items[1].fd, fd2);
+
+	CU_ASSERT_EQUAL_FATAL(clock_gettime(CLOCK_REALTIME, &beforets3), 0);
+	CU_ASSERT_EQUAL(set_read_buffer(fd3, &rbuf3), 0);
+	CU_ASSERT_EQUAL_FATAL(clock_gettime(CLOCK_REALTIME, &afterts3), 0);
+	CU_ASSERT_EQUAL(read_fd_table.n, 3);
+	CU_ASSERT_TRUE(fd_is_read_buffered(fd3));
+	CU_ASSERT_EQUAL(read_fd_table.items[0].buf, &rbuf1);
+	CU_ASSERT_EQUAL(read_fd_table.items[0].fd, fd1);
+	CU_ASSERT_EQUAL(read_fd_table.items[1].buf, &rbuf1);
+	CU_ASSERT_EQUAL(read_fd_table.items[1].fd, fd2);
+	CU_ASSERT_EQUAL(read_fd_table.items[2].buf, &rbuf3);
+	CU_ASSERT_EQUAL(read_fd_table.items[2].fd, fd3);
+
+	CU_ASSERT_EQUAL(set_read_buffer(fd2, &rbuf2), 1);
+	CU_ASSERT_EQUAL(read_fd_table.n, 3);
+	CU_ASSERT_TRUE(fd_is_read_buffered(fd2));
+	CU_ASSERT_EQUAL(set_read_buffer(fd2, NULL), 1);
+	CU_ASSERT_EQUAL(read_fd_table.n, 2);
+	CU_ASSERT_FALSE(fd_is_read_buffered(fd2));
+	CU_ASSERT_EQUAL(set_read_buffer(fd2, NULL), 0);
+	CU_ASSERT_EQUAL(read_fd_table.n, 2);
+	CU_ASSERT_FALSE(fd_is_read_buffered(fd2));
+	CU_ASSERT_EQUAL(clock_gettime(CLOCK_REALTIME, &beforets2), 0);
+	CU_ASSERT_EQUAL(set_read_buffer(fd2, &rbuf2), 0);
+	CU_ASSERT_EQUAL(clock_gettime(CLOCK_REALTIME, &afterts2), 0);
+	CU_ASSERT_EQUAL(read_fd_table.n, 3);
+	CU_ASSERT_TRUE(fd_is_read_buffered(fd1));
+	CU_ASSERT_TRUE(fd_is_read_buffered(fd2));
+	CU_ASSERT_TRUE(fd_is_read_buffered(fd3));
+
+	CU_ASSERT_EQUAL(read_fd_table.items[0].fd, fd1);
+	CU_ASSERT_EQUAL(read_fd_table.items[0].buf, &rbuf1);
+	CU_ASSERT_EQUAL(read_fd_table.items[0].chunk_id, 0);
+	CU_ASSERT_EQUAL(read_fd_table.items[0].bytes_read, 0);
+	CU_ASSERT_EQUAL(read_fd_table.items[0].interval, 0);
+	CU_ASSERT_TRUE(timespec_is_between(&(read_fd_table.items[0].last_time), &beforets1, &afterts1));
+
+	CU_ASSERT_EQUAL(read_fd_table.items[2].fd, fd2);
+	CU_ASSERT_EQUAL(read_fd_table.items[2].buf, &rbuf2);
+	CU_ASSERT_EQUAL(read_fd_table.items[2].chunk_id, 0);
+	CU_ASSERT_EQUAL(read_fd_table.items[2].bytes_read, 0);
+	CU_ASSERT_EQUAL(read_fd_table.items[2].interval, 0);
+	CU_ASSERT_TRUE(timespec_is_between(&(read_fd_table.items[2].last_time), &beforets2, &afterts2));
+
+	CU_ASSERT_EQUAL(read_fd_table.items[1].fd, fd3);
+	CU_ASSERT_EQUAL(read_fd_table.items[1].buf, &rbuf3);
+	CU_ASSERT_EQUAL(read_fd_table.items[1].chunk_id, 0);
+	CU_ASSERT_EQUAL(read_fd_table.items[1].bytes_read, 0);
+	fprintf(stderr, "%lld %lld\n", (long long)read_fd_table.items[1].interval, (long long)rbuf3.chunks[0].interval);
+	CU_ASSERT_EQUAL(read_fd_table.items[1].interval, rbuf3.chunks[0].interval * MILLION);
+	CU_ASSERT_TRUE(timespec_is_between(&(read_fd_table.items[1].last_time), &beforets3, &afterts3));
+	CU_ASSERT_EQUAL(set_read_buffer(fd3, NULL), 1); // We don't need it
+	CU_ASSERT_EQUAL(read_fd_table.n, 2);
+	// Correctly set up of the tests: done
+	// Now, all we have to do is recv the data :-)
+	reinit_read_fd_table();
+	CU_ASSERT_EQUAL(read_fd_table.items, NULL);
+	CU_ASSERT_EQUAL(read_fd_table.n, 0);
+	CU_ASSERT_FALSE(fd_is_read_buffered(fd1));
+	CU_ASSERT_FALSE(fd_is_read_buffered(fd2));
+	CU_ASSERT_FALSE(fd_is_read_buffered(fd3));
+	free(tab1);
+	free(rbuf1.chunks);
+	free(rbuf2.chunks);
+	free(rbuf3.chunks);
+}
+
+void test_fragmented_recv_before()
+{
+	//int64_t MILLION = 1000*1000;
+	set_test_metadata("fragmented_recv_before", _("Tests the use of before-intervals"), 1);
+	MONITOR_ALL_RECV(monitored, true);
+	reinit_network_socket_stats();
+	reinit_read_fd_table();
+	int mode = READ_WRITE_BEFORE_INTERVAL;
+	size_t tab1len = 1000 * sizeof(int);
+	int *tab1 = malloc(tab1len);
+	if (!tab1)
+		CU_FAIL_FATAL("Memory");
+	for (int i = 0; i < 1000; i++) {
+		tab1[i] = i;
+	}
+	off_t offsets1[] = {200 * sizeof(int), 350 * sizeof(int), 445, 250 * sizeof(int), 200 * sizeof(int) - 445};
+	int intervals1[] = {20, 25, 10, 15, 20};
+	struct read_buffer_t rbuf1;
+	rbuf1.mode = mode;
+	if (create_partial_read_buffer(tab1, 5, offsets1, intervals1, &rbuf1)) {
+		free(tab1);
+		CU_FAIL_FATAL("Memory");
+	}
+	int fd1 = 42;
+	int r = set_read_buffer(fd1, &rbuf1);
+	if (r < 0) {
+		free(tab1);
+		free_partial_read_buffer(&rbuf1);
+		CU_FAIL_FATAL("Memory");
+	}
+	CU_ASSERT_EQUAL(r, 0);
+	TIMESPEC_ZERO(ts1);
+	TIMESPEC_ZERO(ts2);
+	TIMESPEC_ZERO(ts3);
+	TIMESPEC_ZERO(ts4);
+	TIMESPEC_ZERO(ts5);
+	TIMESPEC_ZERO(ts6);
+	TIMESPEC_ZERO(ts7);
+	TIMESPEC_ZERO(ts8);
+	TIMESPEC_ZERO(ts9);
+	TIMESPEC_ZERO(ts10);
+	ssize_t read1 = 0, read2 = 0, read3 = 0, read4 = 0, read5 = 0, read6 = 0, read7 = 0, read8 = 0, read9 = 0, cumread = 0;
+	int buf1[1010];
+	void *buf = buf1;
+	SANDBOX_BEGIN;
+	getnanotime(&ts1);
+	read1 = recv(fd1, buf, 250 * sizeof(int), 0); // Should wait 20msec and return 200*4 bytes, next chunk
+	cumread += read1;
+	fprintf(stderr, "1 %d %p\n", (int)cumread, (buf + cumread));
+	getnanotime(&ts2); // difference with 1 should be 20msec
+	read2 = recv(fd1, (buf + cumread), 250 * sizeof(int), 0); // Should wait 25msec and return (50+200)*4 bytes
+	cumread += read2;
+	fprintf(stderr, "2 %d %p\n", (int)cumread, (buf + cumread));
+	getnanotime(&ts3); // difference with 2 should be 25msec
+	read3 = recv(fd1, (buf + cumread), 250 * sizeof(int), 0); // Shouldn't wait and return 100*4 bytes, next chunk
+	cumread += read3;
+	fprintf(stderr, "3 %d %p\n", (int)cumread, (buf + cumread));
+	getnanotime(&ts4); // difference with 3 should be small
+	read4 = recv(fd1, (buf + cumread), 250 * sizeof(int), 0); // Should wait about 10msec and return 445 bytes, next chunk
+	cumread += read4;
+	fprintf(stderr, "4 %d %p\n", (int)cumread, (buf + cumread));
+	getnanotime(&ts5); // difference with 4 should be 10msec
+	struct timespec tss1 = (struct timespec) {.tv_sec = 0, .tv_nsec = 20*1000*1000}; // Shouldn't have any impact
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts6); // difference with 5 should be 20msec
+	read5 = recv(fd1, (buf + cumread), 250 * sizeof(int), 0); // Should wait about 15msec and return 250*4 bytes, next chunk
+	cumread += read5;
+	fprintf(stderr, "5 %d %p\n", (int)cumread, (buf + cumread));
+	getnanotime(&ts7); // difference with 6 should be 15msec
+	read6 = recv(fd1, (buf + cumread), 50 * sizeof(int), 0); // Should wait about 20msec and return 50*4 bytes
+	cumread += read6;
+	fprintf(stderr, "6 %d %p\n", (int)cumread, (buf + cumread));
+	getnanotime(&ts8); // difference with 7 should be 20msec
+	read7 = recv(fd1, (buf + cumread), 250 * sizeof(int), 0); // Shouldn't wait and return (200*4-50*4-445) = 155 bytes, end
+	cumread += read7;
+	fprintf(stderr, "7 %d %p\n", (int)cumread, (buf + cumread));
+	getnanotime(&ts9); // difference with 8 should be 0msec
+	read8 = recv(fd1, (buf + cumread), 250 * sizeof(int), 0); // Shouldn't wait and return 0 bytes, end
+	cumread += read8;
+	fprintf(stderr, "8 %d %p\n", (int)cumread, (buf + cumread));
+	read9 = recv(fd1, NULL, 250 * sizeof(int), 0); // Shouldn't wait, not read the buffer, and return 0 bytes, end
+	getnanotime(&ts10);
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(read1, 200*sizeof(int));
+	CU_ASSERT_EQUAL(read2, (50+200)*sizeof(int));
+	CU_ASSERT_EQUAL(read3, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read4, 445);
+	CU_ASSERT_EQUAL(read5, 250*sizeof(int));
+	CU_ASSERT_EQUAL(read6, 50*sizeof(int));
+	CU_ASSERT_EQUAL(read7, ((200-50)*sizeof(int)-445));
+	CU_ASSERT_EQUAL(read8, 0);
+	CU_ASSERT_EQUAL(read9, 0);
+	CU_ASSERT_EQUAL(cumread, 1000 * sizeof(int));
+	int64_t diff1 = get_time_interval(&ts1, &ts2),
+		diff2 = get_time_interval(&ts2, &ts3),
+		diff3 = get_time_interval(&ts3, &ts4),
+		diff4 = get_time_interval(&ts4, &ts5),
+		diff5 = get_time_interval(&ts5, &ts6),
+		diff6 = get_time_interval(&ts6, &ts7),
+		diff7 = get_time_interval(&ts7, &ts8),
+		diff8 = get_time_interval(&ts8, &ts9),
+		diff9 = get_time_interval(&ts9, &ts10);
+	fprintf(stderr, "%d %d %d %d %d %d %d %d %d\n", (int)read1, (int)read2, (int)read3, (int)read4, (int)read5, (int)read6, (int)read7, (int)read8, (int)read9);
+	fprintf(stderr, "%ld %ld %ld %ld %ld %ld %ld %ld %ld\n", (long)diff1, (long)diff2, (long)diff3, (long)diff4, (long)diff5, (long)diff6, (long)diff7, (long)diff8, (long)diff9);
+	/*
+	 * TODO should be used to check that the wait times are correct,
+	 * but it is extremely machine-dependent.
+	CU_ASSERT_TRUE(is_quasi_equal(diff1, 20*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff2, 25*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff3, 0*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff4, 10*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff5, 20*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff6, 15*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff7, 20*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff8, 0*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff9, 0*MILLION));*/
+	for (int i = 0; i < 1000; i++) {
+		CU_ASSERT_EQUAL(buf1[i], i);
+	}
+	for (int i = 0; i < 1000; i++) {
+		CU_ASSERT_EQUAL(tab1[i], i);
+	}
+	free_partial_read_buffer(&rbuf1);
+	free(tab1);
+}
+
+void test_fragmented_recv_after()
+{
+	set_test_metadata("fragmented_recv_after", _("Tests the use of after-intervals"), 1);
+	int64_t MILLION = 1000*1000;
+	MONITOR_ALL_RECV(monitored, true);
+	reinit_network_socket_stats();
+	reinit_read_fd_table();
+	int mode = READ_WRITE_AFTER_INTERVAL;
+	size_t tab1len = 1000 * sizeof(int);
+	int *tab1 = malloc(tab1len);
+	if (!tab1)
+		CU_FAIL_FATAL("Memory");
+	for (int i = 0; i < 1000; i++)
+		tab1[i] = i;
+	off_t offsets1[] = {250 * sizeof(int), 150 * sizeof(int), 150 * sizeof(int), 200 * sizeof(int), 150 * sizeof(int), 100 * sizeof(int)};
+	int intervals1[] = {20, 20, 20, 20, 20, 20};
+	struct read_buffer_t rbuf1;
+	rbuf1.mode = mode;
+	if (create_partial_read_buffer(tab1, 6, offsets1, intervals1, &rbuf1)) {
+		free(tab1);
+		CU_FAIL_FATAL("Memory");
+	}
+	int fd1 = 42;
+	int r = set_read_buffer(fd1, &rbuf1);
+	if (r < 0) {
+		free(tab1);
+		free_partial_read_buffer(&rbuf1);
+		CU_FAIL_FATAL("Memory");
+	}
+	CU_ASSERT_EQUAL(r, 0);
+	TIMESPEC_ZERO(ts1);
+	TIMESPEC_ZERO(ts2);
+	TIMESPEC_ZERO(ts3);
+	TIMESPEC_ZERO(ts4);
+	TIMESPEC_ZERO(ts5);
+	TIMESPEC_ZERO(ts6);
+	TIMESPEC_ZERO(ts7);
+	TIMESPEC_ZERO(ts8);
+	TIMESPEC_ZERO(ts9);
+	TIMESPEC_ZERO(ts10);
+	TIMESPEC_ZERO(ts11);
+	ssize_t read1 = 0, read2 = 0, read3 = 0, read4 = 0, read5 = 0, read6 = 0, read7 = 0, read8 = 0, read9 = 0, cumread = 0;
+	int errno5 = 0;
+	errno = 0;
+	int buf1[1010];
+	void *buf = buf1;
+	SANDBOX_BEGIN;
+	getnanotime(&ts1);
+	read1 = recv(fd1, (buf + cumread), 200 * sizeof(int), 0); // Wait 20, return 200
+	cumread += read1;
+	getnanotime(&ts2);
+	read2 = recv(fd1, (buf + cumread), 200 * sizeof(int), 0); // No wait, return 50
+	cumread += read2;
+	getnanotime(&ts3);
+	read3 = recv(fd1, (buf + cumread), 200 * sizeof(int), 0); // Wait 20, return 150
+	cumread += read3;
+	getnanotime(&ts4);
+	struct timespec tss1 = (struct timespec) {
+		.tv_sec = 0,
+		.tv_nsec = 20*MILLION
+	};
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts5);
+	read4 = recv(fd1, (buf + cumread), 200 * sizeof(int), 0); // No wait, return 150
+	cumread += read4;
+	getnanotime(&ts6);
+	read5 = recv(fd1, (buf + cumread), 200 * sizeof(int), MSG_DONTWAIT); // No wait, return -1, errno = EAGAIN | EWOULDBLOCK
+	errno5 = errno;
+	getnanotime(&ts7);
+	read6 = recv(fd1, (buf + cumread), 200 * sizeof(int), 0); // Wait, return 200
+	cumread += read6;
+	getnanotime(&ts8);
+	tss1.tv_nsec = 20*MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts9);
+	read7 = recv(fd1, (buf + cumread), 200 * sizeof(int), MSG_DONTWAIT); // No wait, return 150
+	cumread += read7;
+	getnanotime(&ts10);
+	read8 = recv(fd1, (buf + cumread), 200 * sizeof(int), 0); // Wait, return 100
+	cumread += read8;
+	getnanotime(&ts11);
+	read9 = recv(fd1, (buf + cumread), 42, 0); // No wait, return 0
+	SANDBOX_END;
+	CU_ASSERT_EQUAL(read1, 200*sizeof(int));
+	CU_ASSERT_EQUAL(read2, 50*sizeof(int));
+	CU_ASSERT_EQUAL(read3, 150*sizeof(int));
+	CU_ASSERT_EQUAL(read4, 150*sizeof(int));
+	CU_ASSERT_EQUAL(read5, -1);
+	CU_ASSERT_TRUE(errno5 == EAGAIN || errno == EWOULDBLOCK);
+	CU_ASSERT_EQUAL(read6, 200*sizeof(int));
+	CU_ASSERT_EQUAL(read7, 150*sizeof(int));
+	CU_ASSERT_EQUAL(read8, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read9, 0);
+	CU_ASSERT_EQUAL(cumread, 1000*sizeof(int));
+	fprintf(stderr, "%d %d %d %d %d %d %d %d %d\n", (int)read1, (int)read2, (int)read3, (int)read4, (int)read5, (int)read6, (int)read7, (int)read8, (int)read9);
+	int64_t diff1 = get_time_interval(&ts1, &ts2); // 20msec
+	int64_t diff2 = get_time_interval(&ts2, &ts3); // 0
+	int64_t diff3 = get_time_interval(&ts3, &ts4); // 20
+	int64_t diff5 = get_time_interval(&ts5, &ts6); // 0
+	int64_t diff6 = get_time_interval(&ts6, &ts7); // 0
+	int64_t diff7 = get_time_interval(&ts7, &ts8); // 20
+	int64_t diff9 = get_time_interval(&ts9, &ts10); // 0
+	int64_t diff10 = get_time_interval(&ts10, &ts11); // 20
+	fprintf(stderr, "%ld %ld %ld %ld %ld %ld %ld %ld\n", (long)diff1, (long)diff2, (long)diff3, (long)diff5, (long)diff6, (long)diff7, (long)diff9, (long)diff10);
+	/*
+	 * TODO Should be used to check wait time,
+	 * but is too much machine-dependent.
+	CU_ASSERT_TRUE(is_quasi_equal(diff1, 20*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff2, 0*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff3, 20*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff5, 0*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff6, 0*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff7, 20*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff9, 0*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff10, 20*MILLION));*/
+	for (int i = 0; i < 1000; i++) {
+		CU_ASSERT_EQUAL(buf1[i], i);
+		CU_ASSERT_EQUAL(tab1[i], i);
+	}
+	free_partial_read_buffer(&rbuf1);
+	free(tab1);
+}
+
+/*
+ * FIXME this test can sometimes fail, as it depends on the real-time property
+ * of the machine on which it is run.
+ * TODO Make this independent of the machine. Maybe remove the API...
+ */
+void test_fragmented_recv_realtime()
+{
+	set_test_metadata("fragmented_recv_realtime", _("Tests the use of real-time-intervals"), 1);
+	int64_t MILLION = 1000*1000;
+	MONITOR_ALL_RECV(monitored, true);
+	monitored.read = true; // Otherwise it won't work
+	reinit_network_socket_stats();
+	reinit_read_fd_table();
+	int mode = READ_WRITE_REAL_INTERVAL;
+	size_t tab1len = 1000 * sizeof(int);
+	int *tab1 = malloc(tab1len);
+	if (!tab1)
+		CU_FAIL_FATAL("Memory");
+	for (int i = 0; i < 1000; i++)
+		tab1[i] = i;
+	off_t offsets1[] = {200*sizeof(int), 200*sizeof(int), 200*sizeof(int), 200*sizeof(int), 200*sizeof(int)};
+	int intervals1[] = {2*100, 5*100, 1*100, 1*100, 3*100};
+	struct read_buffer_t *rbuf1 = create_read_buffer(tab1, 5, offsets1, intervals1, mode);
+	if (!rbuf1) {
+		free(tab1);
+		CU_FAIL_FATAL("Memory");
+	}
+	int fd1 = 42;
+	int r = set_read_buffer(fd1, rbuf1);
+	if (r < 0) {
+		free(tab1);
+		free_read_buffer(rbuf1);
+		CU_FAIL_FATAL("Memory");
+	}
+	CU_ASSERT_EQUAL(r, 0);
+	TIMESPEC_ZERO(tss1);
+	TIMESPEC_ZERO(ts0);
+	TIMESPEC_ZERO(ts1);
+	TIMESPEC_ZERO(ts2);
+	TIMESPEC_ZERO(ts3);
+	TIMESPEC_ZERO(ts4);
+	TIMESPEC_ZERO(ts5);
+	TIMESPEC_ZERO(ts6);
+	TIMESPEC_ZERO(ts7);
+	TIMESPEC_ZERO(ts8);
+	TIMESPEC_ZERO(ts9);
+	TIMESPEC_ZERO(ts10);
+	TIMESPEC_ZERO(ts11);
+	TIMESPEC_ZERO(ts12);
+	TIMESPEC_ZERO(ts13);
+	TIMESPEC_ZERO(ts14);
+	TIMESPEC_ZERO(ts15);
+	ssize_t read1 = 0, read2 = 0, read3 = 0, read4 = 0, read5 = 0, read6 = 0, read7 = 0, read8 = 0, read9 = 0, cumread = 0;
+	int errno3 = 0;
+	errno = 0;
+	int buf1[1100];
+	memset(buf1, 0, sizeof(buf1));
+	void *buf = buf1;
+	SANDBOX_BEGIN;
+	getnanotime(&ts0);
+
+	tss1.tv_nsec = 300 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts1);
+
+	read1 = recv(fd1, (buf+cumread), 100*sizeof(int), 0); // No wait, return 100
+	cumread += read1;
+	getnanotime(&ts2);
+
+	tss1.tv_nsec = 200 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts3);
+
+	read2 = read(fd1, (buf+cumread), 150*sizeof(int)); // No wait, return 100
+	cumread += read2;
+	getnanotime(&ts4);
+
+	read3 = recv(fd1, (buf+cumread), 50*sizeof(int), MSG_DONTWAIT); // No wait, return -1, errno
+	errno3 = errno;
+	getnanotime(&ts5);
+
+	tss1.tv_nsec = 100 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts6);
+
+	read4 = recv(fd1, (buf+cumread), 50*sizeof(int), 0); // Wait 10, return 50
+	cumread += read4;
+	getnanotime(&ts7);
+
+	tss1.tv_nsec = 200 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts8);
+
+	read5 = recv(fd1, (buf+cumread), 100*sizeof(int), 0); // No wait, return 100
+	cumread += read5;
+	getnanotime(&ts9);
+
+	tss1.tv_nsec = 200 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts10);
+
+	read6 = read(fd1, (buf+cumread), 350*sizeof(int)); // No wait, return 350
+	cumread += read6; // 700
+	getnanotime(&ts11);
+
+	tss1.tv_nsec = 200 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts12);
+
+	read7 = recv(fd1, (buf+cumread), 200*sizeof(int), MSG_DONTWAIT); // No wait, return 200
+	cumread += read7;
+	getnanotime(&ts13);
+
+	tss1.tv_nsec = 200 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts14);
+
+	read8 = read(fd1, (buf+cumread), 200*sizeof(int)); // No wait, return 100
+	cumread += read8;
+	getnanotime(&ts15);
+
+	read9 = read(fd1, (buf+cumread), 200*sizeof(int)); // No wait, return 0
+	SANDBOX_END;
+	fprintf(stderr, "first test, reads: %d %d %d %d %d %d %d %d %d\n", (int)read1, (int)read2, (int)read3, (int)read4, (int)read5, (int)read6, (int)read7, (int)read8, (int)read9);
+	CU_ASSERT_EQUAL(read1, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read2, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read3, -1);
+	CU_ASSERT_TRUE(errno3 == EAGAIN || EWOULDBLOCK);
+	CU_ASSERT_EQUAL(read4, 50*sizeof(int));
+	CU_ASSERT_EQUAL(read5, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read6, 350*sizeof(int));
+	CU_ASSERT_EQUAL(read7, 200*sizeof(int));
+	CU_ASSERT_EQUAL(read8, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read9, 0);
+	int64_t diff1 = get_time_interval(&ts1, &ts2); // 0
+	int64_t diff2 = get_time_interval(&ts3, &ts4); // 0
+	int64_t diff3 = get_time_interval(&ts4, &ts5); // 0
+	int64_t diff4 = get_time_interval(&ts6, &ts7); // 10
+	int64_t diff5 = get_time_interval(&ts8, &ts9); // 0
+	int64_t diff6 = get_time_interval(&ts10, &ts11); // 0
+	int64_t diff7 = get_time_interval(&ts12, &ts13); // 0
+	int64_t diff8 = get_time_interval(&ts14, &ts15); // 0
+	int64_t diff11 = get_time_interval(&ts2, &ts3); // 40
+	int64_t diff31 = get_time_interval(&ts5, &ts6); // 10
+	int64_t diff41 = get_time_interval(&ts7, &ts8); // 20
+	int64_t diff51 = get_time_interval(&ts9, &ts10); // 20
+	int64_t diff61 = get_time_interval(&ts11, &ts12); // 20
+	int64_t diff71 = get_time_interval(&ts13, &ts14); // 20
+	fprintf(stderr, "first test, diff1 %ld %ld %ld %ld diff31 %ld %ld %ld %ld diff51 %ld %ld %ld %ld %ld diff8 %ld\n", diff1, diff11, diff2, diff3, diff31, diff4, diff41, diff5, diff51, diff6, diff61, diff7, diff71, diff8);
+	/*
+	 * TODO Should be used to check wait time,
+	 * but is too much machine-dependent.
+	CU_ASSERT_TRUE(diff1 <= MILLION);
+	CU_ASSERT_TRUE(diff2 <= MILLION);
+	CU_ASSERT_TRUE(diff3 <= MILLION);
+	CU_ASSERT_TRUE(diff4 <= 10*MILLION);
+	CU_ASSERT_TRUE(diff5 <= MILLION);
+	CU_ASSERT_TRUE(diff6 <= MILLION);
+	CU_ASSERT_TRUE(diff7 <= MILLION);
+	CU_ASSERT_TRUE(diff8 <= MILLION);*/
+	for (int i = 0; i < 1000; i++) {
+		CU_ASSERT_EQUAL(buf1[i], i);
+		CU_ASSERT_EQUAL(tab1[i], i);
+	}
+	for (int i = 1000; i < 1100; i++)
+		CU_ASSERT_EQUAL(buf1[i], 0);
+	free_partial_read_buffer(rbuf1);
+	// End of test 1
+	// Begin of test 2
+	off_t offsets2[] = {400*sizeof(int), 400*sizeof(int), 200*sizeof(int)};
+	int intervals2[] = {2*100, 4*100, 5*100};
+	if (create_partial_read_buffer(tab1, 3, offsets2, intervals2, rbuf1)) {
+		free(tab1);
+		free(rbuf1);
+	}
+	if (!fd_is_read_buffered(fd1)) {
+		free(tab1);
+		free_read_buffer(rbuf1);
+		CU_FAIL_FATAL("Memory");
+	}
+	r = set_read_buffer(fd1, rbuf1); // Again
+	CU_ASSERT_EQUAL(r, 1);
+	TS_ZERO(ts0);
+	TS_ZERO(ts1);
+	TS_ZERO(ts2);
+	TS_ZERO(ts3);
+	TS_ZERO(ts4);
+	TS_ZERO(ts5);
+	TS_ZERO(ts6);
+	TS_ZERO(ts7);
+	TS_ZERO(ts8);
+	TS_ZERO(ts9);
+	TS_ZERO(ts10);
+	TS_ZERO(ts11);
+	TS_ZERO(ts12);
+	TS_ZERO(ts13);
+	TS_ZERO(ts14);
+	TS_ZERO(ts15);
+	TIMESPEC_ZERO(ts16);
+	TIMESPEC_ZERO(ts17);
+	TIMESPEC_ZERO(ts18);
+	TIMESPEC_ZERO(ts19);
+	TIMESPEC_ZERO(ts20);
+	TS_ZERO(tss1);
+	read1 = 0; read2 = 0; read3 = 0; read4 = 0; read5 = 0; read6 = 0; read7 = 0, read8 = 0, read9 = 0, cumread = 0;
+	ssize_t read10 = 0, read11 = 0;
+	memset(buf1, 0, sizeof(buf1));
+	SANDBOX_BEGIN;
+	getnanotime(&ts0);
+
+	tss1.tv_nsec = 100 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts1);
+
+	read1 = recv(fd1, (buf+cumread), 100*sizeof(int), 0); // 100, wait 100
+	cumread += read1;
+	getnanotime(&ts2);
+
+	tss1.tv_nsec = 100 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts3);
+
+	read2 = recv(fd1, (buf+cumread), 200*sizeof(int), 0); // 200, wait 0
+	cumread += read2;
+	getnanotime(&ts4);
+
+	tss1.tv_nsec = 100 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts5);
+
+	read3 = recv(fd1, (buf+cumread), 200*sizeof(int), 0); // 100, wait 0
+	cumread += read3;
+	getnanotime(&ts6);
+
+	tss1.tv_nsec = 100 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts7);
+
+	read4 = recv(fd1, (buf+cumread), 100*sizeof(int), 0); // 100, wait 100
+	cumread += read4;
+	getnanotime(&ts8);
+
+	tss1.tv_nsec = 100 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts9);
+
+	read5 = recv(fd1, (buf+cumread), 100*sizeof(int), 0); // 150, wait 0
+	cumread += read5;
+	getnanotime(&ts10);
+
+	tss1.tv_nsec = 100 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts11);
+
+	read6 = read(fd1, (buf+cumread), 100*sizeof(int)); // 150, wait 0
+	cumread += read6;
+	getnanotime(&ts12);
+
+	tss1.tv_nsec = 100 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts13);
+
+	read8 = read(fd1, (buf+cumread), 100*sizeof(int)); // 100, wait 0, emptied
+	cumread += read8;
+	getnanotime(&ts16);
+
+	tss1.tv_nsec = 100 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts17);
+
+	read9 = read(fd1, (buf+cumread), 150*sizeof(int)); // 150, wait 100
+	cumread += read9;
+	getnanotime(&ts18);
+
+	tss1.tv_nsec = 200 * MILLION;
+	nanosleep(&tss1, NULL);
+	getnanotime(&ts19);
+
+	read10 = recv(fd1, (buf+cumread), 50*sizeof(int), 0); // 50, wait 0
+	cumread += read10;
+	getnanotime(&ts20);
+
+	read11 = recv(fd1, (buf+cumread), 50*sizeof(int), 0); // 0, wait 0
+	SANDBOX_END;
+	fprintf(stderr, "second test, reads %d %d %d %d %d %d %d %d %d %d\n", (int)read1, (int)read2, (int)read3, (int)read4, (int)read5, (int)read6, (int)read8, (int)read9, (int)read10, (int)read11);
+	CU_ASSERT_EQUAL(read1, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read2, 200*sizeof(int));
+	CU_ASSERT_EQUAL(read3, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read4, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read5, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read6, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read8, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read9, 150*sizeof(int));
+	CU_ASSERT_EQUAL(read10, 50*sizeof(int));
+	CU_ASSERT_EQUAL(read11, 0);
+	diff1 = get_time_interval(&ts1, &ts2);
+	diff2 = get_time_interval(&ts3, &ts4);
+	diff3 = get_time_interval(&ts5, &ts6);
+	diff4 = get_time_interval(&ts7, &ts8);
+	diff5 = get_time_interval(&ts9, &ts10);
+	diff6 = get_time_interval(&ts11, &ts12);
+	diff7 = get_time_interval(&ts13, &ts16);
+	int64_t diff9 = get_time_interval(&ts17, &ts18);
+	int64_t diff10 = get_time_interval(&ts19, &ts20);
+	fprintf(stderr, "second test, diff1 %ld %ld %ld diff4 %ld %ld %ld diff7 %ld %ld diff10 %ld\n", (long)diff1, (long)diff2, (long)diff3, (long)diff4, (long)diff5, (long)diff6, (long)diff7, (long)diff9, (long)diff10);
+	/*
+	 * TODO Should be used to check wait time,
+	 * but is machine-dependent.
+	CU_ASSERT_TRUE(is_quasi_equal(diff1, 10*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff2, 0*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff3, 0*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff4, 10*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff5, 0*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff6, 0*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff7, 0*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff8, 0*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff9, 10*MILLION));
+	CU_ASSERT_TRUE(is_quasi_equal(diff10, 0*MILLION)); */
+	for (int i = 0; i < 1000; i++) {
+		//fprintf(stderr, "%d %d %d\n", i, tab1[i], buf1[i]);
+		CU_ASSERT_EQUAL(buf1[i], i);
+		CU_ASSERT_EQUAL(tab1[i], i);
+	}
+	for (int i = 1000; i < 1100; i++)
+		CU_ASSERT_EQUAL(buf1[i], 0);
+	free_partial_read_buffer(rbuf1);
+	// End of test 2
+	// Begin of test 3
+	off_t offsets3[10] = {250*sizeof(int), 100*sizeof(int), 100*sizeof(int), 100*sizeof(int), 100*sizeof(int), 100*sizeof(int), 100*sizeof(int), 50*sizeof(int), 50*sizeof(int), 50*sizeof(int)};
+	int intervals3[10] = {2*50, 4*50, 6*50, 1*50, 1*50, 1*50, 2*50, 3*50, 3*50, 1*50};
+	if (create_partial_read_buffer(tab1, 10, offsets3, intervals3, rbuf1)) {
+		free(tab1);
+		free(rbuf1);
+	}
+	r = set_read_buffer(fd1, rbuf1);
+	CU_ASSERT_EQUAL_FATAL(r, 1);
+	// TODO check time interval
+	TS_ZERO(tss1);
+	read1 = 0; read2 = 0; read3 = 0; read4 = 0; read5 = 0; read6 = 0;
+	read7 = 0; read8 = 0; read9 = 0; read10 = 0; read11 = 0; cumread = 0;
+	ssize_t read12 = 0, read13 = 0, read14 = 0;
+	memset(buf1, 0, sizeof(buf1));
+	SANDBOX_BEGIN;
+	tss1.tv_nsec = 3*50*MILLION;
+	nanosleep(&tss1, NULL);
+
+	read1 = recv(fd1, (buf+cumread), 100*sizeof(int), 0);
+	cumread += read1;
+
+	tss1.tv_nsec = 2*50*MILLION;
+	nanosleep(&tss1, NULL);
+
+	read2 = recv(fd1, (buf+cumread), 100*sizeof(int), 0);
+	cumread += read2;
+
+	tss1.tv_nsec = 2*50*MILLION;
+	nanosleep(&tss1, NULL);
+
+	read3 = recv(fd1, (buf+cumread), 100*sizeof(int), 0);
+	cumread += read3;
+
+	tss1.tv_nsec = 2*50*MILLION;
+	nanosleep(&tss1, NULL);
+
+	read4 = recv(fd1, (buf+cumread), 100*sizeof(int), 0); // 50
+	cumread += read4;
+
+	tss1.tv_nsec = 2*50*MILLION;
+	nanosleep(&tss1, NULL);
+
+	read5 = recv(fd1, (buf+cumread), 50*sizeof(int), 0); // wait 1*50
+	cumread += read5;
+
+	tss1.tv_nsec = 2*50*MILLION;
+	nanosleep(&tss1, NULL);
+
+	read6 = recv(fd1, (buf+cumread), 20*sizeof(int), 0);
+	cumread += read6;
+
+	tss1.tv_nsec = 1*50*MILLION;
+	nanosleep(&tss1, NULL);
+
+	read7 = recv(fd1, (buf+cumread), (30+50)*sizeof(int), 0);
+	cumread += read7;
+
+	tss1.tv_nsec = 1*50*MILLION;
+	nanosleep(&tss1, NULL);
+
+	read8 = recv(fd1, (buf+cumread), 200*sizeof(int), 0);
+	cumread += read8;
+
+	tss1.tv_nsec = 2*50*MILLION;
+	nanosleep(&tss1, NULL);
+
+	read9 = recv(fd1, (buf+cumread), 50*sizeof(int), 0);
+	cumread += read9;
+
+	tss1.tv_nsec = 1*50*MILLION;
+	nanosleep(&tss1, NULL);
+
+	read10 = recv(fd1, (buf+cumread), 100*sizeof(int), 0);
+	cumread += read10;
+
+	tss1.tv_nsec = 2*50*MILLION;
+	nanosleep(&tss1, NULL);
+
+	read11 = recv(fd1, (buf+cumread), 100*sizeof(int), 0); // 50
+	cumread += read11;
+
+	tss1.tv_nsec = 1*50*MILLION;
+	nanosleep(&tss1, NULL);
+
+	read12 = recv(fd1, (buf+cumread), 100*sizeof(int), 0); // 50, wait 1*50
+	cumread += read12;
+
+	tss1.tv_nsec = 1*50*MILLION;
+	nanosleep(&tss1, NULL);
+
+	read13 = recv(fd1, (buf+cumread), 50*sizeof(int), 0);
+	cumread += read13;
+
+	read14 = recv(fd1, (buf+cumread), 50*sizeof(int), 0);
+	cumread += read14;
+	SANDBOX_END;
+	fprintf(stderr, "third test, reads %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n",
+			(int)read1, (int)read2, (int)read3, (int)read4, (int)read5,
+			(int)read6, (int)read7, (int)read8, (int)read9, (int)read10,
+			(int)read11, (int)read12, (int)read13, (int)read14);
+	CU_ASSERT_EQUAL(read1, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read2, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read3, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read4, 50*sizeof(int));
+	CU_ASSERT_EQUAL(read5, 50*sizeof(int));
+	CU_ASSERT_EQUAL(read6, 20*sizeof(int));
+	CU_ASSERT_EQUAL(read7, 80*sizeof(int));
+	CU_ASSERT_EQUAL(read8, 200*sizeof(int));
+	CU_ASSERT_EQUAL(read9, 50*sizeof(int));
+	CU_ASSERT_EQUAL(read10, 100*sizeof(int));
+	CU_ASSERT_EQUAL(read11, 50*sizeof(int));
+	CU_ASSERT_EQUAL(read12, 50*sizeof(int));
+	CU_ASSERT_EQUAL(read13, 50*sizeof(int));
+	CU_ASSERT_EQUAL(read14, 0*sizeof(int));
+	for (int i = 0; i < 1000; i++) {
+		CU_ASSERT_EQUAL(i, buf1[i]);
+		CU_ASSERT_EQUAL(i, tab1[i]);
+	}
+	for (int i = 1000; i < 1100; i++)
+		CU_ASSERT_EQUAL(buf1[i], 0);
+	free_read_buffer(rbuf1);
+}
+
+// Check failures:
+// Recall we must use the failures struct, and assign its (call), (call)_ret and (call)_errno fields.
+// And we have the fileds FAIL_ALWAYS, FAIL_NEVER, FAIL_FIRST, FAIL_SECOND, FAIL_THIRD and FAIL_TWICE
+
+int main(int argc, char **argv)
+{
+	RUN(
+			test_fragmented_recv,
+			test_fragmented_recv_before,
+			test_fragmented_recv_after,
+			test_fragmented_recv_realtime
+	   );
+}
+
diff --git a/doc/.gitignore b/doc/.gitignore
new file mode 100644
index 0000000..f70f32b
--- /dev/null
+++ b/doc/.gitignore
@@ -0,0 +1,3 @@
+_build/
+doxygen_output/
+_build/
diff --git a/doc/Doxyfile b/doc/Doxyfile
new file mode 100644
index 0000000..dc6106c
--- /dev/null
+++ b/doc/Doxyfile
@@ -0,0 +1,1451 @@
+# Doxyfile 1.8.5
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+DOXYFILE_ENCODING      = UTF-8
+
+PROJECT_NAME           = "CTester"
+
+PROJECT_NUMBER         = "1.0.0"
+
+PROJECT_BRIEF          =
+
+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       = "./doxygen_output"
+
+CREATE_SUBDIRS         = NO
+
+OUTPUT_LANGUAGE        = English
+
+# 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       =
+
+# 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    =
+
+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      = YES
+
+# 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
+
+# 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.
+
+ALIASES                =
+
+TCL_SUBST              =
+
+# 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
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+OPTIMIZE_OUTPUT_VHDL   = 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,
+# C#, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL. 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.
+
+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 http://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 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 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:
+# http://www.riverbankcomputing.co.uk/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
+
+# 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
+
+#---------------------------------------------------------------------------
+# 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_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. When 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 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
+# (class|struct|union) 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          = YES
+
+# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
+# names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+# 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 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 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.
+# 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 http://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. Do not use file names with spaces, bibtex cannot handle them. See
+# also \cite for info how to create references.
+
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+QUIET                  = NO
+
+WARNINGS               = YES
+
+WARN_IF_UNDOCUMENTED   = YES
+
+WARN_IF_DOC_ERROR      = YES
+
+WARN_NO_PARAMDOC       = NO
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# Writes to stdout by default
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# 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.
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = "../student"
+
+# 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: http://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. 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, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
+# *.qsf, *.as and *.js.
+
+FILE_PATTERNS          = "*.h"
+
+# 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              = YES
+
+# 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       = "*.c"
+
+# 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.
+
+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.
+
+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
+# function 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 http://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 config 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
+
+#---------------------------------------------------------------------------
+# 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
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# 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 an additional user-
+# defined cascading style sheet that is 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 therefor more robust against future updates.
+# Doxygen will copy the style sheet file to the output directory. 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 stylesheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# http://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 NO can help when comparing the output of multiple runs.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = NO
+
+# 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: http://developer.apple.com/tools/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 http://developer.apple.com/tools/creatingdocsetswithdoxygen.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: http://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
+
+# 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 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
+
+# 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 stylesheets (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
+
+# When 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
+
+# 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_TRANPARENT 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
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# http://www.mathjax.org) which uses client side Javascript for the rendering
+# instead of using prerendered 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            = YES
+
+# 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/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 http://www.mathjax.org before deployment.
+# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+
+# 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/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.
+
+# We don't use Doxygen's search tool
+
+SEARCHENGINE           = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# We don't use LaTeX
+GENERATE_LATEX         = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+GENERATE_RTF           = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+GENERATE_MAN           = 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.
+
+# Set to YES for breathe to work
+GENERATE_XML           = YES
+
+# 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"
+
+# The XML_SCHEMA tag can be used to specify a XML schema, which can be used by a
+# validating XML parser to check the syntax of the XML files.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_SCHEMA             =
+
+# The XML_DTD tag can be used to specify a XML DTD, which can be used by a
+# validating XML parser to check the syntax of the XML files.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_DTD                =
+
+# 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
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+GENERATE_DOCBOOK       = NO
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+GENERATE_PERLMOD       = NO
+
+#---------------------------------------------------------------------------
+# 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 includes 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             =
+
+# 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 refrences 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 an 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
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of 'which perl').
+# The default file (with absolute path) is: /usr/bin/perl.
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# This is not CPP, so we don't use this.
+
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = NO
+
+HAVE_DOT               = NO
+
+CLASS_GRAPH            = NO
diff --git a/doc/Makefile b/doc/Makefile
new file mode 100644
index 0000000..d4bb2cb
--- /dev/null
+++ b/doc/Makefile
@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/doc/README.md b/doc/README.md
new file mode 100644
index 0000000..f9e65e2
--- /dev/null
+++ b/doc/README.md
@@ -0,0 +1,8 @@
+# CTester documentation
+
+To compile to HTML, simply call `make html`. `make` alone gives you the different choices.
+
+Note that Doxygen support is somewhat included.
+Ideally, one day it should integrate with the reST documentation,
+ideally using the Breathe extension.
+
diff --git a/doc/api.rst b/doc/api.rst
new file mode 100644
index 0000000..3c2d15f
--- /dev/null
+++ b/doc/api.rst
@@ -0,0 +1,29 @@
+.. _api_index:
+
+=============
+API reference
+=============
+
+Wrappers
+========
+
+.. toctree::
+    :maxdepth: 2
+
+    api/wrap_file
+    api/wrap_mallocs
+    api/wrap_mutexs
+    api/wrap_sockets
+    api/wrap_util_dns
+    api/wrap_util_inet
+    api/wrap_misc
+
+Utility functions
+=================
+
+.. toctree::
+    :maxdepth: 2
+
+    api/read_write
+    api/trap
+    api/util_sockets
diff --git a/doc/api/read_write.rst b/doc/api/read_write.rst
new file mode 100644
index 0000000..d506929
--- /dev/null
+++ b/doc/api/read_write.rst
@@ -0,0 +1,478 @@
+.. _read_write:
+
+=========================
+Controlled read and write
+=========================
+
+The files ``CTester/read_write.h`` and ``CTester/read_write.c`` provide an API
+allowing a more fine-tuned control of the :manpage:`read(2)` and
+:manpage:`write(2)` system calls.
+
+Currently, this API consists of partial read and write.
+
+.. _partial_read_write:
+
+Partial read and write
+======================
+
+The :code:`read` system call (and its :code:`recv` relatives), whose prototype is::
+
+    ssize_t read(int fd, void *buf, size_t count);
+
+attempts to read up to :code:`count` bytes from the file descriptor :code:`fd` into
+the buffer starting at :code:`buf`, and returns the actual number of bytes read
+from :code:`fd` (let's call it :code:`read_count`), or -1 if there was an error.
+
+There is a lot of circumstances that can lead to a number of bytes read that is
+less than the requested amount :code:`count`, without any error:
+we can possibly read from a pipe, or from a socket, or from a terminal.
+Reading less bytes than requested simply means that the underlying device
+couldn't provide more bytes at the time, but may give more bytes
+at a later call.
+
+For :code:`recv` and related, this is even more true: if the socket refers
+to an UDP connection, then the :code:`recv` calls can only return one datagram
+at a time. Generally, these calls return as soon as they have at least one byte
+available (if they were configured as non-blocking, they return nearly
+immediately), and return as many bytes as possible, up to the requested amount,
+without waiting for the full amount.
+
+The :code:`write` system call has a similar behaviour, but for different reasons:
+there may be not enough space on the underlying medium (eg: disk), the pipe or
+buffer may be near-full, or the requested amount is greater than the size of
+a packet, datagram or segment.
+
+The student is of course expected to be able to handle these system calls
+correctly, and hence to be able to handle these "partial read" and
+"partial write". The API here described allows the teacher to test that they
+correctly handle these behaviours.
+
+When partial reads are used, CTester replaces the calls to the real :code:`read`
+calls to a real file descriptor, with reads from a teacher-supplied buffer,
+with pre-determined chunks of custom sizes and custom availability delay.
+
+Currently, partial writes are not supported, as they are ill-defined.
+
+The buffers
+-----------
+
+The buffer used in the partial read is defined by the following
+structures::
+
+    struct read_bufchunk_t {
+        int interval;
+        const void *buf;
+        size_t buflen;
+    };
+    struct read_buffer_t {
+        int mode;
+        size_t nchunks;
+        struct read_bufchunk_t *chunks;
+    };
+
+.. c:type:: struct read_bufchunk_t
+
+   This structure is used to specify a chunk: a piece of continuous data that,
+   when available, can be fully read in one call, if the destination buffer
+   is big enough.
+
+    .. c:member:: int interval
+
+       Specifies the delay (in milliseconds) or the time interval before
+       the chunk is made available; see :ref:`read_write_read_modes`.
+
+    .. c:member:: const void* buf
+
+       Pointer to the data stored by the chunk.
+
+    .. c:member:: size_t buflen
+
+       Size of the data stored by the chunk.
+
+
+.. c:type:: struct read_buffer_t
+
+   This structure is used to specify the full content of the file or the stream
+   backed by this file descriptor. It consists in an array
+   :c:member:`chunks <read_buffer_t.chunks>` of
+   :c:member:`nchunks <read_buffer_t.nchunks>` chunks, as defined before.
+
+    .. c:member:: int mode
+
+       Mode of interpretation of the time intervals; see :ref:`read_write_read_modes`.
+
+    .. c:member:: size_t nchunks
+
+       Number of chunks in the buffer.
+
+    .. c:member:: struct read_bufchunk_t* chunks
+
+       Array of chunks
+
+Creating a buffer for the partial reads, that simulates a file, requires
+allocating all these structures and filling them appropriately.
+
+Buffer creation helpers
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Some utility functions are provided to create a buffer based on an existing
+piece of data (the content of the file or of the stream), the wished sizes
+of each chunk and the wished intervals:
+
+.. c:function:: struct read_buffer_t *create_read_buffer(void *data, size_t n, off_t *offsets, int *intervals, int mode)
+
+This function allows creating a full buffer. For instance, if called like this::
+
+    void *mydata = malloc(40);
+    // mydata is filled with 40 bytes of data
+    off_t chunk_sizes[] = {10, 30};
+    int intervals[] = {100, 200};
+    struct read_buffer_t *rep = create_read_buffer(mydata, 2, chunk_sizes, intervals, READ_WRITE_REAL_INTERVAL);
+
+Then the buffer will be structured like this:
+
+- :code:`rep` will be allocated by the function, or will be :code:`NULL` if there was an error;
+- :code:`rep->mode` will be :code:`READ_WRITE_REAL_INTERVAL`;
+- :code:`rep->nchunks` will be 2;
+- :code:`rep->chunks` will point to an array of 2 :code:`struct read_bufchunk_t`, like this:
+
+  - :code:`rep->chunks[0]` will be the first chunk, with the following fields:
+
+    - :code:`rep->chunks[0].buf` will be equal to :code:`mydata`;
+    - :code:`rep->chunks[0].buflen` will be 10, for 10 bytes;
+    - :code:`rep->chunks[0].interval` will be 100: this is the wait time for
+      the first chunk; see :ref:`read_write_read_modes`.
+
+  - :code:`rep->chunks[1]` will be the second chunk, with the following fields:
+
+    - :code:`rep->chunks[1].buf` will be equal to :code:`mydata + 10`;
+    - :code:`rep->chunks[1].buflen` will be 30, for 30 bytes;
+    - :code:`rep->chunks[1].interval` will be 200: this is the wait time for
+      the second chunk, after the first one was read; see :ref:`read_write_read_modes`.
+
+Note that the size of the full data, 40, is not passed explicitly
+to the function; rather, it can be computed by summing up :code:`offsets`.
+Also note that the parameter :code:`offsets` doesn't contain offsets, but rather
+sizes of each of the corresponding chunk.
+
+.. c:function:: int create_partial_read_buffer(void *data, size_t n, off_t *offsets, int *intervals, struct read_buffer_t *buf)
+
+This function does moestly the same work as :c:func:`create_read_buffer()`,
+but it doesn't allocate the :c:type:`read_buffer_t`; rather, it uses the one
+pointed to by :code:`buf`. This is especially useful if the buffer is allocated
+on the stack. Another difference is that it doesn't set the :code:`mode` field:
+this field must be set by the caller.
+
+.. c:function:: void free_read_buffer(struct read_buffer_t *buf)
+
+.. c:function:: void free_partial_read_buffer(struct read_buffer_t *buf)
+
+Those two functions free the structures that were allocated by
+:c:func:`create_read_buffer()` and :c:func:`create_partial_read_buffer()`
+respectively. Note that they don't free the underlying data.
+
+.. _read_write_read_modes:
+
+The modes
+---------
+
+There are three modes, that relate to the way the chunks become accessible
+as time goes on:
+
+- :code:`READ_WRITE_REAL_INTERVAL`: in this mode, the chunks become available
+  in real time: they become available as time goes on, without depending
+  on the pattern of calls to :code:`read` or :code:`recv`.
+- :code:`READ_WRITE_AFTER_INTERVAL`: in this mode, the next chunk becomes available
+  only after :code:`interval` msec have passed since the previous call to :code:`read`
+  (or :code:`recv`) on this file descriptor; the time may have passed between the
+  two calls, resulting in no wait. Only one chunk is read each time.
+- :code:`READ_WRITE_BEFORE_INTERVAL`: in this mode, the next chunk becomes available
+  only after a forced wait of :code:`interval` msec, whatever time has passed since
+  the previous call; this is the strictest most of the three.
+
+The modes, and the behaviour of the :code:`read` and :code:`recv` calls depending on
+these modes, are described in more details in the :ref:`read_write_working_tracking`
+section.
+
+Setting up
+----------
+
+To enable the partial read on a file descriptor, we use the following function:
+
+.. c:function:: int set_read_buffer(int fd, const struct read_buffer_t *buf)
+
+This function enables partial read on the file descriptor :code:`fd`, and specifies
+the buffer as :code:`buf`. It returns 0 if the file descriptor didn't already have
+a buffer (that is, it wasn't in partial read mode); 1 if there was already
+a buffer, in which case the buffer was changed to the new one, with reset
+statistics of progression; -1 if there was an internal error (like not enough
+memory); -2 if there was an argument error (like an incorrect mode).
+
+Don't forget to enable monitoring of the appropriate calls (:code:`read`, :code:`recv`
+and relatives) if you want the student code run in the sandbox to experience
+this partial read. Outside of these conditions, a standard, native :code:`read`
+will be called on the true file descriptor.
+
+To disable the partial read on a file descriptor, simply call this same
+function with :code:`buf = NULL`.
+
+It is also possible to reset all file descriptor to the default, no-partial-read
+behaviour by calling the following function.
+
+.. c:function:: void reinit_read_fd_table()
+
+This removes all associations between a file descriptor and a read buffer,
+disables partial read for all descriptors previously set, but it doesn't free
+the structures (as they can be allocated on the stack).
+
+.. _read_write_working_tracking:
+
+Working of the partial read and tracking progress
+-------------------------------------------------
+
+Once this is done, the partial read works as follows:
+
+Each time the student calls :code:`read` or :code:`recv` (or its relatives)
+(they should be monitored), on the file descriptor that was set up
+for partial read, inside the sandbox, CTester (referred to as "we" in the
+following lines) will attempt to read up to :code:`count` bytes
+(from the parameter of the call) from the buffer.
+
+If there is an "open" chunk (= a chunk that has already been partially read,
+with at least one byte read, and with remaining bytes left to read), then
+we will first read as much bytes from this chunk as possible and as requested.
+If the requested number of bytes can be satisfied using only this chunk, then
+the call ends and is successful. If not, then we mark this chunk as "finished"
+and "start" the next chunk. If this chunk is already available (based on
+the time interval: we're in real time and the time has passed),
+then we read it; if not, then the call returns without waiting
+for the next chunk to become available. If the chunk is available, we read
+as many bytes as necessary, possibly emptying the chunk, and possibly
+looking at the next chunk: this is repeated as many times as necessary.
+
+If there is no "open" chunk (= the previous chunk was emptied and we're at
+the next chunk), then either the file has been fully read,
+or there is a next chunk, which we can start.
+
+The behaviour then depends on the mode. If we're in real-time, then we must
+wait for the chunk to become available in real-time. It is possible that
+the chunk has already been available for some time before the call, and thus
+no wait will take place; otherwise, we'll have to wait. It is also possible
+that multiple chunks are available at the time of the call; all of theif the request
+available chunks will be used to satisfy the requested amount of bytes, until
+the requested amount has been met, or we have to read a chunk that is not yet
+available; in the latter case, the call ends without waiting.
+
+If we're in after-time, then we must wait only if the current call has been
+issued less than the time interval after the previous call: if the interval
+was set to 50msec and the current call is issued 40msec after the previous
+one, then we wait only 10msec. We then read only one chunk, up to the
+requested amount or the chunk size (whichever comes first), and return,
+without waiting for an eventual next chunk.
+
+If we're in before-time, then we must wait the interval time, whatever the time
+has passed from the previous call. We then read only one chunk, up to the
+requested amount or the chunk size, and return, without waiting for the next.
+
+There is therefore a strong difference between the real-time mode on one side,
+and the before-time or after-time modes on the other side: the latter can only
+read one chunk at each call, possibly emptying it, possibly waiting for it,
+while the former can read multiple chunks if multiple chunks are available,
+stopping only when either the requested amount has been satisfied or the next
+chunk would need to wait.
+
+Note the strange behaviour of the :code:`read` system call: if there is no data
+to read at the moment, then the call blocks (unless we set the file descriptor
+to non-blocking, or we call :code:`recv` with the :code:`MSG_DONTWAIT` flag set).
+But if there is some data, then the call doesn't block, reads as much data
+as requested, but doesn't wait for more data to become available and prefers
+returning a lower amount of bytes than requested. This behaviour is reproduced
+in CTester.
+
+Tracking progress
+~~~~~~~~~~~~~~~~~
+
+It is possible to track the state of the partial read with the following
+functions:
+
+.. c:function: ssize_t get_bytes_read(int fd)
+
+This function returns the number of bytes that have Currently been read
+on the file descriptor :code:`fd`, or -1 if the file descriptor is not associated
+with a read buffer for partial read. If the buffer was completely read,
+then the full size of the buffer will be returned.
+
+.. c:function: int get_current_chunk_id(int fd)
+
+This function returns the current chunk id (index, number) of the read buffer
+of the file descriptor :code:`fd`, or -1 if there is no read buffer.
+If the "read cursor" (read offset) is between two chunks (it has finished one
+and has not yet started the next), then it will return the id of that next chunk.
+Note that the ids start at 0 and not at 1! If the buffer was completely read,
+then the number of chunks will be returned (which is equal to the id of
+the last chunk plus 1).
+
+If, at some point, you need to see if some file descriptor has a read buffer,
+you can use the following function:
+
+.. c:function: bool fd_is_read_buffered(int fd)
+
+This function returns :code:`true` if the file descriptor :code:`fd` has
+a read buffer for partial return.
+
+Applications
+------------
+
+The most common (and original) use case for these functions is when the file
+descriptor is the one of a socket. Sockets don't behave as files, and are more
+prone to partial reads in the real life than for usual files.
+
+For TCP-based, stream sockets, partial reads can happen when the connection
+is not yet closed but we're waiting on new segments to arrive (at any point
+between the sender and the receiving application, even within the OS!).
+This is even more true as TCP reorders the arriving segments, and so may take
+some time waiting for out-of-order segments to arrive before sending the full,
+in-order segments to the application. The real-time mode is more appropriate.
+
+For UDP-based, datagram sockets, we receive datagrams, which are full messages,
+independent of any stream. :code:`recvfrom` and :code:`recvmsg` are preferred,
+as the source address of the datagrams can vary each time (:manpage:`connect(2)` can be
+used to restrict the socket to only accept and receive datagrams coming from
+a specific source). As there is no concept of stream, when one reads on the
+socket, he reads only one message, one datagram at a time; when the read
+terminates, the datagram is discarded (unless we used the :code:`MSG_PEEK` flag)
+from the queue of messages and the next message is available (or not):
+requesting too less data can lead to some part of the message being definitely
+lost. The before-time or after-time modes are more appropriate. Note that this
+is not strictly a partial-return.
+
+Partial writes
+--------------
+
+Currently, CTester doesn't handle partial writes.
+
+Partial writes happen less frequently than partial reads: when the underlying
+file descriptor refers to a file, it mostly happens when the buffers are full;
+when it is a socket, it mostly happens when the networking buffers are full,
+or when the data is too large to fit inside one packet or datagram (especially
+in UDP, where the max size is usually 65507 on IPv4).
+
+Limitations and improvements
+----------------------------
+
+:code:`recvfrom` and :code:`recvmsg`
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Only :manpage:`read(2)` and :manpage:`recv(2)` are guaranteed to pass through partial return
+if set up. :manpage:`recvfrom(2)` will pass through partial return only if :code:`addr`
+and :code:`addrlen` are both :code:`NULL`, otherwise it will go through the real one.
+:manpage:`recvmsg(2)`, due to its complicated definition, doesn't support partial return,
+but one should not expect a lot of student to use this function...
+
+Note for the potential contributor: :code:`recvfrom` should clearly be improved,
+the difficulty comes from what values to put into the :code:`addr` and :code:`addrlen`
+fields.
+
+The :code:`MSG_PEEK` flag
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Currently, the :code:`MSG_PEEK` flag of :code:`recv` and related is not handled:
+the read data cannot be retrieved again.
+
+Note for the potential contributor: in real-time mode, this should be easy:
+just read the data, but reset the control structures to the original values.
+
+In after-time or before-time mode however, it requires a bit more modifications,
+as just resetting the control structures to the original value means that
+a subsequent call will *again* possibly block and wait. One should add a field
+to the control structure to specify that the data has already been waited for
+and we can proceed without waiting.
+
+UDP
+~~~
+
+If the socket is using UDP, normally we should pass to the next chunk/datagram
+each time, as the remains of the current datagram are discarded after reading
+the datagram. But this is not what happens. We should handle this better.
+
+Stability
+~~~~~~~~~
+
+Although it has been tested a lot, the amount of code is prone for a lot of bugs.
+Don't hesitate to add unit tests for a more thorough verification!
+
+Internal working
+----------------
+
+There is two additional data structures::
+
+    struct read_item {
+        int fd;
+        const struct read_buffer_t *buf;
+        unsigned int chunk_id;
+        size_t bytes_read;
+        struct timespec last_time;
+        int64_t interval;
+    };
+    struct read_fd_table_t {
+        size_t n;
+        struct read_item *items;
+    };
+
+The first structure defines all the control variables needed for te partial reads:
+
+- :code:`fd` is the file descriptor.
+- :code:`buf` is the read buffer, never modified.
+- :code:`chunk_id` is the current chunk id. It starts at 0 with the first chunk,
+  is incremented each time we pass to the next chunk, is equal to :code:`buf->nchunks`
+  when we're at the end of the data.
+- :code:`bytes_read` is the number of bytes read thus far in the current chunk.
+  It is 0 if the chunk has not yet been read (and thus, we may need to wait
+  for the chunk to become available). When a chunk is emptied, :code:`chunk_id` is
+  incremented to go to the next chunk, and :code:`bytes_read` is reset to 0.
+- :code:`last_time` is the last time a call to :code:`read` or :code:`recv` has been made.
+  It is updated each time a call is made, and is used in real-time and after-time
+  modes to determine if we have to wait, for how long, and for which chunks.
+  Note that the structure is precise down to the nanosecond and up to billions
+  of seconds.
+- :code:`interval` is, in real-time mode, the real wait interval (in nanoseconds)
+  for the current chunk. It is relative to :code:`last_time`, which was set during
+  the previous call to :code:`read` or :code:`recv`, and is updated each time.
+  It can be positive, meaning we need to wait at least :code:`interval` nanoseconds
+  since :code:`last_time`, or it can be negative, meaning we don't have to wait,
+  but we still need to track the time in order for the subsequent chunks
+  to become available in real-time. It is not used in after-time mode or in
+  before-time mode.
+
+The second structure is actually a singleton definition used to declare
+a variable, :code:`read_fd_table`, which contains one :code:`struct read_item` entry
+in the :code:`items` table (of size :code:`n`) for each file descriptor currently set
+to partial mode.
+
+There are a number of helper functions defined in the .c file, but the most
+important one is the following:
+
+.. c:function: ssize_t read_handle_buffer(int fd, void *buf, size_t len, int flags)
+
+This function is the one that is called by the wrappers of :manpage:`read(2)`, :manpage:`recv(2)`,
+:manpage:`recvfrom(2)` and :manpage:`recvmsg(2)` when the file descriptor :code:`fd` is associated
+with a read buffer, and this is actually the function we've referred to each
+time we talk about "last call to :code:`read` or :code:`recv`".
+
+This function contains a great part of the logic behind the partial read
+(actually, the greatest part is in :code:`read_handle_buffer_rt` and :code:`read_handle_buffer_no_rt`,
+but those are helper functions and not publicly available). Its arguments are
+the same as the ones of :code:`recv`.
+
+Most of the limitations of the current system come from this function, also.
+
+Other functions declared in the .c file include functions manipulating time
+structures (:code:`getnanotime`, :code:`get_time_interval`), adding and removing
+a file descriptor from the :code:`read_fd_table`, and getting its :code:`read_item`
+(:code:`read_get_entry`, :c:func:`fd_is_read_buffered`, :code:`reinit_read_fd_table_item`,
+:code:`read_remove_entry`, :code:`read_get_new_entry`), and the core implementation of
+:code:`read_handle_buffer` (:code:`read_handle_buffer_rt` and :code:`read_handle_buffer_no_rt`).
+
+If you read the source code: it may not be the cleanest code, nor the most
+efficient code, but it gets the job done, and only waits to be improved. ;-)
+
diff --git a/doc/api/trap.rst b/doc/api/trap.rst
new file mode 100644
index 0000000..9c917d3
--- /dev/null
+++ b/doc/api/trap.rst
@@ -0,0 +1,36 @@
+.. _trap:
+
+===============
+Trapped buffers
+===============
+
+The file ``CTester/trap.h`` defines two functions for creating trapped buffers,
+:c:func:`trap_buffer()`, and for deleting them, :c:func:`free_trap()`.
+
+.. c:function:: void* trap_buffer(size_t size, int type, int flags, void *data)
+
+.. c:function:: int free_trap(void *ptr, size_t size)
+
+A trapped buffer is a continuous memory area (a buffer) that is bounded, at one
+edge, with a memory page that is *trapped* (:code:`PROT_NONE`). The buffer itself
+is set with the :code:`flags` (any flag accepted by :manpage:`mprotect(2)`).
+
+The type can be either :code:`TRAP_LEFT` or :code:`TRAP_RIGHT` (defined by an enum).
+
+If :code:`type` is :code:`TRAP_LEFT`, then the buffer has a full page of memory
+with :code:`PROT_NONE` access before it. The pointer returned by :c:func:`trap_buffer()`
+is :code:`buf_start` and is the start of the buffer, whereas the trapped page
+starts at an address called :code:`ptr=buf_start - PAGE_SIZE`. When freeing
+the trapped buffer, one should pass to :c:func:`free_trap()` the above defined:code:`ptr`
+value, and a size of :code:`(2 + (size_of_buffer / PAGE_SIZE)) * PAGE_SIZE`.
+
+If :code:`type` is :code:`TRAP_RIGHT`, then the buffer has a full page of memory
+with :code:`PROT_NONE` access just *after it*. The pointer returned by :c:func:`trap_buffer()`
+is :code:`buf_start` and is, again, the start of the buffer; it is not necessarily
+aligned with a page boundary. The trapped page starts at :code:`buf_start+size`
+and is aligned to a page boundary. The :code:`ptr` value that should be passed
+to :c:func:`free_trap()` is then :code:`(buf_start + size) - (1 + size/PAGE_SIZE) * PAGE_SIZE`
+and the size is again :code:`(2 + (size_of_buffer / PAGE_SIZE)) * PAGE_SIZE`.
+
+Obviously, the API could be better.
+
diff --git a/doc/api/util_sockets.rst b/doc/api/util_sockets.rst
new file mode 100644
index 0000000..cb53138
--- /dev/null
+++ b/doc/api/util_sockets.rst
@@ -0,0 +1,199 @@
+.. _util_sockets:
+
+================================
+Socket-related utility functions
+================================
+
+The file ``CTester/util_sockets.h`` contains various functions that may be
+useful when testing code related to the socket functions
+(see :ref:`wrap_sockets`).
+
+.. _util_sockets_create:
+
+Socket creations
+================
+
+Often, one has to call :manpage:`getaddrinfo(3)` to retrieve the proper addresses
+of some host and services, then call :manpage:`socket(2)`, then call :manpage:`connect(2)`
+or :manpage:`bind(2)` and :manpage:`listen(3)`. The following functions simplify this procedure.
+
+:code:`create_socket`
+---------------------
+
+.. c:function:: int create_socket(const char *host, const char *serv, int domain, int type, int flags, int do_bind)
+
+   This function creates and returns a socket, "connected" to the :code:`host`
+   and :code:`service` (which should both be numeric; :manpage:`getaddrinfo(3)` will be called
+   without DNS, with :code:`AI_NUMERICHOST | AI_NUMERICSERV | flags` as its flags),
+   with the specified :code:`domain` (:code:`AF_INET` or :code:`AF_INET6` or :code:`AF_UNSPEC`)
+   and the specified :code:`type` (:code:`SOCK_STREAM` or :code:`SOCK_DGRAM`).
+   If :code:`do_bind` is :code:`true`, then the resulting socket will be :manpage:`bind(2)` to
+   the address, accepting connections, and configured to reuse the addresses
+   (necessary as :manpage:`close(2)`-ing a socket doesn't free the address immediately);
+   otherwise, :manpage:`connect(2)` will be called. Note that it is possible for the caller
+   to pass a non-:code:`NULL` :code:`host` and leaving :code:`AI_PASSIVE` out of the :code:`flags`
+   and still call :manpage:`bind(2)`, as it is possible for him to do the inverse and call
+   :manpage:`connect(2)` : the incoherence of this is left to the caller.
+
+.. :c:function:: int create_tcp_server_socket(const char *serv, int domain, int type)
+
+
+   This function creates a server socket with
+   :code:`create_socket(NULL, serv, domain, type, AI_PASSIVE, true)`
+   and then makes the socket :manpage:`listen(2)`, with a queue size of 1.
+
+.. :c:function:: int create_tcp_client_socket(const char *host, const char *serv, int domain, int type)
+
+   This function creates a client socket with
+   :code:`create_socket(host, serv, domain, type, 0, false)`
+   and returns it.
+
+Both functions with "tcp" don't enforce the type to :code:`SOCK_STREAM`
+but leave it to the caller.
+
+.. c:function:: int create_udp_server_socket(const char *serv, int domain)
+
+   This function creates a UDP server socket with
+   :code:`create_socket(NULL, serv, domain, SOCK_DGRAM, AI_PASSIVE, true)`
+   and returns it.
+
+.. c:function:: int create_udp_client_socket(const char *host, const char *serv, int domain)
+
+   This function creates a UDP client socket with
+   :code:`create_socket(host, serv, domain, SOCK_DGRAM, 0, false)`
+   and returns it.
+
+Both functions with "udp" enforce the type to :code:`SOCK_DGRAM`.
+
+Socket connection
+-----------------
+
+.. :c:function:: int connect_udp_server_to_client(int sfd, int cfd)
+
+   This function connects the UDP server :code:`sfd` and the UDP client :code:`cfd`
+   so that :manpage:`send(2)` and :manpage:`recv(2)` calls from the server send and receive to
+   the client. Note that the client must be :manpage:`connect(2)`-ed to the server.
+
+Test server and client creations
+================================
+
+It is possible to create test servers and test clients, in UDP or TCP,
+using a set of 4 functions in this header.
+
+Structures
+----------
+
+Three structures are defined::
+
+    struct cs_network_chunk {
+        void *data;
+        size_t data_length;
+        int type;
+    };
+    struct cs_network_transaction {
+        struct cs_network_chunk *chunks;
+        size_t nchunks;
+        struct sockaddr *addr;
+        socklen_t addrlen;
+    };
+    struct cs_network_transactions {
+        struct cs_network_transaction *transactions;
+        size_t ntransactions;
+    };
+
+- The first structure defines a chunk of data that may be sent or received
+  by the test server of client. If type is :code:`SEND_CHUNK` then the chunk
+  is sent to the other end of the connection, and any error is reported.
+  If type is :code:`RECV_CHUNK`, then the test server or client will try
+  to receive a chunk of data, and will compare it with the data in this chunk,
+  reporting any transmission error or any difference. No byte-order conversion
+  is done when sending or comparing!
+- The second structure defines a transaction: a list of chunks exchanged
+  between the test server or client and the other end of the connection.
+  A transaction is successful if all to-send chunks have been sent correctly
+  (=no error), if all to-recv chunks have been received correctly with
+  no difference, and if the test server or client has not been asked to quit.
+- The third structure defines a list of transactions, that are executed one
+  after the other. This is useful to do successive tests without having
+  to recreate a server or client again.
+
+All these functions use :manpage:`recv(2)` and :manpage:`send(2)`, which means that it is possible
+to enable partial reads or writes on the sockets (see :ref:`partial_read_write`).
+
+Functions
+---------
+
+The four functions are declared as follows::
+
+    int launch_test_tcp_server(struct cs_network_transactions *transactions, const char *serv, int domain, int *server_in, int *server_out, int *spid);
+    int launch_test_tcp_client(struct cs_network_transactions *transactions, const char *host, const char *serv, int domain, int *client_in, int *client_out, int *cpid);
+    int launch_test_udp_server(struct cs_network_transactions *transactions, const char *serv, int domain, int *server_in, int *server_out, int *spid);
+    int launch_test_udp_client(struct cs_network_transactions *transactions, const char *host, const char *serv, int domain, int *client_in, int *client_out, int *cpid);
+
+There are a lot of common parameters, hence they are explained together:
+
+- :code:`transactions` is a pointer to a list of transactions, as defined above;
+- :code:`host` and :code:`serv`, for clients, are the address and service to which
+  the client has to send and receive its data. Both should be numeric.
+- :code:`serv`, for servers, is the service name on which the server should be
+  listening. It should be a numeric port.
+- :code:`domain` is the domain (IPv4/IPv6) of the server.
+- :code:`server_in` and :code:`server_out` are two file descriptors used to communicate
+  with the server: the first is the writing end of a pipe that is read by
+  the server, the second is the reading end of a pipe written to by the server.
+- :code:`client_in` and :code:`client_out` are analoguous to :code:`server_in` and
+  :code:`server_out` respectively.
+- :code:`spid` is filled by the call with the server process PID.
+- :code:`cpid` is filled by the call with the client process PID.
+
+Working
+-------
+
+These functions work by forking and creating a new process, where a server
+or a client of the appropriate address, port, domain and type is created and
+initialised, using the appropriate socket creation function
+(see :ref:`util_sockets_create`).
+
+Communications
+--------------
+
+We can communicate with this other process by means of the input and output
+pipes, and we can wait for its termination by waiting on the PID of the server
+or client.
+
+There are a number of codes that the child process can use to communicate
+upstream:
+
+- :code:`OK`: indicates that a transaction was finished.
+- :code:`RECV_ERROR` indicates that an error occured while receiving;
+  it is followed by :code:`sizeof(errno)` bytes representing the value of :code:`errno`
+- :code:`SEND_ERROR` indicates that an error occured while sending.
+- :code:`TOO_MUCH` indicates that much more bytes were received or sent, followed
+  by the number of bytes received or sent.
+- :code:`TOO_FEW` indicates that less bytes were received or sent, followed
+  by the number of bytes received or sent.
+- :code:`NOTHING_RECV` indicates that nothing was received, likely because the
+  connection was closed.
+- :code:`NOT_SAME_DATA` happens when the data is different.
+- :code:`NOT_SAME_ADDR` happens when the address of :code:`recvfrom` differs from
+  the one that should have been; the address length follows, and then
+  the address.
+- :code:`EXIT_PROCESS` happens when the subprocess ends prematurely.
+- :code:`EXTEND_MSG` is used to specify that the next octet gives the status;
+  it is used to allow extensions to these error codes.
+
+Some of the error codes can also be ORed together.
+
+The parent process can communicate with its child by writing to the downstream
+pipe. Currently, anything written to it will cause the subprocess to exit.
+
+Caution
+-------
+
+These 4 functions have never been tested, either by unit tests or in an actual
+exercise.
+There are numberous bugs, bad design choices everywhere.
+This documentation is here for the sole purpose of mentioning it exists,
+and what its intents were.
+Use at your own risk.
+Don't hesitate to contribute, fixing bugs, adding tests, or whatever.
diff --git a/doc/api/wrap_file.rst b/doc/api/wrap_file.rst
new file mode 100644
index 0000000..c6b4b66
--- /dev/null
+++ b/doc/api/wrap_file.rst
@@ -0,0 +1,56 @@
+.. _wrap_file:
+
+==================================================
+File-related functions, structures, and statistics
+==================================================
+
+This page only talks about the wrappers and the statistics of the file-related
+functions. Please check the page :ref:`partial_read_write` for an API allowing
+to finely tune the "partial return" behaviour of the :code:`read`
+and :code:`write` functions.
+
+The following functions have a wrapper:
+
+- :manpage:`open(2)`
+- :manpage:`creat(2)`
+- :manpage:`close(2)`
+- :manpage:`read(2)`
+- :manpage:`write(2)`
+- :manpage:`stat(2)`
+- :manpage:`fstat(2)`
+- :manpage:`lseek(2)`
+
+A particular missing function is :manpage:`fcntl(2)`. Feel free to add support for it!
+
+Notes on specific calls
+=======================
+
+The rest of this page only describes the differences with the usual form
+of the wrappers.
+
+As always, there is a function to reset the statistics of the wrappers,
+:code:`reinit_file_stats`, taking to argument.
+
+:code:`open`
+------------
+
+CTester currently only supports the :manpage:`open(2)` system call with three arguments;
+if one calls the :code:`open` system call with two arguments, it is likely that
+it won't be intercepted (not tested). Simply check that the student called
+the right version through the statistics.
+
+:code:`read`
+------------
+
+This is the only function that supports the partial read/write from the API
+described in the page :ref:`partial_read_write`.
+
+:code:`stat` and :code:`fstat`
+------------------------------
+
+The :code:`struct stats_stat_t` and :code:`struct stats_fstat_t` structures [1]_ have
+an additional field, :code:`returned_stat`, which is a copy of the :code:`struct stat`
+structure which was filled by the last call to :code:`stat` or :code:`fstatt`.
+
+.. [1] Wordy names for structures
+
diff --git a/doc/api/wrap_mallocs.rst b/doc/api/wrap_mallocs.rst
new file mode 100644
index 0000000..e0a69e4
--- /dev/null
+++ b/doc/api/wrap_mallocs.rst
@@ -0,0 +1,104 @@
+.. _wrap_mallocs:
+
+=======================================
+Malloc-related functions and structures
+=======================================
+
+This page describes the features provided by the file ``CTester/wrap_malloc.h``
+and its accompanying ``CTester/wrap_malloc.c``.
+
+The following functions are wrapped and have their statistics recorded:
+
+- :manpage:`malloc(3)`
+- :manpage:`calloc(3)`
+- :manpage:`free(3)`
+- :manpage:`realloc(3)`
+
+The only notable thing to mention is that, as :code:`free` doesn't return anything,
+the corresponding :code:`struct stats_free_t` doesn't have a :code:`last_return` field.
+
+A current misfeature is that :code:`errno` is never set by the wrappers of any of
+the 4 functions in case of failure, and the fields are not present in the
+:c:data:`failures` variable (of type :code:`struct wrap_fail_t`).
+
+Also, :code:`malloc`, :code:`calloc` and :code:`realloc` have a field :code:`_ret` in the
+:c:data:`failures` structure of type :code:`void*` instead of :code:`int`. Beware!
+
+There is a function called :code:`malloc_log` in the header file.
+Don't use it, it has no implementation.
+Same for the commented :code:`malloc_log_init`.
+
+There is no dedicated function to reset the statistics for these 4 functions.
+
+Memory usage API
+================
+
+In order to monitor the memory consumption, several functions and structures
+are provided:
+
+- The :code:`struct stats_memory_t` structure has a field :code:`used` that indicates
+  how many bytes are allocated thus far in the sandbox.
+  This field is updated by each call to one of the 4 functions.
+- The :code:`malloc_allocated` function, when called, returns the number of bytes
+  that are allocated thus far in the sandbox.
+  This value is computed by summing up the sizes of all chunks
+  when the function is called.
+
+The two functions provide a different implementation of the same functionality;
+they should however always return the same result.
+
+.. note:: Unit tests are missing for this: contributions are welcome!
+
+Note that both meters are updated by :code:`malloc`, even if the call to :code:`malloc`
+fails due to a true error (not a simulated one).
+In sharp contrast, the values are updated by :code:`realloc` only if the call
+succeeded.
+This is a current bug that is part of the current API.
+Also note that the meters are decremented for a call to :code:`free`, even if the
+true call to :code:`free` fails: this is actually normal behaviour.
+
+Also, due to :code:`struct stats_memory_t` using an :code:`int` for :code:`used`, and
+:code:`struct malloc_elem_t` using a :code:`size_t` for :code:`size`, some overflows
+are possible. Recall that :code:`size_t` is unsigned...
+
+There is no dedicated function to reset the memory usage statistics.
+
+The details of recorded chunks are recorded in the :c:data:`logs` variable,
+of type :c:type:`wrap_log_t`, which contains a field, :code:`malloc`, of type
+:c:type:`malloc_t`.
+
+.. c:type:: struct malloc_t
+
+   Contains useful statistics for the :code:`malloc` and related functions.
+
+    .. c:member:: int n
+
+       Indicates the number of recorded chunks.
+
+    .. c:member:: struct malloc_elem_t *log
+
+       Array recording each allocated chunks of memory.*
+
+.. c:type:: struct malloc_elem_t
+
+   Defines a chunk of allocated memory.
+
+    .. c:member:: size_t size
+
+       Size of the chunk
+
+    .. c:member:: void *ptr
+
+       Returned pointer*
+
+Checked :code:`free` API
+========================
+
+Currently, it is not checked if the addresses passed to :code:`free`
+have been previously returned by :code:`malloc` or its derivatives.
+This check is left to the underlying library, which may or not
+cause a detectable segfault.
+This remark also applies to :code:`realloc`, which ususally frees up some memory.
+
+Contributions are welcome!
+
diff --git a/doc/api/wrap_misc.rst b/doc/api/wrap_misc.rst
new file mode 100644
index 0000000..ba69491
--- /dev/null
+++ b/doc/api/wrap_misc.rst
@@ -0,0 +1,67 @@
+.. _wrap_misc:
+
+==============================================
+Miscellaneous wrapped functions and structures
+==============================================
+
+Defined in ``unistd.h``
+=======================
+
+:code:`sleep`
+-------------
+
+``CTester/wrap_sleep.h`` and ``CTester/wrap_sleep.c`` are the archetypal
+wrapper definitions files.
+They wrap a very simple function, the :manpage:`sleep(3)` function.
+
+The sole structure declared is the :code:`struct stats_sleep_t` structure,
+which has the following fields:
+
+- :code:`called`: number of times the :code:`sleep` function has been called;
+- :code:`last_return`: return value of the last call to :code:`sleep`;
+- :code:`last_arg`: argument value of the last call to :code:`sleep`; this is **not**
+  the usual name for this field, which is usually :code:`last_params`.
+
+As there is only one argument, this function doesn't use a structure
+to record its parameters.
+
+There are three functions defined in the header:
+
+.. c:function:: void init_sleep()
+
+   Used to initialize the structures needed for the wrapper;
+   in the case of :code:`sleep`, it does nothing.
+
+.. c:function:: void clean_sleep()
+
+   Used to cleanup the structures needed for the wrapper;
+   in the case of :code:`sleep`, it does nothing either.
+
+.. c:function:: void resetstats_sleep()
+
+   Used to reset the statistics for the number of calls,
+   the last arguments and return values, as initially.
+
+The code in the ``CTester/wrap_sleep.c`` file should give an idea of
+the general look of a wrapper for a function.
+
+:code:`getpid`
+--------------
+
+The :manpage:`getpid(2)` system call also has its wrapper, and its associated
+statistics structure (:code:`struct stats_getpid_t`) and initialization,
+cleanup and statistics reset functions, as with :code:`sleep`.
+A significant difference with :code:`sleep` is that it doesn't have any argument,
+so there is no :code:`last_arg` field.
+
+Defined in ``stdlib.h``
+=======================
+
+:code:`exit`
+------------
+
+The :manpage:`exit(3)` function is wrapped by CTester, but doesn't provide
+any statistics nor programmed failures.
+It is wrapped because one should prevent the student from calling :code:`exit`
+and thereby stopping the tests.
+
diff --git a/doc/api/wrap_mutexs.rst b/doc/api/wrap_mutexs.rst
new file mode 100644
index 0000000..3eaf80a
--- /dev/null
+++ b/doc/api/wrap_mutexs.rst
@@ -0,0 +1,26 @@
+.. _wrap_mutexs:
+
+======================================
+Mutex-related functions and structures
+======================================
+
+The header ``CTester/wrap_mutex.h`` contains the wrappers and structures
+for the following functions, handling mutexes:
+
+- :manpage:`pthread_mutex_init(3)`: initializes a mutex;
+- :manpage:`phtread_mutex_lock(3)`: locks a mutex;
+- :manpage:`pthread_mutex_trylock(3)`: tries to lock a mutex, without blocking;
+- :manpage:`pthread_mutex_unlock(3)`: unlocks the mutex;
+- :manpage:`pthread_mutex_destroy(3)`: destroys the mutex and frees the allocated structures.
+
+All functions defined here record statistics of the number of times called,
+of the arguments and return value of the last calls.
+
+However, as of now, they don't allow programmed failures.
+
+There is a initialization, cleanup and statistics reset function
+for each function, as well as three functions for all 5 functions.
+
+As of now, :code:`pthread_mutex_init` statistics only remember the last :code:`mutex`
+argument, not the attributes :code:`attr`. This should be fixed.
+
diff --git a/doc/api/wrap_sockets.rst b/doc/api/wrap_sockets.rst
new file mode 100644
index 0000000..8c65347
--- /dev/null
+++ b/doc/api/wrap_sockets.rst
@@ -0,0 +1,137 @@
+.. _wrap_sockets:
+
+=======================================
+Socket-related functions and structures
+=======================================
+
+The following functions have a wrapper:
+
+- :manpage:`accept(2)`
+- :manpage:`bind(2)`
+- :manpage:`connect(2)`
+- :manpage:`listen(2)`
+- :manpage:`poll(2)`
+- :manpage:`recv(2)`
+- :manpage:`recvfrom(2)`
+- :manpage:`recvmsg(2)`
+- :manpage:`select(2)`
+- :manpage:`send(2)`
+- :manpage:`sendto(2)`
+- :manpage:`sendmsg(2)`
+- :manpage:`shutdown(2)`
+- :manpage:`socket(2)`
+
+Notes on specific calls
+=======================
+
+The rest of this page indicated some particularities.
+
+:code:`accept`
+--------------
+
+The returned address of :code:`accept` and its length is stored into
+a :code:`struct return_accept_t` at fields :code:`addr` and :code:`addrlen`
+respectively. This structure can be accessed from the stats
+by :code:`stats.accept.last_returns`
+(:code:`last_return` contains the return value of the function).
+
+Note that :code:`addr` contains a meaningful value only if the call
+to :code:`__real_accept` was successful, and if both the parameters
+:code:`addr` and :code:`addrlen` are not :code:`NULL`.
+:code:`addrlen` contains a meaningful value only if the :code:`addrlen` parameter
+was not :code:`NULL`.
+
+:code:`poll`
+------------
+
+The :code:`fds_ptr` field contains the value of the original parameter :code:`fds`,
+that is, a pointer to an array of :code:`struct pollfd`.
+The :code:`fds_copy` field contains a copy of this array, if the call succeeded
+or if it failed for a different reason than a segfault.
+
+.. note:: It is very well possible that the reason for the exit was
+          for a different reason than a segfault,
+          yet the :code:`fds` parameter is invalid: this is probably a bug.
+
+:code:`recv` and related
+------------------------
+
+The three functions :code:`recv`, :code:`recvfrom` and :code:`recvmsg` have overlapping
+functionalities, and may be called by the student.
+Technically, it is not wrong for the student to call :code:`recvfrom` when we asked
+him to use :code:`recv` and didn't ask him not to use :code:`recvfrom`.
+So, in a regular, "all-accepting" policy, the three calls have to be monitored,
+and their statistics should be aggregated.
+
+In order to do that, CTester provides, in addition to the three regular
+statistics structures, an additional :code:`struct stats_recv_all_t` structure
+with an only field of :code:`called`, which counts the number of times
+any of the three functions has been called: the sum of the respective :code:`called`.
+
+In the ``CTester/wrap.h`` file, a macro :code:`MONITOR_ALL_RECV` is defined. It can
+be used to monitor all 3 functions at once. For this, call it like this::
+
+    MONITOR_ALL_RECV(monitored, true);
+
+:c:data:`monitored` is the name of the default :code:`struct wrap_monitor_t`.
+
+:code:`recvfrom`
+----------------
+
+The :code:`recvfrom` function returns in its parameter :code:`src_addr` the source
+address, and in :code:`src_addrlen` the length of this address.
+If the call was successful, the actual address and the actual length are stored
+in fields :code:`src_addr` and :code:`src_addrlen` of a :code:`struct return_recvfrom_t`,
+which is accessible at :code:`stats.recvfrom.last_returned_addr`.
+
+:code:`recvmsg`
+---------------
+
+The :code:`recvmsg` function returns in its parameter :code:`msg` a :code:`struct msghdr`,
+which contains a lot of information about the received message.
+If the call was successful, the actual received message is copied and stored
+in :code:`stats.recvmsg.last_returned_msg`.
+
+Note that this :code:`msghdr` structure contains some dynamically allocated fields,
+like :code:`iov`; these inner fields are not copied and may thus have been freed
+when you consult the statistics.
+
+:code:`select`
+--------------
+
+The four parameters :code:`readfds`, :code:`writefds`, :code:`exceptfds` and :code:`timeout`
+are stored in corresponding fields with an :code:`_ptr` attached to it.
+In addition, there are four fields :code:`readfds`, :code:`writefds`, :code:`exceptfds`
+and :code:`timeout` which contain copies of the corresponding structures.
+In sharp contrast with most other functions, the copies are done
+even if the call was not successful.
+
+.. note:: This can probably lead to segfaults too.
+
+:code:`send` and related
+------------------------
+
+In a similar manner to :code:`recv` and its relatives, there is an additional
+:code:`struct stats_send_all_t` accessible at :code:`stats.send_all`,
+with a :code:`called` field that tracks the number of times any of the three
+functions has been called.
+
+In the ``CTester/wrap.h`` file, a macro :code:`MONITOR_ALL_SEND` is defined. It can
+be used to monitor all 3 functions at once. For this, call it like this: ::
+
+    MONITOR_ALL_SEND(monitored, true);
+
+:c:data:`monitored` is the name of the default :code:`struct wrap_monitor_t`.
+
+:code:`sendto` and :code:`sendmsg`
+----------------------------------
+
+In sharp contrast with :code:`recvfrom` and :code:`recvmsg`, there is currently
+no field to store the actual address or message passed as argument.
+
+Resetting
+---------
+
+.. c:function:: void reinit_network_socket_stats()
+
+This function resets the statistics of all the tracked functions listed on this page.
diff --git a/doc/api/wrap_util_dns.rst b/doc/api/wrap_util_dns.rst
new file mode 100644
index 0000000..c2d8610
--- /dev/null
+++ b/doc/api/wrap_util_dns.rst
@@ -0,0 +1,217 @@
+.. _wrap_util_dns:
+
+.. |gai| replace:: :code:`getaddrinfo`
+.. |gni| replace:: :code:`getnameinfo`
+.. |fai| replace:: :code:`freeaddrinfo`
+
+====================================
+DNS-related functions and structures
+====================================
+
+The DNS-related functions, structures, and definitions are located in the
+``CTester/wrap_network_dns.h`` and ``CTester/wrap_network_dns.c`` files.
+
+Wrapped functions
+=================
+
+The wrapped functions are
+
+- :manpage:`getaddrinfo(3)`
+- :manpage:`freeaddrinfo(3)`
+- :manpage:`gai_strerror(3)`
+- :manpage:`getnameinfo(3)`
+
+There are some specificities for the statistics structures for these functions,
+that are described next.
+
+For |gai|
+---------
+
+In addition to the common fields, the :code:`struct stats_getaddrinfo` structure
+has an additional field, :code:`addrinfo_list`, which is a list of nodes of type
+:code:`struct addrinfo_node_t`, which record the various lists returned by |gai|.
+
+For |fai|
+---------
+
+As |fai| doesn't return anything, there is no :code:`last_return` field.
+However, there is a :code:`status` field which, when |fai| is checked
+(see :ref:`checked_freeaddrinfo`), is set to 1 if the last call didn't succeed
+(which happens if the parameter has never been returned by |gai|).
+
+This call cannot be set to fail, unless it is checked, and even then, a failure
+would not be visible to the student, hence the reporter function
+(see :ref:`freeaddrinfo_reporter`).
+
+For :code:`gai_strerror`
+------------------------
+
+There is no structure for the parameters: the sole parameter, an :code:`int`, is
+accessible by the :code:`last_params` field (note that the plural is used).
+
+This call cannot be set to fail.
+
+.. _checked_freeaddrinfo:
+
+Checked freeaddrinfo
+====================
+
+The standard way of using :code:`getaddrinfo` usually goes along these lines::
+
+    struct addrinfo hints, *result, *rp;
+    // set the hints fields
+    const char *host, *serv;
+    // set the host name and service name
+    int sfd = 0; // socket
+    int s = getaddrinfo(host, serv, &hints, &result);
+    if (s != 0) {
+        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(s));
+        exit(1);
+    }
+    for (rp = result; rp != NULL; rp = rp->ai_next) {
+        // Try the address
+        sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+        if (sfd == -1) // print the error and continue with the next struct addrinfo
+        if (connect(sfd, rp->ai_addr, rp->ai_addrlen) != -1)
+            break; // Success
+        else
+            close(sfd);
+    }
+    if (rp == NULL) // print error as we didn't get a valid connection
+    freeaddrinfo(result);
+
+The parameter passed to the :code:`freeaddrinfo` function is usually the pointer
+to the head of the list returned by the previous call to getaddrinfo.
+However, it is also possible to pass any other pointer to one of the item
+of the list: it will free the list of addrinfo structures starting from
+the item at this pointer to the end, but will not free the previous items.
+
+If you want to make sure that the student calls |fai| with a list that has been
+previously returned by a call to |gai|, you can use the following function:
+
+.. c:function:: void set_check_freeaddrinfo(bool check)
+
+   When passed :code:`true`, this function enables the recording of every list returned
+   by |gai|, and when |fai| is called, its argument is checked against
+   the list of recorded lists returned by |gai|
+   (each list stored inside a :code:`struct addrinfo_node_t` node).
+
+.. _freeaddrinfo_reporter:
+
+Report the errors
+-----------------
+
+.. c:type:: typedef void (*freeaddrinfo_badarg_report_t)()
+
+.. c:function:: void set_freeaddrinfo_badarg_reporter(freeaddrinfo_badarg_report_t reporter)
+
+If the check is enabled, when |fai| is called with a list that has
+never been returned by |gai|, it will fail with status 1
+(in the statistics structure; the method still returns :code:`void`).
+If a non-:code:`NULL` reporter function has been specified using
+:c:func:`set_freeaddrinfo_badarg_reporter()`, this function will be called.
+This is useful if you plan to provide a detailed feedback.
+Please note that |fai| **will still attempt to free its argument**,
+which may lead to a premature exit from the sandbox.
+
+Custom |gai| and |gni| wrappers
+===============================
+
+The default wrapper for |gai| only provides limited functionnality:
+it can only call the real |gai| after counting statistics,
+or it can fail with some teacher-specified value.
+When the real |gai| is called, it will generally attempt to call
+the DNS service of the container, which may or may not be accessible.
+In addition, the data returned by |gai| is subject to the *glibc*
+implementation, and may cause problems with the order of the results
+(it is specified in :rfc:`3484` though).
+
+CTester allows the teacher to provide alternative implementations of |gai|,
+by using :c:func:`set_getaddrinfo_method` and :c:func:`set_gai_methods`.
+It also provides :c:func:`set_getnameinfo_method` to provide an alternate |gni| method.
+
+.. c:type:: typedef int (*getaddrinfo_method_t)(const char *node, const char *service, const struct addrinfo *hints, truct addrinfo **res)
+
+.. c:type:: typedef void (*freeaddrinfo_method_t)(struct addrinfo *res)
+
+.. c:type:: typedef int (*getnameinfo_method_t)(const struct sockaddr *addr, socklen_t addrlen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags)
+
+.. c:function:: void set_getaddrinfo_method(getaddrinfo_method_t method)
+
+   Sets the alternate |gai| method; :code:`NULL` resets that method to
+   the default.
+
+.. c:function:: void set_gai_methods(getaddrinfo_method_t gai_method, freeaddrinfo_method_t fai_method)
+
+   Sets the alternate |gai| and |fai| methods; passing :code:`NULL` for one of
+   the parameters resets that function to the default.
+
+.. c:function:: void set_getnameinfo_method(getnameinfo_method_t method)
+
+   Sets the alternate |gni| method; passing :code:`NULL` resets to default.
+
+The first two methods require passing a function with the same signature
+as a standard |gai|.
+The third method requires passing a function with the same signature
+as a standard |gni|.
+
+The difference between :c:func:`set_getaddrinfo_method` and :c:func:`set_gai_methods` is
+that the second method also allows specifying the |fai| replacement function,
+which must logically have the same signature as the standard |fai| function.
+
+The reason you may want to provide both functions is that the POSIX standard
+doesn't specify the actual structure of the list of :code:`struct addrinfo`.
+
+For instance, the *glibc* version constructs this list by allocating a series
+of blocks of size :code:`sizeof(struct addrinfo) + sizeof(struct sockaddr_in)`
+(if the address is IPv4; replace :code:`sockaddr_in` by :code:`sockaddr_in6` if IPv6),
+and then making the :code:`ai_addr` field of the :code:`struct addrinfo` point to
+the end of the block, to the attached :code:`struct sockaddr_in`.
+
+Another library may decide to allocate the blocks separately, or may decide
+to allocate all the :code:`struct addrinfo` together, or anything else.
+This is authorized because the standard only requires |gai| to fill in a list
+that can be used to create and bind sockets, and that can be freed by
+the corresponding |fai|.
+
+Unless you can garantee that your wrapper function will return the list in
+the same format that is expected by |fai|, you may want the possibility
+to also provide a corresponding |fai| when you change the wrapped |gai|.
+
+For |gni|, there is only one function, as there is no :code:`freenameinfo`
+function in the standard library: |gni| only fills in user-provided buffers,
+and only returns one result.
+
+.. c:type:: typedef const char *(*gai_strerror_method_t)(int)
+
+.. c:function:: void set_gai_strerror_method_t(gai_strerror_method_t method)
+
+Finally, it is also possible to replace the :code:`gai_strerror` function
+with a custom one, by calling :c:func:`set_gai_strerror_method` with an appropriate
+parameter: this is useful if you plan to deliberately cause multiple errors
+in |gai| and want to have an easier parsing of stderr experience afterwards.
+
+Note that you can come back to the default, standard-library-backed
+functions by calling the above functions with a :code:`NULL` argument.
+For the :c:func:`set_gai_methods` functions, specifying only one of the arguments
+as NULL will only reset the corresponding function to the default.
+
+Simple replacements for |gai| and |fai|
+---------------------------------------
+
+.. c:function:: int simple_getaddrinfo(const char *host, const char *serv, const struct addrinfo *hints, struct addrinfo **res)
+
+.. c:function:: void simple_freeaddrinfo(struct addrinfo *res)
+
+Examples of custom-defined |gai| and |fai| wrappers are available in CTester
+as :c:func:`simple_getaddrinfo` and :c:func:`simple_freeaddrinfo`.
+Both functions get around the DNS by only accepting numerical arguments
+(it assumes :code:`AI_NUMERICHOST` in the flags).
+
+Resetting to defaults
+---------------------
+
+.. c:function:: void reset_gai_fai_gstr_gni_methods()
+
+   Resets the 4 methods to their default.
+
diff --git a/doc/api/wrap_util_inet.rst b/doc/api/wrap_util_inet.rst
new file mode 100644
index 0000000..46b6fbd
--- /dev/null
+++ b/doc/api/wrap_util_inet.rst
@@ -0,0 +1,60 @@
+.. _wrap_util_inet:
+
+==============================================
+Other network-related functions and structures
+==============================================
+
+.. _wrap_inet_functions:
+
+File ``wrap_network_inet.h``
+============================
+
+The ``CTester/wrap_network_inet.h`` header contains definitions of structures
+and wrapper for the following functions:
+
+- :manpage:`htons(3)`
+- :manpage:`ntohs(3)`
+- :manpage:`htonl(3)`
+- :manpage:`ntohl(3)`
+
+Each of the statistics structure contains the last parameter at :code:`last_params`,
+and the last return value at :code:`last_return`, as usual.
+The parameter structures only contain one field, for the sole parameter
+of these functions.
+
+In addition, there is the following function:
+
+.. c:function:: void reinit_network_inet_stats()
+
+   Reset the statistics for each of these functions.
+
+These byte-order functions cannot fail, and as such are not present
+in the :code:`struct wrap_fail_t` structure.
+
+In the ``CTester/wrap.h`` file, the macro :code:`MONITOR_ALL_BYTEORDER` is defined.
+It can be used to monitor all 4 functions at once, and is called like this::
+
+    MONITOR_ALL_BYTEORDER(monitored, true);
+
+:c:data:`monitored` is the name of the default :code:`struct wrap_monitor_t`.
+
+.. _util_inet_functions:
+
+File ``util_inet.h``
+====================
+
+The ``CTester/util_inet.h`` header contains definitions of some utility
+functions:
+
+- :code:`htons_tab`
+- :code:`ntohs_tab`
+- :code:`htonl_tab`
+- :code:`ntohl_tab`
+
+All these functions translate each integer in an array from one byte order
+format to another, from a source array to a destination array.
+For instance, :code:`htons_tab` translates each short, 16-bit unsigned integer
+of its source array, assumed to be in host byte order, to the network,
+little-endian byte order, and store it in corresponding areas
+of the destination array.
+
diff --git a/doc/conf.py b/doc/conf.py
new file mode 100644
index 0000000..ada2cb0
--- /dev/null
+++ b/doc/conf.py
@@ -0,0 +1,62 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# http://www.sphinx-doc.org/en/master/config
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+import sphinx_rtd_theme
+# sys.path.insert(0, os.path.abspath('.'))
+
+
+# -- Project information -----------------------------------------------------
+
+project = 'CTester'
+copyright = '2019, UCL-INGI'
+author = 'UCL-INGI'
+release = '1.0.0'
+
+
+# -- General configuration ---------------------------------------------------
+
+extensions = [
+    #"breathe",
+    "sphinx_rtd_theme"
+]
+
+templates_path = ['_templates']
+
+source_suffix = ['.rst']
+
+master_doc = 'index'
+
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store', ]
+exclude_patterns += ['full_doc/*.rst', 'doxygendoc.rst'] # Disable it for now
+
+primary_domain = 'c'
+
+highlight_language = 'c'
+
+pygments_style = None
+
+manpages_url = 'http://man7.org/linux/man-pages/man{section}/{page}.{section}.html'
+
+html_theme = 'sphinx_rtd_theme'
+
+html_static_path = ['_static']
+
+# C Autodoc (a.k.a. hawkmoth) configuration
+cautodoc_root = os.path.abspath('../student/CTester')
+cautodoc_compat = 'javadoc-basic'
+
+# breathe configuration
+breathe_projects = { "CTester": "./doxygen_output/xml/"}
+breathe_default_project = "CTester"
+
diff --git a/doc/index.rst b/doc/index.rst
new file mode 100644
index 0000000..4f4a13b
--- /dev/null
+++ b/doc/index.rst
@@ -0,0 +1,27 @@
+.. CTester documentation master file, created by
+   sphinx-quickstart on Tue Jul  9 15:08:32 2019.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+===================================
+Welcome to CTester's documentation!
+===================================
+
+.. highlight:: c
+
+.. toctree::
+    :maxdepth: 3
+    :caption: Contents:
+
+    introduction
+    usage
+    wrap
+    api
+    limitations
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
diff --git a/doc/introduction.rst b/doc/introduction.rst
new file mode 100644
index 0000000..01304b6
--- /dev/null
+++ b/doc/introduction.rst
@@ -0,0 +1,35 @@
+.. _introduction:
+
+=======================
+Introduction to CTester
+=======================
+
+CTester is a library that provides a secure and customizable way of evaluating
+C codes written by students.
+
+It provides the following features:
+
+- Sandboxing of student code: securely running codes of students, with no risk
+  of crashes of the testing environment;
+- Statistics of function calls: records number of calls, last parameter used,
+  for a large number of standard functions and system calls;
+- Customizable behaviour of some functions: DNS-related functions and
+  :code:`read` and :code:`write` functions;
+- And even more features!
+
+This documentation describes in details the API and usage of CTester.
+
+It is organized as follows:
+
+- The :ref:`usage` page describes the general usage of CTester: sandboxing,
+  a few notes on wrappers, how one should write tests and organize its code
+  for efficient testing of student code.
+- The :ref:`wrap` page describes in more details the general look of a wrapper,
+  and the features it provides: statistics, programmed failures...
+- The :ref:`api_index` pages describe in more details the wrappers for each
+  function, as well as the additional features provided by CTester.
+- The :ref:`limitations` page describes the current limitations, bugs,
+  and vulnerabilities of CTester. Yes, there are some, that should be corrected.
+  Improvements to CTester should start by fixing these deficiencies.
+
+
diff --git a/doc/limitations.rst b/doc/limitations.rst
new file mode 100644
index 0000000..828827b
--- /dev/null
+++ b/doc/limitations.rst
@@ -0,0 +1,160 @@
+.. _limitations:
+
+====================================
+CTester limitations and improvements
+====================================
+
+CTester has several limitations, bugs, and source of improvements that
+you should be aware of.
+
+Limitations
+===========
+
+Missing signals
+---------------
+
+Only the SIGSEGV and the SIGFPE signals are currently caught and managed.
+SIGALRM is also used for the timeout timer.
+
+If any other signal happens (for instance, SIGPIPE), the whole CTester program
+will be terminated.
+
+Circumventing signals
+---------------------
+
+Currently, the :manpage:`sigaction(2)` system call (and other related calls)
+are not wrapped. This means that the student could easily call these functions
+and change the signal handlers to something more appropriate for him.
+
+Circumventing the timer
+-----------------------
+
+Similarly, :manpage:`setitimer(2)` is not wrapped, and the student could
+disable the timer.
+
+No randomization of the structures
+----------------------------------
+
+The internal structures are mostly declared "statically", and an :code:`extern`
+declaration of the appropriate structure inside the student code can easily
+give him full access to that structure, if he knows how it works.
+
+A workaround would be removing that access (dynamic allocation+randomization),
+or making impossible the :code:`extern` declaration, e.g. by adding fields
+to the structures unknown to the student.
+
+Another case of non-randomization is that the student function is called
+by CUnit, which calls the function without any precaution or randomization.
+As CTester doesn't currently add any precaution on its side, it means that
+the student function is, more or less, directly called by CTester, and that
+a clever student could modify some variables in the caller functions' stacks.
+
+Missing functions
+-----------------
+
+There is a lot of missing functions, and some of them should be wrapped:
+
+- :manpage:`exit` (actually wrapped, but badly).
+- :manpage:`execve(2)`, :manpage:`fork(2)` and others. :manpage:`waitpid(2)`
+  should be updated then.
+- :manpage:`sigaction(2)`, :manpage:`sigaltstack(2)`, :manpage:`sigemptyset(3)`,
+  :manpage:`signal(2)`, :manpage:`raise(3)` and others.
+- :manpage:`kill(2)` and related.
+- :manpage:`setjmp(2)`, :manpage:`longjmp(2)` and others.
+- :manpage:`phtread_create(3)`, :manpage:`pthread_kill(3)`,
+  :manpage:`pthread_join(3)` etc.
+- :manpage:`sem_init(3)`, :manpage:`sem_open(3)`, :manpage:`sem_wait(3)`,
+  :manpage:`sem_post(3)` etc
+- :manpage:`pipe(2)`
+- :manpage:`fcntl(2)`
+- :manpage:`fopen(3)`, :manpage:`fread(3)`, :manpage:`fwrite(3)` etc.
+
+Etc
+
+Incoherent naming of a few functions
+------------------------------------
+
+Trap is the perfect example: the functions are badly named.
+
+Some fields of some statistics structures too.
+
+Design inconveniences of the API
+--------------------------------
+
+Trap: the pointer to pass for deletion is different than the pointer that
+was returned, in a non-obvious way.
+
+:code:`SANDBOX_BEGIN;` needs a semicolon at the end, for some reason.
+
+Limitations to memory access control (including access to internal structures)
+------------------------------------------------------------------------------
+
+Again, most of the internal structures are not protected, partly because
+it is C after all, and by design the user can do whatever he wants.
+
+Array access, memory access through pointers etc are not properly handled;
+any misuse from the student can lead to undefined behaviour, in his code
+but also in CTester's code if he accessed structures he should not.
+
+Standard output and standard error streams
+------------------------------------------
+
+These are pipes, so they are limited. For instance, there is a maximum
+capacity for the pipes, that varies between systems (16 pages, or 65536 bytes,
+is the current maximum). If the student code writes too much to either
+standard outputs, there is a chance of reaching this limit. As the pipes
+are non-blocking, any write to the full pipes will fail with :code:`EAGAIN`,
+but it means that some information may be lost (like the double frees).
+
+An improvement would be to redirect these to some local files, and to manually
+truncate the writes if it is done from the student code.
+
+Scores and grading
+------------------
+
+As of now, a task is successful if the total score is above some threshold.
+That threshold is currently limited to a choice between 50% and 100%.
+
+Also, the only way to customize the scoring is by adding correct weights
+to the test functions.
+
+Exit
+----
+
+It is wrapped by CTester, to prevent the student from exiting the tests.
+But it also means that the student can't call that function when it encounters
+some error, which may sometimes be needed.
+
+Double free detection
+---------------------
+
+It relies on detecting the string "double free or corruption" inside
+the redirected standard error stream of the program.
+
+As it relies on :code:`read`, it is very well possible that this string is cut
+in parts in the buffer, and that we miss this message.
+Currently, the wrapper for :code:`free` doesn't detect double frees either.
+
+Timer race condition
+--------------------
+
+It is possible, albeit complicated, that the timeout signal arrives during
+the call to the function ending the sandbox, after that this call has reset
+the pipes and the file descriptors to a normal state, bu before that this call
+has disabled the signal.
+
+It should be easy to fix: move lines in that function so that the timer is
+disabled before we do anything else. But maybe that it introduces other errors.
+
+Adding tests
+============
+
+It is possible to add some integration tests to CTester, in the folder
+``ci``.
+
+You can have a look at the folder structure and the tests themselves
+to understand how they are written and how you can write new ones.
+
+It is authorized to update the ``run_ci`` script, if you want to perform
+other kinds of tests.
+
diff --git a/doc/make.bat b/doc/make.bat
new file mode 100644
index 0000000..2119f51
--- /dev/null
+++ b/doc/make.bat
@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd
diff --git a/doc/usage.rst b/doc/usage.rst
new file mode 100644
index 0000000..2655854
--- /dev/null
+++ b/doc/usage.rst
@@ -0,0 +1,531 @@
+.. _usage:
+
+=============
+CTester usage
+=============
+
+First of all, CTester is designed to be used in INGInious. This has a lot of
+consequences in the design choices and the way to run the programs and the tests.
+
+Global view
+===========
+
+The general workflow for creating an exercise in CTester is as follows:
+
+- In  INGInious, you create a task. The ``run`` file should be the file named
+  ``run`` at the root of CTester, and should be copied. The rest of CTester
+  can be placed either in the same directory (thus, ``run.py`` is next to
+  ``run``, as well as the folder ``student``), or in the ``$common/CTester/``
+  folder (which should contain the ``student`` folder as well as the ``run.py``
+  file), which will be copied in the proper place.
+- In the ``student`` folder, you create a file named ``tests.c``, which will
+  contain your tests, and two other files named ``student_code.h`` and
+  ``student_code.c.tpl``, which will define the functions the student needs
+  to fill in. For instance, the header will contain the prototype of
+  the function, and the ``.c.tpl`` file will contain the implementation, with
+  the string ``@@problem_id@@`` replacing the various places the student will
+  need to write code.
+- In INGInious, you declare as many subproblems as places where the student
+  should fill code in the ``.c.tpl`` file, with corresponding problem ids.
+- In the ``tests.c`` file, you include ``student_code.h`` and
+  ``CTester/CTester.h``.
+- You write one or more test function, with appropriate test metadata, and
+  call the functions defined in ``student_code.h`` (which will get a proper
+  implementation in the ``student_code.c`` file when the task is sent to run)
+  inside the sandbox provided by CTester, and you perform tests on the returned
+  values of the functions of the student.
+- In the :code:`main` function, you ban functions the student cannot use
+  (with :c:func:`BAN_FUNCS()`), and you pass each test function to run to the
+  :c:func:`RUN()` function.
+- You test on INGInious if your task accepts the proper result and rejects
+  wrong answers, iterating with debugs and other tasks.
+- You let the students attempt your exercise, and watch them suffer in the
+  marvelous world of C programming.
+
+A basic skeleton of such a task is available in the default ``student_code.h``,
+``student_code.c.tpl`` and ``tests.c`` files of CTester.
+
+Detailing the different parts
+=============================
+
+This section describes in more detail the various steps outlined above.
+
+The ``student_code.h`` and ``student_code.c.tpl`` files
+-------------------------------------------------------
+
+CTester expects you to place the code written by the students in these two files.
+
+It is strongly recommanded that you ask students to complete bodies of functions,
+and not parts of files, for the following reasons:
+
+- This leads to smaller problems, which are easier to grade;
+- This teaches them to think in terms of functions, and to structure their
+  programs in functions;
+- This prevents them from declaring global variables, or from redeclaring
+  structures or variables used by CTester. For instance, the :c:data:`stats`
+  variable is used to record usage statistics. A simple
+  :code:`extern struct wrap_stats_t stats` in the global space of the file
+  is sufficient to gain access to this variable (this is a problem of C).
+  Therefore, limiting them to functions bodies restricts the risk of them
+  interfering with CTester. [#externfunc]_
+
+The functions and their empty bodies should go inside the ``.C.tpl`` file,
+and the function prototypes should go inside the ``.h``.
+CTester's headers should not be included in these files!
+You should put proper problem id references inside the bodies of the functions.
+
+Note that it is possible that you put non-empty bodies inside the functions,
+if you want the student to only complete some part of that body (for instance,
+if you want to convert the results from the student code to a more
+appropriate format for testing).
+
+.. [#externfunc] Actually, :code:`extern` is allowed inside functions, but
+   one can hope that the student is not aware of this...
+
+Writing a test function
+-----------------------
+
+Writing a test function follows mostly the same schema::
+
+    void test_myfunc() {
+        set_test_metadata("myfunc", _("Brief description of the test"), 1);
+        int ret = -1;
+        SANDBOX_BEGIN;
+        ret = myfunc(21); // Suppose myfunc(x) = 2*x
+        SANDBOX_END;
+        CU_ASSERT_EQUAL(ret, 42);
+    }
+
+- The test function should take no argument and return nothing.
+- The first line should specify some metadata of the test, namely, the function
+  that is tested, what is actaully tested, and the relative weight of the test
+  in the score of the student. See :c:func:`set_test_metadata()` below.
+- The code written by the student (here, the content of the :code:`myfunc`
+  function) should be executed within a sandbox.
+- Tests should use CUnit to check that the student functions work as wished.
+
+A very important remark is that you should **not** declare any variable inside
+the sandbox: instead, declare them before. Indeed, the sandbox doesn't
+guarantee that all the code inside it will be executed: any exception inside
+of it will cause subsequent code to never be executed. Variable declarations
+inside the sandbox have therefore a risk of being risky. You can, however,
+assign variables inside the sandbox: it is even recommanded so that you can
+perform tests on the results.
+
+For the same reason that declaring variables inside the sandbox is forbidden,
+we recommend initializing the variables that are assigned in the sandbox with
+an "incorrect" value, i.e. a value that makes the following tests fail.
+That way, tests will not have the risk of succeed if we exit the sandbox,
+a precaution that is particularly necessary as it is sadly currently possible
+to circumvent the sandbox' handling of exceptions...
+
+
+It is recommanded that you only run a minimal set of tests inside one test
+function. Monitorings, statistics, failures and other internal structures used
+for some features are reset at the beginning of the test, just before the call
+to the function containing the tests, and so you have the guarantee of having
+a clean environment at the beginning of the test, which could become cluttered
+as you add code to your test.
+
+Test metadata
+~~~~~~~~~~~~~
+
+.. c:function:: void set_test_metadata(char *problem, char *descr, unsigned int weight)
+
+   This function gives CTester various informations (metadata) about the test
+   in which this function is called. This information is notably shown
+   in the logs of the program, and is the basis of the feedback provided
+   to the student. Please avoid special characters like ``#``.
+
+   :param problem: A string giving the name of the problem.
+   :param descr:   A string giving a longer description of the problem.
+   :param weight:  Weight of the test in the final score of the student.
+
+The sandbox
+~~~~~~~~~~~
+
+A sandbox is delimited by two macros, :c:func:`SANDBOX_BEGIN`
+and :c:func:`SANDBOX_END`.
+
+Inside the sandbox, the code written by the student can be safely tested:
+
+- Exceptions and other signals are caught by the sandbox and immediately
+  cause an exit from the sandbox, without crashing CTester. The cause of error
+  (segmentation fault, floating point exception) will be available in the logs.
+- Monitoring of functions is enabled within the sandbox. This enables a lot
+  of features, like statistics, programmed failures, replacement of functions,
+  and more. See :ref:`wrap` for more information. All of these features
+  are enabled (activated) solely inside the sandbox.
+- There is a time limit for the running time of the code inside the sandbox.
+  By default it is equal to 2 seconds. It is not yet possible to configure
+  that value.
+
+The tests
+~~~~~~~~~
+
+Testing should use CUnit. All the usually required functions, macros
+and headers are available from CTester.
+
+You should **not** perform tests inside the sandbox. Any code in the sandbox
+has the risk of potentially never be executed, if there is an exception, and so
+your tests would also run the risk of not being executed.
+
+It is **extremely** important that your tests don't fail or cause any error,
+as this error would be reported to the student as its own error.
+
+Create and manage multiple tests
+--------------------------------
+
+All the test created should be put inside the ``tests.c`` file, and should be
+called inside the :code:`main` function using the :c:func:`RUN` function.
+
+Suppose that you have two test functions, :code:`test_nonempty_result()`
+and :code:`test_correct_result()`, and you want to prevent the use of :code:`printf`. Then, your main should look like this::
+
+    int main(int argc, char **argv)
+    {
+        BAN_FUNCS(printf);
+        RUN(test_nonempty_result, test_correct_result);
+    }
+
+Don't add a :code:`return` statement, as it is included done by :c:func:`RUN`
+(which is actually a macro).
+
+.. c:type:: typedef void (*void_void_function_t)(void);
+
+   This is a pointer to a function taking void and returning void.
+
+.. c:function:: void RUN(void_void_function_t args[])
+
+   This is a macro that executes the various functions passed in :code:`args`,
+   that are functions taking no parameter and returning nothing (exactly
+   the type of the testing functions).
+
+   This macro is expanded in a true function call (with the number of functions
+   passed too) and with a :code:`return` statement.
+
+   This function essentially sets up the environment for executing
+   the functions safely, providing a clean state for each test function
+   at its start of execution.
+
+.. c:function:: void BAN_FUNCS(args)
+
+   This is a macro used to specify functions that should be banned for
+   the student. Banned functions are not authorized in the student code, and
+   will cause the tests to fail immediately.
+
+Additional features
+-------------------
+
+There is a few more functions you can call inside your test functions:
+
+.. c:function:: void push_info_msg(char *msg)
+
+   This pushes the :code:`msg` message to the list of messages that will be
+   printed in the feedback file.
+
+.. c:function:: void set_tag(char *tag)
+
+   This adds the tag to the test function. The tag will be displayed in the
+   feedback file. There is a limit of 20 tags, which must have a length of
+   less than 30 characters (including :code:`\0`).
+
+.. _ctester_inginious_copy:
+
+Calling on INGInious
+--------------------
+
+CTester is designed to be used on INGInious. As such, it provides a run file,
+and the feedback it provides during the execution is parsed to obtain relevant
+informations that are then displayed to the student.
+
+To work properly, CTester requires the following files:
+
+- the ``run`` file, without extension, which is run by INGInious;
+- the ``run.py`` file, which is called by the ``run`` file and contains most
+  of the logic of a standard run file;
+- the ``student`` folder, which contains:
+
+  - the ``CTester`` folder, containing the various headers and C files
+    used by CTester;
+  - the ``Makefile``, used for compiling all the files;
+  - the above-described ``student_code.h``, ``student_code.c.tpl`` and ``tests.c`` files.
+
+CTester requires either of the following folder structure:
+
+.. code-block:: none
+
+    root_of_the_course/
+    ├─ $common/
+    │  └─ ...
+    ├─ my_task/
+    │  ├─ task.yaml
+    │  ├─ run
+    │  ├─ run.py
+    │  └─ student/
+    │     ├─ CTester/
+    │     │  ├─ CTester.h
+    │     │  └─ ...
+    │     ├─ Makefile
+    │     ├─ student_code.h
+    │     ├─ student_code.c
+    │     └─ tests.c
+    └─ ...
+
+or
+
+.. code-block:: none
+
+    root_of_the_course/
+    ├─ $common/
+    │  ├─ CTester/
+    │  │  ├─ run.py
+    │  │  └─ student/
+    │  │     ├─ CTester/
+    │  │     │  ├─ CTester.h
+    │  │     │  └─ ...
+    │  │     └─ Makefile
+    │  └─ ...─
+    ├─ my_task/
+    │  ├─ task.yaml
+    │  ├─ run
+    │  └─ student/
+    │     ├─ student_code.h
+    │     ├─ student_code.c
+    │     └─ tests.c
+    └─ ...
+
+The first version places a copy of CTester inside each task folder.
+
+The second version only has one copy of CTester, in the ``$common`` folder,
+which is mounted to the ``/common/`` folder at run time. Each task then only
+requires its copy of the ``run`` file (needed by INGInious), as well as
+its custom versions of the ``student_code.h``, ``student_code.c.tpl``
+and ``tests.c`` files.
+
+The CTester ``run`` file, at run time, first looks for a copy of CTester
+in the current folder, then looks for a copy of CTester in the ``/common`` folder.
+
+A "copy of CTester" is merely defined, in the ``run`` file, as the presence
+of the three files ``run.py``, ``Makefile`` and a folder named ``CTester/``
+at the same time. The absence of any of the three causes the folder to not
+be a "copy of CTester".
+
+When copying CTester, the copy doesn't overwrite any file in the task folder.
+If you want to customize CTester, by patching it or by adding additional files,
+you can simply create a ``CTester`` folder in the ``student`` folder
+and put your custom code there. Simply, to guarantee that ``run`` doesn't
+consider the current folder as being a full copy, you should not provide
+a custom version of ``Makefile`` and ``run.py``. Or, modify the ``run`` file
+to your liking, but mention the modifications at the top of the file.
+
+By default, the ``run.py`` script is called without argument; it considers
+that a task is successful if the total score is above 50%.
+If you want to make the task succeed if the total score is 100%,
+just pass any additional argument to the call, different from ``--use-fifty``.
+
+Standard output and error stream redirections
+---------------------------------------------
+
+In order to parse standard output and error streams for error messages,
+and limit the output to a reasonable amount, CTester modifies these streams
+by duplicating them and redirecting them to several other file descriptors
+and pipes.
+
+This section describes the various used file descriptors, their role at
+different instants. We consider only those related to :code:`STDOUT_FILENO`;
+there are similar file descriptors for :code:`STDERR_FILENO`.
+
+- :code:`int STDOUT_FILENO` : the usual file descriptor of the standard output,
+  equal to 1 by definition. It is where :code:`printf()` writes to. Inside
+  the sandbox, it is redirected to :code:`pipe_stdout[1]` (using
+  :manpage:`dup2(2)`), and at the exit from the sandbox it is redirected back
+  to :code:`true_stdout`, and so, to the true output.
+- :code:`FILE *stdout` : a stream version of :code:`STDOUT_FILENO`, for use
+  by :manpage:`fwrite(3)` or :manpage:`fprintf(3)`.
+- :code:`int true_stdout` : copies of the real standard output: this is
+  the actual "file" referred to by :code:`STDOUT_FILENO` before we change
+  :code:`STDOUT_FILENO` using :manpage:`dup2(2)` at the start of the sandbox,
+  and is used at the exit of the sandbox to restore :code:`STDOUT_FILENO`
+  to point to the true standard output. Writing to it writes to the process'
+  :code:`stdout` stream.
+- :code:`int pipe_stdout[2]` : this is a pipe, i.e. writing to 
+  :code:`pipe_stdout[1]` makes the same data readable at :code:`pipe_stdout[0]`.
+  The pipe is non-blocking, meaning that reading it when there is no data
+  results in a :code:`EAGAIN` failure, and writing to it when the pipe is full
+  results in :code:`EAGAIN` too. Inside the sandbox, writing to the standard
+  output actually writes to :code:`pipe_stdout[1]`, making the student code's
+  standard output available at :code:`pipe_stdout[0]`. At sandbox end,
+  this content is sent to :code:`usr_pipe_stdout[1]` and to
+  :code:`STDOUT_FILENO`.
+- :code:`int usr_pipe_stdout[2]` : this is also a pipe, and is also
+  non-blocking. At sandbox exit, it is filled with the standard output
+  from the student code, available for reading. At sandbox start, it is emptied
+  so that the sandbox is in a clean state.
+- :code:`int stdout_cpy` : same value as :code:`usr_pipe_stdout[0]`;
+  it allows the testing program to read the output of the student code
+  after the sandbox, if it is necessary.
+- :code:`FILE *fstdout` : a stream version of :code:`true_stdout`, similarly
+  to :code:`stdout`.
+
+From these file descriptors and streams, only the standard ones
+(:code:`STDOUT_FILENO` and :code:`stdout`) and :code:`stdout_cpy` and
+:code:`fstdout` are available to the testing program; all the others are
+internal to CTester (but it is good to know about the plumbing).
+
+A view at the internal workings of CTester
+==========================================
+
+A look at the way CTester works is useful to understand its limitations.
+
+CTester works by setting up various things:
+
+- It redirects the standard output and error streams to pipes, allowing these
+  streams to be managed and parsed by CTester.
+- It registers handlers for the SIGSEGV and SIGFPE signals, to prevent
+  the program from crashing if such a signal is generated by student code,
+  and exits the sandbox.
+- It registers an alarm and its handler to exit if the student code runs for
+  too long (currently 2 seconds).
+- It wraps a lot of functions (the list is in the page :ref:`wrap`),
+  by using a built-in compiler feature allowing wrapping of functions and
+  definitions of wrappers, and builds the program with these wrappers.
+
+Detailed step-by-step execution of CTester
+------------------------------------------
+
+When the ``run`` file is called by INGInious, the following happens:
+
+#. CTester is copied from an appropriate location, as in
+   :ref:`ctester_inginious_copy`;
+#. The ``run.py`` file is run:
+
+   #. The ``.c.tpl`` file template is parsed by INGInious to insert
+      the student's answers and generate a ``.c`` file.
+   #. The ``make`` command is issued, which compiles and links everything
+      together. If the compilation fails, a proper feedback is sent to
+      the student.
+   #. The banned functions are extracted from the ``tests.c`` file, and the
+      function names are searched inside the ``student_code.o`` binary;
+      if a match is found, a feedback is sent to the student mentioning
+      the bad use of a function.
+   #. Source files and ``.o`` files are removed
+   #. The translations are imported.
+   #. The program, named ``./tests``, is run, using the ``run_student`` command
+      with a time limit of 20 seconds:
+
+      #. The :code:`run_tests()` function, defined in ``CTester.c``, is called
+         by the :c:func:`RUN()` macro.
+      #. Inside that function, the locale (language) is set and initialized,
+         if it was provided in the arguments.
+      #. Memory is set to be initialized with the :code:`~142` value.
+      #. The *glibc* library's memory allocator is configured to print detected
+         memory errors (double free etc) on standard error, and to prevent abort
+         of the program if such an error is found.
+      #. The :code:`true_stdout`, :code:`fstdout`, :code:`, :code:`pipe_stdout`,
+         :code:`usr_pipe_stdout`, :code:`stdout_cpy`
+         and their :code:`stderr` variants are created and configured as above;
+         the pipes are empty, redirection of :code:`stdout` has not yet
+         happened.
+      #. *glibc* is configured to write its errors to standard error.
+      #. A special stack for all signal handlers is allocated and configured.
+      #. The signal handlers for the :code:`SIGSEGV`, :code:`SIGFPE` and
+         :code:`SIGALRM` signals are configured. These handlers update the tags
+         by adding the signal in it (:code:`"timeout"` for :code:`SIGALRM`),
+         and jump to the :code:`sigsetjmp` of the start of the sandbox, making
+         the test fail.
+      #. The ``results.txt`` file is opened.
+      #. CUnit is initialized and the default suite is created.
+      #. For each test function:
+
+         #. Dynamic loading informations is queried, for use with CUnit.
+         #. The test function is added to CUnit as a test, using the above
+            queried informations.
+         #. :code:`start_test()` is called: this function resets the statistics
+            and the various internal structures used by CTester.
+         #. The test function is executed by CUnit's :code:`CU_basic_run_test`
+
+            - Usually, the test function sets the test metadata, that are used
+              after the test to provide a feedback in the ``results.txt`` file.
+            - Usually, the test function will call one or more times
+              the sandbox.
+              The sandbox works as follows:
+
+              - At :code:`SANDBOX_BEGIN;`, we do two things:
+
+                #. We call :code:`sandbox_begin()`, which sets a timer of
+                   2 seconds, redirects :code:`STDOUT_FILENO` to
+                   :code:`pipe_stdout[1]` (same for :code:`stderr`), empties
+                   the :code:`usr_pipe_stdout` pipes, and activates monitoring.
+                #. We set a :manpage:`sigsetjmp(2)` buffer so that we can
+                   get back to that point in case of failure. It is called
+                   inside an :code:`if` statement.
+                #. The code inside the sandbox is run; it is the first, default
+                   branch of the :code:`if`.
+
+              - At :code:`SANDBOX_END;`, we end the first branch of the
+                :code:`if`; the second branch is executed if a signal was
+                caught by the signal handlers, and it makes the CUnit tests
+                fail. Then, we call :code:`sandbox_end()`:
+
+                #. It disables the monitoring, restores :code:`STDOUT_FILENO`
+                   to the normal behaviour.
+                #. It empties the :code:`pipe_stdout` pipe, copying its content
+                   to :code:`usr_pipe_stdout`.
+                #. It empties the :code:`pipe_stderr` pipe, copying its content
+                   to :code:`usr_pipe_stderr`, and checks for the string
+                   ``"double free or corruption"`` inside it, setting a tag
+                   if found.
+                #. It resets the timer to zero, to prevent an accidental call
+                   of it.
+
+            - Usually, after the sandbox, the test function will perform
+              some tests on the returned data (written in the sandbox),
+              using CUnit.
+
+         #. The results from executing that test function are retrieved from
+            CUnit, and are written to ``results.txt``, as well as the tags set
+            and the pushed information messages.
+         #. Some cleanup is done for the next test function.
+
+         Note that any error coming from CTester's setup, CUnit's setup,
+         some other calls or writes to the ``results.txt`` file results in
+         no feedback written to that file, and an error message written
+         to (true) standard error.
+      #. The exit code is CUnit's :code:`CU_get_error()`, unless another error
+         occured during execution.
+
+   #. If the ``run_student`` command, and thus the test program failed,
+      a proper feedback is sent to the student detailing the cause of error.
+      Note that this doesn't distinguish an error caused by the student
+      from an error caused by the tests!
+      Possible errors include floating-point exception, segmentation fault,
+      memory limit exceeded, time limit exceeded, or any other error.
+   #. The ``results.txt`` file is parsed to get the results of the tests:
+
+      - The global feedback depends on whether all tests are successful;
+      - Each test adds its status (success or failure) to the feedback of
+        its corresponding problem ID, and the total points are updated according
+        to the weight of the test.
+      - A problem is successful if all the tests related to it are correct.
+      - Tags are applied, if tags were specified in the test.
+
+   #. The MCQ are graded and included in the total score.
+   #. The total task is successful if the score is above 50
+
+The case of :code:`exit`
+------------------------
+
+The :manpage:`exit(3)` function (which is actually not a system call;
+this is :manpage:`exit(2)`) is wrapped by CTester, even though it doesn't
+provide statistics nor programmed failure.
+
+The reason is obvious: if the student could call :code:`exit`, he/she could
+terminate the test program immediately, bypassing the tests.
+
+As of now, if the student calls :code:`exit`, a :code:`SIGSEGV` signal will be
+raised, causing an immediate abort of the function. More precise behaviour
+has yet to be implemented.
+
+.. about the pipes: writing too much will just cause the write to fail,
+   and so the printf, which are likely to be the culprit, will just fail.
diff --git a/doc/wrap.rst b/doc/wrap.rst
new file mode 100644
index 0000000..b947dc4
--- /dev/null
+++ b/doc/wrap.rst
@@ -0,0 +1,494 @@
+.. _wrap:
+
+=====================
+Wrapping and wrappers
+=====================
+
+The main facilities provided by CTester are wrappers around library functions
+and system calls, allowing CTester to perform various operations: statistics,
+programmed failures, method overriding, and more.
+
+For this, CTester provides four main "big" structures, defined in ``CTester/wrap.h``:
+
+.. c:type:: struct wrap_monitor_t
+
+   Defines one boolean field per supported function or
+   system call (see the table below), with the same name as the function.
+   Assigning the field to :code:`true` sets CTester to monitor the function: it will
+   gather call statistics, will handle programmed failures, and will allow some
+   more advanced and function-specific features (but not specifically enabling
+   them).
+
+.. c:type:: struct wrap_fail_t
+
+   Defines three fields per supported function or system
+   call (see the table below): an :code:`uint32_t` with the same name as
+   the function (say :manpage:`open(2)`), an :code:`int` with :code:`_ret` appended to the name
+   of the function (like :code:`open_ret`), and an :code:`int` with :code:`_errno` appended
+   to the name (like :code:`open_errno`). Some functions may not have the three
+   fields, or may not be present at all. See section :ref:`wrap_failures`.
+
+.. c:type:: struct wrap_stats_t
+
+   Defines one field per supported function or system
+   call (see the table below), with the same name as the function. The type of
+   the field is generally :code:`struct stats_<function>_t`, with :code:`<function>`
+   being the name of the function (e.g. :code:`struct stats_open_t`). This structure
+   defines several fields that are described below.
+
+.. c:type:: struct wrap_log_t
+
+   Consists of logging structure that may be defined and
+   added by some functions for their internal working.
+
+Each of these 4 structures is then instantiated in the ``CTester/CTester.h``
+file to form four global variables:
+
+.. c:var:: struct wrap_monitor_t monitored
+
+   This variable is used to activate the monitoring
+   of each supported function: for instance, depending on the (boolean) value of
+   :code:`monitored.open`, the :code:`open` system call is monitored or not.
+
+.. c:var:: struct wrap_fail_t failures
+
+   This variable is used to cause programmed failures,
+   as described below.
+
+.. c:var:: struct wrap_stats_t stats
+
+   Records statistics for all monitored
+   functions and system calls: their last parameters, last return values, number
+   of calls, and sometimes more.
+
+.. c:var:: struct wrap_log_t logs
+
+   Contains some logs defined by some functions.
+
+The ``CTester/wrap.h`` header should import all headers (the ``.h``)used to
+define wrapping, statistics and failures structures, and should be imported in
+all implementations of the wrappers and associated functions (the ``.c``)
+
+Typical workflow
+================
+
+A typical workflow for testing the appropriate usage of a function starts by
+monitoring the wished function (here, :code:`open`)::
+
+    monitored.open = true;
+
+For the example, we want the student to call that function only one time,
+with the filename :code:`"file.txt"`, the flags :code:`O_RDWR | O_CREAT | O_TRUNC`
+and the :code:`S_IRUSR | S_IWUSR` permissions mode.
+
+Then, we may want the function to have a successful first call, but fail for
+all subsequent calls, for instance, if the student tries to open more than
+one file::
+
+    failures.open = FAIL_ALWAYS & ~(FAIL_FIRST);
+    failures.open_ret = -1;
+    failures.open_errno = EACCESS;
+
+Then, we call the student code within the sandbox::
+
+    int ret = -1;
+    SANDBOX_BEGIN;
+    ret = my_student_function(params);
+    SANDBOX_END;
+
+Only functions that are called within the sandbox will be tracked and monitored!
+
+Then, we can query the statistics of the call, given by the :code:`stats.open`
+field:
+
+- If :code:`stats.open.called` is 1, the student called the function. Then, we can
+  recover the last arguments through the :code:`stats.open.last_params` field,
+  and check that they correspond to the expected parameters.
+- If :code:`stats.open.called` is greater than one, we know that the student called
+  multiple times the :code:`open` function, which was not expected.
+- If :code:`stats.open.called` is still zero, the student didn't call the function.
+
+It is recommanded that you only run a minimal set of tests inside one test
+function. Monitorings, statistics, failures and other internal structures are
+reset to their default values at the start of the test function; if you need
+to reset them again, you need to look up for all the required functions in
+the appropriate documentations.
+
+.. _wrap_failures:
+
+Managing failures
+=================
+
+CTester allows programmed failures through the :c:data:`failures` global variable:
+we can ask CTester to make some function fail, with specified return values
+and :code:`errno` values.
+
+To cause a programmed failure, one has to choose at which time a function
+should fail: this is the role of the first field, :code:`<function_name>` (the same
+name as the function name). This is an :code:`uint32_t` where the n-th bit says
+whether the n-th call to the function should fail or not. Several constants
+are already available to choose from, but you can also combine them or define
+new ones:
+
+- :code:`FAIL_NEVER`, the default and initial value, causes the function to never
+  fail, whatever the number of times called;
+- :code:`FAIL_FIRST` causes the first call to fail; subsequent calls will succeed;
+- :code:`FAIL_SECOND` causes the second call to fail; the first one as well as
+  subsequent ones will succeed;
+- :code:`FAIL_THIRD` causes the third call to fail; the two first ones as well as
+  the 4th and subsequent calls will succeed;
+- :code:`FAIL_TWICE` causes the first two calls to fail; subsequent calls will
+  succeed;
+- :code:`FAIL_ALWAYS` causes all calls to fail.
+
+Failures can only be decided based on the number of times it has been called
+before, not based on the arguments that are passed. Some function calls add
+extra functionalities to have more custom failures: example of :code:`getaddrinfo`.
+
+It is possible to combine these values; for instance, if you want all calls
+to fail except the first two ones and except the 4th one, you can get an
+appropriate value by doing::
+
+    FAIL_ALWAYS & ~(FAIL_TWICE | 0b1000);
+
+Note that only :code:`FAIL_ALWAYS` will cause all calls to fail: the above value
+will only cause calls up to the 32nd to fail, and the 33rd will succeed.
+This is because the field is only 32-bits wide.
+
+.. note:: An improvement would be to check that the 32nd bit is set and decide
+   that it means that the 33rd and up calls should fail: feel free to add
+   support for this!
+
+Once failures have been decided, one can set the return value and the :code:`errno`
+value by setting respectively the fields :code:`<function_name>_ret` and
+:code:`<function_name>_errno` of the :c:data:`failures` global variable. The values will
+be the same for each call failures. In general, the :code:`<function_name>_ret`
+field is an :code:`int`, with the notable exception of :manpage:`malloc(3)` and related.
+
+Statistics
+==========
+
+Each of the statistics structure for a function follow approximately the same
+structure. For instance, the structures for the following fictitious function::
+
+    int my_func(int mode, const void *buf, size_t count, const struct sockaddr *dest_addr, struct sockaddr *source_addr);
+
+would be::
+
+    struct params_my_func_t {
+        int mode;
+        const void *buf;
+        size_t count;
+        const struct sockaddr *dest_addr;
+        struct sockaddr *source_addr;
+    };
+    struct stats_my_func_t {
+        int called;
+        struct params_my_func_t last_params;
+        int last_return;
+    };
+
+The first structure, :code:`params_my_func_t`, contains the value of all the
+parameters of the function.
+
+The second structure contains three fields:
+
+- :code:`called` which counts how many times the function has been called;
+- :code:`last_params` which contains a copy of the values of the parameters
+  of the last call to the function;
+- :code:`last_return` which contains the return value of the last call to the
+  function.
+
+Note that only function calls that were done within the sandbox are counted;
+outside of the sandbox, CTester doesn't count the calls nor save the parameters
+or return values.
+
+Most of the functions and system calls follow this structure, and future
+wrapped functions are expected to respect this format.
+
+There are a few exceptions to this pattern:
+
+- Functions that have only one parameter may bypass the :code:`struct params_t`
+  completely, and the sole parameter may be directly stored in :code:`last_params`;
+  the documentation should precise this choice.
+- In case of only one parameter, you should still call the field :code:`last_params`;
+  any exception of this rule in the current version of CTester is unfortunate
+  but cannot be changed for backward compatibility reasons. [#sleep]_
+- Functions that take no parameter should not have that field, as it makes
+  no sense for them, and it is discouraged to have empty structures.
+- Functions that return nothing (i.e., :code:`void`) similarly should not have the
+  :code:`last_return` field.
+
+.. [#sleep] :manpage:`sleep(3)` choosed the field name :code:`last_arg`.
+
+Additional statistics
+---------------------
+
+In addition to the above fields and structures, it is possible for a function
+to define additional structures and fields.
+
+The first common additional statistics happens when a function takes
+a parameter that is a pointer to a structure. For instance, in the above
+function, :code:`dest_addr` is a pointer to a constant structure, that is used by
+the call for some purpose: the pointer itself only has a meaning if the
+structure still exists at the time the statistics are accessed; maybe,
+in the time between the call to the function and the moment when we read
+the field, the structure has been deallocated and it no longer available.
+
+In that kind of case, one may add an additional field in the :code:`params_t`
+structure containing a copy of this structure, like this::
+
+    struct params_my_func_t {
+        int mode;
+        const void *buf;
+        size_t count;
+        const struct sockaddr *dest_addr;
+        struct dest_addr_val;
+        struct sockaddr *source_addr;
+    };
+
+The proper way of doing this is by using a field name derived from
+the parameter name with the :code:`_val` suffix appended to it [#badptr]_.
+
+There is a notable exception to this pattern: a parameter that points to a data
+buffer, or to an array of non-predefined size, should not be copied or saved.
+This is the case of the :code:`buf` parameter, which points to a buffer of data
+that is modified by the function: we don't know the size
+of the buffer of data, and can't allocate it in the structure other than by
+allocating a new buffer and copying. If the parameter was pointing to an array
+which size doesn't depend on the call (it is pre-defined, for instance
+3 items), it is authorized to maintain a copy.
+
+For instance, :manpage:`poll(2)`'s first parameter is an array of structures, whose size
+is specified by a parameter of the call, and so should not be copied.
+The third parameter of the :manpage:`utimensat(2)` system call, however, is a pointer
+to an array of two :code:`struct timespec`, and could be saved.
+
+A second kind of additional statistics happens when a function takes a pointer
+to a non-const structure, and it is expected that the function fills in
+the value of the structure during the call (this is the case of the :code:`addr`
+parameter of the :manpage:`accept(2)` system call). For instance, suppose :code:`source_addr`
+will be filled by the :code:`my_func` function during the call. Then, this field
+is a kind of "return value", and we may want to save it. The proper way of
+doing is by declaring a new structure::
+
+    struct return_my_func_t {
+        struct sockaddr source_addr;
+    };
+
+and adding it to the :code:`stats_t` structure, with a field name of :code:`last_returns`::
+
+    struct stats_my_func_t {
+        int called;
+        struct params_my_func_t last_params;
+        int last_return;
+        struct return_my_func_t last_returns;
+    };
+
+``accept`` and ``recvfrom`` are perfect examples of this pattern. ``stat`` also
+follows this pattern, bu uses a different field name (bad idea again).
+
+If there is only one field in the :code:`return_t` structure, it is possible
+to bypass the structure completely and directly put the return value in
+the :code:`stats_t` structure.
+
+.. [#badptr] Some functions to the opposite: the pointer is named :code:`dest_addr_ptr`
+   and the value is named :code:`dest_addr`. This is to be avoided, but again,
+   we can't correct this for backward compatibility reasons.
+
+Wrapper structure
+=================
+
+Each wrapper for a function has mostly the same structure, save for the few
+missing features or additional features which are described in the appropriate
+pages of the documentation. The structure for the same fictitious function::
+
+    int my_func(int mode, const void *buf, size_t count, struct sockaddr *source_addr);
+
+would be like this::
+
+    // Declared in .c file
+
+    // No need to declare it, the compiler does it
+    int __real_my_func(int mode, const void *buf, size_t count, const struct sockaddr *dest_addr, struct sockaddr *source_addr);
+
+    int __wrap_my_func(int mode, const void *buf, size_t count, const struct sockaddr *dest_addr, struct sockaddr *source_addr)
+    {
+        if (!(wrap_monitoring && monitored.my_func)) {
+            return __real_my_func(mode, buf, count, dest_addr, source_addr);
+        }
+        stats.my_func.called++;
+        stats.my_func.last_params = (struct params_my_func_t) {
+            .mode = mode,
+            .buf = buf,
+            .count = count,
+            .dest_addr = dest_addr,
+            .source_addr = source_addr
+        };
+        if (FAIL(failures.my_func)) {
+            failures.my_func = NEXT(failures.my_func);
+            errno = failures.my_func_errno;
+            return stats.my_func.last_return = failures.my_func_ret;
+        }
+        failures.my_func = NEXT(failures.my_func);
+        int ret = __real_my_func(mode, buf, count, dest_addr, source_addr);
+        /* Copy values of pointed arguments if you want to here */
+        return (stats.last_return = ret);
+    }
+
+The :code:`FAIL` and :code:`NEXT` functions are defined in ``CTester/wrap.h``.
+
+If the two above-mentioned additional statistics are implemented, they should
+go where indicated: this way, a potential segmentation fault when dereferencing
+would be caused within :code:`__real_my_func`, and not in the wrapper, and may thus
+be caught by some internal mechanism (system calls usually detect segfaults
+without crashing the whole application).
+
+Logging
+=======
+
+Currently, the :c:type:`wrap_log_t` structure only contains one field, :code:`malloc`,
+that contains a :c:type:`malloc_t` structure that is used by :manpage:`malloc(3)` and related
+to track the memory areas that are allocated and freed. Consult the
+:ref:`wrap_mallocs` section for more informations.
+
+List of wrapped functions and system calls
+==========================================
+
+The following table lists the various functions and system calls that currently
+have a wrapper and are supported by CTester, as well as their level of support
+of some features:
+
+- Monitoring: whether they are available in the :code:`wrap_monitor_t` structure;
+  right now there are no exception.
+- Call and usage statistics.
+- Programmed failures.
+- Whether they save a copy of the returned results when those results are
+  filled in pointers passed as parameters:
+  "No return" indicates that these calls don't return nothing except the return
+  value; "None" indicates that these calls don't copy any return value as
+  parameter, but there are some parameters that could. Data buffers fileld by
+  the call are not considered return values nor results.
+- If they support some additional features, and which.
+
+A link to the appropriate API page is also provided.
+
+Not all functions are currently wrapped. The most notable and most embarrassing
+example is that of the signal management functions.
+
+.. |fctname| replace:: Function name
+.. |mon| replace:: Monitoring
+.. |stt| replace:: Statistics
+.. |fls| replace:: Failures
+.. |cpy| replace:: Copy of returned pointers
+.. |adf| replace:: Additional features
+.. |prw| replace:: :ref:`partial_read_write`
+.. |chckfai| replace:: Checked freeaddrinfo
+
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+|       |fctname|       | |mon| | |stt| |  |fls|  |    |cpy|     |    |adf|     |     Documentation      |
++=======================+=======+=======+=========+==============+==============+========================+
+| accept                | Yes   | Yes   | Yes     | Yes (addr    | None         | :ref:`wrap_sockets`    |
+|                       |       |       |         | and addrlen) |              |                        |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| bind                  | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_sockets`    |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| calloc                | Yes   | Yes   | Yes (no | No return    | Tracks       | :ref:`wrap_mallocs`    |
+|                       |       |       | errno   |              | memory usage |                        |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| close                 | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_file`       |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| connect               | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_sockets`    |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| creat                 | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_file`       |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| free                  | Yes   | Yes   | Yes     | No return    | Tracks       | :ref:`wrap_mallocs`    |
+|                       |       |       | [#fre]_ |              | memory usage |                        |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| fstat                 | Yes   | Yes   | Yes     | Yes (struct  | None         | :ref:`wrap_file`       |
+|                       |       |       |         | stat buf)    |              |                        |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| freeaddrinfo          | Yes   | Yes   | No      | No return    | - |chckfai|  | :ref:`wrap_util_dns`   |
+|                       |       |       | [#fai]_ |              |              |                        |
++-----------------------+-------+-------+---------+--------------+ - custom     +------------------------+
+| getaddrinfo           | Yes   | Yes   | Yes     | See doc      |   wrappers   | :ref:`wrap_util_dns`   |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| gai_strerror          | Yes   | Yes   | Yes     | No return    | custom       | :ref:`wrap_util_dns`   |
+|                       |       |       |         |              | wrappers     |                        |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| getnameinfo           | Yes   | Yes   | Yes     | No return    | - custom     | :ref:`wrap_util_dns`   |
+|                       |       |       |         |              |   wrappers   |                        |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| getpid                | Yes   | Yes   | No      | No return    | None         | :ref:`wrap_misc`       |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| htonl                 | Yes   | Yes   | No      | No return    | None         | :ref:`wrap_util_inet`  |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| htons                 | Yes   | Yes   | No      | No return    | None         | :ref:`wrap_util_inet`  |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| listen                | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_sockets`    |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| lseek                 | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_file`       |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| malloc                | Yes   | Yes   | Yes     | No return    | Tracks       | :ref:`wrap_mallocs`    |
+|                       |       |       |         |              | memory usage |                        |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| ntohl                 | Yes   | Yes   | No      | No return    | None         | :ref:`wrap_util_inet`  |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| ntohs                 | Yes   | Yes   | No      | No return    | None         | :ref:`wrap_util_inet`  |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| open                  | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_file`       |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| poll                  | Yes   | Yes   | Yes     | None         | None         | :ref:`wrap_sockets`    |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| pthread_mutex_destroy | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_mutexs`     |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| pthread_mutex_init    | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_mutexs`     |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| pthread_mutex_lock    | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_mutexs`     |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| pthread_mutex_trylock | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_mutexs`     |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| pthread_mutex_unlock  | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_mutexs`     |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| read                  | Yes   | Yes   | Yes     | No return    | Supports     | :ref:`wrap_file`       |
+|                       |       |       |         |              | partial      |                        |
+|                       |       |       |         |              | returns (see |                        |
+|                       |       |       |         |              | |prw|        |                        |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| realloc               | Yes   | Yes   | Yes (no | No return    | Tracks       | :ref:`wrap_mallocs`    |
+|                       |       |       | errno)  |              | memory usage |                        |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| recv                  | Yes   | Yes   | Yes     | No return    | Support      | :ref:`wrap_sockets`    |
++-----------------------+-------+-------+---------+--------------+ partial      |                        |
+| recvfrom              | Yes   | Yes   | Yes     | Yes (addr    | returns (see |                        |
+|                       |       |       |         | and addrlen) | |prw|)       |                        |
++-----------------------+-------+-------+---------+--------------+--------------+                        |
+| recvmsg               | Yes   | Yes   | Yes     | Yes (msg)    | None         |                        |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| select                | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_sockets`    |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| send                  | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_sockets`    |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| sendto                | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_sockets`    |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| sendmsg               | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_sockets`    |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| shutdown              | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_sockets`    |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| sleep                 | Yes   | Yes   | Yes (no | No return    | None         | :ref:`wrap_misc`       |
+|                       |       |       | errno)  |              |              |                        |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| socket                | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_sockets`    |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| stat                  | Yes   | Yes   | Yes     | Yes (struct  | None         | :ref:`wrap_file`       |
+|                       |       |       |         | stat buf)    |              |                        |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+| write                 | Yes   | Yes   | Yes     | No return    | None         | :ref:`wrap_file`       |
++-----------------------+-------+-------+---------+--------------+--------------+------------------------+
+
+.. [#fre] Although it can fail, we cannot enforce a return value nor a value
+   for :code:`errno`, so it is not really useful.
+
+.. [#fai] :manpage:`freeaddrinfo(3)` cannot fail in a detectable way for the student,
+   but there is a :code:`status` field that indicates a rough failure status.
+
diff --git a/run b/run
index 01fb6d2..c295907 100644
--- a/run
+++ b/run
@@ -1,135 +1,51 @@
 #!/bin/python3
 
 # Script d'interface entre INGInious et des tests unitaires écrits à l'aide de CUnit
-# Auteurs : Mathieu Xhonneux, Anthony Gégo
+# Auteurs : Jean-Martin Vlaeminck
 # Licence : GPLv3
 
-import subprocess, shlex, re, os, yaml
-from inginious import feedback, rst, input
-
-# Switch working directory to student/
-os.chdir("student")
-
-# Fetch and save the student code into a file for compilation
-input.parse_template("student_code.c.tpl", "student_code.c")
-
-# Compilation
-p = subprocess.Popen(shlex.split("make"), stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
-make_output = p.communicate()[0].decode('utf-8')
-# If compilation failed, exit with "failed" result
-if p.returncode:
-    feedback.set_tag("not_compile", True)
-    feedback.set_global_result("failed")
-    feedback.set_global_feedback("La compilation de votre code a échoué. Voici le message de sortie de la commande ``make`` :")
-    feedback.set_global_feedback(rst.get_codeblock('', make_output), True)
-    exit(0)
-else:
-    feedback.set_global_result("success")
-    feedback.set_global_feedback("- Votre code compile.\n")
-
-# Parse banned functions
-try:
-    banned_funcs = re.findall("BAN_FUNCS\(([a-zA-Z0-9_, ]*)\)", open('tests.c').read())[-1].replace(" ", "").split(",")
-    banned_funcs = list(filter(None, banned_funcs))
-except IndexError:
-    banned_funcs = []
-
-if banned_funcs:
-    p = subprocess.Popen(shlex.split("readelf -s student_code.o"), stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
-    readelf_output = p.communicate()[0].decode('utf-8')
-    for func in banned_funcs:
-        if re.search("UND {}\n".format(func), readelf_output):
-            feedback.set_tag("banned_funcs", True)
-            feedback.set_global_result("failed")
-            feedback.set_global_feedback("Vous utilisez la fonction {}, qui n'est pas autorisée.".format(func))
-            exit(0)
-
-
-# Remove source files
-subprocess.run("rm -rf *.c *.tpl *.h *.o", shell=True)
-
-LANG = input.get_input('@lang')
-
-# Run the code in a parallel container
-p = subprocess.Popen(shlex.split("run_student --time 20 --hard-time 60 ./tests LANGUAGE={}".format(LANG)), stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
-p.communicate()
-
-# If run failed, exit with "failed" result
-if p.returncode:
-    feedback.set_global_result("failed")
-    if p.returncode == 256-8:
-        montest_output = rst.get_admonition("warning", "**Erreur d'exécution**", "Votre code a produit une erreur. Le signal SIGFPE a été envoyé : *Floating Point Exception*.")
-        feedback.set_tag("sigfpe", True)
-    elif p.returncode == 256-11:
-        montest_output = rst.get_admonition("warning", "**Erreur d'exécution**", "Votre code a produit une erreur. Le signal SIGSEGV a été envoyé : *Segmentation Fault*.")
-    elif p.returncode == 252:
-        montest_output = rst.get_admonition("warning", "**Erreur d'exécution**", "Votre code a tenté d'allouer plus de mémoire que disponible.")
-        feedback.set_tag("memory", True)
-    elif p.returncode == 253:
-        montest_output = rst.get_admonition("warning", "**Erreur d'exécution**", "Votre code a pris trop de temps pour s'exécuter.")
+from __future__ import print_function
+import subprocess, os, shlex, sys
+
+# Get a copy of CTester in the student/ directory, as well as the run.py file
+# From CTester, we need:
+# - the run.py file, at the root of the task
+# - the Makefile, in the student/ folder
+# - the CTester folder, containing all the wraping code, in the student/ folder too
+# We can find it
+# - in the current directory
+# - in the /course/common/CTester/ directory
+
+"""CTester_files = ["/student/Ctester", "/run.py", "/student/Makefile"]"""
+
+def has_CTester(path="."):
+    return os.path.isdir(path + "/student/CTester") and os.path.exists(path + "/run.py") and os.path.exists(path + "/student/Makefile")
+
+def copy_CTester():
+    if has_CTester("."):
+        return 0 # Use it right here
+    elif has_CTester("/course/common/CTester"):
+        # Copy it to here
+        p = subprocess.Popen(shlex.split("cp -n -r /course/common/CTester/. ."), stdin=None, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        (cp_output, cp_errput) = p.communicate()
+        if p.returncode:
+            print("Unable to move CTester", file=sys.stderr)
+            return 1
+        return 0
     else:
-        montest_output = rst.get_admonition("warning", "**Erreur d'exécution**", "Votre code a produit une erreur.")
-    feedback.set_global_feedback(rst.indent_block(2, montest_output, " "), True)
-    exit(0)
-#elif run_output:   
-#    feedback.set_global_feedback("- Sortie de votre méthode de test:\n" + rst.indent_block(2, rst.get_codeblock('', run_output), " "), True)
-
-# Comment to run the tests
-#feedback.set_global_feedback("- **Cette note n'est pas finale.** Une série de tests sera exécutée sur votre code après l'examen.\n", True)
-#exit(0)
-
-# Fetch CUnit test results
-results_raw = [r.split('#') for r in open('results.txt').read().splitlines()]
-results = [{'pid':r[0], 'code':r[1], 'desc':r[2], 'weight':int(r[3]), 'tags': r[4].split(","), 'info_msgs':r[5:]} for r in results_raw]
-
-
-# Produce feedback
-if all([r['code'] == 'SUCCESS' for r in results]):
-    feedback.set_global_feedback("\n- Votre code a passé tous les tests.", True)
-else:
-    feedback.set_global_feedback("\n- Il y a des erreurs dans votre solution.", True)
-
-score = 0
-total = 0
-tests_result = {}
-
-for test in results:
-    total += test['weight']
-    for tag in test['tags']:
-        if tag != "":
-            feedback.set_tag(tag, True)
-    if test['code'] == 'SUCCESS':
-        score += test['weight']
-        feedback.set_problem_feedback("* {desc}\n\n  => réussi ({weight}/{weight}) pts)\n\n".format(**test)+("  Info: {}\n\n".format(" — ".join(test['info_msgs'])) if test['info_msgs'] else '\n'),
-                test['pid'], True)
-        tests_result[test['pid']] = True if tests_result.get(test['pid'], True) else False
-    else:
-        feedback.set_problem_feedback("* {desc}\n\n  => échoué (0/{weight}) pts)\n\n".format(**test)+("  Info: {}\n\n".format(" — ".join(test['info_msgs'])) if test['info_msgs'] else '\n'),
-                test['pid'], True)
-        tests_result[test['pid']] = False
-        
-for pid, result in tests_result.items():
-    if result:
-        feedback.set_problem_result("success", pid)
-    else:
-        feedback.set_problem_result("failed", pid)
-
-with open("../task.yaml", 'r') as stream:
-    problems = yaml.load(stream)['problems']
-    
-    for name, meta in problems.items():
-        if meta['type'] == 'match':
-            answer = input.get_input(name)
-            if answer == meta['answer']:
-                feedback.set_problem_result("success", name)
-                feedback.set_problem_feedback("Votre réponse est correcte. (1/1 pts)", name, True)
-                score += 1
-            else:
-                feedback.set_problem_result("failed", name)
-                feedback.set_problem_feedback("Votre réponse est incorrecte. (0/1 pts)", name, True)
-
-            total += 1
+        print("Unable to locate CTester", file=sys.stderr)
+        return 1
+
+def run():
+    """Call the subprocess"""
+    p = subprocess.Popen(shlex.split("/bin/python3 run.py --no-use-fifty"))
+    p.wait()
+    return p.returncode
+
+if __name__ == "__main__":
+    ret = copy_CTester()
+    if ret:
+        exit(ret)
+    ret = run()
+    exit(ret)
 
-score = 100*score/(total if not total == 0 else 1)
-feedback.set_grade(score)
-feedback.set_global_result("success" if score >= 50 else "failed")
diff --git a/run.py b/run.py
new file mode 100644
index 0000000..f8555f3
--- /dev/null
+++ b/run.py
@@ -0,0 +1,148 @@
+#!/bin/python3
+
+# Script d'interface entre INGInious et des tests unitaires écrits à l'aide de CUnit
+# Auteurs : Mathieu Xhonneux, Anthony Gégo
+# Licence : GPLv3
+
+import subprocess, shlex, re, os, yaml, sys
+from inginious import feedback, rst, input
+
+# Switch working directory to student/
+use_fifty = True if len(sys.argv) == 1 or (len(sys.argv) > 1 and "--use-fifty" in sys.argv) else False
+os.chdir("student")
+
+# Fetch and save the student code into a file for compilation
+input.parse_template("student_code.c.tpl", "student_code.c")
+
+# Compilation
+p = subprocess.Popen(shlex.split("make"), stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
+make_output = p.communicate()[0].decode('utf-8')
+# If compilation failed, exit with "failed" result
+if p.returncode:
+    feedback.set_tag("not_compile", True)
+    feedback.set_global_result("failed")
+    feedback.set_global_feedback("La compilation de votre code a échoué. Voici le message de sortie de la commande ``make`` :")
+    feedback.set_global_feedback(rst.get_codeblock('', make_output), True)
+    exit(0)
+else:
+    # Cppcheck
+    p = subprocess.Popen(shlex.split("make check"), stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
+    cppcheck_output = p.communicate()[0].decode('utf-8')
+    if p.returncode:
+        feedback.set_tag("cppcheck", True)
+        feedback.set_global_result("failed")
+        feedback.set_global_feedback("La compilation de votre code avec ``cppcheck`` a échoué. Voici le message de sortie de la commande ``make check`` :")
+        feedback.set_global_feedback(rst.get_codeblock('', cppcheck_output), True)
+        exit(0)
+    else:
+        feedback.set_global_result("success")
+        feedback.set_global_feedback("- Votre code compile.\n")
+
+# Parse banned functions
+try:
+    banned_funcs = re.findall("BAN_FUNCS\(([a-zA-Z0-9_, ]*)\)", open('tests.c').read())[-1].replace(" ", "").split(",")
+    banned_funcs = list(filter(None, banned_funcs))
+except IndexError:
+    banned_funcs = []
+
+if banned_funcs:
+    p = subprocess.Popen(shlex.split("readelf -s student_code.o"), stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
+    readelf_output = p.communicate()[0].decode('utf-8')
+    for func in banned_funcs:
+        if re.search("UND {}\n".format(func), readelf_output):
+            feedback.set_tag("banned_funcs", True)
+            feedback.set_global_result("failed")
+            feedback.set_global_feedback("Vous utilisez la fonction {}, qui n'est pas autorisée.".format(func))
+            exit(0)
+
+
+# Remove source files
+subprocess.run("rm -rf *.c *.tpl *.h *.o", shell=True)
+
+LANG = input.get_input('@lang')
+
+# Run the code in a parallel container
+p = subprocess.Popen(shlex.split("run_student --time 20 --hard-time 60 ./tests LANGUAGE={}".format(LANG)), stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
+o, e = p.communicate()
+print(o.decode("utf-8"))
+
+# If run failed, exit with "failed" result
+if p.returncode:
+    feedback.set_global_result("failed")
+    if p.returncode == 256-8:
+        montest_output = rst.get_admonition("warning", "**Erreur d'exécution**", "Votre code a produit une erreur. Le signal SIGFPE a été envoyé : *Floating Point Exception*.")
+        feedback.set_tag("sigfpe", True)
+    elif p.returncode == 256-11:
+        montest_output = rst.get_admonition("warning", "**Erreur d'exécution**", "Votre code a produit une erreur. Le signal SIGSEGV a été envoyé : *Segmentation Fault*.")
+    elif p.returncode == 252:
+        montest_output = rst.get_admonition("warning", "**Erreur d'exécution**", "Votre code a tenté d'allouer plus de mémoire que disponible.")
+        feedback.set_tag("memory", True)
+    elif p.returncode == 253:
+        montest_output = rst.get_admonition("warning", "**Erreur d'exécution**", "Votre code a pris trop de temps pour s'exécuter.")
+    else:
+        montest_output = rst.get_admonition("warning", "**Erreur d'exécution**", "Votre code a produit une erreur.")
+    feedback.set_global_feedback(rst.indent_block(2, montest_output, " "), True)
+    exit(0)
+#elif run_output:   
+#    feedback.set_global_feedback("- Sortie de votre méthode de test:\n" + rst.indent_block(2, rst.get_codeblock('', run_output), " "), True)
+
+# Comment to run the tests
+#feedback.set_global_feedback("- **Cette note n'est pas finale.** Une série de tests sera exécutée sur votre code après l'examen.\n", True)
+#exit(0)
+
+# Fetch CUnit test results
+results_raw = [r.split('#') for r in open('results.txt').read().splitlines()]
+results = [{'pid':r[0], 'code':r[1], 'desc':r[2], 'weight':int(r[3]), 'tags': r[4].split(","), 'info_msgs':r[5:]} for r in results_raw]
+
+
+# Produce feedback
+if all([r['code'] == 'SUCCESS' for r in results]):
+    feedback.set_global_feedback("\n- Votre code a passé tous les tests.", True)
+else:
+    feedback.set_global_feedback("\n- Il y a des erreurs dans votre solution.", True)
+
+score = 0
+total = 0
+tests_result = {}
+
+for test in results:
+    total += test['weight']
+    for tag in test['tags']:
+        if tag != "":
+            feedback.set_tag(tag, True)
+    if test['code'] == 'SUCCESS':
+        score += test['weight']
+        feedback.set_problem_feedback("* {desc}\n\n  => réussi ({weight}/{weight}) pts)\n\n".format(**test)+("  Info: {}\n\n".format(" — ".join(test['info_msgs'])) if test['info_msgs'] else '\n'),
+                test['pid'], True)
+        tests_result[test['pid']] = True if tests_result.get(test['pid'], True) else False
+    else:
+        feedback.set_problem_feedback("* {desc}\n\n  => échoué (0/{weight}) pts)\n\n".format(**test)+("  Info: {}\n\n".format(" — ".join(test['info_msgs'])) if test['info_msgs'] else '\n'),
+                test['pid'], True)
+        tests_result[test['pid']] = False
+        
+for pid, result in tests_result.items():
+    if result:
+        feedback.set_problem_result("success", pid)
+    else:
+        feedback.set_problem_result("failed", pid)
+
+with open("../task.yaml", 'r') as stream:
+    problems = yaml.load(stream)['problems']
+    
+    for name, meta in problems.items():
+        if meta['type'] == 'match':
+            answer = input.get_input(name)
+            if answer == meta['answer']:
+                feedback.set_problem_result("success", name)
+                feedback.set_problem_feedback("Votre réponse est correcte. (1/1 pts)", name, True)
+                score += 1
+            else:
+                feedback.set_problem_result("failed", name)
+                feedback.set_problem_feedback("Votre réponse est incorrecte. (0/1 pts)", name, True)
+
+            total += 1
+
+score = 100*score/(total if not total == 0 else 1)
+feedback.set_grade(score)
+global_result = "success" if (score >= 50 and use_fifty) or (score == 100 and not use_fifty) else "failed"
+feedback.set_global_result(global_result)
diff --git a/student/CTester/CTester.c b/student/CTester/CTester.c
index f4a85fa..dc678de 100644
--- a/student/CTester/CTester.c
+++ b/student/CTester/CTester.c
@@ -1,3 +1,18 @@
+/*
+ * Main CTester file, containing all base functions and structures.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #define _GNU_SOURCE
 
 #include <stdlib.h>
@@ -19,6 +34,7 @@
 #include <malloc.h>
 
 #include "wrap.h"
+#include "read_write.h"
 
 #define TAGS_NB_MAX 20
 #define TAGS_LEN_MAX 30
@@ -31,10 +47,25 @@ extern struct wrap_log_t logs;
 
 extern sigjmp_buf segv_jmp;
 
+/**
+ * Copies of the real standard output and error output
+ * (that is, the actual files refered to by STDOUT_FILENO and STDERR_FILENO
+ * before we change them using dup2(2)).
+ * This allows us to restore the correct stdout/stderr of the program after the sandbox.
+ */
 int true_stderr;
 int true_stdout;
+/**
+ * pipe_std(err|out)[2] : when in the sandbox, when writing on STD(ERR|OUT)_FILENO, the program will write on [1] too. At the end of the sandbox, its content (on [0]) will be writtent to usr_pip_std(err|out)[1].
+ * usr_pipe_std(err|out)[2] : when quitting the sandbox,
+ * the content of pipe_std(err|out)[0] will be written on [1], and will be accessible on std(err|out)_cpy too.
+ */
 int pipe_stderr[2], usr_pipe_stderr[2];
 int pipe_stdout[2], usr_pipe_stdout[2];
+/**
+ * File stream objects used to print on true_stdout and true_stderr while in sandbox.
+ */
+extern FILE *fstdout, *fstderr;
 extern int stdout_cpy, stderr_cpy;
 struct itimerval it_val;
 
@@ -73,13 +104,17 @@ void push_info_msg(char *msg)
     }
 
     struct info_msg *item = malloc(sizeof(struct info_msg));
-    if (item == NULL)
+    if (item == NULL) {
         test_metadata.err = ENOMEM;
+        return;
+    }
 
     item->next = NULL;
     item->msg = malloc(strlen(msg) + 1);
-    if (item->msg == NULL)
+    if (item->msg == NULL) {
         test_metadata.err = ENOMEM;
+        return;
+    }
 
     strcpy(item->msg, msg);
     if (test_metadata.fifo_in == NULL && test_metadata.fifo_out == NULL) {
@@ -104,7 +139,11 @@ void set_tag(char *tag)
         strncpy(test_metadata.tags[test_metadata.nb_tags++], tag, TAGS_LEN_MAX);
 }
 
-void segv_handler(int sig, siginfo_t *unused, void *unused2) {
+void segv_handler(int sig, siginfo_t *unused, void *unused2)
+{
+    (void)sig;
+    (void)unused;
+    (void)unused2;
     wrap_monitoring = false;
     push_info_msg(_("Your code produced a segfault."));
     set_tag("sigsegv");
@@ -112,8 +151,23 @@ void segv_handler(int sig, siginfo_t *unused, void *unused2) {
     siglongjmp(segv_jmp, 1);
 }
 
+void fpe_handler(int sig, siginfo_t *unused, void *unused2)
+{
+    (void)sig;
+    (void)unused;
+    (void)unused2;
+    wrap_monitoring = false;
+    push_info_msg(_("Your code produced an arithmetic exception."));
+    set_tag("sigfpe");
+    wrap_monitoring = true;
+    siglongjmp(segv_jmp, 1);
+}
+
 void alarm_handler(int sig, siginfo_t *unused, void *unused2)
 {
+    (void)sig;
+    (void)unused;
+    (void)unused2;
     wrap_monitoring = false;
     push_info_msg(_("Your code exceeded the maximal allowed execution time."));
     set_tag("timeout");
@@ -153,13 +207,14 @@ void sandbox_end()
 {
     wrap_monitoring = false;
 
-    // Remapping stderr to the orignal one ...
+    // Remapping stdout and stderr to the orignal one ...
     dup2(true_stdout, STDOUT_FILENO); // TODO
     dup2(true_stderr, STDERR_FILENO);
 
     // ... and looking for a double free warning
     char buf[BUFSIZ];
-    int n;
+    memset(buf, 0, sizeof(buf));
+    ssize_t n = 0;
     while ((n = read(pipe_stdout[0], buf, BUFSIZ)) > 0) {
         write(usr_pipe_stdout[1], buf, n);
         write(STDOUT_FILENO, buf, n);
@@ -168,6 +223,7 @@ void sandbox_end()
 
     while ((n = read(pipe_stderr[0], buf, BUFSIZ)) > 0) {
         if (strstr(buf, "double free or corruption") != NULL) {
+            // TODO n'y a-t-il pas un risque que le message se fasse couper en plusieurs morceaux à cause de read ?
             CU_FAIL("Double free or corruption");
             push_info_msg(_("Your code produced a double free."));
             set_tag("double_free");
@@ -197,16 +253,40 @@ int clean_suite1(void)
 
 void start_test()
 {
-    bzero(&test_metadata,sizeof(test_metadata));
-    bzero(&stats,sizeof(stats));
-    bzero(&failures,sizeof(failures));
-    bzero(&monitored,sizeof(monitored));
-    bzero(&logs,sizeof(logs));
+    memset(&test_metadata, 0, sizeof(test_metadata));
+    memset(&stats, 0, sizeof(stats));
+    memset(&failures, 0, sizeof(failures));
+    memset(&monitored, 0, sizeof(monitored));
+    memset(&logs, 0, sizeof(logs));
+    reset_gai_fai_gstr_gni_methods();
+    reinit_read_fd_table();
 }
 
-int __real_exit(int status);
-int __wrap_exit(int status){
-    return status;
+/**
+ * CTester functions should *never* call exit directly, but rather __real_exit;
+ * this prevents completely-undefined behaviour from arising in the correcter's program.
+ */
+void __real_exit(int status);
+
+/**
+ * The exit call is considered special by glibc and gcc:
+ * it considers that after such a call, everything that comes after it
+ * will never be executed normally, and therefore it doesn't bother
+ * adding code to perform a clean function return:
+ * the program will have undefined behaviour if this function,
+ * __wrap_exit, actually returns to the callee, and this may or may not end
+ * in a catchable segfault.
+ * If we accept the possibility of a student calling exit, then it is better
+ * to explicitly raise the segfault in order to have a less-undefined behaviour.
+ */
+void __wrap_exit(int status)
+{
+    if (!(wrap_monitoring)) {
+        __real_exit(status);
+    } // else : monitored and in sandbox
+
+    raise(SIGSEGV); // raise SIGSEGV if it comes from the student.
+    // TODO add code so that the student's code can actually exit
 }
 
 int run_tests(int argc, char *argv[], void *tests[], int nb_tests) {
@@ -224,13 +304,18 @@ int run_tests(int argc, char *argv[], void *tests[], int nb_tests) {
     // Code for detecting properly double free errors
     mallopt(M_CHECK_ACTION, 1); // don't abort if double free
     true_stderr = dup(STDERR_FILENO); // preparing a non-blocking pipe for stderr
-    true_stdout = dup(STDOUT_FILENO); // preparing a non-blocking pipe for stderr
+    true_stdout = dup(STDOUT_FILENO); // preparing a non-blocking pipe for stdout
+    fstdout = fdopen(true_stdout, "w"); // We can't just copy-paste stdout and stderr
+    fstderr = fdopen(true_stderr, "w"); // as these structures use the file descriptor
 
     int *pipes[] = {pipe_stderr, pipe_stdout, usr_pipe_stdout, usr_pipe_stderr};
     for(int i=0; i < 4; i++) { // Configuring pipes to be non-blocking
         pipe(pipes[i]);
-        int flags = fcntl(pipes[i][0], F_GETFL, 0);
+        int flags;
+        flags = fcntl(pipes[i][0], F_GETFL, 0);
         fcntl(pipes[i][0], F_SETFL, flags | O_NONBLOCK);
+        flags = fcntl(pipes[i][1], F_GETFL, 0);
+        fcntl(pipes[i][1], F_SETFL, flags | O_NONBLOCK);
     }
     stdout_cpy = usr_pipe_stdout[0];
     stderr_cpy = usr_pipe_stderr[0];
@@ -248,11 +333,15 @@ int run_tests(int argc, char *argv[], void *tests[], int nb_tests) {
         .ss_sp = stack,
     };
 
-    sa.sa_flags     = SA_NODEFER|SA_ONSTACK|SA_RESTART;
+    sa.sa_flags     = SA_NODEFER | SA_ONSTACK | SA_RESTART | SA_SIGINFO;
     sa.sa_sigaction = segv_handler;
     sigaltstack(&ss, 0);
     sigfillset(&sa.sa_mask);
     int ret = sigaction(SIGSEGV, &sa, NULL);
+    if (ret)
+        return ret;
+    sa.sa_sigaction = fpe_handler;
+    ret = sigaction(SIGFPE, &sa, NULL);
     if (ret)
         return ret;
     sa.sa_sigaction = alarm_handler;
@@ -268,24 +357,34 @@ int run_tests(int argc, char *argv[], void *tests[], int nb_tests) {
 
 
     /* initialize the CUnit test registry */
-    if (CUE_SUCCESS != CU_initialize_registry())
+    if (CUE_SUCCESS != CU_initialize_registry()) {
+        fprintf(stderr, "Error when initializing registry\n");
+        fclose(f_out);
         return CU_get_error();
+    }
 
     /* add a suite to the registry */
     pSuite = CU_add_suite("Suite_1", init_suite1, clean_suite1);
     if (NULL == pSuite) {
         CU_cleanup_registry();
+        fprintf(stderr, "Error when adding suite\n");
+        fclose(f_out);
         return CU_get_error();
     }
 
     for (int i=0; i < nb_tests; i++) {
         Dl_info  DlInfo;
-        if (dladdr(tests[i], &DlInfo) == 0)
+        if (dladdr(tests[i], &DlInfo) == 0) {
+            fprintf(stderr, "Error when preparing test (dladdr)\n");
+            fclose(f_out);
             return -EFAULT;
+        }
 
         CU_pTest pTest;
         if ((pTest = CU_add_test(pSuite, DlInfo.dli_sname, tests[i])) == NULL) {
                 CU_cleanup_registry();
+                fprintf(stderr, "Error when adding test\n");
+                fclose(f_out);
                 return CU_get_error();
         }
 
@@ -293,11 +392,17 @@ int run_tests(int argc, char *argv[], void *tests[], int nb_tests) {
 
         start_test();
 
-        if (CU_basic_run_test(pSuite,pTest) != CUE_SUCCESS)
+        if (CU_basic_run_test(pSuite,pTest) != CUE_SUCCESS) {
+            fclose(f_out);
+            fprintf(stderr, "Error when executing tests: CU_basic_run_test\n");
             return CU_get_error();
+        }
 
-        if (test_metadata.err)
+        if (test_metadata.err) {
+            fclose(f_out);
+            fprintf(stderr, "Error when executing tests: metadata\n");
             return test_metadata.err;
+        }
 
         int nb = CU_get_number_of_tests_failed();
         if (nb > 0)
@@ -308,17 +413,17 @@ int run_tests(int argc, char *argv[], void *tests[], int nb_tests) {
             ret = fprintf(f_out, "%s#SUCCESS#%s#%d#", test_metadata.problem,
                     test_metadata.descr, test_metadata.weight);
         if (ret < 0)
-            return ret;
+            goto error_exit;
 
-        for(int i=0; i < test_metadata.nb_tags; i++) {
-            ret = fprintf(f_out, "%s", test_metadata.tags[i]);
+        for(int j=0; j < test_metadata.nb_tags; j++) {
+            ret = fprintf(f_out, "%s", test_metadata.tags[j]);
             if (ret < 0)
-                return ret;
+                goto error_exit;
 
-            if (i != test_metadata.nb_tags - 1) {
+            if (j != test_metadata.nb_tags - 1) {
                 ret = fprintf(f_out, ",");
                 if (ret < 0)
-                    return ret;
+                    goto error_exit;
             }
         }
 
@@ -333,21 +438,26 @@ int run_tests(int argc, char *argv[], void *tests[], int nb_tests) {
             free(head);
 
             if (ret < 0)
-                return ret;
+                goto error_exit;
         }
 
         test_metadata.fifo_out = NULL;
         ret = fprintf(f_out, "\n");
         if (ret < 0)
-            return ret;
-
+            goto error_exit;
     }
 
     fclose(f_out);
+    fclose(fstdout);
+    fclose(fstderr);
 
     /* Run all tests using the CUnit Basic interface */
     //CU_basic_run_tests();
     //CU_automated_run_tests();
     CU_cleanup_registry();
     return CU_get_error();
+error_exit:
+    fclose(f_out);
+    fprintf(stderr, "Error when printing the results.\n");
+    return ret;
 }
diff --git a/student/CTester/CTester.h b/student/CTester/CTester.h
index 4448ade..4322b68 100644
--- a/student/CTester/CTester.h
+++ b/student/CTester/CTester.h
@@ -1,3 +1,23 @@
+/**
+ * @file wrap.h
+ * Main CTester file, containing all base functions and structures.
+ */
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __CTESTER_MAIN_H__
+#define __CTESTER_MAIN_H__
+
 #include <sys/mman.h>
 #include <CUnit/CUnit.h>
 #include <setjmp.h>
@@ -38,6 +58,24 @@ struct wrap_monitor_t monitored;
 struct wrap_fail_t failures;
 struct wrap_log_t logs;
 
+void reinit_all_stats()
+{
+	memset(&stats, 0, sizeof(stats));
+}
+
+void reinit_all_monitored()
+{
+	memset(&monitored, 0, sizeof(monitored));
+}
+
+/**
+ * Readable file descriptors that contain the student's code outputs.
+ */
 int stdout_cpy, stderr_cpy;
 
+FILE *fstdout, *fstderr;
+
 sigjmp_buf segv_jmp;
+
+#endif // __CTESTER_MAIN_H__
+
diff --git a/student/CTester/read_write.c b/student/CTester/read_write.c
new file mode 100644
index 0000000..87d4503
--- /dev/null
+++ b/student/CTester/read_write.c
@@ -0,0 +1,409 @@
+/*
+ * Functions and structure for manipulating read and write system calls,
+ * as well as recv and send calls, in the presence of buffered data.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <time.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <errno.h>
+
+#include "read_write.h"
+
+int64_t MILLION = 1000*1000;
+#define BILLION (1000*1000*1000)
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+
+
+/**
+ * Auxiliary structures and functions
+ */
+
+void getnanotime(struct timespec *res)
+{
+    clock_gettime(CLOCK_REALTIME, res);
+}
+
+int64_t get_time_interval(const struct timespec *pasttime, const struct timespec *curtime)
+{
+    int64_t past = pasttime->tv_sec;
+    past *= BILLION;
+    past += pasttime->tv_nsec;
+    int64_t cur = curtime->tv_sec;
+    cur *= BILLION;
+    cur += curtime->tv_nsec;
+    int64_t interval = cur - past;
+    if (interval < 0) {
+        fprintf(stderr, "BUG: negative time interval: %lld %lld %lld", (long long)past, (long long)cur, (long long)interval); fflush(stderr);
+    }
+    return interval;
+}
+
+
+/**
+ * read-related
+ */
+
+// #define READ_MODE_BUFCHUK 1 // not used
+
+/**
+ * Precision for the 'interval' field.
+ * It contains the wait time for the current chunk, as measured from the previous call.
+ * It may be positive: in this case, it means the next data was not available
+ * at the end of the previous call, and it is the time the current call has
+ * to wait before accessing data. Minus the interval between the two calls.
+ * It may be negative: in this case, it represents the opposite of the amout
+ * of time the current chunk has been available.
+ * Thanks to this field, we can enable the chunks at more or less the right moment.
+ */
+struct read_item {
+    int fd; // the file descriptor this structure applies to
+    //int mode; // the type of data provider used; not used
+    const struct read_buffer_t *buf; // Provided read_buffer_t structure
+    unsigned int chunk_id; // Current chunk, or next chunk to be received
+    size_t bytes_read; // Number of bytes read inside the current chunk
+    struct timespec last_time; // Time of the end of the last call of read on this fd/socket
+    int64_t interval; // In real-time mode (READ_WRITE_REAL_INTERVAL), real wait interval for the current chunk (in nanoseconds).
+};
+
+struct read_fd_table_t {
+    size_t n;
+    struct read_item *items;
+} read_fd_table;
+
+struct read_item *read_get_entry(int fd)
+{
+    for (unsigned int i = 0; i < read_fd_table.n; i++) {
+        if (read_fd_table.items[i].fd == fd)
+            return &(read_fd_table.items[i]);
+    }
+    return NULL;
+}
+
+bool fd_is_read_buffered(int fd)
+{
+    return (read_get_entry(fd) != NULL);
+}
+
+void reinit_read_fd_table_item(int i)
+{
+    // We need to clean up _recv_fd_table.items[i]
+    read_fd_table.items[i].buf = NULL; // We're not responsible to free it.
+    read_fd_table.items[i].chunk_id = 0;
+    read_fd_table.items[i].interval = 0;
+    read_fd_table.items[i].last_time = (struct timespec) {
+        .tv_sec = 0,
+        .tv_nsec = 0
+    };
+}
+
+
+int read_remove_entry(int fd)
+{
+    bool found = false;
+    for (unsigned int i = 0; i < read_fd_table.n; i++) {
+        if (read_fd_table.items[i].fd == fd) {
+            found = true;
+            if (i < read_fd_table.n - 1) {
+                struct read_item *dest = &(read_fd_table.items[i]);
+                memmove(dest, dest + 1, (read_fd_table.n - i - 1) * sizeof(struct read_item));
+                memset(&(read_fd_table.items[read_fd_table.n-1]), 0, sizeof(struct read_item));
+                // This is not really a problem that we have a useless thing at the end
+            }
+            read_fd_table.n--;
+        }
+    }
+    if (read_fd_table.n == 0) {
+        free(read_fd_table.items);
+        read_fd_table.items = NULL;
+    }
+    return (found ? 1 : 0);
+}
+
+/**
+ * Returns a pointer to an entry in the table,
+ * where we can safely store our informations.
+ * May be a pre-existing chunk,
+ * in which case the fd's will match.
+ */
+struct read_item *read_get_new_entry(int fd)
+{
+    unsigned int i = 0;
+    for (i = 0; i < read_fd_table.n; i++) {
+        if (read_fd_table.items[i].fd == fd) {
+            // We should clean it before changing it
+            reinit_read_fd_table_item(i);
+            break;
+        }
+    }
+    if (i >= read_fd_table.n) {
+        // realloc
+        struct read_item *tmp = realloc(read_fd_table.items, (read_fd_table.n + 1) * sizeof(struct read_item));
+        if (tmp == NULL)
+            return NULL;
+        read_fd_table.items = tmp;
+        read_fd_table.n++;
+    }
+    // Now, we can insert at index i
+    return &(read_fd_table.items[i]);
+}
+
+size_t read_handle_buffer_no_rt(struct read_item *cur, void *buf, size_t len, int flags, int64_t call_interval)
+{
+    const struct read_bufchunk_t *curchunk = &(cur->buf->chunks[cur->chunk_id]);
+    if (cur->bytes_read == 0) {
+        // We may have to wait
+        int64_t sleeptime = 0;
+        if (cur->buf->mode == READ_WRITE_BEFORE_INTERVAL) {
+            sleeptime = MILLION * (curchunk->interval);
+        } else { // READ_WRITE_AFTER_INTERVAL
+            sleeptime = MILLION * (curchunk->interval) - call_interval;
+        }
+        if (sleeptime > 0) {
+            if ((flags & MSG_DONTWAIT) != 0) {
+                errno = EAGAIN;
+                return -1;
+            }
+            struct timespec tmp = (struct timespec) {
+                .tv_sec = sleeptime / BILLION,
+                .tv_nsec = sleeptime % BILLION
+            };
+            nanosleep(&tmp, NULL);
+            getnanotime(&(cur->last_time)); // We need to update
+        }
+    }
+    size_t bytes_left = curchunk->buflen - cur->bytes_read;
+    size_t transfered_bytes = MIN(len, bytes_left);
+    memmove(buf, (curchunk->buf + cur->bytes_read), transfered_bytes);
+    cur->bytes_read += transfered_bytes;
+    if (cur->bytes_read >= curchunk->buflen) {
+        cur->chunk_id++;
+        cur->bytes_read = 0;
+    }
+    return transfered_bytes;
+}
+
+size_t read_handle_buffer_rt(struct read_item *cur, void *buf, size_t len, int flags, int64_t call_interval)
+{
+    /*
+     * Assume the following:
+     * - cur->interval was the time to wait for the current chunk to become
+     *   active, at the end of the previous call.
+     * - cur->bytes_read is 0 only if we have to wait.
+     */
+    cur->interval -= call_interval;
+    /*
+     * Assume the following:
+     * - cur->interval is the remaining time to wait for the current chunk to become active.
+     * - cur->bytes_read is 0 only if we have to wait.
+     */
+    if (cur->interval > 0) {
+        if ((flags & MSG_DONTWAIT) != 0) {
+            // The call would block but the caller requested it shouldn't block
+            errno = EAGAIN;
+            return -1;
+        }
+        int64_t sleeptime = cur->interval;
+        struct timespec tmp = (struct timespec) {
+            .tv_sec = sleeptime / BILLION,
+            .tv_nsec = sleeptime % BILLION
+        };
+        nanosleep(&tmp, NULL);
+        cur->interval = 0;
+        getnanotime(&(cur->last_time));
+    }
+    /*
+     * Assume the following:
+     * - cur->interval is the negative of the time the current chunk has been available.
+     */
+    size_t total_bytes = 0;
+    for (unsigned int i = cur->chunk_id; i < cur->buf->nchunks; i++) {
+        if (len <= 0) {
+            break;
+        }
+        const struct read_bufchunk_t *curchunk = &(cur->buf->chunks[i]);
+        size_t bytes_left = curchunk->buflen - cur->bytes_read;
+        size_t transfered_bytes = MIN(len, bytes_left);
+        memmove((buf + total_bytes), (curchunk->buf + cur->bytes_read), transfered_bytes);
+        cur->bytes_read += transfered_bytes;
+        len -= transfered_bytes;
+        total_bytes += transfered_bytes;
+        if (cur->bytes_read >= curchunk->buflen) {
+            // Emptied chunk
+            cur->chunk_id++;
+            cur->bytes_read = 0;
+            if (cur->chunk_id < cur->buf->nchunks) {
+                // Update interval
+                cur->interval += MILLION * (cur->buf->chunks[cur->chunk_id].interval);
+                if (cur->interval > 0) {
+                    break; // Not available yet
+                }
+            }
+        }
+    }
+    return total_bytes;
+}
+
+ssize_t read_handle_buffer(int fd, void *buf, size_t len, int flags)
+{
+    // TODO add support for MSG_OOB, MSG_PEEK and MSG_WAITALL to flags
+    struct read_item *cur = read_get_entry(fd);
+    if (cur == NULL) {
+        errno = EINTR; // This is about the only case where this can happen
+        return -1;
+    }
+    struct timespec curtime;
+    getnanotime(&curtime);
+    int64_t call_interval = get_time_interval(&(cur->last_time), &curtime);
+    cur->last_time = curtime;
+    if (cur->chunk_id >= cur->buf->nchunks) {
+        // Nothing left to read; we can return immediately 0
+        // TODO remove this as a particular case
+        return 0;
+    }
+    size_t bytes_transfered = 0;
+    if (cur->buf->mode == READ_WRITE_BEFORE_INTERVAL || cur->buf->mode == READ_WRITE_AFTER_INTERVAL) {
+        bytes_transfered = read_handle_buffer_no_rt(cur, buf, len, flags, call_interval);
+    } else if (cur->buf->mode == READ_WRITE_REAL_INTERVAL) {
+        bytes_transfered = read_handle_buffer_rt(cur, buf, len, flags, call_interval);
+    } else {
+        return -1;
+    }
+    return bytes_transfered;
+}
+
+void reinit_read_fd_table()
+{
+    // As we're not responsible to clean up all the recv_buffer_t, we can just free everything up
+    free(read_fd_table.items);
+    read_fd_table.items = NULL;
+    read_fd_table.n = 0;
+}
+
+
+int set_read_buffer(int fd, const struct read_buffer_t *buf)
+{
+    if (buf == NULL) {
+        return read_remove_entry(fd);
+    }
+    if (buf->mode != READ_WRITE_REAL_INTERVAL &&
+        buf->mode != READ_WRITE_AFTER_INTERVAL &&
+        buf->mode != READ_WRITE_BEFORE_INTERVAL) {
+        return -2;
+    }
+    bool already_there = false;
+    if (fd_is_read_buffered(fd)) {
+        already_there = true;
+    }
+    struct read_item *tmp = read_get_new_entry(fd);
+    if (tmp == NULL) {
+        return -1;
+    }
+    tmp->fd = fd;
+    tmp->buf = buf;
+    tmp->chunk_id = 0;
+    tmp->bytes_read = 0;
+    getnanotime(&(tmp->last_time));
+    if (buf->mode == READ_WRITE_REAL_INTERVAL && buf->nchunks > 0) {
+        // The first wait interval should be that of the first chunk.
+        tmp->interval = MILLION * (buf->chunks[0].interval);
+    } else {
+        tmp->interval = 0;
+    }
+    return (already_there ? 1 : 0);
+}
+
+ssize_t get_bytes_read(int fd)
+{
+    //return -1;
+    struct read_item *cur = read_get_entry(fd);
+    if (cur == NULL)
+        return -1;
+    size_t bread = 0;
+    for (unsigned int i = 0; i < cur->chunk_id; i++) {
+        bread += cur->buf->chunks[i].buflen;
+    }
+    if (cur->chunk_id < cur->buf->nchunks) {
+        bread += cur->bytes_read;
+    }
+    return bread;
+}
+
+int get_current_chunk_id(int fd)
+{
+    return -1;
+    struct read_item *cur = read_get_entry(fd);
+    if (cur == NULL)
+        return -1;
+    return cur->chunk_id;
+}
+
+int create_partial_read_buffer(void *data, size_t n, off_t *offsets, int *intervals, struct read_buffer_t *buf)
+{
+    buf->nchunks = n;
+    buf->chunks = malloc(n * sizeof(struct read_bufchunk_t));
+    if (!(buf->chunks)) {
+        free(buf);
+        return -1;
+    }
+    off_t cum_offset = 0;
+    for (unsigned int i = 0; i < n; i++) {
+        buf->chunks[i] = (struct read_bufchunk_t) {
+            .buf = (data + cum_offset),
+            .buflen = offsets[i],
+            .interval = intervals[i]
+        };
+        cum_offset += offsets[i];
+    }
+    return 0;
+}
+
+struct read_buffer_t *create_read_buffer(void *data, size_t n, off_t *offsets, int *intervals, int mode)
+{
+    struct read_buffer_t *buf = malloc(sizeof(*buf));
+    if (!buf)
+        return NULL;
+    buf->mode = mode;
+    if (create_partial_read_buffer(data, n, offsets, intervals, buf)) {
+        free(buf);
+        return NULL;
+    }
+    return buf;
+}
+
+void free_partial_read_buffer(struct read_buffer_t *buf)
+{
+    for (unsigned int i = 0; i < buf->nchunks; i++) {
+        buf->chunks[i] = (struct read_bufchunk_t) {
+            .buf = NULL,
+            .buflen = 0,
+            .interval = 0
+        };
+    }
+    free(buf->chunks);
+    buf->chunks = NULL;
+    buf->nchunks = 0;
+}
+
+void free_read_buffer(struct read_buffer_t *buf)
+{
+    free_partial_read_buffer(buf);
+    buf->mode = 0;
+    free(buf);
+}
+
diff --git a/student/CTester/read_write.h b/student/CTester/read_write.h
new file mode 100644
index 0000000..823e369
--- /dev/null
+++ b/student/CTester/read_write.h
@@ -0,0 +1,226 @@
+/**
+ * @file read_write.h
+ * Functions and structure for manipulating read and write system calls,
+ * as well as recv and send calls, in the presence of buffered data.
+ */
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __CTESTER_READ_WRITE_H__
+#define __CTESTER_READ_WRITE_H__
+
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ * @class Read_Write
+ * Functions and structures for manipulating read and write system calls,s
+ * as well as recv and send calls, in the presence of buffered data.
+ *
+ * An example use of these functions is with the recv system call on a socket.
+ * In real-world situations, recv has a blocking and partial return
+ * behaviour: when called, it blocks waiting for data to arrive (in general
+ * through the network), and when the data has arrived, it returns all
+ * the data readily available, and doesn't wait until more data arrives.
+ *
+ * In order to simulate that, we can provide recv with the information that
+ * each read action should return up to a specified chunk of data, and should
+ * therefore fragment the data returned to the caller.
+ *
+ * As we can use recv, recvfrom, recvmsg and read on a socket, all 4 system
+ * calls need to be wrapped.
+ *
+ * Similarly, send can also partially send the provided data, if the underlying
+ * send buffer and network doesn't have enough space to process the request.
+ *
+ * This partial-return behaviour of recv only happens on SOCK_STREAM sockets,
+ * on which we generaly use the recv and send system calls (but we can still
+ * use read, recvfrom and recvmsg without paying attention to flags or remote
+ * address). On UDP (SOCK_DGRAM), this behaviour doesn't happen, in the sense
+ * that it will try to return the whole datagram and discard the rest, and
+ * the use of recvfrom (or recvmsg) is recommanded (recv is allowed but will
+ * ignore the address). On SOCK_STREAM, send is recommanded (for sendto,
+ * sendmsg, address should correspond to the connected address), and
+ * on SOCK_DGRAM, sendto (and sendmsg) is recommanded (send or write should be
+ * connected), and there is no valid partial send (a second send will create
+ * a new datagram).
+ *
+ * On non-socket files, recv, recvfrom and recvmsg cannot be used, only read
+ * is authorized. read may block if the file is a pipe or a fifo (these have
+ * limited capacity). read also has a partial-return behaviour on pipes
+ * and fifos.
+ *
+ * On non-socket files, send, sento and sendmsg cannot be used, only write is
+ * authorized. write may block if the underlying device has no space available
+ * at the moment (pipes and fifos), and may result in a partial-return.
+ *
+ * The functions listed here implement these blocking behaviour, on pipes
+ * (which are remembered internally as pipes) and on sockets (which is a
+ * subclass of pipes in some sense, with the addition of the recv and send
+ * system calls) (which are remembered internally as sockets).
+ */
+
+
+/*
+ * Enable globally the socket monitoring functionnalities. A value of true
+ * activates it, a value of false deactivates it.
+ * This means socket will add the returned fd to the list of sockets,
+ * and subsequent recv and send will check that it is indeed a socket.
+ * Additionnaly, read and write will also know that this is a pipe-like object.
+ */
+//int enable_socket_recv_send_monitoring(bool active);
+
+/*
+ * In addition to enable_socket_recv_send_monitoring, the bind, connect,
+ * listen, accept and shutdown calls check whether it is a socket.
+ */
+//int enable_socket_all_monitoring(bool active);
+
+/*
+ * Enable globally the pipe monitoring functionnalities.
+ * Currently it is not supported. Maybe in a future version...
+ */
+//int enable_pipe_monitoring(bool active);
+
+
+
+//int set_recv_source(int fd, int sourcefd);
+
+//int set_recv_buffer(int fd, void *buf, size_t buflen);
+
+//int set_recv_policy(int fd, struct recv_policy_t *policy);
+// Should define at some point the recv_policy_t structure.
+
+/**
+ * Structure representing a chunk of data, that is a fragment of the data
+ * that is returned as a single entity by read/recv.
+ * When simulating a partial-return read/recv, this is the fragments of data
+ * that the caller receives sequentially (if it asks for the full fragment).
+ * Fields:
+ * - interval: time interval (in milliseconds) to wait before the chunk can be
+ *   received. Should be no more than 1 thousand. Relative to the arrival
+ *   of the previous chunk, and thus relative.
+ * - buf : chunk of data to be read.
+ * - buflen: length of this buffer.
+ */
+struct read_bufchunk_t {
+    int interval;
+    const void *buf;
+    size_t buflen;
+};
+
+/**
+ * The following macros define the modes to interpret the interval value:
+ * - the first possibility (READ_WRITE_REAL_INTERVAL) tracks the time interval
+ *   in "real time", which means that the student may not see the actual
+ *   specified time interval if it waits long enough.
+ * - the second possibility (READ_WRITE_AFTER_INTERVAL) only enforce the time
+ *   interval between the end of a call that emptied a chunk and the actual
+ *   read of the following call, which will start a new chunk. If the student
+ *   waits enough, it may not see it.
+ * - the third possibility (READ_WRITE_BEFORE_INTERVAL) imposes an actual wait
+ *   each time the student calls recv and the chunk has not been read before
+ *   (if it has, then it won't wait, but it will read only one chunk).
+ *   The interval is enforced between the start of this call and the actual
+ *   read of this same call. The student cannot ignore it.
+ * Be careful to select the correct mode of operation,
+ * otherwise it won't work like you want it.
+ */
+#define READ_WRITE_REAL_INTERVAL 1 // Real-time interval: if the student waits a lot, he won't see the interval
+#define READ_WRITE_AFTER_INTERVAL 2 // At least interval µs after emptying the chunk
+#define READ_WRITE_BEFORE_INTERVAL 3 // At least interval µs before reading a new chunk
+
+/**
+ * Structure representing a group of fragments of data, as it would be received
+ * by subsequent read/recv of fragmented data. When simulating a partial-return
+ * read/recv, this is the full data to be read, split into different chunks.
+ */
+struct read_buffer_t {
+    int mode; // The mode of interpretation of interval
+    size_t nchunks; // Number of chunks
+    struct read_bufchunk_t *chunks; // Table of chunks
+};
+
+/**
+ * Sets the data to be retrieved from read/recv, for partial-return,
+ * when simulating fragmented arrival of data.
+ * @param fd   file descriptor.
+ * @param buf  the data to be received.
+ * @return
+ * -  0 if fd was not previously set to have a read_buffer_t
+ * -  1 if fd has been previously set to have a read_buffer_t
+ * - -1 if malloc error
+ * - -2 if argument error (typically buf->mode)
+ */
+int set_read_buffer(int fd, const struct read_buffer_t *buf);
+
+/**
+ * Is the file descriptor fd associated to some read buffer?
+ */
+bool fd_is_read_buffered(int fd);
+
+/**
+ * Returns the amount of bytes read from the previously provided buffer
+ * for this file descriptor, or -1 if the file descriptor is not associated
+ * with a read_buffer.
+ */
+ssize_t get_bytes_read(int fd);
+
+/**
+ * Returns the chunk id currently set up for reading of the previously provided
+ * read buffer for this file descriptor, of -1 if there is no read_buffer
+ * associated with this file descriptor.
+ */
+int get_current_chunk_id(int fd);
+
+/**
+ * Fills in buf with a read_buffer_t structure, from data (a continuous area
+ * of memory), the list of offsets and the list of intervals. Allocates all
+ * the structures needed.
+ * Returns 0 if success, -1 in case of error (memory).
+ */
+int create_partial_read_buffer(void *data, size_t n, off_t *offsets, int *intervals, struct read_buffer_t *buf);
+
+/**
+ * Creates a read_buffer_t structure from data (a continuous area of memory),
+ * the provided mode, the list of offsets and the list of intervals. Allocates
+ * all the structures needed.
+ * Returns the created buffer, or NULL in case of error.
+ */
+struct read_buffer_t *create_read_buffer(void *data, size_t n, off_t *offsets, int *intervals, int mode);
+
+/**
+ * Deallocates the provided read buffer. This doesn't free the actual data
+ * returned by successive calls of recv and read, doesn't free buf itself
+ * (so that a stack-allocated read_buffer_t can be passed on) and doesn't
+ * reset the mode of the read_buffer_t. In short, it only frees up buf->chunks.
+ * This is the inverse of create_partial_read_buffer.
+ */
+void free_partial_read_buffer(struct read_buffer_t *buf);
+
+/**
+ * Deallocates the provided read buffer. This doesn't free the actual data
+ * returned by successive calls of recv and read. Also frees buf itself,
+ * so no `free(buf)` is needed after this call.
+ */
+void free_read_buffer(struct read_buffer_t *buf);
+
+/**
+ * Removes all the association between fd's and read_buffer_t's that have been
+ * previously set. It doesn't free the structures, however.
+ */
+void reinit_read_fd_table();
+
+
+#endif // __CTESTER_READ_WRITE_H__
+
diff --git a/student/CTester/trap.c b/student/CTester/trap.c
index 2b36c07..9b416c3 100644
--- a/student/CTester/trap.c
+++ b/student/CTester/trap.c
@@ -1,3 +1,18 @@
+/*
+ * Functions for creating and destroying trapped buffers.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include <sys/mman.h>
 #include <unistd.h>
 #include <string.h>
@@ -6,19 +21,20 @@
 
 void *trap_buffer(size_t size, int type, int flags, void *data)
 {
-    int nb_pages = (size / getpagesize()) + 2;
-    void *ptr = mmap(NULL, getpagesize() * nb_pages, PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+    size_t pagesize = sysconf(_SC_PAGESIZE);
+    int nb_pages = (size / pagesize) + 2;
+    void *ptr = mmap(NULL, pagesize * nb_pages, PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
     if (ptr == MAP_FAILED) {
         return NULL;
     }
 
     void *buf_start;
     if (type == TRAP_LEFT) {
-        buf_start = ptr + getpagesize();
-        mprotect(ptr, getpagesize(), PROT_NONE);
+        buf_start = ptr + pagesize;
+        mprotect(ptr, pagesize, PROT_NONE);
     } else if (type == TRAP_RIGHT) {
-        buf_start = ptr + (nb_pages - 1) * getpagesize() - size;
-        mprotect(ptr + (nb_pages - 1)*getpagesize(), getpagesize(), PROT_NONE);
+        buf_start = ptr + (nb_pages - 1) * pagesize - size;
+        mprotect(ptr + (nb_pages - 1)*pagesize, pagesize, PROT_NONE);
     } else {
         return NULL;
     }
diff --git a/student/CTester/trap.h b/student/CTester/trap.h
index fa29af4..e4de9bf 100644
--- a/student/CTester/trap.h
+++ b/student/CTester/trap.h
@@ -1,8 +1,49 @@
+/**
+ * @file trap.h
+ * Functions for creating and destroying trapped buffers.
+ */
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __CTESTER_TRAP_H__
+#define __CTESTER_TRAP_H__
+
+/**
+ * Defines the type of the trapped buffer, i.e. which end of the buffer
+ * is trapped.
+ */
 enum {
-    TRAP_LEFT,
-    TRAP_RIGHT
+    TRAP_LEFT, ///< Defines that the left (lower address) page of the buffer is trapped
+    TRAP_RIGHT ///< Defines that the right (upper address) page of the buffer is trapped
 };
 
 
+/**
+ * Creates a trapped buffer, of specified size, of the specified type, with
+ * the specified data optionally pre-filled, and with the specified
+ * access rights flag (from mprotect) applied to the buffer. The trapped page
+ * has PROT_NONE permissions. Returns the start address of the useful
+ * part of the buffer (i.e., not the trapped page, if TRAP_LEFT).
+ */
 void *trap_buffer(size_t size, int type, int flags, void *data);
+
+/**
+ * Frees the trapped buffer referenced to by ptr. Note that for TRAP_LEFT,
+ * this is not the same pointer as the one returned by trap_buffer; rather,
+ * this is the address of the trapped page. Also, the size is not the size
+ * of the buffer itself, but of all the pages of the buffer+the trapped page.
+ */
 int free_trap(void *ptr, size_t size);
+
+#endif // __CTESTER_TRAP_H__
+
diff --git a/student/CTester/util_inet.c b/student/CTester/util_inet.c
new file mode 100644
index 0000000..99c7578
--- /dev/null
+++ b/student/CTester/util_inet.c
@@ -0,0 +1,47 @@
+/*
+ * Utility functions related to htons, ntohs, htonl, ntohl
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <arpa/inet.h>
+
+#include "util_inet.h"
+
+void htons_tab(uint16_t *src, uint16_t *dest, size_t len)
+{
+    for (unsigned i = 0; i < len; i++) {
+        dest[i] = htons(src[i]);
+    }
+}
+
+void ntohs_tab(uint16_t *src, uint16_t *dest, size_t len)
+{
+    for (unsigned i = 0; i < len; i++) {
+        dest[i] = ntohs(src[i]);
+    }
+}
+
+void htonl_tab(uint32_t *src, uint32_t *dest, size_t len)
+{
+    for (unsigned i = 0; i < len; i++) {
+        dest[i] = htonl(src[i]);
+    }
+}
+
+void ntohl_tab(uint32_t *src, uint32_t *dest, size_t len)
+{
+    for (unsigned i = 0; i < len; i++) {
+        dest[i] = ntohl(src[i]);
+    }
+}
+
diff --git a/student/CTester/util_inet.h b/student/CTester/util_inet.h
new file mode 100644
index 0000000..052a95d
--- /dev/null
+++ b/student/CTester/util_inet.h
@@ -0,0 +1,60 @@
+/**
+ * @file util_inet.h
+ * Utility functions related to htons, ntohs, htonl, ntohl
+ */
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __CTESTER_UTIL_INET_H__
+#define __CTESTER_UTIL_INET_H__
+
+#include <stddef.h>
+
+/**
+ * Converts each short integer of the src array from host byte order
+ * to network byte order, to the dest array.
+ * @param src   source array of short integer in host byte order
+ * @param dest  destination array of will-be short ints in network byte order
+ * @param len   length of each array
+ */
+void htons_tab(uint16_t *src, uint16_t *dest, size_t len);
+
+/**
+ * Converts each short integer of the src array from network byte order
+ * to host byte order, to the dest array.
+ * @param src   source array of short integer in network byte order
+ * @param dest  destination array of will-be short integers in host byte order
+ * @param len   length of each array
+ */
+void ntohs_tab(uint16_t *src, uint16_t *dest, size_t len);
+
+/**
+ * Converts each integer of the src array from host byte order
+ * to network byte order, to the dest array.
+ * @param src   source array of integer in host byte order
+ * @param dest  destination array of will-be integers in network byte order
+ * @param len   length of each array
+ */
+void htonl_tab(uint32_t *src, uint32_t *dest, size_t len);
+
+/**
+ * Converts each integer of the src array from network byte order
+ * to host byte order, to the dest array.
+ * @param src   source array of integer in network byte order
+ * @param dest  destination array of will-be integers in host byte order
+ * @param len   length of each array
+ */
+void ntohl_tab(uint32_t *src, uint32_t *dest, size_t len);
+
+#endif // __CTESTER_UTIL_INET_H__
+
diff --git a/student/CTester/util_sockets.c b/student/CTester/util_sockets.c
new file mode 100644
index 0000000..3e39b2d
--- /dev/null
+++ b/student/CTester/util_sockets.c
@@ -0,0 +1,737 @@
+/*
+ * Utility functions and structure for creating and manipulating sockets,
+ * for creating and launching test servers and clients.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <poll.h>
+#include <errno.h>
+
+#include "util_sockets.h"
+
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+
+const uint8_t _OK = 0;
+const uint8_t _TOO_MUCH = 1;
+const uint8_t _TOO_FEW = 2;
+const uint8_t _RECV_ERROR = 3;
+const uint8_t _NOTHING_RECV = 4;
+const uint8_t _SEND_ERROR = 8;
+const uint8_t _NOT_SAME_DATA = 16;
+const uint8_t _NOT_SAME_ADDR = 32;
+const uint8_t _EXIT_PROCESS = 64;
+const uint8_t _EXTEND_MSG = 128;
+
+int create_socket(const char *host, const char *serv, int domain, int type, int flags, int do_bind)
+{
+    errno = 0;
+    struct addrinfo hints;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV | flags;
+    hints.ai_family = domain;
+    hints.ai_socktype = type;
+    struct addrinfo *rep;
+    int r = getaddrinfo(host, serv, &hints, &rep);
+    if (r || !rep) {
+        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(r));
+        return -1;
+    }
+    int fd = socket(rep->ai_family, rep->ai_socktype, rep->ai_protocol);
+    if (fd == -1) {
+        perror("socket");
+        freeaddrinfo(rep);
+        return -1;
+    }
+    if (do_bind) {
+        int yes = 1;
+        if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes))) {
+            perror("setsockopt");
+        }
+        if (bind(fd, rep->ai_addr, rep->ai_addrlen)) {
+            perror("bind");
+            close(fd);
+            freeaddrinfo(rep);
+            return -1;
+        }
+    } else {
+        if (connect(fd, rep->ai_addr, rep->ai_addrlen)) {
+            perror("connect");
+            close(fd);
+            freeaddrinfo(rep);
+            return -1;
+        }
+    }
+    freeaddrinfo(rep);
+    return fd;
+}
+
+int create_tcp_server_socket(const char *serv, int domain, int type)
+{
+    int serverfd = create_socket(NULL, serv, domain, type, AI_PASSIVE, true);
+    if (listen(serverfd, 1)) {
+        perror("listen");
+        close(serverfd);
+        return -1;
+    }
+    return serverfd;
+}
+
+int create_tcp_client_socket(const char *host, const char *serv, int domain, int type)
+{
+    int clientfd = create_socket(host, serv, domain, type, 0, false);
+    return clientfd;
+}
+
+int create_udp_server_socket(const char *serv, int domain)
+{
+    int serverfd = create_socket(NULL, serv, domain, SOCK_DGRAM, AI_PASSIVE, true);
+    return serverfd;
+}
+
+int create_udp_client_socket(const char *host, const char *serv, int domain)
+{
+    int clientfd = create_socket(host, serv, domain, SOCK_DGRAM, 0, false);
+    return clientfd;
+}
+
+int connect_udp_server_to_client(int sfd, int cfd)
+{
+    // send from cfd to recvfrom sfd.
+    char dumb = 'A';
+    ssize_t s = send(cfd, &dumb, sizeof(dumb), 0);
+    if (s != sizeof(dumb)) {
+        perror("send");
+        return -1;
+    }
+    struct sockaddr_storage client_addr;
+    socklen_t client_addrlen = sizeof(client_addr);
+    ssize_t r = recvfrom(sfd, &dumb, sizeof(dumb), 0, (struct sockaddr*)&client_addr, &client_addrlen);
+    if (r != sizeof(dumb)) {
+        perror("recvfrom");
+        return -1;
+    }
+    if (connect(sfd, (struct sockaddr*)&client_addr, client_addrlen)) {
+        perror("connect");
+        return -1;
+    }
+    return 0;
+}
+
+#define PIPE_AND_FORK_BEGIN() \
+if (pipe(c2s)) { \
+    perror("pipe"); \
+    return -1; \
+} \
+if (pipe(s2c)) { \
+    perror("pipe"); \
+    close(c2s[0]); \
+    close(c2s[1]); \
+    return -1; \
+} \
+int pid = fork(); \
+if (pid == -1) { \
+    perror("fork"); \
+    close(c2s[0]); \
+    close(c2s[1]); \
+    close(s2c[0]); \
+    close(s2c[1]); \
+    return -1; \
+} else if (pid == 0) { \
+    close(c2s[1]); \
+    close(s2c[0]); \
+    /* server : end of macro, start of custom */
+
+#define PIPE_AND_FORK_MIDDLE() \
+    /* server : end of custom, start of macro */ \
+} else { \
+    close(c2s[0]); \
+    close(s2c[1]); \
+    /* client : end of macro, start of custom */
+
+#define PIPE_AND_FORK_END() \
+    /* client : end of custom */ \
+}
+
+/**
+ * Returns 0 if correct,
+ * -3 if syscall problem
+ * -2 if pipe_in got a problem,
+ * -1 if recv error
+ *  1 if pipe_in got a message
+ *  2 if too few data recv'd
+ *  3 if too much data recv'd
+ *  4 if different data
+ * Writes of errors left to calling function, except for 2, 3.
+ */
+int wait_recv_tcp(int sockfd, int pipe_in, int pipe_out, const struct cs_network_chunk *chunk)
+{
+    size_t required_bytes = chunk->data_length, recv_bytes = 0, total_bytes = required_bytes + 1;
+    ssize_t r = -1;
+    void *buf = malloc(total_bytes);
+    if (!buf) {
+        perror("malloc");
+        return -3;
+    }
+    nfds_t nfds = 2;
+    struct pollfd fds[2];
+    fds[0] = (struct pollfd) {
+        .fd = sockfd,
+        .events = POLLIN | POLLERR,
+        .revents = 0
+    };
+    fds[1] = (struct pollfd) {
+        .fd = pipe_in,
+        .events = POLLIN | POLLERR,
+        .revents = 0
+    };
+    do {
+        int p = poll(fds, nfds, -1);
+        if (p == -1) {
+            perror("poll");
+            free(buf);
+            return -3;
+        } // p != -1
+        if (fds[1].revents) {
+            // Got something on pipe
+            if (fds[1].revents & POLLIN) {
+                // Read; quit
+                free(buf);
+                return 1;
+            } else {
+                // Error: quit
+                free(buf);
+                return -2;
+            }
+        } // not fds[1], so fds[0]
+        if (fds[0].revents) {
+            // Got something on socket
+            if (fds[0].revents & POLLIN) {
+                r = recv(sockfd, (buf + recv_bytes), (total_bytes - recv_bytes), 0);
+                if (r == -1) {
+                    // Error condition on socket
+                    perror("recv");
+                    free(buf);
+                    return -1;
+                }
+                recv_bytes += r;
+            } else {
+                // Error condition on socket
+                free(buf);
+                return -1;
+            }
+        }
+        // r != -1 and no error
+    } while (recv_bytes <= required_bytes && r != 0);
+    if (recv_bytes < required_bytes) {
+        free(buf);
+        write(pipe_out, &_TOO_FEW, U8SZ);
+        write(pipe_out, &recv_bytes, sizeof(recv_bytes));
+        return 2;
+    }
+    if (recv_bytes > required_bytes) {
+        free(buf);
+        write(pipe_out, &_TOO_MUCH, U8SZ);
+        write(pipe_out, &recv_bytes, sizeof(recv_bytes));
+        return 3;
+    }
+    int c = memcmp(buf, chunk->data, chunk->data_length);
+    free(buf);
+    if (c) {
+        return 4;
+    }
+    return 0;
+}
+
+/**
+ * Returns
+ * -3 if syscall problem
+ * -2 if pipe_in got a problem
+ * -1 if send got a problem
+ *  0 if ok
+ *  1 if pipe_in got a message
+ * Writes of error left to calling function, except for -1.
+ */
+int wait_send_tcp(int sockfd, int pipe_in, int pipe_out, const struct cs_network_chunk *chunk)
+{
+    size_t required_bytes = chunk->data_length, sent_bytes = 0;
+    ssize_t s = -1;
+    nfds_t nfds = 2;
+    struct pollfd fds[2];
+    fds[0] = (struct pollfd) {
+        .fd = sockfd,
+        .events = POLLOUT | POLLERR,
+        .revents = 0
+    };
+    fds[1] = (struct pollfd) {
+        .fd = pipe_in,
+        .events = POLLIN | POLLERR,
+        .revents = 0
+    };
+    do {
+        int p = poll(fds, nfds, -1);
+        if (p == -1) {
+            perror("poll");
+            return -3;
+        }
+        if (fds[1].revents) {
+            if (fds[1].revents & POLLIN) {
+                return 1;
+            } else {
+                return -2;
+            }
+        }
+        if (fds[0].revents) {
+            if (fds[0].revents & POLLOUT) {
+                s = send(sockfd, (chunk->data + sent_bytes), (required_bytes - sent_bytes), 0);
+                if (s == -1) {
+                    perror("send");
+                    write(pipe_out, &_SEND_ERROR, U8SZ);
+                    return -1;
+                }
+                sent_bytes += s;
+            } else {
+                write(pipe_out, &_SEND_ERROR, U8SZ);
+                return -1;
+            }
+        }
+    } while (sent_bytes != required_bytes && s != -1);
+    if (sent_bytes != required_bytes) {
+        uint8_t err = _TOO_FEW | SEND_ERROR;
+        write(pipe_out, &err, U8SZ);
+        return -1;
+    }
+    return 0;
+}
+
+/**
+ * Returns 0 if correct,
+ * -3 if syscall problem
+ * -2 if pipe_in got a problem,
+ * -1 if recv error
+ *  1 if pipe_in got a message
+ *  2 if too few data recv'd
+ *  3 if too much data recv'd
+ *  4 if different data
+ *  5 if different address
+ * Writes of errors left to calling function, except for 2, 3, 4, 5.
+ */
+int wait_recv_udp(int sockfd, int pipe_in, int pipe_out, const struct cs_network_chunk *chunk, const struct sockaddr *addr, socklen_t addrlen)
+{
+    size_t required_bytes = chunk->data_length, total_bytes = required_bytes + 1, recv_bytes;
+    struct sockaddr_storage recv_addr;
+    socklen_t recv_addrlen = sizeof(addr);
+    void *buf = malloc(total_bytes);
+    if (!buf) {
+        perror("malloc");
+        return -3;
+    }
+    nfds_t nfds = 2;
+    struct pollfd fds[2];
+    fds[0] = (struct pollfd) {
+        .fd = sockfd,
+        .events = POLLIN | POLLERR,
+        .revents = 0
+    };
+    fds[1] = (struct pollfd) {
+        .fd = pipe_in,
+        .events = POLLIN | POLLERR,
+        .revents = 0
+    };
+    int p = poll(fds, nfds, -1);
+    if (p == -1) {
+        perror("poll");
+        free(buf);
+        return -3;
+    }
+    if (fds[1].revents) {
+        // pipe_in
+        if (fds[1].revents & POLLIN) {
+            // Read: quit with 1
+            free(buf);
+            return 1;
+        } else {
+            // Error: quit with error
+            free(buf);
+            return -2;
+        }
+    }
+    if (fds[0].revents) {
+        // sockfd
+        if (fds[0].revents & POLLIN) {
+            // read socket
+            ssize_t r = recvfrom(sockfd, buf, total_bytes, 0, (struct sockaddr*)&recv_addr, &recv_addrlen);
+            if (r == -1) {
+                perror("recvfrom");
+                free(buf);
+                return -1;
+            }
+            recv_bytes = r;
+        } else {
+            free(buf);
+            return -1;
+        }
+    }
+    if (recv_bytes < required_bytes) {
+        free(buf);
+        write(pipe_out, &_TOO_FEW, U8SZ);
+        write(pipe_out, &recv_bytes, sizeof(recv_bytes));
+        return 2;
+    }
+    if (recv_bytes > required_bytes) {
+        free(buf);
+        write(pipe_out, &_TOO_MUCH, U8SZ);
+        write(pipe_out, &recv_bytes, sizeof(recv_bytes));
+        return 3;
+    }
+    int c = memcmp(buf, chunk->data, chunk->data_length);
+    free(buf);
+    if (c) {
+        write(pipe_out, &_NOT_SAME_DATA, U8SZ);
+        return 4;
+    }
+    if (addr != NULL) {
+        c = memcmp(&addr, &recv_addr, MIN(recv_addrlen, addrlen));
+        if (c) {
+            write(pipe_out, &_NOT_SAME_ADDR, U8SZ);
+            write(pipe_out, &recv_addrlen, sizeof(recv_addrlen));
+            write(pipe_out, &recv_addr, recv_addrlen);
+            return 5;
+        }
+    }
+    return 0;
+}
+
+/**
+ * Returns
+ * -3 if syscall problem
+ * -2 if pipe_in got a problem
+ * -1 if send got a problem
+ *  0 if ok
+ *  1 if pipe_in got a message
+ * Writes of errors left to caller function, except for -1 (send).
+ */
+int wait_send_udp(int sockfd, int pipe_in, int pipe_out, const struct cs_network_chunk *chunk, const struct sockaddr *addr, socklen_t addrlen)
+{
+    size_t required_bytes = chunk->data_length, sent_bytes = 0;
+    nfds_t nfds = 2;
+    struct pollfd fds[2];
+    fds[0] = (struct pollfd) {
+        .fd = sockfd,
+        .events = POLLOUT | POLLERR,
+        .revents = 0
+    };
+    fds[1] = (struct pollfd) {
+        .fd = pipe_in,
+        .events = POLLIN | POLLERR,
+        .revents = 0
+    };
+    int p = poll(fds, nfds, -1);
+    if (p == -1) {
+        perror("poll");
+        return -3;
+    }
+    if (fds[1].revents) {
+        // pipe_in
+        if (fds[1].revents & POLLIN) {
+            return 1;
+        } else {
+            return -2;
+        }
+    }
+    if (fds[0].revents) {
+        // sockfd
+        if (fds[0].revents & POLLOUT) {
+            ssize_t s = sendto(sockfd, chunk->data, required_bytes, 0, addr, addrlen);
+            if (s == -1) {
+                perror("sendto");
+                write(pipe_out, &_SEND_ERROR, U8SZ);
+                return -1;
+            }
+            sent_bytes = s;
+        } else {
+            write(pipe_out, &_SEND_ERROR, U8SZ);
+            return -1;
+        }
+    }
+    if (sent_bytes != required_bytes) {
+        uint8_t err = _TOO_FEW | _SEND_ERROR;
+        write(pipe_out, &err, U8SZ);
+        return -1;
+    }
+    return 0;
+}
+
+/**
+ * Return 3 if process was asked to stop, 2 if error, 0 on success.
+ */
+int handle_tcp_transaction(int sockfd, const struct cs_network_transaction *transaction, int pipe_in, int pipe_out)
+{
+    for (unsigned j = 0; j < transaction->nchunks; j++) {
+        struct cs_network_chunk *curchunk = &(transaction->chunks[j]);
+        if (curchunk->type == RECV_CHUNK) {
+            // recv
+            int r = wait_recv_tcp(sockfd, pipe_in, pipe_out, curchunk);
+            if (r < -1) {
+                fprintf(stderr, "Server error\n");
+                return 2;
+            }
+            switch (r) {
+                case -1:
+                    // recv error
+                    write(pipe_out, &_RECV_ERROR, U8SZ);
+                    write(pipe_out, &errno, sizeof(errno));
+                    continue;
+                case 1:
+                    // Stop the server
+                    return 3;
+                case 2:
+                    // Not enough bytes before connection was closed
+                    continue;
+                case 3:
+                    // Sent too much data
+                    continue;
+                case 4:
+                    // Different data
+                    write(pipe_out, &_NOT_SAME_DATA, U8SZ);
+                    //write(pipe_out, &(res->expected_request_length), sizeof(res->expected_request_length));
+                    // So that the reader can skip the data without knowing its length in advance
+                    //write(pipe_out, buf, res->expected_request_length);
+                    continue;
+            }
+        } else if (curchunk->type == SEND_CHUNK) {
+            // send
+            int s = wait_send_tcp(sockfd, pipe_in, pipe_out, curchunk);
+            if (s < -1) {
+                fprintf(stderr, "Server error\n");
+                return 2;
+            }
+            if (s == -1) {
+                // Send error
+                continue;
+            }
+            if (s == 1) {
+                return 3;
+            }
+        } // end if type
+    } // end for chunks in transaction
+    write(pipe_out, &_OK, U8SZ);
+    return 0;
+}
+
+int handle_udp_transaction(int sockfd, const struct cs_network_transaction *transaction, int pipe_in, int pipe_out)
+{
+    for (unsigned int j = 0; j < transaction->nchunks; j++) {
+        struct cs_network_chunk *curchunk = &(transaction->chunks[j]);
+        if (curchunk->type == RECV_CHUNK) {
+            // recvfrom
+            int r = wait_recv_udp(sockfd, pipe_in, pipe_out, curchunk, transaction->addr, transaction->addrlen);
+            if (r < -1) {
+                fprintf(stderr, "Server error\n");
+                return 2;
+            }
+            switch (r) {
+                case -1:
+                    //recv error
+                    write(pipe_out, &_RECV_ERROR, U8SZ);
+                    write(pipe_out, &errno, sizeof(errno));
+                    continue;
+                case 1:
+                    // pipe_in in
+                    return 3;
+                // Else: handled by wait_recv_udp
+                case 2: // too few
+                    continue;
+                case 3: // too much
+                    continue;
+                case 4: // data
+                    continue;
+                case 5: // addr
+                    continue;
+            }
+            // TODO complete
+        } else if (curchunk->type == SEND_CHUNK) {
+            // sendto
+            int r = wait_send_udp(sockfd, pipe_in, pipe_out, curchunk, transaction->addr, transaction->addrlen);
+            if (r < -1) {
+                fprintf(stderr, "Server error\n");
+                return 2;
+            }
+            switch (r) {
+                case -1: // send error
+                    continue;
+                case 1: // pipe_in in
+                    return 3;
+            }
+        } // end if type
+    } // end for chunks in transaction
+    write(pipe_out, &_OK, U8SZ);
+    return 0;
+}
+
+int launch_test_tcp_server(struct cs_network_transactions *transactions, const char *serv, int domain, int *server_in, int *server_out, int *spid)
+{
+    int c2s[2], s2c[2];
+    PIPE_AND_FORK_BEGIN();
+    // c2s[0] and s2c[1]
+    int sfd = create_tcp_server_socket(serv, domain, SOCK_STREAM);
+    if (sfd == -1) {
+        write(s2c[1], &_EXIT_PROCESS, U8SZ);
+        exit(1);
+    }
+    for (unsigned i = 0; i < transactions->ntransactions; i++) {
+        struct cs_network_transaction *curtrans = &(transactions->transactions[i]);
+        // First, accept the connection
+        struct sockaddr_storage client_addr;
+        socklen_t client_addrlen = sizeof(client_addr);
+        int cfd = accept(sfd, (struct sockaddr*)&client_addr, &client_addrlen);
+        if (cfd == -1) {
+            perror("accept");
+            write(s2c[1], &_EXIT_PROCESS, U8SZ);
+            exit(1);
+        }
+        int h = handle_tcp_transaction(cfd, curtrans, c2s[0], s2c[1]);
+        switch (h) {
+            case 0:
+                break;
+            case 2:
+                write(s2c[1], &_EXIT_PROCESS, U8SZ);
+                exit(2);
+            case 3:
+                write(s2c[1], &_EXIT_PROCESS, U8SZ);
+                exit(3);
+        }
+    } // end for transaction in transactions
+    exit(0);
+    PIPE_AND_FORK_MIDDLE();
+    // s2c[0] and c2s[1]
+    *spid = pid;
+    *server_in = c2s[1];
+    *server_out = s2c[0];
+    return 0;
+    PIPE_AND_FORK_END();
+}
+
+int launch_test_tcp_client(struct cs_network_transactions *transactions, const char *host, const char *serv, int domain, int *client_in, int *client_out, int *cpid)
+{
+    int c2s[2], s2c[2];
+    PIPE_AND_FORK_BEGIN();
+    // c2s[0] and s2c[1]
+    int cfd = create_tcp_client_socket(host, serv, domain, SOCK_STREAM);
+    if (cfd == -1) {
+        write(s2c[1], &_EXIT_PROCESS, U8SZ);
+        exit(1);
+    }
+    uint8_t buf_in[1];
+    for (unsigned i = 0; i < transactions->ntransactions; i++) {
+        struct cs_network_transaction *curtrans = &(transactions->transactions[i]);
+        // First, wait until the server is up
+        ssize_t rr = read(c2s[0], buf_in, sizeof(buf_in));
+        if (rr == -1) {
+            perror("read");
+            write(s2c[1], &_EXIT_PROCESS, U8SZ);
+            exit(2);
+        }
+        int h = handle_tcp_transaction(cfd, curtrans, c2s[0], s2c[1]);
+        switch (h) {
+            case 0:
+                break;
+            case 2:
+                write(s2c[1], &_EXIT_PROCESS, U8SZ);
+                exit(2);
+            case 3:
+                write(s2c[1], &_EXIT_PROCESS, U8SZ);
+                exit(3);
+        }
+    } // end for transaction in transactions
+    exit(0);
+    PIPE_AND_FORK_MIDDLE();
+    // s2c[0] and c2s[1]
+    *cpid = pid;
+    *client_in = c2s[1];
+    *client_out = s2c[0];
+    return 0;
+    PIPE_AND_FORK_END();
+}
+
+int launch_test_udp_server(struct cs_network_transactions *transactions, const char *serv, int domain, int *server_in, int *server_out, int *spid)
+{
+    int c2s[2], s2c[2];
+    PIPE_AND_FORK_BEGIN();
+    // c2s[0] and s2c[1]
+    int sfd = create_udp_server_socket(serv, domain);
+    if (sfd == -1) {
+        write(s2c[1], &_EXIT_PROCESS, U8SZ);
+        exit(1);
+    }
+    for (unsigned i = 0; i < transactions->ntransactions; i++) {
+        struct cs_network_transaction *curtrans = &(transactions->transactions[i]);
+        int h = handle_udp_transaction(sfd, curtrans, c2s[0], s2c[1]);
+        switch (h) {
+            case 0:
+                break;
+            case 2:
+                write(s2c[1], &_EXIT_PROCESS, U8SZ);
+                exit(2);
+            case 3:
+                write(s2c[1], &_EXIT_PROCESS, U8SZ);
+                exit(3);
+        }
+    }
+    exit(0);
+    PIPE_AND_FORK_MIDDLE();
+    *spid = pid;
+    *server_in = c2s[1];
+    *server_out = s2c[0];
+    return 0;
+    PIPE_AND_FORK_END();
+}
+
+int launch_test_udp_client(struct cs_network_transactions *transactions, const char *host, const char *serv, int domain, int *client_in, int *client_out, int *cpid)
+{
+    int c2s[2], s2c[2];
+    PIPE_AND_FORK_BEGIN();
+    int cfd = create_udp_client_socket(host, serv, domain);
+    if (cfd == -1) {
+        write(s2c[1], &_EXIT_PROCESS, U8SZ);
+        exit(1);
+    }
+    for (unsigned i = 0; i < transactions->ntransactions; i++) {
+        struct cs_network_transaction *curtrans = &(transactions->transactions[i]);
+        int h = handle_udp_transaction(cfd, curtrans, c2s[0], s2c[1]);
+        switch (h) {
+            case 0:
+                break;
+            case 2:
+                write(s2c[1], &_EXIT_PROCESS, U8SZ);
+                exit(2);
+            case 3:
+                write(s2c[1], &_EXIT_PROCESS, U8SZ);
+                exit(3);
+        }
+    }
+    exit(0);
+    PIPE_AND_FORK_MIDDLE();
+    *cpid = pid;
+    *client_in = c2s[1];
+    *client_out = s2c[0];
+    return 0;
+    PIPE_AND_FORK_END();
+}
+
diff --git a/student/CTester/util_sockets.h b/student/CTester/util_sockets.h
new file mode 100644
index 0000000..2f3707f
--- /dev/null
+++ b/student/CTester/util_sockets.h
@@ -0,0 +1,187 @@
+/**
+ * @file util_sockets.h
+ * Utility functions and structure for creating and manipulating sockets,
+ * for creating and launching test servers and clients.
+ */
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __CTESTER_UTIL_SOCKETS_H__
+#define __CTESTER_UTIL_SOCKETS_H__
+
+#include <stdint.h>
+
+/**
+ * Constants used when reporting the output of the mock server or client.
+ * Currenly, they may be combined with any of them;
+ * maybe we should exclude some combination.
+ */
+// Self conflicting constants
+#define OK 0
+#define TOO_MUCH 1 // And the amount should follow
+#define TOO_FEW 2 // And the amount should follow
+#define RECV_ERROR 3 // Followed by value of errno.
+#define NOTHING_RECV 4
+// Left : 6-15
+// Or-ing constants
+#define SEND_ERROR 8 // To indicate the real type of error
+#define NOT_SAME_DATA 16 // Idealy, the recv'd tab should follow, preceded by its length, but not yet implemented
+#define NOT_SAME_ADDR 32 // The recv'd address should follow, preceded by its length (socklen_t)
+#define EXIT_PROCESS 64 // The child process exits: beware of SIGPIPE!
+#define EXTEND_MSG 128 // Next octet gives the status
+
+#define U8SZ (sizeof(uint8_t))
+#define U16SZ (sizeof(uint16_t))
+
+/**
+ * Creates a socket with the specified domain, type, a nought protocol,
+ * and which is either bound to the specified host name (which should be NULL)
+ * and service name (if do_bind is true and flags has AI_PASSIVE) or which is
+ * connected to the specified host name and service name (if do_bind is false).
+ * The call to getaddrinfo has flags AI_NUMERICHOST and AI_NUMERICSERV
+ * set, in order to disable DNS; additionnal flags are then passed with it.
+ * If do_bind, it is important to note that the socket will NOT listen
+ * for incoming connections: it is up to the caller to activate it.
+ */
+int create_socket(const char *host, const char *serv, int domain, int type, int flags, int do_bind);
+
+/**
+ * Creates a socket with the specified domain (AF_INET or AF_INET6),
+ * type (either SOCK_STREAM or SOCK_SEQPACKET), a nought protocol,
+ * and which is listening for incoming connections on port specified in serv.
+ * This calls create_socket, and thus requires serv to be numeric.
+ */
+int create_tcp_server_socket(const char *serv, int domain, int type);
+
+/**
+ * Creates a socket with the specified domain (AF_INET or AF_INET6),
+ * type (either SOCK_STREAM or SOCK_SEQPACKET), a nought protocol,
+ * and connected to the specified address and port (host and serv).
+ * This calls create_socket, and thus requires host and serv to be numeric.
+ */
+int create_tcp_client_socket(const char *host, const char *serv, int domain, int type);
+
+/**
+ * Creates a UDP socket with the specified domain (AF_INET or AF_INET6),
+ * a nought protocol, and which accepts UDP packets on port specified in serv.
+ * This calls create_socket, and thus requires serv to be numeric.
+ */
+int create_udp_server_socket(const char *serv, int domain);
+
+/**
+ * Creates a UDP socket with the specified domain (AF_INET or AF_INET6), a zero
+ * protocol, and connected to the specified address and port (host and serv).
+ * This calls create_socket, and thus requires host and serv to be numeric.
+ */
+int create_udp_client_socket(const char *host, const char *serv, int domain);
+
+/**
+ * Connects the provided sfd UDP server socket to the address of the provided
+ * cfd client socket, such that calls to send on sfd will correctly send
+ * to the client and will be receivable from cfd. cfd should be "connected"
+ * to the server (i.e., its default address should be that of the server).
+ * Returns 0 in case of success, or -1 if there was an error.
+ */
+int connect_udp_server_to_client(int sfd, int cfd);
+
+#define RECV_CHUNK 1
+#define SEND_CHUNK 2
+
+/**
+ * A chunk of data to be recv or send by the server/client.
+ * type can be
+ * - RECV_CHUNK, in which case the server/client will try to receive it
+ *   and will compare the received bytes with the provided data
+ *   (no byte order conversion are done!)
+ * - SEND_CHUNK, in which case the server/client will send to the remote end
+ *   the data, and will report any transmission error.
+ * Warning, the chunks should have the network byte order, as the server/client
+ * will not try to reverse the bytes.
+ */
+struct cs_network_chunk {
+    void *data;
+    size_t data_length;
+    int type;
+};
+
+/**
+ * A transaction, which is a list of chunks exchanged between the server/client
+ * and the remote end.
+ * A transaction is successful if all RECV_CHUNK chunks have been received
+ * correctly, and if the server/client hasn't been asked to quit.
+ */
+struct cs_network_transaction {
+    struct cs_network_chunk *chunks;
+    size_t nchunks;
+    struct sockaddr *addr;
+    socklen_t addrlen;
+};
+
+/**
+ * A list of transactions to be tested one after another, using one instance
+ * of the server/client.
+ */
+struct cs_network_transactions {
+    struct cs_network_transaction *transactions;
+    size_t ntransactions;
+};
+
+/**
+ * Launches a TCP-listening and accepting server, on port specified by serv,
+ * in a separate process. In order to communicate with the caller,
+ * server_in is filled with the writing end of a pipe transfering toward
+ * the server (for example, stop condition), server_out is filled with
+ * the reading end of a pipe written by the server with the results of
+ * the requested transactions, and spid is filled with the process pid,
+ * so that the caller can wait on it.
+ * Returns 0 on successful launch of the server, 1 otherwise.
+ * The server exits with code 3 if it receives something on server_in,
+ * with code 2 if there was an error, and with 1 if it couldn't create the socket.
+ */
+int launch_test_tcp_server(struct cs_network_transactions *transactions, const char *serv, int domain, int *server_in, int *server_out, int *spid);
+
+/**
+ * Launches a TCP client, connecting and sending to host host on port serv,
+ * in a separate process. To communicate with the caller, client_in is filled
+ * with the writing end of a pipe transfering toward the client (for example,
+ * stop condition), client_out is filled with the reading end of a pipe written
+ * by the client with the results of the requested transactions, and cpid
+ * is filled with the process pid, so that the caller can wait on it.
+ * Returns 0 on successful launch of the client, 1 otherwise.
+ */
+int launch_test_tcp_client(struct cs_network_transactions *transactions, const char *host, const char *serv, int domain, int *client_in, int *client_out, int *cpid);
+
+/**
+ * Launches a UDP server, accepting messages on port specified by serv,
+ * in a separate process. To communicate with the caller, server_in is filled
+ * with the writing end of a pipe transfering toward the server (for example,
+ * stop condition), server_out is filled with the reading end of a pipe
+ * written by the server with the results of the requested transactions,
+ * and spid is filled with the process pid, so that the caller can wait on it.
+ * Returns 0 on successful launch of the server, 1 otherwise.
+ */
+int launch_test_udp_server(struct cs_network_transactions *transactions, const char *serv, int domain, int *server_in, int *server_out, int *spid);
+
+/**
+ * Launches a UDP client, sending messages to host host on port serv,
+ * in a separate process. To communicate with the caller, client_in is filled
+ * with the writing end of a pipe transfering toward the client (for example,
+ * stop condition), client_out is filled with the reading end of a pipe written
+ * by the client with the results of the requested transactions, and cpid
+ * is filled with the process pid, so that the caller can wait on it.
+ * Returns 0 on successful launch of the server, 1 otherwise.
+ */
+int launch_test_udp_client(struct cs_network_transactions *transactions, const char *host, const char *serv, int domain, int *client_in, int *client_out, int *cpid);
+
+#endif // __CTESTER_UTIL_SOCKETS_H__
+
diff --git a/student/CTester/wrap.h b/student/CTester/wrap.h
index e62430a..5bad9e9 100644
--- a/student/CTester/wrap.h
+++ b/student/CTester/wrap.h
@@ -1,3 +1,24 @@
+/**
+ * @file wrap.h
+ * Definition of all the wrapper structures: monitoring, failures,
+ * statistics.
+ */
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __WRAP_H_
+#define __WRAP_H_
+
 #include <stdbool.h>
 #include <stdint.h>
 #include <stddef.h>
@@ -9,6 +30,9 @@
 #include "wrap_file.h"
 #include "wrap_malloc.h"
 #include "wrap_mutex.h"
+#include "wrap_network_dns.h"
+#include "wrap_network_socket.h"
+#include "wrap_network_inet.h"
 #include "wrap_sleep.h"
 
 // Basic structures for system call wrapper
@@ -37,8 +61,45 @@ struct wrap_monitor_t {
   bool pthread_mutex_init;
   bool pthread_mutex_destroy;
   bool sleep;
+
+  bool getaddrinfo;
+  bool getnameinfo;
+  bool freeaddrinfo;
+  bool gai_strerror;
+
+  bool accept;
+  bool bind;
+  bool connect;
+  bool listen;
+  bool poll;
+  bool recv;
+  bool recvfrom;
+  bool recvmsg;
+  bool select;
+  bool send;
+  bool sendto;
+  bool sendmsg;
+  bool shutdown;
+  bool socket;
+
+  bool htons;
+  bool ntohs;
+  bool htonl;
+  bool ntohl;
 };
 
+#define MONITOR_ALL_RECV(m, v) do { \
+  m.recv = m.recvfrom = m.recvmsg = v; \
+} while (0);
+
+#define MONITOR_ALL_SEND(m, v) do { \
+  m.send = m.sendto = m.sendmsg = v; \
+} while (0);
+
+#define MONITOR_ALL_BYTEORDER(m, v) do { \
+  m.ntohs = m.htons = m.ntohl = m.htonl = v; \
+} while (0);
+
 #define MAX_LOG 1000
 
 // log for specific system calls
@@ -136,6 +197,76 @@ struct wrap_fail_t {
   uint32_t sleep;
   unsigned int sleep_ret;
 
+  uint32_t getaddrinfo;
+  int getaddrinfo_ret;
+  int getaddrinfo_errno;
+
+  uint32_t getnameinfo;
+  int getnameinfo_ret;
+  int getnameinfo_errno;
+
+  // freeaddrinfo - this call cannot fail, unless res is not a valid pointer.
+
+  // gai_strerror - this call cannot fail;
+  // if its parameter is an unkown error code, it just returns "Unknown error code"
+
+  uint32_t accept;
+  int accept_ret;
+  int accept_errno;
+
+  uint32_t bind;
+  int bind_ret;
+  int bind_errno;
+
+  uint32_t connect;
+  int connect_ret;
+  int connect_errno;
+
+  uint32_t listen;
+  int listen_ret;
+  int listen_errno;
+
+  uint32_t poll;
+  int poll_ret;
+  int poll_errno;
+
+  uint32_t recv;
+  int recv_ret;
+  int recv_errno;
+
+  uint32_t recvfrom;
+  int recvfrom_ret;
+  int recvfrom_errno;
+
+  uint32_t recvmsg;
+  int recvmsg_ret;
+  int recvmsg_errno;
+
+  uint32_t select;
+  int select_ret;
+  int select_errno;
+
+  uint32_t send;
+  int send_ret;
+  int send_errno;
+
+  uint32_t sendto;
+  int sendto_ret;
+  int sendto_errno;
+
+  uint32_t sendmsg;
+  int sendmsg_ret;
+  int sendmsg_errno;
+
+  uint32_t shutdown;
+  int shutdown_ret;
+  int shutdown_errno;
+
+  uint32_t socket;
+  int socket_ret;
+  int socket_errno;
+
+  // byte-order functions (htonl...) cannot fail
 } ;
 
 
@@ -160,4 +291,33 @@ struct wrap_stats_t {
   struct stats_pthread_mutex_unlock_t pthread_mutex_init;
   struct stats_pthread_mutex_unlock_t pthread_mutex_destroy;
   struct stats_sleep_t sleep;
+
+  struct stats_getaddrinfo_t getaddrinfo;
+  struct stats_getnameinfo_t getnameinfo;
+  struct stats_freeaddrinfo_t freeaddrinfo;
+  struct stats_gai_strerror_t gai_strerror;
+
+  struct stats_accept_t accept;
+  struct stats_bind_t bind;
+  struct stats_connect_t connect;
+  struct stats_listen_t listen;
+  struct stats_poll_t poll;
+  struct stats_recv_t recv;
+  struct stats_recvfrom_t recvfrom;
+  struct stats_recvmsg_t recvmsg;
+  struct stats_recv_all_t recv_all;
+  struct stats_select_t select;
+  struct stats_send_t send;
+  struct stats_sendto_t sendto;
+  struct stats_sendmsg_t sendmsg;
+  struct stats_send_all_t send_all;
+  struct stats_shutdown_t shutdown;
+  struct stats_socket_t socket;
+
+  struct stats_htons_t htons;
+  struct stats_ntohs_t ntohs;
+  struct stats_htonl_t htonl;
+  struct stats_ntohl_t ntohl;
 };
+
+#endif // __WRAP_H_
diff --git a/student/CTester/wrap_file.c b/student/CTester/wrap_file.c
index c65bfb2..7efb462 100644
--- a/student/CTester/wrap_file.c
+++ b/student/CTester/wrap_file.c
@@ -1,11 +1,26 @@
-// wrapper for the file operations, open, read, write
+/**
+ * Wrapper for open, creat, read, write, close, stats, fstat, lseek.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
+#include <string.h>
 
 #include "wrap.h"
+#include "read_write.h"
 
 int __real_open(const char *pathname, int flags, mode_t mode);
 int __real_creat(const char *pathname, mode_t mode);
@@ -23,18 +38,31 @@ extern bool wrap_monitoring;
 extern struct wrap_stats_t stats;
 extern struct wrap_monitor_t monitored;
 extern struct wrap_fail_t failures;
-extern struct wrap_log_t logs;
+extern struct wrap_log_t logs; // Unused for now...
+
+
+/**
+ * Auxiliary functions and structures for implementing partial-returns in read/write.
+ */
+extern ssize_t read_handle_buffer(int fd, void *buf, size_t len, int flags);
+
+extern struct read_fd_table_t read_fd_table;
+
+
+/**
+ * Wrap functions.
+ */
 
 int __wrap_open(char *pathname, int flags, mode_t mode) {
 
   if(!wrap_monitoring || !monitored.open) {
-    return __real_open(pathname,flags,mode); 
+    return __real_open(pathname,flags,mode);
   }
   stats.open.called++;
   stats.open.last_params.pathname=pathname;
   stats.open.last_params.flags=flags;
   stats.open.last_params.mode=mode;
-  
+
   if (FAIL(failures.open)) {
     failures.open=NEXT(failures.open);
     errno=failures.open_errno;
@@ -53,12 +81,12 @@ int __wrap_creat(char *pathname, mode_t mode) {
 
 
   if(!wrap_monitoring || !monitored.creat) {
-    return __real_creat(pathname,mode); 
+    return __real_creat(pathname,mode);
   }
   stats.creat.called++;
   stats.creat.last_params.pathname=pathname;
   stats.creat.last_params.mode=mode;
-  
+
   if (FAIL(failures.creat)) {
     failures.creat=NEXT(failures.creat);
     errno=failures.creat_errno;
@@ -76,11 +104,11 @@ int __wrap_creat(char *pathname, mode_t mode) {
 int __wrap_close(int fd){
 
   if(!wrap_monitoring || !monitored.close) {
-    return __real_close(fd); 
+    return __real_close(fd);
   }
   stats.close.called++;
   stats.close.last_params.fd=fd;
-  
+
   if (FAIL(failures.close)) {
     failures.close=NEXT(failures.close);
     errno=failures.close_errno;
@@ -98,13 +126,13 @@ int __wrap_close(int fd){
 ssize_t __wrap_read(int fd, void *buf, size_t count){
 
   if(!wrap_monitoring || !monitored.read) {
-    return __real_read(fd,buf,count); 
+    return __real_read(fd,buf,count);
   }
   stats.read.called++;
   stats.read.last_params.fd=fd;
   stats.read.last_params.buf=buf;
   stats.read.last_params.count=count;
-  
+
   if (FAIL(failures.read)) {
     failures.read=NEXT(failures.read);
     errno=failures.read_errno;
@@ -113,7 +141,12 @@ ssize_t __wrap_read(int fd, void *buf, size_t count){
   }
   failures.read=NEXT(failures.read);
   // did not fail
-  int ret=__real_read(fd,buf,count);
+  int ret = 0;
+  if (fd_is_read_buffered(fd)) {
+    ret = read_handle_buffer(fd, buf, count, 0);
+  } else {
+    ret = __real_read(fd, buf, count);
+  }
   stats.read.last_return=ret;
   return ret;
 
@@ -123,13 +156,13 @@ ssize_t __wrap_read(int fd, void *buf, size_t count){
 ssize_t __wrap_write(int fd, void *buf, size_t count){
 
   if(!wrap_monitoring || !monitored.write) {
-    return __real_write(fd,buf,count); 
+    return __real_write(fd,buf,count);
   }
   stats.write.called++;
   stats.write.last_params.fd=fd;
   stats.write.last_params.buf=buf;
   stats.write.last_params.count=count;
-  
+
   if (FAIL(failures.write)) {
     failures.write=NEXT(failures.write);
     errno=failures.write_errno;
@@ -145,14 +178,14 @@ ssize_t __wrap_write(int fd, void *buf, size_t count){
 }
 
 int __wrap_stat(char *path, struct stat *buf) {
-  
+
   if(!wrap_monitoring || !monitored.stat) {
-return __real_stat(path,buf); 
+    return __real_stat(path,buf);
   }
   stats.stat.called++;
   stats.stat.last_params.path=path;
   stats.stat.last_params.buf=buf;
-  
+
   if (FAIL(failures.stat)) {
     failures.stat=NEXT(failures.stat);
     errno=failures.stat_errno;
@@ -162,19 +195,21 @@ return __real_stat(path,buf);
   failures.stat=NEXT(failures.stat);
   // did not fail
   int ret=__real_stat(path,buf);
-  stats.stat.returned_stat.st_dev=buf->st_dev;
-  stats.stat.returned_stat.st_ino=buf->st_ino;
-  stats.stat.returned_stat.st_mode=buf->st_mode;
-  stats.stat.returned_stat.st_nlink=buf->st_nlink;
-  stats.stat.returned_stat.st_uid=buf->st_uid;
-  stats.stat.returned_stat.st_gid=buf->st_gid;
-  stats.stat.returned_stat.st_rdev=buf->st_rdev;
-  stats.stat.returned_stat.st_size=buf->st_size;
-  stats.stat.returned_stat.st_blksize=buf->st_blksize;
-  stats.stat.returned_stat.st_blocks=buf->st_blocks;
-  stats.stat.returned_stat.st_atime=buf->st_atime;
-  stats.stat.returned_stat.st_mtime=buf->st_mtime;
-  stats.stat.returned_stat.st_ctime=buf->st_ctime;
+  if (buf) {
+    stats.stat.returned_stat.st_dev = buf->st_dev;
+    stats.stat.returned_stat.st_ino = buf->st_ino;
+    stats.stat.returned_stat.st_mode = buf->st_mode;
+    stats.stat.returned_stat.st_nlink = buf->st_nlink;
+    stats.stat.returned_stat.st_uid = buf->st_uid;
+    stats.stat.returned_stat.st_gid = buf->st_gid;
+    stats.stat.returned_stat.st_rdev = buf->st_rdev;
+    stats.stat.returned_stat.st_size = buf->st_size;
+    stats.stat.returned_stat.st_blksize = buf->st_blksize;
+    stats.stat.returned_stat.st_blocks = buf->st_blocks;
+    stats.stat.returned_stat.st_atime = buf->st_atime;
+    stats.stat.returned_stat.st_mtime = buf->st_mtime;
+    stats.stat.returned_stat.st_ctime = buf->st_ctime;
+  }
   stats.stat.last_return=ret;
   return ret;
 
@@ -188,7 +223,7 @@ int __wrap_fstat(int fd, struct stat *buf) {
   stats.fstat.called++;
   stats.fstat.last_params.fd=fd;
   stats.fstat.last_params.buf=buf;
-  
+
   if (FAIL(failures.fstat)) {
     failures.fstat=NEXT(failures.fstat);
     errno=failures.fstat_errno;
@@ -197,19 +232,21 @@ int __wrap_fstat(int fd, struct stat *buf) {
   failures.fstat=NEXT(failures.fstat);
   // did not fail
   int ret=__real_fstat(fd,buf);
-  stats.fstat.returned_stat.st_dev=buf->st_dev;
-  stats.fstat.returned_stat.st_ino=buf->st_ino;
-  stats.fstat.returned_stat.st_mode=buf->st_mode;
-  stats.fstat.returned_stat.st_nlink=buf->st_nlink;
-  stats.fstat.returned_stat.st_uid=buf->st_uid;
-  stats.fstat.returned_stat.st_gid=buf->st_gid;
-  stats.fstat.returned_stat.st_rdev=buf->st_rdev;
-  stats.fstat.returned_stat.st_size=buf->st_size;
-  stats.fstat.returned_stat.st_blksize=buf->st_blksize;
-  stats.fstat.returned_stat.st_blocks=buf->st_blocks;
-  stats.fstat.returned_stat.st_atime=buf->st_atime;
-  stats.fstat.returned_stat.st_mtime=buf->st_mtime;
-  stats.fstat.returned_stat.st_ctime=buf->st_ctime;
+  if (buf) {
+    stats.fstat.returned_stat.st_dev = buf->st_dev;
+    stats.fstat.returned_stat.st_ino = buf->st_ino;
+    stats.fstat.returned_stat.st_mode = buf->st_mode;
+    stats.fstat.returned_stat.st_nlink = buf->st_nlink;
+    stats.fstat.returned_stat.st_uid = buf->st_uid;
+    stats.fstat.returned_stat.st_gid = buf->st_gid;
+    stats.fstat.returned_stat.st_rdev = buf->st_rdev;
+    stats.fstat.returned_stat.st_size = buf->st_size;
+    stats.fstat.returned_stat.st_blksize = buf->st_blksize;
+    stats.fstat.returned_stat.st_blocks = buf->st_blocks;
+    stats.fstat.returned_stat.st_atime = buf->st_atime;
+    stats.fstat.returned_stat.st_mtime = buf->st_mtime;
+    stats.fstat.returned_stat.st_ctime = buf->st_ctime;
+  }
 
   stats.fstat.last_return=ret;
   return ret;
@@ -217,7 +254,7 @@ int __wrap_fstat(int fd, struct stat *buf) {
 }
 
 off_t __wrap_lseek(int fd, off_t offset, int whence) {
-  
+
   if(!wrap_monitoring || !monitored.lseek) {
     return __real_lseek(fd,offset,whence);
   }
@@ -237,3 +274,16 @@ off_t __wrap_lseek(int fd, off_t offset, int whence) {
   stats.lseek.last_return=ret;
   return ret;
 }
+
+void reinit_file_stats()
+{
+  memset(&(stats.open), 0, sizeof(stats.open));
+  memset(&(stats.creat), 0, sizeof(stats.creat));
+  memset(&(stats.close), 0, sizeof(stats.close));
+  memset(&(stats.read), 0, sizeof(stats.read));
+  memset(&(stats.write), 0, sizeof(stats.write));
+  memset(&(stats.stat), 0, sizeof(stats.stat));
+  memset(&(stats.fstat), 0, sizeof(stats.fstat));
+  memset(&(stats.lseek), 0, sizeof(stats.lseek));
+}
+
diff --git a/student/CTester/wrap_file.h b/student/CTester/wrap_file.h
index 7cae21f..992236a 100644
--- a/student/CTester/wrap_file.h
+++ b/student/CTester/wrap_file.h
@@ -1,8 +1,29 @@
+/**
+ * @file wrap_file.h
+ * Wrapper for open, creat, read, write, close, stats, fstat, lseek.
+ */
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __WRAP_FILE_H_
+#define __WRAP_FILE_H_
+
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <fcntl.h>
 
+// TODO fcntl
 // basic structure to record the parameters of the last open call
 
 
@@ -29,9 +50,9 @@ struct params_creat_t {
 // basic statistics for the utilisation of the creat system call
 
 struct stats_creat_t {
-  int called;  // number of times the open system call has been issued
+  int called;  // number of times the creat system call has been issued
   struct params_creat_t last_params; // parameters for the last call issued
-  int last_return;   // return value of the last open call issued
+  int last_return;   // return value of the last creat call issued
 };
 
 
@@ -42,15 +63,15 @@ struct params_close_t {
 // basic statistics for the utilisation of the close system call
 
 struct stats_close_t {
-  int called;  // number of times the open system call has been issued
+  int called;  // number of times the close system call has been issued
   struct params_close_t last_params; // parameters for the last call issued
-  int last_return;   // return value of the last open call issued
+  int last_return;   // return value of the last close call issued
 };
 
 struct params_read_t {
   int fd;
   void *buf;
-  ssize_t count;
+  size_t count;
 }; 
 
 // basic statistics for the utilisation of the read system call
@@ -58,13 +79,13 @@ struct params_read_t {
 struct stats_read_t {
   int called;  // number of times the read system call has been issued
   struct params_read_t last_params; // parameters for the last call issued
-  int last_return;   // return value of the last read call issued
+  ssize_t last_return;   // return value of the last read call issued
 };
 
 struct params_write_t {
   int fd;
   void *buf;
-  ssize_t count;
+  size_t count;
 }; 
 
 // basic statistics for the utilisation of the write system call
@@ -72,7 +93,7 @@ struct params_write_t {
 struct stats_write_t {
   int called;  // number of times the write system call has been issued
   struct params_read_t last_params; // parameters for the last call issued
-  int last_return;   // return value of the last read call issued
+  ssize_t last_return;   // return value of the last write call issued
 };
 
 struct params_stat_t {
@@ -83,9 +104,9 @@ struct params_stat_t {
 // basic statistics for the utilisation of the stat system call
 
 struct stats_stat_t {
-  int called;  // number of times the write system call has been issued
+  int called;  // number of times the stat system call has been issued
   struct params_stat_t last_params; // parameters for the last call issued
-  int last_return;   // return value of the last read call issued
+  int last_return;   // return value of the last stat call issued
   struct stat returned_stat; // last returned stat structure
 };
 
@@ -98,9 +119,9 @@ struct params_fstat_t {
 // basic statistics for the utilisation of the fstat system call
 
 struct stats_fstat_t {
-  int called;  // number of times the write system call has been issued
+  int called;  // number of times the fstat system call has been issued
   struct params_fstat_t last_params; // parameters for the last call issued
-  int last_return;   // return value of the last read call issued
+  int last_return;   // return value of the last fstat call issued
   struct stat returned_stat; // last returned stat structure
 };
 
@@ -111,10 +132,14 @@ struct params_lseek_t {
   int whence;
 }; 
 
-// basic statistics for the utilisation of the fstat system call
+// basic statistics for the utilisation of the lseek system call
 
 struct stats_lseek_t {
   int called;  // number of times the lseek system call has been issued
   struct params_lseek_t last_params; // parameters for the last call issued
   int last_return;   // return value of the last lseek call issued
 };
+
+void reinit_file_stats();
+
+#endif // __WRAP_FILE_H_
diff --git a/student/CTester/wrap_getpid.c b/student/CTester/wrap_getpid.c
index ff2e525..7c19e0f 100644
--- a/student/CTester/wrap_getpid.c
+++ b/student/CTester/wrap_getpid.c
@@ -1,3 +1,17 @@
+/*
+ * Wrapper for getpid.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
 #include <sys/types.h>
 #include <unistd.h>
 #include <stdio.h>
diff --git a/student/CTester/wrap_getpid.h b/student/CTester/wrap_getpid.h
index 2c1905c..3ba9203 100644
--- a/student/CTester/wrap_getpid.h
+++ b/student/CTester/wrap_getpid.h
@@ -1,16 +1,53 @@
+/**
+ * @file wrap_getpid.h
+ * Wrapper for getpid.
+ */
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __WRAP_GETPID_H_
+#define __WRAP_GETPID_H_
+
+#include <sys/types.h>
+#include <unistd.h>
+
 // never remove statistics from this structure, they could be
 // used by existing exercices. You might add some additional information
 // if it can help to validate some exercices
-#include <sys/types.h>
-#include <unistd.h>
 
+/**
+ * Statistics structure for the getpid system call
+ */
 struct stats_getpid_t {
-  int called;           // number of times the system call has been called
-  pid_t last_return;    // last return value for getpid
+  int called;           ///< number of times the system call has been called
+  pid_t last_return;    ///< last return value for getpid
 
 };
 
+/**
+ * Initializes the structures needed for the wrapper of the getpid system call
+ */
 void init_getpid();
+
+/**
+ * Frees up any structure that was needed for the wrapper
+ * of the getpid system call
+ */
 void clean_getpid();
+
+/**
+ * Resets the statistics associated with the getpid system call
+ */
 void resetstats_getpid();
 
+#endif // __WRAP_GETPID_H_
+
diff --git a/student/CTester/wrap_malloc.c b/student/CTester/wrap_malloc.c
index eb345d1..ce3f9e2 100644
--- a/student/CTester/wrap_malloc.c
+++ b/student/CTester/wrap_malloc.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Wrapper for malloc, free and calloc
  *
  * This program is free software: you can redistribute it and/or modify
@@ -13,7 +13,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -80,7 +79,7 @@ void * __wrap_malloc(size_t size) {
     failures.malloc=NEXT(failures.malloc);
     return failures.malloc_ret;
   }
-  stats.memory.used+=size;
+  stats.memory.used+=size; // In theory, we shouldn't update it if the call fails... But anyway.
   failures.malloc=NEXT(failures.malloc);    
   void *ptr=__real_malloc(size);
   stats.malloc.last_return=ptr;
diff --git a/student/CTester/wrap_malloc.h b/student/CTester/wrap_malloc.h
index dcc7a8c..f00d142 100644
--- a/student/CTester/wrap_malloc.h
+++ b/student/CTester/wrap_malloc.h
@@ -1,6 +1,8 @@
-/* 
+/**
+ * @file wrap_malloc.h
  * Wrapper for malloc, free and calloc
- *
+ */
+/*
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
@@ -13,6 +15,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifndef __WRAP_MALLOC_H_
+#define __WRAP_MALLOC_H_
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -83,7 +87,7 @@ struct params_realloc_t {
 // basic statistics for the utilisation of the realloc call
 
 struct stats_realloc_t {
-  int called;  // number of times the malloc call has been issued
+  int called;  // number of times the realloc call has been issued
   struct params_realloc_t last_params; // parameters for the last call issued
   void  *last_return;   // return value of the last realloc call issued
 };
@@ -94,7 +98,9 @@ struct stats_realloc_t {
 //void malloc_log_init(struct malloc_t *l);
 void malloc_log(void *ptr, size_t size);
 
-// true if memory was allocated by malloc, false otherwise
+// true if memory was allocated by malloc/realloc etc, false otherwise
 int malloced(void *addr);
 // total amount of memory allocated by malloc
-int  malloc_allocated();
\ No newline at end of file
+int  malloc_allocated();
+
+#endif // __WRAP_MALLOC_H_
diff --git a/student/CTester/wrap_mutex.c b/student/CTester/wrap_mutex.c
index 7b19c17..63b7c49 100644
--- a/student/CTester/wrap_mutex.c
+++ b/student/CTester/wrap_mutex.c
@@ -1,3 +1,17 @@
+/*
+ * Wrapper for the POSIX thread mutex functions.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
 #include <sys/types.h>
 #include <unistd.h>
 #include <stdio.h>
@@ -7,12 +21,12 @@
 
 //int pthread_mutex_lock(pthread_mutex_t *mutex);
 //int pthread_mutex_trylock(pthread_mutex_t *mutex);
-//int pthread_mutex_unlock(pthread_mutex_t *mutex); 
+//int pthread_mutex_unlock(pthread_mutex_t *mutex);
 
 
 int __real_pthread_mutex_lock(pthread_mutex_t *mutex);
 int __real_pthread_mutex_trylock(pthread_mutex_t *mutex);
-int __real_pthread_mutex_unlock(pthread_mutex_t *mutex); 
+int __real_pthread_mutex_unlock(pthread_mutex_t *mutex);
 int __real_pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
 int __real_pthread_mutex_destroy(pthread_mutex_t *mutex);
 
@@ -22,27 +36,79 @@ extern struct wrap_monitor_t monitored;
 extern struct wrap_fail_t failures;
 
 
-void init_mutex() {
+void init_pthread_mutex_init() {
   // nothing to do
 }
-
-void clean_mutex() {
+void init_pthread_mutex_lock() {
+  // nothing to do
+}
+void init_pthread_mutex_trylock() {
+  // nothing to do
+}
+void init_pthread_mutex_unlock() {
+  // nothing to do
+}
+void init_pthread_mutex_destroy() {
   // nothing to do
 }
+void init_mutex() {
+  init_pthread_mutex_init();
+  init_pthread_mutex_lock();
+  init_pthread_mutex_trylock();
+  init_pthread_mutex_unlock();
+  init_pthread_mutex_destroy();
+}
 
-void resetstats_mutex() {
+void clean_pthread_mutex_init() {
+  // nothing to do
+}
+void clean_pthread_mutex_lock() {
+  // nothing to do
+}
+void clean_pthread_mutex_trylock() {
+  // nothing to do
+}
+void clean_pthread_mutex_unlock() {
+  // nothing to do
+}
+void clean_pthread_mutex_destroy() {
+  // nothing to do
+}
+void clean_mutex() {
+  clean_pthread_mutex_init();
+  clean_pthread_mutex_lock();
+  clean_pthread_mutex_trylock();
+  clean_pthread_mutex_unlock();
+  clean_pthread_mutex_destroy();
+}
 
+void resetstats_pthread_mutex_init() {
+  stats.pthread_mutex_init.called=0;
+  stats.pthread_mutex_init.last_return=0;
+}
+void resetstats_pthread_mutex_lock() {
   stats.pthread_mutex_lock.called=0;
   stats.pthread_mutex_lock.last_return=0;
+}
+void resetstats_pthread_mutex_trylock() {
   stats.pthread_mutex_trylock.called=0;
   stats.pthread_mutex_trylock.last_return=0;
+}
+void resetstats_pthread_mutex_unlock() {
   stats.pthread_mutex_unlock.called=0;
   stats.pthread_mutex_unlock.last_return=0;
-  stats.pthread_mutex_init.called=0;
-  stats.pthread_mutex_init.last_return=0;
+}
+void resetstats_pthread_mutex_destroy() {
   stats.pthread_mutex_destroy.called=0;
   stats.pthread_mutex_destroy.last_return=0;
 }
+void resetstats_mutex() {
+  resetstats_pthread_mutex_init();
+  resetstats_pthread_mutex_lock();
+  resetstats_pthread_mutex_trylock();
+  resetstats_pthread_mutex_unlock();
+  resetstats_pthread_mutex_destroy();
+}
 
 int __wrap_pthread_mutex_destroy(pthread_mutex_t *mutex) {
   if(!wrap_monitoring || !monitored.pthread_mutex_destroy) {
diff --git a/student/CTester/wrap_mutex.h b/student/CTester/wrap_mutex.h
index 9a1e5eb..6ab6048 100644
--- a/student/CTester/wrap_mutex.h
+++ b/student/CTester/wrap_mutex.h
@@ -1,13 +1,33 @@
-// never remove statistics from this structure, they could be
-// used by existing exercices. You might add some additional information
-// if it can help to validate some exercices
+/**
+ * @file wrap_mutex.h
+ * Wrapper for the POSIX thread mutex functions.
+ */
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __WRAP_MUTEX_H_
+#define __WRAP_MUTEX_H_
+
 #include <sys/types.h>
 #include <unistd.h>
 #include <pthread.h>
 
+// never remove statistics from this structure, they could be
+// used by existing exercices. You might add some additional information
+// if it can help to validate some exercices
+
 struct stats_pthread_mutex_lock_t {
   int called;           // number of times the system call has been called
-  pid_t last_return;    // last return value 
+  pid_t last_return;    // last return value
   pthread_mutex_t *last_arg; // last mutex passed as argument
 
 };
@@ -18,7 +38,7 @@ void resetstats_pthread_mutex_lock();
 
 struct stats_pthread_mutex_trylock_t {
   int called;           // number of times the system call has been called
-  pid_t last_return;    // last return value 
+  pid_t last_return;    // last return value
   pthread_mutex_t *last_arg; // last mutex passed as argument
 };
 
@@ -29,7 +49,7 @@ void resetstats_pthread_mutex_trylock();
 
 struct stats_pthread_mutex_unlock_t {
   int called;           // number of times the system call has been called
-  pid_t last_return;    // last return value 
+  pid_t last_return;    // last return value
   pthread_mutex_t *last_arg; // last mutex passed as argument
 
 };
@@ -40,7 +60,7 @@ void resetstats_pthread_mutex_unlock();
 
 struct stats_pthread_mutex_init_t {
   int called;           // number of times the system call has been called
-  pid_t last_return;    // last return value 
+  pid_t last_return;    // last return value
   pthread_mutex_t *last_arg; // last mutex passed as argument
 
 };
@@ -51,7 +71,7 @@ void resetstats_pthread_mutex_init();
 
 struct stats_pthread_mutex_destroy_t {
   int called;           // number of times the system call has been called
-  pid_t last_return;    // last return value 
+  pid_t last_return;    // last return value
   pthread_mutex_t *last_arg; // last mutex passed as argument
 
 };
@@ -60,3 +80,9 @@ void init_pthread_mutex_destroy();
 void clean_pthread_mutex_destroy();
 void resetstats_pthread_mutex_destroy();
 
+void init_mutex();
+void clean_mutex();
+void resetstats_mutex();
+
+#endif // __WRAP_MUTEX_H_
+
diff --git a/student/CTester/wrap_network_dns.c b/student/CTester/wrap_network_dns.c
new file mode 100644
index 0000000..378320a
--- /dev/null
+++ b/student/CTester/wrap_network_dns.c
@@ -0,0 +1,373 @@
+/*
+ * Wrapper for getaddrinfo, freeaddrinfo, gai_strerror and getnameinfo
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <string.h>
+
+#include "wrap.h"
+
+int __real_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);
+int __real_getnameinfo(const struct sockaddr *addr, socklen_t addrlen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags);
+void __real_freeaddrinfo(struct addrinfo *res);
+const char *__real_gai_strerror(int errcode);
+
+extern bool wrap_monitoring;
+extern struct wrap_stats_t stats;
+extern struct wrap_monitor_t monitored;
+extern struct wrap_fail_t failures;
+
+bool check_freeaddrinfo = false;
+getaddrinfo_method_t  getaddrinfo_method  = NULL;
+freeaddrinfo_method_t freeaddrinfo_method = NULL;
+getnameinfo_method_t  getnameinfo_method  = NULL;
+gai_strerror_method_t gai_strerror_method = NULL;
+freeaddrinfo_badarg_report_t freeaddrinfo_badarg_reporter = NULL;
+
+
+void add_result(struct addrinfo *res)
+{
+    struct addrinfo_node_t *new_node = malloc(sizeof(*new_node));
+    if (new_node == NULL) return;
+    new_node->addr_list = res;
+    new_node->next = stats.getaddrinfo.addrinfo_list;
+    stats.getaddrinfo.addrinfo_list = new_node;
+}
+
+/**
+ * Returns 0 if res was successfully removed of the list,
+ * -1 if res was not present in the list,
+ *  -2 if there was some other errors.
+ */
+int remove_result(struct addrinfo *res)
+{
+    if (stats.getaddrinfo.addrinfo_list != NULL) {
+        struct addrinfo_node_t *runner = stats.getaddrinfo.addrinfo_list;
+        if (runner->addr_list == res) {
+            stats.getaddrinfo.addrinfo_list = runner->next;
+            free(runner);
+            // runner->addr_list will be freed by freeaddrinfo
+            return 0;
+        }
+        for (; runner->next != NULL; runner = runner->next) {
+            if (runner->next->addr_list == res) {
+                struct addrinfo_node_t *old = runner->next;
+                runner->next = runner->next->next;
+                free(old);
+                // old->addr_list will be freed by freeaddrinfo when we return
+                return 0;
+            }
+        }
+        return -1;
+    } else {
+        return -1;
+    }
+}
+
+
+int __wrap_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res)
+{
+    if (! (wrap_monitoring && monitored.getaddrinfo)) {
+        return __real_getaddrinfo(node, service, hints, res);
+    }
+    stats.getaddrinfo.called++;
+    stats.getaddrinfo.last_params = (struct params_getaddrinfo_t) {
+        .node = node,
+        .service = service,
+        .hints = hints,
+        .res = res
+    };
+    if (FAIL(failures.getaddrinfo)) {
+        failures.getaddrinfo = NEXT(failures.getaddrinfo);
+        errno = failures.getaddrinfo_errno;
+        stats.getaddrinfo.last_return = failures.getaddrinfo_ret;
+        return failures.getaddrinfo_ret;
+    }
+    failures.getaddrinfo = NEXT(failures.getaddrinfo);
+    int ret;
+    if (getaddrinfo_method == NULL) {
+        ret = __real_getaddrinfo(node, service, hints, res);
+    } else {
+        ret = (*getaddrinfo_method)(node, service, hints, res);
+    }
+    stats.getaddrinfo.last_return = ret;
+    /*
+     * At this point, we may assume that *res is a valid memory location,
+     * as the program will segfault if it is not.
+     */
+    if (check_freeaddrinfo) {
+        add_result(*res);
+    }
+    return ret;
+}
+
+int __wrap_getnameinfo(const struct sockaddr *addr, socklen_t addrlen,
+        char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags)
+{
+    if (! (wrap_monitoring && monitored.getnameinfo)) {
+        return __real_getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags);
+    }
+    stats.getnameinfo.called++;
+    stats.getnameinfo.last_params = (struct params_getnameinfo_t) {
+        .addr = addr,
+        .addrlen = addrlen,
+        .host = host,
+        .hostlen = hostlen,
+        .serv = serv,
+        .servlen = servlen,
+        .flags = flags
+    };
+    if (FAIL(failures.getnameinfo)) {
+        failures.getnameinfo = NEXT(failures.getnameinfo);
+        errno = failures.getnameinfo_errno;
+        stats.getnameinfo.last_return = failures.getnameinfo_ret;
+        return failures.getnameinfo_ret;
+    }
+    failures.getnameinfo = NEXT(failures.getnameinfo);
+    getnameinfo_method_t met = &__real_getnameinfo;
+    if (getnameinfo_method != NULL) {
+        met = getnameinfo_method;
+    }
+    int ret = (*met)(addr, addrlen, host, hostlen, serv, servlen, flags);
+    stats.getnameinfo.last_return = ret;
+    return ret;
+}
+
+/**
+ * The student should call freeaddrinfo on all the result structures that have been initialized by getaddrinfo; failing to do so leads to memory leak.
+ * If the parameter check_freeaddrinfo is true, then this function will check if res was actually returned by getaddrinfo, and is not either an invalid pointer, or a non-first addrinfo in one of the lists.
+ */
+void __wrap_freeaddrinfo(struct addrinfo *res)
+{
+    if (! (wrap_monitoring && monitored.freeaddrinfo)) {
+        __real_freeaddrinfo(res);
+        return;
+    }
+    stats.freeaddrinfo.called++;
+    stats.freeaddrinfo.last_param = res;
+    if (check_freeaddrinfo) {
+        if (remove_result(res) == 0) {
+            // Okay, it is valid
+            stats.freeaddrinfo.status = 0;
+        } else {
+            // Not okay: it is invalid (e.g. this is the second item of the list instead of the first).
+            // TODO report the error, as it is still invalid
+            stats.freeaddrinfo.status = 1;
+            if (freeaddrinfo_badarg_reporter != NULL) {
+                (*freeaddrinfo_badarg_reporter)();
+            }
+        }
+    } else {
+        stats.freeaddrinfo.status = 0; // will not check
+    }
+    if (freeaddrinfo_method == NULL) {
+        __real_freeaddrinfo(res);
+    } else {
+        freeaddrinfo_method(res);
+    }
+}
+
+const char * __wrap_gai_strerror(int ecode)
+{
+    if (! (wrap_monitoring && monitored.gai_strerror)) {
+        return __real_gai_strerror(ecode);
+    }
+    stats.gai_strerror.called++;
+    stats.gai_strerror.last_params = ecode;
+    gai_strerror_method_t met = (gai_strerror_method == NULL ? &__real_gai_strerror : gai_strerror_method);
+    const char *ret = (*met)(ecode);
+    stats.gai_strerror.last_return = ret;
+    return ret;
+}
+
+
+void reinit_stats_network_dns()
+{
+    // First, clean up the list of getaddrinfo returned lists
+    struct addrinfo_node_t *runner = stats.getaddrinfo.addrinfo_list;
+    while (runner != NULL) {
+        struct addrinfo_node_t *old = runner;
+        runner = runner->next;
+        /* Ideally, we should also free old->addr_list by using freeaddrinfo,
+           but as it is possible that the list should be deallocated
+           by a different function than the current freeaddrinfo,
+           it is safer to not attempt it and leave it as-is.
+           TODO: add the dedicated freeaddrinfo as a field of the nodes ;-)
+        */
+        free(old);
+    }
+    memset(&(stats.getaddrinfo), 0, sizeof(stats.getaddrinfo));
+    memset(&(stats.freeaddrinfo), 0, sizeof(stats.freeaddrinfo));
+    memset(&(stats.getnameinfo), 0, sizeof(stats.getnameinfo));
+    memset(&(stats.gai_strerror), 0, sizeof(stats.gai_strerror));
+}
+
+void set_check_freeaddrinfo(bool check)
+{
+    check_freeaddrinfo = check;
+}
+
+
+void set_getaddrinfo_method(getaddrinfo_method_t method)
+{
+    getaddrinfo_method = method;
+}
+
+void set_gai_methods(getaddrinfo_method_t gai_method, freeaddrinfo_method_t fai_method)
+{
+    getaddrinfo_method  = gai_method;
+    freeaddrinfo_method = fai_method;
+}
+
+void set_getnameinfo_method(getnameinfo_method_t method)
+{
+    getnameinfo_method = method;
+}
+
+void set_gai_strerror_method(gai_strerror_method_t method)
+{
+    gai_strerror_method = method;
+}
+
+
+void set_freeaddrinfo_badarg_report(freeaddrinfo_badarg_report_t reporter)
+{
+    freeaddrinfo_badarg_reporter = reporter;
+}
+
+void reset_gai_fai_gstr_gni_methods()
+{
+    set_gai_methods(NULL, NULL);
+    set_getnameinfo_method(NULL);
+    set_gai_strerror_method(NULL);
+}
+
+int simple_getaddrinfo(const char *node, const char *serv, const struct addrinfo *hints, struct addrinfo **res)
+{
+    if (node == NULL && hints != NULL && hints && (hints->ai_flags & AI_CANONNAME) != 0) {
+        return EAI_BADFLAGS;
+    }
+    if (node == NULL && serv == NULL) {
+        return EAI_NONAME;
+    }
+    uint8_t buf[sizeof(struct in6_addr)];
+    memset(buf, 0, sizeof(buf));
+    int family = hints ? hints->ai_family : AF_UNSPEC;
+    if (node == NULL) {
+        if (hints && (hints->ai_flags & AI_PASSIVE)) {
+            if (family == AF_INET) {
+                node = "0.0.0.0";
+            } else {
+                node = "::";
+            }
+        } else {
+            if (family == AF_INET) {
+                node = "127.0.0.1";
+            } else {
+                node = "::1";
+            }
+        }
+    }
+    // Let's try IPv4
+    int s = inet_pton(AF_INET, node, buf);
+    if (s == -1) { // error; should not happen
+        return EAI_FAMILY;
+    } else if (s == 1) { // IPVv4
+        family = AF_INET;
+    } else { // Let's try IPv6
+        memset(buf, 0, sizeof(buf));
+        s = inet_pton(AF_INET6, node, buf);
+        if (s == 1) {
+            family = AF_INET6;
+        } else if (s == -1) { // error; should not happen
+            return EAI_FAMILY;
+        } else { // badly encoded then
+            return EAI_NONAME;
+        }
+    }
+    char *endservptr = NULL;
+    in_port_t port = (serv == NULL) ? 0 : htons((uint16_t)(strtol(serv, &endservptr, 10)));
+    if (serv != NULL && (endservptr == NULL || *endservptr != '\0')) {
+        // As we assume that we only deal with numeric hosts and service numbers, this is invalid
+        return EAI_NONAME;
+    }
+    if (hints && hints->ai_family != AF_UNSPEC && family != hints->ai_family)
+        return EAI_FAMILY;
+    // Converted, and family identified
+    *res = malloc(sizeof(struct addrinfo));
+    struct addrinfo *rp = *res;
+    if (rp == NULL)
+        return EAI_MEMORY;
+    rp->ai_flags = 0;
+    rp->ai_family = family;
+    rp->ai_socktype = hints ? hints->ai_socktype : SOCK_DGRAM;
+    rp->ai_protocol = hints ? hints->ai_protocol : 0;
+    if (hints && (hints->ai_flags & AI_CANONNAME) != 0) {
+        rp->ai_canonname = malloc(strlen(node) + 2);
+        if (rp->ai_canonname == NULL) {
+            free(rp);
+            *res = NULL;
+            return EAI_MEMORY;
+        }
+        strcpy((rp->ai_canonname) + 1, node);
+        rp->ai_canonname[0] = 'C';
+    } else {
+        rp->ai_canonname = NULL;
+    }
+    rp->ai_next = NULL;
+    if (family == AF_INET) {
+        struct sockaddr_in *addr = malloc(sizeof(struct sockaddr_in));
+        if (addr == NULL) {
+            free(rp->ai_canonname);
+            free(rp);
+            *res = NULL;
+            return EAI_MEMORY;
+        }
+        addr->sin_family = AF_INET;
+        addr->sin_port = port;
+        memcpy(&(addr->sin_addr), buf, sizeof(struct in_addr));
+        rp->ai_addr = (struct sockaddr*)addr;
+        rp->ai_addrlen = sizeof(struct sockaddr_in);
+    } else {
+        struct sockaddr_in6 *addr = malloc(sizeof(struct sockaddr_in6));
+        if (addr == NULL) {
+            free(rp->ai_canonname);
+            free(rp);
+            *res = NULL;
+            return EAI_MEMORY;
+        }
+        memset(addr, 0, sizeof(*addr));
+        addr->sin6_family = AF_INET6;
+        addr->sin6_port = port;
+        memcpy(&(addr->sin6_addr), buf, sizeof(struct in6_addr));
+        rp->ai_addr = (struct sockaddr*)addr;
+        rp->ai_addrlen = sizeof(struct sockaddr_in6);
+    }
+    return 0;
+}
+
+void simple_freeaddrinfo(struct addrinfo *res)
+{
+    struct addrinfo *p = res;
+    while (p != NULL) {
+        struct addrinfo *old = p;
+        p = p->ai_next;
+        free(old->ai_canonname);
+        free(old->ai_addr);
+        free(old);
+    }
+}
diff --git a/student/CTester/wrap_network_dns.h b/student/CTester/wrap_network_dns.h
new file mode 100644
index 0000000..59e545a
--- /dev/null
+++ b/student/CTester/wrap_network_dns.h
@@ -0,0 +1,296 @@
+/**
+ * @file wrap_network_dns.h
+ * Wrappers for getaddrinfo, freeaddrinfo, gai_strerror and getnameinfo,
+ * and other miscellaneous helper functions.
+ */
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __WRAP_NETWORK_DNS_H_
+#define __WRAP_NETWORK_DNS_H_
+
+#include <netdb.h>
+#include <stdbool.h>
+
+
+// getaddrinfo parameters structures and statistics structure
+
+/**
+ * Parameters structure for getaddrinfo
+*/
+
+struct params_getaddrinfo_t {
+    const char *node;
+    const char *service;
+    const struct addrinfo *hints;
+    struct addrinfo **res;
+};
+
+// Used to record the addrinfo lists "returned" by getaddrinfo, in order to check for their deallocation via freeaddrinfo.
+/**
+ * Node for a list of all returned lists of struct addrinfo
+ * returned by getaddrinfo.
+ * This is used to check that they are deallocated via freeaddrinfo correctly.
+ */
+struct addrinfo_node_t {
+    struct addrinfo *addr_list;
+    struct addrinfo_node_t *next;
+};
+
+/**
+ * Statistics structure for getaddrinfo
+ */
+struct stats_getaddrinfo_t {
+    int called; // number of times the getaddrinfo call has been issued
+    struct params_getaddrinfo_t last_params; // parameters for the last monitored call
+    struct addrinfo_node_t *addrinfo_list; // list of addrinfo lists "returned" by getaddrinfo
+    int last_return; // return value of the last monitored call issued
+};
+
+
+// getnameinfo parameters structures and statistics structure
+
+/**
+ * Parameters structure for getnameinfo
+ */
+struct params_getnameinfo_t {
+    const struct sockaddr *addr;
+    socklen_t addrlen;
+    char *host;
+    socklen_t hostlen;
+    char *serv;
+    socklen_t servlen;
+    int flags;
+};
+
+/**
+ * Statistics structure for getnameinfo
+ */
+struct stats_getnameinfo_t {
+    int called; // number of calls
+    struct params_getnameinfo_t last_params; // parameters of the last monitored call
+    int last_return; // return value of the last monitored call issued
+};
+
+
+// freeaddrinfo parameters structures and statistics structure
+
+/**
+ * @struct params_freeaddrinfo_t
+ * Parameter structure for freeaddrinfo.
+ * There is no such structure, as there is only one parameter.
+ */
+
+/**
+ * Statistics structure for freeaddrinfo
+ */
+struct stats_freeaddrinfo_t {
+    int called; /**< number of calls */
+    struct addrinfo *last_param; /**< parameter of the last monitored call issued */
+    /**
+     * Status of the last monitored call:
+     * if check_freeaddrinfo is true
+     *     and last_param was not returned by getaddrinfo during the monitoring,
+     *     then status is 1;
+     * else, status is zero.
+     */
+    int status;
+};
+
+
+// gai_strerror parameters structures and statistics structure
+
+/**
+ * @struct params_gai_strerror_t
+ * Parameter structure for gai_strerror.
+ * There is no such structure, as there is only one parameter.
+ */
+
+/**
+ * Statistics structure for gai_strerror
+ */
+struct stats_gai_strerror_t {
+    int called; ///< number of calls
+    int last_params; ///< parameter of the last monitored call
+    const char *last_return; ///< return value of the last monitored call
+};
+
+// TODO Maybe add some init, clean and resetstats methods to these calls ?
+
+/**
+ * Resets the statistics of the DNS-related methods.
+ */
+void reinit_stats_network_dns();
+
+
+/**
+ * Enforces checking that the passed structure has been previously returned by getaddrinfo.
+ * When check is true, freeaddrinfo will check if its argument has been "returned"
+ * by an earlier call to getaddrinfo directly, and will report if it is not the case.
+ * @see freeaddrinfo_badarg_report_t
+ *
+ * @param check do we enforce checking?
+ */
+void set_check_freeaddrinfo(bool check);
+
+
+/**
+ * Functions of this type should return in *res a valid list of
+ * struct addrinfo, in a manner compatible with getaddrinfo,
+ * suitable to be freed by a function of type freeaddrinfo_method_t.
+ */
+typedef int (*getaddrinfo_method_t)(const char *node, const char *service,
+        const struct addrinfo *hints, struct addrinfo **res);
+
+/**
+ * Functions of this type should be able to free structures allocated
+ * by a function of type getaddrinfo_method_t.
+ */
+typedef void (*freeaddrinfo_method_t)(struct addrinfo *res);
+
+/**
+ * Specifies the actual function called by the getaddrinfo wrapper.
+ *
+ * If method is not NULL, replaces __real_getaddrinfo by the function "method"
+ * as the real function executed by the wrapper.
+ * If method is NULL, resets the method to __real_getaddrinfo.
+ * This method only sets the substitute for the getaddrinfo function,
+ * and not the substitute for the freeaddrinfo function;
+ * incompatible definitions of these functions may result in memleaks
+ * or double free if care is not taken.
+ * @see set_gai_methods()
+ *
+ * @param method the function called by the wrapper.
+ */
+void set_getaddrinfo_method(getaddrinfo_method_t method);
+
+/**
+ * Sets the getaddrinfo and freeaddrinfo replacement functions
+ * to be used in the sandbox.
+ *
+ * Specifying NULL for a parameter means that the system will use
+ * the default, system-defined method (__real_getaddrinfo or
+ * __real_freeaddrinfo).
+ * This is especially needed as the POSIX standard doesn't specify the way
+ * the list of struct addrinfo is generated: glibc allocates a single block
+ * of memory for both the struct addrinfo and its struct sockaddr,
+ * as well as one block of memory for the canonical name (if asked for).
+ * Therefore, calling __real_freeaddrinfo on a custom-built list may result
+ * in memleaks, and using a wrong freeaddrinfo_method_t to free a list
+ * generated by __real_getaddrinfo may cause a double free.
+ * @see set_getaddrinfo_method()
+ *
+ * @param gai_method the function called by the getaddrinfo wrapper.
+ * @param fai_method the function called by the freeaddrinfo wrapper.
+ */
+void set_gai_methods(getaddrinfo_method_t gai_method, freeaddrinfo_method_t fai_method);
+
+
+/**
+ * Functions of this type should return in host and serv valid names for a host
+ * and service given the address addr, in manner compatible with getnameinfo.
+ */
+typedef int (*getnameinfo_method_t)(const struct sockaddr *addr,
+        socklen_t addrlen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags);
+
+/**
+ * Sets the getnameinfo replacement function to be used in the sandbox.
+ *
+ * If method is not NULL, replaces __real_getnameinfo by the function "method"
+ * as the real function executed by the wrapper.
+ * If method is NULL, resets the method to __real_getnameinfo.
+ * @see set_getaddrinfo_method().
+ *
+ * @param method the function called by the getnameinfo wrapper.
+ */
+void set_getnameinfo_method(getnameinfo_method_t method);
+
+
+/**
+ * Functions of this type should return a string given an error code
+ * for the getaddrinfo function call.
+ * The string should not be freed by the caller.
+ */
+typedef const char *(*gai_strerror_method_t)(int);
+
+/**
+ * Sets the gai_strerror replacement function to be used in the sandbox.
+ *
+ * If method is not NULL, replaces __real_gai_strerror by the function "method"
+ * as the real function called by the wrapper.
+ * If method is NULL, resets the method to __real_gai_strerror.
+ * This allows specifying other error messages than the standard ones.
+ *
+ * @param method the function called by the gai_strerror wrapper.
+ */
+void set_gai_strerror_method(gai_strerror_method_t method);
+
+
+/**
+ * Functions of this type will be called when freeaddrinfo is called with
+ * an argument that has never been returned by the getaddrinfo wrapper,
+ * when freeaddrinfo is configured to check the validity of its argument.
+ * @see set_check_freeaddrinfo()
+ */
+typedef void (*freeaddrinfo_badarg_report_t)();
+
+/**
+ * Sets the method to be called if check_freeaddrinfo is true
+ * and the argument passed to freeaddrinfo was not returned by getaddrinfo.
+ *
+ * This is useful if you want to use the push_info_msg method
+ * for your feedback, for example. Default is NULL.
+ *
+ * @param reporter the function to be called when a bad argument is provided
+ *                 to freeaddrinfo and detected.
+ */
+void set_freeaddrinfo_badarg_report(freeaddrinfo_badarg_report_t reporter);
+
+
+/**
+ * Resets all methods to the default, library-provided ones.
+ */
+void reset_gai_fai_gstr_gni_methods();
+
+/**
+ * Replaces getaddrinfo by a version which doesn't call DNS.
+ * node should be a numerical address (like 192.168.1.1),
+ * which will be converted using inet_pton and stored inside the answer.
+ * serv should be a positive short integer as a string, representing the port.
+ * Returns only one addrinfo in *res, with appropriate values taken from
+ * node, serv and the fields from hints. Also, the canonical name is set,
+ * if specified, by 'C' followed by the content of node.
+ * If node is NULL and hints->ai_flags contains AI_PASSIVE, then IPv4 (0.0.0.0)
+ * is used if hints->ai_family is AF_INET, otherwise IPv6 (::) is used.
+ * If hints is NULL, an address with SOCK_DGRAM as its socket type is returned.
+ * @see simple_freeaddrinfo for the corresponding freeaddrinfo_method_t
+ * @warning This function is probably only minimally tested, and would benefit
+ *          from more testng.
+ * @param node  See the standard getaddrinfo
+ * @param serv  See the standard getaddrinfo
+ * @param hints See the standard getaddrinfo
+ * @param res   See the standard getaddrinfo
+ */
+int simple_getaddrinfo(const char *node, const char *serv, const struct addrinfo *hints, struct addrinfo **res);
+
+/**
+ * Necessary for cross-library compatibility: should be used in place
+ * of the default freeaddrinfo to free the list returned by simple_getaddrinfo;
+ * see set_gai_methods for more information.
+ * @see simple_getaddrinfo for the corresponding creator function.
+ * @param res See the standard freeaddrinfo
+ */
+void simple_freeaddrinfo(struct addrinfo *res);
+
+#endif // __WRAP_NETWORK_DNS_H_
+
diff --git a/student/CTester/wrap_network_inet.c b/student/CTester/wrap_network_inet.c
new file mode 100644
index 0000000..571a61a
--- /dev/null
+++ b/student/CTester/wrap_network_inet.c
@@ -0,0 +1,82 @@
+/*
+ * Wrapper for htons, ntohs, htonl, ntohl, and other future functions.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h>
+
+#include "wrap.h"
+
+uint16_t __real_htons(uint16_t hostshort);
+uint16_t __real_ntohs(uint16_t netshort);
+uint32_t __real_htonl(uint32_t hostlong);
+uint32_t __real_ntohl(uint32_t netlong);
+
+extern bool wrap_monitoring;
+extern struct wrap_stats_t stats;
+extern struct wrap_monitor_t monitored;
+
+uint16_t __wrap_htons(uint16_t hostshort)
+{
+    uint16_t ret = __real_htons(hostshort);
+    if (wrap_monitoring && monitored.htons) {
+        stats.htons.called++;
+        stats.htons.last_params.hostshort = hostshort;
+        stats.htons.last_return = ret;
+    }
+    return ret;
+}
+
+uint16_t __wrap_ntohs(uint16_t netshort)
+{
+    uint16_t ret = __real_ntohs(netshort);
+    if (wrap_monitoring && monitored.ntohs) {
+        stats.ntohs.called++;
+        stats.ntohs.last_params.netshort = netshort;
+        stats.ntohs.last_return = ret;
+    }
+    return ret;
+}
+
+uint32_t __wrap_htonl(uint32_t hostlong)
+{
+    uint32_t ret = __real_htonl(hostlong);
+    if (wrap_monitoring && monitored.htonl) {
+        stats.htonl.called++;
+        stats.htonl.last_params.hostlong = hostlong;
+        stats.htonl.last_return = ret;
+    }
+    return ret;
+}
+
+uint32_t __wrap_ntohl(uint32_t netlong)
+{
+    uint32_t ret = __real_ntohl(netlong);
+    if (wrap_monitoring && monitored.ntohl) {
+        stats.ntohl.called++;
+        stats.ntohl.last_params.netlong = netlong;
+        stats.ntohl.last_return = ret;
+    }
+    return ret;
+}
+
+// Additionnal functions
+
+void reinit_network_inet_stats()
+{
+    memset(&(stats.htons), 0, sizeof(stats.htons));
+    memset(&(stats.ntohs), 0, sizeof(stats.ntohs));
+    memset(&(stats.htonl), 0, sizeof(stats.htonl));
+    memset(&(stats.ntohl), 0, sizeof(stats.ntohl));
+}
+
diff --git a/student/CTester/wrap_network_inet.h b/student/CTester/wrap_network_inet.h
new file mode 100644
index 0000000..c44f177
--- /dev/null
+++ b/student/CTester/wrap_network_inet.h
@@ -0,0 +1,71 @@
+/**
+ * @file wrap_network_inet.h
+ * Wrapper for htons, ntohs, htonl, ntohl, and other future functions.
+ */
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __WRAP_NETWORK_INET_H_
+#define __WRAP_NETWORK_INET_H_
+
+/*
+ * Structures for htons, ntohs, htonl, ntohl.
+ */
+
+struct params_htons_t {
+    uint16_t hostshort;
+};
+struct params_ntohs_t {
+    uint16_t netshort;
+};
+struct params_htonl_t {
+    uint32_t hostlong;
+};
+struct params_ntohl_t {
+    uint32_t netlong;
+};
+
+struct stats_htons_t {
+    int called;
+    struct params_htons_t last_params;
+    uint16_t last_return;
+};
+struct stats_ntohs_t {
+    int called;
+    struct params_ntohs_t last_params;
+    uint16_t last_return;
+};
+struct stats_htonl_t {
+    int called;
+    struct params_htonl_t last_params;
+    uint32_t last_return;
+};
+struct stats_ntohl_t {
+    int called;
+    struct params_ntohl_t last_params;
+    uint32_t last_return;
+};
+
+
+/*
+ * Utility functions and structures
+ */
+
+/**
+ * Resets the statistics for the functions htons, ntohs, htonl, ntohl.
+ */
+void reinit_network_inet_stats();
+
+
+#endif // __WRAP_NETWORK_INET_H_
+
diff --git a/student/CTester/wrap_network_socket.c b/student/CTester/wrap_network_socket.c
new file mode 100644
index 0000000..ffc356f
--- /dev/null
+++ b/student/CTester/wrap_network_socket.c
@@ -0,0 +1,475 @@
+/*
+ * Wrapper for accept, bind, connect, listen, poll, select,
+ * recv, recvfrom, recvmsg, send, sendto, sendmsg, socket.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdbool.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <poll.h>
+
+#include "read_write.h"
+#include "wrap.h"
+
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+
+
+int     __real_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
+int     __real_bind   (int sockfd, const struct sockaddr *addr, socklen_t addrlen);
+int     __real_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
+int     __real_listen(int sockfd, int backlog);
+int     __real_poll(struct pollfd *fds, nfds_t nfds, int timeout);
+ssize_t __real_recv(int sockfd, void *buf, size_t len, int flags);
+ssize_t __real_recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
+ssize_t __real_recvmsg(int sockfd, struct msghdr *msg, int flags);
+int     __real_select(int nfds, fd_set *readfds, fd_set *write_fds, fd_set *except_fds, struct timeval *timeout);
+ssize_t __real_send(int sockfd, const void *buf, size_t len, int flags);
+ssize_t __real_sendmsg(int sockfd, const struct msghdr *msg, int flags);
+ssize_t __real_sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
+int     __real_shutdown(int sockfd, int how);
+int     __real_socket(int domain, int type, int protocol);
+
+
+extern bool wrap_monitoring;
+extern struct wrap_stats_t stats;
+extern struct wrap_monitor_t monitored;
+extern struct wrap_fail_t failures;
+
+/**
+ * Auxiliary functions and structures for use by implementers for read/write
+ */
+extern ssize_t read_handle_buffer(int fd, void *buf, size_t len, int flags);
+
+extern struct read_fd_table_t read_fd_table;
+
+
+/**
+ * Wrap functions.
+ */
+
+
+/*
+ * Note: addr should point to an existing sockaddr, or NULL if we don't want it
+ * and addrlen should point to an existing socklen_t containing the size
+ * of the existing sockaddr, and will be modified to reflect the true size
+ * of the returned sockaddr; it may be greater than the original value
+ * if the provided sockaddr is too small, and this sockaddr will be truncated.
+ * If addr in NULL, addrlen should also be NULL.
+ */
+int __wrap_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
+{
+    if (!(wrap_monitoring && monitored.accept)) {
+        return __real_accept(sockfd, addr, addrlen);
+    }
+    socklen_t old_addrlen = (addrlen == NULL ? 0 : *addrlen); // May crash if addrlen doesn't point to a valid address.
+    stats.accept.called++;
+    stats.accept.last_params = (struct params_accept_t) {
+        .sockfd = sockfd,
+        .addr = addr,
+        .addrlen = addrlen
+    };
+    // Reinit stats
+    stats.accept.last_returns.addrlen = 0;
+    memset(&(stats.accept.last_returns.addr), 0, sizeof(struct sockaddr_storage));
+    if (FAIL(failures.accept)) {
+        failures.accept = NEXT(failures.accept);
+        errno = failures.accept_errno;
+        return (stats.accept.last_return = failures.accept_ret);
+    }
+    failures.accept = NEXT(failures.accept);
+    int ret = -2;
+    ret = __real_accept(sockfd, addr, addrlen);
+    if (ret == 0 && addr != NULL) {
+        /*
+         * We should only copy the returned address
+         * - if there was no error (otherwise it is probably not wise)
+         * - if addr != NULL; if addr == NULL, then whatever addrlen is,
+         *   nothing was returned
+         */
+        stats.accept.last_returns.addrlen = (addrlen == NULL ? 0 : *addrlen);
+        /*
+         * We need the minimum as *addrlen may be greater than old_addrlen
+         * and grater than the size of *addr, and we're not interested
+         * in potential garbage not set by accept in the remaining space.
+         * This can't segfault as ret == 0
+         */
+        memcpy(&(stats.accept.last_returns.addr), addr, MIN(old_addrlen, *addrlen));
+    } // else: there was an error, so the safest thing to do is ignore the value provided
+    return (stats.accept.last_return = ret);
+}
+
+int __wrap_bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
+{
+    if (!(wrap_monitoring && monitored.bind)) {
+        return __real_bind(sockfd, addr, addrlen);
+    }
+    stats.bind.called++;
+    stats.bind.last_params = (struct params_bind_t) {
+        .sockfd = sockfd,
+        .addr = addr,
+        .addrlen = addrlen
+    };
+    if (FAIL(failures.bind)) {
+        failures.bind = NEXT(failures.bind);
+        errno = failures.bind_errno;
+        return (stats.bind.last_return = failures.bind_ret);
+    }
+    failures.bind = NEXT(failures.bind);
+    int ret = -2;
+    ret = __real_bind(sockfd, addr, addrlen);
+    return (stats.bind.last_return = ret);
+}
+
+int __wrap_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
+{
+    if (!(wrap_monitoring && monitored.connect)) {
+        return __real_connect(sockfd, addr, addrlen);
+    }
+    stats.connect.called++;
+    stats.connect.last_params = (struct params_connect_t) {
+        .sockfd = sockfd,
+        .addr = addr,
+        .addrlen = addrlen
+    };
+    if (FAIL(failures.connect)) {
+        failures.connect = NEXT(failures.connect);
+        errno = failures.connect_errno;
+        return (stats.connect.last_return = failures.connect_ret);
+    }
+    failures.connect = NEXT(failures.connect);
+    int ret = -2;
+    ret = __real_connect(sockfd, addr, addrlen);
+    return (stats.connect.last_return = ret);
+}
+
+int __wrap_listen(int sockfd, int backlog)
+{
+    if (!(wrap_monitoring && monitored.listen)) {
+        return __real_listen(sockfd, backlog);
+    }
+    stats.listen.called++;
+    stats.listen.last_params = (struct params_listen_t) {
+        .sockfd = sockfd,
+        .backlog = backlog
+    };
+    if (FAIL(failures.listen)) {
+        failures.listen = NEXT(failures.listen);
+        errno = failures.listen_errno;
+        return (stats.listen.last_return = failures.listen_ret);
+    }
+    failures.listen = NEXT(failures.listen);
+    int ret = -2;
+    ret = __real_listen(sockfd, backlog);
+    return (stats.listen.last_return = ret);
+}
+
+int __wrap_poll(struct pollfd *fds, nfds_t nfds, int timeout)
+{
+    if (!(wrap_monitoring && monitored.poll)) {
+        return __real_poll(fds, nfds, timeout);
+    }
+    stats.poll.called++;
+    stats.poll.last_params = (struct params_poll_t) {
+        .fds_ptr = fds,
+        .nfds = nfds,
+        .timeout = timeout,
+        .fds_copy = NULL
+    };
+    if (FAIL(failures.poll)) {
+        failures.poll = NEXT(failures.poll);
+        errno = failures.poll_errno;
+        return (stats.poll.last_return = failures.poll_ret);
+    }
+    failures.poll = NEXT(failures.poll);
+    int ret = -2;
+    ret = __real_poll(fds, nfds, timeout);
+    if (! (ret == -1 && errno == EFAULT)) {
+        struct pollfd *tmp = malloc(nfds * sizeof(struct pollfd));
+        if (tmp) {
+            memcpy(tmp, fds, nfds * sizeof(struct pollfd));
+            stats.poll.last_params.fds_copy = tmp;
+        }
+    }
+    return ret;
+}
+
+ssize_t __wrap_recv(int sockfd, void *buf, size_t len, int flags)
+{
+    if (!(wrap_monitoring && monitored.recv)) {
+        return __real_recv(sockfd, buf, len, flags);
+    }
+    stats.recv.called++;
+    stats.recv_all.called++;
+    stats.recv.last_params = (struct params_recv_t) {
+        .sockfd = sockfd,
+        .buf = buf,
+        .len = len,
+        .flags = flags
+    };
+    if (FAIL(failures.recv)) {
+        failures.recv = NEXT(failures.recv);
+        errno = failures.recv_errno;
+        return (stats.recv.last_return = failures.recv_ret);
+    }
+    failures.recv = NEXT(failures.recv);
+    ssize_t ret = -1;
+    if (fd_is_read_buffered(sockfd)) {
+        ret = read_handle_buffer(sockfd, buf, len, flags);
+    } else {
+        ret = __real_recv(sockfd, buf, len, flags);
+    }
+    return (stats.recv.last_return = ret);
+}
+
+ssize_t __wrap_recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen)
+{
+    if (!(wrap_monitoring && monitored.recvfrom)) {
+        return __real_recvfrom(sockfd, buf, len, flags, src_addr, addrlen);
+    }
+    socklen_t old_addrlen = (addrlen == NULL ? 0 : *addrlen); // May crash
+    stats.recvfrom.called++;
+    stats.recv_all.called++;
+    stats.recvfrom.last_params = (struct params_recvfrom_t) {
+        .sockfd = sockfd,
+        .buf = buf,
+        .len = len,
+        .flags = flags,
+        .src_addr = src_addr,
+        .addrlen = addrlen
+    };
+    stats.recvfrom.last_returned_addr.addrlen = 0;
+    memset(&(stats.recvfrom.last_returned_addr.src_addr), 0, sizeof(struct sockaddr_storage));
+    if (FAIL(failures.recvfrom)) {
+        failures.recvfrom = NEXT(failures.recvfrom);
+        errno = failures.recvfrom_errno;
+        return (stats.recv.last_return = failures.recvfrom_ret);
+    }
+    failures.recvfrom = NEXT(failures.recvfrom);
+    ssize_t ret = -1;
+    if (fd_is_read_buffered(sockfd) && src_addr == NULL && addrlen == NULL) {
+        ret = read_handle_buffer(sockfd, buf, len, flags);
+    } else {
+        ret = __real_recvfrom(sockfd, buf, len, flags, src_addr, addrlen);
+    }
+    if (ret >= 0 && src_addr != NULL) {
+        // Same justification as in accept
+        stats.recvfrom.last_returned_addr.addrlen = *addrlen;
+        memcpy(&(stats.recvfrom.last_returned_addr.src_addr), src_addr, MIN(old_addrlen, *addrlen));
+    }
+    return (stats.recvfrom.last_return = ret);
+}
+
+ssize_t __wrap_recvmsg(int sockfd, struct msghdr *msg, int flags)
+{
+    if (!(wrap_monitoring && monitored.recvmsg)) {
+        return __real_recvmsg(sockfd, msg, flags);
+    }
+    stats.recvmsg.called++;
+    stats.recv_all.called++;
+    stats.recvmsg.last_params = (struct params_recvmsg_t) {
+        .sockfd = sockfd,
+        .msg = msg,
+        .flags = flags
+    };
+    // Reinit struct
+    memset(&(stats.recvmsg.last_returned_msg), 0, sizeof(struct msghdr));
+    if (FAIL(failures.recvmsg)) {
+        failures.recvmsg = NEXT(failures.recvmsg);
+        errno = failures.recvmsg_errno;
+        return (stats.recvmsg.last_return = failures.recvmsg_ret);
+    }
+    failures.recvmsg = NEXT(failures.recvmsg);
+    ssize_t ret = -1;
+    ret = __real_recvmsg(sockfd, msg, flags);
+    if (ret == 0) {
+        // Assume that msg doesn't point to an invalid location
+        memcpy(&(stats.recvmsg.last_returned_msg), msg, sizeof(struct msghdr));
+    }
+    return ret;
+}
+
+int __wrap_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
+{
+    if (!(wrap_monitoring && monitored.select)) {
+        return __real_select(nfds, readfds, writefds, exceptfds, timeout);
+    }
+    stats.select.called++;
+    stats.select.last_params = (struct params_select_t) {
+        .nfds = nfds,
+        .readfds_ptr = readfds,
+        .writefds_ptr = writefds,
+        .exceptfds_ptr = exceptfds,
+        .timeout_ptr = timeout,
+        .readfds = *readfds, // FIXME may cause a segfault if the student passed garbage
+        .writefds = *writefds,
+        .exceptfds = *exceptfds,
+        .timeout = *timeout
+    };
+    if (FAIL(failures.select)) {
+        failures.select = NEXT(failures.select);
+        errno = failures.select_errno;
+        return (stats.select.last_return = failures.select_ret);
+    }
+    failures.select = NEXT(failures.select);
+    int ret = -1;
+    ret = __real_select(nfds, readfds, writefds, exceptfds, timeout);
+    return ret;
+}
+
+ssize_t __wrap_send(int sockfd, const void *buf, size_t len, int flags)
+{
+    if (!(wrap_monitoring && monitored.send)) {
+        return __real_send(sockfd, buf, len, flags);
+    }
+    stats.send.called++;
+    stats.send_all.called++;
+    stats.send.last_params = (struct params_send_t) {
+        .sockfd = sockfd,
+        .buf = buf,
+        .len = len,
+        .flags = flags
+    };
+    if (FAIL(failures.send)) {
+        failures.send = NEXT(failures.send);
+        errno = failures.send_errno;
+        return (stats.send.last_return = failures.send_ret);
+    }
+    failures.send = NEXT(failures.send);
+    ssize_t ret = -1;
+    ret = __real_send(sockfd, buf, len, flags);
+    return (stats.send.last_return = ret);
+}
+
+ssize_t __wrap_sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen)
+{
+    if (!(wrap_monitoring && monitored.sendto)) {
+        return __real_sendto(sockfd, buf, len, flags, dest_addr, addrlen);
+    }
+    stats.sendto.called++;
+    stats.send_all.called++;
+    stats.sendto.last_params = (struct params_sendto_t) {
+        .sockfd = sockfd,
+        .buf = buf,
+        .len = len,
+        .flags = flags,
+        .dest_addr = dest_addr,
+        //.dest_addr = (struct sockaddr_storage)0,
+        .addrlen = addrlen
+    };
+    /*if (dest_addr != NULL) {
+        memcpy(&(stats.sendto.last_params.dest_addr), dest_addr, MIN(addrlen, sizeof(struct sockaddr_storage))); // May segfault if dest_addr is badly defined.
+    }*/
+    if (FAIL(failures.sendto)) {
+        failures.sendto = NEXT(failures.sendto);
+        errno = failures.sendto_errno;
+        return (stats.sendto.last_return = failures.sendto_ret);
+    }
+    failures.sendto = NEXT(failures.sendto);
+    ssize_t ret = -1;
+    ret = __real_sendto(sockfd, buf, len, flags, dest_addr, addrlen);
+    return (stats.sendto.last_return = ret);
+}
+
+ssize_t __wrap_sendmsg(int sockfd, const struct msghdr *msg, int flags)
+{
+    if (!(wrap_monitoring && monitored.sendmsg)) {
+        return __real_sendmsg(sockfd, msg, flags);
+    }
+    stats.sendmsg.called++;
+    stats.send_all.called++;
+    stats.sendmsg.last_params = (struct params_sendmsg_t) {
+        .sockfd = sockfd,
+        .msg = msg,
+        //.msg = (struct msghdr)0,
+        .flags = flags
+    };
+    /*if (msg != NULL) {
+        memcpy(&(stats.sendmsg.last_params.msg), msg, sizeof(struct msghdr));
+    }*/
+    if (FAIL(failures.sendmsg)) {
+        failures.sendmsg = NEXT(failures.sendmsg);
+        errno = failures.sendmsg_errno;
+        return (stats.sendmsg.last_return = failures.sendmsg_ret);
+    }
+    failures.sendmsg = NEXT(failures.sendmsg);
+    ssize_t ret = -1;
+    ret = __real_sendmsg(sockfd, msg, flags);
+    return ret;
+}
+
+int __wrap_shutdown(int sockfd, int how)
+{
+    if (!(wrap_monitoring && monitored.shutdown)) {
+        return __real_shutdown(sockfd, how);
+    }
+    stats.shutdown.called++;
+    stats.shutdown.last_params = (struct params_shutdown_t) {
+        .sockfd = sockfd,
+        .how = how
+    };
+    if (FAIL(failures.shutdown)) {
+        failures.shutdown = NEXT(failures.shutdown);
+        errno = failures.shutdown_errno;
+        return (stats.shutdown.last_return = failures.shutdown_ret);
+    }
+    failures.shutdown = NEXT(failures.shutdown);
+    int ret = -1;
+    ret = __real_shutdown(sockfd, how);
+    return ret;
+}
+
+int __wrap_socket(int domain, int type, int protocol)
+{
+    if (!(wrap_monitoring && monitored.socket)) {
+        return __real_socket(domain, type, protocol);
+    }
+    stats.socket.called++;
+    stats.socket.last_params = (struct params_socket_t) {
+        .domain = domain,
+        .type = type,
+        .protocol = protocol
+    };
+    if (FAIL(failures.socket)) {
+        failures.socket = NEXT(failures.socket);
+        errno = failures.socket_errno;
+        return (stats.socket.last_return = failures.socket_ret);
+    }
+    failures.socket = NEXT(failures.socket);
+    int ret = -2;
+    ret = __real_socket(domain, type, protocol);
+    return (stats.socket.last_return = ret);
+}
+
+// Additionnal functions
+
+void reinit_network_socket_stats()
+{
+    memset(&(stats.accept), 0, sizeof(struct stats_accept_t));
+    memset(&(stats.bind), 0, sizeof(struct stats_bind_t));
+    memset(&(stats.connect), 0, sizeof(struct stats_connect_t));
+    memset(&(stats.listen), 0, sizeof(struct stats_listen_t));
+    memset(&(stats.poll), 0, sizeof(stats.poll));
+    memset(&(stats.recv), 0, sizeof(struct stats_recv_t));
+    memset(&(stats.recvfrom), 0, sizeof(struct stats_recvfrom_t));
+    memset(&(stats.recvmsg), 0, sizeof(struct stats_recvmsg_t));
+    memset(&(stats.recv_all), 0, sizeof(struct stats_recv_all_t));
+    memset(&(stats.select), 0, sizeof(stats.select));
+    memset(&(stats.send), 0, sizeof(struct stats_send_t));
+    memset(&(stats.sendto), 0, sizeof(struct stats_sendto_t));
+    memset(&(stats.sendmsg), 0, sizeof(struct stats_sendmsg_t));
+    memset(&(stats.send_all), 0, sizeof(struct stats_send_all_t));
+    memset(&(stats.shutdown), 0, sizeof(stats.shutdown));
+    memset(&(stats.socket), 0, sizeof(struct stats_socket_t));
+}
+
diff --git a/student/CTester/wrap_network_socket.h b/student/CTester/wrap_network_socket.h
new file mode 100644
index 0000000..53ec3f6
--- /dev/null
+++ b/student/CTester/wrap_network_socket.h
@@ -0,0 +1,287 @@
+/**
+ * @file wrap_network_socket.h
+ * Wrapper for accept, bind, connect, listen, poll, select,
+ * recv, recvfrom, recvmsg, send, sendto, sendmsg, socket.
+ */
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __WRAP_NETWORK_SOCKET_H_
+#define __WRAP_NETWORK_SOCKET_H_
+
+/*
+ * Structures for accept.
+ * In addition to the common stats structures,
+ * there is an additional structure called return_accept_t,
+ * which will retain the returned content, in the case that the student
+ * frees the allocated memory before we have the possibility to check it.
+ */
+struct params_accept_t {
+    int sockfd;
+    struct sockaddr *addr;
+    socklen_t *addrlen;
+};
+
+/**
+ * Structure to remember the returned value for accept.
+ */
+struct return_accept_t {
+    /**
+     * sockaddr filled in *addr in the call. Set to 0 if failure.
+     * @note This is not a pointer, but the actual content.
+     */
+    struct sockaddr_storage addr; // We use a sockaddr_storage as it is guaranteed to always be big enough to contain sockaddresses.
+    /** size of the sockaddr filled in *addr, or zero if failure. */
+    socklen_t addrlen;
+};
+
+struct stats_accept_t {
+    int called;                          ///< Number of times the system call has been called.
+    struct params_accept_t last_params;  ///< Parameters of the last call
+    int last_return;
+    struct return_accept_t last_returns; ///< Return values of the call
+};
+
+/*
+ * Structures for bind
+ */
+struct params_bind_t {
+    int sockfd;
+    const struct sockaddr *addr;
+    socklen_t addrlen;
+};
+
+struct stats_bind_t {
+    int called;
+    struct params_bind_t last_params;
+    int last_return;
+};
+
+
+/*
+ * Structures for connect
+ */
+struct params_connect_t {
+    int sockfd;
+    const struct sockaddr *addr;
+    socklen_t addrlen;
+};
+
+struct stats_connect_t {
+    int called;
+    struct params_connect_t last_params;
+    int last_return;
+};
+
+
+/*
+ * Structures for listen
+ */
+struct params_listen_t {
+    int sockfd;
+    int backlog;
+};
+
+struct stats_listen_t {
+    int called;
+    struct params_listen_t last_params;
+    int last_return;
+};
+
+
+/*
+ * Structures for poll
+ */
+struct params_poll_t {
+    struct pollfd *fds_ptr;
+    unsigned long int nfds; // Strictly speaking, this is a nfds_t, but is is at least an unsigned long int.
+    int timeout;
+    struct pollfd *fds_copy;
+};
+
+struct stats_poll_t {
+    int called;
+    struct params_poll_t last_params;
+    int last_return;
+};
+
+
+/*
+ * Structures for recv, recvfrom, recvmsg.
+ */
+struct params_recv_t {
+    int sockfd;
+    void *buf;
+    size_t len;
+    int flags;
+};
+struct params_recvfrom_t {
+    int sockfd;
+    void *buf;
+    size_t len;
+    int flags;
+    struct sockaddr *src_addr;
+    socklen_t *addrlen;
+};
+struct params_recvmsg_t {
+    int sockfd;
+    struct msghdr *msg;
+    int flags;
+};
+/**
+ * Structure for recording the return values of recvfrom
+ */
+struct return_recvfrom_t {
+    /** Source address */
+    struct sockaddr_storage src_addr;
+    /** Source address length */
+    socklen_t addrlen;
+};
+
+
+struct stats_recv_t {
+    int called;
+    struct params_recv_t last_params;
+    ssize_t last_return;
+};
+struct stats_recvfrom_t {
+    int called;
+    struct params_recvfrom_t last_params;
+    ssize_t last_return;
+    struct return_recvfrom_t last_returned_addr;
+};
+struct stats_recvmsg_t {
+    int called;
+    struct params_recvmsg_t last_params;
+    ssize_t last_return;
+    struct msghdr last_returned_msg;
+};
+/**
+ * Structure that records total statistics for recv, recvfrom and recvmsg combined.
+ */
+struct stats_recv_all_t {
+    /** Number of times any of recv, recvfrom or recvmsg has been called */
+    int called; // Should be incremented each time we increment another one
+};
+
+
+/*
+ * Structures for select.
+ */
+struct params_select_t {
+    int nfds;
+    fd_set *readfds_ptr;
+    fd_set *writefds_ptr;
+    fd_set *exceptfds_ptr;
+    struct timeval *timeout_ptr;
+    fd_set readfds;
+    fd_set writefds;
+    fd_set exceptfds;
+    struct timeval timeout;
+};
+
+struct stats_select_t {
+    int called;
+    struct params_select_t last_params;
+    int last_return;
+};
+
+
+/*
+ * Structures for send, sendto and sendmsg.
+ */
+struct params_send_t {
+    int sockfd;
+    const void *buf;
+    size_t len;
+    int flags;
+};
+struct params_sendto_t {
+    int sockfd;
+    const void *buf;
+    size_t len;
+    int flags;
+    const struct sockaddr *dest_addr;
+    //struct sockaddr_storage dest_addr;
+    socklen_t addrlen;
+};
+struct params_sendmsg_t {
+    int sockfd;
+    const struct msghdr *msg;
+    //struct msghdr msg;
+    int flags;
+};
+
+
+struct stats_send_t {
+    int called;
+    struct params_send_t last_params;
+    ssize_t last_return;
+};
+struct stats_sendto_t {
+    int called;
+    struct params_sendto_t last_params;
+    ssize_t last_return;
+};
+struct stats_sendmsg_t {
+    int called;
+    struct params_sendmsg_t last_params;
+    ssize_t last_return;
+};
+struct stats_send_all_t {
+    int called; // Should be incremented each time we increment another one.
+};
+
+
+/*
+ * Structures for shutdown.
+ */
+struct params_shutdown_t {
+    int sockfd;
+    int how;
+};
+
+struct stats_shutdown_t {
+    int called;
+    struct params_shutdown_t last_params;
+    int last_return;
+};
+
+
+/*
+ * Structures for socket
+ */
+struct params_socket_t {
+    int domain;
+    int type;
+    int protocol;
+};
+
+struct stats_socket_t {
+    int called; // Number of times the function has been called
+    struct params_socket_t last_params; // Arguments of the last call to socket(2)
+    int last_return; // Return value of the last call to socket(2)
+};
+
+
+/*
+ * Utility functions and structures
+ */
+
+/**
+ * Resets the statistics for the socket-related functions.
+ */
+void reinit_network_socket_stats();
+
+
+#endif // __WRAP_NETWORK_SOCKET_H__
diff --git a/student/CTester/wrap_sleep.c b/student/CTester/wrap_sleep.c
index b74a2a6..2140636 100644
--- a/student/CTester/wrap_sleep.c
+++ b/student/CTester/wrap_sleep.c
@@ -1,3 +1,18 @@
+/*
+ * Wrapper for sleep.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include <sys/types.h>
 #include <unistd.h>
 #include <stdio.h>
diff --git a/student/CTester/wrap_sleep.h b/student/CTester/wrap_sleep.h
index 6d0a488..6424dae 100644
--- a/student/CTester/wrap_sleep.h
+++ b/student/CTester/wrap_sleep.h
@@ -1,16 +1,53 @@
+/**
+ * @file wrap_sleep.h
+ * Wrapper for sleep.
+ */
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __WRAP_SLEEP_H_
+#define __WRAP_SLEEP_H_
+
+#include <sys/types.h>
+#include <unistd.h>
+
 // never remove statistics from this structure, they could be
 // used by existing exercices. You might add some additional information
 // if it can help to validate some exercices
-#include <sys/types.h>
-#include <unistd.h>
 
+/**
+ * Statistics structure for the sleep function.
+ */
 struct stats_sleep_t {
-  int called;           // number of times the system call has been called
-  unsigned int last_return;    // last return value for sleep
-  unsigned int last_arg;    // last return value for sleep
+  int called;                ///< number of times the system call has been called
+  unsigned int last_return;  ///< last return value for sleep
+  unsigned int last_arg;     ///< last argument value for sleep
 };
 
+/**
+ * Initializes the wrapper and statistics for the sleep function.
+ */
 void init_sleep();
+
+/**
+ * Cleans the wrapper for the sleep function.
+ */
 void clean_sleep();
+
+/**
+ * Resets the statistics for the sleep function.
+ */
 void resetstats_sleep();
 
+#endif // __WRAP_SLEEP_H_
+
diff --git a/student/Makefile b/student/Makefile
index 4cc66a2..636783f 100644
--- a/student/Makefile
+++ b/student/Makefile
@@ -1,10 +1,28 @@
+# Makefile for tasks using CTester
 CC=gcc
+CPP=cppcheck
 EXEC=tests
+CPPFLAGS=--error-exitcode=1
 LDFLAGS=-lcunit -lm -lpthread -ldl -rdynamic
-SRC=$(wildcard *.c) CTester/wrap_mutex.c CTester/wrap_malloc.c CTester/wrap_file.c CTester/wrap_sleep.c CTester/CTester.c CTester/trap.c
+SRC=$(sort $(wildcard *.c)) $(sort $(wildcard CTester/*.c))
 OBJ=$(SRC:.c=.o)
-CFLAGS=-Wall -Werror -DC99 -std=gnu99 -ICTester
-WRAP=-Wl,-wrap=pthread_mutex_lock -Wl,-wrap=pthread_mutex_unlock -Wl,-wrap=pthread_mutex_trylock -Wl,-wrap=pthread_mutex_init -Wl,-wrap=pthread_mutex_destroy -Wl,-wrap=malloc -Wl,-wrap=free -Wl,-wrap=realloc -Wl,-wrap=calloc -Wl,-wrap=open -Wl,-wrap=creat -Wl,-wrap=close -Wl,-wrap=read -Wl,-wrap=write -Wl,-wrap=stat -Wl,-wrap=fstat -Wl,-wrap=lseek -Wl,-wrap=exit -Wl,-wrap=sleep
+CFLAGS = -Wall -Werror -Wextra -Wshadow
+CFLAGS += -std=gnu99
+#CFLAGS += -DC99
+CFLAGS += -ICTester # to include the folder.
+DEBUGFLAGS = -g -Wno-unused-variable -Wno-unused-parameter
+OTHERFLAGS = -fstack-protector-all -D_FORTIFY_SOURCE=2 -fno-omit-frame-pointer
+#CFLAGS += $(DEBUGFLAGS) # Uncomment to activate
+#CFLAGS += $(OTHERFLAGS) # Uncomment to activate
+WRAP += -Wl,-wrap=exit
+WRAP += -Wl,-wrap=open -Wl,-wrap=creat -Wl,-wrap=close -Wl,-wrap=read -Wl,-wrap=write -Wl,-wrap=stat -Wl,-wrap=fstat -Wl,-wrap=lseek
+WRAP += -Wl,-wrap=getpid
+WRAP += -Wl,-wrap=malloc -Wl,-wrap=free -Wl,-wrap=realloc -Wl,-wrap=calloc
+WRAP += -Wl,-wrap=pthread_mutex_lock -Wl,-wrap=pthread_mutex_unlock -Wl,-wrap=pthread_mutex_trylock -Wl,-wrap=pthread_mutex_init -Wl,-wrap=pthread_mutex_destroy
+WRAP += -Wl,-wrap=getaddrinfo -Wl,-wrap=getnameinfo -Wl,-wrap=freeaddrinfo -Wl,-wrap=gai_strerror
+WRAP += -Wl,-wrap=accept -Wl,-wrap=bind -Wl,-wrap=connect -Wl,-wrap=listen -Wl,-wrap=poll -Wl,-wrap=recv -Wl,-wrap=recvfrom -Wl,-wrap=recvmsg -Wl,-wrap=select -Wl,-wrap=send -Wl,-wrap=sendto -Wl,-wrap=sendmsg -Wl,-wrap=shutdown -Wl,-wrap=socket
+WRAP += -Wl,-wrap=htons -Wl,-wrap=ntohs -Wl,-wrap=htonl -Wl,-wrap=ntohl
+WRAP += -Wl,-wrap=sleep
 
 all: $(EXEC)
 
@@ -12,7 +30,7 @@ all: $(EXEC)
 	$(CC) $(CFLAGS) -c -o $@ $< 
 
 $(EXEC): $(OBJ)
-	$(CC) $(WRAP) -o $@ $(OBJ) $(LDFLAGS)
+	$(CC) $(CFLAGS) $(WRAP) -o $@ $(OBJ) $(LDFLAGS)
 
 create-po:
 	mkdir -p po/fr/
@@ -28,8 +46,17 @@ compile-mo:
 	mkdir -p fr/LC_MESSAGES/
 	cp po/fr/tests.mo fr/LC_MESSAGES/tests.mo
 
+check: $(SRC)
+	$(CPP) $(CPPFLAGS) $<
+
 clean:
 	rm -f $(EXEC) $(OBJ)
 
+#clr-aux:
+#	rm -f $(INC) $(ASM)
+
+rebuild: clean all
+
+
 .PHONY: tests
 
diff --git a/student/student_code.h b/student/student_code.h
index 3ccead1..9d10929 100644
--- a/student/student_code.h
+++ b/student/student_code.h
@@ -1 +1,5 @@
+/*
+ * This function should return 0 in all cases.
+ */
+
 int myfunc(int myargs);