Remove iconv_convenience parameter from simple string push/pull

functions.

3 files changed, 345 insertions, 340 deletions

diff --git a/lib/util/charset/charcnv.c b/lib/util/charset/charcnv.c
index 35119e5395..91a16a1cda 100644
--- a/lib/util/charset/charcnv.c
+++ b/lib/util/charset/charcnv.c
@@ -312,329 +312,6 @@ _PUBLIC_ ssize_t convert_string_talloc(TALLOC_CTX *ctx,
 	return convert_string_talloc_descriptor(ctx, descriptor, src, srclen, dest);
 }
 
-/**
- * Copy a string from a char* unix src to a dos codepage string destination.
- *
- * @return the number of bytes occupied by the string in the destination.
- *
- * @param flags can include
- * <dl>
- * <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
- * <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
- * </dl>
- *
- * @param dest_len the maximum length in bytes allowed in the
- * destination.  If @p dest_len is -1 then no maximum is used.
- **/
-static ssize_t push_ascii(struct smb_iconv_convenience *ic, 
-			  void *dest, const char *src, size_t dest_len, int flags)
-{
-	size_t src_len;
-	ssize_t ret;
-
-	if (flags & STR_UPPER) {
-		char *tmpbuf = strupper_talloc(NULL, src);
-		if (tmpbuf == NULL) {
-			return -1;
-		}
-		ret = push_ascii(ic, dest, tmpbuf, dest_len, flags & ~STR_UPPER);
-		talloc_free(tmpbuf);
-		return ret;
-	}
-
-	src_len = strlen(src);
-
-	if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
-		src_len++;
-
-	return convert_string(ic, CH_UNIX, CH_DOS, src, src_len, dest, dest_len);
-}
-
-/**
- * Copy a string from a unix char* src to an ASCII destination,
- * allocating a buffer using talloc().
- *
- * @param dest always set at least to NULL 
- *
- * @returns The number of bytes occupied by the string in the destination
- *         or -1 in case of error.
- **/
-_PUBLIC_ ssize_t push_ascii_talloc(TALLOC_CTX *ctx, struct smb_iconv_convenience *ic, char **dest, const char *src)
-{
-	size_t src_len = strlen(src)+1;
-	*dest = NULL;
-	return convert_string_talloc(ctx, ic, CH_UNIX, CH_DOS, src, src_len, (void **)dest);
-}
-
-
-/**
- * Copy a string from a dos codepage source to a unix char* destination.
- *
- * The resulting string in "dest" is always null terminated.
- *
- * @param flags can have:
- * <dl>
- * <dt>STR_TERMINATE</dt>
- * <dd>STR_TERMINATE means the string in @p src
- * is null terminated, and src_len is ignored.</dd>
- * </dl>
- *
- * @param src_len is the length of the source area in bytes.
- * @returns the number of bytes occupied by the string in @p src.
- **/
-static ssize_t pull_ascii(struct smb_iconv_convenience *ic, char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
-{
-	size_t ret;
-
-	if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII)) {
-		if (src_len == (size_t)-1) {
-			src_len = strlen((const char *)src) + 1;
-		} else {
-			size_t len = strnlen((const char *)src, src_len);
-			if (len < src_len)
-				len++;
-			src_len = len;
-		}
-	}
-
-	ret = convert_string(ic, CH_DOS, CH_UNIX, src, src_len, dest, dest_len);
-
-	if (dest_len)
-		dest[MIN(ret, dest_len-1)] = 0;
-
-	return src_len;
-}
-
-/**
- * Copy a string from a char* src to a unicode destination.
- *
- * @returns the number of bytes occupied by the string in the destination.
- *
- * @param flags can have:
- *
- * <dl>
- * <dt>STR_TERMINATE <dd>means include the null termination.
- * <dt>STR_UPPER     <dd>means uppercase in the destination.
- * <dt>STR_NOALIGN   <dd>means don't do alignment.
- * </dl>
- *
- * @param dest_len is the maximum length allowed in the
- * destination. If dest_len is -1 then no maxiumum is used.
- **/
-static ssize_t push_ucs2(struct smb_iconv_convenience *ic, 
-			 void *dest, const char *src, size_t dest_len, int flags)
-{
-	size_t len=0;
-	size_t src_len = strlen(src);
-	size_t ret;
-
-	if (flags & STR_UPPER) {
-		char *tmpbuf = strupper_talloc(NULL, src);
-		if (tmpbuf == NULL) {
-			return -1;
-		}
-		ret = push_ucs2(ic, dest, tmpbuf, dest_len, flags & ~STR_UPPER);
-		talloc_free(tmpbuf);
-		return ret;
-	}
-
-	if (flags & STR_TERMINATE)
-		src_len++;
-
-	if (ucs2_align(NULL, dest, flags)) {
-		*(char *)dest = 0;
-		dest = (void *)((char *)dest + 1);
-		if (dest_len) dest_len--;
-		len++;
-	}
-
-	/* ucs2 is always a multiple of 2 bytes */
-	dest_len &= ~1;
-
-	ret = convert_string(ic, CH_UNIX, CH_UTF16, src, src_len, dest, dest_len);
-	if (ret == (size_t)-1) {
-		return 0;
-	}
-
-	len += ret;
-
-	return len;
-}
-
-
-/**
- * Copy a string from a unix char* src to a UCS2 destination,
- * allocating a buffer using talloc().
- *
- * @param dest always set at least to NULL 
- *
- * @returns The number of bytes occupied by the string in the destination
- *         or -1 in case of error.
- **/
-_PUBLIC_ ssize_t push_ucs2_talloc(TALLOC_CTX *ctx, struct smb_iconv_convenience *ic, void **dest, const char *src)
-{
-	size_t src_len = strlen(src)+1;
-	*dest = NULL;
-	return convert_string_talloc(ctx, ic, CH_UNIX, CH_UTF16, src, src_len, dest);
-}
-
-
-/**
- * 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 
- *
- * @returns The number of bytes occupied by the string in the destination
- **/
-
-_PUBLIC_ ssize_t push_utf8_talloc(TALLOC_CTX *ctx, struct smb_iconv_convenience *ic, char **dest, const char *src)
-{
-	size_t src_len = strlen(src)+1;
-	*dest = NULL;
-	return convert_string_talloc(ctx, ic, CH_UNIX, CH_UTF8, src, src_len, (void **)dest);
-}
-
-/**
- Copy a string from a ucs2 source to a unix char* destination.
- Flags can have:
-  STR_TERMINATE means the string in src is null terminated.
-  STR_NOALIGN   means don't try to align.
- if STR_TERMINATE is set then src_len is ignored if it is -1.
- src_len is the length of the source area in bytes
- Return the number of bytes occupied by the string in src.
- The resulting string in "dest" is always null terminated.
-**/
-
-static size_t pull_ucs2(struct smb_iconv_convenience *ic, char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
-{
-	size_t ret;
-
-	if (ucs2_align(NULL, src, flags)) {
-		src = (const void *)((const char *)src + 1);
-		if (src_len > 0)
-			src_len--;
-	}
-
-	if (flags & STR_TERMINATE) {
-		if (src_len == (size_t)-1) {
-			src_len = utf16_len(src);
-		} else {
-			src_len = utf16_len_n(src, src_len);
-		}
-	}
-
-	/* ucs2 is always a multiple of 2 bytes */
-	if (src_len != (size_t)-1)
-		src_len &= ~1;
-	
-	ret = convert_string(ic, CH_UTF16, CH_UNIX, src, src_len, dest, dest_len);
-	if (dest_len)
-		dest[MIN(ret, dest_len-1)] = 0;
-
-	return src_len;
-}
-
-/**
- * Copy a string from a ASCII src to a unix char * destination, allocating a buffer using talloc
- *
- * @param dest always set at least to NULL 
- *
- * @returns The number of bytes occupied by the string in the destination
- **/
-
-_PUBLIC_ ssize_t pull_ascii_talloc(TALLOC_CTX *ctx, struct smb_iconv_convenience *ic, char **dest, const char *src)
-{
-	size_t src_len = strlen(src)+1;
-	*dest = NULL;
-	return convert_string_talloc(ctx, ic, CH_DOS, CH_UNIX, src, src_len, (void **)dest);
-}
-
-/**
- * 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 
- *
- * @returns The number of bytes occupied by the string in the destination
- **/
-
-_PUBLIC_ ssize_t pull_ucs2_talloc(TALLOC_CTX *ctx, struct smb_iconv_convenience *ic, char **dest, const void *src)
-{
-	size_t src_len = utf16_len(src);
-	*dest = NULL;
-	return convert_string_talloc(ctx, ic, CH_UTF16, CH_UNIX, src, src_len, (void **)dest);
-}
-
-/**
- * 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 
- *
- * @returns The number of bytes occupied by the string in the destination
- **/
-
-_PUBLIC_ ssize_t pull_utf8_talloc(TALLOC_CTX *ctx, struct smb_iconv_convenience *ic, char **dest, const char *src)
-{
-	size_t src_len = strlen(src)+1;
-	*dest = NULL;
-	return convert_string_talloc(ctx, ic, CH_UTF8, CH_UNIX, src, src_len, (void **)dest);
-}
-
-/**
- Copy a string from a char* src to a unicode or ascii
- dos codepage destination choosing unicode or ascii based on the 
- flags in the SMB buffer starting at base_ptr.
- Return the number of bytes occupied by the string in the destination.
- flags can have:
-  STR_TERMINATE means include the null termination.
-  STR_UPPER     means uppercase in the destination.
-  STR_ASCII     use ascii even with unicode packet.
-  STR_NOALIGN   means don't do alignment.
- dest_len is the maximum length allowed in the destination. If dest_len
- is -1 then no maxiumum is used.
-**/
-
-_PUBLIC_ ssize_t push_string(struct smb_iconv_convenience *ic, 
-			     void *dest, const char *src, size_t dest_len, int flags)
-{
-	if (flags & STR_ASCII) {
-		return push_ascii(ic, dest, src, dest_len, flags);
-	} else if (flags & STR_UNICODE) {
-		return push_ucs2(ic, dest, src, dest_len, flags);
-	} else {
-		smb_panic("push_string requires either STR_ASCII or STR_UNICODE flag to be set");
-		return -1;
-	}
-}
-
-
-/**
- Copy a string from a unicode or ascii source (depending on
- the packet flags) to a char* destination.
- Flags can have:
-  STR_TERMINATE means the string in src is null terminated.
-  STR_UNICODE   means to force as unicode.
-  STR_ASCII     use ascii even with unicode packet.
-  STR_NOALIGN   means don't do alignment.
- if STR_TERMINATE is set then src_len is ignored is it is -1
- src_len is the length of the source area in bytes.
- Return the number of bytes occupied by the string in src.
- The resulting string in "dest" is always null terminated.
-**/
-
-_PUBLIC_ ssize_t pull_string(struct smb_iconv_convenience *ic,
-			     char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
-{
-	if (flags & STR_ASCII) {
-		return pull_ascii(ic, dest, src, dest_len, src_len, flags);
-	} else if (flags & STR_UNICODE) {
-		return pull_ucs2(ic, dest, src, dest_len, src_len, flags);
-	} else {
-		smb_panic("pull_string requires either STR_ASCII or STR_UNICODE flag to be set");
-		return -1;
-	}
-}
-
-
 /*
   return the unicode codepoint for the next multi-byte CH_UNIX character
   in the string
diff --git a/lib/util/charset/charset.h b/lib/util/charset/charset.h
index 4f7167736a..cba8aaf5f3 100644
--- a/lib/util/charset/charset.h
+++ b/lib/util/charset/charset.h
@@ -76,7 +76,6 @@ typedef struct smb_iconv_s {
 
 struct loadparm_context;
 struct smb_iconv_convenience;
-extern struct smb_iconv_convenience *global_smb_iconv_convenience;
 
 /* replace some string functions with multi-byte
    versions */
@@ -105,6 +104,15 @@ bool strhaslower(const char *string);
 char *strrchr_m(const char *s, char c);
 char *strchr_m(const char *s, char c);
 
+ssize_t push_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src);
+ssize_t push_ucs2_talloc(TALLOC_CTX *ctx, void **dest, const char *src);
+ssize_t push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src);
+ssize_t pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src);
+ssize_t pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const void *src);
+ssize_t pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src);
+ssize_t push_string(void *dest, const char *src, size_t dest_len, int flags);
+ssize_t pull_string(char *dest, const void *src, size_t dest_len, size_t src_len, int flags);
+
 /* codepoints */
 codepoint_t next_codepoint(struct smb_iconv_convenience *ic, 
 			    const char *str, size_t *size);
@@ -113,9 +121,13 @@ ssize_t push_codepoint(struct smb_iconv_convenience *ic,
 codepoint_t toupper_m(codepoint_t val);
 codepoint_t tolower_m(codepoint_t val);
 int codepoint_cmpi(codepoint_t c1, codepoint_t c2);
-ssize_t push_string(struct smb_iconv_convenience *ic, void *dest, const char *src, size_t dest_len, int flags);
-ssize_t pull_string(struct smb_iconv_convenience *ic,
-		    char *dest, const void *src, size_t dest_len, size_t src_len, int flags);
+
+/* Iconv convenience functions */
+struct smb_iconv_convenience *smb_iconv_convenience_init(TALLOC_CTX *mem_ctx,
+							 const char *dos_charset,
+							 const char *unix_charset,
+							 bool native_iconv);
+
 ssize_t convert_string(struct smb_iconv_convenience *ic,
 				charset_t from, charset_t to,
 				void const *src, size_t srclen, 
@@ -126,13 +138,6 @@ ssize_t convert_string_talloc(TALLOC_CTX *ctx,
 				       charset_t from, charset_t to, 
 				       void const *src, size_t srclen, 
 				       void **dest);
-ssize_t push_ascii_talloc(TALLOC_CTX *ctx, struct smb_iconv_convenience *ic, char **dest, const char *src);
-ssize_t push_ucs2_talloc(TALLOC_CTX *ctx, struct smb_iconv_convenience *ic, void **dest, const char *src);
-ssize_t push_utf8_talloc(TALLOC_CTX *ctx, struct smb_iconv_convenience *ic, char **dest, const char *src);
-ssize_t pull_ascii_talloc(TALLOC_CTX *ctx, struct smb_iconv_convenience *ic, char **dest, const char *src);
-ssize_t pull_ucs2_talloc(TALLOC_CTX *ctx, struct smb_iconv_convenience *ic, char **dest, const void *src);
-ssize_t pull_utf8_talloc(TALLOC_CTX *ctx, struct smb_iconv_convenience *ic, char **dest, const char *src);
-
 /* iconv */
 smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode);
 int smb_iconv_close(smb_iconv_t cd);
@@ -142,12 +147,6 @@ size_t smb_iconv(smb_iconv_t cd,
 smb_iconv_t smb_iconv_open_ex(TALLOC_CTX *mem_ctx, const char *tocode, 
 			      const char *fromcode, bool native_iconv);
 
-/* iconv convenience */
-struct smb_iconv_convenience *smb_iconv_convenience_init(TALLOC_CTX *mem_ctx,
-							 const char *dos_charset,
-							 const char *unix_charset,
-							 bool native_iconv);
-
 void load_case_tables(void);
 bool charset_register_backend(const void *_funcs);
 
diff --git a/lib/util/charset/util_unistr.c b/lib/util/charset/util_unistr.c
index c53c13b7d0..85f9755557 100644
--- a/lib/util/charset/util_unistr.c
+++ b/lib/util/charset/util_unistr.c
@@ -596,3 +596,332 @@ _PUBLIC_ size_t count_chars_m(const char *s, char c)
 }
 
 
+/**
+ * Copy a string from a char* unix src to a dos codepage string destination.
+ *
+ * @return the number of bytes occupied by the string in the destination.
+ *
+ * @param flags can include
+ * <dl>
+ * <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
+ * <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
+ * </dl>
+ *
+ * @param dest_len the maximum length in bytes allowed in the
+ * destination.  If @p dest_len is -1 then no maximum is used.
+ **/
+static ssize_t push_ascii(void *dest, const char *src, size_t dest_len, int flags)
+{
+	size_t src_len;
+	ssize_t ret;
+	struct smb_iconv_convenience *ic = get_iconv_convenience();
+
+	if (flags & STR_UPPER) {
+		char *tmpbuf = strupper_talloc(NULL, src);
+		if (tmpbuf == NULL) {
+			return -1;
+		}
+		ret = push_ascii(dest, tmpbuf, dest_len, flags & ~STR_UPPER);
+		talloc_free(tmpbuf);
+		return ret;
+	}
+
+	src_len = strlen(src);
+
+	if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
+		src_len++;
+
+	return convert_string(ic, CH_UNIX, CH_DOS, src, src_len, dest, dest_len);
+}
+
+/**
+ * Copy a string from a unix char* src to an ASCII destination,
+ * allocating a buffer using talloc().
+ *
+ * @param dest always set at least to NULL 
+ *
+ * @returns The number of bytes occupied by the string in the destination
+ *         or -1 in case of error.
+ **/
+_PUBLIC_ ssize_t push_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
+{
+	struct smb_iconv_convenience *ic = get_iconv_convenience();
+	size_t src_len = strlen(src)+1;
+	*dest = NULL;
+	return convert_string_talloc(ctx, ic, CH_UNIX, CH_DOS, src, src_len, (void **)dest);
+}
+
+
+/**
+ * Copy a string from a dos codepage source to a unix char* destination.
+ *
+ * The resulting string in "dest" is always null terminated.
+ *
+ * @param flags can have:
+ * <dl>
+ * <dt>STR_TERMINATE</dt>
+ * <dd>STR_TERMINATE means the string in @p src
+ * is null terminated, and src_len is ignored.</dd>
+ * </dl>
+ *
+ * @param src_len is the length of the source area in bytes.
+ * @returns the number of bytes occupied by the string in @p src.
+ **/
+static ssize_t pull_ascii(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
+{
+	struct smb_iconv_convenience *ic = get_iconv_convenience();
+	size_t ret;
+
+	if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII)) {
+		if (src_len == (size_t)-1) {
+			src_len = strlen((const char *)src) + 1;
+		} else {
+			size_t len = strnlen((const char *)src, src_len);
+			if (len < src_len)
+				len++;
+			src_len = len;
+		}
+	}
+
+	ret = convert_string(ic, CH_DOS, CH_UNIX, src, src_len, dest, dest_len);
+
+	if (dest_len)
+		dest[MIN(ret, dest_len-1)] = 0;
+
+	return src_len;
+}
+
+/**
+ * Copy a string from a char* src to a unicode destination.
+ *
+ * @returns the number of bytes occupied by the string in the destination.
+ *
+ * @param flags can have:
+ *
+ * <dl>
+ * <dt>STR_TERMINATE <dd>means include the null termination.
+ * <dt>STR_UPPER     <dd>means uppercase in the destination.
+ * <dt>STR_NOALIGN   <dd>means don't do alignment.
+ * </dl>
+ *
+ * @param dest_len is the maximum length allowed in the
+ * destination. If dest_len is -1 then no maxiumum is used.
+ **/
+static ssize_t push_ucs2(void *dest, const char *src, size_t dest_len, int flags)
+{
+	struct smb_iconv_convenience *ic = get_iconv_convenience();
+	size_t len=0;
+	size_t src_len = strlen(src);
+	size_t ret;
+
+	if (flags & STR_UPPER) {
+		char *tmpbuf = strupper_talloc(NULL, src);
+		if (tmpbuf == NULL) {
+			return -1;
+		}
+		ret = push_ucs2(dest, tmpbuf, dest_len, flags & ~STR_UPPER);
+		talloc_free(tmpbuf);
+		return ret;
+	}
+
+	if (flags & STR_TERMINATE)
+		src_len++;
+
+	if (ucs2_align(NULL, dest, flags)) {
+		*(char *)dest = 0;
+		dest = (void *)((char *)dest + 1);
+		if (dest_len) dest_len--;
+		len++;
+	}
+
+	/* ucs2 is always a multiple of 2 bytes */
+	dest_len &= ~1;
+
+	ret = convert_string(ic, CH_UNIX, CH_UTF16, src, src_len, dest, dest_len);
+	if (ret == (size_t)-1) {
+		return 0;
+	}
+
+	len += ret;
+
+	return len;
+}
+
+
+/**
+ * Copy a string from a unix char* src to a UCS2 destination,
+ * allocating a buffer using talloc().
+ *
+ * @param dest always set at least to NULL 
+ *
+ * @returns The number of bytes occupied by the string in the destination
+ *         or -1 in case of error.
+ **/
+_PUBLIC_ ssize_t push_ucs2_talloc(TALLOC_CTX *ctx, void **dest, const char *src)
+{
+	struct smb_iconv_convenience *ic = get_iconv_convenience();
+	size_t src_len = strlen(src)+1;
+	*dest = NULL;
+	return convert_string_talloc(ctx, ic, CH_UNIX, CH_UTF16, src, src_len, dest);
+}
+
+
+/**
+ * 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 
+ *
+ * @returns The number of bytes occupied by the string in the destination
+ **/
+
+_PUBLIC_ ssize_t push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
+{
+	struct smb_iconv_convenience *ic = get_iconv_convenience();
+	size_t src_len = strlen(src)+1;
+	*dest = NULL;
+	return convert_string_talloc(ctx, ic, CH_UNIX, CH_UTF8, src, src_len, (void **)dest);
+}
+
+/**
+ Copy a string from a ucs2 source to a unix char* destination.
+ Flags can have:
+  STR_TERMINATE means the string in src is null terminated.
+  STR_NOALIGN   means don't try to align.
+ if STR_TERMINATE is set then src_len is ignored if it is -1.
+ src_len is the length of the source area in bytes
+ Return the number of bytes occupied by the string in src.
+ The resulting string in "dest" is always null terminated.
+**/
+
+static size_t pull_ucs2(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
+{
+	struct smb_iconv_convenience *ic = get_iconv_convenience();
+	size_t ret;
+
+	if (ucs2_align(NULL, src, flags)) {
+		src = (const void *)((const char *)src + 1);
+		if (src_len > 0)
+			src_len--;
+	}
+
+	if (flags & STR_TERMINATE) {
+		if (src_len == (size_t)-1) {
+			src_len = utf16_len(src);
+		} else {
+			src_len = utf16_len_n(src, src_len);
+		}
+	}
+
+	/* ucs2 is always a multiple of 2 bytes */
+	if (src_len != (size_t)-1)
+		src_len &= ~1;
+	
+	ret = convert_string(ic, CH_UTF16, CH_UNIX, src, src_len, dest, dest_len);
+	if (dest_len)
+		dest[MIN(ret, dest_len-1)] = 0;
+
+	return src_len;
+}
+
+/**
+ * Copy a string from a ASCII src to a unix char * destination, allocating a buffer using talloc
+ *
+ * @param dest always set at least to NULL 
+ *
+ * @returns The number of bytes occupied by the string in the destination
+ **/
+
+_PUBLIC_ ssize_t pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
+{
+	struct smb_iconv_convenience *ic = get_iconv_convenience();
+	size_t src_len = strlen(src)+1;
+	*dest = NULL;
+	return convert_string_talloc(ctx, ic, CH_DOS, CH_UNIX, src, src_len, (void **)dest);
+}
+
+/**
+ * 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 
+ *
+ * @returns The number of bytes occupied by the string in the destination
+ **/
+
+_PUBLIC_ ssize_t pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const void *src)
+{
+	struct smb_iconv_convenience *ic = get_iconv_convenience();
+	size_t src_len = utf16_len(src);
+	*dest = NULL;
+	return convert_string_talloc(ctx, ic, CH_UTF16, CH_UNIX, src, src_len, (void **)dest);
+}
+
+/**
+ * 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 
+ *
+ * @returns The number of bytes occupied by the string in the destination
+ **/
+
+_PUBLIC_ ssize_t pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
+{
+	struct smb_iconv_convenience *ic = get_iconv_convenience();
+	size_t src_len = strlen(src)+1;
+	*dest = NULL;
+	return convert_string_talloc(ctx, ic, CH_UTF8, CH_UNIX, src, src_len, (void **)dest);
+}
+
+/**
+ Copy a string from a char* src to a unicode or ascii
+ dos codepage destination choosing unicode or ascii based on the 
+ flags in the SMB buffer starting at base_ptr.
+ Return the number of bytes occupied by the string in the destination.
+ flags can have:
+  STR_TERMINATE means include the null termination.
+  STR_UPPER     means uppercase in the destination.
+  STR_ASCII     use ascii even with unicode packet.
+  STR_NOALIGN   means don't do alignment.
+ dest_len is the maximum length allowed in the destination. If dest_len
+ is -1 then no maxiumum is used.
+**/
+
+_PUBLIC_ ssize_t push_string(void *dest, const char *src, size_t dest_len, int flags)
+{
+	if (flags & STR_ASCII) {
+		return push_ascii(dest, src, dest_len, flags);
+	} else if (flags & STR_UNICODE) {
+		return push_ucs2(dest, src, dest_len, flags);
+	} else {
+		smb_panic("push_string requires either STR_ASCII or STR_UNICODE flag to be set");
+		return -1;
+	}
+}
+
+
+/**
+ Copy a string from a unicode or ascii source (depending on
+ the packet flags) to a char* destination.
+ Flags can have:
+  STR_TERMINATE means the string in src is null terminated.
+  STR_UNICODE   means to force as unicode.
+  STR_ASCII     use ascii even with unicode packet.
+  STR_NOALIGN   means don't do alignment.
+ if STR_TERMINATE is set then src_len is ignored is it is -1
+ src_len is the length of the source area in bytes.
+ Return the number of bytes occupied by the string in src.
+ The resulting string in "dest" is always null terminated.
+**/
+
+_PUBLIC_ ssize_t pull_string(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
+{
+	if (flags & STR_ASCII) {
+		return pull_ascii(dest, src, dest_len, src_len, flags);
+	} else if (flags & STR_UNICODE) {
+		return pull_ucs2(dest, src, dest_len, src_len, flags);
+	} else {
+		smb_panic("pull_string requires either STR_ASCII or STR_UNICODE flag to be set");
+		return -1;
+	}
+}
+
+