TDR_PULL_NEED_BYTES(tdr, el_size*length);
- if (!convert_string_talloc(ctx, chset, CH_UNIX, tdr->data.data+tdr->offset, el_size*length, discard_const_p(void *, v), &ret, false)) {
+ if (!convert_string_talloc(ctx, chset, CH_UNIX, tdr->data.data+tdr->offset, el_size*length, discard_const_p(void *, v), &ret)) {
return NT_STATUS_INVALID_PARAMETER;
}
required = el_size * length;
TDR_PUSH_NEED_BYTES(tdr, required);
- ret = convert_string(CH_UNIX, chset, *v, strlen(*v), tdr->data.data+tdr->data.length, required, false);
+ ret = convert_string(CH_UNIX, chset, *v, strlen(*v), tdr->data.data+tdr->data.length, required);
if (ret == -1) {
return NT_STATUS_INVALID_PARAMETER;
}
* @returns the number of bytes occupied in the destination
**/
_PUBLIC_ bool convert_string_convenience(struct smb_iconv_convenience *ic,
- charset_t from, charset_t to,
- void const *src, size_t srclen,
- void *dest, size_t destlen, size_t *converted_size,
- bool allow_badcharcnv)
+ charset_t from, charset_t to,
+ void const *src, size_t srclen,
+ void *dest, size_t destlen, size_t *converted_size)
{
size_t i_len, o_len;
size_t retval;
**/
_PUBLIC_ bool convert_string_talloc_convenience(TALLOC_CTX *ctx,
- struct smb_iconv_convenience *ic,
- charset_t from, charset_t to,
- void const *src, size_t srclen,
- void *dst, size_t *converted_size,
- bool allow_badcharcnv)
+ struct smb_iconv_convenience *ic,
+ charset_t from, charset_t to,
+ void const *src, size_t srclen,
+ void *dst, size_t *converted_size)
{
void **dest = (void **)dst;
smb_iconv_t descriptor;
ssize_t pull_string(char *dest, const void *src, size_t dest_len, size_t src_len, int flags);
bool convert_string_talloc(TALLOC_CTX *ctx,
- charset_t from, charset_t to,
- void const *src, size_t srclen,
- void *dest, size_t *converted_size,
- bool allow_badcharcnv);
+ charset_t from, charset_t to,
+ void const *src, size_t srclen,
+ void *dest, size_t *converted_size);
size_t convert_string(charset_t from, charset_t to,
- void const *src, size_t srclen,
- void *dest, size_t destlen, bool allow_badcharcnv);
+ void const *src, size_t srclen,
+ void *dest, size_t destlen);
ssize_t iconv_talloc(TALLOC_CTX *mem_ctx,
smb_iconv_t cd,
bool convert_string_convenience(struct smb_iconv_convenience *ic,
charset_t from, charset_t to,
void const *src, size_t srclen,
- void *dest, size_t destlen, size_t *converted_size,
- bool allow_badcharcnv);
+ void *dest, size_t destlen, size_t *converted_size);
bool convert_string_talloc_convenience(TALLOC_CTX *ctx,
struct smb_iconv_convenience *ic,
charset_t from, charset_t to,
void const *src, size_t srclen,
- void *dest, size_t *converted_size, bool allow_badcharcnv);
+ void *dest, size_t *converted_size);
/* iconv */
smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode);
int smb_iconv_close(smb_iconv_t cd);
torture_comment(tctx, "converting random buffer\n");
- if (!convert_string_talloc(mem_ctx, CH_UTF16MUNGED, CH_UTF8, (void *)buf, len*2, (void**)&dest, &ret, false)) {
+ if (!convert_string_talloc(mem_ctx, CH_UTF16MUNGED, CH_UTF8, (void *)buf, len*2, (void**)&dest, &ret)) {
torture_fail(tctx, "Failed to convert random buffer\n");
}
torture_comment(tctx, "converting fixed buffer to UTF16\n");
- if (!convert_string_talloc(mem_ctx, CH_UTF16MUNGED, CH_UTF16, (void *)le1, 20, (void**)&munged1, &ret, false)) {
+ if (!convert_string_talloc(mem_ctx, CH_UTF16MUNGED, CH_UTF16, (void *)le1, 20, (void**)&munged1, &ret)) {
torture_fail(tctx, "Failed to convert fixed buffer to UTF16_MUNGED\n");
}
torture_comment(tctx, "converting fixed buffer to UTF8\n");
- if (!convert_string_talloc(mem_ctx, CH_UTF16MUNGED, CH_UTF8, (void *)le1, 20, (void**)&out1, &ret, false)) {
+ if (!convert_string_talloc(mem_ctx, CH_UTF16MUNGED, CH_UTF8, (void *)le1, 20, (void**)&out1, &ret)) {
torture_fail(tctx, "Failed to convert fixed buffer to UTF8\n");
}
if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
src_len++;
- return convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len, false);
+ return convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len);
}
/**
{
size_t src_len = strlen(src)+1;
*dest = NULL;
- return convert_string_talloc(ctx, CH_UNIX, CH_DOS, src, src_len, (void **)dest, converted_size, false);
+ return convert_string_talloc(ctx, CH_UNIX, CH_DOS, src, src_len, (void **)dest, converted_size);
}
}
}
- ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len, false);
+ ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len);
if (dest_len)
dest[MIN(ret, dest_len-1)] = 0;
/* ucs2 is always a multiple of 2 bytes */
dest_len &= ~1;
- ret = convert_string(CH_UNIX, CH_UTF16, src, src_len, dest, dest_len, false);
+ ret = convert_string(CH_UNIX, CH_UTF16, src, src_len, dest, dest_len);
if (ret == (size_t)-1) {
return 0;
}
{
size_t src_len = strlen(src)+1;
*dest = NULL;
- return convert_string_talloc(ctx, CH_UNIX, CH_UTF16, src, src_len, (void **)dest, converted_size, false);
+ return convert_string_talloc(ctx, CH_UNIX, CH_UTF16, src, src_len, (void **)dest, converted_size);
}
{
size_t src_len = strlen(src)+1;
*dest = NULL;
- return convert_string_talloc(ctx, CH_UNIX, CH_UTF8, src, src_len, (void **)dest, converted_size, false);
+ return convert_string_talloc(ctx, CH_UNIX, CH_UTF8, src, src_len, (void **)dest, converted_size);
}
/**
if (src_len != (size_t)-1)
src_len &= ~1;
- ret = convert_string(CH_UTF16, CH_UNIX, src, src_len, dest, dest_len, false);
+ ret = convert_string(CH_UTF16, CH_UNIX, src, src_len, dest, dest_len);
if (dest_len)
dest[MIN(ret, dest_len-1)] = 0;
{
size_t src_len = strlen(src)+1;
*dest = NULL;
- return convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len, (void **)dest, converted_size, false);
+ return convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len, (void **)dest, converted_size);
}
/**
{
size_t src_len = utf16_len(src);
*dest = NULL;
- return convert_string_talloc(ctx, CH_UTF16, CH_UNIX, src, src_len, (void **)dest, converted_size, false);
+ return convert_string_talloc(ctx, CH_UTF16, CH_UNIX, src, src_len, (void **)dest, converted_size);
}
/**
{
size_t src_len = strlen(src)+1;
*dest = NULL;
- return convert_string_talloc(ctx, CH_UTF8, CH_UNIX, src, src_len, (void **)dest, converted_size, false);
+ return convert_string_talloc(ctx, CH_UTF8, CH_UNIX, src, src_len, (void **)dest, converted_size);
}
/**
* @returns the number of bytes occupied in the destination
**/
_PUBLIC_ size_t convert_string(charset_t from, charset_t to,
- void const *src, size_t srclen,
- void *dest, size_t destlen,
- bool allow_badcharcnv)
+ void const *src, size_t srclen,
+ void *dest, size_t destlen)
{
size_t ret;
if (!convert_string_convenience(get_iconv_convenience(), from, to,
- src, srclen,
- dest, destlen, &ret,
- allow_badcharcnv))
+ src, srclen,
+ dest, destlen, &ret))
return -1;
return ret;
}
**/
_PUBLIC_ bool convert_string_talloc(TALLOC_CTX *ctx,
- charset_t from, charset_t to,
- void const *src, size_t srclen,
- void *dest, size_t *converted_size,
- bool allow_badcharcnv)
+ charset_t from, charset_t to,
+ void const *src, size_t srclen,
+ void *dest, size_t *converted_size)
{
return convert_string_talloc_convenience(ctx, get_iconv_convenience(),
- from, to, src, srclen, dest,
- converted_size,
- allow_badcharcnv);
+ from, to, src, srclen, dest,
+ converted_size);
}
size_t pull_len;
if (!convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX,
blob->data + ptr, len1,
- ps, &pull_len, false)) {
+ ps, &pull_len)) {
ret = false;
goto cleanup;
}
if (!convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX,
blob->data + ptr, len1,
- ps, &pull_len, false)) {
+ ps, &pull_len)) {
ret = false;
goto cleanup;
}
if (lm_response->length &&
(convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX,
lm_response->data, lm_response->length,
- (void *)&unix_pw, NULL, false))) {
+ (void *)&unix_pw, NULL))) {
if (E_deshash(unix_pw, client_lm.hash)) {
lm_ok = true;
} else {
&in_buffer[512 - byte_len],
byte_len,
(void *)pp_new_pwrd,
- new_pw_len,
- false)) {
+ new_pw_len)) {
DEBUG(0, ("decode_pw_buffer: failed to convert incoming password\n"));
return false;
}
}
if (!convert_string_talloc(mem_ctx, CH_UTF16LE, CH_UNIX, data_in, n,
- (void *)&data_out, &converted_size, false))
+ (void *)&data_out, &converted_size))
{
status = NT_STATUS_INVALID_BUFFER_SIZE;
goto out;
CH_UTF16, CH_UNIX,
r->blob->data,
r->blob->length,
- (void **)&str, NULL, false)) {
+ (void **)&str, NULL)) {
ndr_print_string(ndr, "string", "INVALID CONVERSION");
} else {
ndr_print_string(ndr, "string", str);
ndr->data+ndr->offset,
(len2 + c_len_term)*byte_mul,
(void **)(void *)&as,
- &converted_size, false))
+ &converted_size))
{
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
"Bad character conversion with flags 0x%x", flags);
ndr->data+ndr->offset,
(len1 + c_len_term)*byte_mul,
(void **)(void *)&as,
- &converted_size, false))
+ &converted_size))
{
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
"Bad character conversion with flags 0x%x", flags);
ndr->data+ndr->offset,
(len1 + c_len_term)*byte_mul,
(void **)(void *)&as,
- &converted_size, false))
+ &converted_size))
{
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
"Bad character conversion with flags 0x%x", flags);
ndr->data+ndr->offset,
(len3 + c_len_term)*byte_mul,
(void **)(void *)&as,
- &converted_size, false))
+ &converted_size))
{
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
"Bad character conversion with flags 0x%x", flags);
CH_UNIX,
ndr->data+ndr->offset, len3,
(void **)(void *)&as,
- &converted_size, false))
+ &converted_size))
{
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
"Bad character conversion with flags 0x%x", flags);
if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
ndr->data+ndr->offset, len1,
(void **)(void *)&as,
- &converted_size, false))
+ &converted_size))
{
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
"Bad character conversion with flags 0x%x", flags);
CH_UNIX,
ndr->data+ndr->offset, len1,
(void **)(void *)&as,
- &converted_size, false))
+ &converted_size))
{
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
"Bad character conversion with flags 0x%x", flags);
s_len++;
}
if (!convert_string_talloc(ndr, CH_UNIX, chset, s, s_len,
- (void **)(void *)&dest, &d_len, false))
+ (void **)(void *)&dest, &d_len))
{
return ndr_push_error(ndr, NDR_ERR_CHARCNV,
"Bad character push conversion with flags 0x%x", flags);
if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
ndr->data+ndr->offset, length*byte_mul,
discard_const_p(void *, var),
- &converted_size, false))
+ &converted_size))
{
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
"Bad character conversion");
NDR_PUSH_NEED_BYTES(ndr, required);
ret = convert_string(CH_UNIX, chset,
var, strlen(var),
- ndr->data+ndr->offset, required, false);
+ ndr->data+ndr->offset, required);
if (ret == -1) {
return ndr_push_error(ndr, NDR_ERR_CHARCNV,
"Bad character conversion");
void init_iconv(void);
size_t convert_string(charset_t from, charset_t to,
void const *src, size_t srclen,
- void *dest, size_t destlen, bool allow_bad_conv);
+ void *dest, size_t destlen);
size_t unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen);
char *talloc_strdup_upper(TALLOC_CTX *ctx, const char *s);
char *strupper_talloc(TALLOC_CTX *ctx, const char *s);
* @param srclen length of the source string in bytes
* @param dest pointer to destination string (multibyte or singlebyte)
* @param destlen maximal length allowed for string
- * @param allow_bad_conv determines if a "best effort" conversion is acceptable (never returns errors)
* @returns the number of bytes occupied in the destination
*
* Ensure the srclen contains the terminating zero.
static size_t convert_string_internal(charset_t from, charset_t to,
void const *src, size_t srclen,
- void *dest, size_t destlen, bool allow_bad_conv)
+ void *dest, size_t destlen)
{
size_t i_len, o_len;
size_t retval;
reason="Incomplete multibyte sequence";
if (!conv_silent)
DEBUG(3,("convert_string_internal: Conversion error: %s(%s)\n",reason,inbuf));
- if (allow_bad_conv)
- goto use_as_is;
return (size_t)-1;
case E2BIG:
reason="No more room";
reason="Illegal multibyte sequence";
if (!conv_silent)
DEBUG(3,("convert_string_internal: Conversion error: %s(%s)\n",reason,inbuf));
- if (allow_bad_conv)
- goto use_as_is;
-
return (size_t)-1;
default:
if (!conv_silent)
/* smb_panic(reason); */
}
return destlen-o_len;
-
- use_as_is:
-
- /*
- * Conversion not supported. This is actually an error, but there are so
- * many misconfigured iconv systems and smb.conf's out there we can't just
- * fail. Do a very bad conversion instead.... JRA.
- */
-
- {
- if (o_len == 0 || i_len == 0)
- return destlen - o_len;
-
- if (((from == CH_UTF16LE)||(from == CH_UTF16BE)) &&
- ((to != CH_UTF16LE)||(to != CH_UTF16BE))) {
- /* Can't convert from utf16 any endian to multibyte.
- Replace with the default fail char.
- */
- if (i_len < 2)
- return destlen - o_len;
- if (i_len >= 2) {
- *outbuf = lp_failed_convert_char();
-
- outbuf++;
- o_len--;
-
- inbuf += 2;
- i_len -= 2;
- }
-
- if (o_len == 0 || i_len == 0)
- return destlen - o_len;
-
- /* Keep trying with the next char... */
- goto again;
-
- } else if (from != CH_UTF16LE && from != CH_UTF16BE && to == CH_UTF16LE) {
- /* Can't convert to UTF16LE - just widen by adding the
- default fail char then zero.
- */
- if (o_len < 2)
- return destlen - o_len;
-
- outbuf[0] = lp_failed_convert_char();
- outbuf[1] = '\0';
-
- inbuf++;
- i_len--;
-
- outbuf += 2;
- o_len -= 2;
-
- if (o_len == 0 || i_len == 0)
- return destlen - o_len;
-
- /* Keep trying with the next char... */
- goto again;
-
- } else if (from != CH_UTF16LE && from != CH_UTF16BE &&
- to != CH_UTF16LE && to != CH_UTF16BE) {
- /* Failed multibyte to multibyte. Just copy the default fail char and
- try again. */
- outbuf[0] = lp_failed_convert_char();
-
- inbuf++;
- i_len--;
-
- outbuf++;
- o_len--;
-
- if (o_len == 0 || i_len == 0)
- return destlen - o_len;
-
- /* Keep trying with the next char... */
- goto again;
-
- } else {
- /* Keep compiler happy.... */
- return destlen - o_len;
- }
- }
}
/**
* @param srclen length of the source string in bytes, or -1 for nul terminated.
* @param dest pointer to destination string (multibyte or singlebyte)
* @param destlen maximal length allowed for string - *NEVER* -1.
- * @param allow_bad_conv determines if a "best effort" conversion is acceptable (never returns errors)
* @returns the number of bytes occupied in the destination
*
* Ensure the srclen contains the terminating zero.
size_t convert_string(charset_t from, charset_t to,
void const *src, size_t srclen,
- void *dest, size_t destlen, bool allow_bad_conv)
+ void *dest, size_t destlen)
{
/*
* NB. We deliberately don't do a strlen here if srclen == -1.
#ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
goto general_case;
#else
- size_t ret = convert_string_internal(from, to, p, slen, q, dlen, allow_bad_conv);
+ size_t ret = convert_string_internal(from, to, p, slen, q, dlen);
if (ret == (size_t)-1) {
return ret;
}
#ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
goto general_case;
#else
- size_t ret = convert_string_internal(from, to, p, slen, q, dlen, allow_bad_conv);
+ size_t ret = convert_string_internal(from, to, p, slen, q, dlen);
if (ret == (size_t)-1) {
return ret;
}
#ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
goto general_case;
#else
- size_t ret = convert_string_internal(from, to, p, slen, q, dlen, allow_bad_conv);
+ size_t ret = convert_string_internal(from, to, p, slen, q, dlen);
if (ret == (size_t)-1) {
return ret;
}
#ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
general_case:
#endif
- return convert_string_internal(from, to, src, srclen, dest, destlen, allow_bad_conv);
+ return convert_string_internal(from, to, src, srclen, dest, destlen);
}
/**
*/
bool convert_string_talloc(TALLOC_CTX *ctx, charset_t from, charset_t to,
void const *src, size_t srclen, void *dst,
- size_t *converted_size, bool allow_bad_conv)
+ size_t *converted_size)
{
size_t i_len, o_len, destlen = (srclen * 3) / 2;
reason="Incomplete multibyte sequence";
if (!conv_silent)
DEBUG(3,("convert_string_talloc: Conversion error: %s(%s)\n",reason,inbuf));
- if (allow_bad_conv)
- goto use_as_is;
break;
case E2BIG:
goto convert;
reason="Illegal multibyte sequence";
if (!conv_silent)
DEBUG(3,("convert_string_talloc: Conversion error: %s(%s)\n",reason,inbuf));
- if (allow_bad_conv)
- goto use_as_is;
break;
}
if (!conv_silent)
*converted_size = destlen;
return true;
-
- use_as_is:
-
- /*
- * Conversion not supported. This is actually an error, but there are so
- * many misconfigured iconv systems and smb.conf's out there we can't just
- * fail. Do a very bad conversion instead.... JRA.
- */
-
- {
- if (o_len == 0 || i_len == 0)
- goto out;
-
- if (((from == CH_UTF16LE)||(from == CH_UTF16BE)) &&
- ((to != CH_UTF16LE)||(to != CH_UTF16BE))) {
- /* Can't convert from utf16 any endian to multibyte.
- Replace with the default fail char.
- */
-
- if (i_len < 2)
- goto out;
-
- if (i_len >= 2) {
- *outbuf = lp_failed_convert_char();
-
- outbuf++;
- o_len--;
-
- inbuf += 2;
- i_len -= 2;
- }
-
- if (o_len == 0 || i_len == 0)
- goto out;
-
- /* Keep trying with the next char... */
- goto again;
-
- } else if (from != CH_UTF16LE && from != CH_UTF16BE && to == CH_UTF16LE) {
- /* Can't convert to UTF16LE - just widen by adding the
- default fail char then zero.
- */
- if (o_len < 2)
- goto out;
-
- outbuf[0] = lp_failed_convert_char();
- outbuf[1] = '\0';
-
- inbuf++;
- i_len--;
-
- outbuf += 2;
- o_len -= 2;
-
- if (o_len == 0 || i_len == 0)
- goto out;
-
- /* Keep trying with the next char... */
- goto again;
-
- } else if (from != CH_UTF16LE && from != CH_UTF16BE &&
- to != CH_UTF16LE && to != CH_UTF16BE) {
- /* Failed multibyte to multibyte. Just copy the default fail char and
- try again. */
- outbuf[0] = lp_failed_convert_char();
-
- inbuf++;
- i_len--;
-
- outbuf++;
- o_len--;
-
- if (o_len == 0 || i_len == 0)
- goto out;
-
- /* Keep trying with the next char... */
- goto again;
-
- } else {
- /* Keep compiler happy.... */
- goto out;
- }
- }
}
size_t unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen)
return srclen;
}
- size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, True);
+ size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen);
TALLOC_FREE(buffer);
return size;
}
if (!convert_string_talloc(ctx, CH_UNIX, CH_UTF16LE, s,
strlen(s)+1, (void *)&ubuf,
- &converted_size, True))
+ &converted_size))
{
return NULL;
}
if (!convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, ubuf,
converted_size, (void *)&out_buffer,
- &converted_size2, True))
+ &converted_size2))
{
TALLOC_FREE(ubuf);
return NULL;
smb_ucs2_t *buffer = NULL;
if (!convert_string_talloc(talloc_tos(), CH_UNIX, CH_UTF16LE, src, srclen,
- (void **)(void *)&buffer, &size,
- True))
+ (void **)(void *)&buffer, &size))
{
smb_panic("failed to create UCS2 buffer");
}
TALLOC_FREE(buffer);
return srclen;
}
- size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, True);
+ size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen);
TALLOC_FREE(buffer);
return size;
}
src_len++;
}
- ret = convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len, True);
+ ret = convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len);
if (ret == (size_t)-1 &&
(flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
&& dest_len > 0) {
for (i = 0; buffer[i] != 0 && (i < buffer_len); i++) {
unsigned char mb[10];
/* Convert one smb_ucs2_t character at a time. */
- size_t mb_len = convert_string(CH_UTF16LE, CH_DOS, buffer+i, sizeof(smb_ucs2_t), mb, sizeof(mb), False);
+ size_t mb_len = convert_string(CH_UTF16LE, CH_DOS, buffer+i, sizeof(smb_ucs2_t), mb, sizeof(mb));
if ((mb_len != (size_t)-1) && (dest_len + mb_len <= MAX_NETBIOSNAME_LEN - 1)) {
memcpy((char *)dest + dest_len, mb, mb_len);
dest_len += mb_len;
*dest = NULL;
return convert_string_talloc(mem_ctx, CH_UNIX, CH_DOS, src, src_len,
- (void **)dest, converted_size, True);
+ (void **)dest, converted_size);
}
/**
}
}
- ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len, True);
+ ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len);
if (ret == (size_t)-1) {
ret = 0;
dest_len = 0;
/* src_len != -1 here. */
if (!convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len, &dest,
- &dest_len, True)) {
+ &dest_len)) {
dest_len = 0;
}
/* ucs2 is always a multiple of 2 bytes */
dest_len &= ~1;
- ret = convert_string(CH_UNIX, CH_UTF16LE, src, src_len, dest, dest_len, True);
+ ret = convert_string(CH_UNIX, CH_UTF16LE, src, src_len, dest, dest_len);
if (ret == (size_t)-1) {
if ((flags & STR_TERMINATE) &&
dest &&
*dest = NULL;
return convert_string_talloc(ctx, CH_UNIX, CH_UTF16LE, src, src_len,
- (void **)dest, converted_size, True);
+ (void **)dest, converted_size);
}
src_len++;
}
- ret = convert_string(CH_UNIX, CH_UTF8, src, src_len, dest, dest_len, True);
+ ret = convert_string(CH_UNIX, CH_UTF8, src, src_len, dest, dest_len);
TALLOC_FREE(tmpbuf);
return ret;
}
*dest = NULL;
return convert_string_talloc(ctx, CH_UNIX, CH_UTF8, src, src_len,
- (void**)dest, converted_size, True);
+ (void**)dest, converted_size);
}
/**
if (src_len != (size_t)-1)
src_len &= ~1;
- ret = convert_string(CH_UTF16LE, CH_UNIX, src, src_len, dest, dest_len, True);
+ ret = convert_string(CH_UTF16LE, CH_UNIX, src, src_len, dest, dest_len);
if (ret == (size_t)-1) {
ret = 0;
dest_len = 0;
src_len &= ~1;
if (!convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src, src_len,
- (void *)&dest, &dest_len, True)) {
+ (void *)&dest, &dest_len)) {
dest_len = 0;
}
*dest = NULL;
return convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src, src_len,
- (void **)dest, converted_size, True);
+ (void **)dest, converted_size);
}
/**
*dest = NULL;
return convert_string_talloc(ctx, CH_UTF8, CH_UNIX, src, src_len,
- (void **)dest, converted_size, True);
+ (void **)dest, converted_size);
}
*dest = NULL;
return convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len,
- (void **)dest, converted_size, True);
+ (void **)dest, converted_size);
}
/**
goto out;
}
- clen = convert_string(CH_UNIX, CH_DISPLAY, p, ret, p2, maxlen, True);
+ clen = convert_string(CH_UNIX, CH_DISPLAY, p, ret, p2, maxlen);
if (clen == -1) {
ret = -1;
goto out;
size_t len;
if (!convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX,
t->sid.data, t->sid.length,
- (void *)&sid_str, &len, false)) {
+ (void *)&sid_str, &len)) {
return NT_STATUS_INVALID_SID;
}
if (len > 0) {
return False;
}
- if (convert_string(CH_UTF8, CH_UNIX,values[0], -1, value, max_len, False) == (size_t)-1) {
+ if (convert_string(CH_UTF8, CH_UNIX,values[0], -1, value, max_len) == (size_t)-1) {
DEBUG(1, ("smbldap_get_single_attribute: string conversion of [%s] = [%s] failed!\n",
attribute, values[0]));
ldap_value_free(values);
}
if (!convert_string_talloc(mem_ctx, CH_UTF8, CH_UNIX,
val.data, val.length,
- &result, &len, false)) {
+ &result, &len)) {
return NULL;
}
return result;
bool ret;
if (!convert_string_talloc(talloc_tos(), CH_UNIX, CH_UTF8, str,
- strlen(str), &utf8.data, &utf8.length,
- false)) {
+ strlen(str), &utf8.data, &utf8.length)) {
return false;
}
int ret;
if (!convert_string_talloc(talloc_tos(), CH_UTF8, CH_UNIX, d1->data,
- d1->length, &s1, &s1len, false)) {
+ d1->length, &s1, &s1len)) {
/* can't do much here */
return 0;
}
if (!convert_string_talloc(talloc_tos(), CH_UTF8, CH_UNIX, d2->data,
- d2->length, &s2, &s2len, false)) {
+ d2->length, &s2, &s2len)) {
/* can't do much here */
TALLOC_FREE(s1);
return 0;
if (!convert_string_talloc(talloc_tos(), CH_UNIX,
ucs2 ? CH_UTF16LE : CH_DOS,
str, str_len, &converted,
- &converted_size, true)) {
+ &converted_size)) {
return NULL;
}
state->data,
state->num_data,
&converted,
- &converted_size,
- true)) {
+ &converted_size)) {
return NT_STATUS_NO_MEMORY;
}
ret = convert_string_talloc(
names, CH_UTF16LE, CH_UNIX,
src, 2 * sizeof(SHADOW_COPY_LABEL),
- &names[i], &converted_size, True);
+ &names[i], &converted_size);
if (!ret) {
TALLOC_FREE(names);
return NT_STATUS_INVALID_NETWORK_RESPONSE;
if (!convert_string_talloc(talloc_tos(), CH_UNIX, CH_DOS,
username, strlen(username)+1,
- &utmp, &ulen, true)) {
+ &utmp, &ulen)) {
goto fail;
}
if (!convert_string_talloc(talloc_tos(), CH_UNIX, CH_DOS,
host, strlen(host)+1,
- &htmp, &hlen, true)) {
+ &htmp, &hlen)) {
goto fail;
}
SSVAL(&state->vwv, 0, grp);
if (convert_string_talloc(talloc_tos(), CH_UNIX, CH_DOS, msg, msglen,
- &tmp, &tmplen, true)) {
+ &tmp, &tmplen)) {
msg = tmp;
msglen = tmplen;
} else {
tmp_buf[nlen+1] = 0;
if (!convert_string_talloc(streams, CH_UTF16, CH_UNIX, tmp_buf,
- nlen+2, &vstr, &size, false))
+ nlen+2, &vstr, &size))
{
TALLOC_FREE(tmp_buf);
goto fail;
rdata + 4,
len,
&converted,
- &converted_size,
- true)) {
+ &converted_size)) {
return NT_STATUS_NO_MEMORY;
}
fstrcpy(alt_name, converted);
cli_ucs2(cli) ? CH_UTF16LE : CH_DOS,
pipe_name, strlen(pipe_name) + 1,
&state->pipe_name_conv,
- &state->pipe_name_conv_len, true))) {
+ &state->pipe_name_conv_len))) {
tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
return tevent_req_post(req, ev);
}
ret &= convert_string_talloc(talloc_tos(),
CH_UNIX, CH_UTF16LE,
pw_quote, strlen(pw_quote),
- &pw_utf16, &pw_utf16_len, false);
+ &pw_utf16, &pw_utf16_len);
if (!ret) {
goto fail;
}
bool ret;
if (!convert_string_talloc(talloc_tos(), CH_UTF8, CH_UNIX,
- dnblob->data, dnblob->length, &dn, &len,
- false)) {
+ dnblob->data, dnblob->length, &dn, &len)) {
return false;
}
rc = pdb_ads_search_fmt(state, dn, TLDAP_SCOPE_BASE,
if (convert_string_talloc(p->valblob, CH_UNIX, CH_UTF16LE,
src, strlen(src)+1,
- &dst, &dlen, true))
+ &dst, &dlen))
{
cbuf_swapptr(p->valblob, &dst, dlen);
} else {
auth_struct->incoming.current.array[i].AuthInfo.clear.password,
auth_struct->incoming.current.array[i].AuthInfo.clear.size,
&dummy,
- &dummy_size,
- false)) {
+ &dummy_size)) {
return NT_STATUS_UNSUCCESSFUL;
}
if (!pdb_set_plaintext_passwd(sam_acct, dummy)) {
* for mb UNIX asian characters like Japanese (SJIS) here.
* JRA.
*/
- if (convert_string(CH_UNIX, CH_UTF16LE, name, 2, mbc, 2, False) == 2) {
+ if (convert_string(CH_UNIX, CH_UTF16LE, name, 2, mbc, 2) == 2) {
/* Was a good mb string. */
name += 2;
continue;
if (!convert_string_talloc(talloc_tos(), CH_DOS, CH_UNIX, state->msg,
talloc_get_size(state->msg), (void *)&msg,
- &len, true)) {
+ &len)) {
DEBUG(3, ("Conversion failed, delivering message in DOS "
"codepage format\n"));
msg = state->msg;
in_name_buffer.data,
in_name_buffer.length,
&in_name_string,
- &in_name_string_size, false);
+ &in_name_string_size);
if (!ok) {
return smbd_smb2_request_error(smb2req, NT_STATUS_ILLEGAL_CHARACTER);
}
in_file_name_buffer.data,
in_file_name_buffer.length,
&in_file_name_string,
- &in_file_name_string_size, false);
+ &in_file_name_string_size);
if (!ok) {
return smbd_smb2_request_error(req, NT_STATUS_ILLEGAL_CHARACTER);
}
in_file_name_buffer.data,
in_file_name_buffer.length,
&in_file_name_string,
- &in_file_name_string_size, false);
+ &in_file_name_string_size);
if (!ok) {
tevent_req_nterror(req, NT_STATUS_ILLEGAL_CHARACTER);
return tevent_req_post(req, ev);
in_path_buffer.data,
in_path_buffer.length,
&in_path_string,
- &in_path_string_size, false);
+ &in_path_string_size);
if (!ok) {
return smbd_smb2_request_error(req, NT_STATUS_ILLEGAL_CHARACTER);
}
p = fname+strlen(fname);
len = convert_string(CH_UTF16LE, CH_UNIX,
&c2, 2,
- p, sizeof(fname)-strlen(fname), True);
+ p, sizeof(fname)-strlen(fname));
p[len] = 0;
fstrcat(fname,"_a_long_extension");
len = convert_string(CH_UTF16LE, CH_UNIX,
&c2, 2,
- p, sizeof(fname)-strlen(fname), True);
+ p, sizeof(fname)-strlen(fname));
p[len] = 0;
return fname;
}
CH_DOS, password,
strlen(password)+1,
&lm_response.data,
- &lm_response.length, True)) {
+ &lm_response.length)) {
DEBUG(0, ("convert_string_talloc failed!\n"));
exit(1);
}
convert_string_talloc(frame, CH_UTF8, CH_UNIX,
variables[i].name, strlen(variables[i].name),
- &dest, &dest_len, True);
+ &dest, &dest_len);
SAFE_FREE(variables[i].name);
variables[i].name = SMB_STRDUP(dest ? dest : "");
dest = NULL;
convert_string_talloc(frame, CH_UTF8, CH_UNIX,
variables[i].value, strlen(variables[i].value),
- &dest, &dest_len, True);
+ &dest, &dest_len);
SAFE_FREE(variables[i].value);
variables[i].value = SMB_STRDUP(dest ? dest : "");
TALLOC_FREE(frame);
convert_string(CH_UTF8, CH_UNIX,
line, -1,
- user, sizeof(user), True);
+ user, sizeof(user));
convert_string(CH_UTF8, CH_UNIX,
p+1, -1,
- user_pass, sizeof(user_pass), True);
+ user_pass, sizeof(user_pass));
/*
* Try and get the user from the UNIX password file.
g->cleartext_utf8->data,
g->cleartext_utf8->length,
(void *)&cleartext_utf16_blob->data,
- &cleartext_utf16_blob->length,
- false)) {
+ &cleartext_utf16_blob->length)) {
if (g->cleartext_utf8->length != 0) {
talloc_free(cleartext_utf16_blob);
ldb_asprintf_errstring(ldb,
g->cleartext_utf16->data,
g->cleartext_utf16->length,
(void *)&cleartext_utf8_blob->data,
- &cleartext_utf8_blob->length,
- false)) {
+ &cleartext_utf8_blob->length)) {
if (g->cleartext_utf16->length != 0) {
/* We must bail out here, the input wasn't even
* a multiple of 2 bytes */
CH_UNIX, CH_UTF16,
newpass, strlen(newpass),
(void *)&newpass_utf16.data,
- &newpass_utf16.length, false)) {
+ &newpass_utf16.length)) {
ldb_asprintf_errstring(ldb,
"samldb_rodc_add: "
"failed to generate UTF16 password from random password");
CH_UTF16, CH_UNIX,
in->value_ctr.values[i].blob->data,
in->value_ctr.values[i].blob->length,
- (void **)&str, NULL, false)) {
+ (void **)&str, NULL)) {
return WERR_FOOBAR;
}
if (!convert_string_talloc(blobs,
CH_UNIX, CH_UTF16,
in->values[i].data, in->values[i].length,
- (void **)&blobs[i].data, &blobs[i].length, false)) {
+ (void **)&blobs[i].data, &blobs[i].length)) {
return WERR_FOOBAR;
}
}
val->data,
val->length,
(void **)&dst,
- &size, false);
+ &size);
TALLOC_FREE(dst);
if (!ok) {
return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
if (!convert_string_talloc(out->values, CH_UTF16, CH_UNIX,
in->value_ctr.values[i].blob->data+4,
in->value_ctr.values[i].blob->length-4,
- (void **)&str, NULL, false)) {
+ (void **)&str, NULL)) {
return WERR_FOOBAR;
}
if (!convert_string_talloc(blobs, CH_UNIX, CH_UTF16,
in->values[i].data,
in->values[i].length,
- (void **)&data, &ret, false)) {
+ (void **)&data, &ret)) {
return WERR_FOOBAR;
}
CH_UTF8, CH_UTF16,
(const char *)input->data,
input->length,
- (void **)&password.data, &pw_len, false)) {
+ (void **)&password.data, &pw_len)) {
return false;
}
password.length = pw_len;
CH_UTF8, CH_UTF16,
(const char *)chpw.newpasswd.data,
chpw.newpasswd.length,
- (void **)&password.data, &pw_len, false)) {
+ (void **)&password.data, &pw_len)) {
free_ChangePasswdDataMS(&chpw);
return false;
}
/* The data should be provided as UTF16 string */
convert_string_talloc(mem_ctx, CH_UTF8, CH_UTF16,
val->data, val->length,
- (void **)&data->data, &data->length, false);
+ (void **)&data->data, &data->length);
} else {
data->data = NULL;
data->length = 0;
/* The data is provided as UTF16 string */
ret2 = convert_string_talloc(mem_ctx, CH_UTF16, CH_UTF8,
(void *)data.data, data.length,
- (void **)&val->data, &val->length,
- false);
+ (void **)&val->data, &val->length);
if (ret2) {
ret = ldb_msg_add_value(msg, "data", val, NULL);
} else {
case REG_EXPAND_SZ:
case REG_SZ:
convert_string_talloc(mem_ctx,
- CH_UTF16, CH_UNIX, data.data, data.length,
- (void **)&ret, NULL, false);
+ CH_UTF16, CH_UNIX, data.data, data.length,
+ (void **)&ret, NULL);
break;
case REG_DWORD:
case REG_DWORD_BIG_ENDIAN:
{
DATA_BLOB db;
convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
- "bla", 3, (void **)&db.data, &db.length, false);
+ "bla", 3, (void **)&db.data, &db.length);
torture_assert_str_equal(ctx, "bla",
reg_val_data_string(ctx, REG_SZ, db),
"sz failed");
convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
"stationary traveller",
strlen("stationary traveller"),
- (void **)&data.data, &data.length, false);
+ (void **)&data.data, &data.length);
torture_assert_str_equal(ctx, "camel = REG_SZ : stationary traveller",
reg_val_description(ctx, "camel", REG_SZ, data),
"reg_val_description failed");
convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
"west berlin",
strlen("west berlin"),
- (void **)&data.data, &data.length, false);
+ (void **)&data.data, &data.length);
torture_assert_str_equal(ctx, "<No Name> = REG_SZ : west berlin",
reg_val_description(ctx, NULL, REG_SZ, data),
"description with null name failed");
convert_string_talloc(mem_ctx,
CH_UTF16, CH_UNIX,
data.data, data.length,
- (void **)&ret, NULL, false);
+ (void **)&ret, NULL);
break;
case REG_DWORD:
case REG_DWORD_BIG_ENDIAN:
CH_UNIX, CH_UTF16,
data_str, strlen(data_str)+1,
(void **)&data->data,
- &data->length, false);
+ &data->length);
break;
case REG_MULTI_SZ:
case REG_EXPAND_SZ:
}
ret = convert_string_talloc(io->streams,
CH_UTF16, CH_UNIX,
- blob.data+ofs+24, nlen, &vstr, NULL, false);
+ blob.data+ofs+24, nlen, &vstr, NULL);
if (!ret) {
return NT_STATUS_ILLEGAL_CHARACTER;
}
return 0;
}
- ret = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, src, src_len2, (void **)dest, &ret_size, false);
+ ret = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, src, src_len2, (void **)dest, &ret_size);
if (!ret) {
*dest = NULL;
return 0;
src_len2++;
}
- ret = convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX, src, src_len2, (void **)dest, &ret_size, false);
+ ret = convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX, src, src_len2, (void **)dest, &ret_size);
if (!ret) {
*dest = NULL;
src_len2 = utf16_len_n(src, src_len);
- ret = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, src, src_len2, (void **)&dest2, &ret_size, false);
+ ret = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, src, src_len2, (void **)&dest2, &ret_size);
if (!ret) {
*dest = NULL;
return 0;
src_len2++;
}
- ret = convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX, src, src_len2, (void **)&dest2, &ret_size, false);
+ ret = convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX, src, src_len2, (void **)&dest2, &ret_size);
if (!ret) {
*dest = NULL;
}
ret = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX,
- blob.data, blob.length, &vstr, NULL, false);
+ blob.data, blob.length, &vstr, NULL);
data_blob_free(&blob);
(*str) = (char *)vstr;
if (!ret) {
}
ret = convert_string_talloc(buf->buffer, CH_UNIX, CH_UTF16,
- str, strlen(str), (void **)&blob.data, &blob.length,
- false);
+ str, strlen(str), (void **)&blob.data, &blob.length);
if (!ret) {
return NT_STATUS_ILLEGAL_CHARACTER;
}
}
if (!convert_string_talloc_convenience(mem_ctx, lpcfg_iconv_convenience(ctx->lp_ctx), CH_UTF16, CH_UNIX,
s->secret.data, s->secret.length,
- (void **)&secret_string, NULL, false)) {
+ (void **)&secret_string, NULL)) {
r->out.error_string = talloc_asprintf(mem_ctx,
"Could not convert secret for domain %s to a string",
t->name);
CH_DOS, CH_UNIX,
(const char *)new_password.data,
new_password.length,
- (void **)&new_pass, NULL, false)) {
+ (void **)&new_pass, NULL)) {
DEBUG(3,("samr: failed to convert incoming password buffer to unix charset\n"));
return NT_STATUS_WRONG_PASSWORD;
}
CH_DOS, CH_UTF16,
(const char *)new_password.data,
new_password.length,
- (void **)&new_unicode_password.data, &unicode_pw_len, false)) {
+ (void **)&new_unicode_password.data, &unicode_pw_len)) {
DEBUG(3,("samr: failed to convert incoming password buffer to UTF16 charset\n"));
return NT_STATUS_WRONG_PASSWORD;
}
CH_UTF16, CH_UNIX,
(const char *)new_password.data,
new_password.length,
- (void **)&new_pass, NULL, false)) {
+ (void **)&new_pass, NULL)) {
E_deshash(new_pass, new_lm_hash);
E_old_pw_hash(new_nt_hash, lm_pwd->hash, lm_verifier.hash);
if (memcmp(lm_verifier.hash, r->in.lm_verifier->hash, 16) != 0) {
return src_len2 + alignment;
}
- ret = convert_string_talloc(bufinfo->mem_ctx, CH_UTF16, CH_UNIX, src, src_len2, (void **)&dest2, NULL, false);
+ ret = convert_string_talloc(bufinfo->mem_ctx, CH_UTF16, CH_UNIX, src, src_len2, (void **)&dest2, NULL);
if (!ret) {
*dest = NULL;
src_len2++;
}
- ret = convert_string_talloc(bufinfo->mem_ctx, CH_DOS, CH_UNIX, src, src_len2, (void **)&dest2, NULL, false);
+ ret = convert_string_talloc(bufinfo->mem_ctx, CH_DOS, CH_UNIX, src, src_len2, (void **)&dest2, NULL);
if (!ret) {
*dest = NULL;
}
SSVAL(ucs_name, i*2, 0);
- if (!convert_string_talloc_convenience(ucs_name, lpcfg_iconv_convenience(tctx->lp_ctx), CH_UTF16, CH_UNIX, ucs_name, (1+u_name_len)*2, (void **)&fname, &i, false)) {
+ if (!convert_string_talloc_convenience(ucs_name, lpcfg_iconv_convenience(tctx->lp_ctx), CH_UTF16, CH_UNIX, ucs_name, (1+u_name_len)*2, (void **)&fname, &i)) {
torture_comment(tctx, "Failed to convert UCS2 Name into unix - convert_string_talloc() failure\n");
talloc_free(ucs_name);
return NT_STATUS_NO_MEMORY;
p = fname+strlen(fname);
len = convert_string(CH_UTF16, CH_UNIX,
c2, 2,
- p, sizeof(fname)-strlen(fname), false);
+ p, sizeof(fname)-strlen(fname));
p[len] = 0;
strncat(fname,"_a_long_extension",sizeof(fname)-1);
len = convert_string(CH_UTF16, CH_UNIX,
c2, 2,
- p, sizeof(fname)-strlen(fname), false);
+ p, sizeof(fname)-strlen(fname));
if (len == -1)
return NULL;
p[len] = 0;
if (!convert_string_talloc(mem_ctx, CH_UNIX, CH_UTF16, password,
strlen(password),
&auth_info_array[0].AuthInfo.clear.password,
- &converted_size,
- false)) {
+ &converted_size)) {
return false;
}
if (!convert_string_talloc(samlogon_state->mem_ctx,
CH_UNIX, CH_DOS,
password, strlen(password)+1,
- (void**)&dospw, NULL, false)) {
+ (void**)&dospw, NULL)) {
DEBUG(0, ("convert_string_talloc failed!\n"));
exit(1);
}
convert_string_talloc(tctx, CH_UNIX, CH_UTF16,
kernel_mode_path,
strlen(kernel_mode_path), /* not NULL terminated */
- &blob.data, &blob.length,
- false),
+ &blob.data, &blob.length),
"failed to convert");
torture_assert(tctx,