library: fix conversion warnings

- Change the data type of variable 'size' in DltContextData struct
  (dlt_user.h.in). Variable 'size' was used repeated with function
  'sizeof()' many time, so change type to 'size_t' can avoid a lot of
  warnings.

- Adding temporary variable to calculate the datasize header (define in
  dlt_common.h) in 'dlt_common.c' file.

Signed-off-by: Dinh Cong Toan(RBVH/ECM12) <Toan.DinhCong@vn.bosch.com>

6 files changed, 130 insertions, 106 deletions

diff --git a/include/dlt/dlt_user.h.in b/include/dlt/dlt_user.h.in
index d0c60b2..e4b2c5a 100644
--- a/include/dlt/dlt_user.h.in
+++ b/include/dlt/dlt_user.h.in
@@ -129,7 +129,7 @@ typedef struct
 {
     DltContext *handle;                           /**< pointer to DltContext */
     unsigned char *buffer;                        /**< buffer for building log message*/
-    int32_t size;                                 /**< payload size */
+    size_t size;                                 /**< payload size */
     int32_t log_level;                            /**< log level */
     int32_t trace_status;                         /**< trace status */
     int32_t args_num;                             /**< number of arguments for extended header*/
diff --git a/src/lib/dlt_client.c b/src/lib/dlt_client.c
index 736fd70..0702f5f 100644
--- a/src/lib/dlt_client.c
+++ b/src/lib/dlt_client.c
@@ -409,7 +409,8 @@ DltReturnValue dlt_client_main_loop(DltClient *client, void *data, int verbose)
             return DLT_RETURN_TRUE;
         }
 
-        while (dlt_message_read(&msg, (unsigned char *)(client->receiver.buf), client->receiver.bytesRcvd, 0,
+        while (dlt_message_read(&msg, (unsigned char *)(client->receiver.buf),
+                                (unsigned int) client->receiver.bytesRcvd, 0,
                                 verbose) == DLT_MESSAGE_ERROR_OK) {
             /* Call callback function */
             if (message_callback_function)
@@ -417,8 +418,8 @@ DltReturnValue dlt_client_main_loop(DltClient *client, void *data, int verbose)
 
             if (msg.found_serialheader) {
                 if (dlt_receiver_remove(&(client->receiver),
-                                        msg.headersize + msg.datasize - sizeof(DltStorageHeader) +
-                                        sizeof(dltSerialHeader)) ==
+                                        (int) (msg.headersize + msg.datasize - sizeof(DltStorageHeader) +
+                                        sizeof(dltSerialHeader))) ==
                     DLT_RETURN_ERROR) {
                     /* Return value ignored */
                     dlt_message_free(&msg, verbose);
@@ -426,7 +427,7 @@ DltReturnValue dlt_client_main_loop(DltClient *client, void *data, int verbose)
                 }
             }
             else if (dlt_receiver_remove(&(client->receiver),
-                                         msg.headersize + msg.datasize - sizeof(DltStorageHeader)) ==
+                                         (int) (msg.headersize + msg.datasize - sizeof(DltStorageHeader))) ==
                      DLT_RETURN_ERROR) {
                 /* Return value ignored */
                 dlt_message_free(&msg, verbose);
@@ -527,12 +528,12 @@ DltReturnValue dlt_client_send_ctrl_msg(DltClient *client, char *apid, char *cti
     dlt_set_id(msg.extendedheader->ctid, (ctid[0] == '\0') ? DLT_CLIENT_DUMMY_CON_ID : ctid);
 
     /* prepare length information */
-    msg.headersize = sizeof(DltStorageHeader) +
+    msg.headersize = (uint32_t) (sizeof(DltStorageHeader) +
         sizeof(DltStandardHeader) +
         sizeof(DltExtendedHeader) +
-        DLT_STANDARD_HEADER_EXTRA_SIZE(msg.standardheader->htyp);
+        DLT_STANDARD_HEADER_EXTRA_SIZE(msg.standardheader->htyp));
 
-    len = msg.headersize - sizeof(DltStorageHeader) + msg.datasize;
+    len = (int32_t) (msg.headersize - sizeof(DltStorageHeader) + msg.datasize);
 
     if (len > UINT16_MAX) {
         fprintf(stderr, "Critical: Huge injection message discarded!\n");
@@ -547,7 +548,7 @@ DltReturnValue dlt_client_send_ctrl_msg(DltClient *client, char *apid, char *cti
     if ((client->mode == DLT_CLIENT_MODE_TCP) || (client->mode == DLT_CLIENT_MODE_SERIAL)) {
         /* via FileDescriptor */
         ret =
-            write(client->sock, msg.headerbuffer + sizeof(DltStorageHeader), msg.headersize - sizeof(DltStorageHeader));
+            (int) write(client->sock, msg.headerbuffer + sizeof(DltStorageHeader), msg.headersize - sizeof(DltStorageHeader));
 
         if (0 > ret) {
             dlt_log(LOG_ERR, "Sending message failed\n");
@@ -555,7 +556,7 @@ DltReturnValue dlt_client_send_ctrl_msg(DltClient *client, char *apid, char *cti
             return DLT_RETURN_ERROR;
         }
 
-        ret = write(client->sock, msg.databuffer, msg.datasize);
+        ret = (int) write(client->sock, msg.databuffer, msg.datasize);
 
         if (0 > ret) {
             dlt_log(LOG_ERR, "Sending message failed\n");
@@ -601,14 +602,14 @@ DltReturnValue dlt_client_send_inject_msg(DltClient *client,
 
     offset = 0;
     memcpy(payload, &serviceID, sizeof(serviceID));
-    offset += sizeof(uint32_t);
+    offset += (int) sizeof(uint32_t);
     memcpy(payload + offset, &size, sizeof(size));
-    offset += sizeof(uint32_t);
+    offset += (int) sizeof(uint32_t);
     memcpy(payload + offset, buffer, size);
 
     /* free message */
     if (dlt_client_send_ctrl_msg(client, apid, ctid, payload,
-                                 sizeof(uint32_t) + sizeof(uint32_t) + size) == DLT_RETURN_ERROR) {
+                                 (uint32_t) (sizeof(uint32_t) + sizeof(uint32_t) + size)) == DLT_RETURN_ERROR) {
         free(payload);
         return DLT_RETURN_ERROR;
     }
@@ -1094,7 +1095,7 @@ DltReturnValue dlt_client_parse_get_log_info_resp_text(DltServiceGetLogInfoRespo
     }
 
     /* count_app_ids */
-    resp->log_info_type.count_app_ids = dlt_getloginfo_conv_ascii_to_uint16_t(rp,
+    resp->log_info_type.count_app_ids = (uint16_t) dlt_getloginfo_conv_ascii_to_uint16_t(rp,
                                                                               &rp_count);
 
     resp->log_info_type.app_ids = (AppIDsType *)calloc
@@ -1112,7 +1113,7 @@ DltReturnValue dlt_client_parse_get_log_info_resp_text(DltServiceGetLogInfoRespo
         dlt_getloginfo_conv_ascii_to_id(rp, &rp_count, app->app_id, DLT_ID_SIZE);
 
         /* count_con_ids */
-        app->count_context_ids = dlt_getloginfo_conv_ascii_to_uint16_t(rp,
+        app->count_context_ids = (uint16_t) dlt_getloginfo_conv_ascii_to_uint16_t(rp,
                                                                        &rp_count);
 
         app->context_id_info = (ContextIDsInfoType *)calloc
@@ -1145,10 +1146,10 @@ DltReturnValue dlt_client_parse_get_log_info_resp_text(DltServiceGetLogInfoRespo
 
             /* context desc */
             if (resp->status == 7) {
-                con->len_context_description = dlt_getloginfo_conv_ascii_to_uint16_t(rp,
+                con->len_context_description = (uint16_t) dlt_getloginfo_conv_ascii_to_uint16_t(rp,
                                                                                      &rp_count);
                 con->context_description = (char *)calloc
-                        (con->len_context_description + 1, sizeof(char));
+                        ((size_t) (con->len_context_description + 1), sizeof(char));
 
                 if (con->context_description == 0) {
                     dlt_log(LOG_ERR, "calloc failed for context description\n");
@@ -1165,10 +1166,10 @@ DltReturnValue dlt_client_parse_get_log_info_resp_text(DltServiceGetLogInfoRespo
 
         /* application desc */
         if (resp->status == 7) {
-            app->len_app_description = dlt_getloginfo_conv_ascii_to_uint16_t(rp,
+            app->len_app_description = (uint16_t) dlt_getloginfo_conv_ascii_to_uint16_t(rp,
                                                                              &rp_count);
             app->app_description = (char *)calloc
-                    (app->len_app_description + 1, sizeof(char));
+                    ((size_t) (app->len_app_description + 1), sizeof(char));
 
             if (app->app_description == 0) {
                 dlt_log(LOG_ERR, "calloc failed for application description\n");
diff --git a/src/lib/dlt_env_ll.c b/src/lib/dlt_env_ll.c
index 8770a02..6cf7ded 100644
--- a/src/lib/dlt_env_ll.c
+++ b/src/lib/dlt_env_ll.c
@@ -125,7 +125,7 @@ int dlt_env_extract_symbolic_ll(char **const env, int8_t *ll)
     if (!(*env))
         return -1;
 
-    if (dlt_env_helper_to_lower(env, &result[0], sizeof(result)) == 0) {
+    if (dlt_env_helper_to_lower(env, &result[0], (int) sizeof(result)) == 0) {
         if (strncmp("default", result, sizeof(result)) == 0)
             *ll = -1;
         else if (strncmp("off", result, sizeof(result)) == 0)
@@ -203,7 +203,7 @@ int dlt_env_extract_ll(char **const env, int8_t *ll)
     }
     else {
         if ((**env >= '0') && (**env < '7')) {
-            *ll = **env - '0';
+            *ll = (int8_t) (**env - '0');
             (*env)++;
         }
         else if (dlt_env_extract_symbolic_ll(env, ll) != 0)
diff --git a/src/lib/dlt_filetransfer.c b/src/lib/dlt_filetransfer.c
index bd196ea..40acafa 100644
--- a/src/lib/dlt_filetransfer.c
+++ b/src/lib/dlt_filetransfer.c
@@ -91,7 +91,7 @@ uint32_t getFilesize(const char *file, int *ok)
     }
 
     *ok = 1;
-    return (uint32_t)st.st_size;
+    return (uint32_t) st.st_size;
 }
 
 /** A simple Hash function for C-strings
@@ -104,7 +104,7 @@ void stringHash(const char *str, uint32_t *hash)
     if (!str || !hash)
         return;
 
-    unsigned int len = strlen(str);
+    unsigned int len = (unsigned int) strlen(str);
 
     unsigned int i = 0;
 
@@ -112,7 +112,7 @@ void stringHash(const char *str, uint32_t *hash)
         return;
 
     for (i = 0; i < len; i++)
-        *hash = 53 * *hash + str[i];
+        *hash = 53 * *hash + (uint32_t) str[i];
 }
 
 
@@ -133,10 +133,10 @@ uint32_t getFileSerialNumber(const char *file, int *ok)
     }
     else {
         *ok = 1;
-        ret = st.st_ino;
+        ret = (uint32_t) st.st_ino;
         ret = ret << (sizeof(ret) * 8) / 2;
-        ret |= st.st_size;
-        ret ^= st.st_ctime;
+        ret |= (uint32_t) st.st_size;
+        ret ^= (uint32_t) st.st_ctime;
         stringHash(file, &ret);
     }
 
@@ -595,7 +595,7 @@ int dlt_user_log_file_data(DltContext *fileContext, const char *filename, int pa
 
             }
 
-            readBytes = fread(buffer, sizeof(char), BUFFER_SIZE, file);
+            readBytes = (uint32_t) fread(buffer, sizeof(char), BUFFER_SIZE, file);
             int ok;
 
             uint32_t fserial = getFileSerialNumber(filename, &ok);
diff --git a/src/lib/dlt_user.c b/src/lib/dlt_user.c
index d810eb1..a5751db 100644
--- a/src/lib/dlt_user.c
+++ b/src/lib/dlt_user.c
@@ -672,7 +672,7 @@ DltReturnValue dlt_init_common(void)
 
     if (dlt_user.use_extended_header_for_non_verbose ==
             DLT_USER_USE_EXTENDED_HEADER_FOR_NONVERBOSE)
-        header_size += sizeof(DltExtendedHeader);
+        header_size += (uint32_t) sizeof(DltExtendedHeader);
 
     /* With session id is enabled by default */
     dlt_user.with_session_id = DLT_USER_WITH_SESSION_ID;
@@ -767,7 +767,7 @@ DltReturnValue dlt_init_common(void)
                      "Configured size exceeds maximum allowed size,restricting to max [65535 bytes]\n");
         }
         else {
-            dlt_user.log_buf_len = buffer_max_configured;
+            dlt_user.log_buf_len = (uint16_t) buffer_max_configured;
             dlt_vlog(LOG_INFO,
                      "Configured buffer size to [%d bytes]\n",
                      buffer_max_configured);
@@ -1382,20 +1382,20 @@ DltReturnValue dlt_register_context_ll_ts_llccb(DltContext *handle,
                                              DLT_USER_LOG_LEVEL_NOT_SET);
 
     if (envLogLevel != DLT_USER_LOG_LEVEL_NOT_SET) {
-        ctx_entry->log_level = envLogLevel;
+        ctx_entry->log_level = (int8_t) envLogLevel;
         loglevel = envLogLevel;
     }
     else if (loglevel != DLT_USER_LOG_LEVEL_NOT_SET)
     {
-        ctx_entry->log_level = loglevel;
+        ctx_entry->log_level = (int8_t) loglevel;
     }
 
     if (tracestatus != DLT_USER_TRACE_STATUS_NOT_SET)
-        ctx_entry->trace_status = tracestatus;
+        ctx_entry->trace_status = (int8_t) tracestatus;
 
     /* Prepare transfer struct */
     dlt_set_id(handle->contextID, contextid);
-    handle->log_level_pos = dlt_user.dlt_ll_ts_num_entries;
+    handle->log_level_pos = (int32_t) dlt_user.dlt_ll_ts_num_entries;
 
     handle->log_level_ptr = ctx_entry->log_level_ptr;
     handle->trace_status_ptr = ctx_entry->trace_status_ptr;
@@ -1403,7 +1403,7 @@ DltReturnValue dlt_register_context_ll_ts_llccb(DltContext *handle,
     log.context_description = ctx_entry->context_description;
 
     *(ctx_entry->log_level_ptr) = ctx_entry->log_level;
-    *(ctx_entry->trace_status_ptr) = ctx_entry->trace_status = tracestatus;
+    *(ctx_entry->trace_status_ptr) = ctx_entry->trace_status = (int8_t) tracestatus;
     ctx_entry->log_level_changed_callback = dlt_log_level_changed_callback;
 
     log.log_level = loglevel;
@@ -2259,12 +2259,12 @@ DltReturnValue dlt_user_log_write_ptr(DltContextData *log, void *data)
     switch (sizeof(void *)) {
     case 4:
         return dlt_user_log_write_uint32_formatted(log,
-                                                   (uintptr_t)data,
+                                                   (uintptr_t) data,
                                                    DLT_FORMAT_HEX32);
         break;
     case 8:
         return dlt_user_log_write_uint64_formatted(log,
-                                                   (uintptr_t)data,
+                                                   (uintptr_t) data,
                                                    DLT_FORMAT_HEX64);
         break;
     default:
@@ -2542,13 +2542,13 @@ DltReturnValue dlt_user_log_write_sized_string_utils(DltContextData *log, const
         ret = DLT_RETURN_USER_BUFFER_FULL;
 
         /* Re-calculate arg_size */
-        arg_size = dlt_user.log_buf_len - log->size - sizeof(uint16_t);
+        arg_size = (uint16_t) (dlt_user.log_buf_len - log->size - sizeof(uint16_t));
 
         size_t min_payload_str_truncate_msg = log->size + str_truncate_message_length + sizeof(uint16_t);
 
         if (dlt_user.verbose_mode) {
             min_payload_str_truncate_msg += sizeof(uint32_t);
-            arg_size -= sizeof(uint32_t);
+            arg_size -= (uint16_t) sizeof(uint32_t);
         }
 
         /* Return when dlt_user.log_buf_len does not have enough space for min_payload_str_truncate_msg */
@@ -2650,7 +2650,7 @@ DltReturnValue dlt_user_log_write_string_utils(DltContextData *log, const char *
     if ((log == NULL) || (text == NULL))
         return DLT_RETURN_WRONG_PARAMETER;
 
-    uint16_t length = strlen(text);
+    uint16_t length = (uint16_t) strlen(text);
     return dlt_user_log_write_sized_string_utils(log, text, length, type);
 }
 
@@ -2682,7 +2682,7 @@ DltReturnValue dlt_register_injection_callback_with_id(DltContext *handle, uint3
     }
 
     /* Insert callback in corresponding table */
-    i = handle->log_level_pos;
+    i = (uint32_t) handle->log_level_pos;
 
     /* Insert each service_id only once */
     for (k = 0; k < dlt_user.dlt_ll_ts[i].nrcallbacks; k++)
@@ -2781,7 +2781,7 @@ DltReturnValue dlt_register_log_level_changed_callback(DltContext *handle,
     }
 
     /* Insert callback in corresponding table */
-    i = handle->log_level_pos;
+    i = (uint32_t) handle->log_level_pos;
 
     /* Store new callback function */
     dlt_user.dlt_ll_ts[i].log_level_changed_callback = dlt_log_level_changed_callback;
@@ -2850,7 +2850,7 @@ DltReturnValue dlt_user_trace_network_segmented_start(uint32_t *id,
         log.size = 0;
 
         gettimeofday(&tv, NULL);
-        *id = tv.tv_usec;
+        *id = (uint32_t) tv.tv_usec;
 
         /* Write identifier */
         if (dlt_user_log_write_string(&log, DLT_TRACE_NW_START) < 0) {
@@ -2964,7 +2964,7 @@ DltReturnValue dlt_user_trace_network_segmented_segment(uint32_t id,
         }
 
         /* Write segment sequence number */
-        if (dlt_user_log_write_uint16(&log, sequence) < DLT_RETURN_OK) {
+        if (dlt_user_log_write_uint16(&log, (uint16_t) sequence) < DLT_RETURN_OK) {
             dlt_user_free_buffer(&(log.buffer));
             return DLT_RETURN_ERROR;
         }
@@ -3118,7 +3118,7 @@ void dlt_user_trace_network_segmented_thread_segmenter(s_segmented_data *data)
         uint16_t len = 0;
 
         if (offset + DLT_MAX_TRACE_SEGMENT_SIZE > data->payload_len)
-            len = data->payload_len - offset;
+            len = (uint16_t) (data->payload_len - offset);
         else
             len = DLT_MAX_TRACE_SEGMENT_SIZE;
 
@@ -3190,9 +3190,11 @@ DltReturnValue dlt_user_trace_network_segmented(DltContext *handle,
 
     /* Send start message */
     DltReturnValue err = dlt_user_trace_network_segmented_start(&(thread_data->id),
-                                                                thread_data->handle, thread_data->nw_trace_type,
-                                                                thread_data->header_len, thread_data->header,
-                                                                thread_data->payload_len);
+                                                                thread_data->handle,
+                                                                thread_data->nw_trace_type,
+                                                                (uint16_t) thread_data->header_len,
+                                                                thread_data->header,
+                                                                (uint16_t) thread_data->payload_len);
 
     if ((err == DLT_RETURN_BUFFER_FULL) || (err == DLT_RETURN_ERROR)) {
         dlt_log(LOG_ERR, "NWTSegmented: Could not send start segment. Aborting.\n");
@@ -3310,7 +3312,7 @@ DltReturnValue dlt_user_trace_network_truncated(DltContext *handle,
             int truncated_payload_len = dlt_user.log_buf_len - log.size - sizeof(uint16_t) - sizeof(uint32_t);
 
             /* Write truncated payload */
-            if (dlt_user_log_write_raw(&log, payload, truncated_payload_len) < DLT_RETURN_OK) {
+            if (dlt_user_log_write_raw(&log, payload, (uint16_t) truncated_payload_len) < DLT_RETURN_OK) {
                 dlt_user_free_buffer(&(log.buffer));
                 return DLT_RETURN_ERROR;
             }
@@ -3751,7 +3753,7 @@ DltReturnValue dlt_user_log_send_log(DltContextData *log, int mtype)
     /* send session id */
     if (dlt_user.with_session_id) {
         msg.standardheader->htyp |= DLT_HTYP_WSID;
-        msg.headerextra.seid = getpid();
+        msg.headerextra.seid = (uint32_t) getpid();
     }
 
     if (dlt_user.verbose_mode)
@@ -3792,14 +3794,14 @@ DltReturnValue dlt_user_log_send_log(DltContextData *log, int mtype)
         switch (mtype) {
         case DLT_TYPE_LOG:
         {
-            msg.extendedheader->msin = (DLT_TYPE_LOG << DLT_MSIN_MSTP_SHIFT) |
-                ((log->log_level << DLT_MSIN_MTIN_SHIFT) & DLT_MSIN_MTIN);
+            msg.extendedheader->msin = (uint8_t) (DLT_TYPE_LOG << DLT_MSIN_MSTP_SHIFT |
+                ((log->log_level << DLT_MSIN_MTIN_SHIFT) & DLT_MSIN_MTIN));
             break;
         }
         case DLT_TYPE_NW_TRACE:
         {
-            msg.extendedheader->msin = (DLT_TYPE_NW_TRACE << DLT_MSIN_MSTP_SHIFT) |
-                ((log->trace_status << DLT_MSIN_MTIN_SHIFT) & DLT_MSIN_MTIN);
+            msg.extendedheader->msin = (uint8_t) (DLT_TYPE_NW_TRACE << DLT_MSIN_MSTP_SHIFT |
+                ((log->trace_status << DLT_MSIN_MTIN_SHIFT) & DLT_MSIN_MTIN));
             break;
         }
         default:
@@ -3814,20 +3816,20 @@ DltReturnValue dlt_user_log_send_log(DltContextData *log, int mtype)
         if (dlt_user.verbose_mode)
             msg.extendedheader->msin |= DLT_MSIN_VERB;
 
-        msg.extendedheader->noar = log->args_num;              /* number of arguments */
+        msg.extendedheader->noar = (uint8_t) log->args_num;              /* number of arguments */
         dlt_set_id(msg.extendedheader->apid, dlt_user.appID);       /* application id */
         dlt_set_id(msg.extendedheader->ctid, log->handle->contextID);   /* context id */
 
-        msg.headersize = sizeof(DltStorageHeader) + sizeof(DltStandardHeader) + sizeof(DltExtendedHeader) +
-            DLT_STANDARD_HEADER_EXTRA_SIZE(msg.standardheader->htyp);
+        msg.headersize = (uint32_t) (sizeof(DltStorageHeader) + sizeof(DltStandardHeader) + sizeof(DltExtendedHeader) +
+            DLT_STANDARD_HEADER_EXTRA_SIZE(msg.standardheader->htyp));
     }
     else {
         /* without extended header */
-        msg.headersize = sizeof(DltStorageHeader) + sizeof(DltStandardHeader) + DLT_STANDARD_HEADER_EXTRA_SIZE(
-            msg.standardheader->htyp);
+        msg.headersize = (uint32_t) (sizeof(DltStorageHeader) + sizeof(DltStandardHeader) + DLT_STANDARD_HEADER_EXTRA_SIZE(
+            msg.standardheader->htyp));
     }
 
-    len = msg.headersize - sizeof(DltStorageHeader) + log->size;
+    len = (int32_t) (msg.headersize - sizeof(DltStorageHeader) + log->size);
 
     if (len > UINT16_MAX) {
         dlt_log(LOG_WARNING, "Huge message discarded!\n");
@@ -3978,7 +3980,7 @@ DltReturnValue dlt_user_log_send_register_application(void)
     usercontext.pid = getpid();
 
     if (dlt_user.application_description != NULL)
-        usercontext.description_length = strlen(dlt_user.application_description);
+        usercontext.description_length = (uint32_t) strlen(dlt_user.application_description);
     else
         usercontext.description_length = 0;
 
@@ -4063,11 +4065,11 @@ DltReturnValue dlt_user_log_send_register_context(DltContextData *log)
     usercontext.log_level_pos = log->handle->log_level_pos;
     usercontext.pid = getpid();
 
-    usercontext.log_level = (int8_t)log->log_level;
-    usercontext.trace_status = (int8_t)log->trace_status;
+    usercontext.log_level = (int8_t) log->log_level;
+    usercontext.trace_status = (int8_t) log->trace_status;
 
     if (log->context_description != NULL)
-        usercontext.description_length = strlen(log->context_description);
+        usercontext.description_length = (uint32_t) strlen(log->context_description);
     else
         usercontext.description_length = 0;
 
@@ -4257,8 +4259,8 @@ DltReturnValue dlt_user_log_send_marker()
 DltReturnValue dlt_user_print_msg(DltMessage *msg, DltContextData *log)
 {
     uint8_t *databuffer_tmp;
-    int32_t datasize_tmp;
-    int32_t databuffersize_tmp;
+    uint32_t datasize_tmp;
+    uint32_t databuffersize_tmp;
     static char text[DLT_USER_TEXT_LENGTH];
 
     if ((msg == NULL) || (log == NULL))
@@ -4275,7 +4277,7 @@ DltReturnValue dlt_user_print_msg(DltMessage *msg, DltContextData *log)
 
     msg->databuffer = log->buffer;
     msg->datasize = log->size;
-    msg->databuffersize = log->size;
+    msg->databuffersize = (uint32_t) log->size;
 
     /* Print message as ASCII */
     if (dlt_message_print_ascii(msg, text, DLT_USER_TEXT_LENGTH, 0) == DLT_RETURN_ERROR)
@@ -4359,7 +4361,7 @@ DltReturnValue dlt_user_log_check_user_message(void)
 
                     offset++;
 
-                } while ((int32_t) (sizeof(DltUserHeader) + offset) <= receiver->bytesRcvd);
+                } while (((int32_t) (sizeof(DltUserHeader)) + offset) <= receiver->bytesRcvd);
 
                 /* Check for user header pattern */
                 if ((dlt_user_check_userheader(userheader) < 0) ||
@@ -4389,24 +4391,24 @@ DltReturnValue dlt_user_log_check_user_message(void)
                         if ((usercontextll->log_level_pos >= 0) &&
                             (usercontextll->log_level_pos < (int32_t)dlt_user.dlt_ll_ts_num_entries)) {
                             if (dlt_user.dlt_ll_ts) {
-                                dlt_user.dlt_ll_ts[usercontextll->log_level_pos].log_level = usercontextll->log_level;
+                                dlt_user.dlt_ll_ts[usercontextll->log_level_pos].log_level = (int8_t) usercontextll->log_level;
                                 dlt_user.dlt_ll_ts[usercontextll->log_level_pos].trace_status =
-                                    usercontextll->trace_status;
+                                    (int8_t) usercontextll->trace_status;
 
                                 if (dlt_user.dlt_ll_ts[usercontextll->log_level_pos].log_level_ptr)
                                     *(dlt_user.dlt_ll_ts[usercontextll->log_level_pos].log_level_ptr) =
-                                        usercontextll->log_level;
+                                        (int8_t) usercontextll->log_level;
 
                                 if (dlt_user.dlt_ll_ts[usercontextll->log_level_pos].trace_status_ptr)
                                     *(dlt_user.dlt_ll_ts[usercontextll->log_level_pos].trace_status_ptr) =
-                                        usercontextll->trace_status;
+                                        (int8_t) usercontextll->trace_status;
 
                                 delayed_log_level_changed_callback.log_level_changed_callback =
                                     dlt_user.dlt_ll_ts[usercontextll->log_level_pos].log_level_changed_callback;
                                 memcpy(delayed_log_level_changed_callback.contextID,
                                        dlt_user.dlt_ll_ts[usercontextll->log_level_pos].contextID, DLT_ID_SIZE);
-                                delayed_log_level_changed_callback.log_level = usercontextll->log_level;
-                                delayed_log_level_changed_callback.trace_status = usercontextll->trace_status;
+                                delayed_log_level_changed_callback.log_level = (int8_t) usercontextll->log_level;
+                                delayed_log_level_changed_callback.trace_status = (int8_t) usercontextll->trace_status;
                             }
                         }
 
@@ -4417,8 +4419,8 @@ DltReturnValue dlt_user_log_check_user_message(void)
                     if (delayed_log_level_changed_callback.log_level_changed_callback != 0)
                         delayed_log_level_changed_callback.log_level_changed_callback(
                             delayed_log_level_changed_callback.contextID,
-                            delayed_log_level_changed_callback.log_level,
-                            delayed_log_level_changed_callback.trace_status);
+                            (uint8_t) delayed_log_level_changed_callback.log_level,
+                            (uint8_t) delayed_log_level_changed_callback.trace_status);
 
                     /* keep not read data in buffer */
                     if (dlt_receiver_remove(receiver,
@@ -4514,7 +4516,7 @@ DltReturnValue dlt_user_log_check_user_message(void)
 
                         /* keep not read data in buffer */
                         if (dlt_receiver_remove(receiver,
-                                                (sizeof(DltUserHeader) +
+                                                (int) (sizeof(DltUserHeader) +
                                                  sizeof(DltUserControlMsgInjection) +
                                                  usercontextinj->data_length_inject)) != DLT_RETURN_OK)
                             return DLT_RETURN_ERROR;
@@ -4632,7 +4634,7 @@ DltReturnValue dlt_user_log_resend_buffer(void)
 
             ret = dlt_user_log_out3(dlt_user.dlt_log_handle, dlt_user.resend_buffer, sizeof(DltUserHeader), 0, 0, 0, 0);
 #else
-            ret = dlt_user_log_out3(dlt_user.dlt_log_handle, dlt_user.resend_buffer, size, 0, 0, 0, 0);
+            ret = dlt_user_log_out3(dlt_user.dlt_log_handle, dlt_user.resend_buffer, (size_t) size, 0, 0, 0, 0);
 #endif
 
             /* in case of error, keep message in ringbuffer */
@@ -4717,7 +4719,7 @@ void dlt_user_log_reattach_to_daemon(void)
             if ((dlt_user.appID[0] != '\0') && (dlt_user.dlt_ll_ts) && (dlt_user.dlt_ll_ts[num].contextID[0] != '\0')) {
                 /*dlt_set_id(log_new.appID, dlt_user.appID); */
                 dlt_set_id(handle.contextID, dlt_user.dlt_ll_ts[num].contextID);
-                handle.log_level_pos = num;
+                handle.log_level_pos = (int32_t) num;
                 log_new.context_description = dlt_user.dlt_ll_ts[num].context_description;
 
                 /* Release the mutex for sending context registration: */
@@ -4770,7 +4772,7 @@ DltReturnValue dlt_user_check_buffer(int *total_size, int *used_size)
     *total_size = dlt_shm_get_total_size(&(dlt_user.dlt_shm));
     *used_size = dlt_shm_get_used_size(&(dlt_user.dlt_shm));
 #else
-    *total_size = dlt_buffer_get_total_size(&(dlt_user.startup_buffer));
+    *total_size = (int) dlt_buffer_get_total_size(&(dlt_user.startup_buffer));
     *used_size = dlt_buffer_get_used_size(&(dlt_user.startup_buffer));
 #endif
 
@@ -4896,18 +4898,18 @@ DltReturnValue dlt_user_log_out_error_handling(void *ptr1, size_t len1, void *pt
                                                size_t len3)
 {
     int ret = DLT_RETURN_ERROR;
-    int msg_size = len1 + len2 + len3;
+    size_t msg_size = len1 + len2 + len3;
 
     DLT_SEM_LOCK();
-    ret = dlt_buffer_check_size(&(dlt_user.startup_buffer), msg_size);
+    ret = (int) dlt_buffer_check_size(&(dlt_user.startup_buffer), (int) msg_size);
     DLT_SEM_FREE();
 
     DLT_SEM_LOCK();
 
     if (dlt_buffer_push3(&(dlt_user.startup_buffer),
-                         ptr1, len1,
-                         ptr2, len2,
-                         ptr3, len3) == DLT_RETURN_ERROR) {
+                         ptr1, (unsigned char) len1,
+                         ptr2, (unsigned char) len2,
+                         ptr3, (unsigned char) len3) == DLT_RETURN_ERROR) {
         if (dlt_user.overflow_counter == 0)
             dlt_log(LOG_WARNING, "Buffer full! Messages will be discarded.\n");
 
diff --git a/src/shared/dlt_common.c b/src/shared/dlt_common.c
index 9cd88f9..3aae317 100644
--- a/src/shared/dlt_common.c
+++ b/src/shared/dlt_common.c
@@ -996,18 +996,26 @@ int dlt_message_read(DltMessage *msg, uint8_t *buffer, unsigned int length, int
     msg->headersize = (uint32_t) (sizeof(DltStorageHeader) + sizeof(DltStandardHeader) + extra_size);
     msg->datasize = DLT_BETOH_16(msg->standardheader->len) - (msg->headersize - sizeof(DltStorageHeader));
 
-    if (verbose) {
-        dlt_vlog(LOG_DEBUG, "BufferLength=%d, HeaderSize=%d, DataSize=%d\n",
-                 length, msg->headersize, msg->datasize);
-    }
+    /* calculate complete size of payload */
+    int32_t temp_datasize;
+    temp_datasize = DLT_BETOH_16(msg->standardheader->len) - (msg->headersize - sizeof(DltStorageHeader));
 
     /* check data size */
-    if (msg->datasize < 0) {
+    if (temp_datasize < 0) {
         dlt_vlog(LOG_WARNING,
                  "Plausibility check failed. Complete message size too short (%d)!\n",
-                 msg->datasize);
+                 temp_datasize);
         return DLT_MESSAGE_ERROR_CONTENT;
     }
+    else {
+        msg->datasize = (uint32_t) temp_datasize;
+    }
+
+    /* check if verbose mode is on*/
+    if (verbose) {
+        dlt_vlog(LOG_DEBUG, "BufferLength=%d, HeaderSize=%d, DataSize=%d\n",
+                 length, msg->headersize, msg->datasize);
+    }
 
     /* load standard header extra parameters and Extended header if used */
     if (extra_size > 0) {
@@ -1204,19 +1212,25 @@ DltReturnValue dlt_file_read_header(DltFile *file, int verbose)
     file->msg.headersize = sizeof(DltStorageHeader) + sizeof(DltStandardHeader) +
         DLT_STANDARD_HEADER_EXTRA_SIZE(file->msg.standardheader->htyp) +
         (DLT_IS_HTYP_UEH(file->msg.standardheader->htyp) ? sizeof(DltExtendedHeader) : 0);
-    file->msg.datasize = DLT_BETOH_16(file->msg.standardheader->len) + sizeof(DltStorageHeader) - file->msg.headersize;
 
-    if (verbose) {
-        dlt_vlog(LOG_DEBUG, "HeaderSize=%d, DataSize=%d\n",
-                 file->msg.headersize, file->msg.datasize);
-    }
+    /* calculate complete size of payload */
+    int32_t temp_datasize;
+    temp_datasize = DLT_BETOH_16(file->msg.standardheader->len) + sizeof(DltStorageHeader) - file->msg.headersize;
 
     /* check data size */
-    if (file->msg.datasize < 0) {
+    if (temp_datasize < 0) {
         dlt_vlog(LOG_WARNING,
                  "Plausibility check failed. Complete message size too short! (%d)\n",
-                 file->msg.datasize);
+                 temp_datasize);
         return DLT_RETURN_ERROR;
+    } else {
+        file->msg.datasize = (uint32_t) temp_datasize;
+    }
+
+    /* check if verbose mode is on */
+    if (verbose) {
+        dlt_vlog(LOG_DEBUG, "HeaderSize=%d, DataSize=%d\n",
+                 file->msg.headersize, file->msg.datasize);
     }
 
     return DLT_RETURN_OK;
@@ -1294,20 +1308,27 @@ DltReturnValue dlt_file_read_header_raw(DltFile *file, int resync, int verbose)
     file->msg.headersize = sizeof(DltStorageHeader) + sizeof(DltStandardHeader) +
         DLT_STANDARD_HEADER_EXTRA_SIZE(file->msg.standardheader->htyp) +
         (DLT_IS_HTYP_UEH(file->msg.standardheader->htyp) ? sizeof(DltExtendedHeader) : 0);
-    file->msg.datasize = DLT_BETOH_16(file->msg.standardheader->len) + sizeof(DltStorageHeader) - file->msg.headersize;
 
-    if (verbose) {
-        dlt_vlog(LOG_DEBUG, "HeaderSize=%d, DataSize=%d\n",
-                 file->msg.headersize, file->msg.datasize);
-    }
+    /* calculate complete size of payload */
+    int32_t temp_datasize;
+    temp_datasize = DLT_BETOH_16(file->msg.standardheader->len) + sizeof(DltStorageHeader) - file->msg.headersize;
 
     /* check data size */
-    if (file->msg.datasize < 0) {
+    if (temp_datasize < 0) {
         dlt_vlog(LOG_WARNING,
                  "Plausibility check failed. Complete message size too short! (%d)\n",
-                 file->msg.datasize);
+                 temp_datasize);
         return DLT_RETURN_ERROR;
     }
+    else {
+        file->msg.datasize = (uint32_t) temp_datasize;
+    }
+
+    /* check if verbose mode is on */
+    if (verbose) {
+        dlt_vlog(LOG_DEBUG, "HeaderSize=%d, DataSize=%d\n",
+                 file->msg.headersize, file->msg.datasize);
+    }
 
     return DLT_RETURN_OK;
 }
@@ -1934,7 +1955,7 @@ DltReturnValue dlt_receiver_init(DltReceiver *receiver, int fd, DltReceiverType
     /** Reuse the receiver buffer if it exists and the buffer size
       * is not changed. If not, free the old one and allocate a new buffer.
       */
-    if ((NULL != receiver->buffer) && (buffersize != receiver->buffersize)) {
+    if ((NULL != receiver->buffer) && ((uint32_t) buffersize != receiver->buffersize)) {
        free(receiver->buffer);
        receiver->buffer = NULL;
     }