int git_buf_put_w(git_buf *buf, const wchar_t *string_w, size_t len_w) { int utf8_len, utf8_write_len; size_t new_size; if (!len_w) return 0; assert(string_w); /* Measure the string necessary for conversion */ if ((utf8_len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, string_w, len_w, NULL, 0, NULL, NULL)) == 0) return 0; assert(utf8_len > 0); GITERR_CHECK_ALLOC_ADD(&new_size, buf->size, (size_t)utf8_len); GITERR_CHECK_ALLOC_ADD(&new_size, new_size, 1); if (git_buf_grow(buf, new_size) < 0) return -1; if ((utf8_write_len = WideCharToMultiByte( CP_UTF8, WC_ERR_INVALID_CHARS, string_w, len_w, &buf->ptr[buf->size], utf8_len, NULL, NULL)) == 0) return handle_wc_error(); assert(utf8_write_len == utf8_len); buf->size += utf8_write_len; buf->ptr[buf->size] = '\0'; return 0; }
/** * NAME * wcsncat_s * * SYNOPSIS * #include "safe_str_lib.h" * errno_t * wcsncat_s(wchar_t *dest, rsize_t dmax, const wchar_t *src, rsize_t slen) * * DESCRIPTION * The wcsncat_s function appends a copy of (at most) the * first slen wide characters pointed to by src to the * end of the string pointed to by dest and terminates the * string with the null character. If less than slen wide * characters are in the string src, the function stops * copying after the null terminator is copied to dest. * The initial character from src overwrites the null * character at the end of dest. * * All elements following the terminating null character (if * any) written by strncat_s in the array of dmax characters * pointed to by dest take unspecified values when strncat_s returns. * * SPECIFIED IN * ISO/IEC TR 24731, Programming languages, environments * and system software interfaces, Extensions to the C Library, * Part I: Bounds-checking interfaces * * INPUT PARAMETERS * dest pointer to string that will be extended by src * if dmax allows. The string is null terminated. * If the resulting concatenated string is less * than dmax, the remaining slack space is nulled. * * dmax restricted maximum length of the resulting dest, * including the null * * src pointer to the string that will be concatenaed * to string dest * * slen maximum characters to append * * OUTPUT PARAMETERS * dest updated string * * RUNTIME CONSTRAINTS * Neither dest nor src shall be a null pointer * dmax shall not equal zero * dmax shall not be greater than RSIZE_STR_MAX * dmax shall be greater than strnlen_s(src,m). * Copying shall not takeplace between objects that overlap * If there is a runtime-constraint violation, then if dest is * not a null pointer and dmax is greater than zero and not * greater thanRSIZE_MAX, then strncat_s sets dest[0] to the * null character. * * RETURN VALUE * EOK successful operation, all the characters from src * were appended to dest and the result in dest is * null terminated. * ESNULLP NULL pointer * ESZEROL zero length * ESLEMAX length exceeds max limit * ESUNTERM dest not terminated * * */ errno_t wcsncat_s (wchar_t *dest, rsize_t dmax, const wchar_t *src, rsize_t slen) { rsize_t orig_dmax; wchar_t *orig_dest; const wchar_t *overlap_bumper; if (dest == NULL) { invoke_safe_str_constraint_handler("wcsncat_s: dest is null", NULL, ESNULLP); return RCNEGATE(ESNULLP); } if (src == NULL) { invoke_safe_str_constraint_handler("wcsncat_s: src is null", NULL, ESNULLP); return RCNEGATE(ESNULLP); } if (slen*sizeof(wchar_t) > RSIZE_MAX_STR) { invoke_safe_str_constraint_handler("wcsncat_s: slen exceeds max", NULL, ESLEMAX); return RCNEGATE(ESLEMAX); } if (dmax == 0) { invoke_safe_str_constraint_handler("wcsncat_s: dmax is 0", NULL, ESZEROL); return RCNEGATE(ESZEROL); } if (dmax*sizeof(wchar_t) > RSIZE_MAX_STR) { invoke_safe_str_constraint_handler("wcsncat_s: dmax exceeds max", NULL, ESLEMAX); return RCNEGATE(ESLEMAX); } /* hold base of dest in case src was not copied */ orig_dmax = dmax; orig_dest = dest; if (dest < src) { overlap_bumper = src; /* Find the end of dest */ while (*dest != L'\0') { if (dest == overlap_bumper) { handle_wc_error(orig_dest, orig_dmax, "wcsncat_s: " "overlapping objects", ESOVRLP); return RCNEGATE(ESOVRLP); } dest++; dmax--; if (dmax == 0) { handle_wc_error(orig_dest, orig_dmax, "wcsncat_s: " "dest unterminated", ESUNTERM); return RCNEGATE(ESUNTERM); } } while (dmax > 0) { if (dest == overlap_bumper) { handle_wc_error(orig_dest, orig_dmax, "wcsncat_s: " "overlapping objects", ESOVRLP); return RCNEGATE(ESOVRLP); } /* * Copying truncated before the source null is encountered */ /* TODO: test if this copies at most slen characters including NULL */ if (slen == 0) { #ifdef SAFECLIB_STR_NULL_SLACK /* null remaining string */ while (dmax) { *dest = L'\0'; dmax--; dest++; } #else *dest = L'\0'; #endif return RCNEGATE(EOK); } *dest = *src; if (*dest == L'\0') { #ifdef SAFECLIB_STR_NULL_SLACK /* null slack to clear data */ while (dmax) { *dest = L'\0'; dmax--; dest++; } #endif return RCNEGATE(EOK); } dmax--; slen--; dest++; src++; } } else { overlap_bumper = dest; /* Find the end of dest */ while (*dest != L'\0') { /* * NOTE: no need to check for overlap here since src comes first * in memory and we're not incrementing src here. */ dest++; dmax--; if (dmax == 0) { handle_wc_error(orig_dest, orig_dmax, "wcsncat_s: " "dest unterminated", ESUNTERM); return RCNEGATE(ESUNTERM); } } while (dmax > 0) { if (src == overlap_bumper) { handle_wc_error(orig_dest, orig_dmax, "wcsncat_s: " "overlapping objects", ESOVRLP); return RCNEGATE(ESOVRLP); } /* * Copying truncated */ if (slen == 0) { #ifdef SAFECLIB_STR_NULL_SLACK /* null remaining string */ while (dmax) { *dest = L'\0'; dmax--; dest++; } #else *dest = L'\0'; #endif return RCNEGATE(EOK); } *dest = *src; if (*dest == L'\0') { #ifdef SAFECLIB_STR_NULL_SLACK /* null slack to clear any data */ while (dmax) { *dest = L'\0'; dmax--; dest++; } #endif return RCNEGATE(EOK); } dmax--; slen--; dest++; src++; } } /* * the entire src was not copied, so the string will be nulled. */ handle_wc_error(orig_dest, orig_dmax, "wcsncat_s: not enough space for src", ESNOSPC); return RCNEGATE(ESNOSPC); }