static int
do_test (void)
{
unsigned char buf[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
const unsigned char bufcheck[6] = { 0x25, 0xe2, 0x82, 0xac, 0xce, 0xbb };
const wchar_t srcbuf[4] = { 0x25, 0x20ac, 0x03bb, 0 };
mbstate_t state;
const wchar_t *src;
char *dst;
int result = 0;
const char *used_locale;
setlocale (LC_CTYPE, "de_DE.UTF-8");
/* Double check. */
used_locale = setlocale (LC_CTYPE, NULL);
printf ("used locale: \"%s\"\n", used_locale);
result = strcmp (used_locale, "de_DE.UTF-8");
memset (&state, '\0', sizeof (state));
src = srcbuf;
dst = (char *) buf;
show (wcsrtombs (dst, &src, 1, &state), 1, srcbuf + 1, buf + 1);
show (wcsrtombs (dst, &src, 1, &state), 0, srcbuf + 1, buf + 1);
show (wcsrtombs (dst, &src, 4, &state), 3, srcbuf + 2, buf + 4);
show (wcsrtombs (dst, &src, 2, &state), 2, srcbuf + 3, buf + 6);
if (memcmp (buf, bufcheck, 6))
{
puts ("wrong results");
result = 1;
}
return result;
}
std::string wstring_to_string(const std::wstring & s)
{
const wchar_t *wcs = s.c_str();
std::size_t len = wcsrtombs(NULL, &wcs, 0, NULL);
if (len != (size_t) -1)
{
char *dest = new char[len + 1];
if (dest)
{
mbstate_t state;
memset(&state, 0, sizeof state);
wcs = s.c_str();
len = wcsrtombs(dest, &wcs, len, &state);
if (len != (size_t) -1)
{
dest[len] = '\0';
std::string result(dest);
delete [] dest;
return result;
}
delete [] dest;
}
}
// conversion error try something stupid
return std::string(s.begin(), s.end());
}
void StringConverter::ToSingle (const wstring &wstr, string &str, bool noThrow)
{
try
{
mbstate_t mbState;
Memory::Zero (&mbState, sizeof (mbState));
const wchar_t *src = wstr.c_str();
size_t size = wcsrtombs (nullptr, &src, 0, &mbState);
if (size == (size_t) -1)
throw StringConversionFailed (SRC_POS, wstr);
vector <char> buf (size + 1);
Memory::Zero (&mbState, sizeof (mbState));
if ((size = wcsrtombs (&buf[0], &src, buf.size(), &mbState)) == (size_t) -1)
throw StringConversionFailed (SRC_POS, wstr);
str.clear();
str.insert (0, &buf.front(), size);
Memory::Erase (&buf.front(), buf.size());
}
catch (...)
{
if (!noThrow)
throw;
}
}
slk_wset(int i, const wchar_t *astr, int format)
{
int result = ERR;
size_t arglen;
const wchar_t *str;
char *mystr;
mbstate_t state;
T((T_CALLED("slk_wset(%d, %s, %d)"), i, _nc_viswbuf(astr), format));
init_mb(state);
str = astr;
if ((arglen = wcsrtombs(NULL, &str, 0, &state)) != (size_t) -1) {
if ((mystr = (char *) _nc_doalloc(0, arglen + 1)) != 0) {
str = astr;
if (wcsrtombs(mystr, &str, arglen, &state) != (size_t) -1) {
/* glibc documentation claims that the terminating L'\0'
* is written, but it is not...
*/
mystr[arglen] = 0;
result = slk_set(i, mystr, format);
}
free(mystr);
}
}
returnCode(result);
}
std::string ws2s(const std::wstring& wstr)
{
#ifdef CSIM_HAVE_STD_CODECVT
typedef std::codecvt_utf8<wchar_t> convert_typeX;
std::wstring_convert<convert_typeX, wchar_t> converterX;
return converterX.to_bytes(wstr);
#else
std::string ss;
if (wstr.length() > 0)
{
const wchar_t* sp = wstr.c_str();
size_t len = wcsrtombs(NULL,&sp,0,NULL);
if (len > 0)
{
len++;
char* s = (char*)malloc(len);
wcsrtombs(s,&sp,len,NULL);
ss = std::string(s);
free(s);
return(ss);
}
}
return(ss);
#endif
}
/*
* Convert a wide character string argument for the %ls format to a multibyte
* string representation. If not -1, prec specifies the maximum number of
* bytes to output, and also means that we can't assume that the wide char
* string is null-terminated.
*/
static char *
__wcsconv(wchar_t *wcsarg, int prec)
{
mbstate_t mbs;
char buf[MB_LEN_MAX];
wchar_t *p;
char *convbuf;
size_t clen, nbytes;
/* Allocate space for the maximum number of bytes we could output. */
if (prec < 0) {
memset(&mbs, 0, sizeof(mbs));
p = wcsarg;
nbytes = wcsrtombs(NULL, (const wchar_t **)&p, 0, &mbs);
if (nbytes == (size_t)-1) {
errno = EILSEQ;
return (NULL);
}
} else {
/*
* Optimisation: if the output precision is small enough,
* just allocate enough memory for the maximum instead of
* scanning the string.
*/
if (prec < 128)
nbytes = prec;
else {
nbytes = 0;
p = wcsarg;
memset(&mbs, 0, sizeof(mbs));
for (;;) {
clen = wcrtomb(buf, *p++, &mbs);
if (clen == 0 || clen == (size_t)-1 ||
nbytes + clen > (size_t)prec)
break;
nbytes += clen;
}
if (clen == (size_t)-1) {
errno = EILSEQ;
return (NULL);
}
}
}
if ((convbuf = malloc(nbytes + 1)) == NULL)
return (NULL);
/* Fill the output buffer. */
p = wcsarg;
memset(&mbs, 0, sizeof(mbs));
if ((nbytes = wcsrtombs(convbuf, (const wchar_t **)&p,
nbytes, &mbs)) == (size_t)-1) {
free(convbuf);
errno = EILSEQ;
return (NULL);
}
convbuf[nbytes] = '\0';
return (convbuf);
}
str
wide_str_t::to_utf8 () const
{
static size_t utf8_char_width = 6;
str ret;
if (!_buf) { /*noop */ }
else if (_len == 0) { ret = ""; }
else {
mbstate_t state;
memset (&state, 0, sizeof (state));
size_t len = _len * utf8_char_width;
mstr m (len);
const wchar_t *in = _buf->base ();
ssize_t nbytes = wcsrtombs (m.cstr (), &in, len, &state);
if (nbytes >= 0) {
// should have consumed all bytes; if not '6' above is wrong!!
assert (!in);
m.setlen (nbytes);
ret = m;
}
}
return ret;
}
size_t
rpl_wcsrtombs (char *dest, const wchar_t **srcp, size_t len, mbstate_t *ps)
{
if (ps == NULL)
ps = &_gl_wcsrtombs_state;
# if WCSRTOMBS_NULL_ARG_BUG
if (dest == NULL)
{
const wchar_t *temp_src = *srcp;
return wcsrtombs (NULL, &temp_src, len, ps);
}
else
# endif
return wcsrtombs (dest, srcp, len, ps);
}
void
test_wcsrtombs_negative(void)
{
mbstate_t ms;
const wchar_t *wcs;
char mbs[32];
char *dst;
int e;
wchar_t src[32] = BAD_WCS;
test_t t;
int cnt;
t = test_start("wcsrtombs_negative");
(void) memset(&ms, 0, sizeof (ms));
if (setlocale(LC_ALL, "ru_RU.UTF-8") == NULL) {
test_failed(t, "setlocale failed: %s", strerror(errno));
}
wcs = src;
dst = mbs;
cnt = wcsrtombs(dst, &wcs, sizeof (mbs), &ms);
if (cnt != -1) {
test_failed(t, "bogus success (%d)", cnt);
}
if ((e = errno) != EILSEQ) {
test_failed(t, "wrong errno, wanted %d (EILSEQ), got %d: %s",
EILSEQ, e, strerror(e));
}
test_passed(t);
}
void
test_wcsrtombs_partial(void)
{
test_t t;
mbstate_t ms;
wchar_t src[32] = HELLO_RU_WCS;
char mbs[32];
char *dst;
const wchar_t *wcs;
size_t cnt;
(void) memset(&ms, 0, sizeof (ms));
t = test_start("wcsrtombs_partial");
if (setlocale(LC_ALL, "ru_RU.UTF-8") == NULL) {
test_failed(t, "setlocale failed: %s", strerror(errno));
}
wcs = src;
dst = mbs;
cnt = wcsrtombs(dst, &wcs, 1, &ms);
if (cnt != 0) {
test_failed(t, "gave back a conversion cnt %d != 0", cnt);
}
if (wcs != src) {
test_failed(t, "incorrectly advanced wcs");
}
cnt = wcsrtombs(dst, &wcs, 2, &ms);
if (cnt != 2) {
test_failed(t, "gave back a conversion cnt %d != 2", cnt);
}
dst += cnt;
cnt = wcsrtombs(dst, &wcs, 4, &ms);
dst += cnt;
cnt = wcsrtombs(dst, &wcs, sizeof (mbs) - strlen(mbs), &ms);
if (extra_debug) {
test_debugf(t, "mbs is %s", mbs);
}
if (strcmp(mbs, HELLO_RU_MBS) != 0) {
test_failed(t, "wrong result: %s != %s", mbs, HELLO_RU_MBS);
}
test_passed(t);
}
std::string wstring2string(const wchar_t* str)
{
if (str)
{
size_t len = wcsrtombs(NULL,&str,0,NULL);
if (len > 0)
{
len++;
char* s = (char*)malloc(len);
wcsrtombs(s,&str,len,NULL);
std::string st = std::string(s);
free(s);
return(st);
}
}
return("");
}
static char *
__mbsdup(const wchar_t *ws)
{
static const mbstate_t initial;
mbstate_t st;
const wchar_t *wcp;
size_t len;
char *mbs;
wcp = ws;
st = initial;
if ((len = wcsrtombs(NULL, &wcp, 0, &st)) == (size_t)-1)
return (NULL);
if ((mbs = malloc(len + 1)) == NULL)
return (NULL);
st = initial;
wcsrtombs(mbs, &ws, len + 1, &st);
return (mbs);
}
char *wc2c(wchar_t *wc, int doFree) {
const wchar_t *wc2 = wc;
size_t clen = wcslen(wc) * 4;
if (clen < 32) clen = 32;
char *cret = (char*)malloc(clen);
if (wcsrtombs (cret, &wc2, clen, NULL) == -1) {
strcpy(cret, "[wide character conversion failed]");
}
if (doFree) free(wc);
return cret;
}
char* ModuleTCharToMbDup(const wchar_t* str)
{
int len = ModuleMbByteLen(str);
char* mbstr = (char*) malloc((len + 1) * sizeof(char));
if (mbstr)
{
wcsrtombs(mbstr, &str, len + 1, NULL);
return mbstr;
}
return NULL;
}
size_t
wcstombs(
char *s,
const wchar_t *pwcs,
size_t n
)
{
/* s may be NULL */
/* pwcs may be NULL */
return wcsrtombs(s, &pwcs, n, NULL);
}
_nc_wcrtomb(char *target, wchar_t source, mbstate_t * state)
{
int result;
if (target == 0) {
wchar_t temp[2];
const wchar_t *tempp = temp;
temp[0] = source;
temp[1] = 0;
result = (int) wcsrtombs(NULL, &tempp, 0, state);
} else {
result = (int) wcrtomb(target, source, state);
}
if (!isEILSEQ(result) && (result == 0))
result = 1;
return (size_t) result;
}
bool WideToChar(const wchar *Src,char *Dest,size_t DestSize)
{
bool RetCode=true;
*Dest=0; // Set 'Dest' to zero just in case the conversion will fail.
#ifdef _WIN_ALL
if (WideCharToMultiByte(CP_ACP,0,Src,-1,Dest,(int)DestSize,NULL,NULL)==0)
RetCode=false;
// wcstombs is broken in Android NDK r9.
#elif defined(_APPLE) || defined(_ANDROID)
WideToUtf(Src,Dest,DestSize);
#elif defined(MBFUNCTIONS)
if (!WideToCharMap(Src,Dest,DestSize,RetCode))
{
mbstate_t ps; // Use thread safe external state based functions.
memset (&ps, 0, sizeof(ps));
const wchar *SrcParam=Src; // wcsrtombs can change the pointer.
size_t ResultingSize=wcsrtombs(Dest,&SrcParam,DestSize,&ps);
if (ResultingSize==(size_t)-1)
RetCode=false;
if (ResultingSize==0 && *Src!=0)
RetCode=false;
}
#else
for (int I=0;I<DestSize;I++)
{
Dest[I]=(char)Src[I];
if (Src[I]==0)
break;
}
#endif
if (DestSize>0)
Dest[DestSize-1]=0;
// We tried to return the empty string if conversion is failed,
// but it does not work well. WideCharToMultiByte returns 'failed' code
// and partially converted string even if we wanted to convert only a part
// of string and passed DestSize smaller than required for fully converted
// string. Such call is the valid behavior in RAR code and we do not expect
// the empty string in this case.
return RetCode;
}
char *lineedit_get_text(void)
{
size_t wide_len, multibyte_max_len;
mbstate_t state;
wchar_t **p_wide_string = &(l.buf);
char *padded_multibyte_string = NULL;
char *multibyte_string = NULL;
memset(&state, '\0', sizeof (state));
wide_len = wcslen(l.buf);
multibyte_max_len = wide_len * 4 + 1;
padded_multibyte_string = (char *) calloc(multibyte_max_len, sizeof(char));
wcsrtombs (padded_multibyte_string, (const wchar_t **) p_wide_string, multibyte_max_len, &state);
multibyte_string = strdup(padded_multibyte_string);
free(padded_multibyte_string);
return multibyte_string;
}
void main()
{
int i;
size_t elements;
const wchar_t *src;
char mb[50];
mbstate_t pstate;
_setmbcp( 932 );
src = wc;
elements = wcsrtombs( mb, &src, 50, &pstate );
if( errno == EILSEQ ) {
printf( "Error in wide character string\n" );
} else {
for( i = 0; i < elements; i++ ) {
printf( "0x%2.2x\n", mb[i] );
}
}
}
int vswprintf(wchar_t* wcs, size_t maxlen, const wchar_t* fmt, va_list ap) {
mbstate_t mbstate;
memset(&mbstate, 0, sizeof(mbstate));
// At most, each wide character (UTF-32) can be expanded to four narrow
// characters (UTF-8).
const size_t max_mb_len = maxlen * 4;
const size_t mb_fmt_len = wcslen(fmt) * 4 + 1;
UniquePtr<char[]> mbfmt(new char[mb_fmt_len]);
if (wcsrtombs(mbfmt.get(), &fmt, mb_fmt_len, &mbstate) == MBS_FAILURE) {
return -1;
}
UniquePtr<char[]> mbs(new char[max_mb_len]);
int nprinted = vsnprintf(mbs.get(), max_mb_len, mbfmt.get(), ap);
if (nprinted == -1) {
return -1;
}
const char* mbsp = mbs.get();
if (mbsrtowcs(wcs, &mbsp, maxlen, &mbstate) == MBS_FAILURE) {
return -1;
}
// Can't use return value from vsnprintf because that number is in narrow
// characters, not wide characters.
int result = wcslen(wcs);
// swprintf differs from snprintf in that it returns -1 if the output was
// truncated.
//
// Truncation can occur in two places:
// 1) vsnprintf truncated, in which case the return value is greater than the
// length we passed.
// 2) Since the char buffer we pass to vsnprintf might be oversized, that
// might not truncate while mbsrtowcs will. In this case, mbsp will point
// to the next unconverted character instead of nullptr.
if (nprinted >= max_mb_len || mbsp != nullptr) {
return -1;
}
return result;
}
static size_t wstring_read(FILE *f, unsigned char *buf, size_t len)
{
const wchar_t *src = f->cookie;
size_t k;
if (!src) return 0;
k = wcsrtombs((void *)f->buf, &src, f->buf_size, 0);
if (k==(size_t)-1) {
f->rpos = f->rend = 0;
return 0;
}
f->rpos = f->buf;
f->rend = f->buf + k;
f->cookie = (void *)src;
if (!len || !k) return 0;
*buf = *f->rpos++;
return 1;
}
void
test_wcsrtombs_1(const char *locale, struct wcsrtombs_test *test)
{
test_t t;
char *v;
mbstate_t ms;
t = test_start("wcsrtombs (locale %s)", locale);
v = setlocale(LC_ALL, locale);
if (v == NULL) {
test_failed(t, "setlocale failed: %s", strerror(errno));
}
if (strcmp(v, locale) != 0) {
test_failed(t, "setlocale got %s instead of %s", v, locale);
}
for (int i = 0; test[i].mbs[0] != 0; i++) {
char mbs[32];
const wchar_t *wcs = test[i].wcs;
size_t cnt;
(void) memset(&ms, 0, sizeof (ms));
(void) memset(mbs, 0, sizeof (mbs));
cnt = wcsrtombs(mbs, &wcs, sizeof (mbs), &ms);
if (cnt != strlen(test[i].mbs)) {
test_failed(t, "incorrect return value: %d != %d",
cnt, strlen(test[i].mbs));
}
if (strcmp(mbs, test[i].mbs) != 0) {
test_failed(t, "wrong result: %s != %s",
mbs, test[i].mbs);
}
if (extra_debug) {
test_debugf(t, "mbs is %s", mbs);
}
}
test_passed(t);
}
int
main (int argc, char *argv[])
{
/* configure should already have checked that the locale is supported. */
if (setlocale (LC_ALL, "") == NULL)
return 1;
if (argc > 1)
{
wchar_t input[10];
size_t n;
const wchar_t *src;
#define BUFSIZE 20
char buf[BUFSIZE];
size_t ret;
{
size_t i;
for (i = 0; i < BUFSIZE; i++)
buf[i] = '_';
}
switch (argv[1][0])
{
case '1':
/* Locale encoding is ISO-8859-1 or ISO-8859-15. */
{
const char original[] = "B\374\337er"; /* "Büßer" */
ret = mbstowcs (input, original, 10);
ASSERT (ret == 5);
for (n = 0; n < 10; n++)
{
src = input;
ret = wcsrtombs (NULL, &src, n, NULL);
ASSERT (ret == 5);
ASSERT (src == input);
src = input;
ret = wcsrtombs (buf, &src, n, NULL);
ASSERT (ret == (n <= 5 ? n : 5));
ASSERT (src == (n <= 5 ? input + n : NULL));
ASSERT (memcmp (buf, original, ret) == 0);
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
ASSERT (buf[ret + (src == NULL) + 1] == '_');
ASSERT (buf[ret + (src == NULL) + 2] == '_');
}
}
break;
case '2':
/* Locale encoding is UTF-8. */
{
const char original[] = "B\303\274\303\237er"; /* "Büßer" */
ret = mbstowcs (input, original, 10);
ASSERT (ret == 5);
for (n = 0; n < 10; n++)
{
src = input;
ret = wcsrtombs (NULL, &src, n, NULL);
ASSERT (ret == 7);
ASSERT (src == input);
src = input;
ret = wcsrtombs (buf, &src, n, NULL);
ASSERT (ret == (n < 1 ? n :
n < 3 ? 1 :
n < 5 ? 3 :
n <= 7 ? n : 7));
ASSERT (src == (n < 1 ? input + n :
n < 3 ? input + 1 :
n < 5 ? input + 2 :
n <= 7 ? input + (n - 2) : NULL));
ASSERT (memcmp (buf, original, ret) == 0);
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
ASSERT (buf[ret + (src == NULL) + 1] == '_');
ASSERT (buf[ret + (src == NULL) + 2] == '_');
}
}
break;
case '3':
/* Locale encoding is EUC-JP. */
{
const char original[] = "<\306\374\313\334\270\354>"; /* "<日本語>" */
ret = mbstowcs (input, original, 10);
ASSERT (ret == 5);
for (n = 0; n < 10; n++)
{
src = input;
ret = wcsrtombs (NULL, &src, n, NULL);
ASSERT (ret == 8);
ASSERT (src == input);
src = input;
ret = wcsrtombs (buf, &src, n, NULL);
ASSERT (ret == (n < 1 ? n :
n < 3 ? 1 :
n < 5 ? 3 :
n < 7 ? 5 :
n <= 8 ? n : 8));
ASSERT (src == (n < 1 ? input + n :
n < 3 ? input + 1 :
n < 5 ? input + 2 :
n < 7 ? input + 3 :
n <= 8 ? input + (n - 3) : NULL));
ASSERT (memcmp (buf, original, ret) == 0);
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
ASSERT (buf[ret + (src == NULL) + 1] == '_');
ASSERT (buf[ret + (src == NULL) + 2] == '_');
}
}
break;
case '4':
/* Locale encoding is GB18030. */
{
const char original[] = "B\250\271\201\060\211\070er"; /* "Büßer" */
ret = mbstowcs (input, original, 10);
ASSERT (ret == 5);
for (n = 0; n < 10; n++)
{
src = input;
ret = wcsrtombs (NULL, &src, n, NULL);
ASSERT (ret == 9);
ASSERT (src == input);
src = input;
ret = wcsrtombs (buf, &src, n, NULL);
ASSERT (ret == (n < 1 ? n :
n < 3 ? 1 :
n < 7 ? 3 :
n <= 9 ? n : 9));
ASSERT (src == (n < 1 ? input + n :
n < 3 ? input + 1 :
n < 7 ? input + 2 :
n <= 9 ? input + (n - 4) : NULL));
ASSERT (memcmp (buf, original, ret) == 0);
if (src == NULL)
ASSERT (buf[ret] == '\0');
ASSERT (buf[ret + (src == NULL) + 0] == '_');
ASSERT (buf[ret + (src == NULL) + 1] == '_');
ASSERT (buf[ret + (src == NULL) + 2] == '_');
}
}
break;
default:
return 1;
}
return 0;
}
return 1;
}
static reg_errcode_t
tre_parse_bracket_items(tre_parse_ctx_t *ctx, int negate,
tre_ctype_t neg_classes[], int *num_neg_classes,
tre_ast_node_t ***items, int *num_items,
int *items_size)
{
const tre_char_t *re = ctx->re;
reg_errcode_t status = REG_OK;
tre_ctype_t classt = (tre_ctype_t)0;
int i = *num_items;
int max_i = *items_size;
int skip;
/* Build an array of the items in the bracket expression. */
while (status == REG_OK)
{
skip = 0;
if (re == ctx->re_end)
{
status = REG_EBRACK;
}
else if (*re == CHAR_RBRACKET && re > ctx->re)
{
DPRINT(("tre_parse_bracket: done: '%.*" STRF "'\n", REST(re)));
re++;
break;
}
else
{
tre_cint_t min = 0, max = 0;
classt = (tre_ctype_t)0;
if (re + 2 < ctx->re_end
&& *(re + 1) == CHAR_MINUS && *(re + 2) != CHAR_RBRACKET)
{
DPRINT(("tre_parse_bracket: range: '%.*" STRF "'\n", REST(re)));
min = *re;
max = *(re + 2);
re += 3;
/* XXX - Should use collation order instead of encoding values
in character ranges. */
if (min > max)
status = REG_ERANGE;
}
else if (re + 1 < ctx->re_end
&& *re == CHAR_LBRACKET && *(re + 1) == CHAR_PERIOD)
status = REG_ECOLLATE;
else if (re + 1 < ctx->re_end
&& *re == CHAR_LBRACKET && *(re + 1) == CHAR_EQUAL)
status = REG_ECOLLATE;
else if (re + 1 < ctx->re_end
&& *re == CHAR_LBRACKET && *(re + 1) == CHAR_COLON)
{
char tmp_str[64];
const tre_char_t *endptr = re + 2;
size_t len;
DPRINT(("tre_parse_bracket: class: '%.*" STRF "'\n", REST(re)));
while (endptr < ctx->re_end && *endptr != CHAR_COLON)
endptr++;
if (endptr != ctx->re_end)
{
len = MIN(endptr - re - 2, 63);
#ifdef TRE_WCHAR
{
tre_char_t tmp_wcs[64];
wcsncpy(tmp_wcs, re + 2, len);
tmp_wcs[len] = L'\0';
#if defined HAVE_WCSRTOMBS
{
mbstate_t state;
const tre_char_t *src = tmp_wcs;
memset(&state, '\0', sizeof(state));
len = wcsrtombs(tmp_str, &src, sizeof(tmp_str), &state);
}
#elif defined HAVE_WCSTOMBS
len = wcstombs(tmp_str, tmp_wcs, 63);
#endif /* defined HAVE_WCSTOMBS */
}
#else /* !TRE_WCHAR */
strncpy(tmp_str, (const char*)re + 2, len);
#endif /* !TRE_WCHAR */
tmp_str[len] = '\0';
DPRINT((" class name: %s\n", tmp_str));
classt = tre_ctype(tmp_str);
if (!classt)
status = REG_ECTYPE;
/* Optimize character classes for 8 bit character sets. */
if (status == REG_OK && ctx->cur_max == 1)
{
status = tre_expand_ctype(ctx->mem, classt, items,
&i, &max_i, ctx->cflags);
classt = (tre_ctype_t)0;
skip = 1;
}
re = endptr + 2;
}
else
status = REG_ECTYPE;
min = 0;
max = TRE_CHAR_MAX;
}
else
{
DPRINT(("tre_parse_bracket: char: '%.*" STRF "'\n", REST(re)));
if (*re == CHAR_MINUS && *(re + 1) != CHAR_RBRACKET
&& ctx->re != re)
/* Two ranges are not allowed to share and endpoint. */
status = REG_ERANGE;
min = max = *re++;
}
if (status != REG_OK)
break;
if (classt && negate)
if (*num_neg_classes >= MAX_NEG_CLASSES)
status = REG_ESPACE;
else
neg_classes[(*num_neg_classes)++] = classt;
else if (!skip)
{
status = tre_new_item(ctx->mem, min, max, &i, &max_i, items);
if (status != REG_OK)
break;
((tre_literal_t*)((*items)[i-1])->obj)->u.classt = classt;
}
/* Add opposite-case counterpoints if REG_ICASE is present.
This is broken if there are more than two "same" characters. */
if (ctx->cflags & REG_ICASE && !classt && status == REG_OK && !skip)
{
tre_cint_t cmin, ccurr;
DPRINT(("adding opposite-case counterpoints\n"));
while (min <= max)
{
if (tre_islower(min))
{
cmin = ccurr = tre_toupper(min++);
while (tre_islower(min) && tre_toupper(min) == ccurr + 1
&& min <= max)
ccurr = tre_toupper(min++);
status = tre_new_item(ctx->mem, cmin, ccurr,
&i, &max_i, items);
}
else if (tre_isupper(min))
{
cmin = ccurr = tre_tolower(min++);
while (tre_isupper(min) && tre_tolower(min) == ccurr + 1
&& min <= max)
ccurr = tre_tolower(min++);
status = tre_new_item(ctx->mem, cmin, ccurr,
&i, &max_i, items);
}
else min++;
if (status != REG_OK)
break;
}
if (status != REG_OK)
break;
}
}
}
*num_items = i;
*items_size = max_i;
ctx->re = re;
return status;
}
int
main(int argc, char *argv[])
{
wchar_t srcbuf[128];
char dstbuf[128];
wchar_t *src;
mbstate_t s;
/*
* C/POSIX locale.
*/
printf("1..1\n");
/* Simple null terminated string. */
wmemset(srcbuf, 0xcc, sizeof(srcbuf) / sizeof(*srcbuf));
wcscpy(srcbuf, L"hello");
memset(dstbuf, 0xcc, sizeof(dstbuf));
src = srcbuf;
memset(&s, 0, sizeof(s));
assert(wcsrtombs(dstbuf, (const wchar_t **)&src, sizeof(dstbuf),
&s) == 5);
assert(strcmp(dstbuf, "hello") == 0);
assert((unsigned char)dstbuf[6] == 0xcc);
assert(src == NULL);
/* Not enough space in destination buffer. */
wmemset(srcbuf, 0xcc, sizeof(srcbuf) / sizeof(*srcbuf));
wcscpy(srcbuf, L"hello");
memset(dstbuf, 0xcc, sizeof(dstbuf));
src = srcbuf;
memset(&s, 0, sizeof(s));
assert(wcsrtombs(dstbuf, (const wchar_t **)&src, 4,
&s) == 4);
assert(memcmp(dstbuf, "hell", 4) == 0);
assert((unsigned char)dstbuf[5] == 0xcc);
assert(src == srcbuf + 4);
/* Null terminated string, internal dest. buffer */
wmemset(srcbuf, 0xcc, sizeof(srcbuf) / sizeof(*srcbuf));
wcscpy(srcbuf, L"hello");
src = srcbuf;
memset(&s, 0, sizeof(s));
assert(wcsrtombs(NULL, (const wchar_t **)&src, sizeof(dstbuf),
&s) == 5);
/* Null terminated string, internal state. */
wmemset(srcbuf, 0xcc, sizeof(srcbuf) / sizeof(*srcbuf));
wcscpy(srcbuf, L"hello");
memset(dstbuf, 0xcc, sizeof(dstbuf));
src = srcbuf;
assert(wcsrtombs(dstbuf, (const wchar_t **)&src, sizeof(dstbuf),
NULL) == 5);
assert(strcmp(dstbuf, "hello") == 0);
assert((unsigned char)dstbuf[6] == 0xcc);
assert(src == NULL);
/* Null terminated string, internal state, internal dest. buffer. */
wmemset(srcbuf, 0xcc, sizeof(srcbuf) / sizeof(*srcbuf));
wcscpy(srcbuf, L"hello");
src = srcbuf;
assert(wcsrtombs(NULL, (const wchar_t **)&src, 0, NULL) == 5);
/* Empty source buffer. */
wmemset(srcbuf, 0xcc, sizeof(srcbuf) / sizeof(*srcbuf));
srcbuf[0] = L'\0';
memset(dstbuf, 0xcc, sizeof(dstbuf));
src = srcbuf;
memset(&s, 0, sizeof(s));
assert(wcsrtombs(dstbuf, (const wchar_t **)&src, sizeof(dstbuf),
&s) == 0);
assert(dstbuf[0] == L'\0');
/* Zero length destination buffer. */
wmemset(srcbuf, 0xcc, sizeof(srcbuf) / sizeof(*srcbuf));
wcscpy(srcbuf, L"hello");
memset(dstbuf, 0xcc, sizeof(dstbuf));
src = srcbuf;
memset(&s, 0, sizeof(s));
assert(wcsrtombs(dstbuf, (const wchar_t **)&src, 0, &s) == 0);
assert((unsigned char)dstbuf[0] == 0xcc);
/*
* Japanese (EUC) locale.
*/
assert(strcmp(setlocale(LC_CTYPE, "ja_JP.eucJP"), "ja_JP.eucJP") == 0);
assert(MB_CUR_MAX > 1);
wmemset(srcbuf, 0xcc, sizeof(srcbuf) / sizeof(*srcbuf));
srcbuf[0] = 0xA3C1;
srcbuf[1] = 0x0020;
srcbuf[2] = 0x0042;
srcbuf[3] = 0x0020;
srcbuf[4] = 0xA3C3;
srcbuf[5] = 0x0000;
memset(dstbuf, 0xcc, sizeof(dstbuf));
src = srcbuf;
memset(&s, 0, sizeof(s));
assert(wcsrtombs(dstbuf, (const wchar_t **)&src, sizeof(dstbuf),
&s) == 7);
assert(strcmp(dstbuf, "\xA3\xC1 B \xA3\xC3") == 0);
assert((unsigned char)dstbuf[8] == 0xcc);
assert(src == NULL);
printf("ok 1 - wcsrtombs()\n");
return (0);
}
size_t wcstombs(char *dst, const wchar_t *src, size_t len) {
return wcsrtombs(dst, &src, len, NULL);
}
int main()
{
mbstate_t mb = {0};
size_t s = 0;
tm tm = {0};
wint_t w = 0;
::FILE* fp = 0;
__darwin_va_list va;
char* ns = 0;
wchar_t* ws = 0;
static_assert((std::is_same<decltype(fwprintf(fp, L"")), int>::value), "");
static_assert((std::is_same<decltype(fwscanf(fp, L"")), int>::value), "");
static_assert((std::is_same<decltype(swprintf(ws, s, L"")), int>::value), "");
static_assert((std::is_same<decltype(swscanf(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(vfwprintf(fp, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vfwscanf(fp, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vswprintf(ws, s, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vswscanf(L"", L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vwprintf(L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vwscanf(L"", va)), int>::value), "");
static_assert((std::is_same<decltype(wprintf(L"")), int>::value), "");
static_assert((std::is_same<decltype(wscanf(L"")), int>::value), "");
static_assert((std::is_same<decltype(fgetwc(fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(fgetws(ws, 0, fp)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(fputwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(fputws(L"", fp)), int>::value), "");
static_assert((std::is_same<decltype(fwide(fp, 0)), int>::value), "");
static_assert((std::is_same<decltype(getwc(fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(getwchar()), wint_t>::value), "");
static_assert((std::is_same<decltype(putwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(putwchar(L' ')), wint_t>::value), "");
static_assert((std::is_same<decltype(ungetwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(wcstod(L"", (wchar_t**)0)), double>::value), "");
static_assert((std::is_same<decltype(wcstof(L"", (wchar_t**)0)), float>::value), "");
static_assert((std::is_same<decltype(wcstold(L"", (wchar_t**)0)), long double>::value), "");
static_assert((std::is_same<decltype(wcstol(L"", (wchar_t**)0, 0)), long>::value), "");
static_assert((std::is_same<decltype(wcstoll(L"", (wchar_t**)0, 0)), long long>::value), "");
static_assert((std::is_same<decltype(wcstoul(L"", (wchar_t**)0, 0)), unsigned long>::value), "");
static_assert((std::is_same<decltype(wcstoull(L"", (wchar_t**)0, 0)), unsigned long long>::value), "");
static_assert((std::is_same<decltype(wcscpy(ws, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsncpy(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscat(ws, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsncat(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscmp(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(wcscoll(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(wcsncmp(L"", L"", s)), int>::value), "");
static_assert((std::is_same<decltype(wcsxfrm(ws, L"", s)), size_t>::value), "");
static_assert((std::is_same<decltype(wcschr((wchar_t*)0, L' ')), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscspn(L"", L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcslen(L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcspbrk((wchar_t*)0, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsrchr((wchar_t*)0, L' ')), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsspn(L"", L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcsstr((wchar_t*)0, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcstok(ws, L"", (wchar_t**)0)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemchr((wchar_t*)0, L' ', s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemcmp(L"", L"", s)), int>::value), "");
static_assert((std::is_same<decltype(wmemcpy(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemmove(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemset(ws, L' ', s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsftime(ws, s, L"", &tm)), size_t>::value), "");
static_assert((std::is_same<decltype(btowc(0)), wint_t>::value), "");
static_assert((std::is_same<decltype(wctob(w)), int>::value), "");
static_assert((std::is_same<decltype(mbsinit(&mb)), int>::value), "");
static_assert((std::is_same<decltype(mbrlen("", s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(mbrtowc(ws, "", s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(wcrtomb(ns, L' ', &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(mbsrtowcs(ws, (const char**)0, s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(wcsrtombs(ns, (const wchar_t**)0, s, &mb)), size_t>::value), "");
}
TEST(wchar, wcstombs_wcrtombs) {
const wchar_t chars[] = { L'h', L'e', L'l', L'l', L'o', 0 };
const wchar_t bad_chars[] = { L'h', L'i', static_cast<wchar_t>(0xffffffff), 0 };
const wchar_t* src;
char bytes[BUFSIZ];
// Given a NULL destination, these functions count valid characters.
EXPECT_EQ(5U, wcstombs(NULL, chars, 0));
EXPECT_EQ(5U, wcstombs(NULL, chars, 4));
EXPECT_EQ(5U, wcstombs(NULL, chars, 256));
src = chars;
EXPECT_EQ(5U, wcsrtombs(NULL, &src, 0, NULL));
EXPECT_EQ(&chars[0], src);
src = chars;
EXPECT_EQ(5U, wcsrtombs(NULL, &src, 4, NULL));
EXPECT_EQ(&chars[0], src);
src = chars;
EXPECT_EQ(5U, wcsrtombs(NULL, &src, 256, NULL));
EXPECT_EQ(&chars[0], src);
// An unrepresentable char just returns an error from wcstombs...
errno = 0;
EXPECT_EQ(static_cast<size_t>(-1), wcstombs(NULL, bad_chars, 0));
EXPECT_EQ(EILSEQ, errno);
errno = 0;
EXPECT_EQ(static_cast<size_t>(-1), wcstombs(NULL, bad_chars, 256));
EXPECT_EQ(EILSEQ, errno);
// And wcsrtombs doesn't tell us where it got stuck because we didn't ask it
// to actually convert anything...
errno = 0;
src = bad_chars;
EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(NULL, &src, 0, NULL));
EXPECT_EQ(&bad_chars[0], src);
EXPECT_EQ(EILSEQ, errno);
errno = 0;
src = bad_chars;
EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(NULL, &src, 256, NULL));
EXPECT_EQ(&bad_chars[0], src);
EXPECT_EQ(EILSEQ, errno);
// Okay, now let's test actually converting something...
memset(bytes, 'x', sizeof(bytes));
EXPECT_EQ(0U, wcstombs(bytes, chars, 0));
memset(bytes, 'x', sizeof(bytes));
EXPECT_EQ(4U, wcstombs(bytes, chars, 4));
bytes[5] = 0;
EXPECT_STREQ("hellx", bytes);
memset(bytes, 'x', sizeof(bytes));
EXPECT_EQ(5U, wcstombs(bytes, chars, 256));
EXPECT_STREQ("hello", bytes);
memset(bytes, 'x', sizeof(bytes));
EXPECT_EQ(5U, wcstombs(bytes, chars, 6));
EXPECT_STREQ("hello", bytes);
errno = 0;
memset(bytes, 'x', sizeof(bytes));
EXPECT_EQ(static_cast<size_t>(-1), wcstombs(bytes, bad_chars, 256));
EXPECT_EQ(EILSEQ, errno);
bytes[3] = 0;
EXPECT_STREQ("hix", bytes);
// wcsrtombs is a bit more informative...
memset(bytes, 'x', sizeof(bytes));
src = chars;
EXPECT_EQ(0U, wcsrtombs(bytes, &src, 0, NULL));
EXPECT_EQ(&chars[0], src); // No input consumed.
EXPECT_EQ(EILSEQ, errno);
memset(bytes, 'x', sizeof(bytes));
src = chars;
EXPECT_EQ(4U, wcsrtombs(bytes, &src, 4, NULL));
EXPECT_EQ(&chars[4], src); // Some input consumed.
EXPECT_EQ(EILSEQ, errno);
bytes[5] = 0;
EXPECT_STREQ("hellx", bytes);
memset(bytes, 'x', sizeof(bytes));
src = chars;
EXPECT_EQ(5U, wcsrtombs(bytes, &src, 256, NULL));
EXPECT_EQ(NULL, src); // All input consumed!
EXPECT_EQ(EILSEQ, errno);
EXPECT_STREQ("hello", bytes);
memset(bytes, 'x', sizeof(bytes));
src = chars;
EXPECT_EQ(5U, wcsrtombs(bytes, &src, 6, NULL));
EXPECT_EQ(NULL, src); // All input consumed.
EXPECT_EQ(EILSEQ, errno);
EXPECT_STREQ("hello", bytes);
memset(bytes, 'x', sizeof(bytes));
src = bad_chars;
EXPECT_EQ(static_cast<size_t>(-1), wcsrtombs(bytes, &src, 256, NULL));
EXPECT_EQ(&bad_chars[2], src);
EXPECT_EQ(EILSEQ, errno);
bytes[3] = 0;
EXPECT_STREQ("hix", bytes);
}
static int
do_test (void)
{
struct sigaction sa;
sa.sa_handler = handler;
sa.sa_flags = 0;
sigemptyset (&sa.sa_mask);
sigaction (SIGABRT, &sa, NULL);
/* Avoid all the buffer overflow messages on stderr. */
int fd = open (_PATH_DEVNULL, O_WRONLY);
if (fd == -1)
close (STDERR_FILENO);
else
{
dup2 (fd, STDERR_FILENO);
close (fd);
}
setenv ("LIBC_FATAL_STDERR_", "1", 1);
struct A { char buf1[9]; char buf2[1]; } a;
struct wA { wchar_t buf1[9]; wchar_t buf2[1]; } wa;
printf ("Test checking routines at fortify level %d\n",
#ifdef __USE_FORTIFY_LEVEL
(int) __USE_FORTIFY_LEVEL
#else
0
#endif
);
/* These ops can be done without runtime checking of object size. */
memcpy (buf, "abcdefghij", 10);
memmove (buf + 1, buf, 9);
if (memcmp (buf, "aabcdefghi", 10))
FAIL ();
if (mempcpy (buf + 5, "abcde", 5) != buf + 10
|| memcmp (buf, "aabcdabcde", 10))
FAIL ();
memset (buf + 8, 'j', 2);
if (memcmp (buf, "aabcdabcjj", 10))
FAIL ();
strcpy (buf + 4, "EDCBA");
if (memcmp (buf, "aabcEDCBA", 10))
FAIL ();
if (stpcpy (buf + 8, "F") != buf + 9 || memcmp (buf, "aabcEDCBF", 10))
FAIL ();
strncpy (buf + 6, "X", 4);
if (memcmp (buf, "aabcEDX\0\0", 10))
FAIL ();
if (sprintf (buf + 7, "%s", "67") != 2 || memcmp (buf, "aabcEDX67", 10))
FAIL ();
if (snprintf (buf + 7, 3, "%s", "987654") != 6
|| memcmp (buf, "aabcEDX98", 10))
FAIL ();
/* These ops need runtime checking, but shouldn't __chk_fail. */
memcpy (buf, "abcdefghij", l0 + 10);
memmove (buf + 1, buf, l0 + 9);
if (memcmp (buf, "aabcdefghi", 10))
FAIL ();
if (mempcpy (buf + 5, "abcde", l0 + 5) != buf + 10
|| memcmp (buf, "aabcdabcde", 10))
FAIL ();
memset (buf + 8, 'j', l0 + 2);
if (memcmp (buf, "aabcdabcjj", 10))
FAIL ();
strcpy (buf + 4, str1 + 5);
if (memcmp (buf, "aabcEDCBA", 10))
FAIL ();
if (stpcpy (buf + 8, str2) != buf + 9 || memcmp (buf, "aabcEDCBF", 10))
FAIL ();
strncpy (buf + 6, "X", l0 + 4);
if (memcmp (buf, "aabcEDX\0\0", 10))
FAIL ();
if (stpncpy (buf + 5, "cd", l0 + 5) != buf + 7
|| memcmp (buf, "aabcEcd\0\0", 10))
FAIL ();
if (sprintf (buf + 7, "%d", num1) != 2 || memcmp (buf, "aabcEcd67", 10))
FAIL ();
if (snprintf (buf + 7, 3, "%d", num2) != 6 || memcmp (buf, "aabcEcd98", 10))
FAIL ();
buf[l0 + 8] = '\0';
strcat (buf, "A");
if (memcmp (buf, "aabcEcd9A", 10))
FAIL ();
buf[l0 + 7] = '\0';
strncat (buf, "ZYXWV", l0 + 2);
if (memcmp (buf, "aabcEcdZY", 10))
FAIL ();
memcpy (a.buf1, "abcdefghij", l0 + 10);
memmove (a.buf1 + 1, a.buf1, l0 + 9);
if (memcmp (a.buf1, "aabcdefghi", 10))
FAIL ();
if (mempcpy (a.buf1 + 5, "abcde", l0 + 5) != a.buf1 + 10
|| memcmp (a.buf1, "aabcdabcde", 10))
FAIL ();
memset (a.buf1 + 8, 'j', l0 + 2);
if (memcmp (a.buf1, "aabcdabcjj", 10))
FAIL ();
#if __USE_FORTIFY_LEVEL < 2
/* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2
and sufficient GCC support, as the string operations overflow
from a.buf1 into a.buf2. */
strcpy (a.buf1 + 4, str1 + 5);
if (memcmp (a.buf1, "aabcEDCBA", 10))
FAIL ();
if (stpcpy (a.buf1 + 8, str2) != a.buf1 + 9
|| memcmp (a.buf1, "aabcEDCBF", 10))
FAIL ();
strncpy (a.buf1 + 6, "X", l0 + 4);
if (memcmp (a.buf1, "aabcEDX\0\0", 10))
FAIL ();
if (sprintf (a.buf1 + 7, "%d", num1) != 2
|| memcmp (a.buf1, "aabcEDX67", 10))
FAIL ();
if (snprintf (a.buf1 + 7, 3, "%d", num2) != 6
|| memcmp (a.buf1, "aabcEDX98", 10))
FAIL ();
a.buf1[l0 + 8] = '\0';
strcat (a.buf1, "A");
if (memcmp (a.buf1, "aabcEDX9A", 10))
FAIL ();
a.buf1[l0 + 7] = '\0';
strncat (a.buf1, "ZYXWV", l0 + 2);
if (memcmp (a.buf1, "aabcEDXZY", 10))
FAIL ();
#endif
#if __USE_FORTIFY_LEVEL >= 1
/* Now check if all buffer overflows are caught at runtime. */
CHK_FAIL_START
memcpy (buf + 1, "abcdefghij", l0 + 10);
CHK_FAIL_END
CHK_FAIL_START
memmove (buf + 2, buf + 1, l0 + 9);
CHK_FAIL_END
CHK_FAIL_START
p = mempcpy (buf + 6, "abcde", l0 + 5);
CHK_FAIL_END
CHK_FAIL_START
memset (buf + 9, 'j', l0 + 2);
CHK_FAIL_END
CHK_FAIL_START
strcpy (buf + 5, str1 + 5);
CHK_FAIL_END
CHK_FAIL_START
p = stpcpy (buf + 9, str2);
CHK_FAIL_END
CHK_FAIL_START
strncpy (buf + 7, "X", l0 + 4);
CHK_FAIL_END
CHK_FAIL_START
stpncpy (buf + 6, "cd", l0 + 5);
CHK_FAIL_END
CHK_FAIL_START
sprintf (buf + 8, "%d", num1);
CHK_FAIL_END
CHK_FAIL_START
snprintf (buf + 8, l0 + 3, "%d", num2);
CHK_FAIL_END
memcpy (buf, str1 + 2, l0 + 9);
CHK_FAIL_START
strcat (buf, "AB");
CHK_FAIL_END
memcpy (buf, str1 + 3, l0 + 8);
CHK_FAIL_START
strncat (buf, "ZYXWV", l0 + 3);
CHK_FAIL_END
CHK_FAIL_START
memcpy (a.buf1 + 1, "abcdefghij", l0 + 10);
CHK_FAIL_END
CHK_FAIL_START
memmove (a.buf1 + 2, a.buf1 + 1, l0 + 9);
CHK_FAIL_END
CHK_FAIL_START
p = mempcpy (a.buf1 + 6, "abcde", l0 + 5);
CHK_FAIL_END
CHK_FAIL_START
memset (a.buf1 + 9, 'j', l0 + 2);
CHK_FAIL_END
#if __USE_FORTIFY_LEVEL >= 2
# define O 0
#else
# define O 1
#endif
CHK_FAIL_START
strcpy (a.buf1 + (O + 4), str1 + 5);
CHK_FAIL_END
CHK_FAIL_START
p = stpcpy (a.buf1 + (O + 8), str2);
CHK_FAIL_END
CHK_FAIL_START
strncpy (a.buf1 + (O + 6), "X", l0 + 4);
CHK_FAIL_END
CHK_FAIL_START
sprintf (a.buf1 + (O + 7), "%d", num1);
CHK_FAIL_END
CHK_FAIL_START
snprintf (a.buf1 + (O + 7), l0 + 3, "%d", num2);
CHK_FAIL_END
memcpy (a.buf1, str1 + (3 - O), l0 + 8 + O);
CHK_FAIL_START
strcat (a.buf1, "AB");
CHK_FAIL_END
memcpy (a.buf1, str1 + (4 - O), l0 + 7 + O);
CHK_FAIL_START
strncat (a.buf1, "ZYXWV", l0 + 3);
CHK_FAIL_END
#endif
/* These ops can be done without runtime checking of object size. */
wmemcpy (wbuf, L"abcdefghij", 10);
wmemmove (wbuf + 1, wbuf, 9);
if (wmemcmp (wbuf, L"aabcdefghi", 10))
FAIL ();
if (wmempcpy (wbuf + 5, L"abcde", 5) != wbuf + 10
|| wmemcmp (wbuf, L"aabcdabcde", 10))
FAIL ();
wmemset (wbuf + 8, L'j', 2);
if (wmemcmp (wbuf, L"aabcdabcjj", 10))
FAIL ();
wcscpy (wbuf + 4, L"EDCBA");
if (wmemcmp (wbuf, L"aabcEDCBA", 10))
FAIL ();
if (wcpcpy (wbuf + 8, L"F") != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10))
FAIL ();
wcsncpy (wbuf + 6, L"X", 4);
if (wmemcmp (wbuf, L"aabcEDX\0\0", 10))
FAIL ();
if (swprintf (wbuf + 7, 3, L"%ls", L"987654") >= 0
|| wmemcmp (wbuf, L"aabcEDX98", 10))
FAIL ();
if (swprintf (wbuf + 7, 3, L"64") != 2
|| wmemcmp (wbuf, L"aabcEDX64", 10))
FAIL ();
/* These ops need runtime checking, but shouldn't __chk_fail. */
wmemcpy (wbuf, L"abcdefghij", l0 + 10);
wmemmove (wbuf + 1, wbuf, l0 + 9);
if (wmemcmp (wbuf, L"aabcdefghi", 10))
FAIL ();
if (wmempcpy (wbuf + 5, L"abcde", l0 + 5) != wbuf + 10
|| wmemcmp (wbuf, L"aabcdabcde", 10))
FAIL ();
wmemset (wbuf + 8, L'j', l0 + 2);
if (wmemcmp (wbuf, L"aabcdabcjj", 10))
FAIL ();
wcscpy (wbuf + 4, wstr1 + 5);
if (wmemcmp (wbuf, L"aabcEDCBA", 10))
FAIL ();
if (wcpcpy (wbuf + 8, wstr2) != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10))
FAIL ();
wcsncpy (wbuf + 6, L"X", l0 + 4);
if (wmemcmp (wbuf, L"aabcEDX\0\0", 10))
FAIL ();
if (wcpncpy (wbuf + 5, L"cd", l0 + 5) != wbuf + 7
|| wmemcmp (wbuf, L"aabcEcd\0\0", 10))
FAIL ();
if (swprintf (wbuf + 7, 3, L"%d", num2) >= 0
|| wmemcmp (wbuf, L"aabcEcd98", 10))
FAIL ();
wbuf[l0 + 8] = L'\0';
wcscat (wbuf, L"A");
if (wmemcmp (wbuf, L"aabcEcd9A", 10))
FAIL ();
wbuf[l0 + 7] = L'\0';
wcsncat (wbuf, L"ZYXWV", l0 + 2);
if (wmemcmp (wbuf, L"aabcEcdZY", 10))
FAIL ();
wmemcpy (wa.buf1, L"abcdefghij", l0 + 10);
wmemmove (wa.buf1 + 1, wa.buf1, l0 + 9);
if (wmemcmp (wa.buf1, L"aabcdefghi", 10))
FAIL ();
if (wmempcpy (wa.buf1 + 5, L"abcde", l0 + 5) != wa.buf1 + 10
|| wmemcmp (wa.buf1, L"aabcdabcde", 10))
FAIL ();
wmemset (wa.buf1 + 8, L'j', l0 + 2);
if (wmemcmp (wa.buf1, L"aabcdabcjj", 10))
FAIL ();
#if __USE_FORTIFY_LEVEL < 2
/* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2
and sufficient GCC support, as the string operations overflow
from a.buf1 into a.buf2. */
wcscpy (wa.buf1 + 4, wstr1 + 5);
if (wmemcmp (wa.buf1, L"aabcEDCBA", 10))
FAIL ();
if (wcpcpy (wa.buf1 + 8, wstr2) != wa.buf1 + 9
|| wmemcmp (wa.buf1, L"aabcEDCBF", 10))
FAIL ();
wcsncpy (wa.buf1 + 6, L"X", l0 + 4);
if (wmemcmp (wa.buf1, L"aabcEDX\0\0", 10))
FAIL ();
if (swprintf (wa.buf1 + 7, 3, L"%d", num2) >= 0
|| wmemcmp (wa.buf1, L"aabcEDX98", 10))
FAIL ();
wa.buf1[l0 + 8] = L'\0';
wcscat (wa.buf1, L"A");
if (wmemcmp (wa.buf1, L"aabcEDX9A", 10))
FAIL ();
wa.buf1[l0 + 7] = L'\0';
wcsncat (wa.buf1, L"ZYXWV", l0 + 2);
if (wmemcmp (wa.buf1, L"aabcEDXZY", 10))
FAIL ();
#endif
#if __USE_FORTIFY_LEVEL >= 1
/* Now check if all buffer overflows are caught at runtime. */
CHK_FAIL_START
wmemcpy (wbuf + 1, L"abcdefghij", l0 + 10);
CHK_FAIL_END
CHK_FAIL_START
wmemmove (wbuf + 2, wbuf + 1, l0 + 9);
CHK_FAIL_END
CHK_FAIL_START
wp = wmempcpy (wbuf + 6, L"abcde", l0 + 5);
CHK_FAIL_END
CHK_FAIL_START
wmemset (wbuf + 9, L'j', l0 + 2);
CHK_FAIL_END
CHK_FAIL_START
wcscpy (wbuf + 5, wstr1 + 5);
CHK_FAIL_END
CHK_FAIL_START
wp = wcpcpy (wbuf + 9, wstr2);
CHK_FAIL_END
CHK_FAIL_START
wcsncpy (wbuf + 7, L"X", l0 + 4);
CHK_FAIL_END
CHK_FAIL_START
wcpncpy (wbuf + 6, L"cd", l0 + 5);
CHK_FAIL_END
wmemcpy (wbuf, wstr1 + 2, l0 + 9);
CHK_FAIL_START
wcscat (wbuf, L"AB");
CHK_FAIL_END
wmemcpy (wbuf, wstr1 + 3, l0 + 8);
CHK_FAIL_START
wcsncat (wbuf, L"ZYXWV", l0 + 3);
CHK_FAIL_END
CHK_FAIL_START
wmemcpy (wa.buf1 + 1, L"abcdefghij", l0 + 10);
CHK_FAIL_END
CHK_FAIL_START
wmemmove (wa.buf1 + 2, wa.buf1 + 1, l0 + 9);
CHK_FAIL_END
CHK_FAIL_START
wp = wmempcpy (wa.buf1 + 6, L"abcde", l0 + 5);
CHK_FAIL_END
CHK_FAIL_START
wmemset (wa.buf1 + 9, L'j', l0 + 2);
CHK_FAIL_END
#if __USE_FORTIFY_LEVEL >= 2
# define O 0
#else
# define O 1
#endif
CHK_FAIL_START
wcscpy (wa.buf1 + (O + 4), wstr1 + 5);
CHK_FAIL_END
CHK_FAIL_START
wp = wcpcpy (wa.buf1 + (O + 8), wstr2);
CHK_FAIL_END
CHK_FAIL_START
wcsncpy (wa.buf1 + (O + 6), L"X", l0 + 4);
CHK_FAIL_END
wmemcpy (wa.buf1, wstr1 + (3 - O), l0 + 8 + O);
CHK_FAIL_START
wcscat (wa.buf1, L"AB");
CHK_FAIL_END
wmemcpy (wa.buf1, wstr1 + (4 - O), l0 + 7 + O);
CHK_FAIL_START
wcsncat (wa.buf1, L"ZYXWV", l0 + 3);
CHK_FAIL_END
#endif
/* Now checks for %n protection. */
/* Constant literals passed directly are always ok
(even with warnings about possible bugs from GCC). */
int n1, n2;
if (sprintf (buf, "%s%n%s%n", str2, &n1, str2, &n2) != 2
|| n1 != 1 || n2 != 2)
FAIL ();
/* In this case the format string is not known at compile time,
but resides in read-only memory, so is ok. */
if (snprintf (buf, 4, str3, str2, &n1, str2, &n2) != 2
|| n1 != 1 || n2 != 2)
FAIL ();
strcpy (buf2 + 2, "%n%s%n");
/* When the format string is writable and contains %n,
with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */
CHK_FAIL2_START
if (sprintf (buf, buf2, str2, &n1, str2, &n1) != 2)
FAIL ();
CHK_FAIL2_END
CHK_FAIL2_START
if (snprintf (buf, 3, buf2, str2, &n1, str2, &n1) != 2)
FAIL ();
CHK_FAIL2_END
/* But if there is no %n, even writable format string
should work. */
buf2[6] = '\0';
if (sprintf (buf, buf2 + 4, str2) != 1)
FAIL ();
/* Constant literals passed directly are always ok
(even with warnings about possible bugs from GCC). */
if (printf ("%s%n%s%n", str4, &n1, str5, &n2) != 14
|| n1 != 7 || n2 != 14)
FAIL ();
/* In this case the format string is not known at compile time,
but resides in read-only memory, so is ok. */
if (printf (str3, str4, &n1, str5, &n2) != 14
|| n1 != 7 || n2 != 14)
FAIL ();
strcpy (buf2 + 2, "%n%s%n");
/* When the format string is writable and contains %n,
with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */
CHK_FAIL2_START
if (printf (buf2, str4, &n1, str5, &n1) != 14)
FAIL ();
CHK_FAIL2_END
/* But if there is no %n, even writable format string
should work. */
buf2[6] = '\0';
if (printf (buf2 + 4, str5) != 7)
FAIL ();
FILE *fp = stdout;
/* Constant literals passed directly are always ok
(even with warnings about possible bugs from GCC). */
if (fprintf (fp, "%s%n%s%n", str4, &n1, str5, &n2) != 14
|| n1 != 7 || n2 != 14)
FAIL ();
/* In this case the format string is not known at compile time,
but resides in read-only memory, so is ok. */
if (fprintf (fp, str3, str4, &n1, str5, &n2) != 14
|| n1 != 7 || n2 != 14)
FAIL ();
strcpy (buf2 + 2, "%n%s%n");
/* When the format string is writable and contains %n,
with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */
CHK_FAIL2_START
if (fprintf (fp, buf2, str4, &n1, str5, &n1) != 14)
FAIL ();
CHK_FAIL2_END
/* But if there is no %n, even writable format string
should work. */
buf2[6] = '\0';
if (fprintf (fp, buf2 + 4, str5) != 7)
FAIL ();
if (freopen (temp_filename, "r", stdin) == NULL)
{
puts ("could not open temporary file");
exit (1);
}
if (gets (buf) != buf || memcmp (buf, "abcdefgh", 9))
FAIL ();
if (gets (buf) != buf || memcmp (buf, "ABCDEFGHI", 10))
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (gets (buf) != buf)
FAIL ();
CHK_FAIL_END
#endif
rewind (stdin);
if (fgets (buf, sizeof (buf), stdin) != buf
|| memcmp (buf, "abcdefgh\n", 10))
FAIL ();
if (fgets (buf, sizeof (buf), stdin) != buf || memcmp (buf, "ABCDEFGHI", 10))
FAIL ();
rewind (stdin);
if (fgets (buf, l0 + sizeof (buf), stdin) != buf
|| memcmp (buf, "abcdefgh\n", 10))
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (fgets (buf, sizeof (buf) + 1, stdin) != buf)
FAIL ();
CHK_FAIL_END
CHK_FAIL_START
if (fgets (buf, l0 + sizeof (buf) + 1, stdin) != buf)
FAIL ();
CHK_FAIL_END
#endif
rewind (stdin);
if (fgets_unlocked (buf, sizeof (buf), stdin) != buf
|| memcmp (buf, "abcdefgh\n", 10))
FAIL ();
if (fgets_unlocked (buf, sizeof (buf), stdin) != buf
|| memcmp (buf, "ABCDEFGHI", 10))
FAIL ();
rewind (stdin);
if (fgets_unlocked (buf, l0 + sizeof (buf), stdin) != buf
|| memcmp (buf, "abcdefgh\n", 10))
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (fgets_unlocked (buf, sizeof (buf) + 1, stdin) != buf)
FAIL ();
CHK_FAIL_END
CHK_FAIL_START
if (fgets_unlocked (buf, l0 + sizeof (buf) + 1, stdin) != buf)
FAIL ();
CHK_FAIL_END
#endif
lseek (fileno (stdin), 0, SEEK_SET);
if (read (fileno (stdin), buf, sizeof (buf) - 1) != sizeof (buf) - 1
|| memcmp (buf, "abcdefgh\n", 9))
FAIL ();
if (read (fileno (stdin), buf, sizeof (buf) - 1) != sizeof (buf) - 1
|| memcmp (buf, "ABCDEFGHI", 9))
FAIL ();
lseek (fileno (stdin), 0, SEEK_SET);
if (read (fileno (stdin), buf, l0 + sizeof (buf) - 1) != sizeof (buf) - 1
|| memcmp (buf, "abcdefgh\n", 9))
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (read (fileno (stdin), buf, sizeof (buf) + 1) != sizeof (buf) + 1)
FAIL ();
CHK_FAIL_END
#endif
if (pread (fileno (stdin), buf, sizeof (buf) - 1, sizeof (buf) - 2)
!= sizeof (buf) - 1
|| memcmp (buf, "\nABCDEFGH", 9))
FAIL ();
if (pread (fileno (stdin), buf, sizeof (buf) - 1, 0) != sizeof (buf) - 1
|| memcmp (buf, "abcdefgh\n", 9))
FAIL ();
if (pread (fileno (stdin), buf, l0 + sizeof (buf) - 1, sizeof (buf) - 3)
!= sizeof (buf) - 1
|| memcmp (buf, "h\nABCDEFG", 9))
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (pread (fileno (stdin), buf, sizeof (buf) + 1, 2 * sizeof (buf))
!= sizeof (buf) + 1)
FAIL ();
CHK_FAIL_END
#endif
if (pread64 (fileno (stdin), buf, sizeof (buf) - 1, sizeof (buf) - 2)
!= sizeof (buf) - 1
|| memcmp (buf, "\nABCDEFGH", 9))
FAIL ();
if (pread64 (fileno (stdin), buf, sizeof (buf) - 1, 0) != sizeof (buf) - 1
|| memcmp (buf, "abcdefgh\n", 9))
FAIL ();
if (pread64 (fileno (stdin), buf, l0 + sizeof (buf) - 1, sizeof (buf) - 3)
!= sizeof (buf) - 1
|| memcmp (buf, "h\nABCDEFG", 9))
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (pread64 (fileno (stdin), buf, sizeof (buf) + 1, 2 * sizeof (buf))
!= sizeof (buf) + 1)
FAIL ();
CHK_FAIL_END
#endif
if (freopen (temp_filename, "r", stdin) == NULL)
{
puts ("could not open temporary file");
exit (1);
}
if (fseek (stdin, 9 + 10 + 11, SEEK_SET))
{
puts ("could not seek in test file");
exit (1);
}
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (gets (buf) != buf)
FAIL ();
CHK_FAIL_END
#endif
/* Check whether missing N$ formats are detected. */
CHK_FAIL2_START
printf ("%3$d\n", 1, 2, 3, 4);
CHK_FAIL2_END
CHK_FAIL2_START
fprintf (stdout, "%3$d\n", 1, 2, 3, 4);
CHK_FAIL2_END
CHK_FAIL2_START
sprintf (buf, "%3$d\n", 1, 2, 3, 4);
CHK_FAIL2_END
CHK_FAIL2_START
snprintf (buf, sizeof (buf), "%3$d\n", 1, 2, 3, 4);
CHK_FAIL2_END
int sp[2];
if (socketpair (PF_UNIX, SOCK_STREAM, 0, sp))
FAIL ();
else
{
const char *sendstr = "abcdefgh\nABCDEFGH\n0123456789\n";
if (send (sp[0], sendstr, strlen (sendstr), 0) != strlen (sendstr))
FAIL ();
char recvbuf[12];
if (recv (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK)
!= sizeof recvbuf
|| memcmp (recvbuf, sendstr, sizeof recvbuf) != 0)
FAIL ();
if (recv (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK)
!= sizeof recvbuf - 7
|| memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (recv (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK)
!= sizeof recvbuf)
FAIL ();
CHK_FAIL_END
CHK_FAIL_START
if (recv (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK)
!= sizeof recvbuf - 3)
FAIL ();
CHK_FAIL_END
#endif
socklen_t sl;
struct sockaddr_un sa_un;
sl = sizeof (sa_un);
if (recvfrom (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK, &sa_un, &sl)
!= sizeof recvbuf
|| memcmp (recvbuf, sendstr, sizeof recvbuf) != 0)
FAIL ();
sl = sizeof (sa_un);
if (recvfrom (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK,
&sa_un, &sl) != sizeof recvbuf - 7
|| memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
sl = sizeof (sa_un);
if (recvfrom (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK, &sa_un, &sl)
!= sizeof recvbuf)
FAIL ();
CHK_FAIL_END
CHK_FAIL_START
sl = sizeof (sa_un);
if (recvfrom (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK,
&sa_un, &sl) != sizeof recvbuf - 3)
FAIL ();
CHK_FAIL_END
#endif
close (sp[0]);
close (sp[1]);
}
char fname[] = "/tmp/tst-chk1-dir-XXXXXX\0foo";
char *enddir = strchr (fname, '\0');
if (mkdtemp (fname) == NULL)
{
printf ("mkdtemp failed: %m\n");
return 1;
}
*enddir = '/';
if (symlink ("bar", fname) != 0)
FAIL ();
char readlinkbuf[4];
if (readlink (fname, readlinkbuf, 4) != 3
|| memcmp (readlinkbuf, "bar", 3) != 0)
FAIL ();
if (readlink (fname, readlinkbuf + 1, l0 + 3) != 3
|| memcmp (readlinkbuf, "bbar", 4) != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (readlink (fname, readlinkbuf + 2, l0 + 3) != 3)
FAIL ();
CHK_FAIL_END
CHK_FAIL_START
if (readlink (fname, readlinkbuf + 3, 4) != 3)
FAIL ();
CHK_FAIL_END
#endif
char *cwd1 = getcwd (NULL, 0);
if (cwd1 == NULL)
FAIL ();
char *cwd2 = getcwd (NULL, 250);
if (cwd2 == NULL)
FAIL ();
if (cwd1 && cwd2)
{
if (strcmp (cwd1, cwd2) != 0)
FAIL ();
*enddir = '\0';
if (chdir (fname))
FAIL ();
char *cwd3 = getcwd (NULL, 0);
if (cwd3 == NULL)
FAIL ();
if (strcmp (fname, cwd3) != 0)
printf ("getcwd after chdir is '%s' != '%s',"
"get{c,}wd tests skipped\n", cwd3, fname);
else
{
char getcwdbuf[sizeof fname - 3];
char *cwd4 = getcwd (getcwdbuf, sizeof getcwdbuf);
if (cwd4 != getcwdbuf
|| strcmp (getcwdbuf, fname) != 0)
FAIL ();
cwd4 = getcwd (getcwdbuf + 1, l0 + sizeof getcwdbuf - 1);
if (cwd4 != getcwdbuf + 1
|| getcwdbuf[0] != fname[0]
|| strcmp (getcwdbuf + 1, fname) != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (getcwd (getcwdbuf + 2, l0 + sizeof getcwdbuf)
!= getcwdbuf + 2)
FAIL ();
CHK_FAIL_END
CHK_FAIL_START
if (getcwd (getcwdbuf + 2, sizeof getcwdbuf)
!= getcwdbuf + 2)
FAIL ();
CHK_FAIL_END
#endif
if (getwd (getcwdbuf) != getcwdbuf
|| strcmp (getcwdbuf, fname) != 0)
FAIL ();
if (getwd (getcwdbuf + 1) != getcwdbuf + 1
|| strcmp (getcwdbuf + 1, fname) != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (getwd (getcwdbuf + 2) != getcwdbuf + 2)
FAIL ();
CHK_FAIL_END
#endif
}
if (chdir (cwd1) != 0)
FAIL ();
free (cwd3);
}
free (cwd1);
free (cwd2);
*enddir = '/';
if (unlink (fname) != 0)
FAIL ();
*enddir = '\0';
if (rmdir (fname) != 0)
FAIL ();
#if PATH_MAX > 0
char largebuf[PATH_MAX];
char *realres = realpath (".", largebuf);
if (realres != largebuf)
FAIL ();
# if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
char realbuf[1];
realres = realpath (".", realbuf);
if (realres != realbuf)
FAIL ();
CHK_FAIL_END
# endif
#endif
if (setlocale (LC_ALL, "de_DE.UTF-8") != NULL)
{
assert (MB_CUR_MAX <= 10);
/* First a simple test. */
char enough[10];
if (wctomb (enough, L'A') != 1)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
/* We know the wchar_t encoding is ISO 10646. So pick a
character which has a multibyte representation which does not
fit. */
CHK_FAIL_START
char smallbuf[2];
if (wctomb (smallbuf, L'\x100') != 2)
FAIL ();
CHK_FAIL_END
#endif
mbstate_t s;
memset (&s, '\0', sizeof (s));
if (wcrtomb (enough, L'D', &s) != 1 || enough[0] != 'D')
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
/* We know the wchar_t encoding is ISO 10646. So pick a
character which has a multibyte representation which does not
fit. */
CHK_FAIL_START
char smallbuf[2];
if (wcrtomb (smallbuf, L'\x100', &s) != 2)
FAIL ();
CHK_FAIL_END
#endif
wchar_t wenough[10];
memset (&s, '\0', sizeof (s));
const char *cp = "A";
if (mbsrtowcs (wenough, &cp, 10, &s) != 1
|| wcscmp (wenough, L"A") != 0)
FAIL ();
cp = "BC";
if (mbsrtowcs (wenough, &cp, l0 + 10, &s) != 2
|| wcscmp (wenough, L"BC") != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
wchar_t wsmallbuf[2];
cp = "ABC";
mbsrtowcs (wsmallbuf, &cp, 10, &s);
CHK_FAIL_END
#endif
cp = "A";
if (mbstowcs (wenough, cp, 10) != 1
|| wcscmp (wenough, L"A") != 0)
FAIL ();
cp = "DEF";
if (mbstowcs (wenough, cp, l0 + 10) != 3
|| wcscmp (wenough, L"DEF") != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
wchar_t wsmallbuf[2];
cp = "ABC";
mbstowcs (wsmallbuf, cp, 10);
CHK_FAIL_END
#endif
memset (&s, '\0', sizeof (s));
cp = "ABC";
wcscpy (wenough, L"DEF");
if (mbsnrtowcs (wenough, &cp, 1, 10, &s) != 1
|| wcscmp (wenough, L"AEF") != 0)
FAIL ();
cp = "IJ";
if (mbsnrtowcs (wenough, &cp, 1, l0 + 10, &s) != 1
|| wcscmp (wenough, L"IEF") != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
wchar_t wsmallbuf[2];
cp = "ABC";
mbsnrtowcs (wsmallbuf, &cp, 3, 10, &s);
CHK_FAIL_END
#endif
memset (&s, '\0', sizeof (s));
const wchar_t *wcp = L"A";
if (wcsrtombs (enough, &wcp, 10, &s) != 1
|| strcmp (enough, "A") != 0)
FAIL ();
wcp = L"BC";
if (wcsrtombs (enough, &wcp, l0 + 10, &s) != 2
|| strcmp (enough, "BC") != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
char smallbuf[2];
wcp = L"ABC";
wcsrtombs (smallbuf, &wcp, 10, &s);
CHK_FAIL_END
#endif
memset (enough, 'Z', sizeof (enough));
wcp = L"EF";
if (wcstombs (enough, wcp, 10) != 2
|| strcmp (enough, "EF") != 0)
FAIL ();
wcp = L"G";
if (wcstombs (enough, wcp, l0 + 10) != 1
|| strcmp (enough, "G") != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
char smallbuf[2];
wcp = L"ABC";
wcstombs (smallbuf, wcp, 10);
CHK_FAIL_END
#endif
memset (&s, '\0', sizeof (s));
wcp = L"AB";
if (wcsnrtombs (enough, &wcp, 1, 10, &s) != 1
|| strcmp (enough, "A") != 0)
FAIL ();
wcp = L"BCD";
if (wcsnrtombs (enough, &wcp, 1, l0 + 10, &s) != 1
|| strcmp (enough, "B") != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
char smallbuf[2];
wcp = L"ABC";
wcsnrtombs (smallbuf, &wcp, 3, 10, &s);
CHK_FAIL_END
#endif
}
size_t wcstombs(char *s, const wchar_t *pwcs, size_t n)
{
return wcsrtombs(s, &pwcs, n, NULL);
}