Fix dlog format error

Change-Id: Ia27a245ba72c34316e2f06ce07f0d8ab0bdf3ffd

diff --git a/packaging/download-provider.spec b/packaging/download-provider.spec
index f41dc04..8a6e64b 100755 (executable)
--- a/packaging/download-provider.spec
+++ b/packaging/download-provider.spec
@@ -1,6 +1,6 @@
 Name:       download-provider
 Summary:    Download the contents in background
-Version:    2.1.104
+Version:    2.1.105
 Release:    0
 Group:      Development/Libraries
 License:    Apache-2.0

diff --git a/provider-interface/download-provider-interface.c b/provider-interface/download-provider-interface.c
index 6a3c2d1..401e3a8 100755 (executable)
--- a/provider-interface/download-provider-interface.c
+++ b/provider-interface/download-provider-interface.c
@@ -521,7 +521,7 @@ static int __dp_ipc_set_binary(const int id, const unsigned property,
 {
        int errorcode = DP_ERROR_NONE;
        if (string == NULL || length <= 0) {
-               TRACE_ERROR("%s check binary (%d)", funcname, length);
+               TRACE_ERROR("%s check binary (%zd)", funcname, length);
                return DOWNLOAD_ADAPTOR_ERROR_INVALID_PARAMETER;
        }
 
@@ -554,7 +554,7 @@ static int __dp_ipc_set_string(const int id, const short section, const unsigned
        size_t length = 0;
        if (string == NULL || (length = strlen(string)) <= 0 ||
                        length > DP_MAX_STR_LEN) {
-               TRACE_ERROR("%s check string (%d:%s)", funcname, length, string);
+               TRACE_ERROR("%s check string (%zd:%s)", funcname, length, string);
                return DOWNLOAD_ADAPTOR_ERROR_INVALID_PARAMETER;
        }
 
@@ -605,7 +605,7 @@ static int __dp_ipc_get_string(const int id, const unsigned property,
                        if (string_length > 0) {
                                char *recv_str = (char *)calloc((string_length + (size_t)1), sizeof(char));
                                if (recv_str == NULL) {
-                                       TRACE_ERROR("check memory length:%d", string_length);
+                                       TRACE_ERROR("check memory length:%zd", string_length);
                                        errorcode = DP_ERROR_OUT_OF_MEMORY;
                                        __dp_ipc_clear_garbage(sock, string_length);
                                } else {
@@ -754,7 +754,7 @@ int dp_interface_create(int *id)
                } else if (ipc_info->section != DP_SEC_CONTROL ||
                                ipc_info->property != DP_PROP_CREATE ||
                                ipc_info->size != 0) {
-                       TRACE_ERROR("sock:%d id:%d section:%d property:%d size:%d",
+                       TRACE_ERROR("sock:%d id:%d section:%d property:%d size:%zd",
                                sock, ipc_info->id, ipc_info->section, ipc_info->property,
                                ipc_info->size);
                        errorcode = DP_ERROR_IO_ERROR;
@@ -1254,16 +1254,16 @@ int dp_interface_get_notification_bundle(const int id, const int type, void **bu
        if (errorcode == DP_ERROR_NONE && extra_size > 0) {
                unsigned char *recv_raws = (unsigned char *)calloc(extra_size, sizeof(unsigned char));
                if (recv_raws == NULL) {
-                       TRACE_ERROR("sock:%d check memory length:%d", sock, extra_size);
+                       TRACE_ERROR("sock:%d check memory length:%zd", sock, extra_size);
                        errorcode = DP_ERROR_OUT_OF_MEMORY;
                        __dp_ipc_clear_garbage(sock, extra_size);
                } else {
                        if (dp_ipc_read(sock, recv_raws, extra_size, __FUNCTION__) <= 0) {
-                               TRACE_ERROR("sock:%d check ipc length:%d", sock, extra_size);
+                               TRACE_ERROR("sock:%d check ipc length:%zd", sock, extra_size);
                                errorcode = DP_ERROR_IO_ERROR;
                                free(recv_raws);
                        } else {
-                               TRACE_DEBUG("sock:%d length:%d raws", sock, extra_size);
+                               TRACE_DEBUG("sock:%d length:%zd raws", sock, extra_size);
                                *bundle_param = bundle_decode_raw(recv_raws, extra_size);
                                free(recv_raws);
                        }
@@ -1357,16 +1357,16 @@ int dp_interface_get_notification_service_handle(const int id, const int type, v
        if (errorcode == DP_ERROR_NONE && extra_size > 0) {
                unsigned char *recv_raws = (unsigned char *)calloc(extra_size, sizeof(unsigned char));
                if (recv_raws == NULL) {
-                       TRACE_ERROR("sock:%d check memory length:%d", sock, extra_size);
+                       TRACE_ERROR("sock:%d check memory length:%zd", sock, extra_size);
                        errorcode = DP_ERROR_OUT_OF_MEMORY;
                        __dp_ipc_clear_garbage(sock, extra_size);
                } else {
                        if (dp_ipc_read(sock, recv_raws, extra_size, __FUNCTION__) <= 0) {
-                               TRACE_ERROR("sock:%d check ipc length:%d", sock, extra_size);
+                               TRACE_ERROR("sock:%d check ipc length:%zd", sock, extra_size);
                                errorcode = DP_ERROR_IO_ERROR;
                                free(recv_raws);
                        } else {
-                               TRACE_DEBUG("sock:%d length:%d raws", sock, extra_size);
+                               TRACE_DEBUG("sock:%d length:%zd raws", sock, extra_size);
 
                                bundle_data = bundle_decode_raw(recv_raws, extra_size);
                                if (bundle_data) {
@@ -1404,12 +1404,12 @@ int dp_interface_add_http_header_field(const int id, const char *field,
        size_t value_length = 0;
        if (field == NULL || (field_length = strlen(field)) <= 0 ||
                        field_length > DP_MAX_STR_LEN) {
-               TRACE_ERROR("check field (%d:%s)", field_length, field);
+               TRACE_ERROR("check field (%zd:%s)", field_length, field);
                return DOWNLOAD_ADAPTOR_ERROR_INVALID_PARAMETER;
        }
        if (value == NULL || (value_length = strlen(value)) <= 0 ||
                        value_length > DP_MAX_STR_LEN) {
-               TRACE_ERROR("check value (%d:%s)", value_length, value);
+               TRACE_ERROR("check value (%zd:%s)", value_length, value);
                return DOWNLOAD_ADAPTOR_ERROR_INVALID_PARAMETER;
        }
 
@@ -1459,7 +1459,7 @@ int dp_interface_get_http_header_field(const int id, const char *field,
        size_t length = 0;
        if (field == NULL || (length = strlen(field)) <= 0 ||
                        length > DP_MAX_STR_LEN) {
-               TRACE_ERROR("check field (%d:%s)", length, field);
+               TRACE_ERROR("check field (%zd:%s)", length, field);
                return DOWNLOAD_ADAPTOR_ERROR_INVALID_PARAMETER;
        }
        if (value == NULL) {
@@ -1489,7 +1489,7 @@ int dp_interface_get_http_header_field(const int id, const char *field,
                                if (string_length > 0) {
                                        char *recv_str = (char *)calloc((string_length + (size_t)1), sizeof(char));
                                        if (recv_str == NULL) {
-                                               TRACE_ERROR("check memory length:%d", string_length);
+                                               TRACE_ERROR("check memory length:%zd", string_length);
                                                errorcode = DP_ERROR_OUT_OF_MEMORY;
                                                __dp_ipc_clear_garbage(sock, string_length);
                                        } else {
@@ -1562,7 +1562,7 @@ int dp_interface_get_http_header_field_list(const int id, char ***fields,
 
                                                recv_strings = (char **)calloc(array_size, sizeof(char *));
                                                if (recv_strings == NULL) {
-                                                       TRACE_ERROR("check memory size:%d", array_size);
+                                                       TRACE_ERROR("check memory size:%zd", array_size);
                                                        errorcode = DP_ERROR_OUT_OF_MEMORY;
                                                        *length = 0;
                                                } else {
@@ -1574,7 +1574,7 @@ int dp_interface_get_http_header_field_list(const int id, char ***fields,
                                                                if (errorcode == DP_ERROR_NONE && string_length > 0 && string_length < SIZE_MAX) {
                                                                        char *recv_str = (char *)calloc((string_length + (size_t)1), sizeof(char));
                                                                        if (recv_str == NULL) {
-                                                                               TRACE_ERROR("check memory length:%d", string_length * sizeof(char));
+                                                                               TRACE_ERROR("check memory length:%zd", string_length * sizeof(char));
                                                                                errorcode = DP_ERROR_OUT_OF_MEMORY;
                                                                                break;
                                                                        } else {

diff --git a/provider/download-provider-client-manager.c b/provider/download-provider-client-manager.c
index 022a59d..2e8ee5b 100755 (executable)
--- a/provider/download-provider-client-manager.c
+++ b/provider/download-provider-client-manager.c
@@ -604,7 +604,7 @@ void *dp_client_manager(void *arg)
                                TRACE_ERROR("check ipc sock:%d", clientfd);
 
                        if (errorcode != DP_ERROR_NONE) {
-                               TRACE_ERROR("sock:%d id:%d section:%s property:%s errorcode:%s size:%d",
+                               TRACE_ERROR("sock:%d id:%d section:%s property:%s errorcode:%s size:%zd",
                                                clientfd, ipc_info.id,
                                                dp_print_section(ipc_info.section),
                                                dp_print_property(ipc_info.property),

diff --git a/provider/download-provider-client.c b/provider/download-provider-client.c
index 91db623..af272db 100755 (executable)
--- a/provider/download-provider-client.c
+++ b/provider/download-provider-client.c
@@ -458,7 +458,7 @@ static int __dp_request_read_int(int sock, dp_ipc_fmt *ipc_info, int *value)
        int errorcode = DP_ERROR_NONE;
        if (ipc_info->size == sizeof(int)) {
                if (dp_ipc_read(sock, value, ipc_info->size, __FUNCTION__) < 0) {
-                       TRACE_ERROR("sock:%d check ipc length:%d", sock, ipc_info->size);
+                       TRACE_ERROR("sock:%d check ipc length:%zd", sock, ipc_info->size);
                        errorcode = DP_ERROR_IO_ERROR;
                }
        } else {
@@ -476,12 +476,12 @@ static int __dp_request_feedback_string(int sock, dp_ipc_fmt *ipc_info, void *st
 
        if (dp_ipc_query(sock, ipc_info->id, ipc_info->section, ipc_info->property, errorvalue, length * sizeof(char)) < 0) {
                errorcode = DP_ERROR_IO_ERROR;
-               TRACE_ERROR("sock:%d check ipc length:%d", sock, length);
+               TRACE_ERROR("sock:%d check ipc length:%zd", sock, length);
        }
        if (errorvalue == DP_ERROR_NONE && errorcode == DP_ERROR_NONE) {
                if (dp_ipc_write(sock, string, sizeof(char) * length) < 0) {
                        errorcode = DP_ERROR_IO_ERROR;
-                       TRACE_ERROR("sock:%d check ipc length:%d", sock, length);
+                       TRACE_ERROR("sock:%d check ipc length:%zd", sock, length);
                }
        }
        return errorcode;
@@ -493,16 +493,16 @@ static int __dp_request_read_string(int sock, dp_ipc_fmt *ipc_info, char **strin
        if (ipc_info->size > 0) {
                char *recv_str = (char *)calloc((ipc_info->size + (size_t)1), sizeof(char));
                if (recv_str == NULL) {
-                       TRACE_ERROR("sock:%d check memory length:%d", sock, ipc_info->size);
+                       TRACE_ERROR("sock:%d check memory length:%zd", sock, ipc_info->size);
                        errorcode = DP_ERROR_OUT_OF_MEMORY;
                } else {
                        if (dp_ipc_read(sock, recv_str, ipc_info->size, __FUNCTION__) <= 0) {
-                               TRACE_ERROR("sock:%d check ipc length:%d", sock, ipc_info->size);
+                               TRACE_ERROR("sock:%d check ipc length:%zd", sock, ipc_info->size);
                                errorcode = DP_ERROR_IO_ERROR;
                                free(recv_str);
                        } else {
                                recv_str[ipc_info->size] = '\0';
-                               TRACE_DEBUG("sock:%d length:%d string:%s", sock, ipc_info->size, recv_str);
+                               TRACE_DEBUG("sock:%d length:%zd string:%s", sock, ipc_info->size, recv_str);
                                *string = recv_str;
                        }
                }
@@ -519,12 +519,12 @@ static int __dp_request_feedback_int(int sock, dp_ipc_fmt *ipc_info, void *value
                extra_size = 0;
        if (dp_ipc_query(sock, ipc_info->id, ipc_info->section, ipc_info->property, errorvalue, extra_size) < 0) {
                errorcode = DP_ERROR_IO_ERROR;
-               TRACE_ERROR("sock:%d check ipc length:%d", sock, extra_size);
+               TRACE_ERROR("sock:%d check ipc length:%zd", sock, extra_size);
        }
        if (errorvalue == DP_ERROR_NONE && errorcode == DP_ERROR_NONE) {
                if (dp_ipc_write(sock, value, extra_size) < 0) {
                        errorcode = DP_ERROR_IO_ERROR;
-                       TRACE_ERROR("sock:%d check ipc length:%d", sock, extra_size);
+                       TRACE_ERROR("sock:%d check ipc length:%zd", sock, extra_size);
                }
        }
        return errorcode;
@@ -1305,14 +1305,14 @@ static int __dp_request_set_info(dp_client_slots_fmt *slot, dp_ipc_fmt *ipc_info
                                if (raw_info != NULL && raw_info->size > 0 && raw_info->size < SIZE_MAX) {
                                        unsigned char *recv_raws = (unsigned char *)calloc(raw_info->size, sizeof(unsigned char));
                                        if (recv_raws == NULL) {
-                                               TRACE_ERROR("sock:%d check memory length:%d", client->channel, raw_info->size);
+                                               TRACE_ERROR("sock:%d check memory length:%zd", client->channel, raw_info->size);
                                                errorcode = DP_ERROR_OUT_OF_MEMORY;
                                        } else {
                                                if (dp_ipc_read(client->channel, recv_raws, raw_info->size, __FUNCTION__) <= 0) {
-                                                       TRACE_ERROR("sock:%d check ipc length:%d", client->channel, raw_info->size);
+                                                       TRACE_ERROR("sock:%d check ipc length:%zd", client->channel, raw_info->size);
                                                        errorcode = DP_ERROR_IO_ERROR;
                                                } else {
-                                                       TRACE_DEBUG("sock:%d length:%d raws", client->channel, raw_info->size);
+                                                       TRACE_DEBUG("sock:%d length:%zd raws", client->channel, raw_info->size);
                                                        // save to database
                                                        if (dp_db_replace_property(client->dbhandle, ipc_info->id, DP_TABLE_NOTIFICATION, raw_column, (void *)recv_raws, raw_info->size, 3, &errorcode) < 0) {
                                                                TRACE_ERROR("failed to set %s", dp_print_property(ipc_info->property));
@@ -1971,7 +1971,7 @@ void *dp_client_request_thread(void *arg)
                                TRACE_ERROR("sock:%d maybe closed", client_sock);
                                errorcode = DP_ERROR_IO_ERROR;
                        } else {
-                               TRACE_DEBUG("sock:%d id:%d section:%s property:%s errorcode:%s size:%d",
+                               TRACE_DEBUG("sock:%d id:%d section:%s property:%s errorcode:%s size:%zd",
                                                client_sock, ipc_info->id,
                                                dp_print_section(ipc_info->section),
                                                dp_print_property(ipc_info->property),

diff --git a/provider/download-provider-ipc.c b/provider/download-provider-ipc.c
index 0cb2b84..0375219 100644 (file)
--- a/provider/download-provider-ipc.c
+++ b/provider/download-provider-ipc.c
@@ -101,7 +101,7 @@ dp_ipc_fmt *dp_ipc_get_fmt(int sock)
        memset(ipc_info, 0x00, sizeof(dp_ipc_fmt));
        ssize_t recv_size = read(sock, ipc_info, sizeof(dp_ipc_fmt));
        if (recv_size <= 0 || recv_size != sizeof(dp_ipc_fmt)) {
-               TRACE_ERROR("socket read ipcinfo read size:%d", recv_size);
+               TRACE_ERROR("socket read ipcinfo read size:%zd", recv_size);
                free(ipc_info);
                return NULL;
        }

diff --git a/provider/download-provider-utils.c b/provider/download-provider-utils.c
index d29b51f..440aafa 100644 (file)
--- a/provider/download-provider-utils.c
+++ b/provider/download-provider-utils.c
@@ -39,7 +39,7 @@ char *dp_strdup(char *src)
 
        src_len = strlen(src);
        if (src_len <= 0) {
-               TRACE_ERROR("[CHECK PARAM] len[%d]", src_len);
+               TRACE_ERROR("[CHECK PARAM] len[%zd]", src_len);
                return NULL;
        }