bool convert_string_allocate(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 convert_string_talloc(TALLOC_CTX *ctx, charset_t from, charset_t to,
- void const *src, size_t srclen, void *dst,
- bool allow_bad_conv);
+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 unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen);
char *strdup_upper(const char *s);
char *talloc_strdup_upper(TALLOC_CTX *ctx, const char *s);
size_t push_ascii(void *dest, const char *src, size_t dest_len, int flags);
size_t push_ascii_fstring(void *dest, const char *src);
size_t push_ascii_nstring(void *dest, const char *src);
-size_t push_ascii_allocate(char **dest, const char *src);
+bool push_ascii_allocate(char **dest, const char *src, size_t *converted_size);
size_t pull_ascii(char *dest, const void *src, size_t dest_len, size_t src_len, int flags);
size_t pull_ascii_fstring(char *dest, const void *src);
size_t pull_ascii_nstring(char *dest, size_t dest_len, const void *src);
size_t push_ucs2(const void *base_ptr, void *dest, const char *src, size_t dest_len, int flags);
-size_t push_ucs2_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src);
-size_t push_ucs2_allocate(smb_ucs2_t **dest, const char *src);
+bool push_ucs2_allocate(smb_ucs2_t **dest, const char *src,
+ size_t *converted_size);
size_t push_utf8_fstring(void *dest, const char *src);
-size_t push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src);
-size_t push_utf8_allocate(char **dest, const char *src);
+bool push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src,
+ size_t *converted_size);
+bool push_utf8_allocate(char **dest, const char *src, size_t *converted_size);
size_t pull_ucs2(const void *base_ptr, char *dest, const void *src, size_t dest_len, size_t src_len, int flags);
size_t pull_ucs2_base_talloc(TALLOC_CTX *ctx,
const void *base_ptr,
size_t src_len,
int flags);
size_t pull_ucs2_fstring(char *dest, const void *src);
-size_t pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const smb_ucs2_t *src);
-size_t pull_ucs2_allocate(char **dest, const smb_ucs2_t *src);
-size_t pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src);
-size_t pull_utf8_allocate(char **dest, const char *src);
-size_t pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src);
+bool push_ucs2_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src,
+ size_t *converted_size);
+bool pull_ucs2_allocate(char **dest, const smb_ucs2_t *src,
+ size_t *converted_size);
+bool pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src,
+ size_t *converted_size);
+bool pull_utf8_allocate(char **dest, const char *src, size_t *converted_size);
+bool pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const smb_ucs2_t *src,
+ size_t *converted_size);
+bool pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src,
+ size_t *converted_size);
size_t push_string_fn(const char *function, unsigned int line,
const void *base_ptr, uint16 flags2,
void *dest, const char *src,
* true
* @note -1 is not accepted for srclen.
*
- * @return True if new buffer was correctly allocated, and string was
+ * @return true if new buffer was correctly allocated, and string was
* converted.
*
* Ensure the srclen contains the terminating zero.
*
* @param srclen length of source buffer.
* @param dest always set at least to NULL
+ * @parm converted_size set to the number of bytes occupied by the string in
+ * the destination on success.
* @note -1 is not accepted for srclen.
*
- * @returns Size in bytes of the converted string; or -1 in case of error.
- **/
-size_t convert_string_talloc(TALLOC_CTX *ctx, charset_t from, charset_t to,
- void const *src, size_t srclen, void *dst,
- bool allow_bad_conv)
+ * @return true if new buffer was correctly allocated, and string was
+ * converted.
+ */
+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)
{
void **dest = (void **)dst;
- size_t dest_len;
*dest = NULL;
- if (!convert_string_allocate(ctx, from, to, src, srclen, dest,
- &dest_len, allow_bad_conv))
- return (size_t)-1;
- if (*dest == NULL)
- return (size_t)-1;
- return dest_len;
+ return convert_string_allocate(ctx, from, to, src, srclen, dest,
+ converted_size, allow_bad_conv);
}
size_t unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen)
size_t size;
smb_ucs2_t *buffer;
- size = push_ucs2_allocate(&buffer, src);
- if (size == (size_t)-1) {
+ if (!push_ucs2_allocate(&buffer, src, &size)) {
return (size_t)-1;
}
+
if (!strupper_w(buffer) && (dest == src)) {
free(buffer);
return srclen;
if (*p) {
/* MB case. */
- size_t size, size2;
+ size_t converted_size, converted_size2;
smb_ucs2_t *buffer = NULL;
SAFE_FREE(out_buffer);
if (!convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, s,
- strlen(s) + 1, (void **)(void *)&buffer, &size,
- True)) {
+ strlen(s) + 1,
+ (void **)(void *)&buffer,
+ &converted_size, True))
+ {
return NULL;
}
strupper_w(buffer);
if (!convert_string_allocate(NULL, CH_UTF16LE, CH_UNIX, buffer,
- size, (void **)(void *)&out_buffer, &size2, True)) {
+ converted_size,
+ (void **)(void *)&out_buffer,
+ &converted_size2, True))
+ {
TALLOC_FREE(buffer);
return NULL;
}
if (*p) {
/* MB case. */
- size_t size;
+ size_t converted_size, converted_size2;
smb_ucs2_t *ubuf = NULL;
/* We're not using the ascii buffer above. */
TALLOC_FREE(out_buffer);
- size = convert_string_talloc(ctx, CH_UNIX, CH_UTF16LE,
- s, strlen(s)+1,
- (void *)&ubuf,
- True);
- if (size == (size_t)-1) {
+ if (!convert_string_talloc(ctx, CH_UNIX, CH_UTF16LE, s,
+ strlen(s)+1, (void *)&ubuf,
+ &converted_size, True))
+ {
return NULL;
}
strupper_w(ubuf);
- size = convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX,
- ubuf, size,
- (void *)&out_buffer,
- True);
+ if (!convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, ubuf,
+ converted_size, (void *)&out_buffer,
+ &converted_size2, True))
+ {
+ TALLOC_FREE(ubuf);
+ return NULL;
+ }
/* Don't need the intermediate buffer
* anymore.
*/
-
TALLOC_FREE(ubuf);
-
- if (size == (size_t)-1) {
- return NULL;
- }
}
return out_buffer;
smb_ucs2_t *buffer = NULL;
if (!convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, srclen,
- (void **)(void *)&buffer, &size, True)) {
+ (void **)(void *)&buffer, &size,
+ True))
+ {
smb_panic("failed to create UCS2 buffer");
}
if (!strlower_w(buffer) && (dest == src)) {
char *strdup_lower(const char *s)
{
- size_t size;
+ size_t converted_size;
smb_ucs2_t *buffer = NULL;
char *out_buffer;
- size = push_ucs2_allocate(&buffer, s);
- if (size == -1 || !buffer) {
+ if (!push_ucs2_allocate(&buffer, s, &converted_size)) {
return NULL;
}
strlower_w(buffer);
- size = pull_ucs2_allocate(&out_buffer, buffer);
- SAFE_FREE(buffer);
-
- if (size == (size_t)-1) {
+ if (!pull_ucs2_allocate(&out_buffer, buffer, &converted_size)) {
+ SAFE_FREE(buffer);
return NULL;
}
+ SAFE_FREE(buffer);
+
return out_buffer;
}
char *talloc_strdup_lower(TALLOC_CTX *ctx, const char *s)
{
- size_t size;
+ size_t converted_size;
smb_ucs2_t *buffer = NULL;
char *out_buffer;
- size = push_ucs2_talloc(ctx, &buffer, s);
- if (size == -1 || !buffer) {
- TALLOC_FREE(buffer);
+ if (!push_ucs2_talloc(ctx, &buffer, s, &converted_size)) {
return NULL;
}
strlower_w(buffer);
- size = pull_ucs2_talloc(ctx, &out_buffer, buffer);
- TALLOC_FREE(buffer);
-
- if (size == (size_t)-1) {
- TALLOC_FREE(out_buffer);
+ if (!pull_ucs2_talloc(ctx, &out_buffer, buffer, &converted_size)) {
+ TALLOC_FREE(buffer);
return NULL;
}
+ TALLOC_FREE(buffer);
+
return out_buffer;
}
smb_ucs2_t *buffer;
conv_silent = True;
- buffer_len = push_ucs2_allocate(&buffer, src);
- if (buffer_len == (size_t)-1) {
+ if (!push_ucs2_allocate(&buffer, src, &buffer_len)) {
smb_panic("failed to create UCS2 buffer");
}
Push and malloc an ascii string. src and dest null terminated.
********************************************************************/
-size_t push_ascii_allocate(char **dest, const char *src)
+bool push_ascii_allocate(char **dest, const char *src, size_t *converted_size)
{
- size_t dest_len, src_len = strlen(src)+1;
+ size_t src_len = strlen(src)+1;
*dest = NULL;
- if (!convert_string_allocate(NULL, CH_UNIX, CH_DOS, src, src_len,
- (void **)dest, &dest_len, True))
- return (size_t)-1;
- else
- return dest_len;
+ return convert_string_allocate(NULL, CH_UNIX, CH_DOS, src, src_len,
+ (void **)dest, converted_size, True);
}
/**
int flags)
{
char *dest = NULL;
- size_t dest_len = 0;
+ size_t converted_size;
#ifdef DEVELOPER
/* Ensure we never use the braindead "malloc" varient. */
}
if (!convert_string_allocate(ctx, CH_DOS, CH_UNIX, src, src_len, &dest,
- &dest_len, True))
- dest_len = 0;
+ &converted_size, True))
+ {
+ converted_size = 0;
+ }
- if (dest_len && dest) {
+ if (converted_size && dest) {
/* Did we already process the terminating zero ? */
- if (dest[dest_len-1] != 0) {
- dest[dest_len-1] = 0;
+ if (dest[converted_size - 1] != 0) {
+ dest[converted_size - 1] = 0;
}
} else if (dest) {
dest[0] = 0;
* allocating a buffer using talloc().
*
* @param dest always set at least to NULL
+ * @parm converted_size set to the number of bytes occupied by the string in
+ * the destination on success.
*
- * @returns The number of bytes occupied by the string in the destination
- * or -1 in case of error.
+ * @return true if new buffer was correctly allocated, and string was
+ * converted.
**/
-size_t push_ucs2_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src)
+bool push_ucs2_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src,
+ size_t *converted_size)
{
size_t src_len = strlen(src)+1;
*dest = NULL;
- return convert_string_talloc(ctx, CH_UNIX, CH_UTF16LE, src, src_len, (void **)dest, True);
+ return convert_string_talloc(ctx, CH_UNIX, CH_UTF16LE, src, src_len,
+ (void **)dest, converted_size, True);
}
* Copy a string from a unix char* src to a UCS2 destination, allocating a buffer
*
* @param dest always set at least to NULL
+ * @parm converted_size set to the number of bytes occupied by the string in
+ * the destination on success.
*
- * @returns The number of bytes occupied by the string in the destination
- * or -1 in case of error.
+ * @return true if new buffer was correctly allocated, and string was
+ * converted.
**/
-size_t push_ucs2_allocate(smb_ucs2_t **dest, const char *src)
+bool push_ucs2_allocate(smb_ucs2_t **dest, const char *src,
+ size_t *converted_size)
{
- size_t dest_len, src_len = strlen(src)+1;
+ size_t src_len = strlen(src)+1;
*dest = NULL;
- if (!convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, src_len,
- (void **)dest, &dest_len, True))
- return (size_t)-1;
- else
- return dest_len;
+ return convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, src_len,
+ (void **)dest, converted_size, True);
}
/**
* Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer using talloc
*
* @param dest always set at least to NULL
+ * @parm converted_size set to the number of bytes occupied by the string in
+ * the destination on success.
*
- * @returns The number of bytes occupied by the string in the destination
+ * @return true if new buffer was correctly allocated, and string was
+ * converted.
**/
-size_t push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
+bool push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src,
+ size_t *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, True);
+ return convert_string_talloc(ctx, CH_UNIX, CH_UTF8, src, src_len,
+ (void**)dest, converted_size, True);
}
/**
* Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer
*
* @param dest always set at least to NULL
+ * @parm converted_size set to the number of bytes occupied by the string in
+ * the destination on success.
*
- * @returns The number of bytes occupied by the string in the destination
+ * @return true if new buffer was correctly allocated, and string was
+ * converted.
**/
-size_t push_utf8_allocate(char **dest, const char *src)
+bool push_utf8_allocate(char **dest, const char *src, size_t *converted_size)
{
- size_t dest_len, src_len = strlen(src)+1;
+ size_t src_len = strlen(src)+1;
*dest = NULL;
- if (!convert_string_allocate(NULL, CH_UNIX, CH_UTF8, src, src_len,
- (void **)dest, &dest_len, True))
- return (size_t)-1;
- else
- return dest_len;
+ return convert_string_allocate(NULL, CH_UNIX, CH_UTF8, src, src_len,
+ (void **)dest, converted_size, True);
}
/**
src_len &= ~1;
}
- dest_len = convert_string_talloc(ctx,
- CH_UTF16LE,
- CH_UNIX,
- src,
- src_len,
- (void *)&dest,
- True);
- if (dest_len == (size_t)-1) {
+ if (!convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src, src_len,
+ (void *)&dest, &dest_len, True)) {
dest_len = 0;
}
* Copy a string from a UCS2 src to a unix char * destination, allocating a buffer using talloc
*
* @param dest always set at least to NULL
+ * @parm converted_size set to the number of bytes occupied by the string in
+ * the destination on success.
*
- * @returns The number of bytes occupied by the string in the destination
+ * @return true if new buffer was correctly allocated, and string was
+ * converted.
**/
-size_t pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const smb_ucs2_t *src)
+bool pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const smb_ucs2_t *src,
+ size_t *converted_size)
{
size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
+
*dest = NULL;
- return convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
+ return convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src, src_len,
+ (void **)dest, converted_size, True);
}
/**
* Copy a string from a UCS2 src to a unix char * destination, allocating a buffer
*
* @param dest always set at least to NULL
- *
- * @returns The number of bytes occupied by the string in the destination
+ * @parm converted_size set to the number of bytes occupied by the string in
+ * the destination on success.
+ * @return true if new buffer was correctly allocated, and string was
+ * converted.
**/
-size_t pull_ucs2_allocate(char **dest, const smb_ucs2_t *src)
+bool pull_ucs2_allocate(char **dest, const smb_ucs2_t *src,
+ size_t *converted_size)
{
- size_t dest_len, src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
+ size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
+
*dest = NULL;
- if (!convert_string_allocate(NULL, CH_UTF16LE, CH_UNIX, src, src_len,
- (void **)dest, &dest_len, True))
- return (size_t)-1;
- else
- return dest_len;
+ return convert_string_allocate(NULL, CH_UTF16LE, CH_UNIX, src, src_len,
+ (void **)dest, converted_size, True);
}
/**
* Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer using talloc
*
* @param dest always set at least to NULL
+ * @parm converted_size set to the number of bytes occupied by the string in
+ * the destination on success.
*
- * @returns The number of bytes occupied by the string in the destination
+ * @return true if new buffer was correctly allocated, and string was
+ * converted.
**/
-size_t pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
+bool pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src,
+ size_t *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, True);
+ return convert_string_talloc(ctx, CH_UTF8, CH_UNIX, src, src_len,
+ (void **)dest, converted_size, True);
}
/**
* Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer
*
* @param dest always set at least to NULL
+ * @parm converted_size set to the number of bytes occupied by the string in
+ * the destination on success.
*
- * @returns The number of bytes occupied by the string in the destination
+ * @return true if new buffer was correctly allocated, and string was
+ * converted.
**/
-size_t pull_utf8_allocate(char **dest, const char *src)
+bool pull_utf8_allocate(char **dest, const char *src, size_t *converted_size)
{
- size_t dest_len, src_len = strlen(src)+1;
+ size_t src_len = strlen(src)+1;
+
*dest = NULL;
- if (!convert_string_allocate(NULL, CH_UTF8, CH_UNIX, src, src_len,
- (void **)dest, &dest_len, True))
- return (size_t)-1;
- else
- return dest_len;
+ return convert_string_allocate(NULL, CH_UTF8, CH_UNIX, src, src_len,
+ (void **)dest, converted_size, True);
}
/**
* Copy a string from a DOS src to a unix char * destination, allocating a buffer using talloc
*
* @param dest always set at least to NULL
+ * @parm converted_size set to the number of bytes occupied by the string in
+ * the destination on success.
*
- * @returns The number of bytes occupied by the string in the destination
+ * @return true if new buffer was correctly allocated, and string was
+ * converted.
**/
-size_t pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
+bool pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src,
+ size_t *converted_size)
{
size_t src_len = strlen(src)+1;
+
*dest = NULL;
- return convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len, (void **)dest, True);
+ return convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len,
+ (void **)dest, converted_size, True);
}
/**
struct max_n *max_n = NULL;
struct max_n *max_n_free = NULL;
struct max_n one_max_n;
+ size_t converted_size;
if (ISDOTDOT(string)) {
string = ".";
}
}
- if (push_ucs2_allocate(&p, pattern) == (size_t)-1) {
+ if (!push_ucs2_allocate(&p, pattern, &converted_size)) {
return -1;
}
- if (push_ucs2_allocate(&s, string) == (size_t)-1) {
+ if (!push_ucs2_allocate(&s, string, &converted_size)) {
SAFE_FREE(p);
return -1;
}
{
char **values;
char *result;
+ size_t converted_size;
if (attribute == NULL) {
return NULL;
return NULL;
}
- if (pull_utf8_talloc(mem_ctx, &result, values[0]) == (size_t)-1) {
+ if (!pull_utf8_talloc(mem_ctx, &result, values[0], &converted_size)) {
DEBUG(10, ("pull_utf8_talloc failed\n"));
ldap_value_free(values);
return NULL;
if (value != NULL) {
char *utf8_value = NULL;
+ size_t converted_size;
j = 0;
if (mods[i]->mod_values != NULL) {
/* notreached. */
}
- if (push_utf8_allocate(&utf8_value, value) == (size_t)-1) {
+ if (!push_utf8_allocate(&utf8_value, value, &converted_size)) {
smb_panic("smbldap_set_mod: String conversion failure!");
/* notreached. */
}
char *utf8_filter;
time_t endtime = time(NULL)+lp_ldap_timeout();
struct timeval timeout;
+ size_t converted_size;
SMB_ASSERT(ldap_state);
ZERO_STRUCT(ldap_state->last_rebind);
}
- if (push_utf8_allocate(&utf8_filter, filter) == (size_t)-1) {
+ if (!push_utf8_allocate(&utf8_filter, filter, &converted_size)) {
return LDAP_NO_MEMORY;
}
int attempts = 0;
char *utf8_dn;
time_t endtime = time(NULL)+lp_ldap_timeout();
+ size_t converted_size;
SMB_ASSERT(ldap_state);
DEBUG(5,("smbldap_modify: dn => [%s]\n", dn ));
- if (push_utf8_allocate(&utf8_dn, dn) == (size_t)-1) {
+ if (!push_utf8_allocate(&utf8_dn, dn, &converted_size)) {
return LDAP_NO_MEMORY;
}
int attempts = 0;
char *utf8_dn;
time_t endtime = time(NULL)+lp_ldap_timeout();
+ size_t converted_size;
SMB_ASSERT(ldap_state);
DEBUG(5,("smbldap_add: dn => [%s]\n", dn ));
- if (push_utf8_allocate(&utf8_dn, dn) == (size_t)-1) {
+ if (!push_utf8_allocate(&utf8_dn, dn, &converted_size)) {
return LDAP_NO_MEMORY;
}
int attempts = 0;
char *utf8_dn;
time_t endtime = time(NULL)+lp_ldap_timeout();
+ size_t converted_size;
SMB_ASSERT(ldap_state);
DEBUG(5,("smbldap_delete: dn => [%s]\n", dn ));
- if (push_utf8_allocate(&utf8_dn, dn) == (size_t)-1) {
+ if (!push_utf8_allocate(&utf8_dn, dn, &converted_size)) {
return LDAP_NO_MEMORY;
}
char *smbldap_get_dn(LDAP *ld, LDAPMessage *entry)
{
char *utf8_dn, *unix_dn;
+ size_t converted_size;
utf8_dn = ldap_get_dn(ld, entry);
if (!utf8_dn) {
DEBUG (5, ("smbldap_get_dn: ldap_get_dn failed\n"));
return NULL;
}
- if (pull_utf8_allocate(&unix_dn, utf8_dn) == (size_t)-1) {
- DEBUG (0, ("smbldap_get_dn: String conversion failure utf8 [%s]\n", utf8_dn));
+ if (!pull_utf8_allocate(&unix_dn, utf8_dn, &converted_size)) {
+ DEBUG (0, ("smbldap_get_dn: String conversion failure utf8 "
+ "[%s]\n", utf8_dn));
return NULL;
}
ldap_memfree(utf8_dn);
LDAPMessage *entry)
{
char *utf8_dn, *unix_dn;
+ size_t converted_size;
utf8_dn = ldap_get_dn(ld, entry);
if (!utf8_dn) {
DEBUG (5, ("smbldap_get_dn: ldap_get_dn failed\n"));
return NULL;
}
- if (pull_utf8_talloc(mem_ctx, &unix_dn, utf8_dn) == (size_t)-1) {
+ if (!pull_utf8_talloc(mem_ctx, &unix_dn, utf8_dn, &converted_size)) {
DEBUG (0, ("smbldap_get_dn: String conversion failure utf8 "
"[%s]\n", utf8_dn));
return NULL;
goto error;
}
- value->v.sz.len = convert_string_talloc(
- value, CH_UTF16LE, CH_UNIX, tmp, length+2,
- &value->v.sz.str, False);
-
- SAFE_FREE(tmp);
-
- if (value->v.sz.len == (size_t)-1) {
+ if (!convert_string_talloc(value, CH_UTF16LE, CH_UNIX, tmp,
+ length+2, &value->v.sz.str,
+ &value->v.sz.len, False)) {
+ SAFE_FREE(tmp);
err = WERR_INVALID_PARAM;
goto error;
}
+
+ SAFE_FREE(tmp);
break;
}
case REG_MULTI_SZ:
}
case REG_SZ:
case REG_EXPAND_SZ: {
- presult->length = convert_string_talloc(
- mem_ctx, CH_UNIX, CH_UTF16LE, value->v.sz.str,
- MIN(value->v.sz.len, strlen(value->v.sz.str)+1),
- (void *)&(presult->data), False);
- if (presult->length == (size_t)-1) {
+ if (!convert_string_talloc(mem_ctx, CH_UNIX, CH_UTF16LE,
+ value->v.sz.str,
+ MIN(value->v.sz.len,
+ strlen(value->v.sz.str)+1),
+ (void *)&(presult->data),
+ &presult->length, False))
+ {
return WERR_NOMEM;
}
break;
/* convert the single strings */
for (count = 0; count < value->v.multi_sz.num_strings; count++)
{
- string_lengths[count] = convert_string_talloc(
- strings, CH_UNIX, CH_UTF16LE,
- value->v.multi_sz.strings[count],
+ if (!convert_string_talloc(strings, CH_UNIX,
+ CH_UTF16LE, value->v.multi_sz.strings[count],
strlen(value->v.multi_sz.strings[count])+1,
- (void *)&strings[count], false);
- if (string_lengths[count] == (size_t)-1) {
+ (void *)&strings[count],
+ &string_lengths[count], false))
+ {
+
TALLOC_FREE(tmp_ctx);
return WERR_NOMEM;
}
return +1;
}
- size = push_ucs2_allocate(&buffer_s, ps);
- if (size == (size_t)-1) {
+ if (!push_ucs2_allocate(&buffer_s, ps, &size)) {
return strcmp(ps, pt);
/* Not quite the right answer, but finding the right one
under this failure case is expensive, and it's pretty
close */
}
- size = push_ucs2_allocate(&buffer_t, pt);
- if (size == (size_t)-1) {
+ if (!push_ucs2_allocate(&buffer_t, pt, &size)) {
SAFE_FREE(buffer_s);
return strcmp(ps, pt);
/* Not quite the right answer, but finding the right one
return 0;
}
- size = push_ucs2_allocate(&buffer_s, ps);
- if (size == (size_t)-1) {
+ if (!push_ucs2_allocate(&buffer_s, ps, &size)) {
return strncmp(ps, pt, len-n);
/* Not quite the right answer, but finding the right one
under this failure case is expensive,
and it's pretty close */
}
- size = push_ucs2_allocate(&buffer_t, pt);
- if (size == (size_t)-1) {
+ if (!push_ucs2_allocate(&buffer_t, pt, &size)) {
SAFE_FREE(buffer_s);
return strncmp(ps, pt, len-n);
/* Not quite the right answer, but finding the right one
size_t str_charnum(const char *s)
{
- size_t ret;
+ size_t ret, converted_size;
smb_ucs2_t *tmpbuf2 = NULL;
- if (push_ucs2_allocate(&tmpbuf2, s) == (size_t)-1) {
+ if (!push_ucs2_allocate(&tmpbuf2, s, &converted_size)) {
return 0;
}
ret = strlen_w(tmpbuf2);
size_t str_ascii_charnum(const char *s)
{
- size_t ret;
+ size_t ret, converted_size;
char *tmpbuf2 = NULL;
- if (push_ascii_allocate(&tmpbuf2, s) == (size_t)-1) {
+ if (!push_ascii_allocate(&tmpbuf2, s, &converted_size)) {
return 0;
}
ret = strlen(tmpbuf2);
{
smb_ucs2_t *tmp, *p;
bool ret;
+ size_t converted_size;
- if (push_ucs2_allocate(&tmp, s) == -1) {
+ if (!push_ucs2_allocate(&tmp, s, &converted_size)) {
return false;
}
{
smb_ucs2_t *tmp, *p;
bool ret;
+ size_t converted_size;
- if (push_ucs2_allocate(&tmp, s) == -1) {
+ if (!push_ucs2_allocate(&tmp, s, &converted_size)) {
return false;
}
smb_ucs2_t *ptr;
int count;
smb_ucs2_t *alloc_tmpbuf = NULL;
+ size_t converted_size;
- if (push_ucs2_allocate(&alloc_tmpbuf, s) == (size_t)-1) {
+ if (!push_ucs2_allocate(&alloc_tmpbuf, s, &converted_size)) {
return 0;
}
smb_ucs2_t *p;
const char *s;
char *ret;
+ size_t converted_size;
/* characters below 0x3F are guaranteed to not appear in
non-initial position in multi-byte charsets */
s = src;
#endif
- if (push_ucs2_allocate(&ws, s)==(size_t)-1) {
+ if (!push_ucs2_allocate(&ws, s, &converted_size)) {
/* Wrong answer, but what can we do... */
return strchr(src, c);
}
return NULL;
}
*p = 0;
- if (pull_ucs2_allocate(&s2, ws)==(size_t)-1) {
+ if (!pull_ucs2_allocate(&s2, ws, &converted_size)) {
SAFE_FREE(ws);
/* Wrong answer, but what can we do... */
return strchr(src, c);
char *s2 = NULL;
smb_ucs2_t *p;
char *ret;
+ size_t converted_size;
- if (push_ucs2_allocate(&ws,s)==(size_t)-1) {
+ if (!push_ucs2_allocate(&ws, s, &converted_size)) {
/* Wrong answer, but what can we do. */
return strrchr(s, c);
}
return NULL;
}
*p = 0;
- if (pull_ucs2_allocate(&s2,ws)==(size_t)-1) {
+ if (!pull_ucs2_allocate(&s2, ws, &converted_size)) {
SAFE_FREE(ws);
/* Wrong answer, but what can we do. */
return strrchr(s, c);
char *s2 = NULL;
smb_ucs2_t *p;
char *ret;
+ size_t converted_size;
- if (push_ucs2_allocate(&ws,s)==(size_t)-1) {
+ if (!push_ucs2_allocate(&ws, s, &converted_size)) {
/* Too hard to try and get right. */
return NULL;
}
return NULL;
}
*p = 0;
- if (pull_ucs2_allocate(&s2,ws)==(size_t)-1) {
+ if (!pull_ucs2_allocate(&s2, ws, &converted_size)) {
SAFE_FREE(ws);
/* Too hard to try and get right. */
return NULL;
char *s2;
char *retp;
- size_t findstr_len = 0;
+ size_t converted_size, findstr_len = 0;
/* for correctness */
if (!findstr[0]) {
s = src;
#endif
- if (push_ucs2_allocate(&src_w, src) == (size_t)-1) {
+ if (!push_ucs2_allocate(&src_w, src, &converted_size)) {
DEBUG(0,("strstr_m: src malloc fail\n"));
return NULL;
}
- if (push_ucs2_allocate(&find_w, findstr) == (size_t)-1) {
+ if (!push_ucs2_allocate(&find_w, findstr, &converted_size)) {
SAFE_FREE(src_w);
DEBUG(0,("strstr_m: find malloc fail\n"));
return NULL;
}
*p = 0;
- if (pull_ucs2_allocate(&s2, src_w) == (size_t)-1) {
+ if (!pull_ucs2_allocate(&s2, src_w, &converted_size)) {
SAFE_FREE(src_w);
SAFE_FREE(find_w);
DEBUG(0,("strstr_m: dest malloc fail\n"));
char *rpcstr_pull_unistr2_talloc(TALLOC_CTX *ctx, const UNISTR2 *src)
{
char *dest = NULL;
- size_t dest_len = convert_string_talloc(ctx,
- CH_UTF16LE,
- CH_UNIX,
- src->buffer,
- src->uni_str_len * 2,
- (void *)&dest,
- true);
- if (dest_len == (size_t)-1) {
+ size_t dest_len;
+
+ if (!convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src->buffer,
+ src->uni_str_len * 2, (void *)&dest,
+ &dest_len, true))
+ {
return NULL;
}
int rpcstr_push_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src)
{
- return push_ucs2_talloc(ctx, dest, src);
+ size_t size;
+ if (push_ucs2_talloc(ctx, dest, src, &size))
+ return size;
+ else
+ return -1;
}
/*******************************************************************
{
char **values;
int i;
-
+ size_t size;
+
if (!in_vals) return NULL;
for (i=0; in_vals[i]; i++)
; /* count values */
if (!values) return NULL;
for (i=0; in_vals[i]; i++) {
- if (push_utf8_talloc(ctx, &values[i], in_vals[i]) == (size_t) -1) {
+ if (!push_utf8_talloc(ctx, &values[i], in_vals[i], &size)) {
TALLOC_FREE(values);
return NULL;
}
{
char **values;
int i;
+ size_t converted_size;
if (!in_vals) return NULL;
for (i=0; in_vals[i]; i++)
if (!values) return NULL;
for (i=0; in_vals[i]; i++) {
- pull_utf8_talloc(ctx, &values[i], in_vals[i]);
+ if (!pull_utf8_talloc(ctx, &values[i], in_vals[i],
+ &converted_size)) {
+ DEBUG(0,("ads_pull_strvals: pull_utf8_talloc failed: "
+ "%s", strerror(errno)));
+ }
}
return values;
}
{
int rc, i, version;
char *utf8_expr, *utf8_path, **search_attrs;
+ size_t converted_size;
LDAPControl PagedResults, NoReferrals, ExternalCtrl, *controls[4], **rcontrols;
BerElement *cookie_be = NULL;
struct berval *cookie_bv= NULL;
/* 0 means the conversion worked but the result was empty
so we only fail if it's -1. In any case, it always
at least nulls out the dest */
- if ((push_utf8_talloc(ctx, &utf8_expr, expr) == (size_t)-1) ||
- (push_utf8_talloc(ctx, &utf8_path, bind_path) == (size_t)-1)) {
+ if (!push_utf8_talloc(ctx, &utf8_expr, expr, &converted_size) ||
+ !push_utf8_talloc(ctx, &utf8_path, bind_path, &converted_size))
+ {
rc = LDAP_NO_MEMORY;
goto done;
}
{
int rc;
char *utf8_expr, *utf8_path, **search_attrs = NULL;
+ size_t converted_size;
TALLOC_CTX *ctx;
*res = NULL;
/* 0 means the conversion worked but the result was empty
so we only fail if it's negative. In any case, it always
at least nulls out the dest */
- if ((push_utf8_talloc(ctx, &utf8_expr, expr) == (size_t)-1) ||
- (push_utf8_talloc(ctx, &utf8_path, bind_path) == (size_t)-1)) {
+ if (!push_utf8_talloc(ctx, &utf8_expr, expr, &converted_size) ||
+ !push_utf8_talloc(ctx, &utf8_path, bind_path, &converted_size))
+ {
DEBUG(1,("ads_do_search: push_utf8_talloc() failed!"));
rc = LDAP_NO_MEMORY;
goto done;
char *ads_get_dn(ADS_STRUCT *ads, LDAPMessage *msg)
{
char *utf8_dn, *unix_dn;
+ size_t converted_size;
utf8_dn = ldap_get_dn(ads->ldap.ld, msg);
return NULL;
}
- if (pull_utf8_allocate(&unix_dn, utf8_dn) == (size_t)-1) {
+ if (!pull_utf8_allocate(&unix_dn, utf8_dn, &converted_size)) {
DEBUG(0,("ads_get_dn: string conversion failure utf8 [%s]\n",
utf8_dn ));
return NULL;
{
int ret,i;
char *utf8_dn = NULL;
+ size_t converted_size;
/*
this control is needed to modify that contains a currently
non-existent attribute (but allowable for the object) to run
controls[0] = &PermitModify;
controls[1] = NULL;
- if (push_utf8_allocate(&utf8_dn, mod_dn) == -1) {
+ if (!push_utf8_allocate(&utf8_dn, mod_dn, &converted_size)) {
return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
}
{
int ret, i;
char *utf8_dn = NULL;
+ size_t converted_size;
- if (push_utf8_allocate(&utf8_dn, new_dn) == -1) {
+ if (!push_utf8_allocate(&utf8_dn, new_dn, &converted_size)) {
DEBUG(1, ("ads_gen_add: push_utf8_allocate failed!"));
return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
}
{
int ret;
char *utf8_dn = NULL;
- if (push_utf8_allocate(&utf8_dn, del_dn) == -1) {
+ size_t converted_size;
+ if (!push_utf8_allocate(&utf8_dn, del_dn, &converted_size)) {
DEBUG(1, ("ads_del_dn: push_utf8_allocate failed!"));
return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
}
{
LDAPMessage *msg;
TALLOC_CTX *ctx;
+ size_t converted_size;
if (!(ctx = talloc_init("ads_process_results")))
return;
char *field;
bool string;
- pull_utf8_talloc(ctx, &field, utf8_field);
+ if (!pull_utf8_talloc(ctx, &field, utf8_field,
+ &converted_size))
+ {
+ DEBUG(0,("ads_process_results: "
+ "pull_utf8_talloc failed: %s",
+ strerror(errno)));
+ }
+
string = fn(ads, field, NULL, data_area);
if (string) {
char **values;
char *ret = NULL;
char *ux_string;
- size_t rc;
+ size_t converted_size;
values = ldap_get_values(ads->ldap.ld, msg, field);
if (!values)
return NULL;
- if (values[0]) {
- rc = pull_utf8_talloc(mem_ctx, &ux_string,
- values[0]);
- if (rc != (size_t)-1)
- ret = ux_string;
-
+ if (values[0] && pull_utf8_talloc(mem_ctx, &ux_string, values[0],
+ &converted_size))
+ {
+ ret = ux_string;
}
ldap_value_free(values);
return ret;
char **values;
char **ret = NULL;
int i;
+ size_t converted_size;
values = ldap_get_values(ads->ldap.ld, msg, field);
if (!values)
}
for (i=0;i<*num_values;i++) {
- if (pull_utf8_talloc(mem_ctx, &ret[i], values[i]) == -1) {
+ if (!pull_utf8_talloc(mem_ctx, &ret[i], values[i],
+ &converted_size))
+ {
ldap_value_free(values);
return NULL;
}
const REGISTRY_VALUE *value)
{
char *str_value = NULL;
+ size_t converted_size;
ADS_STATUS status;
if (value->type != REG_SZ)
- return False;
+ return false;
if (value->size && *((smb_ucs2_t *) value->data_p)) {
- pull_ucs2_talloc(ctx, &str_value, (const smb_ucs2_t *) value->data_p);
+ if (!pull_ucs2_talloc(ctx, &str_value,
+ (const smb_ucs2_t *) value->data_p,
+ &converted_size))
+ {
+ return false;
+ }
status = ads_mod_str(ctx, mods, value->valuename, str_value);
return ADS_ERR_OK(status);
}
- return True;
+ return true;
}
const REGISTRY_VALUE *value)
{
char **str_values = NULL;
+ size_t converted_size;
smb_ucs2_t *cur_str = (smb_ucs2_t *) value->data_p;
uint32 size = 0, num_vals = 0, i=0;
ADS_STATUS status;
(num_vals + 1) * sizeof(char *));
cur_str = (smb_ucs2_t *) value->data_p;
- for (i=0; i < num_vals; i++)
+ for (i=0; i < num_vals; i++) {
cur_str += pull_ucs2_talloc(ctx, &str_values[i],
- cur_str);
+ cur_str, &converted_size) ?
+ converted_size : (size_t)-1;
+ }
status = ads_mod_strlist(ctx, mods, value->valuename,
(const char **) str_values);
char *key = NULL;
char *value = NULL;
enum gp_reg_action action = GP_REG_ACTION_NONE;
+ size_t converted_size;
ZERO_STRUCTP(*reg_entry);
if (strlen_w((const smb_ucs2_t *)file_entry->key.buffer) <= 0)
return false;
- if (!pull_ucs2_talloc(mem_ctx, &key, file_entry->key.buffer))
+ if (!pull_ucs2_talloc(mem_ctx, &key, file_entry->key.buffer,
+ &converted_size))
+ {
return false;
+ }
- if (strlen_w((const smb_ucs2_t *)file_entry->value.buffer) > 0) {
- if (!pull_ucs2_talloc(mem_ctx, &value,
- file_entry->value.buffer))
+ if (strlen_w((const smb_ucs2_t *)file_entry->value.buffer) > 0 &&
+ !pull_ucs2_talloc(mem_ctx, &value, file_entry->value.buffer,
+ &converted_size))
+ {
return false;
}
case REG_NONE:
break;
case REG_SZ:
- data->v.sz.len = pull_ucs2_talloc(mem_ctx,
- &data->v.sz.str,
- (const smb_ucs2_t *)file_entry->data);
+ if (!pull_ucs2_talloc(mem_ctx, &data->v.sz.str,
+ (const smb_ucs2_t *)
+ file_entry->data,
+ &data->v.sz.len)) {
+ data->v.sz.len = -1;
+ }
+
break;
case REG_DWORD_BIG_ENDIAN:
case REG_EXPAND_SZ:
char *tmp_name = NULL;
NTSTATUS status;
size_t n = 0;
+ size_t converted_size;
if (!filename_out) {
return NT_STATUS_INVALID_PARAMETER;
goto out;
}
- n = convert_string_talloc(mem_ctx, CH_UTF16LE, CH_UNIX,
- data_in, n, &data_out, False);
-
- if (n == -1) {
+ if (!convert_string_talloc(mem_ctx, CH_UTF16LE, CH_UNIX, data_in, n,
+ &data_out, &converted_size, False))
+ {
status = NT_STATUS_INVALID_BUFFER_SIZE;
goto out;
}
DEBUG(11,("convert_file_from_ucs2: "
"%s skipping utf8 BOM\n", tmp_name));
data_out += 3;
- n -= 3;
+ converted_size -= 3;
}
- if (sys_write(tmp_fd, data_out, n) != n) {
+ if (sys_write(tmp_fd, data_out, converted_size) != converted_size) {
status = map_nt_error_from_unix(errno);
goto out;
}
char *as=NULL;
uint32_t len1, ofs, len2;
uint16_t len3;
- int ret;
+ size_t converted_size;
int chset = CH_UTF16;
unsigned byte_mul = 2;
unsigned flags = ndr->flags;
if (len2 == 0) {
as = talloc_strdup(ndr->current_mem_ctx, "");
} else {
- ret = convert_string_talloc(ndr->current_mem_ctx,
- chset, CH_UNIX,
- ndr->data+ndr->offset,
- (len2 + c_len_term)*byte_mul,
- (void **)(void *)&as,
- false);
- if (ret == -1) {
- return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
- "Bad character conversion");
+ if (!convert_string_talloc(ndr->current_mem_ctx, chset,
+ CH_UNIX,
+ ndr->data+ndr->offset,
+ (len2 + c_len_term)*byte_mul,
+ (void **)(void *)&as,
+ &converted_size, false))
+ {
+ return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
+ "Bad char conversion");
}
}
NDR_CHECK(ndr_pull_advance(ndr, (len2 + c_len_term)*byte_mul));
if (len1 == 0) {
as = talloc_strdup(ndr->current_mem_ctx, "");
} else {
- ret = convert_string_talloc(ndr->current_mem_ctx,
- chset, CH_UNIX,
- ndr->data+ndr->offset,
- (len1 + c_len_term)*byte_mul,
- (void **)(void *)&as,
- false);
- if (ret == -1) {
+ if (!convert_string_talloc(ndr->current_mem_ctx, chset,
+ CH_UNIX,
+ ndr->data+ndr->offset,
+ (len1 + c_len_term)*byte_mul,
+ (void **)(void *)&as,
+ &converted_size, false))
+ {
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
- "Bad character conversion");
+ "Bad char conversion");
}
}
NDR_CHECK(ndr_pull_advance(ndr, (len1 + c_len_term)*byte_mul));
if (len1 == 0) {
as = talloc_strdup(ndr->current_mem_ctx, "");
} else {
- ret = convert_string_talloc(ndr->current_mem_ctx,
- chset, CH_UNIX,
- ndr->data+ndr->offset,
- (len1 + c_len_term)*byte_mul,
- (void **)(void *)&as,
- false);
- if (ret == -1) {
+ if (!convert_string_talloc(ndr->current_mem_ctx, chset,
+ CH_UNIX,
+ ndr->data+ndr->offset,
+ (len1 + c_len_term)*byte_mul,
+ (void **)(void *)&as,
+ &converted_size, false))
+ {
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
- "Bad character conversion");
+ "Bad char conversion");
}
}
NDR_CHECK(ndr_pull_advance(ndr, (len1 + c_len_term)*byte_mul));
if (len3 == 0) {
as = talloc_strdup(ndr->current_mem_ctx, "");
} else {
- ret = convert_string_talloc(ndr->current_mem_ctx,
- chset, CH_UNIX,
- ndr->data+ndr->offset,
- (len3 + c_len_term)*byte_mul,
- (void **)(void *)&as,
- false);
- if (ret == -1) {
+ if (!convert_string_talloc(ndr->current_mem_ctx, chset,
+ CH_UNIX,
+ ndr->data+ndr->offset,
+ (len3 + c_len_term)*byte_mul,
+ (void **)(void *)&as,
+ &converted_size, false))
+ {
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
- "Bad character conversion");
+ "Bad char conversion");
}
}
NDR_CHECK(ndr_pull_advance(ndr, (len3 + c_len_term)*byte_mul));
if (len3 == 0) {
as = talloc_strdup(ndr->current_mem_ctx, "");
} else {
- ret = convert_string_talloc(ndr->current_mem_ctx,
- chset, CH_UNIX,
- ndr->data+ndr->offset,
- len3,
- (void **)(void *)&as,
- false);
- if (ret == -1) {
+ if (!convert_string_talloc(ndr->current_mem_ctx, chset,
+ CH_UNIX,
+ ndr->data+ndr->offset, len3,
+ (void **)(void *)&as,
+ &converted_size, false))
+ {
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
- "Bad character conversion");
+ "Bad char conversion");
}
}
NDR_CHECK(ndr_pull_advance(ndr, len3));
} else {
len1 = utf16_len_n(ndr->data+ndr->offset, ndr->data_size - ndr->offset);
}
- ret = convert_string_talloc(ndr->current_mem_ctx,
- chset, CH_UNIX,
- ndr->data+ndr->offset,
- len1,
- (void **)(void *)&as,
- false);
- if (ret == -1) {
+ if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
+ ndr->data+ndr->offset, len1,
+ (void **)(void *)&as,
+ &converted_size, false))
+ {
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
- "Bad character conversion");
+ "Bad char conversion");
}
NDR_CHECK(ndr_pull_advance(ndr, len1));
*s = as;
case LIBNDR_FLAG_STR_FIXLEN32:
len1 = (flags & LIBNDR_FLAG_STR_FIXLEN32)?32:15;
NDR_PULL_NEED_BYTES(ndr, len1*byte_mul);
- ret = convert_string_talloc(ndr->current_mem_ctx,
- chset, CH_UNIX,
- ndr->data+ndr->offset,
- len1*byte_mul,
- (void **)(void *)&as,
- false);
- if (ret == -1) {
+ if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
+ ndr->data+ndr->offset, len1*byte_mul,
+ (void **)(void *)&as,
+ &converted_size, false))
+ {
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
- "Bad character conversion");
+ "Bad char conversion");
}
NDR_CHECK(ndr_pull_advance(ndr, len1*byte_mul));
*s = as;
if (len1 == 0) {
as = talloc_strdup(ndr->current_mem_ctx, "");
} else {
- ret = convert_string_talloc(ndr->current_mem_ctx,
- chset, CH_UNIX,
- ndr->data+ndr->offset,
- len1,
- (void **)(void *)&as,
- false);
- if (ret == -1) {
+ if (!convert_string_talloc(ndr->current_mem_ctx, chset,
+ CH_UNIX,
+ ndr->data+ndr->offset, len1,
+ (void **)(void *)&as,
+ &converted_size, false))
+ {
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
- "Bad character conversion");
+ "Bad char conversion");
}
}
NDR_CHECK(ndr_pull_advance(ndr, len1));
LIBNDR_FLAG_STR_FIXLEN32))) {
s_len++;
}
- d_len = convert_string_talloc(ndr, CH_UNIX, chset, s, s_len,
- (void **)(void *)&dest, false);
- if (d_len == -1) {
+ if (!convert_string_talloc(ndr, CH_UNIX, chset, s, s_len,
+ (void **)(void *)&dest, &d_len, false))
+ {
return ndr_push_error(ndr, NDR_ERR_CHARCNV,
- "Bad character conversion");
+ "Bad char conversion");
}
if (flags & LIBNDR_FLAG_STR_BYTESIZE) {
uint32_t pad_len = fix_len - d_len;
if (d_len > fix_len) {
return ndr_push_error(ndr, NDR_ERR_CHARCNV,
- "Bad character conversion");
+ "Bad char conversion");
}
NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
if (pad_len != 0) {
_PUBLIC_ enum ndr_err_code ndr_pull_charset(struct ndr_pull *ndr, int ndr_flags, const char **var, uint32_t length, uint8_t byte_mul, charset_t chset)
{
- int ret;
+ size_t converted_size;
+
if (length == 0) {
*var = talloc_strdup(ndr->current_mem_ctx, "");
return NDR_ERR_SUCCESS;
NDR_PULL_NEED_BYTES(ndr, length*byte_mul);
- ret = convert_string_talloc(ndr->current_mem_ctx,
- chset, CH_UNIX,
- ndr->data+ndr->offset,
- length*byte_mul,
- discard_const_p(void *, var), false);
- if (ret == -1) {
+ 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))
+ {
return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
- "Bad character conversion");
+ "Bad char conversion");
}
NDR_CHECK(ndr_pull_advance(ndr, length*byte_mul));
ndr->data+ndr->offset, required, false);
if (ret == -1) {
return ndr_push_error(ndr, NDR_ERR_CHARCNV,
- "Bad character conversion");
+ "Bad char conversion");
}
/* Make sure the remaining part of the string is filled with zeroes */
{
krb5_error_code ret;
char *utf8_name;
+ size_t converted_size;
- if (push_utf8_allocate(&utf8_name, name) == (size_t)-1) {
+ if (!push_utf8_allocate(&utf8_name, name, &converted_size)) {
return ENOMEM;
}
{
krb5_error_code ret;
char *utf8_name;
+ size_t converted_size;
*principal = NULL;
- if (push_utf8_allocate(&utf8_name, name) == (size_t)-1) {
+ if (!push_utf8_allocate(&utf8_name, name, &converted_size)) {
return ENOMEM;
}
{
krb5_error_code ret;
char *utf8_name;
+ size_t converted_size;
*unix_name = NULL;
ret = krb5_unparse_name(context, principal, &utf8_name);
return ret;
}
- if (pull_utf8_allocate(unix_name, utf8_name)==-1) {
+ if (!pull_utf8_allocate(unix_name, utf8_name, &converted_size)) {
krb5_free_unparsed_name(context, utf8_name);
return ENOMEM;
}
tmp_buf[nlen] = 0;
tmp_buf[nlen+1] = 0;
- size = convert_string_talloc(streams, CH_UTF16, CH_UNIX,
- tmp_buf, nlen+2, &vstr,
- false);
- TALLOC_FREE(tmp_buf);
-
- if (size == -1) {
+ if (!convert_string_talloc(streams, CH_UTF16, CH_UNIX, tmp_buf,
+ nlen+2, &vstr, &size, false))
+ {
+ TALLOC_FREE(tmp_buf);
goto fail;
}
+
+ TALLOC_FREE(tmp_buf);
streams[num_streams].name = (char *)vstr;
num_streams++;
HMACMD5Context ctx;
- user_byte_len = push_ucs2_allocate(&user, user_in);
- if (user_byte_len == (size_t)-1) {
- DEBUG(0, ("push_uss2_allocate() for user returned -1 (probably malloc() failure)\n"));
+ if (!push_ucs2_allocate(&user, user_in, &user_byte_len)) {
+ DEBUG(0, ("push_uss2_allocate() for user failed: %s\n",
+ strerror(errno)));
return False;
}
- domain_byte_len = push_ucs2_allocate(&domain, domain_in);
- if (domain_byte_len == (size_t)-1) {
- DEBUG(0, ("push_uss2_allocate() for domain returned -1 (probably malloc() failure)\n"));
+ if (!push_ucs2_allocate(&domain, domain_in, &domain_byte_len)) {
+ DEBUG(0, ("push_uss2_allocate() for domain failed: %s\n",
+ strerror(errno)));
return False;
}
smb_ucs2_t *ptr = NULL;
smb_ucs2_t old = oldc;
char *ret = NULL;
+ size_t converted_size;
if (!s) {
return NULL;
}
- if (push_ucs2_talloc(ctx, &tmpbuf, s) == -1) {
+ if (!push_ucs2_talloc(ctx, &tmpbuf, s, &converted_size)) {
return NULL;
}
}
}
- if (pull_ucs2_talloc(ctx, &ret, tmpbuf) == -1) {
+ if (!pull_ucs2_talloc(ctx, &ret, tmpbuf, &converted_size)) {
TALLOC_FREE(tmpbuf);
return NULL;
}
struct berval *retdata = NULL;
char *utf8_password;
char *utf8_dn;
+ size_t converted_size;
if (!ldap_state->is_nds_ldap) {
}
}
- if (push_utf8_allocate(&utf8_password, pdb_get_plaintext_passwd(newpwd)) == (size_t)-1) {
+ if (!push_utf8_allocate(&utf8_password,
+ pdb_get_plaintext_passwd(newpwd),
+ &converted_size))
+ {
return NT_STATUS_NO_MEMORY;
}
- if (push_utf8_allocate(&utf8_dn, dn) == (size_t)-1) {
+ if (!push_utf8_allocate(&utf8_dn, dn, &converted_size)) {
SAFE_FREE(utf8_password);
return NT_STATUS_NO_MEMORY;
}
struct samr_displayentry *result)
{
char **vals;
+ size_t converted_size;
DOM_SID sid;
uint32 acct_flags;
DEBUG(5, ("\"uid\" not found\n"));
return False;
}
- pull_utf8_talloc(mem_ctx,
- CONST_DISCARD(char **, &result->account_name),
- vals[0]);
+ if (!pull_utf8_talloc(mem_ctx,
+ CONST_DISCARD(char **, &result->account_name),
+ vals[0], &converted_size))
+ {
+ DEBUG(0,("ldapuser2displayentry: pull_utf8_talloc failed: %s",
+ strerror(errno)));
+ }
+
ldap_value_free(vals);
vals = ldap_get_values(ld, entry, "displayName");
if ((vals == NULL) || (vals[0] == NULL))
DEBUG(8, ("\"displayName\" not found\n"));
- else
- pull_utf8_talloc(mem_ctx,
- CONST_DISCARD(char **, &result->fullname),
- vals[0]);
+ else if (!pull_utf8_talloc(mem_ctx,
+ CONST_DISCARD(char **, &result->fullname),
+ vals[0], &converted_size))
+ {
+ DEBUG(0,("ldapuser2displayentry: pull_utf8_talloc failed: %s",
+ strerror(errno)));
+ }
+
ldap_value_free(vals);
vals = ldap_get_values(ld, entry, "description");
if ((vals == NULL) || (vals[0] == NULL))
DEBUG(8, ("\"description\" not found\n"));
- else
- pull_utf8_talloc(mem_ctx,
- CONST_DISCARD(char **, &result->description),
- vals[0]);
+ else if (!pull_utf8_talloc(mem_ctx,
+ CONST_DISCARD(char **, &result->description),
+ vals[0], &converted_size))
+ {
+ DEBUG(0,("ldapuser2displayentry: pull_utf8_talloc failed: %s",
+ strerror(errno)));
+ }
+
ldap_value_free(vals);
if ((result->account_name == NULL) ||
struct samr_displayentry *result)
{
char **vals;
+ size_t converted_size;
DOM_SID sid;
uint16 group_type;
DEBUG(5, ("\"cn\" not found\n"));
return False;
}
- pull_utf8_talloc(mem_ctx,
- CONST_DISCARD(char **, &result->account_name),
- vals[0]);
+ if (!pull_utf8_talloc(mem_ctx,
+ CONST_DISCARD(char **,
+ &result->account_name),
+ vals[0], &converted_size))
+ {
+ DEBUG(0,("ldapgroup2displayentry: pull_utf8_talloc "
+ "failed: %s", strerror(errno)));
+ }
}
- else {
- pull_utf8_talloc(mem_ctx,
- CONST_DISCARD(char **, &result->account_name),
- vals[0]);
+ else if (!pull_utf8_talloc(mem_ctx,
+ CONST_DISCARD(char **,
+ &result->account_name),
+ vals[0], &converted_size))
+ {
+ DEBUG(0,("ldapgroup2displayentry: pull_utf8_talloc failed: %s",
+ strerror(errno)));
}
ldap_value_free(vals);
vals = ldap_get_values(ld, entry, "description");
if ((vals == NULL) || (vals[0] == NULL))
DEBUG(8, ("\"description\" not found\n"));
- else
- pull_utf8_talloc(mem_ctx,
- CONST_DISCARD(char **, &result->description),
- vals[0]);
+ else if (!pull_utf8_talloc(mem_ctx,
+ CONST_DISCARD(char **, &result->description),
+ vals[0], &converted_size))
+ {
+ DEBUG(0,("ldapgroup2displayentry: pull_utf8_talloc failed: %s",
+ strerror(errno)));
+ }
ldap_value_free(vals);
if ((result->account_name == NULL) ||
{
smb_ucs2_t *uni_dom_name;
bool ret;
+ size_t converted_size;
/* packing structures */
uint8 *pass_buf = NULL;
struct trusted_dom_pass pass;
ZERO_STRUCT(pass);
- if (push_ucs2_allocate(&uni_dom_name, domain) == (size_t)-1) {
+ if (!push_ucs2_allocate(&uni_dom_name, domain, &converted_size)) {
DEBUG(0, ("Could not convert domain name %s to unicode\n",
domain));
return False;
static int list_trusted_domain(struct db_record *rec, void *private_data)
{
const size_t prefix_len = strlen(SECRETS_DOMTRUST_ACCT_PASS);
- size_t packed_size = 0;
+ size_t converted_size, packed_size = 0;
struct trusted_dom_pass pass;
struct trustdom_info *dom_info;
return 0;
}
- if (pull_ucs2_talloc(dom_info, &dom_info->name,
- pass.uni_name) == (size_t)-1) {
+ if (!pull_ucs2_talloc(dom_info, &dom_info->name, pass.uni_name,
+ &converted_size)) {
DEBUG(2, ("pull_ucs2_talloc failed\n"));
TALLOC_FREE(dom_info);
return 0;
const char *attrs[] = {"objectGUID", NULL};
struct GUID guid;
WERROR win_rc = WERR_OK;
+ size_t converted_size;
DEBUG(5, ("publishing printer %s\n", printer->info_2->printername));
return WERR_SERVER_UNAVAILABLE;
}
/* Now convert to CH_UNIX. */
- if (pull_utf8_allocate(&srv_dn, srv_dn_utf8) == (size_t)-1) {
+ if (!pull_utf8_allocate(&srv_dn, srv_dn_utf8, &converted_size)) {
ldap_memfree(srv_dn_utf8);
ldap_memfree(srv_cn_utf8);
ads_destroy(&ads);
return WERR_SERVER_UNAVAILABLE;
}
- if (pull_utf8_allocate(&srv_cn_0, srv_cn_utf8[0]) == (size_t)-1) {
+ if (!pull_utf8_allocate(&srv_cn_0, srv_cn_utf8[0], &converted_size)) {
ldap_memfree(srv_dn_utf8);
ldap_memfree(srv_cn_utf8);
ads_destroy(&ads);
message = argv[1];
}
- message_size = push_ucs2_talloc(mem_ctx,
- &message_buffer,
- message);
- if (message_size == -1) {
+ if (!push_ucs2_talloc(mem_ctx, &message_buffer, message,
+ &message_size))
+ {
return WERR_NOMEM;
}
unsigned int offset;
int snum;
int res = ERRunsup;
+ size_t converted_size;
if (!str1 || !str2 || !p) {
return False;
return False;
}
- pull_ascii_talloc(talloc_tos(), &pathname, offset? (data+offset) : "");
+ if (!pull_ascii_talloc(talloc_tos(), &pathname,
+ offset ? (data+offset) : "", &converted_size))
+ {
+ DEBUG(0,("api_RNetShareAdd: pull_ascii_talloc failed: %s",
+ strerror(errno)));
+ }
+
if (!pathname) {
return false;
}
if (strlen(f) > 12)
return False;
- size = push_ucs2_allocate(&ucs2name, f);
- if (size == (size_t)-1) {
+ if (!push_ucs2_allocate(&ucs2name, f, &size)) {
DEBUG(0,("is_8_3: internal error push_ucs2_allocate() failed!\n"));
goto done;
}
{
smb_ucs2_t *name_ucs2 = NULL;
NTSTATUS status;
+ size_t converted_size;
+
magic_char = lp_magicchar(p);
- if (push_ucs2_allocate(&name_ucs2, name) == (size_t)-1) {
+ if (!push_ucs2_allocate(&name_ucs2, name, &converted_size)) {
DEBUG(0, ("push_ucs2_allocate failed!\n"));
return False;
}
const struct share_params *p)
{
smb_ucs2_t *in_ucs2 = NULL;
+ size_t converted_size;
+
magic_char = lp_magicchar(p);
DEBUG(5,("hash_name_to_8_3( %s, cache83 = %s)\n", in,
cache83 ? "True" : "False"));
- if (push_ucs2_allocate(&in_ucs2, in) == (size_t)-1) {
+ if (!push_ucs2_allocate(&in_ucs2, in, &converted_size)) {
DEBUG(0, ("push_ucs2_allocate failed!\n"));
return False;
}
int i;
int fd;
char *msg;
- int len;
+ size_t len;
ssize_t sz;
fstring alpha_buf;
char *s;
* Incoming message is in DOS codepage format. Convert to UNIX.
*/
- len = convert_string_talloc(
- talloc_tos(), CH_DOS, CH_UNIX, state->msg,
- talloc_get_size(state->msg), (void *)&msg, true);
-
- if (len == -1) {
+ if (!convert_string_talloc(talloc_tos(), CH_DOS, CH_UNIX, state->msg,
+ talloc_get_size(state->msg), (void *)&msg,
+ &len, true)) {
DEBUG(3, ("Conversion failed, delivering message in DOS "
"codepage format\n"));
msg = state->msg;
}
for (i = 0; i < len; i++) {
- if ((msg[i] == '\r') && (i < (len-1)) && (msg[i+1] == '\n')) {
+ if ((msg[i] == '\r') &&
+ (i < (len-1)) && (msg[i+1] == '\n')) {
continue;
}
sz = write(fd, &msg[i], 1);
int num_cliprotos;
char **cliprotos;
int i;
+ size_t converted_size;
static bool done_negprot = False;
cliprotos = tmp;
- if (pull_ascii_talloc(cliprotos, &cliprotos[num_cliprotos], p)
- == (size_t)-1) {
+ if (!pull_ascii_talloc(cliprotos, &cliprotos[num_cliprotos], p,
+ &converted_size)) {
DEBUG(0, ("pull_ascii_talloc failed\n"));
TALLOC_FREE(cliprotos);
reply_nterror(req, NT_STATUS_NO_MEMORY);
char *p;
char **names, **tmp;
size_t num_names;
- ssize_t sizeret;
+ ssize_t sizeret = -1;
if (!lp_ea_support(SNUM(conn))) {
*pnames = NULL;
static struct ea_list *read_ea_name_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
{
struct ea_list *ea_list_head = NULL;
- size_t offset = 0;
+ size_t converted_size, offset = 0;
while (offset + 2 < data_size) {
struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
if (pdata[offset + namelen] != '\0') {
return NULL;
}
- pull_ascii_talloc(ctx, &eal->ea.name, &pdata[offset]);
+ if (!pull_ascii_talloc(ctx, &eal->ea.name, &pdata[offset],
+ &converted_size)) {
+ DEBUG(0,("read_ea_name_list: pull_ascii_talloc "
+ "failed: %s", strerror(errno)));
+ }
if (!eal->ea.name) {
return NULL;
}
struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
uint16 val_len;
unsigned int namelen;
+ size_t converted_size;
if (!eal) {
return NULL;
if (pdata[namelen + 4] != '\0') {
return NULL;
}
- pull_ascii_talloc(ctx, &eal->ea.name, pdata + 4);
+ if (!pull_ascii_talloc(ctx, &eal->ea.name, pdata + 4, &converted_size)) {
+ DEBUG(0,("read_ea_list_entry: pull_ascii_talloc failed: %s",
+ strerror(errno)));
+ }
if (!eal->ea.name) {
return NULL;
}
size_t namelen;
smb_ucs2_t *namebuf;
- namelen = push_ucs2_talloc(talloc_tos(), &namebuf,
- streams[i].name);
-
- if ((namelen == (size_t)-1) || (namelen <= 2)) {
+ if (!push_ucs2_talloc(talloc_tos(), &namebuf,
+ streams[i].name, &namelen) ||
+ namelen <= 2)
+ {
return NT_STATUS_INVALID_PARAMETER;
}
smb_ucs2_t *dest = NULL;
char *orig2 = NULL;
int ret;
+ size_t converted_size;
- push_ucs2_allocate(&dest, orig);
- pull_ucs2_allocate(&orig2, dest);
+ push_ucs2_allocate(&dest, orig, &converted_size);
+ pull_ucs2_allocate(&orig2, dest, &converted_size);
ret = strcmp(orig, orig2);
if (ret) {
fprintf(stderr, "orig: %s\n", orig);
DATA_BLOB lm_response = data_blob_null;
char *password;
smb_ucs2_t *nt_response_ucs2;
+ size_t converted_size;
uchar user_session_key[16];
uchar lm_key[16];
flags |= WBFLAG_PAM_LMKEY;
flags |= WBFLAG_PAM_USER_SESSION_KEY;
- if ((push_ucs2_allocate(&nt_response_ucs2, opt_password)) == -1) {
+ if (!push_ucs2_allocate(&nt_response_ucs2, opt_password,
+ &converted_size))
+ {
DEBUG(0, ("push_ucs2_allocate failed!\n"));
exit(1);
}
{
char *utf8_fname;
int deny_mode;
+ size_t converted_size;
if (!is_valid_share_mode_entry(e)) {
return;
printf("NONE ");
printf("</td>");
- push_utf8_allocate(&utf8_fname, fname);
+ push_utf8_allocate(&utf8_fname, fname, &converted_size);
printf("<td>%s</td><td>%s</td></tr>\n",
utf8_fname,tstring(talloc_tos(),e->time.tv_sec));
SAFE_FREE(utf8_fname);
int i;
void *ptr = parm->ptr;
char *utf8_s1, *utf8_s2;
+ size_t converted_size;
TALLOC_CTX *ctx = talloc_stackframe();
if (parm->p_class == P_LOCAL && snum >= 0) {
for (;*list;list++) {
/* enclose in HTML encoded quotes if the string contains a space */
if ( strchr_m(*list, ' ') ) {
- push_utf8_allocate(&utf8_s1, *list);
- push_utf8_allocate(&utf8_s2, ((*(list+1))?", ":""));
+ push_utf8_allocate(&utf8_s1, *list, &converted_size);
+ push_utf8_allocate(&utf8_s2, ((*(list+1))?", ":""), &converted_size);
printf(""%s"%s", utf8_s1, utf8_s2);
} else {
- push_utf8_allocate(&utf8_s1, *list);
- push_utf8_allocate(&utf8_s2, ((*(list+1))?", ":""));
+ push_utf8_allocate(&utf8_s1, *list, &converted_size);
+ push_utf8_allocate(&utf8_s2, ((*(list+1))?", ":""), &converted_size);
printf("%s%s", utf8_s1, utf8_s2);
}
SAFE_FREE(utf8_s1);
case P_STRING:
case P_USTRING:
- push_utf8_allocate(&utf8_s1, *(char **)ptr);
+ push_utf8_allocate(&utf8_s1, *(char **)ptr, &converted_size);
printf("<input type=text size=40 name=\"parm_%s\" value=\"%s\">",
make_parm_name(parm->label), fix_quotes(ctx, utf8_s1));
SAFE_FREE(utf8_s1);
int i;
int mode = 0;
unsigned int parm_filter = FLAG_BASIC;
+ size_t converted_size;
if (share)
snum = lp_servicenumber(share);
for (i=0;i<lp_numservices();i++) {
s = lp_servicename(i);
if (s && (*s) && strcmp(s,"IPC$") && !lp_print_ok(i)) {
- push_utf8_allocate(&utf8_s, s);
+ push_utf8_allocate(&utf8_s, s, &converted_size);
printf("<option %s value=\"%s\">%s\n",
(share && strcmp(share,s)==0)?"SELECTED":"",
utf8_s, utf8_s);
git.samba.org / kai / samba.git / commitdiff