LCOV - code coverage report
Current view: top level - daemon - dlt-daemon.c (source / functions) Hit Total Coverage
Test: dlt_final_coverage.info Lines: 606 1152 52.6 %
Date: 2024-10-22 04:07:23 Functions: 31 42 73.8 %

          Line data    Source code
       1             : /*
       2             :  * SPDX license identifier: MPL-2.0
       3             :  *
       4             :  * Copyright (C) 2011-2015, BMW AG
       5             :  *
       6             :  * This file is part of COVESA Project DLT - Diagnostic Log and Trace.
       7             :  *
       8             :  * This Source Code Form is subject to the terms of the
       9             :  * Mozilla Public License (MPL), v. 2.0.
      10             :  * If a copy of the MPL was not distributed with this file,
      11             :  * You can obtain one at http://mozilla.org/MPL/2.0/.
      12             :  *
      13             :  * For further information see http://www.covesa.org/.
      14             :  */
      15             : 
      16             : /*!
      17             :  * \author
      18             :  * Alexander Wenzel <alexander.aw.wenzel@bmw.de>
      19             :  * Markus Klein <Markus.Klein@esk.fraunhofer.de>
      20             :  * Mikko Rapeli <mikko.rapeli@bmw.de>
      21             :  *
      22             :  * \copyright Copyright © 2011-2015 BMW AG. \n
      23             :  * License MPL-2.0: Mozilla Public License version 2.0 http://mozilla.org/MPL/2.0/.
      24             :  *
      25             :  * \file dlt-daemon.c
      26             :  */
      27             : 
      28             : #include <netdb.h>
      29             : #include <ctype.h>
      30             : #include <stdio.h>      /* for printf() and fprintf() */
      31             : #include <sys/socket.h> /* for socket(), connect(), (), and recv() */
      32             : #include <sys/un.h>
      33             : #include <arpa/inet.h>  /* for sockaddr_in and inet_addr() */
      34             : #include <stdlib.h>     /* for atoi() and exit() */
      35             : #include <string.h>     /* for memset() */
      36             : #include <unistd.h>     /* for close() and access */
      37             : #include <fcntl.h>
      38             : #include <signal.h>
      39             : #include <syslog.h>
      40             : #include <errno.h>
      41             : #include <pthread.h>
      42             : #include <grp.h>
      43             : 
      44             : #ifdef linux
      45             : #   include <sys/timerfd.h>
      46             : #endif
      47             : #include <sys/stat.h>
      48             : #include <sys/time.h>
      49             : #include <libgen.h>
      50             : 
      51             : #if defined(linux) && defined(__NR_statx)
      52             : #   include <linux/stat.h>
      53             : #endif
      54             : 
      55             : #ifdef DLT_DAEMON_VSOCK_IPC_ENABLE
      56             : #   ifdef linux
      57             : #       include <linux/vm_sockets.h>
      58             : #   endif
      59             : #   ifdef __QNX__
      60             : #       include <vm_sockets.h>
      61             : #   endif
      62             : #endif
      63             : 
      64             : #include "dlt_types.h"
      65             : #include "dlt-daemon.h"
      66             : #include "dlt-daemon_cfg.h"
      67             : #include "dlt_daemon_common_cfg.h"
      68             : 
      69             : #include "dlt_daemon_socket.h"
      70             : #include "dlt_daemon_unix_socket.h"
      71             : #include "dlt_daemon_serial.h"
      72             : 
      73             : #include "dlt_daemon_client.h"
      74             : #include "dlt_daemon_connection.h"
      75             : #include "dlt_daemon_event_handler.h"
      76             : #include "dlt_daemon_offline_logstorage.h"
      77             : #include "dlt_gateway.h"
      78             : 
      79             : #ifdef UDP_CONNECTION_SUPPORT
      80             : #   include "dlt_daemon_udp_socket.h"
      81             : #endif
      82             : #if defined(DLT_SYSTEMD_WATCHDOG_ENABLE) || defined(DLT_SYSTEMD_ENABLE)
      83             : #   include "sd-daemon.h"
      84             : #endif
      85             : 
      86             : /**
      87             :  * \defgroup daemon DLT Daemon
      88             :  * \addtogroup daemon
      89             :  \{
      90             :  */
      91             : 
      92             : #define DLT_DAEMON_APP_ID "DLTD"
      93             : #define DLT_DAEMON_CTX_ID "INTM"
      94             : 
      95             : 
      96             : static int dlt_daemon_log_internal(DltDaemon *daemon,
      97             :                                    DltDaemonLocal *daemon_local, char *str,
      98             :                                    DltLogLevelType level, const char *app_id,
      99             :                                    const char *ctx_id, int verbose);
     100             : 
     101             : static int dlt_daemon_check_numeric_setting(char *token,
     102             :                                             char *value,
     103             :                                             unsigned long *data);
     104             : 
     105             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
     106             : 
     107             : struct DltTraceLoadLogParams {
     108             :     DltDaemon *daemon;
     109             :     DltDaemonLocal *daemon_local;
     110             :     int verbose;
     111             :     char *app_id;
     112             : };
     113             : 
     114             : static DltReturnValue dlt_daemon_output_internal_msg(DltLogLevelType loglevel, const char *text, void *params);
     115             : 
     116             : pthread_rwlock_t trace_load_rw_lock;
     117             : #endif
     118             : 
     119             : /* used in main event loop and signal handler */
     120             : int g_exit = 0;
     121             : 
     122             : int g_signo = 0;
     123             : 
     124             : /* used for value from conf file */
     125             : static int value_length = 1024;
     126             : 
     127             : static char dlt_timer_conn_types[DLT_TIMER_UNKNOWN + 1] = {
     128             :     [DLT_TIMER_PACKET] = DLT_CONNECTION_ONE_S_TIMER,
     129             :     [DLT_TIMER_ECU] = DLT_CONNECTION_SIXTY_S_TIMER,
     130             : #ifdef DLT_SYSTEMD_WATCHDOG_ENABLE
     131             :     [DLT_TIMER_SYSTEMD] = DLT_CONNECTION_SYSTEMD_TIMER,
     132             : #endif
     133             :     [DLT_TIMER_GATEWAY] = DLT_CONNECTION_GATEWAY_TIMER,
     134             :     [DLT_TIMER_UNKNOWN] = DLT_CONNECTION_TYPE_MAX
     135             : };
     136             : 
     137             : static char dlt_timer_names[DLT_TIMER_UNKNOWN + 1][32] = {
     138             :     [DLT_TIMER_PACKET] = "Timing packet",
     139             :     [DLT_TIMER_ECU] = "ECU version",
     140             : #ifdef DLT_SYSTEMD_WATCHDOG_ENABLE
     141             :     [DLT_TIMER_SYSTEMD] = "Systemd watchdog",
     142             : #endif
     143             :     [DLT_TIMER_GATEWAY] = "Gateway",
     144             :     [DLT_TIMER_UNKNOWN] = "Unknown timer"
     145             : };
     146             : 
     147             : #ifdef __QNX__
     148             : static int dlt_timer_pipes[DLT_TIMER_UNKNOWN][2] = {
     149             :     /* [timer_id] = {read_pipe, write_pipe} */
     150             :     [DLT_TIMER_PACKET] = {DLT_FD_INIT, DLT_FD_INIT},
     151             :     [DLT_TIMER_ECU] = {DLT_FD_INIT, DLT_FD_INIT},
     152             : #ifdef DLT_SYSTEMD_WATCHDOG_ENABLE
     153             :     [DLT_TIMER_SYSTEMD] = {DLT_FD_INIT, DLT_FD_INIT},
     154             : #endif
     155             :     [DLT_TIMER_GATEWAY] = {DLT_FD_INIT, DLT_FD_INIT}
     156             : };
     157             : 
     158             : static pthread_t timer_threads[DLT_TIMER_UNKNOWN] = {
     159             :     [DLT_TIMER_PACKET] = 0,
     160             :     [DLT_TIMER_ECU] = 0,
     161             : #ifdef DLT_SYSTEMD_WATCHDOG_ENABLE
     162             :     [DLT_TIMER_SYSTEMD] = 0,
     163             : #endif
     164             :     [DLT_TIMER_GATEWAY] = 0
     165             : };
     166             : 
     167             : static DltDaemonPeriodicData *timer_data[DLT_TIMER_UNKNOWN] = {
     168             :     [DLT_TIMER_PACKET] = NULL,
     169             :     [DLT_TIMER_ECU] = NULL,
     170             : #ifdef DLT_SYSTEMD_WATCHDOG_ENABLE
     171             :     [DLT_TIMER_SYSTEMD] = NULL,
     172             : #endif
     173             :     [DLT_TIMER_GATEWAY] = NULL
     174             : };
     175             : 
     176             : void close_pipes(int fds[2])
     177             : {
     178             :     if (fds[0] > 0) {
     179             :         close(fds[0]);
     180             :         fds[0] = DLT_FD_INIT;
     181             :     }
     182             : 
     183             :     if (fds[1] > 0) {
     184             :         close(fds[1]);
     185             :         fds[1] = DLT_FD_INIT;
     186             :     }
     187             : }
     188             : 
     189             : #endif // __QNX__
     190             : 
     191             : /**
     192             :  * Print usage information of tool.
     193             :  */
     194           0 : void usage()
     195             : {
     196             :     char version[DLT_DAEMON_TEXTBUFSIZE];
     197           0 :     dlt_get_version(version, DLT_DAEMON_TEXTBUFSIZE);
     198             : 
     199             :     /*printf("DLT logging daemon %s %s\n", _DLT_PACKAGE_VERSION, _DLT_PACKAGE_VERSION_STATE); */
     200             :     /*printf("Compile options: %s %s %s %s",_DLT_SYSTEMD_ENABLE, _DLT_SYSTEMD_WATCHDOG_ENABLE, _DLT_TEST_ENABLE, _DLT_SHM_ENABLE); */
     201             :     printf("%s", version);
     202             :     printf("Usage: dlt-daemon [options]\n");
     203             :     printf("Options:\n");
     204             :     printf("  -d            Daemonize\n");
     205             :     printf("  -h            Usage\n");
     206             :     printf("  -c filename   DLT daemon configuration file (Default: " CONFIGURATION_FILES_DIR "/dlt.conf)\n");
     207             : 
     208             : #ifdef DLT_DAEMON_USE_FIFO_IPC
     209             :     printf("  -t directory  Directory for local fifo and user-pipes (Default: /tmp)\n");
     210             :     printf("                (Applications wanting to connect to a daemon using a\n");
     211             :     printf("                custom directory need to be started with the environment \n");
     212             :     printf("                variable DLT_PIPE_DIR set appropriately)\n");
     213             : #endif
     214             : 
     215             : #ifdef DLT_SHM_ENABLE
     216             :     printf("  -s filename   The file name to create the share memory (Default: /dlt-shm)\n");
     217             :     printf("                (Applications wanting to connect to a daemon using a\n");
     218             :     printf("                custom shm name need to be started with the environment \n");
     219             :     printf("                variable DLT_SHM_NAME set appropriately)\n");
     220             : #endif
     221             :     printf("  -p port       port to monitor for incoming requests (Default: 3490)\n");
     222             :     printf("                (Applications wanting to connect to a daemon using a custom\n");
     223             :     printf("                port need to be started with the environment variable\n");
     224             :     printf("                DLT_DAEMON_TCP_PORT set appropriately)\n");
     225             : #ifdef DLT_LOG_LEVEL_APP_CONFIG
     226             :     printf("  -a filename   The filename for load default app id log levels (Default: " CONFIGURATION_FILES_DIR "/dlt-log-levels.conf)\n");
     227             : #endif
     228             : 
     229             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
     230             :     printf("  -l filename   The filename for load limits (Default: " CONFIGURATION_FILES_DIR "/dlt-trace-load.conf)\n");
     231             : #endif
     232             : 
     233             : #
     234           0 : } /* usage() */
     235             : 
     236             : /**
     237             :  * Option handling
     238             :  */
     239           9 : int option_handling(DltDaemonLocal *daemon_local, int argc, char *argv[])
     240             : {
     241             :     int c;
     242             :     char options[255];
     243             :     memset(options, 0, sizeof options);
     244             :     const char *const default_options = "hdc:t:p:";
     245             :     strcpy(options, default_options);
     246             : 
     247           9 :     if (daemon_local == 0) {
     248           0 :         fprintf (stderr, "Invalid parameter passed to option_handling()\n");
     249           0 :         return -1;
     250             :     }
     251             : 
     252             :     /* Initialize flags */
     253             :     memset(daemon_local, 0, sizeof(DltDaemonLocal));
     254             : 
     255             :     /* default values */
     256           9 :     daemon_local->flags.port = DLT_DAEMON_TCP_PORT;
     257             : 
     258             : #ifdef DLT_DAEMON_USE_FIFO_IPC
     259           9 :     dlt_log_set_fifo_basedir(DLT_USER_IPC_PATH);
     260             : #endif
     261             : 
     262             : #ifdef DLT_SHM_ENABLE
     263             :     strncpy(dltShmName, "/dlt-shm", NAME_MAX);
     264             : #endif
     265             : 
     266           9 :     opterr = 0;
     267             : 
     268             : #ifdef DLT_SHM_ENABLE
     269             :     strcpy(options + strlen(options), "s:");
     270             : #endif
     271             : #ifdef DLT_LOG_LEVEL_APP_CONFIG
     272             :     strcpy(options + strlen(options), "a:");
     273             : #endif
     274             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
     275             :     strcpy(options + strlen(options), "l:");
     276             : #endif
     277          20 :     while ((c = getopt(argc, argv, options)) != -1)
     278          11 :         switch (c) {
     279           2 :         case 'd':
     280             :         {
     281           2 :             daemon_local->flags.dflag = 1;
     282           2 :             break;
     283             :         }
     284           8 :         case 'c':
     285             :         {
     286           8 :             strncpy(daemon_local->flags.cvalue, optarg, NAME_MAX);
     287             :             break;
     288             :         }
     289             : #ifdef DLT_LOG_LEVEL_APP_CONFIG
     290             :         case 'a':
     291             :         {
     292             :             strncpy(daemon_local->flags.avalue, optarg, NAME_MAX);
     293             :             break;
     294             :         }
     295             : #endif
     296             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
     297             :         case 'l':
     298             :         {
     299             :             strncpy(daemon_local->flags.lvalue, optarg, NAME_MAX);
     300             :             break;
     301             :         }
     302             : #endif
     303             : #ifdef DLT_DAEMON_USE_FIFO_IPC
     304           0 :         case 't':
     305             :         {
     306           0 :             dlt_log_set_fifo_basedir(optarg);
     307           0 :             break;
     308             :         }
     309             : #endif
     310             : 
     311             : #ifdef DLT_SHM_ENABLE
     312             :         case 's':
     313             :         {
     314             :             strncpy(dltShmName, optarg, NAME_MAX);
     315             :             break;
     316             :         }
     317             : #endif
     318           1 :         case 'p':
     319             :         {
     320           1 :             daemon_local->flags.port = (unsigned int) atoi(optarg);
     321             : 
     322           1 :             if (daemon_local->flags.port == 0) {
     323           0 :                 fprintf (stderr, "Invalid port `%s' specified.\n", optarg);
     324           0 :                 return -1;
     325             :             }
     326             : 
     327             :             break;
     328             :         }
     329           0 :         case 'h':
     330             :         {
     331           0 :             usage();
     332           0 :             return -2; /* return no error */
     333             :         }
     334             : 
     335           0 :         case '?':
     336             :         {
     337           0 :             if ((optopt == 'c') || (optopt == 't') || (optopt == 'p')
     338             :     #ifdef DLT_LOG_LEVEL_APP_CONFIG
     339             :                   || (optopt == 'a')
     340             :     #endif
     341             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
     342             :                 || (optopt == 'l')
     343             : #endif
     344             :           )
     345           0 :                 fprintf (stderr, "Option -%c requires an argument.\n", optopt);
     346           0 :             else if (isprint (optopt))
     347           0 :                 fprintf (stderr, "Unknown option `-%c'.\n", optopt);
     348             :             else
     349           0 :                 fprintf (stderr, "Unknown option character `\\x%x'.\n", (uint32_t)optopt);
     350             : 
     351             :             /* unknown or wrong option used, show usage information and terminate */
     352           0 :             usage();
     353           0 :             return -1;
     354             :         }
     355           0 :         default:
     356             :         {
     357           0 :             fprintf (stderr, "Invalid option, this should never occur!\n");
     358           0 :             return -1;
     359             :         }
     360             :         }
     361             : 
     362             :     /* switch() */
     363             : 
     364             : #ifdef DLT_DAEMON_USE_FIFO_IPC
     365           9 :     snprintf(daemon_local->flags.userPipesDir, DLT_PATH_MAX,
     366             :              "%s/dltpipes", dltFifoBaseDir);
     367           9 :     snprintf(daemon_local->flags.daemonFifoName, DLT_PATH_MAX,
     368             :              "%s/dlt", dltFifoBaseDir);
     369             : #endif
     370             : 
     371             : #ifdef DLT_SHM_ENABLE
     372             :     strncpy(daemon_local->flags.dltShmName, dltShmName, NAME_MAX);
     373             : #endif
     374             : 
     375           9 :     return 0;
     376             : 
     377             : }  /* option_handling() */
     378             : 
     379             : /**
     380             :  * Option file parser
     381             :  */
     382           9 : int option_file_parser(DltDaemonLocal *daemon_local)
     383           9 : {
     384             :     FILE *pFile;
     385           9 :     char line[value_length - 1];
     386           9 :     char token[value_length];
     387           9 :     char value[value_length];
     388             :     char *pch;
     389             :     const char *filename;
     390             :     ssize_t n;
     391             : 
     392             :     /* set default values for configuration */
     393           9 :     daemon_local->flags.sharedMemorySize = DLT_SHM_SIZE;
     394           9 :     daemon_local->flags.sendMessageTime = 0;
     395           9 :     daemon_local->flags.offlineTraceDirectory[0] = 0;
     396           9 :     daemon_local->flags.offlineTraceFileSize = 1000000;
     397           9 :     daemon_local->flags.offlineTraceMaxSize = 4000000;
     398           9 :     daemon_local->flags.offlineTraceFilenameTimestampBased = true;
     399           9 :     daemon_local->flags.loggingMode = DLT_LOG_TO_CONSOLE;
     400           9 :     daemon_local->flags.loggingLevel = LOG_INFO;
     401             : 
     402             : #ifdef DLT_DAEMON_USE_UNIX_SOCKET_IPC
     403             :     n = snprintf(daemon_local->flags.loggingFilename,
     404             :                  sizeof(daemon_local->flags.loggingFilename),
     405             :                  "%s/dlt.log", DLT_USER_IPC_PATH);
     406             : #else /* DLT_DAEMON_USE_FIFO_IPC */
     407           9 :     n = snprintf(daemon_local->flags.loggingFilename,
     408             :                  sizeof(daemon_local->flags.loggingFilename),
     409             :                  "%s/dlt.log", dltFifoBaseDir);
     410             : #endif
     411             : 
     412           9 :     if (n < 0 || (size_t)n > sizeof(daemon_local->flags.loggingFilename)) {
     413           0 :         dlt_vlog(LOG_WARNING, "%s: snprintf truncation/error(%ld) %s\n",
     414             :                 __func__, n, daemon_local->flags.loggingFilename);
     415             :     }
     416           9 :     daemon_local->flags.enableLoggingFileLimit = false;
     417           9 :     daemon_local->flags.loggingFileSize = 250000;
     418           9 :     daemon_local->flags.loggingFileMaxSize = 1000000;
     419             : 
     420           9 :     daemon_local->timeoutOnSend = 4;
     421           9 :     daemon_local->RingbufferMinSize = DLT_DAEMON_RINGBUFFER_MIN_SIZE;
     422           9 :     daemon_local->RingbufferMaxSize = DLT_DAEMON_RINGBUFFER_MAX_SIZE;
     423           9 :     daemon_local->RingbufferStepSize = DLT_DAEMON_RINGBUFFER_STEP_SIZE;
     424           9 :     daemon_local->daemonFifoSize = 0;
     425           9 :     daemon_local->flags.sendECUSoftwareVersion = 0;
     426           9 :     memset(daemon_local->flags.pathToECUSoftwareVersion, 0, sizeof(daemon_local->flags.pathToECUSoftwareVersion));
     427           9 :     memset(daemon_local->flags.ecuSoftwareVersionFileField, 0, sizeof(daemon_local->flags.ecuSoftwareVersionFileField));
     428           9 :     daemon_local->flags.sendTimezone = 0;
     429           9 :     daemon_local->flags.offlineLogstorageMaxDevices = 0;
     430           9 :     daemon_local->flags.offlineLogstorageDirPath[0] = 0;
     431           9 :     daemon_local->flags.offlineLogstorageTimestamp = 1;
     432           9 :     daemon_local->flags.offlineLogstorageDelimiter = '_';
     433           9 :     daemon_local->flags.offlineLogstorageMaxCounter = UINT_MAX;
     434           9 :     daemon_local->flags.offlineLogstorageMaxCounterIdx = 0;
     435           9 :     daemon_local->flags.offlineLogstorageOptionalCounter = false;
     436           9 :     daemon_local->flags.offlineLogstorageCacheSize = 30000; /* 30MB */
     437           9 :     dlt_daemon_logstorage_set_logstorage_cache_size(
     438             :         daemon_local->flags.offlineLogstorageCacheSize);
     439           9 :     strncpy(daemon_local->flags.ctrlSockPath,
     440             :             DLT_DAEMON_DEFAULT_CTRL_SOCK_PATH,
     441             :             sizeof(daemon_local->flags.ctrlSockPath));
     442             : #ifdef DLT_DAEMON_USE_UNIX_SOCKET_IPC
     443             :     snprintf(daemon_local->flags.appSockPath, DLT_IPC_PATH_MAX, "%s/dlt", DLT_USER_IPC_PATH);
     444             : 
     445             :     if (strlen(DLT_USER_IPC_PATH) > DLT_IPC_PATH_MAX)
     446             :         fprintf(stderr, "Provided path too long...trimming it to path[%s]\n",
     447             :                 daemon_local->flags.appSockPath);
     448             : 
     449             : #else /* DLT_DAEMON_USE_FIFO_IPC */
     450           9 :     memset(daemon_local->flags.daemonFifoGroup, 0, sizeof(daemon_local->flags.daemonFifoGroup));
     451             : #endif
     452           9 :     daemon_local->flags.gatewayMode = 0;
     453           9 :     strncpy(daemon_local->flags.gatewayConfigFile,
     454             :             DLT_GATEWAY_CONFIG_PATH,
     455             :             DLT_DAEMON_FLAG_MAX);
     456           9 :     daemon_local->flags.autoResponseGetLogInfoOption = 7;
     457           9 :     daemon_local->flags.contextLogLevel = DLT_LOG_INFO;
     458           9 :     daemon_local->flags.contextTraceStatus = DLT_TRACE_STATUS_OFF;
     459           9 :     daemon_local->flags.enforceContextLLAndTS = 0; /* default is off */
     460             : #ifdef UDP_CONNECTION_SUPPORT
     461             :     daemon_local->UDPConnectionSetup = MULTICAST_CONNECTION_ENABLED;
     462             :     strncpy(daemon_local->UDPMulticastIPAddress, MULTICASTIPADDRESS, MULTICASTIP_MAX_SIZE - 1);
     463             :     daemon_local->UDPMulticastIPPort = MULTICASTIPPORT;
     464             : #endif
     465           9 :     daemon_local->flags.ipNodes = NULL;
     466           9 :     daemon_local->flags.injectionMode = 1;
     467             : 
     468             :     /* open configuration file */
     469           9 :     if (daemon_local->flags.cvalue[0])
     470           8 :         filename = daemon_local->flags.cvalue;
     471             :     else
     472             :         filename = CONFIGURATION_FILES_DIR "/dlt.conf";
     473             : 
     474             :     /*printf("Load configuration from file: %s\n",filename); */
     475           9 :     pFile = fopen (filename, "r");
     476             : 
     477           9 :     if (pFile != NULL) {
     478             :         while (1) {
     479             :             /* fetch line from configuration file */
     480         112 :             if (fgets (line, value_length - 1, pFile) != NULL) {
     481          49 :                 pch = strtok (line, " =\r\n");
     482          49 :                 token[0] = 0;
     483          49 :                 value[0] = 0;
     484             : 
     485          92 :                 while (pch != NULL) {
     486          86 :                     if (strcmp(pch, "#") == 0)
     487             :                         break;
     488             : 
     489          86 :                     if (token[0] == 0) {
     490          43 :                         strncpy(token, pch, sizeof(token) - 1);
     491          43 :                         token[sizeof(token) - 1] = 0;
     492             :                     }
     493             :                     else {
     494          43 :                         strncpy(value, pch, sizeof(value) - 1);
     495          43 :                         value[sizeof(value) - 1] = 0;
     496          43 :                         break;
     497             :                     }
     498             : 
     499          43 :                     pch = strtok (NULL, " =\r\n");
     500             :                 }
     501             : 
     502          49 :                 if (token[0] && value[0]) {
     503             :                     /* parse arguments here */
     504          43 :                     if (strcmp(token, "Verbose") == 0) {
     505           0 :                         daemon_local->flags.vflag = atoi(value);
     506             :                         /*printf("Option: %s=%s\n",token,value); */
     507             :                     }
     508          43 :                     else if (strcmp(token, "PrintASCII") == 0)
     509             :                     {
     510           0 :                         daemon_local->flags.aflag = atoi(value);
     511             :                         /*printf("Option: %s=%s\n",token,value); */
     512             :                     }
     513          43 :                     else if (strcmp(token, "PrintHex") == 0)
     514             :                     {
     515           0 :                         daemon_local->flags.xflag = atoi(value);
     516             :                         /*printf("Option: %s=%s\n",token,value); */
     517             :                     }
     518          43 :                     else if (strcmp(token, "PrintHeadersOnly") == 0)
     519             :                     {
     520           0 :                         daemon_local->flags.sflag = atoi(value);
     521             :                         /*printf("Option: %s=%s\n",token,value); */
     522             :                     }
     523          43 :                     else if (strcmp(token, "SendSerialHeader") == 0)
     524             :                     {
     525           0 :                         daemon_local->flags.lflag = atoi(value);
     526             :                         /*printf("Option: %s=%s\n",token,value); */
     527             :                     }
     528          43 :                     else if (strcmp(token, "SendContextRegistration") == 0)
     529             :                     {
     530           1 :                         daemon_local->flags.rflag = atoi(value);
     531             :                         /*printf("Option: %s=%s\n",token,value); */
     532             :                     }
     533          42 :                     else if (strcmp(token, "SendContextRegistrationOption") == 0)
     534             :                     {
     535           0 :                         daemon_local->flags.autoResponseGetLogInfoOption = atoi(value);
     536             :                         /*printf("Option: %s=%s\n",token,value); */
     537             :                     }
     538          42 :                     else if (strcmp(token, "SendMessageTime") == 0)
     539             :                     {
     540           0 :                         daemon_local->flags.sendMessageTime = atoi(value);
     541             :                         /*printf("Option: %s=%s\n",token,value); */
     542             :                     }
     543          42 :                     else if (strcmp(token, "RS232SyncSerialHeader") == 0)
     544             :                     {
     545           0 :                         daemon_local->flags.mflag = atoi(value);
     546             :                         /*printf("Option: %s=%s\n",token,value); */
     547             :                     }
     548          42 :                     else if (strcmp(token, "TCPSyncSerialHeader") == 0)
     549             :                     {
     550           0 :                         daemon_local->flags.nflag = atoi(value);
     551             :                         /*printf("Option: %s=%s\n",token,value); */
     552             :                     }
     553          42 :                     else if (strcmp(token, "RS232DeviceName") == 0)
     554             :                     {
     555           0 :                         strncpy(daemon_local->flags.yvalue, value, NAME_MAX);
     556           0 :                         daemon_local->flags.yvalue[NAME_MAX] = 0;
     557             :                         /*printf("Option: %s=%s\n",token,value); */
     558             :                     }
     559          42 :                     else if (strcmp(token, "RS232Baudrate") == 0)
     560             :                     {
     561           0 :                         strncpy(daemon_local->flags.bvalue, value, NAME_MAX);
     562           0 :                         daemon_local->flags.bvalue[NAME_MAX] = 0;
     563             :                         /*printf("Option: %s=%s\n",token,value); */
     564             :                     }
     565          42 :                     else if (strcmp(token, "ECUId") == 0)
     566             :                     {
     567           1 :                         strncpy(daemon_local->flags.evalue, value, NAME_MAX);
     568           1 :                         daemon_local->flags.evalue[NAME_MAX] = 0;
     569             :                         /*printf("Option: %s=%s\n",token,value); */
     570             :                     }
     571          41 :                     else if (strcmp(token, "PersistanceStoragePath") == 0)
     572             :                     {
     573           0 :                         strncpy(daemon_local->flags.ivalue, value, NAME_MAX);
     574           0 :                         daemon_local->flags.ivalue[NAME_MAX] = 0;
     575             :                         /*printf("Option: %s=%s\n",token,value); */
     576             :                     }
     577          41 :                     else if (strcmp(token, "LoggingMode") == 0)
     578             :                     {
     579           1 :                         daemon_local->flags.loggingMode = (DltLoggingMode)atoi(value);
     580             :                         /*printf("Option: %s=%s\n",token,value); */
     581             :                     }
     582          40 :                     else if (strcmp(token, "LoggingLevel") == 0)
     583             :                     {
     584           1 :                         daemon_local->flags.loggingLevel = atoi(value);
     585             :                         /*printf("Option: %s=%s\n",token,value); */
     586             :                     }
     587          39 :                     else if (strcmp(token, "LoggingFilename") == 0)
     588             :                     {
     589             :                         strncpy(daemon_local->flags.loggingFilename,
     590             :                                 value,
     591             :                                 sizeof(daemon_local->flags.loggingFilename) - 1);
     592           1 :                         daemon_local->flags.loggingFilename[sizeof(daemon_local->flags.loggingFilename) - 1] = 0;
     593             :                         /*printf("Option: %s=%s\n",token,value); */
     594             :                     }
     595          38 :                     else if (strcmp(token, "EnableLoggingFileLimit") == 0)
     596             :                     {
     597           0 :                         daemon_local->flags.enableLoggingFileLimit = (bool)atoi(value);
     598             :                     }
     599          38 :                     else if (strcmp(token, "LoggingFileSize") == 0)
     600             :                     {
     601           0 :                         daemon_local->flags.loggingFileSize = atoi(value);
     602             :                     }
     603          38 :                     else if (strcmp(token, "LoggingFileMaxSize") == 0)
     604             :                     {
     605           0 :                         daemon_local->flags.loggingFileMaxSize = atoi(value);
     606             :                     }
     607          38 :                     else if (strcmp(token, "TimeOutOnSend") == 0)
     608             :                     {
     609           1 :                         daemon_local->timeoutOnSend = atoi(value);
     610             :                         /*printf("Option: %s=%s\n",token,value); */
     611             :                     }
     612          37 :                     else if (strcmp(token, "RingbufferMinSize") == 0)
     613             :                     {
     614           1 :                         if (dlt_daemon_check_numeric_setting(token,
     615             :                                 value, &(daemon_local->RingbufferMinSize)) < 0) {
     616           0 :                             fclose (pFile);
     617           0 :                             return -1;
     618             :                         }
     619             :                     }
     620          36 :                     else if (strcmp(token, "RingbufferMaxSize") == 0)
     621             :                     {
     622           1 :                         if (dlt_daemon_check_numeric_setting(token,
     623             :                                 value, &(daemon_local->RingbufferMaxSize)) < 0) {
     624           0 :                             fclose (pFile);
     625           0 :                             return -1;
     626             :                         }
     627             :                     }
     628          35 :                     else if (strcmp(token, "RingbufferStepSize") == 0)
     629             :                     {
     630           1 :                         if (dlt_daemon_check_numeric_setting(token,
     631             :                                 value, &(daemon_local->RingbufferStepSize)) < 0) {
     632           0 :                             fclose (pFile);
     633           0 :                             return -1;
     634             :                         }
     635             :                     }
     636          34 :                     else if (strcmp(token, "SharedMemorySize") == 0)
     637             :                     {
     638           1 :                         daemon_local->flags.sharedMemorySize = atoi(value);
     639             :                         /*printf("Option: %s=%s\n",token,value); */
     640             :                     }
     641          33 :                     else if (strcmp(token, "OfflineTraceDirectory") == 0)
     642             :                     {
     643           0 :                         strncpy(daemon_local->flags.offlineTraceDirectory, value,
     644             :                                 sizeof(daemon_local->flags.offlineTraceDirectory) - 1);
     645             :                         daemon_local->flags.offlineTraceDirectory[sizeof(daemon_local->flags.offlineTraceDirectory) -
     646           0 :                                                                   1] = 0;
     647             :                         /*printf("Option: %s=%s\n",token,value); */
     648             :                     }
     649          33 :                     else if (strcmp(token, "OfflineTraceFileSize") == 0)
     650             :                     {
     651           0 :                         daemon_local->flags.offlineTraceFileSize = atoi(value);
     652             :                         /*printf("Option: %s=%s\n",token,value); */
     653             :                     }
     654          33 :                     else if (strcmp(token, "OfflineTraceMaxSize") == 0)
     655             :                     {
     656           0 :                         daemon_local->flags.offlineTraceMaxSize = atoi(value);
     657             :                         /*printf("Option: %s=%s\n",token,value); */
     658             :                     }
     659          33 :                     else if (strcmp(token, "OfflineTraceFileNameTimestampBased") == 0)
     660             :                     {
     661           0 :                         daemon_local->flags.offlineTraceFilenameTimestampBased = (bool)atoi(value);
     662             :                         /*printf("Option: %s=%s\n",token,value); */
     663             :                     }
     664          33 :                     else if (strcmp(token, "SendECUSoftwareVersion") == 0)
     665             :                     {
     666           0 :                         daemon_local->flags.sendECUSoftwareVersion = atoi(value);
     667             :                         /*printf("Option: %s=%s\n",token,value); */
     668             :                     }
     669          33 :                     else if (strcmp(token, "PathToECUSoftwareVersion") == 0)
     670             :                     {
     671             :                         strncpy(daemon_local->flags.pathToECUSoftwareVersion, value,
     672             :                                 sizeof(daemon_local->flags.pathToECUSoftwareVersion) - 1);
     673             :                         daemon_local->flags.pathToECUSoftwareVersion[sizeof(daemon_local->flags.pathToECUSoftwareVersion)
     674           0 :                                                                      - 1] = 0;
     675             :                         /*printf("Option: %s=%s\n",token,value); */
     676             :                     }
     677          33 :                     else if (strcmp(token, "ECUSoftwareVersionFileField") == 0) {
     678             :                         strncpy(daemon_local->flags.ecuSoftwareVersionFileField, value,
     679             :                                 sizeof(daemon_local->flags.ecuSoftwareVersionFileField) - 1);
     680             :                         daemon_local->flags.ecuSoftwareVersionFileField[sizeof(daemon_local->flags.ecuSoftwareVersionFileField)
     681           0 :                                                                      - 1] = 0;
     682             :                         /*printf("Option: %s=%s\n",token,value); */
     683             :                     }
     684          33 :                     else if (strcmp(token, "SendTimezone") == 0)
     685             :                     {
     686           0 :                         daemon_local->flags.sendTimezone = atoi(value);
     687             :                         /*printf("Option: %s=%s\n",token,value); */
     688             :                     }
     689          33 :                     else if (strcmp(token, "OfflineLogstorageMaxDevices") == 0)
     690             :                     {
     691           6 :                         daemon_local->flags.offlineLogstorageMaxDevices = (uint32_t) atoi(value);
     692             :                     }
     693          27 :                     else if (strcmp(token, "OfflineLogstorageDirPath") == 0)
     694             :                     {
     695           6 :                         strncpy(daemon_local->flags.offlineLogstorageDirPath,
     696             :                                 value,
     697             :                                 sizeof(daemon_local->flags.offlineLogstorageDirPath) - 1);
     698             :                     }
     699          21 :                     else if (strcmp(token, "OfflineLogstorageTimestamp") == 0)
     700             :                     {
     701             :                         /* Check if set to 0, default otherwise */
     702           6 :                         if (atoi(value) == 0)
     703           6 :                             daemon_local->flags.offlineLogstorageTimestamp = 0;
     704             :                     }
     705          15 :                     else if (strcmp(token, "OfflineLogstorageDelimiter") == 0)
     706             :                     {
     707             :                         /* Check if valid punctuation, default otherwise*/
     708           0 :                         if (ispunct((char)value[0]))
     709           0 :                             daemon_local->flags.offlineLogstorageDelimiter = (char)value[0];
     710             :                     }
     711          15 :                     else if (strcmp(token, "OfflineLogstorageMaxCounter") == 0)
     712             :                     {
     713           0 :                         daemon_local->flags.offlineLogstorageMaxCounter = (unsigned int) atoi(value);
     714           0 :                         daemon_local->flags.offlineLogstorageMaxCounterIdx = (unsigned int) strlen(value);
     715          15 :                     } else if (strcmp(token, "OfflineLogstorageOptionalIndex") == 0) {
     716           6 :                         daemon_local->flags.offlineLogstorageOptionalCounter = atoi(value);
     717             :                     }
     718           9 :                     else if (strcmp(token, "OfflineLogstorageCacheSize") == 0)
     719             :                     {
     720           0 :                         daemon_local->flags.offlineLogstorageCacheSize =
     721           0 :                             (unsigned int)atoi(value);
     722           0 :                         dlt_daemon_logstorage_set_logstorage_cache_size(
     723             :                             daemon_local->flags.offlineLogstorageCacheSize);
     724             :                     }
     725           9 :                     else if (strcmp(token, "ControlSocketPath") == 0)
     726             :                     {
     727             :                         memset(
     728             :                             daemon_local->flags.ctrlSockPath,
     729             :                             0,
     730             :                             DLT_DAEMON_FLAG_MAX);
     731             :                         strncpy(
     732             :                             daemon_local->flags.ctrlSockPath,
     733             :                             value,
     734             :                             DLT_DAEMON_FLAG_MAX - 1);
     735             :                     }
     736           2 :                     else if (strcmp(token, "GatewayMode") == 0)
     737             :                     {
     738           1 :                         daemon_local->flags.gatewayMode = atoi(value);
     739             :                         /*printf("Option: %s=%s\n",token,value); */
     740             :                     }
     741           1 :                     else if (strcmp(token, "GatewayConfigFile") == 0)
     742             :                     {
     743             :                         memset(
     744             :                             daemon_local->flags.gatewayConfigFile,
     745             :                             0,
     746             :                             DLT_DAEMON_FLAG_MAX);
     747             :                         strncpy(
     748             :                             daemon_local->flags.gatewayConfigFile,
     749             :                             value,
     750             :                             DLT_DAEMON_FLAG_MAX - 1);
     751             :                     }
     752           0 :                     else if (strcmp(token, "ContextLogLevel") == 0)
     753             :                     {
     754             :                         int const intval = atoi(value);
     755             : 
     756           0 :                         if ((intval >= DLT_LOG_OFF) && (intval <= DLT_LOG_VERBOSE)) {
     757           0 :                             daemon_local->flags.contextLogLevel = intval;
     758             :                             printf("Option: %s=%s\n", token, value);
     759             :                         }
     760             :                         else {
     761           0 :                             fprintf(stderr,
     762             :                                     "Invalid value for ContextLogLevel: %i. Must be in range [%i..%i]\n",
     763             :                                     intval,
     764             :                                     DLT_LOG_OFF,
     765             :                                     DLT_LOG_VERBOSE);
     766             :                         }
     767             :                     }
     768           0 :                     else if (strcmp(token, "ContextTraceStatus") == 0)
     769             :                     {
     770             :                         int const intval = atoi(value);
     771             : 
     772           0 :                         if ((intval >= DLT_TRACE_STATUS_OFF) && (intval <= DLT_TRACE_STATUS_ON)) {
     773           0 :                             daemon_local->flags.contextTraceStatus = intval;
     774             :                             printf("Option: %s=%s\n", token, value);
     775             :                         }
     776             :                         else {
     777           0 :                             fprintf(stderr,
     778             :                                     "Invalid value for ContextTraceStatus: %i. Must be in range [%i..%i]\n",
     779             :                                     intval,
     780             :                                     DLT_TRACE_STATUS_OFF,
     781             :                                     DLT_TRACE_STATUS_ON);
     782             :                         }
     783             :                     }
     784           0 :                     else if (strcmp(token, "ForceContextLogLevelAndTraceStatus") == 0)
     785             :                     {
     786             :                         int const intval = atoi(value);
     787             : 
     788           0 :                         if ((intval >= 0) && (intval <= 1)) {
     789           0 :                             daemon_local->flags.enforceContextLLAndTS = intval;
     790             :                             printf("Option: %s=%s\n", token, value);
     791             :                         }
     792             :                         else {
     793           0 :                             fprintf(stderr,
     794             :                                     "Invalid value for ForceContextLogLevelAndTraceStatus: %i. Must be 0, 1\n",
     795             :                                     intval);
     796             :                         }
     797             :                     }
     798             : 
     799             : #ifdef DLT_DAEMON_USE_FIFO_IPC
     800           0 :                     else if (strcmp(token, "DaemonFIFOSize") == 0)
     801             :                     {
     802           0 :                         if (dlt_daemon_check_numeric_setting(token,
     803             :                                 value, &(daemon_local->daemonFifoSize)) < 0) {
     804           0 :                             fclose (pFile);
     805           0 :                             return -1;
     806             :                         }
     807             : #ifndef __linux__
     808             :                             printf("Option DaemonFIFOSize is set but only supported on Linux. Ignored.\n");
     809             : #endif
     810             :                     }
     811           0 :                     else if (strcmp(token, "DaemonFifoGroup") == 0)
     812             :                     {
     813             :                         strncpy(daemon_local->flags.daemonFifoGroup, value, NAME_MAX);
     814           0 :                         daemon_local->flags.daemonFifoGroup[NAME_MAX] = 0;
     815             :                     }
     816             : #endif
     817             : #ifdef UDP_CONNECTION_SUPPORT
     818             :                     else if (strcmp(token, "UDPConnectionSetup") == 0)
     819             :                     {
     820             :                         const long longval = strtol(value, NULL, 10);
     821             : 
     822             :                         if ((longval == MULTICAST_CONNECTION_DISABLED)
     823             :                             || (longval == MULTICAST_CONNECTION_ENABLED)) {
     824             :                             daemon_local->UDPConnectionSetup = longval;
     825             :                             printf("Option: %s=%s\n", token, value);
     826             :                         }
     827             :                         else {
     828             :                             daemon_local->UDPConnectionSetup = MULTICAST_CONNECTION_DISABLED;
     829             :                             fprintf(stderr,
     830             :                                     "Invalid value for UDPConnectionSetup set to default %ld\n",
     831             :                                     longval);
     832             :                         }
     833             :                     }
     834             :                     else if (strcmp(token, "UDPMulticastIPAddress") == 0)
     835             :                     {
     836             :                         strncpy(daemon_local->UDPMulticastIPAddress, value,
     837             :                                 MULTICASTIP_MAX_SIZE - 1);
     838             :                     }
     839             :                     else if (strcmp(token, "UDPMulticastIPPort") == 0)
     840             :                     {
     841             :                         daemon_local->UDPMulticastIPPort = strtol(value, NULL, 10);
     842             :                     }
     843             : #endif
     844           0 :                     else if (strcmp(token, "BindAddress") == 0)
     845             :                     {
     846             :                         DltBindAddress_t *newNode = NULL;
     847             :                         DltBindAddress_t *temp = NULL;
     848             : 
     849           0 :                         char *tok = strtok(value, ",;");
     850             : 
     851           0 :                         if (tok != NULL) {
     852           0 :                             daemon_local->flags.ipNodes = calloc(1, sizeof(DltBindAddress_t));
     853             : 
     854           0 :                             if (daemon_local->flags.ipNodes == NULL) {
     855           0 :                                 dlt_vlog(LOG_ERR, "Could not allocate for IP list\n");
     856           0 :                                 fclose(pFile);
     857           0 :                                 return -1;
     858             :                             }
     859             :                             else {
     860           0 :                                 strncpy(daemon_local->flags.ipNodes->ip,
     861             :                                         tok,
     862             :                                         sizeof(daemon_local->flags.ipNodes->ip) - 1);
     863           0 :                                 daemon_local->flags.ipNodes->next = NULL;
     864             :                                 temp = daemon_local->flags.ipNodes;
     865             : 
     866           0 :                                 tok = strtok(NULL, ",;");
     867             : 
     868           0 :                                 while (tok != NULL) {
     869           0 :                                     newNode = calloc(1, sizeof(DltBindAddress_t));
     870             : 
     871           0 :                                     if (newNode == NULL) {
     872           0 :                                         dlt_vlog(LOG_ERR, "Could not allocate for IP list\n");
     873           0 :                                         fclose(pFile);
     874           0 :                                         return -1;
     875             :                                     }
     876             :                                     else {
     877           0 :                                         strncpy(newNode->ip, tok, sizeof(newNode->ip) - 1);
     878             :                                     }
     879             : 
     880           0 :                                     temp->next = newNode;
     881             :                                     temp = temp->next;
     882           0 :                                     tok = strtok(NULL, ",;");
     883             :                                 }
     884             :                             }
     885             :                         }
     886             :                         else {
     887           0 :                             dlt_vlog(LOG_WARNING, "BindAddress option is empty\n");
     888             :                         }
     889             :                     }
     890           0 :                     else if (strcmp(token, "InjectionMode") == 0) {
     891           0 :                         daemon_local->flags.injectionMode = atoi(value);
     892             :                     }
     893             :                     else {
     894           0 :                         fprintf(stderr, "Unknown option: %s=%s\n", token, value);
     895             :                     }
     896             :                 }
     897             :             }
     898             :             else {
     899             :                 break;
     900             :             }
     901             :         }
     902             : 
     903           7 :         fclose (pFile);
     904             :     }
     905             :     else {
     906           2 :         fprintf(stderr, "Cannot open configuration file: %s\n", filename);
     907             :     }
     908             : 
     909             :     return 0;
     910             : }
     911             : 
     912             : #ifdef DLT_LOG_LEVEL_APP_CONFIG
     913             : /**
     914             :  * Load configuration file parser
     915             :  */
     916             : 
     917             : static int compare_app_id_conf(const void *lhs, const void *rhs)
     918             : {
     919             :     return strncmp(((DltDaemonContextLogSettings *)lhs)->apid,
     920             :                    ((DltDaemonContextLogSettings *)rhs)->apid, DLT_ID_SIZE);
     921             : }
     922             : 
     923             : int app_id_default_log_level_config_parser(DltDaemon *daemon,
     924             :                                            DltDaemonLocal *daemon_local) {
     925             :     FILE *pFile;
     926             :     char line[value_length - 1];
     927             :     char app_id_value[value_length];
     928             :     char ctx_id_value[value_length];
     929             :     DltLogLevelType log_level_value;
     930             : 
     931             :     char *pch;
     932             :     const char *filename;
     933             : 
     934             :     /* open configuration file */
     935             :     filename = daemon_local->flags.avalue[0]
     936             :                    ? daemon_local->flags.avalue
     937             :                    : CONFIGURATION_FILES_DIR "/dlt-log-levels.conf";
     938             : 
     939             :     pFile = fopen(filename, "r");
     940             :     if (pFile == NULL) {
     941             :         dlt_vlog(LOG_WARNING, "Cannot open app log level configuration%s\n", filename);
     942             :         return -errno;
     943             :     }
     944             : 
     945             :     /* fetch lines from configuration file */
     946             :     while (fgets(line, value_length - 1, pFile) != NULL) {
     947             :         pch = strtok(line, " \t");
     948             :         memset(app_id_value, 0, value_length);
     949             :         memset(ctx_id_value, 0, value_length);
     950             :         log_level_value = DLT_LOG_MAX;
     951             : 
     952             :         /* ignore comments and new lines*/
     953             :         if (strncmp(pch, "#", 1) == 0 || strncmp(pch, "\n", 1) == 0
     954             :             || strlen(pch) < 1)
     955             :             continue;
     956             : 
     957             :         strncpy(app_id_value, pch, sizeof(app_id_value) - 1);
     958             :         app_id_value[sizeof(app_id_value) - 1] = 0;
     959             :         if (strlen(app_id_value) == 0 || strlen(app_id_value) > DLT_ID_SIZE) {
     960             :             if (app_id_value[strlen(app_id_value) - 1] == '\n') {
     961             :                 dlt_vlog(LOG_WARNING, "Missing log level for apid %s in log settings\n",
     962             :                          app_id_value);
     963             :             } else {
     964             :                 dlt_vlog(LOG_WARNING,
     965             :                          "Invalid apid for log settings settings: app id: %s\n",
     966             :                          app_id_value);
     967             :             }
     968             : 
     969             :             continue;
     970             :         }
     971             : 
     972             :         char *pch_next1 = strtok(NULL, " \t");
     973             :         char *pch_next2 = strtok(NULL, " \t");
     974             :         char *log_level;
     975             :         /* no context id given, log level is next token */
     976             :         if (pch_next2 == NULL || pch_next2[0] == '#') {
     977             :             log_level = pch_next1;
     978             :         } else {
     979             :             /* context id is given, log level is second to next token */
     980             :             log_level = pch_next2;
     981             : 
     982             :             /* next token is token id */
     983             :             strncpy(ctx_id_value, pch_next1, sizeof(ctx_id_value) - 1);
     984             :             if (strlen(ctx_id_value) == 0 || strlen(app_id_value) > DLT_ID_SIZE) {
     985             :                 dlt_vlog(LOG_WARNING,
     986             :                          "Invalid ctxid for log settings: app id: %s "
     987             :                          "(skipping line)\n",
     988             :                          app_id_value);
     989             :                 continue;
     990             :             }
     991             : 
     992             :             ctx_id_value[sizeof(ctx_id_value) - 1] = 0;
     993             :         }
     994             : 
     995             :         errno = 0;
     996             :         log_level_value = strtol(log_level, NULL, 10);
     997             :         if (errno != 0 || log_level_value >= DLT_LOG_MAX ||
     998             :             log_level_value <= DLT_LOG_DEFAULT) {
     999             :             dlt_vlog(LOG_WARNING,
    1000             :                      "Invalid log level (%i), app id %s, conversion error: %s\n",
    1001             :                      log_level_value, app_id_value, strerror(errno));
    1002             :             continue;
    1003             :         }
    1004             : 
    1005             :         DltDaemonContextLogSettings *settings =
    1006             :             dlt_daemon_find_configured_app_id_ctx_id_settings(
    1007             :                 daemon, app_id_value, NULL);
    1008             : 
    1009             :         if (settings != NULL &&
    1010             :             strncmp(settings->ctid, ctx_id_value, DLT_ID_SIZE) == 0) {
    1011             :             if (strlen(ctx_id_value) > 0) {
    1012             :                 dlt_vlog(LOG_WARNING,
    1013             :                          "Appid %s with ctxid %s is already configured, skipping "
    1014             :                          "duplicated entry\n",
    1015             :                          app_id_value, ctx_id_value);
    1016             :             } else {
    1017             :                 dlt_vlog(LOG_WARNING,
    1018             :                          "Appid %s is already configured, skipping duplicated entry\n",
    1019             :                          app_id_value);
    1020             :             }
    1021             : 
    1022             :             continue;
    1023             :         }
    1024             : 
    1025             :         /* allocate one more element in the trace load settings */
    1026             :         DltDaemonContextLogSettings *tmp =
    1027             :             realloc(daemon->app_id_log_level_settings,
    1028             :                     (++daemon->num_app_id_log_level_settings) *
    1029             :                         sizeof(DltDaemonContextLogSettings));
    1030             : 
    1031             :         if (tmp == NULL) {
    1032             :             dlt_log(LOG_CRIT, "Failed to allocate memory for app load settings\n");
    1033             :             continue;
    1034             :         }
    1035             : 
    1036             :         daemon->app_id_log_level_settings = tmp;
    1037             : 
    1038             :         /* update newly created entry */
    1039             :         settings = &daemon->app_id_log_level_settings
    1040             :                         [daemon->num_app_id_log_level_settings -1];
    1041             : 
    1042             :         memset(settings, 0, sizeof(DltDaemonContextLogSettings));
    1043             :         memcpy(settings->apid, app_id_value, DLT_ID_SIZE);
    1044             :         memcpy(settings->ctid, ctx_id_value, DLT_ID_SIZE);
    1045             :         settings->log_level = log_level_value;
    1046             : 
    1047             :         /* make sure ids are 0 terminated for printing */
    1048             :         char apid_buf[DLT_ID_SIZE + 1] = {0};
    1049             :         char ctid_buf[DLT_ID_SIZE + 1] = {0};
    1050             :         memcpy(apid_buf, app_id_value, DLT_ID_SIZE);
    1051             :         memcpy(ctid_buf, ctx_id_value, DLT_ID_SIZE);
    1052             : 
    1053             :         /* log with or without context id */
    1054             :         if (strlen(ctid_buf) > 0) {
    1055             :             dlt_vlog(
    1056             :                 LOG_INFO,
    1057             :                 "Configured trace limits for app id %s, context id %s, level %u\n",
    1058             :                 apid_buf, ctid_buf, log_level_value);
    1059             :         } else {
    1060             :             dlt_vlog(LOG_INFO, "Configured trace limits for app id %s, level %u\n",
    1061             :                      apid_buf, log_level_value);
    1062             :         }
    1063             : 
    1064             :     } /* while */
    1065             :     fclose(pFile);
    1066             : 
    1067             :     /* list must be sorted to speed up dlt_daemon_find_configured_app_id_ctx_id_settings */
    1068             :     qsort(daemon->app_id_log_level_settings,
    1069             :             daemon->num_app_id_log_level_settings,
    1070             :             sizeof(DltDaemonContextLogSettings), compare_app_id_conf);
    1071             : 
    1072             :     return 0;
    1073             : }
    1074             : #endif
    1075             : 
    1076             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
    1077             : static bool is_ascii_only(const char *str) {
    1078             :     while (*str) {
    1079             :         if ((unsigned char)*str > 127) {
    1080             :             return false;
    1081             :         }
    1082             :         str++;
    1083             :     }
    1084             :     return true;
    1085             : }
    1086             : 
    1087             : /**
    1088             :  * Load configuration file parser
    1089             :  */
    1090             : int trace_load_config_file_parser(DltDaemon *daemon, DltDaemonLocal *daemon_local)
    1091             : {
    1092             :     FILE *pFile;
    1093             :     const int max_tokens = 4;
    1094             :     const int min_tokens = 3;
    1095             :     char tokens[max_tokens][value_length];
    1096             :     char line[value_length - 1];
    1097             :     char app_id_value[value_length];
    1098             :     char ctx_id_value[value_length];
    1099             :     char soft_limit_value[value_length];
    1100             :     char hard_limit_value[value_length];
    1101             :     int i;
    1102             :     uint32_t soft_limit;
    1103             :     uint32_t hard_limit;
    1104             : 
    1105             :     char *pch;
    1106             :     const char *filename;
    1107             : 
    1108             :     bool skipped;
    1109             : 
    1110             :     if (daemon->preconfigured_trace_load_settings != NULL) {
    1111             :         free(daemon->preconfigured_trace_load_settings);
    1112             :         daemon->preconfigured_trace_load_settings = NULL;
    1113             :         daemon->preconfigured_trace_load_settings_count = 0;
    1114             :     }
    1115             :     daemon->preconfigured_trace_load_settings = malloc(sizeof(DltTraceLoadSettings));
    1116             :     if (daemon->preconfigured_trace_load_settings == NULL) {
    1117             :         dlt_log(LOG_CRIT, "Failed to allocate memory for trace load settings\n");
    1118             :         return DLT_RETURN_ERROR;
    1119             :     }
    1120             : 
    1121             :     /* open configuration file */
    1122             :     filename = daemon_local->flags.lvalue[0]
    1123             :                    ? daemon_local->flags.lvalue
    1124             :                    : CONFIGURATION_FILES_DIR "/dlt-trace-load.conf";
    1125             : 
    1126             :     pFile = fopen (filename, "r");
    1127             :     if (pFile == NULL) {
    1128             :         dlt_vlog(LOG_WARNING, "Cannot open trace load configuration file: %s\n",
    1129             :                  filename);
    1130             :         return -errno;
    1131             :     }
    1132             : 
    1133             :     while (1) {
    1134             :         /* fetch line from configuration file */
    1135             :         if (fgets(line, value_length - 1, pFile) == NULL) {
    1136             :             break;
    1137             :         }
    1138             : 
    1139             :         pch = strtok(line, " ");
    1140             :         app_id_value[0] = 0;
    1141             :         ctx_id_value[0] = 0;
    1142             :         soft_limit_value[0] = 0;
    1143             :         hard_limit_value[0] = 0;
    1144             :         soft_limit = 0U;
    1145             :         hard_limit = 0U;
    1146             :         memset(tokens, 0, sizeof(tokens));
    1147             :         i = 0;
    1148             : 
    1149             :         skipped = false;
    1150             :         while (pch != NULL && i < max_tokens) {
    1151             :             /* ignore comments, empty lines and new lines */
    1152             :             if (strncmp(pch, "#", 1) == 0 || strncmp(pch, "\n", 1) == 0 ||
    1153             :                 strncmp(pch, "\r", 1) == 0 || strncmp(pch, " ", 1) == 0) {
    1154             :                 skipped = true;
    1155             :                 break;
    1156             :             }
    1157             :             strncpy(tokens[i], pch, sizeof(tokens[i]) - 1);
    1158             :             pch = strtok(NULL, " ");
    1159             :             ++i;
    1160             :         }
    1161             : 
    1162             :         if (skipped && i < min_tokens)
    1163             :             continue;
    1164             : 
    1165             :         if (pch != NULL
    1166             :             && (pch[0] != '\n')
    1167             :             && (pch[0] != '\t')
    1168             :             && (pch[0] != ' ')
    1169             :             && (pch[0] != '#')) {
    1170             :             dlt_vlog(LOG_WARNING,
    1171             :                      "Invalid trace load settings: too many tokens in line '%s'\n", line);
    1172             :             continue;
    1173             :         }
    1174             : 
    1175             :         bool has_ctx_id = i == max_tokens;
    1176             :         int soft_limit_idx = has_ctx_id ? 2 : 1;
    1177             :         int hard_limit_idx = has_ctx_id ? 3 : 2;
    1178             : 
    1179             :         strncpy(app_id_value, tokens[0], sizeof(app_id_value) - 1);
    1180             :         if ((strlen(app_id_value) == 0)
    1181             :             || (strlen(app_id_value) > DLT_ID_SIZE)
    1182             :             || (!is_ascii_only(app_id_value))) {
    1183             :             dlt_vlog(LOG_WARNING,
    1184             :                      "Invalid apid for trace load settings: app id: '%s'\n", app_id_value);
    1185             :             continue;
    1186             :         }
    1187             : 
    1188             :         if (has_ctx_id) {
    1189             :             strncpy(ctx_id_value, tokens[1], sizeof(ctx_id_value) - 1);
    1190             :             if ((strlen(ctx_id_value) == 0)
    1191             :                 || (strlen(ctx_id_value) > DLT_ID_SIZE)
    1192             :                 || (!is_ascii_only(ctx_id_value))) {
    1193             :                 dlt_vlog(LOG_WARNING,
    1194             :                          "Invalid ctid for trace load settings: context id: '%s'\n", ctx_id_value);
    1195             :                 continue;
    1196             :             }
    1197             :         }
    1198             : 
    1199             :         if (strlen(tokens[soft_limit_idx]) == 0) {
    1200             :             dlt_vlog(LOG_WARNING,
    1201             :                      "Invalid soft_limit for trace load settings: app id: '%.4s', '%s'\n",
    1202             :                      app_id_value, tokens[soft_limit_idx]);
    1203             :             continue;
    1204             :         }
    1205             : 
    1206             :         if (strlen(tokens[hard_limit_idx]) == 0) {
    1207             :             dlt_vlog(LOG_WARNING,
    1208             :                      "Invalid hard_limit for trace load settings: app id: '%.4s', '%s'\n",
    1209             :                      app_id_value, tokens[hard_limit_idx]);
    1210             :             continue;
    1211             :         }
    1212             : 
    1213             :         strncpy(soft_limit_value, tokens[soft_limit_idx],
    1214             :                 sizeof(soft_limit_value) - 1);
    1215             :         strncpy(hard_limit_value, tokens[hard_limit_idx],
    1216             :                 sizeof(hard_limit_value) - 1);
    1217             : 
    1218             :         errno = 0;
    1219             :         char *endptr;
    1220             :         endptr = NULL;
    1221             :         soft_limit = strtoul(soft_limit_value, &endptr, 10);
    1222             :         if ((errno != 0)
    1223             :             || ((soft_limit == 0) && (soft_limit_value[0] != '0'))
    1224             :             || (soft_limit_value[0] == '-')
    1225             :             || ((*endptr != '\n') && (*endptr != '\0'))) {
    1226             :             dlt_vlog(LOG_WARNING,
    1227             :                      "Invalid soft_limit for trace load settings: app id: '%.4s', soft_limit '%s'\n",
    1228             :                      app_id_value, soft_limit_value);
    1229             :             continue;
    1230             :         }
    1231             : 
    1232             :         errno = 0;
    1233             :         endptr = NULL;
    1234             :         hard_limit = strtoul(hard_limit_value, &endptr, 10);
    1235             :         if ((errno != 0)
    1236             :             || ((hard_limit == 0) && (hard_limit_value[0] != '0'))
    1237             :             || (hard_limit_value[0] == '-')
    1238             :             || ((*endptr != '\n') && (*endptr != '\0'))) {
    1239             :             dlt_vlog(LOG_WARNING,
    1240             :                      "Invalid hard_limit for trace load settings: app id: '%.4s', hard_limit '%s'\n",
    1241             :                      app_id_value, hard_limit_value);
    1242             :             continue;
    1243             :         }
    1244             : 
    1245             :         if (soft_limit > hard_limit) {
    1246             :             dlt_vlog(LOG_WARNING,
    1247             :                      "Invalid trace load settings: app id: '%.4s', soft limit %u is greater than hard limit %u\n",
    1248             :                      app_id_value, soft_limit, hard_limit);
    1249             :             continue;
    1250             :         }
    1251             : 
    1252             :         DltTraceLoadSettings *settings = NULL;
    1253             :         int num_settings = 0;
    1254             :         DltReturnValue find_trace_settings_return_value = dlt_daemon_find_preconfigured_trace_load_settings(
    1255             :             daemon, app_id_value, ctx_id_value, &settings, &num_settings,
    1256             :             0);
    1257             :         if (find_trace_settings_return_value != DLT_RETURN_OK || num_settings != 0) {
    1258             :             dlt_vlog(LOG_WARNING,
    1259             :                      "App id '%.4s' is already configured, or an error occurred, skipping entry\n",
    1260             :                      app_id_value);
    1261             :             if (settings != NULL) {
    1262             :                 free(settings);
    1263             :             }
    1264             :             continue;
    1265             :         }
    1266             : 
    1267             :         /* allocate one more element in the trace load settings */
    1268             :         DltTraceLoadSettings *tmp =
    1269             :             realloc(daemon->preconfigured_trace_load_settings,
    1270             :                     (++daemon->preconfigured_trace_load_settings_count) *
    1271             :                         sizeof(DltTraceLoadSettings));
    1272             : 
    1273             :         if (tmp == NULL) {
    1274             :             dlt_log(LOG_CRIT,
    1275             :                     "Failed to allocate memory for trace load settings\n");
    1276             :             return DLT_RETURN_ERROR;
    1277             :         }
    1278             : 
    1279             :         daemon->preconfigured_trace_load_settings = tmp;
    1280             :         settings = &daemon->preconfigured_trace_load_settings
    1281             :                         [daemon->preconfigured_trace_load_settings_count - 1];
    1282             :         memset(settings, 0, sizeof(DltTraceLoadSettings));
    1283             :         settings->soft_limit = soft_limit;
    1284             :         settings->hard_limit = hard_limit;
    1285             : 
    1286             :         memcpy(settings->apid, app_id_value, DLT_ID_SIZE);
    1287             :         if (has_ctx_id) {
    1288             :             memcpy(settings->ctid, ctx_id_value, DLT_ID_SIZE);
    1289             :             dlt_vlog(LOG_INFO,
    1290             :                      "Configured trace limits for app id '%.4s', ctx id '%.4s', soft limit: %u, hard_limit: %u\n",
    1291             :                      app_id_value, ctx_id_value, soft_limit, hard_limit);
    1292             :         } else {
    1293             :             dlt_vlog(LOG_INFO,
    1294             :                      "Configured trace limits for app id '%.4s', soft limit: %u, hard_limit: %u\n",
    1295             :                      app_id_value, soft_limit, hard_limit);
    1296             :         }
    1297             : 
    1298             : 
    1299             : 
    1300             :     } /* while */
    1301             :     fclose(pFile);
    1302             : 
    1303             :     // sort limits to improve search performance
    1304             :     qsort(daemon->preconfigured_trace_load_settings, daemon->preconfigured_trace_load_settings_count,
    1305             :           sizeof(DltTraceLoadSettings),
    1306             :           dlt_daemon_compare_trace_load_settings);
    1307             :     return 0;
    1308             : }
    1309             : #endif
    1310             : 
    1311           9 : static int dlt_mkdir_recursive(const char *dir)
    1312             : {
    1313             :     int ret = 0;
    1314             :     char tmp[PATH_MAX + 1];
    1315             :     char *p = NULL;
    1316             :     char *end = NULL;
    1317             :     size_t len;
    1318             : 
    1319             :     strncpy(tmp, dir, PATH_MAX);
    1320           9 :     len = strlen(tmp);
    1321             : 
    1322           9 :     if (tmp[len - 1] == '/')
    1323           0 :         tmp[len - 1] = 0;
    1324             : 
    1325           9 :     end = tmp + len;
    1326             : 
    1327          36 :     for (p = tmp + 1; ((*p) && (ret == 0)) || ((ret == -1 && errno == EEXIST) && (p != end)); p++)
    1328          27 :         if (*p == '/') {
    1329           0 :             *p = 0;
    1330             : 
    1331           0 :             if (access(tmp, F_OK) != 0 && errno == ENOENT) {
    1332           0 :                 ret = mkdir(tmp,
    1333             :                 #ifdef DLT_DAEMON_USE_FIFO_IPC
    1334             :                                 S_IRWXU);
    1335             :                 #else
    1336             :                     S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IROTH  | S_IWOTH /*S_IRWXU*/);
    1337             :                 #endif
    1338             :             }
    1339             : 
    1340           0 :             *p = '/';
    1341             :         }
    1342             : 
    1343             : 
    1344             : 
    1345           9 :     if ((ret == 0) || ((ret == -1) && (errno == EEXIST)))
    1346           9 :         ret = mkdir(tmp,
    1347             :         #ifdef DLT_DAEMON_USE_FIFO_IPC
    1348             :                     S_IRWXU);
    1349             :         #else
    1350             :                     S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IROTH  | S_IWOTH /*S_IRWXU*/);
    1351             :         #endif
    1352             : 
    1353           9 :     if ((ret == -1) && (errno == EEXIST))
    1354             :         ret = 0;
    1355             : 
    1356           9 :     return ret;
    1357             : }
    1358             : 
    1359             : #ifdef DLT_DAEMON_USE_FIFO_IPC
    1360           9 : static DltReturnValue dlt_daemon_create_pipes_dir(char *dir)
    1361             : {
    1362             :     int ret = DLT_RETURN_OK;
    1363             : 
    1364           9 :     if (dir == NULL) {
    1365           0 :         dlt_vlog(LOG_ERR, "%s: Invalid parameter\n", __func__);
    1366           0 :         return DLT_RETURN_WRONG_PARAMETER;
    1367             :     }
    1368             : 
    1369             :     /* create dlt pipes directory */
    1370           9 :     ret = mkdir(dir,
    1371             :                 S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH | S_ISVTX);
    1372             : 
    1373           9 :     if ((ret == -1) && (errno != EEXIST)) {
    1374           0 :         dlt_vlog(LOG_ERR,
    1375             :                  "FIFO user dir %s cannot be created (%s)!\n",
    1376             :                  dir,
    1377             :                  strerror(errno));
    1378             : 
    1379           0 :         return DLT_RETURN_ERROR;
    1380             :     }
    1381             : 
    1382             :     /* S_ISGID cannot be set by mkdir, let's reassign right bits */
    1383           9 :     ret = chmod(dir,
    1384             :                 S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH | S_ISGID |
    1385             :                 S_ISVTX);
    1386             : 
    1387           9 :     if (ret == -1) {
    1388           0 :         dlt_vlog(LOG_ERR,
    1389             :                  "FIFO user dir %s cannot be chmoded (%s)!\n",
    1390             :                  dir,
    1391           0 :                  strerror(errno));
    1392             : 
    1393           0 :         return DLT_RETURN_ERROR;
    1394             :     }
    1395             : 
    1396             :     return ret;
    1397             : }
    1398             : #endif
    1399             : // This will be defined when unit testing, so functions
    1400             : // from this file can be tested without defining main twice
    1401             : #ifndef DLT_DAEMON_UNIT_TESTS_NO_MAIN
    1402             : /**
    1403             :  * Main function of tool.
    1404             :  */
    1405           9 : int main(int argc, char *argv[])
    1406             : {
    1407             :     char version[DLT_DAEMON_TEXTBUFSIZE];
    1408             :     char local_str[DLT_DAEMON_TEXTBUFSIZE];
    1409             :     DltDaemonLocal daemon_local;
    1410             :     DltDaemon daemon;
    1411             :     int back = 0;
    1412             : 
    1413             :     memset(&daemon_local, 0, sizeof(DltDaemonLocal));
    1414             :     memset(&daemon, 0, sizeof(DltDaemon));
    1415             : 
    1416             :     /* Command line option handling */
    1417           9 :     if ((back = option_handling(&daemon_local, argc, argv)) < 0) {
    1418           0 :         if (back != -2)
    1419           0 :             fprintf (stderr, "option_handling() failed!\n");
    1420             : 
    1421           0 :         return -1;
    1422             :     }
    1423             : 
    1424             :     /* Configuration file option handling */
    1425           9 :     if ((back = option_file_parser(&daemon_local)) < 0) {
    1426           0 :         if (back != -2)
    1427           0 :             fprintf (stderr, "option_file_parser() failed!\n");
    1428             : 
    1429           0 :         return -1;
    1430             :     }
    1431             : 
    1432             :     /* Initialize internal logging facility */
    1433           9 :     dlt_log_set_filename(daemon_local.flags.loggingFilename);
    1434           9 :     dlt_log_set_level(daemon_local.flags.loggingLevel);
    1435             :     DltReturnValue log_init_result =
    1436           9 :             dlt_log_init_multiple_logfiles_support(daemon_local.flags.loggingMode,
    1437           9 :                                                    daemon_local.flags.enableLoggingFileLimit,
    1438             :                                                    daemon_local.flags.loggingFileSize,
    1439             :                                                    daemon_local.flags.loggingFileMaxSize);
    1440             : 
    1441           9 :     if (log_init_result != DLT_RETURN_OK) {
    1442           0 :       fprintf(stderr, "Failed to init internal logging\n");
    1443             : 
    1444             : #if WITH_DLT_FILE_LOGGING_SYSLOG_FALLBACK
    1445             :         if (daemon_local.flags.loggingMode == DLT_LOG_TO_FILE) {
    1446             :           fprintf(stderr, "Falling back to syslog mode\n");
    1447             : 
    1448             :           daemon_local.flags.loggingMode = DLT_LOG_TO_SYSLOG;
    1449             :           log_init_result = dlt_log_init(daemon_local.flags.loggingMode);
    1450             :           if (log_init_result != DLT_RETURN_OK) {
    1451             :             fprintf(stderr, "Failed to setup syslog logging, internal logs will "
    1452             :                             "not be available\n");
    1453             :           }
    1454             :       }
    1455             : #endif
    1456             :     }
    1457             : 
    1458             :     /* Print version information */
    1459           9 :     dlt_get_version(version, DLT_DAEMON_TEXTBUFSIZE);
    1460             : 
    1461           9 :     dlt_vlog(LOG_NOTICE, "Starting DLT Daemon; %s\n", version);
    1462             : 
    1463           9 :     PRINT_FUNCTION_VERBOSE(daemon_local.flags.vflag);
    1464             : 
    1465             : /* Make sure the parent user directory is created */
    1466             : #ifdef DLT_DAEMON_USE_FIFO_IPC
    1467             : 
    1468           9 :     if (dlt_mkdir_recursive(dltFifoBaseDir) != 0) {
    1469           0 :         dlt_vlog(LOG_ERR, "Base dir %s cannot be created!\n", dltFifoBaseDir);
    1470           0 :         return -1;
    1471             :   }
    1472             : 
    1473             : #else
    1474             :     if (dlt_mkdir_recursive(DLT_USER_IPC_PATH) != 0) {
    1475             :         dlt_vlog(LOG_ERR, "Base dir %s cannot be created!\n", daemon_local.flags.appSockPath);
    1476             :         return -1;
    1477             :     }
    1478             : 
    1479             : #endif
    1480             : 
    1481             :     /* --- Daemon init phase 1 begin --- */
    1482           9 :     if (dlt_daemon_local_init_p1(&daemon, &daemon_local, daemon_local.flags.vflag) == -1) {
    1483           0 :         dlt_log(LOG_CRIT, "Initialization of phase 1 failed!\n");
    1484           0 :         return -1;
    1485             :     }
    1486             : 
    1487             :     /* --- Daemon init phase 1 end --- */
    1488             : 
    1489           9 :     if (dlt_daemon_prepare_event_handling(&daemon_local.pEvent)) {
    1490             :         /* TODO: Perform clean-up */
    1491           0 :         dlt_log(LOG_CRIT, "Initialization of event handling failed!\n");
    1492           0 :         return -1;
    1493             :     }
    1494             : 
    1495             :     /* --- Daemon connection init begin */
    1496           9 :     if (dlt_daemon_local_connection_init(&daemon, &daemon_local, daemon_local.flags.vflag) == -1) {
    1497           0 :         dlt_log(LOG_CRIT, "Initialization of local connections failed!\n");
    1498           0 :         return -1;
    1499             :     }
    1500             : 
    1501             :     /* --- Daemon connection init end */
    1502             : 
    1503           9 :     if (dlt_daemon_init_runtime_configuration(&daemon, daemon_local.flags.ivalue, daemon_local.flags.vflag) == -1) {
    1504           0 :         dlt_log(LOG_ERR, "Could not load runtime config\n");
    1505           0 :         return -1;
    1506             :     }
    1507             : 
    1508             :     /*
    1509             :      * Load dlt-runtime.cfg if available.
    1510             :      * This must be loaded before offline setup
    1511             :      */
    1512           9 :     dlt_daemon_configuration_load(&daemon, daemon.runtime_configuration, daemon_local.flags.vflag);
    1513             : 
    1514             :     /* --- Daemon init phase 2 begin --- */
    1515           9 :     if (dlt_daemon_local_init_p2(&daemon, &daemon_local, daemon_local.flags.vflag) == -1) {
    1516           0 :         dlt_log(LOG_CRIT, "Initialization of phase 2 failed!\n");
    1517           0 :         return -1;
    1518             :     }
    1519             : 
    1520             : #ifdef DLT_LOG_LEVEL_APP_CONFIG
    1521             :     /* Load control app id level configuration file without setting `back` to
    1522             :      * prevent exit if file is missing */
    1523             :     if (app_id_default_log_level_config_parser(&daemon, &daemon_local) < 0) {
    1524             :         dlt_vlog(LOG_WARNING, "app_id_default_log_level_config_parser() failed, "
    1525             :                            "no app specific log levels will be configured\n");
    1526             :     }
    1527             : #endif
    1528             : 
    1529             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
    1530             :     /* Load control trace load configuration file without setting `back` to prevent exit if file is missing */
    1531             :     pthread_rwlock_init(&trace_load_rw_lock, NULL);
    1532             :     if (trace_load_config_file_parser(&daemon, &daemon_local) < 0) {
    1533             :         dlt_vlog(LOG_WARNING, "trace_load_config_file_parser() failed, using defaults for all app ids!\n");
    1534             :     }
    1535             : #endif
    1536             : 
    1537             :     /* --- Daemon init phase 2 end --- */
    1538             : 
    1539           9 :     if (daemon_local.flags.offlineLogstorageDirPath[0])
    1540           6 :         if (dlt_daemon_logstorage_setup_internal_storage(
    1541             :                 &daemon,
    1542             :                 &daemon_local,
    1543             :                 daemon_local.flags.offlineLogstorageDirPath,
    1544             :                 daemon_local.flags.vflag) == -1)
    1545           0 :             dlt_log(LOG_INFO,
    1546             :                     "Setting up internal offline log storage failed!\n");
    1547             : 
    1548             :     /* create fd for watchdog */
    1549             : #ifdef DLT_SYSTEMD_WATCHDOG_ENABLE
    1550             :     {
    1551             :         char *watchdogUSec = getenv("WATCHDOG_USEC");
    1552             :         int watchdogTimeoutSeconds = 0;
    1553             : 
    1554             :         dlt_log(LOG_DEBUG, "Systemd watchdog initialization\n");
    1555             : 
    1556             :         if (watchdogUSec)
    1557             :             watchdogTimeoutSeconds = atoi(watchdogUSec) / 2000000;
    1558             : 
    1559             :         daemon.watchdog_trigger_interval = watchdogTimeoutSeconds;
    1560             :         create_timer_fd(&daemon_local,
    1561             :                         watchdogTimeoutSeconds,
    1562             :                         watchdogTimeoutSeconds,
    1563             :                         DLT_TIMER_SYSTEMD);
    1564             :     }
    1565             : #endif
    1566             : 
    1567             :     /* create fd for timer timing packets */
    1568           9 :     create_timer_fd(&daemon_local, 1, 1, DLT_TIMER_PACKET);
    1569             : 
    1570             :     /* create fd for timer ecu version */
    1571           9 :     if ((daemon_local.flags.sendECUSoftwareVersion > 0) ||
    1572           9 :         (daemon_local.flags.sendTimezone > 0))
    1573           0 :         create_timer_fd(&daemon_local, 60, 60, DLT_TIMER_ECU);
    1574             : 
    1575             :     /* initiate gateway */
    1576           9 :     if (daemon_local.flags.gatewayMode == 1) {
    1577           1 :         if (dlt_gateway_init(&daemon_local, daemon_local.flags.vflag) == -1) {
    1578           0 :             dlt_log(LOG_CRIT, "Failed to create gateway\n");
    1579           0 :             return -1;
    1580             :         }
    1581             : 
    1582             :         /* create gateway timer */
    1583           1 :         create_timer_fd(&daemon_local,
    1584             :                         daemon_local.pGateway.interval,
    1585             :                         daemon_local.pGateway.interval,
    1586             :                         DLT_TIMER_GATEWAY);
    1587             :     }
    1588             : 
    1589             :     /* For offline tracing we still can use the same states */
    1590             :     /* as for socket sending. Using this trick we see the traces */
    1591             :     /* In the offline trace AND in the socket stream. */
    1592           9 :     if (daemon_local.flags.yvalue[0])
    1593           0 :         dlt_daemon_change_state(&daemon, DLT_DAEMON_STATE_SEND_DIRECT);
    1594             :     else
    1595           9 :         dlt_daemon_change_state(&daemon, DLT_DAEMON_STATE_BUFFER);
    1596             : 
    1597           9 :     dlt_daemon_init_user_information(&daemon,
    1598             :                                      &daemon_local.pGateway,
    1599             :                                      daemon_local.flags.gatewayMode,
    1600             :                                      daemon_local.flags.vflag);
    1601             : 
    1602             :     /*
    1603             :      * Check for app and ctx runtime cfg.
    1604             :      * These cfg must be loaded after ecuId and num_user_lists are available
    1605             :      */
    1606           9 :     if ((dlt_daemon_applications_load(&daemon, daemon.runtime_application_cfg,
    1607           0 :                                       daemon_local.flags.vflag) == 0) &&
    1608           0 :         (dlt_daemon_contexts_load(&daemon, daemon.runtime_context_cfg,
    1609             :                                   daemon_local.flags.vflag) == 0))
    1610           0 :         daemon.runtime_context_cfg_loaded = 1;
    1611             : 
    1612           9 :     dlt_daemon_log_internal(&daemon, &daemon_local,
    1613             :                             "Daemon launched. Starting to output traces...",
    1614             :                             DLT_LOG_INFO, DLT_DAEMON_APP_ID, DLT_DAEMON_CTX_ID,
    1615             :                             daemon_local.flags.vflag);
    1616             : 
    1617             :     /* Even handling loop. */
    1618        1355 :     while ((back >= 0) && (g_exit >= 0))
    1619        1346 :         back = dlt_daemon_handle_event(&daemon_local.pEvent,
    1620             :                                        &daemon,
    1621             :                                        &daemon_local);
    1622             : 
    1623           9 :     snprintf(local_str, DLT_DAEMON_TEXTBUFSIZE, "Exiting DLT daemon... [%d]",
    1624             :              g_signo);
    1625           9 :     dlt_daemon_log_internal(&daemon, &daemon_local, local_str, DLT_LOG_INFO,
    1626             :                             DLT_DAEMON_APP_ID, DLT_DAEMON_CTX_ID,
    1627             :                             daemon_local.flags.vflag);
    1628           9 :     dlt_vlog(LOG_NOTICE, "%s%s", local_str, "\n");
    1629             : 
    1630           9 :     dlt_daemon_local_cleanup(&daemon, &daemon_local, daemon_local.flags.vflag);
    1631             : 
    1632             : #ifdef UDP_CONNECTION_SUPPORT
    1633             :     dlt_daemon_udp_close_connection();
    1634             : #endif
    1635             : 
    1636           9 :     dlt_gateway_deinit(&daemon_local.pGateway, daemon_local.flags.vflag);
    1637             : 
    1638           9 :     dlt_daemon_free(&daemon, daemon_local.flags.vflag);
    1639             : 
    1640           9 :     dlt_log(LOG_NOTICE, "Leaving DLT daemon\n");
    1641             : 
    1642           9 :     dlt_log_free();
    1643             : 
    1644           9 :     return 0;
    1645             : 
    1646             : } /* main() */
    1647             : #endif
    1648             : 
    1649           9 : int dlt_daemon_local_init_p1(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose)
    1650             : {
    1651           9 :     PRINT_FUNCTION_VERBOSE(verbose);
    1652             :     int ret = DLT_RETURN_OK;
    1653             : 
    1654           9 :     if ((daemon == 0) || (daemon_local == 0)) {
    1655           0 :         dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_local_init_p1()\n");
    1656           0 :         return -1;
    1657             :     }
    1658             : 
    1659             : #if defined(DLT_SYSTEMD_WATCHDOG_ENABLE) || defined(DLT_SYSTEMD_ENABLE)
    1660             :     ret = sd_booted();
    1661             : 
    1662             :     if (ret == 0) {
    1663             :         dlt_log(LOG_CRIT, "System not booted with systemd!\n");
    1664             :     }
    1665             :     else if (ret < 0)
    1666             :     {
    1667             :         dlt_log(LOG_CRIT, "sd_booted failed!\n");
    1668             :         return -1;
    1669             :     }
    1670             :     else {
    1671             :         dlt_log(LOG_INFO, "System booted with systemd\n");
    1672             :     }
    1673             : 
    1674             : #endif
    1675             : 
    1676             : #ifdef DLT_DAEMON_USE_FIFO_IPC
    1677             : 
    1678           9 :     if (dlt_daemon_create_pipes_dir(daemon_local->flags.userPipesDir) == DLT_RETURN_ERROR)
    1679             :         return DLT_RETURN_ERROR;
    1680             : 
    1681             : #endif
    1682             : 
    1683             :     /* Check for daemon mode */
    1684           9 :     if (daemon_local->flags.dflag)
    1685           2 :         dlt_daemon_daemonize(daemon_local->flags.vflag);
    1686             : 
    1687             :     /* initialise structure to use DLT file */
    1688           9 :     ret = dlt_file_init(&(daemon_local->file), daemon_local->flags.vflag);
    1689             : 
    1690           9 :     if (ret == DLT_RETURN_ERROR) {
    1691           0 :         dlt_log(LOG_ERR, "Could not initialize file structure\n");
    1692             :         /* Return value ignored, dlt daemon will exit */
    1693           0 :         dlt_file_free(&(daemon_local->file), daemon_local->flags.vflag);
    1694           0 :         return ret;
    1695             :     }
    1696             : 
    1697           9 :     signal(SIGPIPE, SIG_IGN);
    1698             : 
    1699           9 :     signal(SIGTERM, dlt_daemon_signal_handler); /* software termination signal from kill */
    1700           9 :     signal(SIGHUP, dlt_daemon_signal_handler);  /* hangup signal */
    1701           9 :     signal(SIGQUIT, dlt_daemon_signal_handler);
    1702           9 :     signal(SIGINT, dlt_daemon_signal_handler);
    1703             : #ifdef __QNX__
    1704             :     signal(SIGUSR1, dlt_daemon_signal_handler); /* for timer threads */
    1705             : #endif
    1706             : 
    1707           9 :     return DLT_RETURN_OK;
    1708             : }
    1709             : 
    1710           9 : int dlt_daemon_local_init_p2(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose)
    1711             : {
    1712           9 :     PRINT_FUNCTION_VERBOSE(verbose);
    1713             : 
    1714           9 :     if ((daemon == 0) || (daemon_local == 0)) {
    1715           0 :         dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_local_init_p2()\n");
    1716           0 :         return -1;
    1717             :     }
    1718             : 
    1719             :     /* Daemon data */
    1720           9 :     if (dlt_daemon_init(daemon, daemon_local->RingbufferMinSize, daemon_local->RingbufferMaxSize,
    1721           9 :                         daemon_local->RingbufferStepSize, daemon_local->flags.ivalue,
    1722             :                         daemon_local->flags.contextLogLevel,
    1723             :                         daemon_local->flags.contextTraceStatus, daemon_local->flags.enforceContextLLAndTS,
    1724             :                         daemon_local->flags.vflag) == -1) {
    1725           0 :         dlt_log(LOG_ERR, "Could not initialize daemon data\n");
    1726           0 :         return -1;
    1727             :     }
    1728             : 
    1729             :     /* init offline trace */
    1730           9 :     if (((daemon->mode == DLT_USER_MODE_INTERNAL) || (daemon->mode == DLT_USER_MODE_BOTH)) &&
    1731           0 :         daemon_local->flags.offlineTraceDirectory[0]) {
    1732           0 :         if (multiple_files_buffer_init(&(daemon_local->offlineTrace),
    1733           0 :                                        daemon_local->flags.offlineTraceDirectory,
    1734             :                                        daemon_local->flags.offlineTraceFileSize,
    1735             :                                        daemon_local->flags.offlineTraceMaxSize,
    1736           0 :                                        daemon_local->flags.offlineTraceFilenameTimestampBased,
    1737             :                                        false,
    1738             :                                        DLT_OFFLINETRACE_FILENAME_BASE,
    1739             :                                        DLT_OFFLINETRACE_FILENAME_EXT) == -1) {
    1740           0 :             dlt_log(LOG_ERR, "Could not initialize offline trace\n");
    1741           0 :             return -1;
    1742             :         }
    1743             :     }
    1744             : 
    1745             :     /* Init offline logstorage for MAX devices */
    1746           9 :     if (daemon_local->flags.offlineLogstorageMaxDevices > 0) {
    1747           6 :         daemon->storage_handle = malloc(sizeof(DltLogStorage) * daemon_local->flags.offlineLogstorageMaxDevices);
    1748             : 
    1749           6 :         if (daemon->storage_handle == NULL) {
    1750           0 :             dlt_log(LOG_ERR, "Could not initialize offline logstorage\n");
    1751           0 :             return -1;
    1752             :         }
    1753             : 
    1754             :         memset(daemon->storage_handle, 0, (sizeof(DltLogStorage) * daemon_local->flags.offlineLogstorageMaxDevices));
    1755             :     }
    1756             : 
    1757             :     /* Set ECU id of daemon */
    1758           9 :     if (daemon_local->flags.evalue[0])
    1759           1 :         dlt_set_id(daemon->ecuid, daemon_local->flags.evalue);
    1760             :     else
    1761           8 :         dlt_set_id(daemon->ecuid, DLT_DAEMON_ECU_ID);
    1762             : 
    1763             :     /* Set flag for optional sending of serial header */
    1764           9 :     daemon->sendserialheader = daemon_local->flags.lflag;
    1765             : 
    1766             : #ifdef DLT_SHM_ENABLE
    1767             : 
    1768             :     /* init shared memory */
    1769             :     if (dlt_shm_init_server(&(daemon_local->dlt_shm), daemon_local->flags.dltShmName,
    1770             :                             daemon_local->flags.sharedMemorySize) == DLT_RETURN_ERROR) {
    1771             :         dlt_log(LOG_ERR, "Could not initialize shared memory\n");
    1772             :         return -1;
    1773             :     }
    1774             : 
    1775             :     daemon_local->recv_buf_shm = (unsigned char *)calloc(1, DLT_SHM_RCV_BUFFER_SIZE);
    1776             : 
    1777             :     if (NULL == daemon_local->recv_buf_shm) {
    1778             :         dlt_log(LOG_ERR, "failed to allocated the buffer to receive shm data\n");
    1779             :         return -1;
    1780             :     }
    1781             : 
    1782             : #endif
    1783             : 
    1784             :     /* prepare main loop */
    1785           9 :     if (dlt_message_init(&(daemon_local->msg), daemon_local->flags.vflag) == DLT_RETURN_ERROR) {
    1786           0 :         dlt_log(LOG_ERR, "Could not initialize message\n");
    1787           0 :         return -1;
    1788             :     }
    1789             : 
    1790             :     /* configure sending timing packets */
    1791           9 :     if (daemon_local->flags.sendMessageTime)
    1792           0 :         daemon->timingpackets = 1;
    1793             : 
    1794             :     /* Get ECU version info from a file. If it fails, use dlt_version as fallback. */
    1795           9 :     if (dlt_daemon_local_ecu_version_init(daemon, daemon_local, daemon_local->flags.vflag) < 0) {
    1796           9 :         daemon->ECUVersionString = malloc(DLT_DAEMON_TEXTBUFSIZE);
    1797             : 
    1798           9 :         if (daemon->ECUVersionString == 0) {
    1799           0 :             dlt_log(LOG_WARNING, "Could not allocate memory for version string\n");
    1800           0 :             return -1;
    1801             :         }
    1802             : 
    1803           9 :         dlt_get_version(daemon->ECUVersionString, DLT_DAEMON_TEXTBUFSIZE);
    1804             :     }
    1805             : 
    1806             :     /* Set to allows to maintain logstorage loglevel as default */
    1807           9 :     daemon->maintain_logstorage_loglevel = DLT_MAINTAIN_LOGSTORAGE_LOGLEVEL_ON;
    1808             : 
    1809           9 :     return 0;
    1810             : }
    1811             : 
    1812           9 : static int dlt_daemon_init_serial(DltDaemonLocal *daemon_local)
    1813             : {
    1814             :     /* create and open serial connection from/to client */
    1815             :     /* open serial connection */
    1816             :     int fd = -1;
    1817             : 
    1818           9 :     if (daemon_local->flags.yvalue[0] == '\0')
    1819             :         return 0;
    1820             : 
    1821           0 :     fd = open(daemon_local->flags.yvalue, O_RDWR);
    1822             : 
    1823           0 :     if (fd < 0) {
    1824           0 :         dlt_vlog(LOG_ERR, "Failed to open serial device %s\n",
    1825             :                  daemon_local->flags.yvalue);
    1826             : 
    1827           0 :         daemon_local->flags.yvalue[0] = 0;
    1828           0 :         return -1;
    1829             :     }
    1830             : 
    1831           0 :     if (isatty(fd)) {
    1832             :         int speed = DLT_DAEMON_SERIAL_DEFAULT_BAUDRATE;
    1833             : 
    1834           0 :         if (daemon_local->flags.bvalue[0])
    1835           0 :             speed = atoi(daemon_local->flags.bvalue);
    1836             : 
    1837           0 :         daemon_local->baudrate = dlt_convert_serial_speed(speed);
    1838             : 
    1839           0 :         if (dlt_setup_serial(fd, (speed_t) daemon_local->baudrate) < 0) {
    1840           0 :             close(fd);
    1841           0 :             daemon_local->flags.yvalue[0] = 0;
    1842             : 
    1843           0 :             dlt_vlog(LOG_ERR, "Failed to configure serial device %s (%s) \n",
    1844           0 :                      daemon_local->flags.yvalue, strerror(errno));
    1845             : 
    1846           0 :             return -1;
    1847             :         }
    1848             : 
    1849           0 :         if (daemon_local->flags.vflag)
    1850           0 :             dlt_log(LOG_DEBUG, "Serial init done\n");
    1851             :     }
    1852             :     else {
    1853           0 :         close(fd);
    1854           0 :         fprintf(stderr,
    1855             :                 "Device is not a serial device, device = %s (%s) \n",
    1856             :                 daemon_local->flags.yvalue,
    1857           0 :                 strerror(errno));
    1858           0 :         daemon_local->flags.yvalue[0] = 0;
    1859           0 :         return -1;
    1860             :     }
    1861             : 
    1862           0 :     return dlt_connection_create(daemon_local,
    1863             :                                  &daemon_local->pEvent,
    1864             :                                  fd,
    1865             :                                  POLLIN,
    1866             :                                  DLT_CONNECTION_CLIENT_MSG_SERIAL);
    1867             : }
    1868             : 
    1869             : #ifdef DLT_DAEMON_USE_FIFO_IPC
    1870           9 : static int dlt_daemon_init_fifo(DltDaemonLocal *daemon_local)
    1871             : {
    1872             :     int ret;
    1873             :     int fd = -1;
    1874             :     int fifo_size;
    1875             : 
    1876             :     /* open named pipe(FIFO) to receive DLT messages from users */
    1877           9 :     umask(0);
    1878             : 
    1879             :     /* Try to delete existing pipe, ignore result of unlink */
    1880           9 :     const char *tmpFifo = daemon_local->flags.daemonFifoName;
    1881           9 :     unlink(tmpFifo);
    1882             : 
    1883           9 :     ret = mkfifo(tmpFifo, S_IRUSR | S_IWUSR | S_IWGRP);
    1884             : 
    1885           9 :     if (ret == -1) {
    1886           0 :         dlt_vlog(LOG_WARNING, "FIFO user %s cannot be created (%s)!\n",
    1887           0 :                  tmpFifo, strerror(errno));
    1888           0 :         return -1;
    1889             :     } /* if */
    1890             : 
    1891             :     /* Set group of daemon FIFO */
    1892           9 :     if (daemon_local->flags.daemonFifoGroup[0] != 0) {
    1893           0 :         errno = 0;
    1894           0 :         struct group *group_dlt = getgrnam(daemon_local->flags.daemonFifoGroup);
    1895             : 
    1896           0 :         if (group_dlt) {
    1897           0 :             ret = chown(tmpFifo, -1, group_dlt->gr_gid);
    1898             : 
    1899           0 :             if (ret == -1)
    1900           0 :                 dlt_vlog(LOG_ERR, "FIFO user %s cannot be chowned to group %s (%s)\n",
    1901             :                          tmpFifo, daemon_local->flags.daemonFifoGroup,
    1902             :                          strerror(errno));
    1903             :         }
    1904           0 :         else if ((errno == 0) || (errno == ENOENT) || (errno == EBADF) || (errno == EPERM))
    1905             :         {
    1906           0 :             dlt_vlog(LOG_ERR, "Group name %s is not found (%s)\n",
    1907             :                      daemon_local->flags.daemonFifoGroup,
    1908             :                      strerror(errno));
    1909             :         }
    1910             :         else {
    1911           0 :             dlt_vlog(LOG_ERR, "Failed to get group id of %s (%s)\n",
    1912             :                      daemon_local->flags.daemonFifoGroup,
    1913             :                      strerror(errno));
    1914             :         }
    1915             :     }
    1916             : 
    1917             :     fd = open(tmpFifo, O_RDWR);
    1918             : 
    1919           9 :     if (fd == -1) {
    1920           0 :         dlt_vlog(LOG_WARNING, "FIFO user %s cannot be opened (%s)!\n",
    1921           0 :                  tmpFifo, strerror(errno));
    1922           0 :         return -1;
    1923             :     } /* if */
    1924             : 
    1925             : #ifdef __linux__
    1926             :     /* F_SETPIPE_SZ and F_GETPIPE_SZ are only supported for Linux.
    1927             :      * For other OSes it depends on its system e.g. pipe manager.
    1928             :      */
    1929           9 :     if (daemon_local->daemonFifoSize != 0) {
    1930             :         /* Set Daemon FIFO size */
    1931           0 :         if (fcntl(fd, F_SETPIPE_SZ, daemon_local->daemonFifoSize) == -1)
    1932           0 :             dlt_vlog(LOG_ERR, "set FIFO size error: %s\n", strerror(errno));
    1933             :     }
    1934             : 
    1935             :     /* Get Daemon FIFO size */
    1936           9 :     if ((fifo_size = fcntl(fd, F_GETPIPE_SZ, 0)) == -1)
    1937           0 :         dlt_vlog(LOG_ERR, "get FIFO size error: %s\n", strerror(errno));
    1938             :     else
    1939           9 :         dlt_vlog(LOG_INFO, "FIFO size: %d\n", fifo_size);
    1940             : #endif
    1941             : 
    1942             :     /* Early init, to be able to catch client (app) connections
    1943             :      * as soon as possible. This registration is automatically ignored
    1944             :      * during next execution.
    1945             :      */
    1946           9 :     return dlt_connection_create(daemon_local,
    1947             :                                  &daemon_local->pEvent,
    1948             :                                  fd,
    1949             :                                  POLLIN,
    1950             :                                  DLT_CONNECTION_APP_MSG);
    1951             : }
    1952             : #endif
    1953             : 
    1954             : #ifdef DLT_DAEMON_VSOCK_IPC_ENABLE
    1955             : static int dlt_daemon_init_vsock(DltDaemonLocal *daemon_local)
    1956             : {
    1957             :     int fd;
    1958             :     struct sockaddr_vm addr;
    1959             : 
    1960             :     fd = socket(AF_VSOCK, SOCK_STREAM, 0);
    1961             :     if (fd == -1) {
    1962             :         dlt_vlog(LOG_ERR, "Failed to create VSOCK socket: %s\n", strerror(errno));
    1963             :         return -1;
    1964             :     }
    1965             : 
    1966             :     memset(&addr, 0, sizeof(addr));
    1967             :     addr.svm_family = AF_VSOCK;
    1968             :     addr.svm_port = DLT_VSOCK_PORT;
    1969             :     addr.svm_cid = VMADDR_CID_ANY;
    1970             : 
    1971             :     if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) != 0) {
    1972             :         dlt_vlog(LOG_ERR, "Failed to bind VSOCK socket: %s\n", strerror(errno));
    1973             :         close(fd);
    1974             :         return -1;
    1975             :     }
    1976             : 
    1977             :     if (listen(fd, 1) != 0) {
    1978             :         dlt_vlog(LOG_ERR, "Failed to listen on VSOCK socket: %s\n", strerror(errno));
    1979             :         close(fd);
    1980             :         return -1;
    1981             :     }
    1982             : 
    1983             :     return dlt_connection_create(daemon_local,
    1984             :                                  &daemon_local->pEvent,
    1985             :                                  fd,
    1986             :                                  POLLIN,
    1987             :                                  DLT_CONNECTION_APP_CONNECT);
    1988             : }
    1989             : #endif
    1990             : 
    1991             : #ifdef DLT_DAEMON_USE_UNIX_SOCKET_IPC
    1992             : static DltReturnValue dlt_daemon_init_app_socket(DltDaemonLocal *daemon_local)
    1993             : {
    1994             :     /* socket access permission set to srw-rw-rw- (666) */
    1995             :     int mask = S_IXUSR | S_IXGRP | S_IXOTH;
    1996             :     DltReturnValue ret = DLT_RETURN_OK;
    1997             :     int fd = -1;
    1998             : 
    1999             :     if (daemon_local == NULL) {
    2000             :         dlt_vlog(LOG_ERR, "%s: Invalid function parameters\n", __func__);
    2001             :         return DLT_RETURN_ERROR;
    2002             :     }
    2003             : 
    2004             : #ifdef ANDROID
    2005             :     /* on android if we want to use security contexts on Unix sockets,
    2006             :      * they should be created by init (see dlt-daemon.rc in src/daemon)
    2007             :      * and recovered through the below API */
    2008             :     ret = dlt_daemon_unix_android_get_socket(&fd, daemon_local->flags.appSockPath);
    2009             :     if (ret < DLT_RETURN_OK) {
    2010             :         /* we failed to get app socket created by init.
    2011             :          * To avoid blocking users to launch dlt-daemon only through
    2012             :          * init on android (e.g: by hand for debugging purpose), try to
    2013             :          * create app socket by ourselves */
    2014             :         ret = dlt_daemon_unix_socket_open(&fd,
    2015             :                                           daemon_local->flags.appSockPath,
    2016             :                                           SOCK_STREAM,
    2017             :                                           mask);
    2018             :     }
    2019             : #else
    2020             :     ret = dlt_daemon_unix_socket_open(&fd,
    2021             :                                       daemon_local->flags.appSockPath,
    2022             :                                       SOCK_STREAM,
    2023             :                                       mask);
    2024             : #endif
    2025             :     if (ret == DLT_RETURN_OK) {
    2026             :         if (dlt_connection_create(daemon_local,
    2027             :                                   &daemon_local->pEvent,
    2028             :                                   fd,
    2029             :                                   POLLIN,
    2030             :                                   DLT_CONNECTION_APP_CONNECT)) {
    2031             :             dlt_log(LOG_CRIT, "Could not create connection for app socket.\n");
    2032             :             return DLT_RETURN_ERROR;
    2033             :         }
    2034             :     }
    2035             :     else {
    2036             :         dlt_log(LOG_CRIT, "Could not create and open app socket.\n");
    2037             :         return DLT_RETURN_ERROR;
    2038             :     }
    2039             : 
    2040             :     return ret;
    2041             : }
    2042             : #endif
    2043             : 
    2044           9 : static DltReturnValue dlt_daemon_initialize_control_socket(DltDaemonLocal *daemon_local)
    2045             : {
    2046             :     /* socket access permission set to srw-rw---- (660)  */
    2047             :     int mask = S_IXUSR | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH;
    2048             :     DltReturnValue ret = DLT_RETURN_OK;
    2049           9 :     int fd = -1;
    2050             : 
    2051           9 :     if (daemon_local == NULL) {
    2052           0 :         dlt_vlog(LOG_ERR, "%s: Invalid function parameters\n", __func__);
    2053           0 :         return -1;
    2054             :     }
    2055             : 
    2056             : #ifdef ANDROID
    2057             :     /* on android if we want to use security contexts on Unix sockets,
    2058             :      * they should be created by init (see dlt-daemon.rc in src/daemon)
    2059             :      * and recovered through the below API */
    2060             :     ret = dlt_daemon_unix_android_get_socket(&fd, daemon_local->flags.ctrlSockPath);
    2061             :     if (ret < DLT_RETURN_OK) {
    2062             :         /* we failed to get app socket created by init.
    2063             :          * To avoid blocking users to launch dlt-daemon only through
    2064             :          * init on android (e.g by hand for debugging purpose), try to
    2065             :          * create app socket by ourselves */
    2066             :         ret = dlt_daemon_unix_socket_open(&fd,
    2067             :                                           daemon_local->flags.ctrlSockPath,
    2068             :                                           SOCK_STREAM,
    2069             :                                           mask);
    2070             :     }
    2071             : #else
    2072           9 :     ret = dlt_daemon_unix_socket_open(&fd,
    2073           9 :                                       daemon_local->flags.ctrlSockPath,
    2074             :                                       SOCK_STREAM,
    2075             :                                       mask);
    2076             : #endif
    2077           9 :     if (ret == DLT_RETURN_OK) {
    2078           9 :         if (dlt_connection_create(daemon_local,
    2079             :                                   &daemon_local->pEvent,
    2080             :                                   fd,
    2081             :                                   POLLIN,
    2082             :                                   DLT_CONNECTION_CONTROL_CONNECT) < DLT_RETURN_OK) {
    2083           0 :             dlt_log(LOG_ERR, "Could not initialize control socket.\n");
    2084             :             ret = DLT_RETURN_ERROR;
    2085             :         }
    2086             :     }
    2087             : 
    2088             :     return ret;
    2089             : }
    2090             : 
    2091           9 : int dlt_daemon_local_connection_init(DltDaemon *daemon,
    2092             :                                      DltDaemonLocal *daemon_local,
    2093             :                                      int verbose)
    2094             : {
    2095           9 :     int fd = -1;
    2096             : 
    2097           9 :     PRINT_FUNCTION_VERBOSE(verbose);
    2098             : 
    2099           9 :     if ((daemon == NULL) || (daemon_local == NULL)) {
    2100           0 :         dlt_vlog(LOG_ERR, "%s: Invalid function parameters\n", __func__);
    2101           0 :         return -1;
    2102             :     }
    2103             : 
    2104           9 :     DltBindAddress_t *head = daemon_local->flags.ipNodes;
    2105             : 
    2106             : #ifdef DLT_DAEMON_USE_UNIX_SOCKET_IPC
    2107             :     /* create and open socket to receive incoming connections from user application */
    2108             :     if (dlt_daemon_init_app_socket(daemon_local) < DLT_RETURN_OK) {
    2109             :         dlt_log(LOG_ERR, "Unable to initialize app socket.\n");
    2110             :         return DLT_RETURN_ERROR;
    2111             :     }
    2112             : 
    2113             : #else /* DLT_DAEMON_USE_FIFO_IPC */
    2114             : 
    2115           9 :     if (dlt_daemon_init_fifo(daemon_local)) {
    2116           0 :         dlt_log(LOG_ERR, "Unable to initialize fifo.\n");
    2117           0 :         return DLT_RETURN_ERROR;
    2118             :     }
    2119             : 
    2120             : #endif
    2121             : 
    2122             : #ifdef DLT_DAEMON_VSOCK_IPC_ENABLE
    2123             :     if (dlt_daemon_init_vsock(daemon_local) != 0) {
    2124             :         dlt_log(LOG_ERR, "Unable to initialize app VSOCK socket.\n");
    2125             :         return DLT_RETURN_ERROR;
    2126             :     }
    2127             : #endif
    2128             : 
    2129             :     /* create and open socket to receive incoming connections from client */
    2130           9 :     daemon_local->client_connections = 0;
    2131             : 
    2132           9 :     if (head == NULL) { /* no IP set in BindAddress option, will use "0.0.0.0" as default */
    2133             : 
    2134           9 :         if (dlt_daemon_socket_open(&fd, daemon_local->flags.port, "0.0.0.0") == DLT_RETURN_OK) {
    2135           9 :             if (dlt_connection_create(daemon_local,
    2136             :                                       &daemon_local->pEvent,
    2137             :                                       fd,
    2138             :                                       POLLIN,
    2139             :                                       DLT_CONNECTION_CLIENT_CONNECT)) {
    2140           0 :                 dlt_log(LOG_ERR, "Could not initialize main socket.\n");
    2141           0 :                 return DLT_RETURN_ERROR;
    2142             :             }
    2143             :         }
    2144             :         else {
    2145           0 :             dlt_log(LOG_ERR, "Could not initialize main socket.\n");
    2146           0 :             return DLT_RETURN_ERROR;
    2147             :         }
    2148             :     }
    2149             :     else {
    2150             :         bool any_open = false;
    2151           0 :         while (head != NULL) { /* open socket for each IP in the bindAddress list */
    2152             : 
    2153           0 :             if (dlt_daemon_socket_open(&fd, daemon_local->flags.port, head->ip) == DLT_RETURN_OK) {
    2154           0 :                 if (dlt_connection_create(daemon_local,
    2155             :                                           &daemon_local->pEvent,
    2156             :                                           fd,
    2157             :                                           POLLIN,
    2158             :                                           DLT_CONNECTION_CLIENT_CONNECT)) {
    2159           0 :                     dlt_vlog(LOG_ERR, "Could not create connection, for binding %s\n", head->ip);
    2160             :                 } else {
    2161             :                     any_open = true;
    2162             :                 }
    2163             :             }
    2164             :             else {
    2165           0 :                 dlt_vlog(LOG_ERR, "Could not open main socket, for binding %s\n", head->ip);
    2166             :             }
    2167             : 
    2168           0 :             head = head->next;
    2169             :         }
    2170             : 
    2171           0 :         if (!any_open) {
    2172           0 :             dlt_vlog(LOG_ERR, "Failed create main socket for any configured binding\n");
    2173           0 :             return DLT_RETURN_ERROR;
    2174             :         }
    2175             :     }
    2176             : 
    2177             : #ifdef UDP_CONNECTION_SUPPORT
    2178             : 
    2179             :     if (daemon_local->UDPConnectionSetup == MULTICAST_CONNECTION_ENABLED) {
    2180             :         if (dlt_daemon_udp_connection_setup(daemon_local) < 0) {
    2181             :             dlt_log(LOG_ERR, "UDP fd creation failed\n");
    2182             :             return DLT_RETURN_ERROR;
    2183             :         }
    2184             :         else {
    2185             :             dlt_log(LOG_INFO, "UDP fd creation success\n");
    2186             :         }
    2187             :     }
    2188             : 
    2189             : #endif
    2190             : 
    2191             :     /* create and open unix socket to receive incoming connections from
    2192             :      * control application */
    2193           9 :     if (dlt_daemon_initialize_control_socket(daemon_local) < DLT_RETURN_OK) {
    2194           0 :         dlt_log(LOG_ERR, "Could not initialize control socket.\n");
    2195           0 :         return DLT_RETURN_ERROR;
    2196             :     }
    2197             : 
    2198             :     /* Init serial */
    2199           9 :     if (dlt_daemon_init_serial(daemon_local) < 0) {
    2200           0 :         dlt_log(LOG_ERR, "Could not initialize daemon data\n");
    2201           0 :         return DLT_RETURN_ERROR;
    2202             :     }
    2203             : 
    2204             :     return 0;
    2205             : }
    2206             : 
    2207           0 : static char* file_read_everything(FILE* const file, const size_t sizeLimit)
    2208             : {
    2209           0 :     if (!file) {
    2210             :         return NULL;
    2211             :     }
    2212             : 
    2213             :     /* Get the file size. Bail out if stat fails. */
    2214           0 :     const int fd = fileno(file);
    2215           0 :     struct stat s_buf = {0};
    2216           0 :     if (fstat(fd, &s_buf) < 0) {
    2217           0 :         dlt_log(LOG_WARNING, "failed to stat file size\n");
    2218           0 :         fclose(file);
    2219           0 :         return NULL;
    2220             :     }
    2221             : 
    2222             :     /* Size limit includes NULL terminator. */
    2223           0 :     const off_t size = s_buf.st_size;
    2224           0 :     if (size < 0 || size >= sizeLimit) {
    2225           0 :         dlt_log(LOG_WARNING, "file size invalid\n");
    2226           0 :         fclose(file);
    2227           0 :         return NULL;
    2228             :     }
    2229             : 
    2230           0 :     char* const string = malloc((size_t)size + 1);
    2231           0 :     if (!string) {
    2232           0 :         dlt_log(LOG_WARNING, "failed to allocate string for file contents\n");
    2233           0 :         fclose(file);
    2234           0 :         return NULL;
    2235             :     }
    2236             : 
    2237             :     off_t offset = 0;
    2238           0 :     while (!feof(file)) {
    2239           0 :         offset += (off_t)fread(string + offset, 1, (size_t)size, file);
    2240             : 
    2241           0 :         if (ferror(file)) {
    2242           0 :             dlt_log(LOG_WARNING, "failed to read file\n");
    2243           0 :             free(string);
    2244           0 :             fclose(file);
    2245           0 :             return NULL;
    2246             :         }
    2247             : 
    2248           0 :         if (offset > size) {
    2249           0 :             dlt_log(LOG_WARNING, "file too long for buffer\n");
    2250           0 :             free(string);
    2251           0 :             fclose(file);
    2252           0 :             return NULL;
    2253             :         }
    2254             :     }
    2255             : 
    2256           0 :     string[offset] = '\0'; /* append null termination at end of string */
    2257             : 
    2258           0 :     return string;
    2259             : }
    2260             : 
    2261           0 : static char* file_read_field(FILE* const file, const char* const fieldName)
    2262             : {
    2263           0 :     if (!file) {
    2264             :         return NULL;
    2265             :     }
    2266             : 
    2267             :     const char* const kDelimiters = "\r\n\"\'=";
    2268           0 :     const size_t fieldNameLen = strlen(fieldName);
    2269             : 
    2270             :     char* result = NULL;
    2271             : 
    2272           0 :     char* buffer = NULL;
    2273           0 :     ssize_t bufferSize = 0;
    2274             : 
    2275             :     while (true) {
    2276             :         ssize_t lineSize = getline(&buffer, &bufferSize, file);
    2277           0 :         if (lineSize < 0 || !buffer) {
    2278             :             /* end of file */
    2279             :             break;
    2280             :         }
    2281             : 
    2282             :         char* line = buffer;
    2283             : 
    2284             :         /* trim trailing delimiters */
    2285           0 :         while (lineSize >= 1 && strchr(kDelimiters, line[lineSize - 1]) != NULL) {
    2286           0 :             line[lineSize - 1] = '\0';
    2287           0 :             --lineSize;
    2288             :         }
    2289             : 
    2290             :         /* check fieldName */
    2291           0 :         if (   strncmp(line, fieldName, fieldNameLen) == 0
    2292           0 :             && lineSize >= (fieldNameLen + 1)
    2293           0 :             && strchr(kDelimiters, line[fieldNameLen]) != NULL
    2294             :            ) {
    2295             :             /* trim fieldName */
    2296             :             line += fieldNameLen;
    2297             : 
    2298             :             /* trim delimiter */
    2299           0 :             ++line;
    2300             : 
    2301             :             /* trim leading delimiters */
    2302           0 :             while (*line != '\0' && strchr(kDelimiters, *line) != NULL) {
    2303           0 :                 ++line;
    2304             :                 --lineSize;
    2305             :             }
    2306             : 
    2307           0 :             result = strdup(line);
    2308           0 :             break;
    2309             :         }
    2310             :     }
    2311             : 
    2312           0 :     free(buffer);
    2313             : 
    2314           0 :     return result;
    2315             : }
    2316             : 
    2317           9 : int dlt_daemon_local_ecu_version_init(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose)
    2318             : {
    2319             :     FILE *f = NULL;
    2320             : 
    2321           9 :     PRINT_FUNCTION_VERBOSE(verbose);
    2322             : 
    2323             :     /* By default, version string is null. */
    2324           9 :     daemon->ECUVersionString = NULL;
    2325             : 
    2326             :     /* Open the file. Bail out if error occurs */
    2327           9 :     f = fopen(daemon_local->flags.pathToECUSoftwareVersion, "r");
    2328             : 
    2329           9 :     if (f == NULL) {
    2330             :         /* Error level notice, because this might be deliberate choice */
    2331           9 :         dlt_log(LOG_NOTICE, "Failed to open ECU Software version file.\n");
    2332           9 :         return -1;
    2333             :     }
    2334             : 
    2335           0 :     if (daemon_local->flags.ecuSoftwareVersionFileField[0] != '\0') {
    2336           0 :         daemon->ECUVersionString = file_read_field(f, daemon_local->flags.ecuSoftwareVersionFileField);
    2337             :     } else {
    2338           0 :         daemon->ECUVersionString = file_read_everything(f, DLT_DAEMON_TEXTBUFSIZE);
    2339             :     }
    2340             : 
    2341           0 :     fclose(f);
    2342             : 
    2343           0 :     return (daemon->ECUVersionString != NULL) ? 0 : -1;
    2344             : }
    2345             : 
    2346           9 : void dlt_daemon_local_cleanup(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose)
    2347             : {
    2348           9 :     PRINT_FUNCTION_VERBOSE(verbose);
    2349             : 
    2350           9 :     if ((daemon == 0) || (daemon_local == 0)) {
    2351           0 :         dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_local_cleanup()\n");
    2352           0 :         return;
    2353             :     }
    2354             : 
    2355             :     /* Don't receive event anymore */
    2356           9 :     dlt_event_handler_cleanup_connections(&daemon_local->pEvent);
    2357             : 
    2358           9 :     dlt_message_free(&(daemon_local->msg), daemon_local->flags.vflag);
    2359             : 
    2360             :     /* free shared memory */
    2361           9 :     if (daemon_local->flags.offlineTraceDirectory[0])
    2362           0 :         multiple_files_buffer_free(&(daemon_local->offlineTrace));
    2363             : 
    2364             :     /* Ignore result */
    2365           9 :     dlt_file_free(&(daemon_local->file), daemon_local->flags.vflag);
    2366             : 
    2367             : #ifdef DLT_DAEMON_USE_FIFO_IPC
    2368             :     /* Try to delete existing pipe, ignore result of unlink() */
    2369           9 :     unlink(daemon_local->flags.daemonFifoName);
    2370             : #else /* DLT_DAEMON_USE_UNIX_SOCKET_IPC */
    2371             :     /* Try to delete existing pipe, ignore result of unlink() */
    2372             :     if (unlink(daemon_local->flags.appSockPath) != 0) {
    2373             :         dlt_vlog(LOG_WARNING, "%s: unlink() failed: %s\n",
    2374             :                 __func__, strerror(errno));
    2375             :     }
    2376             : #endif
    2377             : 
    2378             : #ifdef DLT_SHM_ENABLE
    2379             :     /* free shared memory */
    2380             :     dlt_shm_free_server(&(daemon_local->dlt_shm), daemon_local->flags.dltShmName);
    2381             :     free(daemon_local->recv_buf_shm);
    2382             :     daemon_local->recv_buf_shm = NULL;
    2383             : #endif
    2384             : 
    2385           9 :     if (daemon_local->flags.offlineLogstorageMaxDevices > 0) {
    2386             :         /* disconnect all logstorage devices */
    2387           6 :         dlt_daemon_logstorage_cleanup(daemon,
    2388             :                                       daemon_local,
    2389             :                                       daemon_local->flags.vflag);
    2390             : 
    2391           6 :         free(daemon->storage_handle);
    2392             :     }
    2393             : 
    2394           9 :     if (daemon->ECUVersionString != NULL)
    2395           9 :         free(daemon->ECUVersionString);
    2396             : 
    2397           9 :     if (unlink(daemon_local->flags.ctrlSockPath) != 0) {
    2398           1 :         dlt_vlog(LOG_WARNING, "%s: unlink() failed: %s\n",
    2399           1 :                 __func__, strerror(errno));
    2400             :     }
    2401             : 
    2402             :     /* free IP list */
    2403           9 :     free(daemon_local->flags.ipNodes);
    2404             : }
    2405             : 
    2406           9 : void dlt_daemon_exit_trigger()
    2407             : {
    2408             :     /* stop event loop */
    2409           9 :     g_exit = -1;
    2410             : 
    2411             : #ifdef DLT_DAEMON_USE_FIFO_IPC
    2412           9 :     char tmp[DLT_PATH_MAX] = { 0 };
    2413             : 
    2414             :     ssize_t n;
    2415           9 :     n = snprintf(tmp, DLT_PATH_MAX, "%s/dlt", dltFifoBaseDir);
    2416           9 :     if (n < 0 || (size_t)n > DLT_PATH_MAX) {
    2417           0 :         dlt_vlog(LOG_WARNING, "%s: snprintf truncation/error(%ld) %s\n",
    2418             :                 __func__, n, tmp);
    2419             :     }
    2420             : 
    2421           9 :     (void)unlink(tmp);
    2422             : #endif
    2423             : 
    2424             : #ifdef __QNX__
    2425             :     dlt_daemon_cleanup_timers();
    2426             : #endif
    2427             : 
    2428           9 : }
    2429             : 
    2430           9 : void dlt_daemon_signal_handler(int sig)
    2431             : {
    2432           9 :     g_signo = sig;
    2433             : 
    2434           9 :     switch (sig) {
    2435           9 :         case SIGHUP:
    2436             :         case SIGTERM:
    2437             :         case SIGINT:
    2438             :         case SIGQUIT:
    2439             :         {
    2440             :             /* finalize the server */
    2441           9 :             dlt_vlog(LOG_NOTICE, "Exiting DLT daemon due to signal: %s\n",
    2442             :                      strsignal(sig));
    2443           9 :             dlt_daemon_exit_trigger();
    2444           9 :             break;
    2445             :         }
    2446             :         default:
    2447             :         {
    2448             :             /* This case should never happen! */
    2449             :             break;
    2450             :         }
    2451             :     } /* switch */
    2452             : 
    2453           9 : } /* dlt_daemon_signal_handler() */
    2454             : 
    2455             : #ifdef __QNX__
    2456             : void dlt_daemon_cleanup_timers()
    2457             : {
    2458             :     int i = 0;
    2459             :     while (i < DLT_TIMER_UNKNOWN) {
    2460             :         /* Remove FIFO of every timer and kill timer thread */
    2461             :         if (0 != timer_threads[i]) {
    2462             :             pthread_kill(timer_threads[i], SIGUSR1);
    2463             :             pthread_join(timer_threads[i], NULL);
    2464             :             timer_threads[i] = 0;
    2465             : 
    2466             :             close_pipes(dlt_timer_pipes[i]);
    2467             : 
    2468             :             /* Free data of every timer */
    2469             :             if (NULL != timer_data[i]) {
    2470             :                 free(timer_data[i]);
    2471             :                 timer_data[i] = NULL;
    2472             :             }
    2473             :         }
    2474             :         i++;
    2475             :     }
    2476             : }
    2477             : #endif
    2478             : 
    2479           2 : void dlt_daemon_daemonize(int verbose)
    2480             : {
    2481             :     int i;
    2482             :     int fd;
    2483             : 
    2484           2 :     PRINT_FUNCTION_VERBOSE(verbose);
    2485             : 
    2486           2 :     dlt_log(LOG_NOTICE, "Daemon mode\n");
    2487             : 
    2488             :     /* Daemonize */
    2489           2 :     i = fork();
    2490             : 
    2491           4 :     if (i < 0) {
    2492           0 :         dlt_log(LOG_CRIT, "Unable to fork(), exiting DLT daemon\n");
    2493           0 :         exit(-1); /* fork error */
    2494             :     }
    2495             : 
    2496           4 :     if (i > 0)
    2497           2 :         exit(0); /* parent exits */
    2498             : 
    2499             :     /* child (daemon) continues */
    2500             : 
    2501             :     /* Process independency */
    2502             : 
    2503             :     /* obtain a new process group */
    2504           2 :     if (setsid() == -1) {
    2505           0 :         dlt_log(LOG_CRIT, "setsid() failed, exiting DLT daemon\n");
    2506           0 :         exit(-1); /* fork error */
    2507             :     }
    2508             : 
    2509             :     /* Open standard descriptors stdin, stdout, stderr */
    2510             :     fd = open("/dev/null", O_RDWR);
    2511             : 
    2512           2 :     if (fd != -1) {
    2513             :         /* Redirect STDOUT to /dev/null */
    2514           2 :         if (dup2(fd, STDOUT_FILENO) < 0)
    2515           0 :             dlt_vlog(LOG_WARNING, "Failed to direct stdout to /dev/null. Error: %s\n", strerror(errno));
    2516             : 
    2517             :         /* Redirect STDERR to /dev/null */
    2518           2 :         if (dup2(fd, STDERR_FILENO) < 0)
    2519           0 :             dlt_vlog(LOG_WARNING, "Failed to direct stderr to /dev/null. Error: %s\n", strerror(errno));
    2520             : 
    2521           2 :         close(fd);
    2522             :     }
    2523             :     else {
    2524           0 :         dlt_log(LOG_CRIT, "Error opening /dev/null, exiting DLT daemon\n");
    2525           0 :         exit(-1); /* fork error */
    2526             :     }
    2527             : 
    2528             :     /* Set umask */
    2529           2 :     umask(DLT_DAEMON_UMASK);
    2530             : 
    2531             :     /* Change to root directory */
    2532           2 :     if (chdir("/") < 0)
    2533           0 :         dlt_log(LOG_WARNING, "Failed to chdir to root\n");
    2534             : 
    2535             :     /* Catch signals */
    2536           2 :     signal(SIGCHLD, SIG_IGN); /* ignore child */
    2537           2 :     signal(SIGTSTP, SIG_IGN); /* ignore tty signals */
    2538           2 :     signal(SIGTTOU, SIG_IGN);
    2539           2 :     signal(SIGTTIN, SIG_IGN);
    2540             : 
    2541           2 : } /* dlt_daemon_daemonize() */
    2542             : 
    2543             : /* This function logs str to the configured output sink (socket, serial, offline trace).
    2544             :  * To avoid recursion this function must be called only from DLT highlevel functions.
    2545             :  * E. g. calling it to output a failure when the open of the offline trace file fails
    2546             :  * would cause an endless loop because dlt_daemon_log_internal() would itself again try
    2547             :  * to open the offline trace file.
    2548             :  * This is a dlt-daemon only function. The libdlt has no equivalent function available. */
    2549          40 : int dlt_daemon_log_internal(DltDaemon *daemon, DltDaemonLocal *daemon_local,
    2550             :                             char *str, DltLogLevelType level,
    2551             :                             const char *app_id, const char *ctx_id, int verbose)
    2552             : {
    2553          40 :     DltMessage msg = { 0 };
    2554             :     static uint8_t uiMsgCount = 0;
    2555             :     DltStandardHeaderExtra *pStandardExtra = NULL;
    2556             :     uint32_t uiType;
    2557             :     uint16_t uiSize;
    2558             :     uint32_t uiExtraSize;
    2559             : 
    2560          40 :     PRINT_FUNCTION_VERBOSE(verbose);
    2561             : 
    2562             :     /* Set storageheader */
    2563          40 :     msg.storageheader = (DltStorageHeader *)(msg.headerbuffer);
    2564          40 :     dlt_set_storageheader(msg.storageheader, daemon->ecuid);
    2565             : 
    2566             :     /* Set standardheader */
    2567          40 :     msg.standardheader = (DltStandardHeader *)(msg.headerbuffer + sizeof(DltStorageHeader));
    2568          40 :     msg.standardheader->htyp = DLT_HTYP_UEH | DLT_HTYP_WEID | DLT_HTYP_WSID | DLT_HTYP_WTMS |
    2569             :         DLT_HTYP_PROTOCOL_VERSION1;
    2570          40 :     msg.standardheader->mcnt = uiMsgCount++;
    2571             : 
    2572             :     uiExtraSize = (uint32_t) (DLT_STANDARD_HEADER_EXTRA_SIZE(msg.standardheader->htyp) +
    2573             :         (DLT_IS_HTYP_UEH(msg.standardheader->htyp) ? sizeof(DltExtendedHeader) : 0));
    2574          40 :     msg.headersize = (uint32_t) sizeof(DltStorageHeader) + (uint32_t) sizeof(DltStandardHeader) + uiExtraSize;
    2575             : 
    2576             :     /* Set extraheader */
    2577             :     pStandardExtra =
    2578             :         (DltStandardHeaderExtra *)(msg.headerbuffer + sizeof(DltStorageHeader) + sizeof(DltStandardHeader));
    2579          40 :     dlt_set_id(pStandardExtra->ecu, daemon->ecuid);
    2580          40 :     pStandardExtra->tmsp = DLT_HTOBE_32(dlt_uptime());
    2581          40 :     pStandardExtra->seid = (unsigned int) DLT_HTOBE_32(getpid());
    2582             : 
    2583             :     /* Set extendedheader */
    2584          40 :     msg.extendedheader =
    2585          40 :         (DltExtendedHeader *)(msg.headerbuffer + sizeof(DltStorageHeader) + sizeof(DltStandardHeader) +
    2586          40 :                               DLT_STANDARD_HEADER_EXTRA_SIZE(msg.standardheader->htyp));
    2587          40 :     msg.extendedheader->msin = DLT_MSIN_VERB | (DLT_TYPE_LOG << DLT_MSIN_MSTP_SHIFT) |
    2588          40 :         ((level << DLT_MSIN_MTIN_SHIFT) & DLT_MSIN_MTIN);
    2589          40 :     msg.extendedheader->noar = 1;
    2590          40 :     dlt_set_id(msg.extendedheader->apid, app_id);
    2591          40 :     dlt_set_id(msg.extendedheader->ctid, ctx_id);
    2592             : 
    2593             :     /* Set payload data... */
    2594          40 :     uiType = DLT_TYPE_INFO_STRG;
    2595          40 :     uiSize = (uint16_t) (strlen(str) + 1);
    2596          40 :     msg.datasize = (uint32_t) (sizeof(uint32_t) + sizeof(uint16_t) + uiSize);
    2597             : 
    2598          40 :     msg.databuffer = (uint8_t *)malloc((size_t) msg.datasize);
    2599          40 :     msg.databuffersize = msg.datasize;
    2600             : 
    2601          40 :     if (msg.databuffer == 0) {
    2602           0 :         dlt_log(LOG_WARNING, "Can't allocate buffer for get log info message\n");
    2603           0 :         return -1;
    2604             :     }
    2605             : 
    2606             :     msg.datasize = 0;
    2607             :     memcpy((uint8_t *)(msg.databuffer + msg.datasize), (uint8_t *)(&uiType), sizeof(uint32_t));
    2608          40 :     msg.datasize += (uint32_t) sizeof(uint32_t);
    2609          40 :     memcpy((uint8_t *)(msg.databuffer + msg.datasize), (uint8_t *)(&uiSize), sizeof(uint16_t));
    2610          40 :     msg.datasize += (uint32_t) sizeof(uint16_t);
    2611          40 :     memcpy((uint8_t *)(msg.databuffer + msg.datasize), str, uiSize);
    2612          40 :     msg.datasize += uiSize;
    2613             : 
    2614             :     /* Calc length */
    2615          40 :     msg.standardheader->len = DLT_HTOBE_16(msg.headersize - sizeof(DltStorageHeader) + msg.datasize);
    2616             : 
    2617          40 :     dlt_daemon_client_send(DLT_DAEMON_SEND_TO_ALL, daemon,daemon_local,
    2618             :                            msg.headerbuffer, sizeof(DltStorageHeader),
    2619             :                            msg.headerbuffer + sizeof(DltStorageHeader),
    2620          40 :                            (int) (msg.headersize - sizeof(DltStorageHeader)),
    2621          40 :                            msg.databuffer, (int) msg.datasize, verbose);
    2622             : 
    2623          40 :     free(msg.databuffer);
    2624             : 
    2625          40 :     return 0;
    2626             : }
    2627             : 
    2628           3 : int dlt_daemon_check_numeric_setting(char *token,
    2629             :                                     char *value,
    2630             :                                     unsigned long *data)
    2631           3 : {
    2632           3 :     char value_check[value_length];
    2633           3 :     value_check[0] = 0;
    2634           3 :     sscanf(value, "%lu%s", data, value_check);
    2635           3 :     if (value_check[0] || !isdigit(value[0])) {
    2636           0 :         fprintf(stderr, "Invalid input [%s] detected in option %s\n",
    2637             :                 value,
    2638             :                 token);
    2639           0 :         return -1;
    2640             :     }
    2641             :     return 0;
    2642             : }
    2643             : 
    2644           4 : int dlt_daemon_process_client_connect(DltDaemon *daemon,
    2645             :                                       DltDaemonLocal *daemon_local,
    2646             :                                       DltReceiver *receiver,
    2647             :                                       int verbose)
    2648             : {
    2649             :     socklen_t cli_size;
    2650             :     struct sockaddr_un cli;
    2651             : 
    2652             :     int in_sock = -1;
    2653           4 :     char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' };
    2654             : 
    2655           4 :     PRINT_FUNCTION_VERBOSE(verbose);
    2656             : 
    2657           4 :     if ((daemon == NULL) || (daemon_local == NULL) || (receiver == NULL)) {
    2658           0 :         dlt_log(LOG_ERR,
    2659             :                 "Invalid function parameters used for function "
    2660             :                 "dlt_daemon_process_client_connect()\n");
    2661           0 :         return -1;
    2662             :     }
    2663             : 
    2664             :     /* event from TCP server socket, new connection */
    2665           4 :     cli_size = sizeof(cli);
    2666             : 
    2667           4 :     if ((in_sock = accept(receiver->fd, (struct sockaddr *)&cli, &cli_size)) < 0) {
    2668           0 :         if (errno == ECONNABORTED) // Caused by nmap -v -p 3490 -Pn <IP of dlt-daemon>
    2669             :             return 0;
    2670           0 :         dlt_vlog(LOG_ERR, "accept() for socket %d failed: %s\n", receiver->fd, strerror(errno));
    2671           0 :         return -1;
    2672             :     }
    2673             : 
    2674             :     /* check if file file descriptor was already used, and make it invalid if it
    2675             :      * is reused. */
    2676             :     /* This prevents sending messages to wrong file descriptor */
    2677           4 :     dlt_daemon_applications_invalidate_fd(daemon, daemon->ecuid, in_sock, verbose);
    2678           4 :     dlt_daemon_contexts_invalidate_fd(daemon, daemon->ecuid, in_sock, verbose);
    2679             : 
    2680             :     /* Set socket timeout in reception */
    2681             :     struct timeval timeout_send;
    2682           4 :     timeout_send.tv_sec = daemon_local->timeoutOnSend;
    2683           4 :     timeout_send.tv_usec = 0;
    2684             : 
    2685           4 :     if (setsockopt (in_sock,
    2686             :                     SOL_SOCKET,
    2687             :                     SO_SNDTIMEO,
    2688             :                     (char *)&timeout_send,
    2689             :                     sizeof(timeout_send)) < 0)
    2690           0 :         dlt_log(LOG_WARNING, "setsockopt failed\n");
    2691             : 
    2692           4 :     if (dlt_connection_create(daemon_local,
    2693             :                               &daemon_local->pEvent,
    2694             :                               in_sock,
    2695             :                               POLLIN,
    2696             :                               DLT_CONNECTION_CLIENT_MSG_TCP)) {
    2697           0 :         dlt_log(LOG_ERR, "Failed to register new client. \n");
    2698           0 :         close(in_sock);
    2699           0 :         return -1;
    2700             :     }
    2701             : 
    2702             :     /* send connection info about connected */
    2703           4 :     dlt_daemon_control_message_connection_info(in_sock,
    2704             :                                                daemon,
    2705             :                                                daemon_local,
    2706             :                                                DLT_CONNECTION_STATUS_CONNECTED,
    2707             :                                                "",
    2708             :                                                verbose);
    2709             : 
    2710             :     /* send ecu version string */
    2711           4 :     if (daemon_local->flags.sendECUSoftwareVersion > 0) {
    2712             :         if (daemon_local->flags.sendECUSoftwareVersion > 0)
    2713           0 :             dlt_daemon_control_get_software_version(DLT_DAEMON_SEND_TO_ALL,
    2714             :                                                     daemon,
    2715             :                                                     daemon_local,
    2716             :                                                     daemon_local->flags.vflag);
    2717             : 
    2718           0 :         if (daemon_local->flags.sendTimezone > 0)
    2719           0 :             dlt_daemon_control_message_timezone(DLT_DAEMON_SEND_TO_ALL,
    2720             :                                                 daemon,
    2721             :                                                 daemon_local,
    2722             :                                                 daemon_local->flags.vflag);
    2723             :     }
    2724             : 
    2725           4 :     snprintf(local_str, DLT_DAEMON_TEXTBUFSIZE,
    2726             :              "New client connection #%d established, Total Clients : %d",
    2727             :              in_sock, daemon_local->client_connections);
    2728             : 
    2729           4 :     dlt_daemon_log_internal(daemon, daemon_local, local_str, DLT_LOG_INFO,
    2730             :                             DLT_DAEMON_APP_ID, DLT_DAEMON_CTX_ID,
    2731             :                             daemon_local->flags.vflag);
    2732           4 :     dlt_vlog(LOG_DEBUG, "%s%s", local_str, "\n");
    2733             : 
    2734           4 :     if (daemon_local->client_connections == 1) {
    2735           2 :         if (daemon_local->flags.vflag)
    2736           0 :             dlt_log(LOG_DEBUG, "Send ring-buffer to client\n");
    2737             : 
    2738           2 :         dlt_daemon_change_state(daemon, DLT_DAEMON_STATE_SEND_BUFFER);
    2739             : 
    2740           2 :         if (dlt_daemon_send_ringbuffer_to_client(daemon, daemon_local, verbose) == -1) {
    2741           0 :             dlt_log(LOG_WARNING, "Can't send contents of ringbuffer to clients\n");
    2742           0 :             close(in_sock);
    2743             :             in_sock = -1;
    2744           0 :             return -1;
    2745             :         }
    2746             : 
    2747             :         /* send new log state to all applications */
    2748           2 :         daemon->connectionState = 1;
    2749           2 :         dlt_daemon_user_send_all_log_state(daemon, verbose);
    2750             : 
    2751             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
    2752             :         /* Reset number of received bytes from FIFO */
    2753             :         daemon->bytes_recv = 0;
    2754             : #endif
    2755             :     }
    2756             : 
    2757             :     return 0;
    2758             : }
    2759             : 
    2760           7 : int dlt_daemon_process_client_messages(DltDaemon *daemon,
    2761             :                                        DltDaemonLocal *daemon_local,
    2762             :                                        DltReceiver *receiver,
    2763             :                                        int verbose)
    2764             : {
    2765             :     int bytes_to_be_removed = 0;
    2766             :     int must_close_socket = -1;
    2767             : 
    2768           7 :     PRINT_FUNCTION_VERBOSE(verbose);
    2769             : 
    2770           7 :     if ((daemon == NULL) || (daemon_local == NULL) || (receiver == NULL)) {
    2771           0 :         dlt_log(LOG_ERR,
    2772             :                 "Invalid function parameters used for function "
    2773             :                 "dlt_daemon_process_client_messages()\n");
    2774           0 :         return -1;
    2775             :     }
    2776             : 
    2777           7 :     must_close_socket = dlt_receiver_receive(receiver);
    2778             : 
    2779           7 :     if (must_close_socket < 0) {
    2780           0 :         dlt_daemon_close_socket(receiver->fd,
    2781             :                                 daemon,
    2782             :                                 daemon_local,
    2783             :                                 verbose);
    2784           0 :         return -1;
    2785             :     }
    2786             : 
    2787             :     /* Process all received messages */
    2788          17 :     while (dlt_message_read(&(daemon_local->msg),
    2789          17 :                             (uint8_t *)receiver->buf,
    2790          17 :                             (unsigned int) receiver->bytesRcvd,
    2791             :                             daemon_local->flags.nflag,
    2792          17 :                             daemon_local->flags.vflag) == DLT_MESSAGE_ERROR_OK) {
    2793             :         /* Check for control message */
    2794          10 :         if ((0 < receiver->fd) &&
    2795          10 :             DLT_MSG_IS_CONTROL_REQUEST(&(daemon_local->msg)))
    2796          10 :             dlt_daemon_client_process_control(receiver->fd,
    2797             :                                               daemon,
    2798             :                                               daemon_local,
    2799             :                                               &(daemon_local->msg),
    2800             :                                               daemon_local->flags.vflag);
    2801             : 
    2802          10 :         bytes_to_be_removed = (int) (daemon_local->msg.headersize +
    2803          10 :             daemon_local->msg.datasize -
    2804             :             sizeof(DltStorageHeader));
    2805             : 
    2806          10 :         if (daemon_local->msg.found_serialheader)
    2807             :             bytes_to_be_removed += (int) sizeof(dltSerialHeader);
    2808             : 
    2809          10 :         if (daemon_local->msg.resync_offset)
    2810           0 :             bytes_to_be_removed += daemon_local->msg.resync_offset;
    2811             : 
    2812          10 :         if (dlt_receiver_remove(receiver, bytes_to_be_removed) == -1) {
    2813           0 :             dlt_log(LOG_WARNING,
    2814             :                     "Can't remove bytes from receiver for sockets\n");
    2815           0 :             return -1;
    2816             :         }
    2817             :     } /* while */
    2818             : 
    2819           7 :     if (dlt_receiver_move_to_begin(receiver) == -1) {
    2820           0 :         dlt_log(LOG_WARNING,
    2821             :                 "Can't move bytes to beginning of receiver buffer for sockets\n");
    2822           0 :         return -1;
    2823             :     }
    2824             : 
    2825           7 :     if (must_close_socket == 0)
    2826             :         /* FIXME: Why the hell do we need to close the socket
    2827             :          * on control message reception ??
    2828             :          */
    2829           1 :         dlt_daemon_close_socket(receiver->fd,
    2830             :                                 daemon,
    2831             :                                 daemon_local,
    2832             :                                 verbose);
    2833             : 
    2834             :     return 0;
    2835             : }
    2836             : 
    2837           0 : int dlt_daemon_process_client_messages_serial(DltDaemon *daemon,
    2838             :                                               DltDaemonLocal *daemon_local,
    2839             :                                               DltReceiver *receiver,
    2840             :                                               int verbose)
    2841             : {
    2842             :     int bytes_to_be_removed = 0;
    2843             : 
    2844           0 :     PRINT_FUNCTION_VERBOSE(verbose);
    2845             : 
    2846           0 :     if ((daemon == NULL) || (daemon_local == NULL) || (receiver == NULL)) {
    2847           0 :         dlt_log(LOG_ERR,
    2848             :                 "Invalid function parameters used for function "
    2849             :                 "dlt_daemon_process_client_messages_serial()\n");
    2850           0 :         return -1;
    2851             :     }
    2852             : 
    2853           0 :     if (dlt_receiver_receive(receiver) <= 0) {
    2854           0 :         dlt_log(LOG_WARNING,
    2855             :                 "dlt_receiver_receive_fd() for messages from serial interface "
    2856             :                 "failed!\n");
    2857           0 :         return -1;
    2858             :     }
    2859             : 
    2860             :     /* Process all received messages */
    2861           0 :     while (dlt_message_read(&(daemon_local->msg),
    2862           0 :                             (uint8_t *)receiver->buf,
    2863           0 :                             (unsigned int) receiver->bytesRcvd,
    2864             :                             daemon_local->flags.mflag,
    2865           0 :                             daemon_local->flags.vflag) == DLT_MESSAGE_ERROR_OK) {
    2866             :         /* Check for control message */
    2867           0 :         if (DLT_MSG_IS_CONTROL_REQUEST(&(daemon_local->msg))) {
    2868           0 :             if (dlt_daemon_client_process_control(receiver->fd,
    2869             :                                                   daemon,
    2870             :                                                   daemon_local,
    2871             :                                                   &(daemon_local->msg),
    2872             :                                                   daemon_local->flags.vflag)
    2873             :                 == -1) {
    2874           0 :                 dlt_log(LOG_WARNING, "Can't process control messages\n");
    2875           0 :                 return -1;
    2876             :             }
    2877             :         }
    2878             : 
    2879           0 :         bytes_to_be_removed = (int) (daemon_local->msg.headersize +
    2880           0 :             daemon_local->msg.datasize -
    2881             :             sizeof(DltStorageHeader));
    2882             : 
    2883           0 :         if (daemon_local->msg.found_serialheader)
    2884             :             bytes_to_be_removed += (int) sizeof(dltSerialHeader);
    2885             : 
    2886           0 :         if (daemon_local->msg.resync_offset)
    2887           0 :             bytes_to_be_removed += daemon_local->msg.resync_offset;
    2888             : 
    2889           0 :         if (dlt_receiver_remove(receiver, bytes_to_be_removed) == -1) {
    2890           0 :             dlt_log(LOG_WARNING,
    2891             :                     "Can't remove bytes from receiver for serial connection\n");
    2892           0 :             return -1;
    2893             :         }
    2894             :     } /* while */
    2895             : 
    2896           0 :     if (dlt_receiver_move_to_begin(receiver) == -1) {
    2897           0 :         dlt_log(LOG_WARNING,
    2898             :                 "Can't move bytes to beginning of receiver buffer for serial "
    2899             :                 "connection\n");
    2900           0 :         return -1;
    2901             :     }
    2902             : 
    2903             :     return 0;
    2904             : }
    2905             : 
    2906           2 : int dlt_daemon_process_control_connect(
    2907             :     DltDaemon *daemon,
    2908             :     DltDaemonLocal *daemon_local,
    2909             :     DltReceiver *receiver,
    2910             :     int verbose)
    2911             : {
    2912             :     socklen_t ctrl_size;
    2913             :     struct sockaddr_un ctrl;
    2914             :     int in_sock = -1;
    2915             : 
    2916           2 :     PRINT_FUNCTION_VERBOSE(verbose);
    2917             : 
    2918           2 :     if ((daemon == NULL) || (daemon_local == NULL) || (receiver == NULL)) {
    2919           0 :         dlt_log(LOG_ERR,
    2920             :                 "Invalid function parameters used for function "
    2921             :                 "dlt_daemon_process_control_connect()\n");
    2922           0 :         return -1;
    2923             :     }
    2924             : 
    2925             :     /* event from UNIX server socket, new connection */
    2926           2 :     ctrl_size = sizeof(ctrl);
    2927             : 
    2928           2 :     if ((in_sock = accept(receiver->fd, (struct sockaddr *)&ctrl, &ctrl_size)) < 0) {
    2929           0 :         dlt_vlog(LOG_ERR, "accept() on UNIX control socket %d failed: %s\n", receiver->fd, strerror(errno));
    2930           0 :         return -1;
    2931             :     }
    2932             : 
    2933             :     /* check if file file descriptor was already used, and make it invalid if it
    2934             :      *  is reused */
    2935             :     /* This prevents sending messages to wrong file descriptor */
    2936           2 :     dlt_daemon_applications_invalidate_fd(daemon, daemon->ecuid, in_sock, verbose);
    2937           2 :     dlt_daemon_contexts_invalidate_fd(daemon, daemon->ecuid, in_sock, verbose);
    2938             : 
    2939           2 :     if (dlt_connection_create(daemon_local,
    2940             :                               &daemon_local->pEvent,
    2941             :                               in_sock,
    2942             :                               POLLIN,
    2943             :                               DLT_CONNECTION_CONTROL_MSG)) {
    2944           0 :         dlt_log(LOG_ERR, "Failed to register new client. \n");
    2945             :         /* TODO: Perform clean-up */
    2946           0 :         return -1;
    2947             :     }
    2948             : 
    2949           2 :     if (verbose)
    2950           0 :         dlt_vlog(LOG_INFO, "New connection to control client established\n");
    2951             : 
    2952             :     return 0;
    2953             : }
    2954             : 
    2955             : #if defined DLT_DAEMON_USE_UNIX_SOCKET_IPC || defined DLT_DAEMON_VSOCK_IPC_ENABLE
    2956             : int dlt_daemon_process_app_connect(
    2957             :     DltDaemon *daemon,
    2958             :     DltDaemonLocal *daemon_local,
    2959             :     DltReceiver *receiver,
    2960             :     int verbose)
    2961             : {
    2962             :     int in_sock = -1;
    2963             : 
    2964             :     PRINT_FUNCTION_VERBOSE(verbose);
    2965             : 
    2966             :     if ((daemon == NULL) || (daemon_local == NULL) || (receiver == NULL)) {
    2967             :         dlt_vlog(LOG_ERR,
    2968             :                  "%s: Invalid parameters\n",
    2969             :                  __func__);
    2970             :         return DLT_RETURN_WRONG_PARAMETER;
    2971             :     }
    2972             : 
    2973             :     /* event from server socket, new connection */
    2974             : 
    2975             :     if ((in_sock = accept(receiver->fd, NULL, NULL)) < 0) {
    2976             :         dlt_vlog(LOG_ERR, "accept() on UNIX socket %d failed: %s\n", receiver->fd, strerror(errno));
    2977             :         return -1;
    2978             :     }
    2979             : 
    2980             :     /* check if file file descriptor was already used, and make it invalid if it
    2981             :      * is reused. This prevents sending messages to wrong file descriptor */
    2982             :     dlt_daemon_applications_invalidate_fd(daemon, daemon->ecuid, in_sock, verbose);
    2983             :     dlt_daemon_contexts_invalidate_fd(daemon, daemon->ecuid, in_sock, verbose);
    2984             : 
    2985             :     if (dlt_connection_create(daemon_local,
    2986             :                               &daemon_local->pEvent,
    2987             :                               in_sock,
    2988             :                               POLLIN,
    2989             :                               DLT_CONNECTION_APP_MSG)) {
    2990             :         dlt_log(LOG_ERR, "Failed to register new application. \n");
    2991             :         close(in_sock);
    2992             :         return -1;
    2993             :     }
    2994             : 
    2995             :     if (verbose)
    2996             :         dlt_vlog(LOG_INFO, "New connection to application established\n");
    2997             : 
    2998             :     return 0;
    2999             : }
    3000             : #endif
    3001             : 
    3002           4 : int dlt_daemon_process_control_messages(
    3003             :     DltDaemon *daemon,
    3004             :     DltDaemonLocal *daemon_local,
    3005             :     DltReceiver *receiver,
    3006             :     int verbose)
    3007             : {
    3008             :     int bytes_to_be_removed = 0;
    3009             : 
    3010           4 :     PRINT_FUNCTION_VERBOSE(verbose);
    3011             : 
    3012           4 :     if ((daemon == NULL) || (daemon_local == NULL) || (receiver == NULL)) {
    3013           0 :         dlt_log(LOG_ERR,
    3014             :                 "Invalid function parameters used for function "
    3015             :                 "dlt_daemon_process_control_messages()\n");
    3016           0 :         return -1;
    3017             :     }
    3018             : 
    3019           4 :     if (dlt_receiver_receive(receiver) <= 0) {
    3020           2 :         dlt_daemon_close_socket(receiver->fd,
    3021             :                                 daemon,
    3022             :                                 daemon_local,
    3023             :                                 verbose);
    3024             :         /* FIXME: Why the hell do we need to close the socket
    3025             :          * on control message reception ??
    3026             :          */
    3027           2 :         return 0;
    3028             :     }
    3029             : 
    3030             :     /* Process all received messages */
    3031           4 :     while (dlt_message_read(
    3032             :                &(daemon_local->msg),
    3033           4 :                (uint8_t *)receiver->buf,
    3034           4 :                (unsigned int) receiver->bytesRcvd,
    3035             :                daemon_local->flags.nflag,
    3036           4 :                daemon_local->flags.vflag) == DLT_MESSAGE_ERROR_OK) {
    3037             :         /* Check for control message */
    3038           2 :         if ((receiver->fd > 0) &&
    3039           2 :             DLT_MSG_IS_CONTROL_REQUEST(&(daemon_local->msg)))
    3040           2 :             dlt_daemon_client_process_control(receiver->fd,
    3041             :                                               daemon, daemon_local,
    3042             :                                               &(daemon_local->msg),
    3043             :                                               daemon_local->flags.vflag);
    3044             : 
    3045           2 :         bytes_to_be_removed = (int) (daemon_local->msg.headersize +
    3046           2 :             daemon_local->msg.datasize -
    3047             :             sizeof(DltStorageHeader));
    3048             : 
    3049           2 :         if (daemon_local->msg.found_serialheader)
    3050             :             bytes_to_be_removed += (int) sizeof(dltSerialHeader);
    3051             : 
    3052           2 :         if (daemon_local->msg.resync_offset)
    3053           0 :             bytes_to_be_removed += daemon_local->msg.resync_offset;
    3054             : 
    3055           2 :         if (dlt_receiver_remove(receiver, bytes_to_be_removed) == -1) {
    3056           0 :             dlt_log(LOG_WARNING,
    3057             :                     "Can't remove bytes from receiver for sockets\n");
    3058           0 :             return -1;
    3059             :         }
    3060             :     } /* while */
    3061             : 
    3062           2 :     if (dlt_receiver_move_to_begin(receiver) == -1) {
    3063           0 :         dlt_log(LOG_WARNING, "Can't move bytes to beginning of receiver buffer for sockets\n");
    3064           0 :         return -1;
    3065             :     }
    3066             : 
    3067             :     return 0;
    3068             : }
    3069             : 
    3070           0 : static int dlt_daemon_process_user_message_not_sup(DltDaemon *daemon,
    3071             :                                                    DltDaemonLocal *daemon_local,
    3072             :                                                    DltReceiver *receiver,
    3073             :                                                    int verbose)
    3074             : {
    3075           0 :     DltUserHeader *userheader = (DltUserHeader *)(receiver->buf);
    3076             :     (void)daemon;
    3077             :     (void)daemon_local;
    3078             : 
    3079           0 :     PRINT_FUNCTION_VERBOSE(verbose);
    3080             : 
    3081           0 :     dlt_vlog(LOG_ERR, "Invalid user message type received: %u!\n",
    3082             :              userheader->message);
    3083             : 
    3084             :     /* remove user header */
    3085           0 :     if (dlt_receiver_remove(receiver, sizeof(DltUserHeader)) == -1)
    3086           0 :         dlt_log(LOG_WARNING,
    3087             :                 "Can't remove bytes from receiver for user messages\n");
    3088             : 
    3089           0 :     return -1;
    3090             : }
    3091             : 
    3092             : static dlt_daemon_process_user_message_func process_user_func[DLT_USER_MESSAGE_NOT_SUPPORTED] = {
    3093             :     dlt_daemon_process_user_message_not_sup,
    3094             :     dlt_daemon_process_user_message_log,
    3095             :     dlt_daemon_process_user_message_register_application,
    3096             :     dlt_daemon_process_user_message_unregister_application,
    3097             :     dlt_daemon_process_user_message_register_context,
    3098             :     dlt_daemon_process_user_message_unregister_context,
    3099             :     dlt_daemon_process_user_message_not_sup,
    3100             :     dlt_daemon_process_user_message_not_sup,
    3101             :     dlt_daemon_process_user_message_overflow,
    3102             :     dlt_daemon_process_user_message_set_app_ll_ts,
    3103             :     dlt_daemon_process_user_message_not_sup,
    3104             :     dlt_daemon_process_user_message_not_sup,
    3105             :     dlt_daemon_process_user_message_not_sup,
    3106             :     dlt_daemon_process_user_message_marker,
    3107             :     dlt_daemon_process_user_message_not_sup,
    3108             :     dlt_daemon_process_user_message_not_sup
    3109             : };
    3110             : 
    3111        1306 : int dlt_daemon_process_user_messages(DltDaemon *daemon,
    3112             :                                      DltDaemonLocal *daemon_local,
    3113             :                                      DltReceiver *receiver,
    3114             :                                      int verbose)
    3115             : {
    3116             :     int offset = 0;
    3117             :     int run_loop = 1;
    3118             :     int32_t min_size = (int32_t) sizeof(DltUserHeader);
    3119             :     DltUserHeader *userheader;
    3120             :     int recv;
    3121             : 
    3122        1306 :     PRINT_FUNCTION_VERBOSE(verbose);
    3123             : 
    3124        1306 :     if ((daemon == NULL) || (daemon_local == NULL) || (receiver == NULL)) {
    3125           0 :         dlt_log(LOG_ERR,
    3126             :                 "Invalid function parameters used for function "
    3127             :                 "dlt_daemon_process_user_messages()\n");
    3128           0 :         return -1;
    3129             :     }
    3130             : 
    3131        1306 :     recv = dlt_receiver_receive(receiver);
    3132             : 
    3133        1306 :     if (recv <= 0 && receiver->type == DLT_RECEIVE_SOCKET) {
    3134           0 :         dlt_daemon_close_socket(receiver->fd,
    3135             :                                 daemon,
    3136             :                                 daemon_local,
    3137             :                                 verbose);
    3138           0 :         return 0;
    3139             :     }
    3140        1306 :     else if (recv < 0) {
    3141           0 :         dlt_log(LOG_WARNING,
    3142             :                 "dlt_receiver_receive_fd() for user messages failed!\n");
    3143           0 :         return -1;
    3144             :     }
    3145             : 
    3146             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
    3147             :     /* Count up number of received bytes from FIFO */
    3148             :     if (receiver->bytesRcvd > receiver->lastBytesRcvd)
    3149             :     {
    3150             :         daemon->bytes_recv += receiver->bytesRcvd - receiver->lastBytesRcvd;
    3151             :     }
    3152             : #endif
    3153             : 
    3154             :     /* look through buffer as long as data is in there */
    3155        7203 :     while ((receiver->bytesRcvd >= min_size) && run_loop) {
    3156             :         dlt_daemon_process_user_message_func func = NULL;
    3157             : 
    3158             :         offset = 0;
    3159        5897 :         userheader = (DltUserHeader *)(receiver->buf + offset);
    3160             : 
    3161        5897 :         while (!dlt_user_check_userheader(userheader) &&
    3162           0 :                (offset + min_size <= receiver->bytesRcvd)) {
    3163             :             /* resync if necessary */
    3164           0 :             offset++;
    3165           0 :             userheader = (DltUserHeader *)(receiver->buf + offset);
    3166             :         }
    3167             : 
    3168             :         /* Check for user header pattern */
    3169        5897 :         if (!dlt_user_check_userheader(userheader))
    3170             :             break;
    3171             : 
    3172             :         /* Set new start offset */
    3173        5897 :         if (offset > 0) {
    3174           0 :             if (dlt_receiver_remove(receiver, offset) == -1) {
    3175           0 :                 dlt_log(LOG_WARNING,
    3176             :                         "Can't remove offset from receiver\n");
    3177           0 :                 return -1;
    3178             :             }
    3179             :         }
    3180             : 
    3181        5897 :         if (userheader->message >= DLT_USER_MESSAGE_NOT_SUPPORTED)
    3182             :             func = dlt_daemon_process_user_message_not_sup;
    3183             :         else
    3184        5897 :             func = process_user_func[userheader->message];
    3185             : 
    3186        5897 :         if (func(daemon,
    3187             :                  daemon_local,
    3188             :                  receiver,
    3189             :                  daemon_local->flags.vflag) == -1)
    3190             :             run_loop = 0;
    3191             :     }
    3192             : 
    3193             :     /* keep not read data in buffer */
    3194        1306 :     if (dlt_receiver_move_to_begin(receiver) == -1) {
    3195           0 :         dlt_log(LOG_WARNING,
    3196             :                 "Can't move bytes to beginning of receiver buffer for user "
    3197             :                 "messages\n");
    3198           0 :         return -1;
    3199             :     }
    3200             : 
    3201             :     return 0;
    3202             : }
    3203             : 
    3204           0 : int dlt_daemon_process_user_message_overflow(DltDaemon *daemon,
    3205             :                                              DltDaemonLocal *daemon_local,
    3206             :                                              DltReceiver *rec,
    3207             :                                              int verbose)
    3208             : {
    3209             :     uint32_t len = sizeof(DltUserControlMsgBufferOverflow);
    3210             :     DltUserControlMsgBufferOverflow userpayload;
    3211             : 
    3212           0 :     PRINT_FUNCTION_VERBOSE(verbose);
    3213             : 
    3214           0 :     if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) {
    3215           0 :         dlt_vlog(LOG_ERR, "Invalid function parameters used for %s\n",
    3216             :                  __func__);
    3217           0 :         return -1;
    3218             :     }
    3219             : 
    3220           0 :     if (dlt_receiver_check_and_get(rec,
    3221             :                                    &userpayload,
    3222             :                                    len,
    3223             :                                    DLT_RCV_SKIP_HEADER | DLT_RCV_REMOVE) < 0)
    3224             :         /* Not enough bytes received */
    3225             :         return -1;
    3226             : 
    3227             :     /* Store in daemon, that a message buffer overflow has occured */
    3228             :     /* look if TCP connection to client is available or it least message can be put into buffer */
    3229           0 :     if (dlt_daemon_control_message_buffer_overflow(DLT_DAEMON_SEND_TO_ALL,
    3230             :                                                    daemon,
    3231             :                                                    daemon_local,
    3232             :                                                    userpayload.overflow_counter,
    3233             :                                                    userpayload.apid,
    3234             :                                                    verbose))
    3235             :         /* there was an error when storing message */
    3236             :         /* add the counter of lost messages to the daemon counter */
    3237           0 :         daemon->overflow_counter += userpayload.overflow_counter;
    3238             : 
    3239             :     return 0;
    3240             : }
    3241             : 
    3242           0 : int dlt_daemon_send_message_overflow(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose)
    3243             : {
    3244             :     int ret;
    3245           0 :     PRINT_FUNCTION_VERBOSE(verbose);
    3246             : 
    3247           0 :     if ((daemon == 0) || (daemon_local == 0)) {
    3248           0 :         dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_process_user_message_overflow()\n");
    3249           0 :         return DLT_DAEMON_ERROR_UNKNOWN;
    3250             :     }
    3251             : 
    3252             :     /* Store in daemon, that a message buffer overflow has occured */
    3253           0 :     if ((ret =
    3254           0 :              dlt_daemon_control_message_buffer_overflow(DLT_DAEMON_SEND_TO_ALL, daemon, daemon_local,
    3255             :                                                         daemon->overflow_counter,
    3256             :                                                         "", verbose)))
    3257           0 :         return ret;
    3258             : 
    3259             :     return DLT_DAEMON_ERROR_OK;
    3260             : }
    3261             : 
    3262           7 : int dlt_daemon_process_user_message_register_application(DltDaemon *daemon,
    3263             :                                                          DltDaemonLocal *daemon_local,
    3264             :                                                          DltReceiver *rec,
    3265             :                                                          int verbose)
    3266             : {
    3267             :     uint32_t len = sizeof(DltUserControlMsgRegisterApplication);
    3268             :     uint32_t to_remove = 0;
    3269             :     DltDaemonApplication *application = NULL;
    3270             :     DltDaemonApplication *old_application = NULL;
    3271             :     pid_t old_pid = 0;
    3272           7 :     char description[DLT_DAEMON_DESCSIZE + 1] = { '\0' };
    3273             :     DltUserControlMsgRegisterApplication userapp;
    3274             :     char *origin;
    3275             :     int fd = -1;
    3276             : 
    3277           7 :     PRINT_FUNCTION_VERBOSE(verbose);
    3278             : 
    3279           7 :     if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) {
    3280           0 :         dlt_vlog(LOG_ERR, "Invalid function parameters used for %s\n",
    3281             :                  __func__);
    3282           0 :         return -1;
    3283             :     }
    3284             : 
    3285             :     memset(&userapp, 0, sizeof(DltUserControlMsgRegisterApplication));
    3286           7 :     origin = rec->buf;
    3287             : 
    3288             :     /* Adding temp variable to check the return value */
    3289             :     int temp = 0;
    3290             : 
    3291             :     /* We shall not remove data before checking that everything is there. */
    3292           7 :     temp = dlt_receiver_check_and_get(rec,
    3293             :                                            &userapp,
    3294             :                                            len,
    3295             :                                            DLT_RCV_SKIP_HEADER);
    3296             : 
    3297           7 :     if (temp < 0)
    3298             :         /* Not enough bytes received */
    3299             :         return -1;
    3300             :     else {
    3301           7 :         to_remove = (uint32_t) temp;
    3302             :     }
    3303             : 
    3304           7 :     len = userapp.description_length;
    3305             : 
    3306           7 :     if (len > DLT_DAEMON_DESCSIZE) {
    3307             :         len = DLT_DAEMON_DESCSIZE;
    3308           0 :         dlt_log(LOG_WARNING, "Application description exceeds limit\n");
    3309             :     }
    3310             : 
    3311             :     /* adjust buffer pointer */
    3312           7 :     rec->buf += to_remove + sizeof(DltUserHeader);
    3313             : 
    3314           7 :     if (dlt_receiver_check_and_get(rec, description, len, DLT_RCV_NONE) < 0) {
    3315           0 :         dlt_log(LOG_ERR, "Unable to get application description\n");
    3316             :         /* in case description was not readable, set dummy description */
    3317             :         memcpy(description, "Unknown", sizeof("Unknown"));
    3318             : 
    3319             :         /* unknown len of original description, set to 0 to not remove in next
    3320             :          * step. Because message buffer is re-adjusted the corrupted description
    3321             :          * is ignored. */
    3322             :         len = 0;
    3323             :     }
    3324             : 
    3325             :     /* adjust to_remove */
    3326           7 :     to_remove += (uint32_t) sizeof(DltUserHeader) + len;
    3327             :     /* point to begin of message */
    3328           7 :     rec->buf = origin;
    3329             : 
    3330             :     /* We can now remove data. */
    3331           7 :     if (dlt_receiver_remove(rec, (int) to_remove) != DLT_RETURN_OK) {
    3332           0 :         dlt_log(LOG_WARNING, "Can't remove bytes from receiver\n");
    3333           0 :         return -1;
    3334             :     }
    3335             : 
    3336           7 :     old_application = dlt_daemon_application_find(daemon, userapp.apid, daemon->ecuid, verbose);
    3337             : 
    3338           7 :     if (old_application != NULL)
    3339           0 :         old_pid = old_application->pid;
    3340             : 
    3341           7 :     if (rec->type == DLT_RECEIVE_SOCKET)
    3342           0 :         fd = rec->fd; /* For sockets, an app specific fd has already been created with accept(). */
    3343             : 
    3344           7 :     application = dlt_daemon_application_add(daemon,
    3345             :                                              userapp.apid,
    3346             :                                              userapp.pid,
    3347             :                                              description,
    3348             :                                              fd,
    3349             :                                              daemon->ecuid,
    3350             :                                              verbose);
    3351             : 
    3352             :     /* send log state to new application */
    3353           7 :     dlt_daemon_user_send_log_state(daemon, application, verbose);
    3354             : 
    3355           7 :     if (application == NULL) {
    3356           0 :         dlt_vlog(LOG_WARNING, "Can't add ApplicationID '%.4s' for PID %d\n",
    3357             :                  userapp.apid, userapp.pid);
    3358           0 :         return -1;
    3359             :     }
    3360           7 :     else if (old_pid != application->pid)
    3361             :     {
    3362           7 :         char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' };
    3363             : 
    3364           7 :         snprintf(local_str,
    3365             :                  DLT_DAEMON_TEXTBUFSIZE,
    3366             :                  "ApplicationID '%.4s' registered for PID %d, Description=%s",
    3367           7 :                  application->apid,
    3368             :                  application->pid,
    3369             :                  application->application_description);
    3370           7 :         dlt_daemon_log_internal(daemon, daemon_local, local_str, DLT_LOG_INFO,
    3371             :                                 DLT_DAEMON_APP_ID, DLT_DAEMON_CTX_ID,
    3372             :                                 daemon_local->flags.vflag);
    3373           7 :         dlt_vlog(LOG_DEBUG, "%s%s", local_str, "\n");
    3374             :     }
    3375             : 
    3376             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
    3377             :     if (dlt_daemon_user_send_trace_load_config(daemon, application, verbose) != DLT_RETURN_OK)
    3378             :         dlt_vlog(LOG_WARNING, "Cannot send trace config to Apid: %.4s, PID: %d\n",
    3379             :                  application->apid, application->pid);
    3380             : #endif
    3381             : 
    3382             :     return 0;
    3383             : }
    3384             : 
    3385          38 : int dlt_daemon_process_user_message_register_context(DltDaemon *daemon,
    3386             :                                                      DltDaemonLocal *daemon_local,
    3387             :                                                      DltReceiver *rec,
    3388             :                                                      int verbose)
    3389             : {
    3390             :     uint32_t to_remove = 0;
    3391             :     uint32_t len = sizeof(DltUserControlMsgRegisterContext);
    3392             :     DltUserControlMsgRegisterContext userctxt;
    3393          38 :     char description[DLT_DAEMON_DESCSIZE + 1] = { '\0' };
    3394             :     DltDaemonApplication *application = NULL;
    3395             :     DltDaemonContext *context = NULL;
    3396             :     DltServiceGetLogInfoRequest *req = NULL;
    3397             :     char *origin;
    3398             : 
    3399             :     DltMessage msg;
    3400             : 
    3401          38 :     PRINT_FUNCTION_VERBOSE(verbose);
    3402             : 
    3403          38 :     if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) {
    3404           0 :         dlt_vlog(LOG_ERR, "Invalid function parameters used for %s\n",
    3405             :                  __func__);
    3406           0 :         return -1;
    3407             :     }
    3408             : 
    3409             :     memset(&userctxt, 0, sizeof(DltUserControlMsgRegisterContext));
    3410          38 :     origin = rec->buf;
    3411             : 
    3412             :     /* Adding temp variable to check the return value */
    3413             :     int temp = 0;
    3414             : 
    3415          38 :     temp = dlt_receiver_check_and_get(rec,
    3416             :                                            &userctxt,
    3417             :                                            len,
    3418             :                                            DLT_RCV_SKIP_HEADER);
    3419             : 
    3420          38 :     if (temp < 0)
    3421             :         /* Not enough bytes received */
    3422             :         return -1;
    3423             :     else {
    3424          38 :         to_remove = (uint32_t) temp;
    3425             :     }
    3426             : 
    3427          38 :     len = userctxt.description_length;
    3428             : 
    3429          38 :     if (len > DLT_DAEMON_DESCSIZE) {
    3430           0 :         dlt_vlog(LOG_WARNING, "Context description exceeds limit: %u\n", len);
    3431             :         len = DLT_DAEMON_DESCSIZE;
    3432             :     }
    3433             : 
    3434             :     /* adjust buffer pointer */
    3435          38 :     rec->buf += to_remove + sizeof(DltUserHeader);
    3436             : 
    3437          38 :     if (dlt_receiver_check_and_get(rec, description, len, DLT_RCV_NONE) < 0) {
    3438           0 :         dlt_log(LOG_ERR, "Unable to get context description\n");
    3439             :         /* in case description was not readable, set dummy description */
    3440             :         memcpy(description, "Unknown", sizeof("Unknown"));
    3441             : 
    3442             :         /* unknown len of original description, set to 0 to not remove in next
    3443             :          * step. Because message buffer is re-adjusted the corrupted description
    3444             :          * is ignored. */
    3445             :         len = 0;
    3446             :     }
    3447             : 
    3448             :     /* adjust to_remove */
    3449          38 :     to_remove += (uint32_t) sizeof(DltUserHeader) + len;
    3450             :     /* point to begin of message */
    3451          38 :     rec->buf = origin;
    3452             : 
    3453             :     /* We can now remove data. */
    3454          38 :     if (dlt_receiver_remove(rec, (int) to_remove) != DLT_RETURN_OK) {
    3455           0 :         dlt_log(LOG_WARNING, "Can't remove bytes from receiver\n");
    3456           0 :         return -1;
    3457             :     }
    3458             : 
    3459          38 :     application = dlt_daemon_application_find(daemon,
    3460             :                                               userctxt.apid,
    3461          38 :                                               daemon->ecuid,
    3462             :                                               verbose);
    3463             : 
    3464          38 :     if (application == 0) {
    3465           0 :         dlt_vlog(LOG_WARNING,
    3466             :                  "ApID '%.4s' not found for new ContextID '%.4s' in %s\n",
    3467             :                  userctxt.apid,
    3468             :                  userctxt.ctid,
    3469             :                  __func__);
    3470             : 
    3471           0 :         return 0;
    3472             :     }
    3473             : 
    3474             :     /* Set log level */
    3475          38 :     if (userctxt.log_level == DLT_USER_LOG_LEVEL_NOT_SET) {
    3476          38 :         userctxt.log_level = DLT_LOG_DEFAULT;
    3477             :     } else {
    3478             :         /* Plausibility check */
    3479           0 :         if ((userctxt.log_level < DLT_LOG_DEFAULT) ||
    3480             :                 (userctxt.log_level > DLT_LOG_VERBOSE)) {
    3481             :             return -1;
    3482             :         }
    3483             :     }
    3484             : 
    3485             :     /* Set trace status */
    3486          38 :     if (userctxt.trace_status == DLT_USER_TRACE_STATUS_NOT_SET) {
    3487          38 :         userctxt.trace_status = DLT_TRACE_STATUS_DEFAULT;
    3488             :     } else {
    3489             :         /* Plausibility check */
    3490           0 :         if ((userctxt.trace_status < DLT_TRACE_STATUS_DEFAULT) ||
    3491             :                 (userctxt.trace_status > DLT_TRACE_STATUS_ON)) {
    3492             :             return -1;
    3493             :         }
    3494             :     }
    3495             : 
    3496          38 :     context = dlt_daemon_context_add(daemon,
    3497             :                                      userctxt.apid,
    3498             :                                      userctxt.ctid,
    3499          38 :                                      userctxt.log_level,
    3500          38 :                                      userctxt.trace_status,
    3501             :                                      userctxt.log_level_pos,
    3502             :                                      application->user_handle,
    3503             :                                      description,
    3504             :                                      daemon->ecuid,
    3505             :                                      verbose);
    3506             : 
    3507          38 :     if (context == 0) {
    3508           0 :         dlt_vlog(LOG_WARNING,
    3509             :                  "Can't add ContextID '%.4s' for ApID '%.4s'\n in %s",
    3510             :                  userctxt.ctid, userctxt.apid, __func__);
    3511           0 :         return -1;
    3512             :     }
    3513             :     else {
    3514          38 :         char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' };
    3515             : 
    3516          38 :         snprintf(local_str,
    3517             :                  DLT_DAEMON_TEXTBUFSIZE,
    3518             :                  "ContextID '%.4s' registered for ApID '%.4s', Description=%s",
    3519          38 :                  context->ctid,
    3520          38 :                  context->apid,
    3521             :                  context->context_description);
    3522             : 
    3523          38 :         if (verbose)
    3524           0 :             dlt_daemon_log_internal(daemon, daemon_local, local_str,
    3525             :                                     DLT_LOG_INFO, DLT_DAEMON_APP_ID,
    3526             :                                     DLT_DAEMON_CTX_ID, verbose);
    3527             : 
    3528          38 :         dlt_vlog(LOG_DEBUG, "%s%s", local_str, "\n");
    3529             :     }
    3530             : 
    3531          38 :     if (daemon_local->flags.offlineLogstorageMaxDevices)
    3532             :         /* Store log level set for offline logstorage into context structure*/
    3533          33 :         context->storage_log_level =
    3534          33 :             (int8_t) dlt_daemon_logstorage_get_loglevel(daemon,
    3535          33 :                                                (int8_t) daemon_local->flags.offlineLogstorageMaxDevices,
    3536             :                                                userctxt.apid,
    3537             :                                                userctxt.ctid);
    3538             :     else
    3539           5 :         context->storage_log_level = DLT_LOG_DEFAULT;
    3540             : 
    3541             :     /* Create automatic get log info response for registered context */
    3542          38 :     if (daemon_local->flags.rflag) {
    3543             :         /* Prepare request for get log info with one application and one context */
    3544           0 :         if (dlt_message_init(&msg, verbose) == -1) {
    3545           0 :             dlt_log(LOG_WARNING, "Can't initialize message");
    3546           0 :             return -1;
    3547             :         }
    3548             : 
    3549           0 :         msg.datasize = sizeof(DltServiceGetLogInfoRequest);
    3550             : 
    3551           0 :         if (msg.databuffer && (msg.databuffersize < msg.datasize)) {
    3552           0 :             free(msg.databuffer);
    3553           0 :             msg.databuffer = 0;
    3554             :         }
    3555             : 
    3556           0 :         if (msg.databuffer == 0) {
    3557           0 :             msg.databuffer = (uint8_t *)malloc(msg.datasize);
    3558           0 :             msg.databuffersize = msg.datasize;
    3559             :         }
    3560             : 
    3561           0 :         if (msg.databuffer == 0) {
    3562           0 :             dlt_log(LOG_WARNING, "Can't allocate buffer for get log info message\n");
    3563           0 :             return -1;
    3564             :         }
    3565             : 
    3566             :         req = (DltServiceGetLogInfoRequest *)msg.databuffer;
    3567             : 
    3568           0 :         req->service_id = DLT_SERVICE_ID_GET_LOG_INFO;
    3569           0 :         req->options = (uint8_t) daemon_local->flags.autoResponseGetLogInfoOption;
    3570           0 :         dlt_set_id(req->apid, userctxt.apid);
    3571           0 :         dlt_set_id(req->ctid, userctxt.ctid);
    3572           0 :         dlt_set_id(req->com, "remo");
    3573             : 
    3574           0 :         dlt_daemon_control_get_log_info(DLT_DAEMON_SEND_TO_ALL, daemon, daemon_local, &msg, verbose);
    3575             : 
    3576           0 :         dlt_message_free(&msg, verbose);
    3577             :     }
    3578             : 
    3579          38 :     if (context->user_handle >= DLT_FD_MINIMUM) {
    3580          38 :         if ((userctxt.log_level == DLT_LOG_DEFAULT) || (userctxt.trace_status == DLT_TRACE_STATUS_DEFAULT)) {
    3581             :             /* This call also replaces the default values with the values defined for default */
    3582          38 :             if (dlt_daemon_user_send_log_level(daemon, context, verbose) == -1) {
    3583           0 :                 dlt_vlog(LOG_WARNING, "Can't send current log level as response to %s for (%.4s;%.4s)\n",
    3584             :                          __func__,
    3585             :                          context->apid,
    3586             :                          context->ctid);
    3587           0 :                 return -1;
    3588             :             }
    3589             :         }
    3590             :     }
    3591             : 
    3592             :     return 0;
    3593             : }
    3594             : 
    3595           6 : int dlt_daemon_process_user_message_unregister_application(DltDaemon *daemon,
    3596             :                                                            DltDaemonLocal *daemon_local,
    3597             :                                                            DltReceiver *rec,
    3598             :                                                            int verbose)
    3599             : {
    3600             :     uint32_t len = sizeof(DltUserControlMsgUnregisterApplication);
    3601             :     DltUserControlMsgUnregisterApplication userapp;
    3602             :     DltDaemonApplication *application = NULL;
    3603             :     DltDaemonContext *context;
    3604             :     int i, offset_base;
    3605             :     DltDaemonRegisteredUsers *user_list = NULL;
    3606             : 
    3607           6 :     PRINT_FUNCTION_VERBOSE(verbose);
    3608             : 
    3609           6 :     if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) {
    3610           0 :         dlt_vlog(LOG_ERR,
    3611             :                  "Invalid function parameters used for %s\n",
    3612             :                  __func__);
    3613           0 :         return -1;
    3614             :     }
    3615             : 
    3616           6 :     if (dlt_receiver_check_and_get(rec,
    3617             :                                    &userapp,
    3618             :                                    len,
    3619             :                                    DLT_RCV_SKIP_HEADER | DLT_RCV_REMOVE) < 0)
    3620             :         /* Not enough bytes received */
    3621             :         return -1;
    3622             : 
    3623           6 :     user_list = dlt_daemon_find_users_list(daemon, daemon->ecuid, verbose);
    3624             : 
    3625           6 :     if (user_list == NULL)
    3626             :         return -1;
    3627             : 
    3628           6 :     if (user_list->num_applications > 0) {
    3629             :         /* Delete this application and all corresponding contexts
    3630             :          * for this application from internal table.
    3631             :          */
    3632           6 :         application = dlt_daemon_application_find(daemon,
    3633             :                                                   userapp.apid,
    3634             :                                                   daemon->ecuid,
    3635             :                                                   verbose);
    3636             : 
    3637           6 :         if (application) {
    3638             :             /* Calculate start offset within contexts[] */
    3639             :             offset_base = 0;
    3640             : 
    3641           6 :             for (i = 0; i < (application - (user_list->applications)); i++)
    3642           0 :                 offset_base += user_list->applications[i].num_contexts;
    3643             : 
    3644           6 :             for (i = (application->num_contexts) - 1; i >= 0; i--) {
    3645           0 :                 context = &(user_list->contexts[offset_base + i]);
    3646             : 
    3647           0 :                 if (context) {
    3648             :                     /* Delete context */
    3649           0 :                     if (dlt_daemon_context_del(daemon,
    3650             :                                                context,
    3651             :                                                daemon->ecuid,
    3652             :                                                verbose) == -1) {
    3653           0 :                         dlt_vlog(LOG_WARNING,
    3654             :                                  "Can't delete CtID '%.4s' for ApID '%.4s' in %s\n",
    3655           0 :                                  context->ctid,
    3656           0 :                                  context->apid,
    3657             :                                  __func__);
    3658           0 :                         return -1;
    3659             :                     }
    3660             :                 }
    3661             :             }
    3662             : 
    3663             :             /* Delete this application entry from internal table*/
    3664           6 :             if (dlt_daemon_application_del(daemon,
    3665             :                                            application,
    3666             :                                            daemon->ecuid,
    3667             :                                            verbose) == -1) {
    3668           0 :                 dlt_vlog(LOG_WARNING,
    3669             :                          "Can't delete ApID '%.4s' in %s\n",
    3670           0 :                          application->apid,
    3671             :                          __func__);
    3672           0 :                 return -1;
    3673             :             }
    3674             :             else {
    3675           6 :                 char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' };
    3676             : 
    3677             :                 snprintf(local_str,
    3678             :                          DLT_DAEMON_TEXTBUFSIZE,
    3679             :                          "Unregistered ApID '%.4s'",
    3680             :                          userapp.apid);
    3681           6 :                 dlt_daemon_log_internal(daemon, daemon_local, local_str,
    3682             :                                         DLT_LOG_INFO, DLT_DAEMON_APP_ID,
    3683             :                                         DLT_DAEMON_CTX_ID, verbose);
    3684           6 :                 dlt_vlog(LOG_DEBUG, "%s%s", local_str, "\n");
    3685             :             }
    3686             :         }
    3687             :     }
    3688             : 
    3689             :     return 0;
    3690             : }
    3691             : 
    3692          37 : int dlt_daemon_process_user_message_unregister_context(DltDaemon *daemon,
    3693             :                                                        DltDaemonLocal *daemon_local,
    3694             :                                                        DltReceiver *rec,
    3695             :                                                        int verbose)
    3696             : {
    3697             :     uint32_t len = sizeof(DltUserControlMsgUnregisterContext);
    3698             :     DltUserControlMsgUnregisterContext userctxt;
    3699             :     DltDaemonContext *context;
    3700             : 
    3701          37 :     PRINT_FUNCTION_VERBOSE(verbose);
    3702             : 
    3703          37 :     if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) {
    3704           0 :         dlt_vlog(LOG_ERR,
    3705             :                  "Invalid function parameters used for %s\n",
    3706             :                  __func__);
    3707             : 
    3708           0 :         return -1;
    3709             :     }
    3710             : 
    3711          37 :     if (dlt_receiver_check_and_get(rec,
    3712             :                                    &userctxt,
    3713             :                                    len,
    3714             :                                    DLT_RCV_SKIP_HEADER | DLT_RCV_REMOVE) < 0)
    3715             :         /* Not enough bytes received */
    3716             :         return -1;
    3717             : 
    3718          37 :     context = dlt_daemon_context_find(daemon,
    3719             :                                       userctxt.apid,
    3720             :                                       userctxt.ctid,
    3721          37 :                                       daemon->ecuid,
    3722             :                                       verbose);
    3723             : 
    3724             :     /* In case the daemon is loaded with predefined contexts and its context
    3725             :      * unregisters, the context information will not be deleted from daemon's
    3726             :      * table until its parent application is unregistered.
    3727             :      */
    3728          37 :     if (context && (context->predefined == false)) {
    3729             :         /* Delete this connection entry from internal table*/
    3730          37 :         if (dlt_daemon_context_del(daemon, context, daemon->ecuid, verbose) == -1) {
    3731           0 :             dlt_vlog(LOG_WARNING,
    3732             :                      "Can't delete CtID '%.4s' for ApID '%.4s' in %s\n",
    3733             :                      userctxt.ctid,
    3734             :                      userctxt.apid,
    3735             :                      __func__);
    3736           0 :             return -1;
    3737             :         }
    3738             :         else {
    3739          37 :             char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' };
    3740             : 
    3741             :             snprintf(local_str,
    3742             :                      DLT_DAEMON_TEXTBUFSIZE,
    3743             :                      "Unregistered CtID '%.4s' for ApID '%.4s'",
    3744             :                      userctxt.ctid,
    3745             :                      userctxt.apid);
    3746             : 
    3747          37 :             if (verbose)
    3748           0 :                 dlt_daemon_log_internal(daemon, daemon_local, local_str,
    3749             :                                         DLT_LOG_INFO, DLT_DAEMON_APP_ID,
    3750             :                                         DLT_DAEMON_CTX_ID, verbose);
    3751             : 
    3752          37 :             dlt_vlog(LOG_DEBUG, "%s%s", local_str, "\n");
    3753             :         }
    3754             :     }
    3755             : 
    3756             :     /* Create automatic unregister context response for unregistered context */
    3757          37 :     if (daemon_local->flags.rflag)
    3758           0 :         dlt_daemon_control_message_unregister_context(DLT_DAEMON_SEND_TO_ALL,
    3759             :                                                       daemon,
    3760             :                                                       daemon_local,
    3761             :                                                       userctxt.apid,
    3762             :                                                       userctxt.ctid,
    3763             :                                                       "remo",
    3764             :                                                       verbose);
    3765             : 
    3766             :     return 0;
    3767             : }
    3768             : 
    3769        5809 : int dlt_daemon_process_user_message_log(DltDaemon *daemon,
    3770             :                                         DltDaemonLocal *daemon_local,
    3771             :                                         DltReceiver *rec,
    3772             :                                         int verbose)
    3773             : {
    3774             :     int ret = 0;
    3775             :     int size = 0;
    3776             : 
    3777        5809 :     PRINT_FUNCTION_VERBOSE(verbose);
    3778             : 
    3779        5809 :     if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) {
    3780           0 :         dlt_vlog(LOG_ERR, "%s: invalid function parameters.\n", __func__);
    3781           0 :         return DLT_DAEMON_ERROR_UNKNOWN;
    3782             :     }
    3783             : 
    3784             : #ifdef DLT_SYSTEMD_WATCHDOG_ENFORCE_MSG_RX_ENABLE
    3785             :     daemon->received_message_since_last_watchdog_interval = 1;
    3786             : #endif
    3787             : #ifdef DLT_SHM_ENABLE
    3788             : 
    3789             :     /** In case of SHM, the header still received via fifo/unix_socket receiver,
    3790             :      * so we need to remove header from the receiver.
    3791             :      */
    3792             :     if (dlt_receiver_remove(rec, sizeof(DltUserHeader)) < 0)
    3793             :         /* Not enough bytes received to remove*/
    3794             :         return DLT_DAEMON_ERROR_UNKNOWN;
    3795             : 
    3796             : #ifdef DLT_SYSTEMD_WATCHDOG_ENABLE
    3797             :     const unsigned int start_time = dlt_uptime();
    3798             : #endif
    3799             : 
    3800             :     while (1) {
    3801             : #ifdef DLT_SYSTEMD_WATCHDOG_ENABLE
    3802             :         const unsigned int uptime = dlt_uptime();
    3803             :         if ((uptime - start_time) / 10000 > daemon->watchdog_trigger_interval) {
    3804             :             dlt_vlog(LOG_WARNING,
    3805             :                      "spent already 1 watchdog trigger interval in %s, yielding to process other events.\n", __func__);
    3806             :             if (sd_notify(0, "WATCHDOG=1") < 0)
    3807             :                 dlt_vlog(LOG_CRIT, "Could not reset systemd watchdog from %s\n", __func__);
    3808             :             break;
    3809             :         }
    3810             : #endif
    3811             : 
    3812             :         /* get log message from SHM then store into receiver buffer */
    3813             :         size = dlt_shm_pull(&(daemon_local->dlt_shm),
    3814             :                             daemon_local->recv_buf_shm,
    3815             :                             DLT_SHM_RCV_BUFFER_SIZE);
    3816             : 
    3817             :         if (size <= 0)
    3818             :             break;
    3819             : 
    3820             :         ret = dlt_message_read(&(daemon_local->msg),
    3821             :                                daemon_local->recv_buf_shm, size, 0, verbose);
    3822             : 
    3823             :         if (DLT_MESSAGE_ERROR_OK != ret) {
    3824             :             dlt_shm_remove(&(daemon_local->dlt_shm));
    3825             :             dlt_log(LOG_WARNING, "failed to read messages from shm.\n");
    3826             :             return DLT_DAEMON_ERROR_UNKNOWN;
    3827             :         }
    3828             : 
    3829             : #if defined(DLT_LOG_LEVEL_APP_CONFIG) || defined(DLT_TRACE_LOAD_CTRL_ENABLE)
    3830             :         DltDaemonApplication *app = dlt_daemon_application_find(
    3831             :             daemon, daemon_local->msg.extendedheader->apid, daemon->ecuid, verbose);
    3832             : #endif
    3833             : 
    3834             :         /* discard non-allowed levels if enforcement is on */
    3835             :         bool keep_message = enforce_context_ll_and_ts_keep_message(
    3836             :             daemon_local
    3837             : #ifdef DLT_LOG_LEVEL_APP_CONFIG
    3838             :             , app
    3839             : #endif
    3840             :         );
    3841             : 
    3842             :         // check trace_load
    3843             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
    3844             :         keep_message &= trace_load_keep_message(app, size, daemon, daemon_local, verbose);
    3845             : #endif
    3846             : 
    3847             :         if (keep_message)
    3848             :           dlt_daemon_client_send_message_to_all_client(daemon, daemon_local, verbose);
    3849             : 
    3850             :         if (DLT_DAEMON_ERROR_OK != ret)
    3851             :             dlt_log(LOG_ERR, "failed to send message to client.\n");
    3852             :     }
    3853             : 
    3854             : #else
    3855        5809 :     ret = dlt_message_read(&(daemon_local->msg),
    3856        5809 :                            (unsigned char *)rec->buf + sizeof(DltUserHeader),
    3857        5809 :                            (unsigned int) ((unsigned int) rec->bytesRcvd - sizeof(DltUserHeader)),
    3858             :                            0,
    3859             :                            verbose);
    3860             : 
    3861        5809 :     if (ret != DLT_MESSAGE_ERROR_OK) {
    3862           0 :         if (ret != DLT_MESSAGE_ERROR_SIZE)
    3863             :             /* This is a normal usecase: The daemon reads the data in 10kb chunks.
    3864             :              * Thus the last trace in this chunk is probably not complete and will be completed
    3865             :              * with the next chunk read. This happens always when the FIFO is filled with more than 10kb before
    3866             :              * the daemon is able to read from the FIFO.
    3867             :              * Thus the loglevel of this message is set to DEBUG.
    3868             :              * A cleaner solution would be to check more in detail whether the message is not complete (normal usecase)
    3869             :              * or the headers are corrupted (error case). */
    3870           0 :             dlt_log(LOG_DEBUG, "Can't read messages from receiver\n");
    3871             : 
    3872           0 :         if (dlt_receiver_remove(rec, rec->bytesRcvd) != DLT_RETURN_OK) {
    3873             :             /* In certain rare scenarios where only a partial message has been received
    3874             :              * (Eg: kernel IPC buffer memory being full), we want to discard the message
    3875             :              * and not broadcast it forward to connected clients. Since the DLT library
    3876             :              * checks return value of the writev() call against the sent total message
    3877             :              * length, the partial message will be buffered and retransmitted again.
    3878             :              * This implicitly ensures that no message loss occurs.
    3879             :              */
    3880           0 :             dlt_log(LOG_WARNING, "failed to remove required bytes from receiver.\n");
    3881             :         }
    3882             : 
    3883           0 :         return DLT_DAEMON_ERROR_UNKNOWN;
    3884             :     }
    3885             : 
    3886             : #if defined(DLT_LOG_LEVEL_APP_CONFIG) || defined(DLT_TRACE_LOAD_CTRL_ENABLE)
    3887             :     DltDaemonApplication *app = dlt_daemon_application_find(
    3888             :         daemon, daemon_local->msg.extendedheader->apid, daemon->ecuid, verbose);
    3889             : #endif
    3890             : 
    3891             :     /* discard non-allowed levels if enforcement is on */
    3892           0 :     bool keep_message = enforce_context_ll_and_ts_keep_message(
    3893             :         daemon_local
    3894             : #ifdef DLT_LOG_LEVEL_APP_CONFIG
    3895             :         , app
    3896             : #endif
    3897             :     );
    3898             : 
    3899             :     // check trace_load
    3900             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
    3901             :     keep_message &=
    3902             :         trace_load_keep_message(app, size, daemon, daemon_local, verbose);
    3903             : #endif
    3904             : 
    3905           0 :     if (keep_message)
    3906        5809 :       dlt_daemon_client_send_message_to_all_client(daemon, daemon_local, verbose);
    3907             : 
    3908             :     /* keep not read data in buffer */
    3909        5809 :     size = (int) (daemon_local->msg.headersize +
    3910        5809 :         daemon_local->msg.datasize - sizeof(DltStorageHeader) +
    3911             :         sizeof(DltUserHeader));
    3912             : 
    3913        5809 :     if (daemon_local->msg.found_serialheader)
    3914             :         size += (int) sizeof(dltSerialHeader);
    3915             : 
    3916        5809 :     if (dlt_receiver_remove(rec, size) != DLT_RETURN_OK) {
    3917           0 :         dlt_log(LOG_WARNING, "failed to remove bytes from receiver.\n");
    3918           0 :         return DLT_DAEMON_ERROR_UNKNOWN;
    3919             :     }
    3920             : 
    3921             : #endif
    3922             : 
    3923             :     return DLT_DAEMON_ERROR_OK;
    3924             : }
    3925             : 
    3926           0 : bool enforce_context_ll_and_ts_keep_message(DltDaemonLocal *daemon_local
    3927             : #ifdef DLT_LOG_LEVEL_APP_CONFIG
    3928             :                                             , DltDaemonApplication *app
    3929             : #endif
    3930             : )
    3931             : {
    3932        5809 :     if (!daemon_local->flags.enforceContextLLAndTS ||
    3933           0 :         !daemon_local->msg.extendedheader) {
    3934             :         return true;
    3935             :     }
    3936             : 
    3937             : #ifdef DLT_LOG_LEVEL_APP_CONFIG
    3938             :     if (app == NULL) {
    3939             :         return true;
    3940             :     }
    3941             : #endif
    3942             : 
    3943           0 :     const int mtin = DLT_GET_MSIN_MTIN(daemon_local->msg.extendedheader->msin);
    3944             : #ifdef DLT_LOG_LEVEL_APP_CONFIG
    3945             :     if (app->num_context_log_level_settings > 0) {
    3946             :         DltDaemonContextLogSettings *log_settings =
    3947             :             dlt_daemon_find_app_log_level_config(app, daemon_local->msg.extendedheader->ctid);
    3948             : 
    3949             :         if (log_settings != NULL) {
    3950             :             return mtin <= log_settings->log_level;
    3951             :         }
    3952             :     }
    3953             : #endif
    3954           0 :     return mtin <= daemon_local->flags.contextLogLevel;
    3955             : }
    3956             : 
    3957             : 
    3958             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
    3959             : bool trace_load_keep_message(DltDaemonApplication *app,
    3960             :                              const int size, DltDaemon *const daemon,
    3961             :                              DltDaemonLocal *const daemon_local,
    3962             :                              int verbose)
    3963             : {
    3964             :     bool keep_message = true;
    3965             :     if (app == NULL || !daemon_local->msg.extendedheader) {
    3966             :         return keep_message;
    3967             :     }
    3968             : 
    3969             :     DltMessage* msg = &daemon_local->msg;
    3970             :     const int mtin = DLT_GET_MSIN_MTIN(msg->extendedheader->msin);
    3971             : 
    3972             :     struct DltTraceLoadLogParams params = {
    3973             :         daemon,
    3974             :         daemon_local,
    3975             :         verbose,
    3976             :         app->apid,
    3977             :     };
    3978             : 
    3979             :     DltTraceLoadSettings *trace_load_settings =
    3980             :         dlt_find_runtime_trace_load_settings(
    3981             :             app->trace_load_settings, app->trace_load_settings_count,
    3982             :             app->apid, msg->extendedheader->ctid);
    3983             : 
    3984             :     if (trace_load_settings != NULL) {
    3985             :         pthread_rwlock_wrlock(&trace_load_rw_lock);
    3986             :         keep_message = dlt_check_trace_load(
    3987             :             trace_load_settings, mtin, msg->headerextra.tmsp, size,
    3988             :             dlt_daemon_output_internal_msg, (void *)(&params));
    3989             :         pthread_rwlock_unlock(&trace_load_rw_lock);
    3990             :     }
    3991             :     else {
    3992             :         dlt_vlog(
    3993             :             LOG_ERR,
    3994             :             "Failed to lookup trace load limits for %s, "
    3995             :             "dropping message, likely app was not registered properly\n",
    3996             :             app->apid);
    3997             :         keep_message = false;
    3998             :     }
    3999             : 
    4000             :     return keep_message;
    4001             : }
    4002             : #endif
    4003             : 
    4004           0 : int dlt_daemon_process_user_message_set_app_ll_ts(DltDaemon *daemon,
    4005             :                                                   DltDaemonLocal *daemon_local,
    4006             :                                                   DltReceiver *rec,
    4007             :                                                   int verbose)
    4008             : {
    4009             :     uint32_t len = sizeof(DltUserControlMsgAppLogLevelTraceStatus);
    4010             :     DltUserControlMsgAppLogLevelTraceStatus userctxt;
    4011             :     DltDaemonApplication *application;
    4012             :     DltDaemonContext *context;
    4013             :     int i, offset_base;
    4014             :     int8_t old_log_level, old_trace_status;
    4015             :     DltDaemonRegisteredUsers *user_list = NULL;
    4016             : 
    4017           0 :     PRINT_FUNCTION_VERBOSE(verbose);
    4018             : 
    4019           0 :     if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) {
    4020           0 :         dlt_vlog(LOG_ERR,
    4021             :                  "Invalid function parameters used for %s\n",
    4022             :                  __func__);
    4023           0 :         return DLT_RETURN_ERROR;
    4024             :     }
    4025             : 
    4026           0 :     user_list = dlt_daemon_find_users_list(daemon, daemon->ecuid, verbose);
    4027             : 
    4028           0 :     if (user_list == NULL)
    4029             :         return DLT_RETURN_ERROR;
    4030             : 
    4031             :     memset(&userctxt, 0, len);
    4032             : 
    4033           0 :     if (dlt_receiver_check_and_get(rec,
    4034             :                                    &userctxt,
    4035             :                                    len,
    4036             :                                    DLT_RCV_SKIP_HEADER | DLT_RCV_REMOVE) < 0)
    4037             :         /* Not enough bytes received */
    4038             :         return DLT_RETURN_ERROR;
    4039             : 
    4040           0 :     if (user_list->num_applications > 0) {
    4041             :         /* Get all contexts with application id matching the received application id */
    4042           0 :         application = dlt_daemon_application_find(daemon,
    4043             :                                                   userctxt.apid,
    4044             :                                                   daemon->ecuid,
    4045             :                                                   verbose);
    4046             : 
    4047           0 :         if (application) {
    4048             :             /* Calculate start offset within contexts[] */
    4049             :             offset_base = 0;
    4050             : 
    4051           0 :             for (i = 0; i < (application - (user_list->applications)); i++)
    4052           0 :                 offset_base += user_list->applications[i].num_contexts;
    4053             : 
    4054           0 :             for (i = 0; i < application->num_contexts; i++) {
    4055           0 :                 context = &(user_list->contexts[offset_base + i]);
    4056             : 
    4057           0 :                 if (context) {
    4058           0 :                     old_log_level = context->log_level;
    4059           0 :                     context->log_level = (int8_t) userctxt.log_level; /* No endianess conversion necessary*/
    4060             : 
    4061           0 :                     old_trace_status = context->trace_status;
    4062           0 :                     context->trace_status = (int8_t) userctxt.trace_status;   /* No endianess conversion necessary */
    4063             : 
    4064             :                     /* The following function sends also the trace status */
    4065           0 :                     if ((context->user_handle >= DLT_FD_MINIMUM) &&
    4066           0 :                         (dlt_daemon_user_send_log_level(daemon,
    4067             :                                                         context,
    4068             :                                                         verbose) != 0)) {
    4069           0 :                         context->log_level = old_log_level;
    4070           0 :                         context->trace_status = old_trace_status;
    4071             :                     }
    4072             :                 }
    4073             :             }
    4074             :         }
    4075             :     }
    4076             : 
    4077             :     return DLT_RETURN_OK;
    4078             : }
    4079             : 
    4080           0 : int dlt_daemon_process_user_message_log_mode(DltDaemon *daemon,
    4081             :                                              DltDaemonLocal *daemon_local,
    4082             :                                              DltReceiver *rec,
    4083             :                                              int verbose)
    4084             : {
    4085             :     DltUserControlMsgLogMode userctxt;
    4086             :     uint32_t len = sizeof(DltUserControlMsgLogMode);
    4087             : 
    4088           0 :     PRINT_FUNCTION_VERBOSE(verbose);
    4089             : 
    4090           0 :     if ((daemon == 0) || (daemon_local == 0)) {
    4091           0 :         dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_process_log_mode()\n");
    4092           0 :         return -1;
    4093             :     }
    4094             : 
    4095             :     memset(&userctxt, 0, len);
    4096             : 
    4097           0 :     if (dlt_receiver_check_and_get(rec,
    4098             :                                    &userctxt,
    4099             :                                    len,
    4100             :                                    DLT_RCV_SKIP_HEADER | DLT_RCV_REMOVE) < 0)
    4101             :         /* Not enough bytes received */
    4102             :         return -1;
    4103             : 
    4104             :     /* set the new log mode */
    4105           0 :     daemon->mode = userctxt.log_mode;
    4106             : 
    4107             :     /* write configuration persistantly */
    4108           0 :     dlt_daemon_configuration_save(daemon, daemon->runtime_configuration, verbose);
    4109             : 
    4110           0 :     return 0;
    4111             : }
    4112             : 
    4113           0 : int dlt_daemon_process_user_message_marker(DltDaemon *daemon,
    4114             :                                            DltDaemonLocal *daemon_local,
    4115             :                                            DltReceiver *rec,
    4116             :                                            int verbose)
    4117             : {
    4118             :     uint32_t len = sizeof(DltUserControlMsgLogMode);
    4119             :     DltUserControlMsgLogMode userctxt;
    4120           0 :     PRINT_FUNCTION_VERBOSE(verbose);
    4121             : 
    4122           0 :     if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) {
    4123           0 :         dlt_vlog(LOG_ERR, "Invalid function parameters used for %s\n",
    4124             :                  __func__);
    4125           0 :         return -1;
    4126             :     }
    4127             : 
    4128             :     memset(&userctxt, 0, len);
    4129             : 
    4130           0 :     if (dlt_receiver_check_and_get(rec,
    4131             :                                    &userctxt,
    4132             :                                    len,
    4133             :                                    DLT_RCV_SKIP_HEADER | DLT_RCV_REMOVE) < 0)
    4134             :         /* Not enough bytes received */
    4135             :         return -1;
    4136             : 
    4137             :     /* Create automatic unregister context response for unregistered context */
    4138           0 :     dlt_daemon_control_message_marker(DLT_DAEMON_SEND_TO_ALL, daemon, daemon_local, verbose);
    4139             : 
    4140           0 :     return 0;
    4141             : }
    4142             : 
    4143           2 : int dlt_daemon_send_ringbuffer_to_client(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose)
    4144             : {
    4145             :     int ret;
    4146             :     static uint8_t data[DLT_DAEMON_RCVBUFSIZE];
    4147             :     int length;
    4148             : #ifdef DLT_SYSTEMD_WATCHDOG_ENABLE
    4149             :     uint32_t curr_time = 0U;
    4150             : #endif
    4151             : 
    4152           2 :     PRINT_FUNCTION_VERBOSE(verbose);
    4153             : 
    4154           2 :     if ((daemon == 0) || (daemon_local == 0)) {
    4155           0 :         dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_send_ringbuffer_to_client()\n");
    4156           0 :         return DLT_DAEMON_ERROR_UNKNOWN;
    4157             :     }
    4158             : 
    4159           2 :     if (dlt_buffer_get_message_count(&(daemon->client_ringbuffer)) <= 0) {
    4160           0 :         dlt_daemon_change_state(daemon, DLT_DAEMON_STATE_SEND_DIRECT);
    4161           0 :         return DLT_DAEMON_ERROR_OK;
    4162             :     }
    4163             : 
    4164           4 :     while ((length = dlt_buffer_copy(&(daemon->client_ringbuffer), data, sizeof(data))) > 0) {
    4165             : #ifdef DLT_SYSTEMD_WATCHDOG_ENABLE
    4166             :         dlt_daemon_trigger_systemd_watchdog_if_necessary(&curr_time, daemon->watchdog_trigger_interval);
    4167             : #endif
    4168             : 
    4169           4 :         if ((ret =
    4170           4 :                  dlt_daemon_client_send(DLT_DAEMON_SEND_FORCE, daemon, daemon_local, 0, 0, data, length, 0, 0,
    4171             :                                         verbose)))
    4172           0 :             return ret;
    4173             : 
    4174           4 :         dlt_buffer_remove(&(daemon->client_ringbuffer));
    4175             : 
    4176           4 :         if (daemon->state != DLT_DAEMON_STATE_SEND_BUFFER)
    4177           0 :             dlt_daemon_change_state(daemon, DLT_DAEMON_STATE_SEND_BUFFER);
    4178             : 
    4179           4 :         if (dlt_buffer_get_message_count(&(daemon->client_ringbuffer)) <= 0) {
    4180           2 :             dlt_daemon_change_state(daemon, DLT_DAEMON_STATE_SEND_DIRECT);
    4181           2 :             return DLT_DAEMON_ERROR_OK;
    4182             :         }
    4183             :     }
    4184             : 
    4185             :     return DLT_DAEMON_ERROR_OK;
    4186             : }
    4187             : 
    4188             : #ifdef __QNX__
    4189             : static void *timer_thread(void *data)
    4190             : {
    4191             :     int pexit = 0;
    4192             :     unsigned int sleep_ret = 0;
    4193             : 
    4194             :     DltDaemonPeriodicData* timer_thread_data = (DltDaemonPeriodicData*) data;
    4195             : 
    4196             :     /* Timer will start in starts_in sec*/
    4197             :     if ((sleep_ret = sleep(timer_thread_data->starts_in))) {
    4198             :         dlt_vlog(LOG_NOTICE, "Sleep remains [%u] for starting!"
    4199             :                 "Stop thread of timer [%d]\n",
    4200             :                 sleep_ret, timer_thread_data->timer_id);
    4201             :          close_pipes(dlt_timer_pipes[timer_thread_data->timer_id]);
    4202             :          return NULL;
    4203             :     }
    4204             : 
    4205             :     while (1) {
    4206             :         if ((dlt_timer_pipes[timer_thread_data->timer_id][1] > 0) &&
    4207             :                 (0 > write(dlt_timer_pipes[timer_thread_data->timer_id][1], "1", 1))) {
    4208             :             dlt_vlog(LOG_ERR, "Failed to send notification for timer [%s]!\n",
    4209             :                     dlt_timer_names[timer_thread_data->timer_id]);
    4210             :             pexit = 1;
    4211             :         }
    4212             : 
    4213             :         if (pexit || g_exit) {
    4214             :             dlt_vlog(LOG_NOTICE, "Received signal!"
    4215             :                     "Stop thread of timer [%d]\n",
    4216             :                     timer_thread_data->timer_id);
    4217             :             close_pipes(dlt_timer_pipes[timer_thread_data->timer_id]);
    4218             :             return NULL;
    4219             :         }
    4220             : 
    4221             :         if ((sleep_ret = sleep(timer_thread_data->period_sec))) {
    4222             :             dlt_vlog(LOG_NOTICE, "Sleep remains [%u] for interval!"
    4223             :                     "Stop thread of timer [%d]\n",
    4224             :                     sleep_ret, timer_thread_data->timer_id);
    4225             :              close_pipes(dlt_timer_pipes[timer_thread_data->timer_id]);
    4226             :              return NULL;
    4227             :         }
    4228             :     }
    4229             : }
    4230             : #endif
    4231             : 
    4232          10 : int create_timer_fd(DltDaemonLocal *daemon_local,
    4233             :                     int period_sec,
    4234             :                     int starts_in,
    4235             :                     DltTimers timer_id)
    4236             : {
    4237             :     int local_fd = DLT_FD_INIT;
    4238             :     char *timer_name = NULL;
    4239             : 
    4240          10 :     if (timer_id >= DLT_TIMER_UNKNOWN) {
    4241           0 :         dlt_log(DLT_LOG_ERROR, "Unknown timer.");
    4242           0 :         return -1;
    4243             :     }
    4244             : 
    4245          10 :     timer_name = dlt_timer_names[timer_id];
    4246             : 
    4247          10 :     if (daemon_local == NULL) {
    4248           0 :         dlt_log(DLT_LOG_ERROR, "Daemon local structure is NULL");
    4249           0 :         return -1;
    4250             :     }
    4251             : 
    4252          10 :     if ((period_sec <= 0) || (starts_in <= 0)) {
    4253             :         /* timer not activated via the service file */
    4254           0 :         dlt_vlog(LOG_INFO, "<%s> not set: period=0\n", timer_name);
    4255             :         local_fd = DLT_FD_INIT;
    4256             :     }
    4257             :     else {
    4258             : #ifdef linux
    4259             :         struct itimerspec l_timer_spec;
    4260          10 :         local_fd = timerfd_create(CLOCK_MONOTONIC, 0);
    4261             : 
    4262          10 :         if (local_fd < 0)
    4263           0 :             dlt_vlog(LOG_WARNING, "<%s> timerfd_create failed: %s\n",
    4264           0 :                      timer_name, strerror(errno));
    4265             : 
    4266          10 :         l_timer_spec.it_interval.tv_sec = period_sec;
    4267          10 :         l_timer_spec.it_interval.tv_nsec = 0;
    4268          10 :         l_timer_spec.it_value.tv_sec = starts_in;
    4269          10 :         l_timer_spec.it_value.tv_nsec = 0;
    4270             : 
    4271          10 :         if (timerfd_settime(local_fd, 0, &l_timer_spec, NULL) < 0) {
    4272           0 :             dlt_vlog(LOG_WARNING, "<%s> timerfd_settime failed: %s\n",
    4273           0 :                      timer_name, strerror(errno));
    4274             :             local_fd = DLT_FD_INIT;
    4275             :         }
    4276             : #elif __QNX__
    4277             :         /*
    4278             :          * Since timerfd is not valid in QNX, new threads are introduced
    4279             :          * to manage timers and communicate with main thread when timer expires.
    4280             :          */
    4281             :         if(0 != pipe(dlt_timer_pipes[timer_id])) {
    4282             :             dlt_vlog(LOG_ERR, "Failed to create pipe for timer [%s]",
    4283             :                     dlt_timer_names[timer_id]);
    4284             :             return -1;
    4285             :         }
    4286             :         if (NULL == timer_data[timer_id]) {
    4287             :             timer_data[timer_id] = calloc(1, sizeof(DltDaemonPeriodicData));
    4288             :             if (NULL == timer_data[timer_id]) {
    4289             :                 dlt_vlog(LOG_ERR, "Failed to allocate memory for timer_data [%s]!\n",
    4290             :                          dlt_timer_names[timer_id]);
    4291             :                 close_pipes(dlt_timer_pipes[timer_id]);
    4292             :                 return -1;
    4293             :             }
    4294             :         }
    4295             : 
    4296             :         timer_data[timer_id]->timer_id = timer_id;
    4297             :         timer_data[timer_id]->period_sec = period_sec;
    4298             :         timer_data[timer_id]->starts_in = starts_in;
    4299             :         timer_data[timer_id]->wakeups_missed = 0;
    4300             : 
    4301             :         if (0 != pthread_create(&timer_threads[timer_id], NULL,
    4302             :                             &timer_thread, (void*)timer_data[timer_id])) {
    4303             :             dlt_vlog(LOG_ERR, "Failed to create new thread for timer [%s]!\n",
    4304             :                                      dlt_timer_names[timer_id]);
    4305             :             /* Clean up timer before returning */
    4306             :             close_pipes(dlt_timer_pipes[timer_id]);
    4307             :             free(timer_data[timer_id]);
    4308             :             timer_data[timer_id] = NULL;
    4309             : 
    4310             :             return -1;
    4311             :         }
    4312             :         local_fd = dlt_timer_pipes[timer_id][0];
    4313             : #endif
    4314             :     }
    4315             : 
    4316          10 :     return dlt_connection_create(daemon_local,
    4317             :                                  &daemon_local->pEvent,
    4318             :                                  local_fd,
    4319             :                                  POLLIN,
    4320          10 :                                  dlt_timer_conn_types[timer_id]);
    4321             : }
    4322             : 
    4323             : /* Close connection function */
    4324           5 : int dlt_daemon_close_socket(int sock, DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose)
    4325             : {
    4326           5 :     char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' };
    4327             : 
    4328           5 :     PRINT_FUNCTION_VERBOSE(verbose);
    4329             : 
    4330           5 :     if ((daemon_local == NULL) || (daemon == NULL)) {
    4331           0 :         dlt_log(LOG_ERR, "dlt_daemon_close_socket: Invalid input parmeters\n");
    4332           0 :         return -1;
    4333             :     }
    4334             : 
    4335             :     /* Closure is done while unregistering has for any connection */
    4336           5 :     dlt_event_handler_unregister_connection(&daemon_local->pEvent,
    4337             :                                             daemon_local,
    4338             :                                             sock);
    4339             : 
    4340           5 :     if (daemon_local->client_connections == 0) {
    4341             :         /* send new log state to all applications */
    4342           3 :         daemon->connectionState = 0;
    4343           3 :         dlt_daemon_user_send_all_log_state(daemon, verbose);
    4344             : 
    4345             :         /* For offline tracing we still can use the same states */
    4346             :         /* as for socket sending. Using this trick we see the traces */
    4347             :         /* In the offline trace AND in the socket stream. */
    4348           3 :         if (daemon_local->flags.yvalue[0] == 0)
    4349           3 :             dlt_daemon_change_state(daemon, DLT_DAEMON_STATE_BUFFER);
    4350             :     }
    4351             : 
    4352           5 :     dlt_daemon_control_message_connection_info(DLT_DAEMON_SEND_TO_ALL,
    4353             :                                                daemon,
    4354             :                                                daemon_local,
    4355             :                                                DLT_CONNECTION_STATUS_DISCONNECTED,
    4356             :                                                "",
    4357             :                                                verbose);
    4358             : 
    4359           5 :     snprintf(local_str, DLT_DAEMON_TEXTBUFSIZE,
    4360             :              "Client connection #%d closed. Total Clients : %d",
    4361             :              sock,
    4362             :              daemon_local->client_connections);
    4363           5 :     dlt_daemon_log_internal(daemon, daemon_local, local_str, DLT_LOG_INFO,
    4364             :                             DLT_DAEMON_APP_ID, DLT_DAEMON_CTX_ID,
    4365             :                             daemon_local->flags.vflag);
    4366           5 :     dlt_vlog(LOG_DEBUG, "%s%s", local_str, "\n");
    4367             : 
    4368           5 :     return 0;
    4369             : }
    4370             : 
    4371             : #ifdef DLT_TRACE_LOAD_CTRL_ENABLE
    4372             : 
    4373             : static DltReturnValue dlt_daemon_output_internal_msg(
    4374             :     const DltLogLevelType loglevel, const char *const text, void* const params) {
    4375             :     struct DltTraceLoadLogParams* log_params = (struct DltTraceLoadLogParams*)params;
    4376             :     return dlt_daemon_log_internal(
    4377             :         log_params->daemon, log_params->daemon_local, (char *)text, loglevel,
    4378             :         log_params->app_id, DLT_TRACE_LOAD_CONTEXT_ID, log_params->verbose);
    4379             : }
    4380             : #endif
    4381             : 
    4382             : 
    4383             : /**
    4384             :  \}
    4385             :  */

Generated by: LCOV version 1.14