From 906578850094f8f5e9ce488c71ad831b2f35330c Mon Sep 17 00:00:00 2001 From: "Dinh Cong Toan(RBVH/ECM12)" Date: Tue, 27 Oct 2020 15:35:51 +0700 Subject: 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) --- include/dlt/dlt_user.h.in | 2 +- src/lib/dlt_client.c | 37 ++++++++------- src/lib/dlt_env_ll.c | 4 +- src/lib/dlt_filetransfer.c | 14 +++--- src/lib/dlt_user.c | 116 +++++++++++++++++++++++---------------------- src/shared/dlt_common.c | 63 ++++++++++++++++-------- 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; } -- cgit v1.2.1