From a9a43701138c99b3211ded8d388666161f7cde67 Mon Sep 17 00:00:00 2001 From: Frederic Berat Date: Tue, 1 Dec 2015 11:13:12 +0100 Subject: dlt-daemon: receiver rework The receiver structures have been removed from the dlt-daemon structure, they are now part of the connection. The overall usage of the receiver structrure has also been reviewed in the daemon. Signed-off-by: Frederic Berat Change-Id: I7cf80d79ed73bd6d4f370bb3f278d26ccc9d8d7a --- src/daemon/dlt-daemon.c | 1210 +++++++++++++++++++++++------------------------ 1 file changed, 595 insertions(+), 615 deletions(-) (limited to 'src/daemon/dlt-daemon.c') diff --git a/src/daemon/dlt-daemon.c b/src/daemon/dlt-daemon.c index 804b36b..674ece5 100644 --- a/src/daemon/dlt-daemon.c +++ b/src/daemon/dlt-daemon.c @@ -562,6 +562,9 @@ int main(int argc, char* argv[]) DltDaemon daemon; int back = 0; + memset(&daemon_local, 0, sizeof(DltDaemonLocal)); + memset(&daemon, 0, sizeof(DltDaemon)); + /* Command line option handling */ if ((back = option_handling(&daemon_local,argc,argv))<0) { @@ -657,27 +660,18 @@ int main(int argc, char* argv[]) create_timer_fd(&daemon_local, watchdogTimeoutSeconds, watchdogTimeoutSeconds, - &daemon_local.timer_wd.fd, DLT_TIMER_SYSTEMD); } #endif // create fd for timer timing packets - create_timer_fd(&daemon_local, - 1, - 1, - &daemon_local.timer_one_s.fd, - DLT_TIMER_PACKET); + create_timer_fd(&daemon_local, 1, 1, DLT_TIMER_PACKET); // create fd for timer ecu version if((daemon_local.flags.sendECUSoftwareVersion > 0) || (daemon_local.flags.sendTimezone > 0)) { - create_timer_fd(&daemon_local, - 60, - 60, - &daemon_local.timer_sixty_s.fd, - DLT_TIMER_ECU); + create_timer_fd(&daemon_local, 60, 60, DLT_TIMER_ECU); } /* initiate gateway */ @@ -693,15 +687,8 @@ int main(int argc, char* argv[]) create_timer_fd(&daemon_local, DLT_GATEWAY_TIMER_INTERVAL, DLT_GATEWAY_TIMER_INTERVAL, - &daemon_local.timer_gateway.fd, DLT_TIMER_GATEWAY); } - if (dlt_connection_create_remaining(&daemon_local) == -1) - { - /* TODO: Perform clean-up */ - dlt_log(LOG_CRIT,"Fail to create remaining connection handler!\n"); - return -1; - } // For offline tracing we still can use the same states // as for socket sending. Using this trick we see the traces @@ -879,31 +866,6 @@ int dlt_daemon_local_init_p2(DltDaemon *daemon, DltDaemonLocal *daemon_local, in return -1; } - if (dlt_receiver_init(&(daemon_local->receiver),daemon_local->fp,DLT_DAEMON_RCVBUFSIZE) == DLT_RETURN_ERROR) - { - dlt_log(LOG_ERR,"Could not initialize receiver\n"); - return -1; - } - if (dlt_receiver_init(&(daemon_local->receiverSock),daemon_local->sock,DLT_DAEMON_RCVBUFSIZESOCK) == DLT_RETURN_ERROR) - { - dlt_log(LOG_ERR,"Could not initialize receiver for socket\n"); - return -1; - } - if (dlt_receiver_init(&(daemon_local->receiverCtrlSock), - daemon_local->ctrlsock, DLT_DAEMON_RCVBUFSIZESOCK)==-1) - { - dlt_log(LOG_ERR,"Could not initialize receiver for control socket\n"); - return -1; - } - if (daemon_local->flags.yvalue[0]) - { - if (dlt_receiver_init(&(daemon_local->receiverSerial),daemon_local->fdserial,DLT_DAEMON_RCVBUFSIZESERIAL) == DLT_RETURN_ERROR) - { - dlt_log(LOG_ERR,"Could not initialize receiver for serial connection\n"); - return -1; - } - } - /* configure sending timing packets */ if (daemon_local->flags.sendMessageTime) { @@ -934,17 +896,16 @@ int dlt_daemon_local_init_p2(DltDaemon *daemon, DltDaemonLocal *daemon_local, in static int dlt_daemon_init_serial(DltDaemonLocal *daemon_local) { - if (!daemon_local->flags.yvalue[0]) - { - /* Nothing to do here. */ - daemon_local->fdserial = -1; + /* create and open serial connection from/to client */ + /* open serial connection */ + int fd = -1; + + if (daemon_local->flags.yvalue[0] == '\0') { return 0; } - /* create and open serial connection from/to client */ - /* open serial connection */ - daemon_local->fdserial = open(daemon_local->flags.yvalue, O_RDWR); - if (daemon_local->fdserial < 0) + fd = open(daemon_local->flags.yvalue, O_RDWR); + if (fd < 0) { snprintf(str, DLT_DAEMON_TEXTBUFSIZE, @@ -956,7 +917,7 @@ static int dlt_daemon_init_serial(DltDaemonLocal *daemon_local) return -1; } - if (isatty(daemon_local->fdserial)) + if (isatty(fd)) { int speed = DLT_DAEMON_SERIAL_DEFAULT_BAUDRATE; @@ -967,10 +928,9 @@ static int dlt_daemon_init_serial(DltDaemonLocal *daemon_local) daemon_local->baudrate = dlt_convert_serial_speed(speed); - if (dlt_setup_serial(daemon_local->fdserial, - daemon_local->baudrate) < 0) + if (dlt_setup_serial(fd, daemon_local->baudrate) < 0) { - close(daemon_local->fdserial); + close(fd); daemon_local->flags.yvalue[0] = 0; snprintf(str, @@ -990,7 +950,7 @@ static int dlt_daemon_init_serial(DltDaemonLocal *daemon_local) } else { - close(daemon_local->fdserial); + close(fd); fprintf(stderr, "Device is not a serial device, device = %s (%s) \n", daemon_local->flags.yvalue, @@ -999,12 +959,17 @@ static int dlt_daemon_init_serial(DltDaemonLocal *daemon_local) return -1; } - return 0; + return dlt_connection_create(daemon_local, + &daemon_local->pEvent, + fd, + EPOLLIN, + DLT_CONNECTION_CLIENT_MSG_SERIAL); } static int dlt_daemon_init_fifo(DltDaemonLocal *daemon_local) { int ret; + int fd = -1; char local_str[DLT_DAEMON_TEXTBUFSIZE]; /* open named pipe(FIFO) to receive DLT messages from users */ @@ -1026,8 +991,8 @@ static int dlt_daemon_init_fifo(DltDaemonLocal *daemon_local) return -1; } /* if */ - daemon_local->fp = open(tmpFifo, O_RDWR); - if (daemon_local->fp == -1) + fd = open(tmpFifo, O_RDWR); + if (fd == -1) { snprintf(local_str, DLT_DAEMON_TEXTBUFSIZE, @@ -1044,7 +1009,7 @@ static int dlt_daemon_init_fifo(DltDaemonLocal *daemon_local) */ return dlt_connection_create(daemon_local, &daemon_local->pEvent, - daemon_local->fp, + fd, EPOLLIN, DLT_CONNECTION_APP_MSG); } @@ -1054,6 +1019,7 @@ int dlt_daemon_local_connection_init(DltDaemon *daemon, int verbose) { char local_str[DLT_DAEMON_TEXTBUFSIZE]; + int fd = -1; PRINT_FUNCTION_VERBOSE(verbose); if ((daemon == NULL) || (daemon_local == NULL)) @@ -1075,7 +1041,12 @@ int dlt_daemon_local_connection_init(DltDaemon *daemon, /* create and open socket to receive incoming connections from client */ daemon_local->client_connections = 0; - if(dlt_daemon_socket_open(&(daemon_local->sock),daemon_local->flags.port)) + if(dlt_daemon_socket_open(&fd, daemon_local->flags.port) || + dlt_connection_create(daemon_local, + &daemon_local->pEvent, + fd, + EPOLLIN, + DLT_CONNECTION_CLIENT_CONNECT)) { dlt_log(LOG_ERR,"Could not initialize main socket.\n"); return -1; @@ -1083,9 +1054,12 @@ int dlt_daemon_local_connection_init(DltDaemon *daemon, /* create and open unix socket to receive incoming connections from * control application */ - if (dlt_daemon_unix_socket_open( - &(daemon_local->ctrlsock), - daemon_local->flags.ctrlSockPath)) + if (dlt_daemon_unix_socket_open(&fd, daemon_local->flags.ctrlSockPath) || + dlt_connection_create(daemon_local, + &daemon_local->pEvent, + fd, + EPOLLIN, + DLT_CONNECTION_CONTROL_CONNECT)) { dlt_log(LOG_ERR, "Could not initialize control socket.\n"); return -1; @@ -1183,32 +1157,14 @@ void dlt_daemon_local_cleanup(DltDaemon *daemon, DltDaemonLocal *daemon_local, i return; } - /* Ignore result */ - dlt_receiver_free(&(daemon_local->receiver)); - /* Ignore result */ - dlt_receiver_free(&(daemon_local->receiverSock)); + /* Don't receive event anymore */ + dlt_event_handler_cleanup_connections(&daemon_local->pEvent); - /* Ignore result */ - dlt_receiver_free(&(daemon_local->receiverCtrlSock)); - /* Ignore result */ - if (daemon_local->flags.yvalue[0]) - { - /* Ignore result */ - dlt_receiver_free(&(daemon_local->receiverSerial)); - } - /* Ignore result */ dlt_message_free(&(daemon_local->msg),daemon_local->flags.vflag); - close(daemon_local->fp); /* free shared memory */ if(daemon_local->flags.offlineTraceDirectory[0]) dlt_offline_trace_free(&(daemon_local->offlineTrace)); -#if 0 - if (daemon_local->flags.ovalue[0]) - { - close(daemon_local->ohandle); - } /* if */ -#endif /* free ringbuffer */ dlt_buffer_free_dynamic(&(daemon->client_ringbuffer)); @@ -1242,10 +1198,8 @@ void dlt_daemon_local_cleanup(DltDaemon *daemon, DltDaemonLocal *daemon_local, i free(daemon->ECUVersionString); } - dlt_daemon_unix_socket_close(daemon_local->ctrlsock); unlink(daemon_local->flags.ctrlSockPath); - dlt_event_handler_cleanup_connections(&daemon_local->pEvent); } void dlt_daemon_signal_handler(int sig) @@ -1595,6 +1549,7 @@ int dlt_daemon_process_client_messages(DltDaemon *daemon, int verbose) { int bytes_to_be_removed=0; + int must_close_socket = -1; PRINT_FUNCTION_VERBOSE(verbose); @@ -1606,17 +1561,15 @@ int dlt_daemon_process_client_messages(DltDaemon *daemon, return -1; } - if (dlt_receiver_receive_socket(receiver) <= 0) + must_close_socket = dlt_receiver_receive_socket(receiver); + if (must_close_socket < 0) { dlt_daemon_close_socket(receiver->fd, daemon, daemon_local, verbose); receiver->fd = -1; - /* FIXME: Why the hell do we need to close the socket - * on control message reception ?? - */ - //return 0; + return -1; } /* Process all received messages */ @@ -1665,6 +1618,16 @@ int dlt_daemon_process_client_messages(DltDaemon *daemon, return -1; } + if (must_close_socket == 0) { + /* FIXME: Why the hell do we need to close the socket + * on control message reception ?? + */ + dlt_daemon_close_socket(receiver->fd, + daemon, + daemon_local, + verbose); + } + return 0; } @@ -1884,6 +1847,57 @@ int dlt_daemon_process_control_messages( return 0; } +static int dlt_daemon_process_user_message_not_sup(DltDaemon *daemon, + DltDaemonLocal *daemon_local, + DltReceiver *receiver, + int verbose) +{ + char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' }; + DltUserHeader *userheader = (DltUserHeader*) (receiver->buf); + (void)daemon; + (void)daemon_local; + + PRINT_FUNCTION_VERBOSE(verbose); + + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Invalid user message type received: %d!\n", + userheader->message); + dlt_log(LOG_ERR, local_str); + + /* remove user header */ + if (dlt_receiver_remove(receiver, sizeof(DltUserHeader)) == -1) + { + dlt_log(LOG_WARNING, + "Can't remove bytes from receiver for user messages\n"); + } + + return -1; +} + +static dlt_daemon_process_user_message_func process_user_func[DLT_USER_MESSAGE_NOT_SUPPORTED] = { + dlt_daemon_process_user_message_not_sup, + dlt_daemon_process_user_message_log, + dlt_daemon_process_user_message_register_application, + dlt_daemon_process_user_message_unregister_application, + dlt_daemon_process_user_message_register_context, + dlt_daemon_process_user_message_unregister_context, + dlt_daemon_process_user_message_not_sup, + dlt_daemon_process_user_message_not_sup, + dlt_daemon_process_user_message_overflow, + dlt_daemon_process_user_message_set_app_ll_ts, +#ifdef DLT_SHM_ENABLE + dlt_daemon_process_user_message_log_shm, +#else + dlt_daemon_process_user_message_not_sup, +#endif + dlt_daemon_process_user_message_not_sup, + dlt_daemon_process_user_message_not_sup, + dlt_daemon_process_user_message_marker, + dlt_daemon_process_user_message_not_sup, + dlt_daemon_process_user_message_not_sup +}; + int dlt_daemon_process_user_messages(DltDaemon *daemon, DltDaemonLocal *daemon_local, DltReceiver *receiver, @@ -1891,6 +1905,7 @@ int dlt_daemon_process_user_messages(DltDaemon *daemon, { int offset = 0; int run_loop = 1; + int32_t min_size = (int32_t)sizeof(DltUserHeader); DltUserHeader *userheader; PRINT_FUNCTION_VERBOSE(verbose); @@ -1912,31 +1927,23 @@ int dlt_daemon_process_user_messages(DltDaemon *daemon, } /* look through buffer as long as data is in there */ - do + while ((receiver->bytesRcvd > min_size) && run_loop) { - if (receiver->bytesRcvd < (int32_t)sizeof(DltUserHeader)) - { - break; - } + dlt_daemon_process_user_message_func func = NULL; - /* resync if necessary */ offset = 0; - do - { - userheader = (DltUserHeader*) (receiver->buf+offset); - - /* Check for user header pattern */ - if (dlt_user_check_userheader(userheader)) - { - break; - } + userheader = (DltUserHeader*) (receiver->buf + offset); + while (!dlt_user_check_userheader(userheader) && + (offset + min_size < receiver->bytesRcvd)) + /* resync if necessary */ + { + userheader = (DltUserHeader*) (receiver->buf + offset); offset++; - } while ((int32_t)(sizeof(DltUserHeader) + offset) <= - receiver->bytesRcvd); + } /* Check for user header pattern */ - if (dlt_user_check_userheader(userheader) == 0) + if (!dlt_user_check_userheader(userheader)) { break; } @@ -1944,147 +1951,27 @@ int dlt_daemon_process_user_messages(DltDaemon *daemon, /* Set new start offset */ if (offset > 0) { - receiver->buf += offset; - receiver->bytesRcvd -= offset; + dlt_receiver_remove(receiver, offset); } - switch (userheader->message) - { - case DLT_USER_MESSAGE_OVERFLOW: - { - if (dlt_daemon_process_user_message_overflow( - daemon, - daemon_local, - daemon_local->flags.vflag) == -1) - { - run_loop = 0; - } - break; - } - case DLT_USER_MESSAGE_REGISTER_CONTEXT: - { - if (dlt_daemon_process_user_message_register_context( - daemon, - daemon_local, - daemon_local->flags.vflag) == -1) - { - run_loop = 0; - } - break; - } - case DLT_USER_MESSAGE_UNREGISTER_CONTEXT: - { - if (dlt_daemon_process_user_message_unregister_context( - daemon, - daemon_local, - daemon_local->flags.vflag) == -1) - { - run_loop = 0; - } - break; - } - case DLT_USER_MESSAGE_LOG: - { - if (dlt_daemon_process_user_message_log( - daemon, - daemon_local, - daemon_local->flags.vflag) == -1) - { - run_loop = 0; - } - break; - } -#ifdef DLT_SHM_ENABLE - case DLT_USER_MESSAGE_LOG_SHM: - { - if (dlt_daemon_process_user_message_log_shm( - daemon, - daemon_local, - daemon_local->flags.vflag) == -1) - { - run_loop = 0; - } - break; - } -#endif - case DLT_USER_MESSAGE_REGISTER_APPLICATION: - { - if (dlt_daemon_process_user_message_register_application( - daemon, - daemon_local, - daemon_local->flags.vflag) == -1) - { - run_loop = 0; - } - break; - } - case DLT_USER_MESSAGE_UNREGISTER_APPLICATION: - { - if (dlt_daemon_process_user_message_unregister_application( - daemon, - daemon_local, - daemon_local->flags.vflag) == -1) - { - run_loop = 0; - } - break; - } - case DLT_USER_MESSAGE_APP_LL_TS: - { - if (dlt_daemon_process_user_message_set_app_ll_ts( - daemon, - daemon_local, - daemon_local->flags.vflag) == -1) - { - run_loop = 0; - } - break; - } - case DLT_USER_MESSAGE_LOG_MODE: + + if (userheader->message >= DLT_USER_MESSAGE_NOT_SUPPORTED) { - if (dlt_daemon_process_user_message_log_mode(daemon, daemon_local, daemon_local->flags.vflag)==-1) - { - run_loop=0; - } - break; + func = dlt_daemon_process_user_message_not_sup; } - case DLT_USER_MESSAGE_MARKER: + else { - if (dlt_daemon_process_user_message_marker( - daemon, - daemon_local, - daemon_local->flags.vflag) == -1) - { - run_loop = 0; - } - break; + func = process_user_func[userheader->message]; } - default: - { - snprintf(str, - DLT_DAEMON_TEXTBUFSIZE, - "Invalid user message type received: %d!\n", - userheader->message); - dlt_log(LOG_ERR,str); - - /* remove user header */ - if (dlt_receiver_remove(receiver, sizeof(DltUserHeader)) == -1) - { - dlt_log(LOG_WARNING, - "Can't remove bytes from receiver for user messages\n"); - return -1; - } - /* In next invocation of do-while loop, a resync will be triggered - * if additional data was received */ + if (func(daemon, + daemon_local, + receiver, + daemon_local->flags.vflag) == -1) + { run_loop = 0; - - break; - } } - } - while (run_loop); /* keep not read data in buffer */ if (dlt_receiver_move_to_begin(receiver) == -1) @@ -2098,42 +1985,46 @@ int dlt_daemon_process_user_messages(DltDaemon *daemon, return 0; } -int dlt_daemon_process_user_message_overflow(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose) +int dlt_daemon_process_user_message_overflow(DltDaemon *daemon, + DltDaemonLocal *daemon_local, + DltReceiver *rec, + int verbose) { - int ret; - DltUserControlMsgBufferOverflow *userpayload; + uint32_t len = sizeof(DltUserControlMsgBufferOverflow); + char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' }; + DltUserControlMsgBufferOverflow userpayload; PRINT_FUNCTION_VERBOSE(verbose); - if ((daemon==0) || (daemon_local==0)) + if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) { - dlt_log(LOG_WARNING, "Invalid function parameters used for function dlt_daemon_process_user_message_overflow()\n"); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Invalid function parameters used for %s\n", + __func__); + + dlt_log(LOG_ERR, local_str); return -1; } - if (daemon_local->receiver.bytesRcvd < (int32_t)(sizeof(DltUserHeader)+sizeof(DltUserControlMsgBufferOverflow))) + if (dlt_receiver_check_and_get(rec, &userpayload, len, 1) < 0) { /* Not enough bytes received */ return -1; } - /* get the payload of the user message */ - userpayload = (DltUserControlMsgBufferOverflow*) (daemon_local->receiver.buf+sizeof(DltUserHeader)); - /* Store in daemon, that a message buffer overflow has occured */ /* look if TCP connection to client is available or it least message can be put into buffer */ - if((ret=dlt_daemon_control_message_buffer_overflow(DLT_DAEMON_SEND_TO_ALL, daemon,daemon_local, userpayload->overflow_counter,userpayload->apid,verbose))) + if(dlt_daemon_control_message_buffer_overflow(DLT_DAEMON_SEND_TO_ALL, + daemon, + daemon_local, + userpayload.overflow_counter, + userpayload.apid, + verbose)) { /* there was an error when storing message */ /* add the counter of lost messages to the daemon counter */ - daemon->overflow_counter+=userpayload->overflow_counter; - } - - /* keep not read data in buffer */ - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgBufferOverflow)) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message overflow\n"); - return -1; + daemon->overflow_counter += userpayload.overflow_counter; } return 0; @@ -2159,180 +2050,212 @@ int dlt_daemon_send_message_overflow(DltDaemon *daemon, DltDaemonLocal *daemon_l return DLT_DAEMON_ERROR_OK; } -int dlt_daemon_process_user_message_register_application(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose) +int dlt_daemon_process_user_message_register_application(DltDaemon *daemon, + DltDaemonLocal *daemon_local, + DltReceiver *rec, + int verbose) { - uint32_t len=0; - DltDaemonApplication *application; - char description[DLT_DAEMON_DESCSIZE+1]; - DltUserControlMsgRegisterApplication *usercontext; + uint32_t len = sizeof(DltUserControlMsgRegisterApplication); + DltDaemonApplication *application = NULL; + char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' }; + char description[DLT_DAEMON_DESCSIZE + 1] = { '\0' }; + DltUserControlMsgRegisterApplication userapp; PRINT_FUNCTION_VERBOSE(verbose); - if ((daemon==0) || (daemon_local==0)) + if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) { - dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_process_user_message_register_application()\n"); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Invalid function parameters used for %s\n", + __func__); + + dlt_log(LOG_ERR, local_str); return -1; } - if (daemon_local->receiver.bytesRcvd < (int32_t)(sizeof(DltUserHeader)+sizeof(DltUserControlMsgRegisterApplication))) + if (dlt_receiver_check_and_get(rec, &userapp, len, 1) < 0) { /* Not enough bytes received */ return -1; } - usercontext = (DltUserControlMsgRegisterApplication*) (daemon_local->receiver.buf+sizeof(DltUserHeader)); + len = userapp.description_length; - memset(description,0,sizeof(description)); - - len=usercontext->description_length; - if ((len>0) && (len<=DLT_DAEMON_DESCSIZE)) + if ((len > DLT_DAEMON_DESCSIZE) || + (dlt_receiver_check_and_get(rec, description, len, 0) < 0)) { - /* Read and store application description */ - strncpy(description, (daemon_local->receiver.buf+sizeof(DltUserHeader)+sizeof(DltUserControlMsgRegisterApplication)), len); - description[sizeof(description)-1]=0; - + dlt_log(LOG_ERR, "Unable to get application description\n"); + return -1; } - application=dlt_daemon_application_add(daemon,usercontext->apid,usercontext->pid,description,verbose); + application = dlt_daemon_application_add(daemon, + userapp.apid, + userapp.pid, + description, + verbose); /* send log state to new application */ - dlt_daemon_user_send_log_state(daemon,application,verbose); + dlt_daemon_user_send_log_state(daemon, application, verbose); - /* keep not read data in buffer */ - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgRegisterApplication)+len) == DLT_RETURN_ERROR) + if (application == NULL) { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message register application\n"); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Can't add ApplicationID '%.4s' for PID %d\n", + userapp.apid, + userapp.pid); + dlt_log(LOG_WARNING,local_str); return -1; } - - if (application==0) - { - snprintf(str, DLT_DAEMON_TEXTBUFSIZE, "Can't add ApplicationID '%.4s' for PID %d\n", usercontext->apid, usercontext->pid); - dlt_log(LOG_WARNING,str); - return -1; - } else + else { - snprintf(str, DLT_DAEMON_TEXTBUFSIZE, "ApplicationID '%.4s' registered for PID %d, Description=%s\n", application->apid, application->pid, application->application_description); - dlt_daemon_log_internal(daemon, daemon_local, str, daemon_local->flags.vflag); - dlt_log(LOG_DEBUG,str); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "ApplicationID '%.4s' registered for PID %d, Description=%s\n", + application->apid, + application->pid, + application->application_description); + dlt_daemon_log_internal(daemon, + daemon_local, + local_str, + daemon_local->flags.vflag); + dlt_log(LOG_DEBUG, local_str); } return 0; } -int dlt_daemon_process_user_message_register_context(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose) +int dlt_daemon_process_user_message_register_context(DltDaemon *daemon, + DltDaemonLocal *daemon_local, + DltReceiver *rec, + int verbose) { - uint32_t len=0; - int8_t loglevel, tracestatus; - DltUserControlMsgRegisterContext *usercontext; - char description[DLT_DAEMON_DESCSIZE+1]; - DltDaemonApplication *application; - DltDaemonContext *context; - DltServiceGetLogInfoRequest *req; + char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' }; + uint32_t len = sizeof(DltUserControlMsgRegisterContext); + DltUserControlMsgRegisterContext userctxt; + char description[DLT_DAEMON_DESCSIZE + 1] = { '\0' }; + DltDaemonApplication *application = NULL; + DltDaemonContext *context = NULL; + DltServiceGetLogInfoRequest *req = NULL; DltMessage msg; PRINT_FUNCTION_VERBOSE(verbose); - if ((daemon==0) || (daemon_local==0)) + if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) { - dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_process_user_message_register_context()\n"); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Invalid function parameters used for %s\n", + __func__); + + dlt_log(LOG_ERR, local_str); return -1; } - if (daemon_local->receiver.bytesRcvd < (int32_t)(sizeof(DltUserHeader)+sizeof(DltUserControlMsgRegisterContext))) + memset(&userctxt, 0, len); + if (dlt_receiver_check_and_get(rec, &userctxt, len, 1) < 0) { /* Not enough bytes received */ return -1; } - usercontext = (DltUserControlMsgRegisterContext*) (daemon_local->receiver.buf+sizeof(DltUserHeader)); - - memset(description,0,sizeof(description)); + len = userctxt.description_length; - len=usercontext->description_length; - if ((len>0) && (len<=DLT_DAEMON_DESCSIZE)) + if ((len > DLT_DAEMON_DESCSIZE) || + (dlt_receiver_check_and_get(rec, description, len, 0) < 0)) { - /* Read and store context description */ - strncpy(description, (daemon_local->receiver.buf+sizeof(DltUserHeader)+sizeof(DltUserControlMsgRegisterContext)), len); - description[sizeof(description)-1]=0; + dlt_log(LOG_ERR, "Unable to get application description\n"); + return -1; } - application = dlt_daemon_application_find(daemon,usercontext->apid,verbose); + application = dlt_daemon_application_find(daemon, userctxt.apid, verbose); - if (application==0) + if (application == 0) { - snprintf(str, DLT_DAEMON_TEXTBUFSIZE, "ApplicationID '%.4s' not found while registering ContextID '%.4s' in dlt_daemon_process_user_message_register_context()\n", usercontext->apid, usercontext->ctid); - dlt_log(LOG_WARNING, str); - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgRegisterContext)+len) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message register context\n"); - return -1; - } + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "ApID '%.4s' not found for new ContextID '%.4s' in %s\n", + userctxt.apid, + userctxt.ctid, + __func__); + dlt_log(LOG_WARNING, local_str); + return 0; } - /* Pre-set loglevel */ - if (usercontext->log_level == DLT_USER_LOG_LEVEL_NOT_SET) + /* Set log level */ + if (userctxt.log_level == DLT_USER_LOG_LEVEL_NOT_SET) { - loglevel=DLT_LOG_DEFAULT; + userctxt.log_level = DLT_LOG_DEFAULT; } else { - loglevel=usercontext->log_level; /* Plausibility check */ - if ((loglevelDLT_LOG_VERBOSE)) + if ((userctxt.log_level < DLT_LOG_DEFAULT) || + (userctxt.log_level > DLT_LOG_VERBOSE)) { - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgRegisterContext)+len) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message register context\n"); - } return -1; } } - /* Pre-set tracestatus */ - if (usercontext->trace_status == DLT_USER_TRACE_STATUS_NOT_SET) + /* Set trace status */ + if (userctxt.trace_status == DLT_USER_TRACE_STATUS_NOT_SET) { - tracestatus=DLT_TRACE_STATUS_DEFAULT; + userctxt.trace_status = DLT_TRACE_STATUS_DEFAULT; } else { - tracestatus=usercontext->trace_status; - /* Plausibility check */ - if ((tracestatusDLT_TRACE_STATUS_ON)) + if ((userctxt.trace_status < DLT_TRACE_STATUS_DEFAULT) || + (userctxt.trace_status > DLT_TRACE_STATUS_ON)) { - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgRegisterContext)+len) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message register context\n"); - } return -1; } } - context = dlt_daemon_context_add(daemon,usercontext->apid,usercontext->ctid, loglevel, tracestatus, usercontext->log_level_pos,application->user_handle,description,verbose); + context = dlt_daemon_context_add(daemon, + userctxt.apid, + userctxt.ctid, + userctxt.log_level, + userctxt.trace_status, + userctxt.log_level_pos, + application->user_handle, + description, + verbose); if (context==0) { - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgRegisterContext)+len) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message register context\n"); - } - - snprintf(str, DLT_DAEMON_TEXTBUFSIZE, "Can't add ContextID '%.4s' for ApplicationID '%.4s'\n", usercontext->ctid, usercontext->apid); - dlt_log(LOG_WARNING,str); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Can't add ContextID '%.4s' for ApID '%.4s'\n in %s", + userctxt.ctid, + userctxt.apid, + __func__); + dlt_log(LOG_WARNING, local_str); return -1; - } else + } + else { - snprintf(str, DLT_DAEMON_TEXTBUFSIZE, "ContextID '%.4s' registered for ApplicationID '%.4s', Description=%s\n", context->ctid, context->apid, context->context_description); - dlt_daemon_log_internal(daemon, daemon_local, str, daemon_local->flags.vflag); - dlt_log(LOG_DEBUG,str); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "ContextID '%.4s' registered for ApID '%.4s', Description=%s\n", + context->ctid, + context->apid, + context->context_description); + dlt_daemon_log_internal(daemon, daemon_local, local_str, verbose); + dlt_log(LOG_DEBUG, local_str); } + if(daemon_local->flags.offlineLogstorageMaxDevices) { /* Store log level set for offline logstorage into context structure*/ - context->storage_log_level = dlt_daemon_logstorage_get_loglevel(daemon, daemon_local->flags.offlineLogstorageMaxDevices, usercontext->apid, usercontext->ctid); + context->storage_log_level = + dlt_daemon_logstorage_get_loglevel(daemon, + daemon_local->flags.offlineLogstorageMaxDevices, + userctxt.apid, + userctxt.ctid); } else { @@ -2342,13 +2265,8 @@ int dlt_daemon_process_user_message_register_context(DltDaemon *daemon, DltDaemo if (daemon_local->flags.rflag) { /* Prepare request for get log info with one application and one context */ - if (dlt_message_init(&msg, verbose) == DLT_RETURN_ERROR) + if (dlt_message_init(&msg, verbose)==-1) { - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgRegisterContext)+len) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message register context\n"); - return -1; - } dlt_log(LOG_WARNING,"Can't initialize message"); return -1; } @@ -2365,11 +2283,6 @@ int dlt_daemon_process_user_message_register_context(DltDaemon *daemon, DltDaemo } if (msg.databuffer==0) { - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgRegisterContext)+len) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message register context\n"); - return -1; - } dlt_log(LOG_WARNING,"Can't allocate buffer for get log info message\n"); return -1; } @@ -2378,8 +2291,8 @@ int dlt_daemon_process_user_message_register_context(DltDaemon *daemon, DltDaemo req->service_id = DLT_SERVICE_ID_GET_LOG_INFO; req->options = 7; - dlt_set_id(req->apid, usercontext->apid); - dlt_set_id(req->ctid, usercontext->ctid); + dlt_set_id(req->apid, userctxt.apid); + dlt_set_id(req->ctid, userctxt.ctid); dlt_set_id(req->com,"remo"); dlt_daemon_control_get_log_info(DLT_DAEMON_SEND_TO_ALL , daemon,daemon_local, &msg, verbose); @@ -2392,54 +2305,59 @@ int dlt_daemon_process_user_message_register_context(DltDaemon *daemon, DltDaemo /* This call also replaces the default values with the values defined for default */ if (dlt_daemon_user_send_log_level(daemon, context, verbose)==-1) { - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgRegisterContext)+len) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message register context\n"); - return -1; - } - snprintf(str, DLT_DAEMON_TEXTBUFSIZE, "Can't send current log level as response to user message register context for (%.4s;%.4s)\n", context->apid, context->ctid); - dlt_log(LOG_WARNING,str); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Can't send current log level as response to %s for (%.4s;%.4s)\n", + __func__, + context->apid, + context->ctid); + dlt_log(LOG_WARNING, local_str); return -1; } } - /* keep not read data in buffer */ - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgRegisterContext)+len) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message register context\n"); - return -1; - } - return 0; } -int dlt_daemon_process_user_message_unregister_application(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose) +int dlt_daemon_process_user_message_unregister_application(DltDaemon *daemon, + DltDaemonLocal *daemon_local, + DltReceiver *rec, + int verbose) { - DltUserControlMsgUnregisterApplication *usercontext; - DltDaemonApplication *application; + uint32_t len = sizeof(DltUserControlMsgUnregisterApplication); + DltUserControlMsgUnregisterApplication userapp; + char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' }; + DltDaemonApplication *application = NULL; DltDaemonContext *context; int i, offset_base; PRINT_FUNCTION_VERBOSE(verbose); - if ((daemon==0) || (daemon_local==0)) + if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) { - dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_process_user_message_unregister_application()\n"); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Invalid function parameters used for %s\n", + __func__); + + dlt_log(LOG_ERR, local_str); return -1; } - if (daemon_local->receiver.bytesRcvd < (int32_t)(sizeof(DltUserHeader)+sizeof(DltUserControlMsgUnregisterApplication))) + if (dlt_receiver_check_and_get(rec, &userapp, len, 1) < 0) { /* Not enough bytes received */ return -1; } - if (daemon->num_applications>0) + if (daemon->num_applications > 0) { - usercontext = (DltUserControlMsgUnregisterApplication*) (daemon_local->receiver.buf+sizeof(DltUserHeader)); - - /* Delete this application and all corresponding contexts for this application from internal table */ - application = dlt_daemon_application_find(daemon,usercontext->apid, verbose); + /* Delete this application and all corresponding contexts + * for this application from internal table. + */ + application = dlt_daemon_application_find(daemon, + userapp.apid, + verbose); if (application) { @@ -2456,15 +2374,15 @@ int dlt_daemon_process_user_message_unregister_application(DltDaemon *daemon, Dl if (context) { /* Delete context */ - if (dlt_daemon_context_del(daemon, context, verbose)==-1) + if (dlt_daemon_context_del(daemon, context, verbose) == -1) { - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgUnregisterApplication)) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message unregister application\n"); - return -1; - } - snprintf(str, DLT_DAEMON_TEXTBUFSIZE, "Can't delete ContextID '%.4s' in ApplicationID '%.4s' for user message unregister application\n", context->ctid, context->apid); - dlt_log(LOG_WARNING,str); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Can't delete CtID '%.4s' for ApID '%.4s' in %s\n", + context->ctid, + context->apid, + __func__); + dlt_log(LOG_WARNING, local_str); return -1; } } @@ -2473,93 +2391,114 @@ int dlt_daemon_process_user_message_unregister_application(DltDaemon *daemon, Dl /* Delete this application entry from internal table*/ if (dlt_daemon_application_del(daemon, application, verbose)==-1) { - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgUnregisterApplication)) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message unregister application\n"); - return -1; - } - snprintf(str, DLT_DAEMON_TEXTBUFSIZE, "Can't delete ApplicationID '%.4s' for user message unregister application\n", application->apid); - dlt_log(LOG_WARNING,str); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Can't delete ApID '%.4s' in %s\n", + application->apid, + __func__); + dlt_log(LOG_WARNING, local_str); return -1; - } else + } + else { - snprintf(str, DLT_DAEMON_TEXTBUFSIZE, "Unregistered ApplicationID '%.4s'\n", usercontext->apid); - dlt_daemon_log_internal(daemon, daemon_local, str, daemon_local->flags.vflag); - dlt_log(LOG_DEBUG,str); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Unregistered ApID '%.4s'\n", + userapp.apid); + dlt_daemon_log_internal(daemon, + daemon_local, + local_str, + verbose); + dlt_log(LOG_DEBUG, local_str); } } } - /* keep not read data in buffer */ - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgUnregisterApplication)) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message unregister application\n"); - return -1; - } - return 0; } -int dlt_daemon_process_user_message_unregister_context(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose) +int dlt_daemon_process_user_message_unregister_context(DltDaemon *daemon, + DltDaemonLocal *daemon_local, + DltReceiver *rec, + int verbose) { - DltUserControlMsgUnregisterContext *usercontext; + char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' }; + uint32_t len = sizeof(DltUserControlMsgUnregisterContext); + DltUserControlMsgUnregisterContext userctxt; DltDaemonContext *context; PRINT_FUNCTION_VERBOSE(verbose); - if ((daemon==0) || (daemon_local==0)) + if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) { - dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_process_user_message_unregister_context()\n"); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Invalid function parameters used for %s\n", + __func__); + + dlt_log(LOG_ERR, local_str); return -1; } - if (daemon_local->receiver.bytesRcvd < (int32_t)(sizeof(DltUserHeader)+sizeof(DltUserControlMsgUnregisterContext))) + if (dlt_receiver_check_and_get(rec, &userctxt, len, 1) < 0) { /* Not enough bytes received */ return -1; } - usercontext = (DltUserControlMsgUnregisterContext*) (daemon_local->receiver.buf+sizeof(DltUserHeader)); - context = dlt_daemon_context_find(daemon,usercontext->apid, usercontext->ctid, verbose); + context = dlt_daemon_context_find(daemon, + userctxt.apid, + userctxt.ctid, + verbose); if (context) { /* Delete this connection entry from internal table*/ if (dlt_daemon_context_del(daemon, context, verbose)==-1) { - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgUnregisterContext)) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message unregister context\n"); - return -1; - } - snprintf(str, DLT_DAEMON_TEXTBUFSIZE, "Can't delete ContextID '%.4s' for ApplicationID '%.4s' for user message unregister context\n", usercontext->ctid, usercontext->apid); - dlt_log(LOG_WARNING,str); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Can't delete CtID '%.4s' for ApID '%.4s' in %s\n", + userctxt.ctid, + userctxt.apid, + __func__); + dlt_log(LOG_WARNING, local_str); return -1; - } else + } + else { - snprintf(str, DLT_DAEMON_TEXTBUFSIZE, "Unregistered ContextID '%.4s' for ApplicationID '%.4s'\n", usercontext->ctid, usercontext->apid); - dlt_daemon_log_internal(daemon, daemon_local, str, daemon_local->flags.vflag); - dlt_log(LOG_DEBUG,str); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Unregistered CtID '%.4s' for ApID '%.4s'\n", + userctxt.ctid, + userctxt.apid); + dlt_daemon_log_internal(daemon, + daemon_local, + local_str, + verbose); + dlt_log(LOG_DEBUG, local_str); } } /* Create automatic unregister context response for unregistered context */ if (daemon_local->flags.rflag) { - dlt_daemon_control_message_unregister_context(DLT_DAEMON_SEND_TO_ALL,daemon,daemon_local,usercontext->apid, usercontext->ctid, "remo",verbose); - } - - /* keep not read data in buffer */ - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgUnregisterContext)) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message unregister context\n"); - return -1; + dlt_daemon_control_message_unregister_context(DLT_DAEMON_SEND_TO_ALL, + daemon, + daemon_local, + userctxt.apid, + userctxt.ctid, + "remo", + verbose); } return 0; } -int dlt_daemon_process_user_message_log(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose) +int dlt_daemon_process_user_message_log(DltDaemon *daemon, + DltDaemonLocal *daemon_local, + DltReceiver *rec, + int verbose) { int ret; int bytes_to_be_removed; @@ -2568,13 +2507,17 @@ int dlt_daemon_process_user_message_log(DltDaemon *daemon, DltDaemonLocal *daemo PRINT_FUNCTION_VERBOSE(verbose); - if ((daemon==0) || (daemon_local==0)) + if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) { dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_process_user_message_log()\n"); - return DLT_DAEMON_ERROR_UNKNOWN; + return -DLT_DAEMON_ERROR_UNKNOWN; } - ret=dlt_message_read(&(daemon_local->msg),(unsigned char*)daemon_local->receiver.buf+sizeof(DltUserHeader),daemon_local->receiver.bytesRcvd-sizeof(DltUserHeader),0,verbose); + ret = dlt_message_read(&(daemon_local->msg), + (unsigned char*)rec->buf + sizeof(DltUserHeader), + rec->bytesRcvd - sizeof(DltUserHeader), + 0, + verbose); if(ret!=DLT_MESSAGE_ERROR_OK) { if(ret!=DLT_MESSAGE_ERROR_SIZE) @@ -2588,7 +2531,7 @@ int dlt_daemon_process_user_message_log(DltDaemon *daemon, DltDaemonLocal *daemo or the headers are corrupted (error case). */ dlt_log(LOG_DEBUG,"Can't read messages from receiver\n"); } - return DLT_DAEMON_ERROR_UNKNOWN; + return -DLT_DAEMON_ERROR_UNKNOWN; } /* set overwrite ecu id */ @@ -2600,7 +2543,7 @@ int dlt_daemon_process_user_message_log(DltDaemon *daemon, DltDaemonLocal *daemo if (dlt_message_set_extraparameters(&(daemon_local->msg),0) == DLT_RETURN_ERROR) { dlt_log(LOG_WARNING,"Can't set message extra parameters in process user message log\n"); - return DLT_DAEMON_ERROR_UNKNOWN; + return -DLT_DAEMON_ERROR_UNKNOWN; } /* Correct value of timestamp, this was changed by dlt_message_set_extraparameters() */ @@ -2613,7 +2556,7 @@ int dlt_daemon_process_user_message_log(DltDaemon *daemon, DltDaemonLocal *daemo if (dlt_set_storageheader(daemon_local->msg.storageheader,daemon_local->msg.headerextra.ecu) == DLT_RETURN_ERROR) { dlt_log(LOG_WARNING,"Can't set storage header in process user message log\n"); - return DLT_DAEMON_ERROR_UNKNOWN; + return -DLT_DAEMON_ERROR_UNKNOWN; } } else @@ -2621,7 +2564,7 @@ int dlt_daemon_process_user_message_log(DltDaemon *daemon, DltDaemonLocal *daemo if (dlt_set_storageheader(daemon_local->msg.storageheader,daemon->ecuid) == DLT_RETURN_ERROR) { dlt_log(LOG_WARNING,"Can't set storage header in process user message log\n"); - return DLT_DAEMON_ERROR_UNKNOWN; + return -DLT_DAEMON_ERROR_UNKNOWN; } } @@ -2680,136 +2623,160 @@ int dlt_daemon_process_user_message_log(DltDaemon *daemon, DltDaemonLocal *daemo bytes_to_be_removed += sizeof(dltSerialHeader); } - if (dlt_receiver_remove(&(daemon_local->receiver),bytes_to_be_removed) == DLT_RETURN_ERROR) + if (dlt_receiver_remove(rec, bytes_to_be_removed) == -1) { dlt_log(LOG_WARNING,"Can't remove bytes from receiver\n"); - return DLT_DAEMON_ERROR_UNKNOWN; + return -DLT_DAEMON_ERROR_UNKNOWN; } return DLT_DAEMON_ERROR_OK; } #ifdef DLT_SHM_ENABLE -int dlt_daemon_process_user_message_log_shm(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose) +#define DLT_SHM_RCV_BUFFER_SIZE 10000 +int dlt_daemon_process_user_message_log_shm(DltDaemon *daemon, + DltDaemonLocal *daemon_local, + DltReceiver *rec, + int verbose) { - int bytes_to_be_removed=0; + char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' }; int j,sent,third_value; ssize_t ret; - uint8_t rcv_buffer[10000]; + uint8_t *rcv_buffer = NULL; int size; - DltUserHeader *userheader; + uint32_t len = sizeof(DltUserHeader); + DltUserHeader userheader; static char text[DLT_DAEMON_TEXTSIZE]; PRINT_FUNCTION_VERBOSE(verbose); - if ((daemon==0) || (daemon_local==0)) + if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) { - dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_process_user_message_log()\n"); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Invalid function parameters used for %s\n", + __func__); + + dlt_log(LOG_ERR, local_str); return -1; } - userheader = (DltUserHeader*) (daemon_local->receiver.buf); + rcv_buffer = calloc(1, DLT_SHM_RCV_BUFFER_SIZE); - //dlt_shm_status(&(daemon_local->dlt_shm)); - while (1) + if (!rcv_buffer) { - /* log message in SHM */ - if((size = dlt_shm_copy(&(daemon_local->dlt_shm),rcv_buffer,10000)) <= 0) - break; - if (dlt_message_read(&(daemon_local->msg),rcv_buffer,size,0,verbose)!=0) { - break; - dlt_log(LOG_WARNING,"Can't read messages from shm\n"); - return -1; - } - bytes_to_be_removed = daemon_local->msg.headersize+daemon_local->msg.datasize-sizeof(DltStorageHeader)+sizeof(DltUserHeader); - if (daemon_local->msg.found_serialheader) - { - bytes_to_be_removed += sizeof(dltSerialHeader); - } - - /* set overwrite ecu id */ - if (daemon_local->flags.evalue[0]) - { - /* Set header extra parameters */ - dlt_set_id(daemon_local->msg.headerextra.ecu, daemon->ecuid ); - //msg.headerextra.seid = 0; - if (dlt_message_set_extraparameters(&(daemon_local->msg),0)==-1) - { - dlt_log(LOG_WARNING,"Can't set message extra parameters in process user message log\n"); - dlt_shm_remove(&(daemon_local->dlt_shm)); - return -1; - } + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "No memory to allocate receiver buffer in %s.\n", + __func__); - /* Correct value of timestamp, this was changed by dlt_message_set_extraparameters() */ - daemon_local->msg.headerextra.tmsp = DLT_BETOH_32(daemon_local->msg.headerextra.tmsp); - } + dlt_log(LOG_ERR, local_str); - /* prepare storage header */ - if (DLT_IS_HTYP_WEID(daemon_local->msg.standardheader->htyp)) - { - if (dlt_set_storageheader(daemon_local->msg.storageheader,daemon_local->msg.headerextra.ecu)==-1) - { - dlt_log(LOG_WARNING,"Can't set storage header in process user message log\n"); - dlt_shm_remove(&(daemon_local->dlt_shm)); - return -1; - } - } - else - { - if (dlt_set_storageheader(daemon_local->msg.storageheader,daemon->ecuid)==-1) - { - dlt_log(LOG_WARNING,"Can't set storage header in process user message log\n"); - dlt_shm_remove(&(daemon_local->dlt_shm)); - return -1; - } - } + return -1; + } - /* display message */ - if (daemon_local->flags.xflag) - { - if (dlt_message_print_hex(&(daemon_local->msg),text,DLT_DAEMON_TEXTSIZE,verbose)==-1) - { - dlt_log(LOG_WARNING,"dlt_message_print_hex() failed!\n"); - } - } /* if */ - else if (daemon_local->flags.aflag) - { - if (dlt_message_print_ascii(&(daemon_local->msg),text,DLT_DAEMON_TEXTSIZE,verbose)==-1) - { - dlt_log(LOG_WARNING,"dlt_message_print_ascii() failed!\n"); - } - } /* if */ - else if (daemon_local->flags.sflag) - { - if (dlt_message_print_header(&(daemon_local->msg),text,DLT_DAEMON_TEXTSIZE,verbose)==-1) - { - dlt_log(LOG_WARNING,"dlt_message_print_header() failed!\n"); - } - /* print message header only */ - } /* if */ + memset(&userheader, 0, len); - sent=0; + if (dlt_receiver_check_and_get(rec, &userheader, len, 0) < 0) + { + /* Not enough bytes received */ + return -1; + } - /* write message to offline trace */ - if(((daemon->mode == DLT_USER_MODE_INTERNAL) || (daemon->mode == DLT_USER_MODE_BOTH)) && daemon_local->flags.offlineTraceDirectory[0]) - { - dlt_offline_trace_write(&(daemon_local->offlineTrace),daemon_local->msg.headerbuffer,daemon_local->msg.headersize, - daemon_local->msg.databuffer,daemon_local->msg.datasize,0,0); - sent = 1; - } + //dlt_shm_status(&(daemon_local->dlt_shm)); + while (1) + { + /* log message in SHM */ + size = dlt_shm_copy(&(daemon_local->dlt_shm), + rcv_buffer, + DLT_SHM_RCV_BUFFER_SIZE); + if(size <= 0) + break; - /* look if TCP connection to client is available */ - if((daemon->mode == DLT_USER_MODE_EXTERNAL) || - (daemon->mode == DLT_USER_MODE_BOTH)) - { - sent = dlt_daemon_client_send_all(daemon, daemon_local, verbose); - } + if (dlt_message_read(&(daemon_local->msg),rcv_buffer,size,0,verbose)!=0) { + break; + dlt_log(LOG_WARNING,"Can't read messages from shm\n"); + return -1; + } + + /* set overwrite ecu id */ + if (daemon_local->flags.evalue[0]) + { + /* Set header extra parameters */ + dlt_set_id(daemon_local->msg.headerextra.ecu, daemon->ecuid ); + //msg.headerextra.seid = 0; + if (dlt_message_set_extraparameters(&(daemon_local->msg),0)==-1) + { + dlt_log(LOG_WARNING,"Can't set message extra parameters in process user message log\n"); + dlt_shm_remove(&(daemon_local->dlt_shm)); + return -1; + } + + /* Correct value of timestamp, this was changed by dlt_message_set_extraparameters() */ + daemon_local->msg.headerextra.tmsp = DLT_BETOH_32(daemon_local->msg.headerextra.tmsp); + } + + /* prepare storage header */ + if (DLT_IS_HTYP_WEID(daemon_local->msg.standardheader->htyp)) + { + if (dlt_set_storageheader(daemon_local->msg.storageheader,daemon_local->msg.headerextra.ecu)==-1) + { + dlt_log(LOG_WARNING,"Can't set storage header in process user message log\n"); + dlt_shm_remove(&(daemon_local->dlt_shm)); + return -1; + } + } + else + { + if (dlt_set_storageheader(daemon_local->msg.storageheader,daemon->ecuid)==-1) + { + dlt_log(LOG_WARNING,"Can't set storage header in process user message log\n"); + dlt_shm_remove(&(daemon_local->dlt_shm)); + return -1; + } + } + + /* display message */ + if (daemon_local->flags.xflag) + { + if (dlt_message_print_hex(&(daemon_local->msg),text,DLT_DAEMON_TEXTSIZE,verbose)==-1) + { + dlt_log(LOG_WARNING,"dlt_message_print_hex() failed!\n"); + } + } /* if */ + else if (daemon_local->flags.aflag) + { + if (dlt_message_print_ascii(&(daemon_local->msg),text,DLT_DAEMON_TEXTSIZE,verbose)==-1) + { + dlt_log(LOG_WARNING,"dlt_message_print_ascii() failed!\n"); + } + } /* if */ + else if (daemon_local->flags.sflag) + { + if (dlt_message_print_header(&(daemon_local->msg),text,DLT_DAEMON_TEXTSIZE,verbose)==-1) + { + dlt_log(LOG_WARNING,"dlt_message_print_header() failed!\n"); + } + /* print message header only */ + } /* if */ + + sent=0; + + /* write message to offline trace */ + if(daemon_local->flags.offlineTraceDirectory[0]) + { + dlt_offline_trace_write(&(daemon_local->offlineTrace),daemon_local->msg.headerbuffer,daemon_local->msg.headersize, + daemon_local->msg.databuffer,daemon_local->msg.datasize,0,0); + sent = 1; + } + + sent = dlt_daemon_client_send_all(daemon, daemon_local, verbose); /* Message was not sent to client, so store it in client ringbuffer */ - if (sent==1 || (daemon->mode == DLT_USER_MODE_OFF)) + if (sent == 1) { - if(userheader->message == DLT_USER_MESSAGE_LOG_SHM) { + if(userheader.message == DLT_USER_MESSAGE_LOG_SHM) { /* dlt message was sent, remove from buffer if log message from shm */ dlt_shm_remove(&(daemon_local->dlt_shm)); } @@ -2819,23 +2786,21 @@ int dlt_daemon_process_user_message_log_shm(DltDaemon *daemon, DltDaemonLocal *d /* dlt message was not sent, keep in buffer */ break; } - - } - - /* keep not read data in buffer */ - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader))==-1) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message overflow\n"); - return -1; } return 0; } +#undef DLT_SHM_RCV_BUFFER_SIZE #endif -int dlt_daemon_process_user_message_set_app_ll_ts(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose) +int dlt_daemon_process_user_message_set_app_ll_ts(DltDaemon *daemon, + DltDaemonLocal *daemon_local, + DltReceiver *rec, + int verbose) { - DltUserControlMsgAppLogLevelTraceStatus *usercontext; + char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' }; + uint32_t len = sizeof(DltUserControlMsgAppLogLevelTraceStatus); + DltUserControlMsgAppLogLevelTraceStatus userctxt; DltDaemonApplication *application; DltDaemonContext *context; int i, offset_base; @@ -2843,24 +2808,30 @@ int dlt_daemon_process_user_message_set_app_ll_ts(DltDaemon *daemon, DltDaemonLo PRINT_FUNCTION_VERBOSE(verbose); - if ((daemon==0) || (daemon_local==0)) + if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) { - dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_process_user_message_set_app_ll_ts()\n"); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Invalid function parameters used for %s\n", + __func__); + + dlt_log(LOG_ERR, local_str); return -1; } - if (daemon_local->receiver.bytesRcvd < (int32_t)(sizeof(DltUserHeader)+sizeof(DltUserControlMsgAppLogLevelTraceStatus ))) + memset(&userctxt, 0, len); + if (dlt_receiver_check_and_get(rec, &userctxt, len, 1) < 0) { - /* Not enough bytes receeived */ + /* Not enough bytes received */ return -1; } if (daemon->num_applications>0) { - usercontext = (DltUserControlMsgAppLogLevelTraceStatus*) (daemon_local->receiver.buf+sizeof(DltUserHeader)); - /* Get all contexts with application id matching the received application id */ - application = dlt_daemon_application_find(daemon, usercontext->apid, verbose); + application = dlt_daemon_application_find(daemon, + userctxt.apid, + verbose); if (application) { /* Calculate start offset within contexts[] */ @@ -2876,10 +2847,10 @@ int dlt_daemon_process_user_message_set_app_ll_ts(DltDaemon *daemon, DltDaemonLo if (context) { old_log_level = context->log_level; - context->log_level = usercontext->log_level; /* No endianess conversion necessary*/ + context->log_level = userctxt.log_level; /* No endianess conversion necessary*/ old_trace_status = context->trace_status; - context->trace_status = usercontext->trace_status; /* No endianess conversion necessary */ + context->trace_status = userctxt.trace_status; /* No endianess conversion necessary */ /* The folowing function sends also the trace status */ if (context->user_handle >= DLT_FD_MINIMUM && dlt_daemon_user_send_log_level(daemon, context, verbose)!=0) @@ -2892,19 +2863,16 @@ int dlt_daemon_process_user_message_set_app_ll_ts(DltDaemon *daemon, DltDaemonLo } } - /* keep not read data in buffer */ - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgAppLogLevelTraceStatus)) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver\n"); - return -1; - } - return 0; } -int dlt_daemon_process_user_message_log_mode(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose) +int dlt_daemon_process_user_message_log_mode(DltDaemon *daemon, + DltDaemonLocal *daemon_local, + DltReceiver *rec, + int verbose) { - DltUserControlMsgLogMode *logmode; + DltUserControlMsgLogMode userctxt; + uint32_t len = sizeof(DltUserControlMsgLogMode); PRINT_FUNCTION_VERBOSE(verbose); @@ -2914,41 +2882,45 @@ int dlt_daemon_process_user_message_log_mode(DltDaemon *daemon, DltDaemonLocal * return -1; } - if (daemon_local->receiver.bytesRcvd < (int32_t)(sizeof(DltUserHeader)+sizeof(DltUserControlMsgLogMode))) + memset(&userctxt, 0, len); + if (dlt_receiver_check_and_get(rec, &userctxt, len, 1) < 0) { /* Not enough bytes received */ return -1; } - logmode = (DltUserControlMsgLogMode*) (daemon_local->receiver.buf+sizeof(DltUserHeader)); - /* set the new log mode */ - daemon->mode = logmode->log_mode; + daemon->mode = userctxt.log_mode; /* write configuration persistantly */ dlt_daemon_configuration_save(daemon, daemon->runtime_configuration, verbose); - /* keep not read data in buffer */ - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgLogMode)) == DLT_RETURN_ERROR) - { - dlt_log(LOG_WARNING,"Can't remove bytes from receiver for user message log mode\n"); - return -1; - } - return 0; } -int dlt_daemon_process_user_message_marker(DltDaemon *daemon, DltDaemonLocal *daemon_local, int verbose) +int dlt_daemon_process_user_message_marker(DltDaemon *daemon, + DltDaemonLocal *daemon_local, + DltReceiver *rec, + int verbose) { + char local_str[DLT_DAEMON_TEXTBUFSIZE] = { '\0' }; + uint32_t len = sizeof(DltUserControlMsgLogMode); + DltUserControlMsgLogMode userctxt; PRINT_FUNCTION_VERBOSE(verbose); - if ((daemon==0) || (daemon_local==0)) + if ((daemon == NULL) || (daemon_local == NULL) || (rec == NULL)) { - dlt_log(LOG_ERR, "Invalid function parameters used for function dlt_daemon_process_user_message_marker()\n"); + snprintf(local_str, + DLT_DAEMON_TEXTBUFSIZE, + "Invalid function parameters used for %s\n", + __func__); + + dlt_log(LOG_ERR, local_str); return -1; } - if (daemon_local->receiver.bytesRcvd < (int32_t)(sizeof(DltUserHeader))) + memset(&userctxt, 0, len); + if (dlt_receiver_check_and_get(rec, &userctxt, len, 1) < 0) { /* Not enough bytes received */ return -1; @@ -2957,13 +2929,6 @@ int dlt_daemon_process_user_message_marker(DltDaemon *daemon, DltDaemonLocal *da /* Create automatic unregister context response for unregistered context */ dlt_daemon_control_message_marker(DLT_DAEMON_SEND_TO_ALL,daemon,daemon_local,verbose); - /* keep not read data in buffer */ - if (dlt_receiver_remove(&(daemon_local->receiver),sizeof(DltUserHeader)+sizeof(DltUserControlMsgLogMode)) == DLT_RETURN_ERROR) - { - dlt_log(LOG_ERR,"Can't remove bytes from receiver for user message log mode\n"); - return -1; - } - return 0; } @@ -3028,49 +2993,58 @@ int dlt_daemon_send_ringbuffer_to_client(DltDaemon *daemon, DltDaemonLocal *daem return DLT_DAEMON_ERROR_OK; } +static char dlt_timer_conn_types[DLT_TIMER_UNKNOWN + 1] = { + [DLT_TIMER_PACKET] = DLT_CONNECTION_ONE_S_TIMER, + [DLT_TIMER_ECU] = DLT_CONNECTION_SIXTY_S_TIMER, +#ifdef DLT_SYSTEMD_WATCHDOG_ENABLE + [DLT_TIMER_SYSTEMD] = DLT_CONNECTION_SYSTEMD_TIMER, +#endif + [DLT_TIMER_GATEWAY] = DLT_CONNECTION_GATEWAY_TIMER, + [DLT_TIMER_UNKNOWN] = DLT_CONNECTION_TYPE_MAX +}; + static char dlt_timer_names[DLT_TIMER_UNKNOWN + 1][32] = { [DLT_TIMER_PACKET] = "Timing packet", [DLT_TIMER_ECU] = "ECU version", #ifdef DLT_SYSTEMD_WATCHDOG_ENABLE [DLT_TIMER_SYSTEMD] = "Systemd watchdog", #endif + [DLT_TIMER_GATEWAY] = "Gateway", [DLT_TIMER_UNKNOWN] = "Unknown timer" }; int create_timer_fd(DltDaemonLocal *daemon_local, int period_sec, int starts_in, - int* fd, DltTimers timer_id) { int local_fd = -1; struct itimerspec l_timer_spec; - char *timer_name = dlt_timer_names[timer_id]; + char *timer_name = NULL; - if(timer_name == NULL) - { - timer_name = "timer_not_named"; + if (timer_id >= DLT_TIMER_UNKNOWN) { + dlt_log(DLT_LOG_ERROR, "Unknown timer."); + return -1; } + timer_name = dlt_timer_names[timer_id]; + if(daemon_local == NULL) { dlt_log(DLT_LOG_ERROR, "Daemaon local structure is NULL"); return -1; } - if( fd == NULL ) - { - snprintf(str, sizeof(str), "<%s> fd is NULL pointer\n", timer_name ); - dlt_log(LOG_WARNING, str); - return -1; - } - - if( period_sec > 0 ) { + if(period_sec > 0) { #ifdef linux local_fd = timerfd_create(CLOCK_MONOTONIC, 0); if( local_fd < 0) { - snprintf(str, sizeof(str), "<%s> timerfd_create failed: %s\n", timer_name, strerror(errno)); + snprintf(str, + sizeof(str), + "<%s> timerfd_create failed: %s\n", + timer_name, + strerror(errno)); dlt_log(LOG_WARNING, str); } @@ -3079,9 +3053,13 @@ int create_timer_fd(DltDaemonLocal *daemon_local, l_timer_spec.it_value.tv_sec = starts_in; l_timer_spec.it_value.tv_nsec = 0; - if( timerfd_settime( local_fd, 0, &l_timer_spec, NULL) < 0) + if( timerfd_settime(local_fd, 0, &l_timer_spec, NULL) < 0) { - snprintf(str, sizeof(str), "<%s> timerfd_settime failed: %s\n", timer_name, strerror(errno)); + snprintf(str, + sizeof(str), + "<%s> timerfd_settime failed: %s\n", + timer_name, + strerror(errno)); dlt_log(LOG_WARNING, str); local_fd = -1; } @@ -3107,9 +3085,11 @@ int create_timer_fd(DltDaemonLocal *daemon_local, dlt_log(LOG_INFO, str); } - *fd = local_fd; - - return local_fd; + return dlt_connection_create(daemon_local, + &daemon_local->pEvent, + local_fd, + EPOLLIN, + dlt_timer_conn_types[timer_id]); } /* Close connection function */ -- cgit v1.2.1