dlt-daemon: Implement epoll based event handling

The event handling has been reworked in order to use epoll and
restructure the code.
There are 2 new structures.
The DltConnection which contains all basic connection information, like
the type, the file descriptor, and the receiver structure corresponding.
The DltEventHandler that manages the DltConnections and the associated
events.

The concept is basically the following. The daemon will create different
connections, serial connections, socket connections, fifos etc ... Each of
them will then register itself to the event handler, and give it the
ownership of this connection. From this point in time, the daemon can act
on the connections.
Once an event is triggered, the event handler will call the connection
specific callback, creates new connections when clients arrives,
and potentially destroy the connection in case of hangup.
On exit, the daemon cleanup the event handler, which leads to the
destruction of the connections.

The work there is a first step for a global restructuring. Several
modification will follow, in order to rationalize the different daemon
structures, and avoid variable and code duplication.

Signed-off-by: Frederic Berat <fberat@de.adit-jv.com>

1 files changed, 374 insertions, 0 deletions

diff --git a/src/daemon/dlt_daemon_connection.c b/src/daemon/dlt_daemon_connection.c
new file mode 100644
index 0000000..0eee668
--- /dev/null
+++ b/src/daemon/dlt_daemon_connection.c
@@ -0,0 +1,374 @@
+/*
+ * @licence app begin@
+ * SPDX license identifier: MPL-2.0
+ *
+ * Copyright (C) 2015 Advanced Driver Information Technology.
+ * This code is developed by Advanced Driver Information Technology.
+ * Copyright of Advanced Driver Information Technology, Bosch and DENSO.
+ *
+ * This file is part of GENIVI Project DLT - Diagnostic Log and Trace.
+ *
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License (MPL), v. 2.0.
+ * If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * For further information see http://www.genivi.org/.
+ * @licence end@
+ */
+
+/*!
+ * \author
+ * Frederic Berat <fberat@de.adit-jv.com>
+ *
+ * \copyright Copyright © 2015 Advanced Driver Information Technology. \n
+ * License MPL-2.0: Mozilla Public License version 2.0 http://mozilla.org/MPL/2.0/.
+ *
+ * \file dlt_daemon_connection.c
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <sys/socket.h>
+#include <sys/syslog.h>
+#include <sys/types.h>
+
+#include "dlt_daemon_connection_types.h"
+#include "dlt_daemon_connection.h"
+#include "dlt_daemon_event_handler_types.h"
+#include "dlt_daemon_event_handler.h"
+#include "dlt-daemon.h"
+#include "dlt-daemon_cfg.h"
+#include "dlt_daemon_common.h"
+#include "dlt_common.h"
+
+/** @brief Generic sending function.
+ *
+ * We manage different type of connection which have similar send/write
+ * functions. We can then abstract the data transfer using this function,
+ * moreover as we often transfer data to different kind of connection
+ * within the same loop.
+ *
+ * @param conn The connection structure.
+ * @param msg The message buffer to be sent
+ * @param msg_size The length of the message to be sent
+ *
+ * @return The amount of bytes send on success, -1 otherwise.
+ *         errno is appropriately set.
+ */
+static int dlt_connection_send(DltConnection *conn,
+                              void *msg,
+                              size_t msg_size)
+{
+    DltConnectionType type = DLT_CONNECTION_TYPE_MAX;
+
+    if (conn != NULL)
+    {
+        type = conn->type;
+    }
+
+    switch (type)
+    {
+    case DLT_CONNECTION_CLIENT_MSG_SERIAL:
+        return write(conn->fd, msg, msg_size);
+    case DLT_CONNECTION_CLIENT_MSG_TCP:
+        return send(conn->fd, msg, msg_size, 0);
+    default:
+        return -1;
+    }
+}
+
+/** @brief Send up to two messages through a connection.
+ *
+ * We often need to send 2 messages through a specific connection, plus
+ * the serial header. This function groups these different calls.
+ *
+ * @param con The connection to send the messages through.
+ * @param data1 The first message to be sent.
+ * @param size1 The size of the first message.
+ * @param data2 The second message to be send.
+ * @param size2 The second message size.
+ * @param sendserialheader Whether we need or not to send the serial header.
+ *
+ * @return DLT_DAEMON_ERROR_OK on success, -1 otherwise. errno is properly set.
+ */
+int dlt_connection_send_multiple(DltConnection *con,
+                                void *data1,
+                                int size1,
+                                void *data2,
+                                int size2,
+                                int sendserialheader)
+{
+    int ret = 0;
+
+    if (con == NULL)
+    {
+        return -1;
+    }
+
+    if (sendserialheader)
+    {
+        ret = dlt_connection_send(con,
+                                 (void *)dltSerialHeader,
+                                 sizeof(dltSerialHeader));
+    }
+
+    if ((data1 != NULL) && (ret >= 0))
+    {
+        ret = dlt_connection_send(con, data1, size1);
+    }
+
+    if ((data2 != NULL) && (ret >= 0))
+    {
+        ret = dlt_connection_send(con, data2, size2);
+    }
+
+    if (ret >=0)
+    {
+        ret = DLT_DAEMON_ERROR_OK;
+    }
+
+    return ret;
+}
+
+/** @brief Get the next connection filtered with a type mask.
+ *
+ * In some cases we need the next connection available of a specific type or
+ * specific different types. This function returns the next available connection
+ * that is of one of the types included in the mask. The current connection can
+ * be returned.
+ *
+ * @param current The current connection pointer.
+ * @param type_mask A bit mask representing the connection types to be filtered.
+ *
+ * @return The next available connection of the considered types or NULL.
+ */
+DltConnection *dlt_connection_get_next(DltConnection *current, int type_mask)
+{
+    while (current && !((1 << current->type) & type_mask))
+    {
+        current = current->next;
+    }
+
+    return current;
+}
+
+/** @brief Get the receiver structure associated to a connection.
+ *
+ * The receiver structure is sometimes needed while handling the event.
+ * This behavior is mainly due to the fact that it's not intended to modify
+ * the whole design of the daemon while implementing the new event handling.
+ * Based on the connection type provided, this function returns the pointer
+ * to the DltReceiver structure corresponding.
+ *
+ * @param dameon_local Structure where to take the DltReceiver pointer from.
+ * @param type Type of the connection.
+ *
+ * @return DltReceiver structure or NULL if none corresponds to the type.
+ */
+static DltReceiver *dlt_connection_get_receiver(DltDaemonLocal *daemon_local,
+                                               DltConnectionType type)
+{
+    DltReceiver *ret = NULL;
+
+    switch (type)
+    {
+    case DLT_CONNECTION_CLIENT_CONNECT:
+    /* FALL THROUGH */
+    /* There must be the same structure for this case */
+    case DLT_CONNECTION_CLIENT_MSG_TCP:
+        ret = &daemon_local->receiverSock;
+        break;
+    case DLT_CONNECTION_CLIENT_MSG_SERIAL:
+        ret = &daemon_local->receiverSerial;
+        break;
+    case DLT_CONNECTION_APP_MSG:
+        ret = &daemon_local->receiver;
+        break;
+    case DLT_CONNECTION_ONE_S_TIMER:
+        ret = &daemon_local->timer_one_s;
+        break;
+    case DLT_CONNECTION_SIXTY_S_TIMER:
+        ret = &daemon_local->timer_sixty_s;
+        break;
+#ifdef DLT_SYSTEMD_WATCHDOG_ENABLE
+    case DLT_CONNECTION_SYSTEMD_TIMER:
+        ret = &daemon_local->timer_wd;
+        break;
+#endif
+    default:
+        ret = NULL;
+    }
+
+    return ret;
+}
+
+/** @brief Get the callback from a specific connection.
+ *
+ * The callback retrieved that way is used to handle event for this connection.
+ * It as been chosen to proceed that way instead of having the callback directly
+ * in the structure in order to have some way to check that the structure is
+ * still valid, or at least gracefully handle errors instead of crashing.
+ *
+ * @param con The connection to retrieve the callback from.
+ *
+ * @return Function pointer or NULL.
+ */
+void *dlt_connection_get_callback(DltConnection *con)
+{
+    void *ret = NULL;
+    DltConnectionType type = DLT_CONNECTION_TYPE_MAX;
+
+    if (con)
+    {
+        type = con->type;
+    }
+
+    switch (type)
+    {
+    case DLT_CONNECTION_CLIENT_CONNECT:
+        ret = dlt_daemon_process_client_connect;
+        break;
+    case DLT_CONNECTION_CLIENT_MSG_TCP:
+        ret = dlt_daemon_process_client_messages;
+        break;
+    case DLT_CONNECTION_CLIENT_MSG_SERIAL:
+        ret = dlt_daemon_process_client_messages_serial;
+        break;
+    case DLT_CONNECTION_APP_MSG:
+        ret = dlt_daemon_process_user_messages;
+        break;
+    case DLT_CONNECTION_ONE_S_TIMER:
+        ret = dlt_daemon_process_one_s_timer;
+        break;
+    case DLT_CONNECTION_SIXTY_S_TIMER:
+        ret = dlt_daemon_process_sixty_s_timer;
+        break;
+#ifdef DLT_SYSTEMD_WATCHDOG_ENABLE
+    case DLT_CONNECTION_SYSTEMD_TIMER:
+        ret = dlt_daemon_process_systemd_timer;
+        break;
+#endif
+    default:
+        ret = NULL;
+    }
+
+    return ret;
+}
+
+/** @brief Destroys a connection.
+ *
+ * This function closes and frees the corresponding connection. This is expected
+ * to be called by the connection owner: the DltEventHandler.
+ * Ownership of the connection is given during the registration to
+ * the DltEventHandler.
+ *
+ * @param to_destroy Connection to be destroyed.
+ */
+void dlt_connection_destroy(DltConnection *to_destroy)
+{
+    close(to_destroy->fd);
+    free(to_destroy);
+}
+
+/** @brief Creates a connection and registers it to the DltEventHandler.
+ *
+ * The function will allocate memory for the connection, and give the pointer
+ * to the DltEventHandler in order to register it for incoming events.
+ * The connection is then destroyed later on, once it's not needed anymore or
+ * it the event handler is destroyed.
+ *
+ * @param daemon_local Structure were some needed information is.
+ * @param evh DltEventHandler to register the connection to.
+ * @param fd File descriptor of the connection.
+ * @param mask Event list bit mask.
+ * @param type Connection type.
+ *
+ * @return 0 On success, -1 otherwise.
+ */
+int dlt_connection_create(DltDaemonLocal *daemon_local,
+                         DltEventHandler *evh,
+                         int fd,
+                         int mask,
+                         DltConnectionType type)
+{
+    DltConnection *temp = NULL;
+
+    if (dlt_event_handler_find_connection(evh, fd) != NULL)
+    {
+        /* No need for the same client to be registered twice
+         * for the same event.
+         * TODO: If another mask can be expected,
+         * we need it to update the epoll event here.
+         */
+        return 0;
+    }
+
+    temp = (DltConnection *)malloc(sizeof(DltConnection));
+
+    if (temp == NULL)
+    {
+        dlt_log(LOG_CRIT, "Allocation of client handle failed\n");
+        return -1;
+    }
+
+    memset(temp, 0, sizeof(DltConnection));
+
+    temp->fd = fd;
+    temp->type = type;
+    temp->receiver = dlt_connection_get_receiver(daemon_local, type);
+
+    /* Now give the ownership of the newly created connection
+     * to the event handler, by registering for events.
+     */
+    return dlt_event_handler_register_connection(evh, daemon_local, temp, mask);
+}
+
+/** @brief Creates connection from all types.
+ *
+ * This functions run through all connection types and tries to register
+ * on the event handler the one that were not already registered.
+ *
+ * @param daemon_local Structure to retrieve information from.
+ *
+ * @return 0 on success, -1 if a failure occurs.
+ */
+int dlt_connection_create_remaining(DltDaemonLocal *daemon_local)
+{
+    DltConnectionType i = 0;
+    DltEventHandler *ev = &daemon_local->pEvent;
+    char local_str[DLT_DAEMON_TEXTBUFSIZE];
+
+    for (i = 0 ; i < DLT_CONNECTION_TYPE_MAX ; i++)
+    {
+        int fd = 0;
+        DltReceiver *rec = dlt_connection_get_receiver(daemon_local, i);
+
+        if (rec == NULL)
+        {
+            /* We are not interested if there is no receiver available */
+            continue;
+        }
+
+        fd = rec->fd;
+
+        /* Already created connections are ignored here */
+        if ((fd > 0) && dlt_connection_create(daemon_local, ev, fd, EPOLLIN, i))
+        {
+            snprintf(local_str,
+                     DLT_DAEMON_TEXTBUFSIZE,
+                     "Unable to register type %i event handler.\n",
+                     i);
+
+            dlt_log(LOG_ERR, local_str);
+
+            return -1;
+        }
+    }
+
+    return 0;
+}