Leon Dietrich
--- a/src/mumta/evloop.cpp
+++ b/src/mumta/evloop.cpp
 void rmrf::ev::loop() {
    ::ev::default_loop defloop;

    auto w = std::make_shared<stdin_waiter>();
--- a/src/mumta/evloop.cpp
+++ b/src/mumta/evloop.cpp

    defloop.run(0);
 }
+
+void stop_default_loop_cb(EV_P_ ev_async*, int) {
+    ::ev::loop_ref defloop = ::ev::get_default_loop();
+    defloop.break_loop();
+}
+
+void rmrf::ev::stop() {
+    ::ev::loop_ref defloop = ::ev::get_default_loop();
+    // We need to use the C API directly as ev++ does not yet support asynchrounous events
+    ev_async stop_event;
+    ev_async_init(&stop_event, stop_default_loop_cb);
+    ev_async_start(defloop, &stop_event);
+    ev_async_send(defloop, &stop_event);
--- a/src/net/async_fd.hpp
+++ b/src/net/async_fd.hpp

 namespace rmrf::net {

+    /**
+     * @class null_fd
+     * @author leondietrich
+     * @date 07/08/21
--- a/src/net/async_fd.hpp
+++ b/src/net/async_fd.hpp
        constexpr operator int() const { return -1; }
    };

+    /**
+     * Instantiate a null FD.
+     */
    constexpr null_fd nullfd{};

+    /**
+     * Automatic file descriptor. This class wraps raw file descriptors and handles their
+     * life time.
+     * @class auto_fd
+     * @author leondietrich
+     * @date 07/08/21
--- a/src/net/async_fd.hpp
+++ b/src/net/async_fd.hpp
            return r;
        }

-        // Close an open file descriptor. Reset the descriptor to -1.
+        /**
+         * Use this method in order to manually close the resource associated with this file descriptor.
+         * After this method was executed this file descriptor is invalid. Further calls to this method
+         * won't do anything.
-         * won't do anything.
+         * will do anything.
-         * won't do anything.
+         * will do nothing.
--- a/src/net/async_server.hpp
+++ b/src/net/async_server.hpp

 namespace rmrf::net {

+    /**
+     * This class handles raw server sockets and wrapps them with automatic
+     * resource management functions. This class is an internal helper class
+     * utilized by classes like the TCP Server and thus shouldn't be used directly.
+     * @class async_server_socket
+     * @author leondietrich
+     * @date 14/07/21
+     * @file async_server.hpp
+     * @brief An asynchronous server socket handler.
+     * @see rmrf::net::tcp_server_socket
+     */
 class async_server_socket : public std::enable_shared_from_this<async_server_socket> {
--- a/src/net/async_server.hpp
+++ b/src/net/async_server.hpp
    ::ev::io io;

 public:
+
+    /**
+      * This constructor accepts your given file descriptor to the operating systems socket.
+      * @param fd A handle to the socket in form of an auto_fd
+      */
    async_server_socket(auto_fd &&fd);
+    
+    /**
+     * This deconstructor automatically unregisteres the socket from libev which in turn automatically removes it from
+     * the watch list of active sockets. However this does not close the socket in the kernels perspective so you must
+     * use always auto_fd.
--- a/src/net/async_server.hpp
+++ b/src/net/async_server.hpp
+     * the watch list of active sockets. However this does not close the socket in the kernels perspective so you must
+     * use always auto_fd.
+     * @brief Automatically unregister the socket from libev
+     */
    ~async_server_socket();

-	accept_handler_type get_accept_handler() const;
-	void set_accept_handler(const accept_handler_type &value);
+    /**
+     * This method will return the currently used connection acceptance handler.
+     * Be aware that it will return an invalid state unless you used set_accept_handler
+     * prior to calling this method.
+     * @brief get the current registered accept handler
+     * @return The current accept handler
+     */
+	inline accept_handler_type get_accept_handler() const {
--- a/src/net/async_server.hpp
+++ b/src/net/async_server.hpp
+     * prior to calling this method.
+     * @brief get the current registered accept handler
+     * @return The current accept handler
+     */
+	inline accept_handler_type get_accept_handler() const {
+        return on_accept;
+    }
+    
+    /**
+     * Use this method in order to set a new incomming socket acceptance handler.
+     * It's best to call this method right after the constructor call of this class.
+     * @brief Set a new acceptance handler
+     * @param value The new handler to set
+     */
+	inline void set_accept_handler(
+            const accept_handler_type& value) {
-	inline void set_accept_handler(
-            const accept_handler_type& value) {
+    inline void set_accept_handler(const accept_handler_type& value) {
--- a/src/net/connection_client.hpp
+++ b/src/net/connection_client.hpp
 public:
+
+    /**
+      * This function type accepts a reference to the incomming data string which it may not alter
+      * and may not return any data.
+      */
 	typedef std::function<void(const std::string&)> incomming_data_cb;
 protected:
 	incomming_data_cb in_data_cb;
 public:
-	connection_client();
+	connection_client() : in_data_cb{} {};

 	/**
 	 * Use this method to send data to the other endpoint.
+     * @param data The data to send
--- a/src/net/connection_line_buffer.cpp
+++ b/src/net/connection_line_buffer.cpp
 *  Created on: 05.01.2021
 *      Author: doralitze
 */
-
+ 
 #include "net/connection_line_buffer.hpp"

 namespace rmrf::net {

-static std::string::size_type default_eol_search(const std::string& data, std::string::size_type start_position) {
+std::string::size_type default_eol_search(const std::string& data, std::string::size_type start_position) {
--- a/src/net/connection_line_buffer.cpp
+++ b/src/net/connection_line_buffer.cpp
 		client(c),
 		found_next_line_cb(found_next_line_cb_),
 		max(max_line_size),
-		data("") {
-	this->client->set_incomming_data_callback(std::bind(&connection_line_buffer::conn_data_in_cb, this, std::placeholders::_1));
+		data_buffer(std::ostringstream::ate),
+        buffer_length{0} {
+	this->client->set_incomming_data_callback(
+		[this](const std::string& data_in) {
+			conn_data_in_cb(data_in);
+		});