Fix svace errors

- add '\0' after using strncpy macro
- replace strcpy of strncpy
- add missing return value
- initialize value
- remove memory leak

Change-Id: Idaab6a604377462d637f69d595a2b051d98ac420
Signed-off-by: Hyunjee Kim <hj0426.kim@samsung.com>

diff --git a/i18ninfo/i18ninfo.c b/i18ninfo/i18ninfo.c
index 1b7944224df9d3022ec0161d770af27e5ee94c54..dc3d562588f02c5630b85aa5e07e7dfccf3be76d 100644 (file)
--- a/i18ninfo/i18ninfo.c
+++ b/i18ninfo/i18ninfo.c
@@ -26,6 +26,11 @@
                PRINT_ERROR_LOG(fun_name, error_code); \
        }
 
+#define COPY_STR(dst, src, dst_len) do {            \
+                       strncpy((dst), (src), (dst_len));       \
+                       (dst)[(dst_len) - 1] = '\0';            \
+} while (0)
+
 
 char *default_locale = I18N_ULOCALE_UK;
 i18n_uchar default_timezone_id[BUF_SIZE] = {0,};
@@ -64,6 +69,7 @@ static int __get_language_info();
 static int __manage_string_iteration(char *custom_type);
 static int __analyze_string(char *custom_string);
 static int __get_timezone_info();
+static int __get_tzdata_version();
 
 char *__print_i18n_type_string(char *type, int num);
 
@@ -93,202 +99,202 @@ char *__print_i18n_type_string(char *type, int num)
        if (type == "time") {
                switch (num) {
                case 0:
-                       strcpy(str, "I18N_UDATE_FULL");
+                       COPY_STR(str, "I18N_UDATE_FULL", strlen("I18N_UDATE_FULL"));
                        break;
                case 1:
-                       strcpy(str, "I18N_UDATE_LONG");
+                       COPY_STR(str, "I18N_UDATE_LONG", strlen("I18N_UDATE_LONG"));
                        break;
                case 2:
-                       strcpy(str, "I18N_UDATE_MEDIUM");
+                       COPY_STR(str, "I18N_UDATE_MEDIUM", strlen("I18N_UDATE_MEDIUM"));
                        break;
                case 3:
-                       strcpy(str, "I18N_UDATE_SHORT");
+                       COPY_STR(str, "I18N_UDATE_SHORT", strlen("I18N_UDATE_SHORT"));
                        break;
                case 4:
-                       strcpy(str, "I18N_UDATE_NONE");
+                       COPY_STR(str, "I18N_UDATE_NONE", strlen("I18N_UDATE_NONE"));
                        break;
                default:
-                       strcpy(str, "err");
+                       COPY_STR(str, "err", strlen("err"));
                        break;
                }
        } else if (type == "date") {
                switch (num) {
                case 0:
-                       strcpy(str, "I18N_UDATE_FULL");
+                       COPY_STR(str, "I18N_UDATE_FULL", strlen("I18N_UDATE_FULL"));
                        break;
                case 1:
-                       strcpy(str, "I18N_UDATE_LONG");
+                       COPY_STR(str, "I18N_UDATE_LONG", strlen("I18N_UDATE_LONG"));
                        break;
                case 2:
-                       strcpy(str, "I18N_UDATE_MEDIUM");
+                       COPY_STR(str, "I18N_UDATE_MEDIUM", strlen("I18N_UDATE_MEDIUM"));
                        break;
                case 3:
-                       strcpy(str, "I18N_UDATE_SHORT");
+                       COPY_STR(str, "I18N_UDATE_SHORT", strlen("I18N_UDATE_SHORT"));
                        break;
                case 4:
-                       strcpy(str, "I18N_UDATE_RELATIVE");
+                       COPY_STR(str, "I18N_UDATE_RELATIVE", strlen("I18N_UDATE_RELATIVE"));
                        break;
                case 5:
-                       strcpy(str, "I18N_UDATE_LONG_RELATIVE");
+                       COPY_STR(str, "I18N_UDATE_LONG_RELATIVE", strlen("I18N_UDATE_LONG_RELATIVE"));
                        break;
                case 6:
-                       strcpy(str, "I18N_UDATE_MEDIUM_RELATIVE");
+                       COPY_STR(str, "I18N_UDATE_MEDIUM_RELATIVE", strlen("I18N_UDATE_MEDIUM_RELATIVE"));
                        break;
                case 7:
-                       strcpy(str, "I18N_UDATE_SHORT_RELATIVE");
+                       COPY_STR(str, "I18N_UDATE_SHORT_RELATIVE", strlen("I18N_UDATE_SHORT_RELATIVE"));
                        break;
                case 8:
-                       strcpy(str, "I18N_UDATE_NONE");
+                       COPY_STR(str, "I18N_UDATE_NONE", strlen("I18N_UDATE_NONE"));
                        break;
                default:
-                       strcpy(str, "err");
+                       COPY_STR(str, "err", strlen("err"));
                        break;
                }
        } else if (type == "number_format") {
                switch (num) {
                case 1:
-                       strcpy(str, "I18N_UNUMBER_DECIMAL");
+                       COPY_STR(str, "I18N_UNUMBER_DECIMAL", strlen("I18N_UNUMBER_DECIMAL"));
                        break;
                case 2:
-                       strcpy(str, "I18N_UNUMBER_CURRENCY");
+                       COPY_STR(str, "I18N_UNUMBER_CURRENCY", strlen("I18N_UNUMBER_CURRENCY"));
                        break;
                case 3:
-                       strcpy(str, "I18N_UNUMBER_PERCENT");
+                       COPY_STR(str, "I18N_UNUMBER_PERCENT", strlen("I18N_UNUMBER_PERCENT"));
                        break;
                case 4:
-                       strcpy(str, "I18N_UNUMBER_SCIENTIFIC");
+                       COPY_STR(str, "I18N_UNUMBER_SCIENTIFIC", strlen("I18N_UNUMBER_SCIENTIFIC"));
                        break;
                case 5:
-                       strcpy(str, "I18N_UNUMBER_SPELLOUT");
+                       COPY_STR(str, "I18N_UNUMBER_SPELLOUT", strlen("I18N_UNUMBER_SPELLOUT"));
                        break;
                case 6:
-                       strcpy(str, "I18N_UNUMBER_ORDINAL");
+                       COPY_STR(str, "I18N_UNUMBER_ORDINAL", strlen("I18N_UNUMBER_ORDINAL"));
                        break;
                case 7:
-                       strcpy(str, "I18N_UNUMBER_DURATION");
+                       COPY_STR(str, "I18N_UNUMBER_DURATION", strlen("I18N_UNUMBER_DURATION"));
                        break;
                case 8:
-                       strcpy(str, "I18N_UNUMBER_NUMBERING_SYSTEM");
+                       COPY_STR(str, "I18N_UNUMBER_NUMBERING_SYSTEM", strlen("I18N_UNUMBER_NUMBERING_SYSTEM"));
                        break;
                case 9:
-                       strcpy(str, "I18N_UNUMBER_PATTERN_RULEBASED");
+                       COPY_STR(str, "I18N_UNUMBER_PATTERN_RULEBASED", strlen("I18N_UNUMBER_PATTERN_RULEBASED"));
                        break;
                case 10:
-                       strcpy(str, "I18N_UNUMBER_CURRENCY_ISO");
+                       COPY_STR(str, "I18N_UNUMBER_CURRENCY_ISO", strlen("I18N_UNUMBER_CURRENCY_ISO"));
                        break;
                case 11:
-                       strcpy(str, "I18N_UNUMBER_CURRENCY_PLURAL");
+                       COPY_STR(str, "I18N_UNUMBER_CURRENCY_PLURAL", strlen("I18N_UNUMBER_CURRENCY_PLURAL"));
                        break;
                case 12:
-                       strcpy(str, "I18N_UNUMBER_FORMAT_STYLE_COUNT");
+                       COPY_STR(str, "I18N_UNUMBER_FORMAT_STYLE_COUNT", strlen("I18N_UNUMBER_FORMAT_STYLE_COUNT"));
                        break;
                default:
-                       strcpy(str, "err");
+                       COPY_STR(str, "err", strlen("err"));
                        break;
                }
        } else if (type == "symbol") {
                switch (num) {
                case 1:
-                       strcpy(str, "I18N_UNUMBER_DECIMAL_SEPARATOR_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_DECIMAL_SEPARATOR_SYMBOL", strlen("I18N_UNUMBER_DECIMAL_SEPARATOR_SYMBOL"));
                        break;
                case 2:
-                       strcpy(str, "I18N_UNUMBER_GROUPING_SEPARATOR_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_GROUPING_SEPARATOR_SYMBOL", strlen("I18N_UNUMBER_GROUPING_SEPARATOR_SYMBOL"));
                        break;
                case 3:
-                       strcpy(str, "I18N_UNUMBER_PATTERN_SEPARATOR_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_PATTERN_SEPARATOR_SYMBOL", strlen("I18N_UNUMBER_PATTERN_SEPARATOR_SYMBOL"));
                        break;
                case 4:
-                       strcpy(str, "I18N_UNUMBER_PERCENT_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_PERCENT_SYMBOL", strlen("I18N_UNUMBER_PERCENT_SYMBOL"));
                        break;
                case 5:
-                       strcpy(str, "I18N_UNUMBER_ZERO_DIGIT_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_ZERO_DIGIT_SYMBOL", strlen("I18N_UNUMBER_ZERO_DIGIT_SYMBOL"));
                        break;
                case 6:
-                       strcpy(str, "I18N_UNUMBER_DIGIT_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_DIGIT_SYMBOL", strlen("I18N_UNUMBER_DIGIT_SYMBOL"));
                        break;
                case 7:
-                       strcpy(str, "I18N_UNUMBER_MINUS_SIGN_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_MINUS_SIGN_SYMBOL", strlen("I18N_UNUMBER_MINUS_SIGN_SYMBOL"));
                        break;
                case 8:
-                       strcpy(str, "I18N_UNUMBER_PLUS_SIGN_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_PLUS_SIGN_SYMBOL", strlen("I18N_UNUMBER_PLUS_SIGN_SYMBOL"));
                        break;
                case 9:
-                       strcpy(str, "I18N_UNUMBER_CURRENCY_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_CURRENCY_SYMBOL", strlen("I18N_UNUMBER_CURRENCY_SYMBOL"));
                        break;
                case 10:
-                       strcpy(str, "I18N_UNUMBER_INTL_CURRENCY_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_INTL_CURRENCY_SYMBOL", strlen("I18N_UNUMBER_INTL_CURRENCY_SYMBOL"));
                        break;
                case 11:
-                       strcpy(str, "I18N_UNUMBER_MONETARY_SEPARATOR_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_MONETARY_SEPARATOR_SYMBOL", strlen("I18N_UNUMBER_MONETARY_SEPARATOR_SYMBOL"));
                        break;
                case 12:
-                       strcpy(str, "I18N_UNUMBER_EXPONENTIAL_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_EXPONENTIAL_SYMBOL", strlen("I18N_UNUMBER_EXPONENTIAL_SYMBOL"));
                        break;
                case 13:
-                       strcpy(str, "I18N_UNUMBER_PERMILL_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_PERMILL_SYMBOL", strlen("I18N_UNUMBER_PERMILL_SYMBOL"));
                        break;
                case 14:
-                       strcpy(str, "I18N_UNUMBER_PAD_ESCAPE_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_PAD_ESCAPE_SYMBOL", strlen("I18N_UNUMBER_PAD_ESCAPE_SYMBOL"));
                        break;
                case 15:
-                       strcpy(str, "I18N_UNUMBER_INFINITY_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_INFINITY_SYMBOL", strlen("I18N_UNUMBER_INFINITY_SYMBOL"));
                        break;
                case 16:
-                       strcpy(str, "I18N_UNUMBER_NAN_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_NAN_SYMBOL", strlen("I18N_UNUMBER_NAN_SYMBOL"));
                        break;
                case 17:
-                       strcpy(str, "I18N_UNUMBER_SIGNIFICANT_DIGIT_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_SIGNIFICANT_DIGIT_SYMBOL", strlen("I18N_UNUMBER_SIGNIFICANT_DIGIT_SYMBOL"));
                        break;
                case 18:
-                       strcpy(str, "I18N_UNUMBER_MONETARY_GROUPING_SEPARATOR_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_MONETARY_GROUPING_SEPARATOR_SYMBOL", strlen("I18N_UNUMBER_MONETARY_GROUPING_SEPARATOR_SYMBOL"));
                        break;
                case 19:
-                       strcpy(str, "I18N_UNUMBER_ONE_DIGIT_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_ONE_DIGIT_SYMBOL", strlen("I18N_UNUMBER_ONE_DIGIT_SYMBOL"));
                        break;
                case 20:
-                       strcpy(str, "I18N_UNUMBER_TWO_DIGIT_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_TWO_DIGIT_SYMBOL", strlen("I18N_UNUMBER_TWO_DIGIT_SYMBOL"));
                        break;
                case 21:
-                       strcpy(str, "I18N_UNUMBER_THREE_DIGIT_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_THREE_DIGIT_SYMBOL", strlen("I18N_UNUMBER_THREE_DIGIT_SYMBOL"));
                        break;
                case 22:
-                       strcpy(str, "I18N_UNUMBER_FOUR_DIGIT_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_FOUR_DIGIT_SYMBOL", strlen("I18N_UNUMBER_FOUR_DIGIT_SYMBOL"));
                        break;
                case 23:
-                       strcpy(str, "I18N_UNUMBER_FIVE_DIGIT_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_FIVE_DIGIT_SYMBOL", strlen("I18N_UNUMBER_FIVE_DIGIT_SYMBOL"));
                        break;
                case 24:
-                       strcpy(str, "I18N_UNUMBER_SIX_DIGIT_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_SIX_DIGIT_SYMBOL", strlen("I18N_UNUMBER_SIX_DIGIT_SYMBOL"));
                        break;
                case 25:
-                       strcpy(str, "I18N_UNUMBER_SEVEN_DIGIT_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_SEVEN_DIGIT_SYMBOL", strlen("I18N_UNUMBER_SEVEN_DIGIT_SYMBOL"));
                        break;
                case 26:
-                       strcpy(str, "I18N_UNUMBER_EIGHT_DIGIT_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_EIGHT_DIGIT_SYMBOL", strlen("I18N_UNUMBER_EIGHT_DIGIT_SYMBOL"));
                        break;
                case 27:
-                       strcpy(str, "I18N_UNUMBER_NINE_DIGIT_SYMBOL");
+                       COPY_STR(str, "I18N_UNUMBER_NINE_DIGIT_SYMBOL", strlen("I18N_UNUMBER_NINE_DIGIT_SYMBOL"));
                        break;
                default:
-                       strcpy(str, "err");
+                       COPY_STR(str, "err", strlen("err"));
                        break;
                }
        } else if (type == "iter_type") {
                switch (num) {
                case 0:
-                       strcpy(str, "I18N_UBRK_CHARACTER");
+                       COPY_STR(str, "I18N_UBRK_CHARACTER", strlen("I18N_UBRK_CHARACTER"));
                        break;
                case 1:
-                       strcpy(str, "I18N_UBRK_WORD");
+                       COPY_STR(str, "I18N_UBRK_WORD", strlen("I18N_UBRK_WORD"));
                        break;
                case 2:
-                       strcpy(str, "I18N_UBRK_LINE");
+                       COPY_STR(str, "I18N_UBRK_LINE", strlen("I18N_UBRK_LINE"));
                        break;
                case 3:
-                       strcpy(str, "I18N_UBRK_SENTENCE");
+                       COPY_STR(str, "I18N_UBRK_SENTENCE", strlen("I18N_UBRK_SENTENCE"));
                        break;
                default:
-                       strcpy(str, "err");
+                       COPY_STR(str, "err", strlen("err"));
                        break;
                }
        }
@@ -334,7 +340,13 @@ static int __get_date_and_time()
 
                        char s[BUF_SIZE];
                        i18n_ustring_copy_au(s, result);
-                       printf("TIME[%-17.17s] DATE[%-26.26s] : %s\n", __print_i18n_type_string("time", n_enum_time_counter), __print_i18n_type_string("date", n_enum_date_counter), s);
+                       free(result);
+                       char *time_str, *date_str;
+                       time_str = __print_i18n_type_string("time", n_enum_time_counter);
+                       date_str = __print_i18n_type_string("date", n_enum_date_counter);
+                       printf("TIME[%-17.17s] DATE[%-26.26s] : %s\n", time_str, date_str, s);
+                       free(time_str);
+                       free(date_str);
                }
        }
        return 0;
@@ -363,12 +375,17 @@ static int __get_number_format(char *input_number)
                char string[BUF_SIZE];
                i18n_ustring_copy_au(string, formatted_number);
 
-               printf("NUMBER_FORMAT[%-30.30s] : %s\n", __print_i18n_type_string("number_format", i), string);
+               char *number_str;
+               number_str = __print_i18n_type_string("number_format", i);
+               printf("NUMBER_FORMAT[%-30.30s] : %s\n", number_str, string);
+               free(number_str);
        }
 
        /* Release the decimal number formatter. */
        error_code = i18n_unumber_destroy(num_format);
        CHECK_ERROR("i18n_unumber_destroy", error_code);
+
+       return 0;
 }
 
 static int __get_symbol()
@@ -391,12 +408,18 @@ static int __get_symbol()
                /* Display the formatted symbol. */
                char string[BUF_SIZE];
                i18n_ustring_copy_au(string, u_buffer);
-               printf("SYMBOL[%-47.47s] : %s\n", __print_i18n_type_string("symbol", i+1), string);
+
+               char *symbol_str;
+               symbol_str = __print_i18n_type_string("symbol", i+1);
+               printf("SYMBOL[%-47.47s] : %s\n", symbol_str, string);
+               free(symbol_str);
        }
 
        /* Release the default number formatter object. */
        error_code = i18n_unumber_destroy(num_format);
        CHECK_ERROR("i18n_unumber_destroy", error_code);
+
+       return 0;
 }
 
 static const char *layout_orientation_converter(i18n_ulocale_layout_type_e type)
@@ -477,6 +500,8 @@ static int __get_language_info()
        error_code = i18n_ulocale_get_variant(default_locale, variant, BUF_SIZE);
        CHECK_ERROR("i18n_ulocale_get_variant", error_code);
        printf("variant code: %s\n", variant);
+
+       return 0;
 }
 
 static int __manage_string_iteration(char *input_string)
@@ -495,7 +520,7 @@ static int __manage_string_iteration(char *input_string)
                i18n_ustring_copy_ua(string_to_examine, input_text);
        } else {
                char input_text[1000] = {0,};
-               strncpy(input_text, input_string, 999);
+               COPY_STR(input_text, input_string, 999);
                printf("Input string : %s\n", input_text);
                string_to_examine =
                        (i18n_uchar *) malloc(sizeof(i18n_uchar) * (strlen(input_text) + 1));
@@ -503,6 +528,7 @@ static int __manage_string_iteration(char *input_string)
        }
 
        int i;
+       char *iter_type;
 
        /* Displays the first element in the given text */
        for (i = 0; i <= I18N_UBRK_SENTENCE; i++) {
@@ -515,7 +541,10 @@ static int __manage_string_iteration(char *input_string)
                i18n_ustring_copy_n(result, &string_to_examine[start], end-start);
                char str[BUF_SIZE];
                i18n_ustring_copy_au(str, result);
-               printf("ITER First element[%-19.19s] : %s\n",  __print_i18n_type_string("iter_type", i), str);
+               free(result);
+
+               iter_type =  __print_i18n_type_string("iter_type", i);
+               printf("ITER First element[%-19.19s] : %s\n", iter_type, str);
        }
 
        /* Displays the last element in the given text */
@@ -529,12 +558,18 @@ static int __manage_string_iteration(char *input_string)
                i18n_ustring_copy_n(result, &string_to_examine[start], end-start);
                char str[BUF_SIZE];
                i18n_ustring_copy_au(str, result);
-               printf("ITER Last  element[%-19.19s] : %s\n",  __print_i18n_type_string("iter_type", i), str);
+               free(result);
+
+               iter_type =  __print_i18n_type_string("iter_type", i);
+               printf("ITER Last  element[%-19.19s] : %s\n", iter_type, str);
        }
 
+       free(iter_type);
        free(string_to_examine);
        error_code = i18n_ubrk_destroy(boundary);
        CHECK_ERROR("i18n_ubrk_destroy", error_code);
+
+       return 0;
 }
 
 static int __analyze_string(char *custom_string)
@@ -584,6 +619,7 @@ static int __analyze_string(char *custom_string)
        i18n_ustring_copy_au(s, dest);
        printf("To Title : %s\n", s);
 
+       return 0;
 }
 
 static int __get_timezone_info()
@@ -643,17 +679,24 @@ static int __get_timezone_info()
        /* Release the time zone object. */
        error_code = i18n_timezone_destroy(tmz);
        CHECK_ERROR("i18n_timezone_destroy", error_code);
+       free(timezone_id);
+
+       return 0;
+
 }
 
 static int __get_tzdata_version()
 {
        const char *ver = i18n_timezone_get_tzdata_version();
        printf("tzdata version : %s\n", ver);
+
+       return 0;
+
 }
 
 void allTest()
 {
-       int ret, i = 0;
+       int ret = 0, i = 0;
        int loc_count;
 
        loc_count = i18n_ulocale_count_available();
@@ -687,7 +730,7 @@ void showAllLocale()
 
 void showLangInfo(char *locale)
 {
-       int ret, i = 0;
+       int ret = 0, i = 0;
        int loc_count;
 
        if (!locale) {
@@ -726,7 +769,7 @@ void showTzdataVersion()
 
 void testDatentime(char *locale)
 {
-       int ret, i = 0;
+       int ret = 0,  i = 0;
        int loc_count;
 
        if (!locale) {
@@ -752,7 +795,7 @@ void testDatentime(char *locale)
 
 void testNumberFormat(char *input, char *locale)
 {
-       int ret, i = 0;
+       int ret = 0, i = 0;
        int loc_count;
 
        if (!input) {
@@ -781,7 +824,7 @@ void testNumberFormat(char *input, char *locale)
 
 void testNumberSymbol(char *locale)
 {
-       int ret, i = 0;
+       int ret = 0, i = 0;
        int loc_count;
 
        if (!locale) {

diff --git a/src/include/utils_i18n_private.h b/src/include/utils_i18n_private.h
index 692c2dd10952a3e36103d8f5afeed77ab7cf028a..c7c1172b671a8bd382dd4c766f61f6e516d924ad 100644 (file)
--- a/src/include/utils_i18n_private.h
+++ b/src/include/utils_i18n_private.h
@@ -85,6 +85,10 @@ extern "C" {
 
 #define ERR_MAPPING(ICU_ERROR, BASE_UTILS_ERROR) BASE_UTILS_ERROR = \
                                                                                                                                        (i18n_error_code_e)_i18n_error_mapping((int)ICU_ERROR)
+#define COPY_STR(dst, src, dst_len) do {            \
+                   strncpy((dst), (src), (dst_len));       \
+                   (dst)[(dst_len) - 1] = '\0';            \
+} while (0)
 
 int _i18n_error_mapping(int err);
 int _i18n_error_mapping_reverse(int err);

diff --git a/src/utils_i18n_ubidi.c b/src/utils_i18n_ubidi.c
index 806f0c32209d47cdd0dae1eafcfbdd0e34ccd373..95c9af4c5ddad6a05088b2593ff894f4fba00ef1 100644 (file)
--- a/src/utils_i18n_ubidi.c
+++ b/src/utils_i18n_ubidi.c
@@ -273,7 +273,7 @@ int i18n_ubidi_get_text(const i18n_ubidi_h ubidi, char **text)
        retv_if(*text == NULL, I18N_ERROR_OUT_OF_MEMORY);
        memset(*text, 0x0, len+1);
 
-       strncpy(*text, _text, len);
+       COPY_STR(*text, _text, len);
 
        return I18N_ERROR_NONE;
 }