The big character set handling changeover!

This commit gets rid of all our old codepage handling and replaces it with
iconv. All internal strings in Samba are now in "unix" charset, which may
be multi-byte. See internals.doc and my posting to samba-technical for
a more complete explanation.
(This used to be commit debb471267960e56005a741817ebd227ecfc512a)

1 files changed, 71 insertions, 1573 deletions

diff --git a/source3/lib/util_unistr.c b/source3/lib/util_unistr.c
index 96aa62a283..1bfcd179f4 100644
--- a/source3/lib/util_unistr.c
+++ b/source3/lib/util_unistr.c
@@ -1,8 +1,8 @@
 /* 
    Unix SMB/Netbios implementation.
-   Version 1.9.
+   Version 3.0
    Samba utility functions
-   Copyright (C) Andrew Tridgell 1992-1998
+   Copyright (C) Andrew Tridgell 1992-2001
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -31,11 +31,7 @@ extern int DEBUGLEVEL;
  * These are dynamically loaded from a unicode translation file.
  */
 
-static smb_ucs2_t *doscp_to_ucs2;
-static uint16 *ucs2_to_doscp;
-
-static smb_ucs2_t *unixcp_to_ucs2;
-static uint16 *ucs2_to_unixcp;
+#define CONV_DEBUGLEVEL		83
 
 #ifndef MAXUNI
 #define MAXUNI 1024
@@ -54,62 +50,10 @@ static uint16 *ucs2_to_unixcp;
 
 size_t dos_PutUniCode(char *dst,const char *src, ssize_t len, BOOL null_terminate)
 {
-	size_t ret = 0;
-	while (*src && (len >= 2)) {
-		size_t skip = get_character_len(*src);
-		smb_ucs2_t val = (*src & 0xff);
-
-		/*
-		 * If this is a multibyte character (and all DOS/Windows
-		 * codepages have at maximum 2 byte multibyte characters)
-		 * then work out the index value for the unicode conversion.
-		 */
-
-		if (skip == 2)
-			val = ((val << 8) | (src[1] & 0xff));
-
-		SSVAL(dst,ret,doscp_to_ucs2[val]);
-		ret += 2;
-		len -= 2;
-		if (skip)
-			src += skip;
-		else
-			src++;
-	}
-	if (null_terminate) {
-		SSVAL(dst,ret,0);
-		ret += 2;
-	}
-	return(ret);
+	return push_ucs2(NULL, dst, src, len, 
+			 STR_UNICODE|STR_NOALIGN | (null_terminate?STR_TERMINATE:0));
 }
 
-/*******************************************************************
- Pull a DOS codepage string out of a UNICODE array. len is in bytes.
-********************************************************************/
-
-void unistr_to_dos(char *dest, const char *src, size_t len)
-{
-	char *destend = dest + len;
-
-	while (dest < destend) {
-		uint16 ucs2_val = SVAL(src,0);
-		uint16 cp_val = ucs2_to_doscp[ucs2_val];
-
-		src += 2;
-
-		if (ucs2_val == 0)
-			break;
-
-		if (cp_val < 256)
-			*dest++ = (char)cp_val;
-		else {
-			*dest++ = (cp_val >> 8) & 0xff;
-			*dest++ = (cp_val & 0xff);
-		}
-	}
-
-	*dest = 0;
-}
 
 /*******************************************************************
  Skip past a unicode string, but not more than len. Always move
@@ -129,183 +73,48 @@ char *skip_unibuf(char *src, size_t len)
     return src;
 }
 
+/* Copy a string from little-endian or big-endian unicode source (depending
+ * on flags) to internal samba format destination
+ */ 
+int rpcstr_pull(char* dest, void *src, int dest_len, int src_len, int flags)
+{
+	if(dest_len==-1) dest_len=MAXUNI-3;
+	return pull_ucs2(NULL, dest, src, dest_len, src_len, flags|STR_UNICODE|STR_NOALIGN);
+}
+
+/* Converts a string from internal samba format to unicode
+ */ 
+int rpcstr_push(void* dest, const char *src, int dest_len, int flags)
+{
+	return push_ucs2(NULL, dest, src, dest_len, flags|STR_UNICODE|STR_NOALIGN);
+}
+
 /*******************************************************************
  Return a DOS codepage version of a little-endian unicode string.
  len is the filename length (ignoring any terminating zero) in uin16
  units. Always null terminates.
  Hack alert: uses fixed buffer(s).
 ********************************************************************/
-
 char *dos_unistrn2(uint16 *src, int len)
 {
 	static char lbufs[8][MAXUNI];
 	static int nexti;
 	char *lbuf = lbufs[nexti];
-	char *p;
-
 	nexti = (nexti+1)%8;
-
-	for (p = lbuf; (len > 0) && (p-lbuf < MAXUNI-3) && *src; len--, src++) {
-		uint16 ucs2_val = SVAL(src,0);
-		uint16 cp_val = ucs2_to_doscp[ucs2_val];
-
-		if (cp_val < 256)
-			*p++ = (char)cp_val;
-		else {
-			*p++ = (cp_val >> 8) & 0xff;
-			*p++ = (cp_val & 0xff);
-		}
-	}
-
-	*p = 0;
+	pull_ucs2(NULL, lbuf, src, MAXUNI-3, len*2, STR_NOALIGN);
 	return lbuf;
 }
 
-static char lbufs[8][MAXUNI];
-static int nexti;
-
-/*******************************************************************
- Return a DOS codepage version of a little-endian unicode string.
- Hack alert: uses fixed buffer(s).
-********************************************************************/
-
-char *dos_unistr2(uint16 *src)
-{
-	char *lbuf = lbufs[nexti];
-	char *p;
-
-	nexti = (nexti+1)%8;
-
-	for (p = lbuf; (p-lbuf < MAXUNI-3) && *src; src++) {
-		uint16 ucs2_val = SVAL(src,0);
-		uint16 cp_val = ucs2_to_doscp[ucs2_val];
-
-		if (cp_val < 256)
-			*p++ = (char)cp_val;
-		else {
-			*p++ = (cp_val >> 8) & 0xff;
-			*p++ = (cp_val & 0xff);
-		}
-	}
-
-	*p = 0;
-	return lbuf;
-}
-
-/*******************************************************************
-Return a DOS codepage version of a little-endian unicode string
-********************************************************************/
-
-char *dos_unistr2_to_str(UNISTR2 *str)
-{
-	char *lbuf = lbufs[nexti];
-	char *p;
-	uint16 *src = str->buffer;
-
-	nexti = (nexti+1)%8;
-
-	for (p = lbuf; (p - lbuf < MAXUNI-3) && (src - str->buffer < str->uni_str_len) && *src; src++) {
-		uint16 ucs2_val = SVAL(src,0);
-		uint16 cp_val = ucs2_to_doscp[ucs2_val];
-
-		if (cp_val < 256)
-			*p++ = (char)cp_val;
-		else {
-			*p++ = (cp_val >> 8) & 0xff;
-			*p++ = (cp_val & 0xff);
-		}
-	}
-
-	*p = 0;
-	return lbuf;
-}
-
-/*******************************************************************
- Put an ASCII string into a UNICODE array (uint16's).
- use little-endian ucs2
- ********************************************************************/
-void ascii_to_unistr(uint16 *dest, const char *src, int maxlen)
-{
-	uint16 *destend = dest + maxlen;
-	char c;
-
-	while (dest < destend) {
-		c = *(src++);
-		if (c == 0)
-			break;
-
-		SSVAL(dest, 0, c);
-		dest++;
-	}
-
-	*dest = 0;
-}
-
-/*******************************************************************
- Pull an ASCII string out of a UNICODE array (uint16's).
- ********************************************************************/
-
-void unistr_to_ascii(char *dest, const uint16 *src, int len)
-{
-	char *destend = dest + len;
-	uint16 c;
-	
-	if (src == NULL) {
-		*dest = '\0';
-		return;
-	}
-
-	/* normal code path for a valid 'src' */
-	while (dest < destend) {
-		c = SVAL(src, 0);
-		src++;
-		if (c == 0)
-			break;
-
-		*(dest++) = (char)c;
-	}
-
-	*dest = 0;
-	return;
-}
-
 /*******************************************************************
  Convert a (little-endian) UNISTR2 structure to an ASCII string
- Warning: this version does DOS codepage.
 ********************************************************************/
-
 void unistr2_to_ascii(char *dest, const UNISTR2 *str, size_t maxlen)
 {
-	char *p;
-	uint16 *src;
-	size_t len;
-
 	if (str == NULL) {
 		*dest='\0';
 		return;
 	}
-
-	src = str->buffer;
-	len = MIN(str->uni_str_len, maxlen);
-
-	if (len == 0) {
-		*dest='\0';
-		return;
-	}
-
-	for (p = dest; (p-dest < len) && *src; src++) {
-		uint16 ucs2_val = SVAL(src,0);
-		uint16 cp_val = ucs2_to_doscp[ucs2_val];
-
-		if (cp_val < 256)
-			*p++ = (char)cp_val;
-		else {
-			*p   = (cp_val >> 8) & 0xff;
-			*p++ = (cp_val & 0xff);
-		}
-	}
-	
-	*p = 0;
+	pull_ucs2(NULL, dest, str->buffer, maxlen, str->uni_str_len, STR_NOALIGN);
 }
 
 
@@ -322,743 +131,6 @@ uint32 buffer2_to_uint32(BUFFER2 *str)
 }
 
 /*******************************************************************
-Return a DOS codepage version of a NOTunicode string
-********************************************************************/
-
-char *dos_buffer2_to_str(BUFFER2 *str)
-{
-	char *lbuf = lbufs[nexti];
-	char *p;
-	uint16 *src = str->buffer;
-
-	nexti = (nexti+1)%8;
-
-	for (p = lbuf; (p - lbuf < sizeof(str->buffer)-3) && (src - str->buffer < str->buf_len/2) && *src; src++) {
-		uint16 ucs2_val = SVAL(src,0);
-		uint16 cp_val = ucs2_to_doscp[ucs2_val];
-
-		if (cp_val < 256)
-			*p++ = (char)cp_val;
-		else {
-			*p++ = (cp_val >> 8) & 0xff;
-			*p++ = (cp_val & 0xff);
-		}
-	}
-
-	*p = 0;
-	return lbuf;
-}
-
-/*******************************************************************
- Return a dos codepage version of a NOTunicode string
-********************************************************************/
-
-char *dos_buffer2_to_multistr(BUFFER2 *str)
-{
-	char *lbuf = lbufs[nexti];
-	char *p;
-	uint16 *src = str->buffer;
-
-	nexti = (nexti+1)%8;
-
-	for (p = lbuf; (p - lbuf < sizeof(str->buffer)-3) && (src - str->buffer < str->buf_len/2); src++) {
-		if (*src == 0) {
-			*p++ = ' ';
-		} else {
-			uint16 ucs2_val = SVAL(src,0);
-			uint16 cp_val = ucs2_to_doscp[ucs2_val];
-
-			if (cp_val < 256)
-				*p++ = (char)cp_val;
-			else {
-				*p++ = (cp_val >> 8) & 0xff;
-				*p++ = (cp_val & 0xff);
-			}
-		}
-	}
-
-	*p = 0;
-	return lbuf;
-}
-
-/*******************************************************************
- Create a null-terminated unicode string from a null-terminated DOS
- codepage string.
- Return number of unicode chars copied, excluding the null character.
- Unicode strings created are in little-endian format.
-********************************************************************/
-
-size_t dos_struni2(char *dst, const char *src, size_t max_len)
-{
-	size_t len = 0;
-
-	if (dst == NULL)
-		return 0;
-
-	if (src != NULL) {
-		for (; (len < max_len-2) && *src; len++, dst +=2) {
-			size_t skip = get_character_len(*src);
-			smb_ucs2_t val = (*src & 0xff);
-
-			/*
-			 * If this is a multibyte character (and all DOS/Windows
-			 * codepages have at maximum 2 byte multibyte characters)
-			 * then work out the index value for the unicode conversion.
-			 */
-
-			if (skip == 2)
-				val = ((val << 8) | (src[1] & 0xff));
-
-			SSVAL(dst,0,doscp_to_ucs2[val]);
-			if (skip)
-				src += skip;
-			else
-				src++;
-		}
-	}
-
-	SSVAL(dst,0,0);
-
-	return len;
-}
-
-/*******************************************************************
- Return a DOS codepage version of a little-endian unicode string.
- Hack alert: uses fixed buffer(s).
-********************************************************************/
-
-char *dos_unistr(char *buf)
-{
-	char *lbuf = lbufs[nexti];
-	uint16 *src = (uint16 *)buf;
-	char *p;
-
-	nexti = (nexti+1)%8;
-
-	for (p = lbuf; (p-lbuf < MAXUNI-3) && *src; src++) {
-		uint16 ucs2_val = SVAL(src,0);
-		uint16 cp_val = ucs2_to_doscp[ucs2_val];
-
-		if (cp_val < 256)
-			*p++ = (char)cp_val;
-		else {
-			*p++ = (cp_val >> 8) & 0xff;
-			*p++ = (cp_val & 0xff);
-		}
-	}
-
-	*p = 0;
-	return lbuf;
-}
-
-/*******************************************************************
- Strcpy for unicode strings.  returns length (in num of wide chars)
-********************************************************************/
-
-int unistrcpy(char *dst, char *src)
-{
-	int num_wchars = 0;
-	uint16 *wsrc = (uint16 *)src;
-	uint16 *wdst = (uint16 *)dst;
-
-	while (*wsrc) {
-		*wdst++ = *wsrc++;
-		num_wchars++;
-	}
-	*wdst = 0;
-
-	return num_wchars;
-}
-
-/*******************************************************************
- Free any existing maps.
-********************************************************************/
-
-static void free_maps(smb_ucs2_t **pp_cp_to_ucs2, uint16 **pp_ucs2_to_cp)
-{
-	/* this handles identity mappings where we share the pointer */
-	if (*pp_ucs2_to_cp == *pp_cp_to_ucs2) {
-		*pp_ucs2_to_cp = NULL;
-	}
-
-	if (*pp_cp_to_ucs2) {
-		free(*pp_cp_to_ucs2);
-		*pp_cp_to_ucs2 = NULL;
-	}
-
-	if (*pp_ucs2_to_cp) {
-		free(*pp_ucs2_to_cp);
-		*pp_ucs2_to_cp = NULL;
-	}
-}
-
-/*******************************************************************
- Build a default (null) codepage to unicode map.
-********************************************************************/
-
-void default_unicode_map(smb_ucs2_t **pp_cp_to_ucs2, uint16 **pp_ucs2_to_cp)
-{
-  int i;
-
-  free_maps(pp_cp_to_ucs2, pp_ucs2_to_cp);
-
-  if ((*pp_ucs2_to_cp = (uint16 *)malloc(2*65536)) == NULL) {
-    DEBUG(0,("default_unicode_map: malloc fail for ucs2_to_cp size %u.\n", 2*65536));
-    abort();
-  }
-
-  *pp_cp_to_ucs2 = *pp_ucs2_to_cp; /* Default map is an identity. */
-  for (i = 0; i < 65536; i++)
-    (*pp_cp_to_ucs2)[i] = i;
-}
-
-/*******************************************************************
- Load a codepage to unicode and vica-versa map.
-********************************************************************/
-
-BOOL load_unicode_map(const char *codepage, smb_ucs2_t **pp_cp_to_ucs2, uint16 **pp_ucs2_to_cp)
-{
-  pstring unicode_map_file_name;
-  FILE *fp = NULL;
-  SMB_STRUCT_STAT st;
-  smb_ucs2_t *cp_to_ucs2 = *pp_cp_to_ucs2;
-  uint16 *ucs2_to_cp = *pp_ucs2_to_cp;
-  size_t cp_to_ucs2_size;
-  size_t ucs2_to_cp_size;
-  size_t i;
-  size_t size;
-  char buf[UNICODE_MAP_HEADER_SIZE];
-
-  DEBUG(5, ("load_unicode_map: loading unicode map for codepage %s.\n", codepage));
-
-  if (*codepage == '\0')
-    goto clean_and_exit;
-
-  if(strlen(lp_codepagedir()) + 13 + strlen(codepage) > 
-     sizeof(unicode_map_file_name)) {
-    DEBUG(0,("load_unicode_map: filename too long to load\n"));
-    goto clean_and_exit;
-  }
-
-  pstrcpy(unicode_map_file_name, lp_codepagedir());
-  pstrcat(unicode_map_file_name, "/");
-  pstrcat(unicode_map_file_name, "unicode_map.");
-  pstrcat(unicode_map_file_name, codepage);
-
-  if(sys_stat(unicode_map_file_name,&st)!=0) {
-    DEBUG(0,("load_unicode_map: filename %s does not exist.\n",
-              unicode_map_file_name));
-    goto clean_and_exit;
-  }
-
-  size = st.st_size;
-
-  if ((size != UNICODE_MAP_HEADER_SIZE + 4*65536) && (size != UNICODE_MAP_HEADER_SIZE +(2*256 + 2*65536))) {
-    DEBUG(0,("load_unicode_map: file %s is an incorrect size for a \
-unicode map file (size=%d).\n", unicode_map_file_name, (int)size));
-    goto clean_and_exit;
-  }
-
-  if((fp = sys_fopen( unicode_map_file_name, "r")) == NULL) {
-    DEBUG(0,("load_unicode_map: cannot open file %s. Error was %s\n",
-              unicode_map_file_name, strerror(errno)));
-    goto clean_and_exit;
-  }
-
-  if(fread( buf, 1, UNICODE_MAP_HEADER_SIZE, fp)!=UNICODE_MAP_HEADER_SIZE) {
-    DEBUG(0,("load_unicode_map: cannot read header from file %s. Error was %s\n",
-              unicode_map_file_name, strerror(errno)));
-    goto clean_and_exit;
-  }
-
-  /* Check the version value */
-  if(SVAL(buf,UNICODE_MAP_VERSION_OFFSET) != UNICODE_MAP_FILE_VERSION_ID) {
-    DEBUG(0,("load_unicode_map: filename %s has incorrect version id. \
-Needed %hu, got %hu.\n",
-          unicode_map_file_name, (uint16)UNICODE_MAP_FILE_VERSION_ID,
-          SVAL(buf,UNICODE_MAP_VERSION_OFFSET)));
-    goto clean_and_exit;
-  }
-
-  /* Check the codepage value */
-  if(!strequal(&buf[UNICODE_MAP_CLIENT_CODEPAGE_OFFSET], codepage)) {
-    DEBUG(0,("load_unicode_map: codepage %s in file %s is not the same as that \
-requested (%s).\n", &buf[UNICODE_MAP_CLIENT_CODEPAGE_OFFSET], unicode_map_file_name, codepage ));
-    goto clean_and_exit;
-  }
-
-  ucs2_to_cp_size = 2*65536;
-  if (size == UNICODE_MAP_HEADER_SIZE + 4*65536) {
-    /* 
-     * This is a multibyte code page.
-     */
-    cp_to_ucs2_size = 2*65536;
-  } else {
-    /*
-     * Single byte code page.
-     */
-    cp_to_ucs2_size = 2*256;
-  }
-
-  /* 
-   * Free any old translation tables.
-   */
-
-  free_maps(pp_cp_to_ucs2, pp_ucs2_to_cp);
-
-  if ((cp_to_ucs2 = (smb_ucs2_t *)malloc(cp_to_ucs2_size)) == NULL) {
-    DEBUG(0,("load_unicode_map: malloc fail for cp_to_ucs2 size %u.\n", cp_to_ucs2_size ));
-    goto clean_and_exit;
-  }
-
-  if ((ucs2_to_cp = (uint16 *)malloc(ucs2_to_cp_size)) == NULL) {
-    DEBUG(0,("load_unicode_map: malloc fail for ucs2_to_cp size %u.\n", ucs2_to_cp_size ));
-    goto clean_and_exit;
-  }
-
-  if(fread( (char *)cp_to_ucs2, 1, cp_to_ucs2_size, fp)!=cp_to_ucs2_size) {
-    DEBUG(0,("load_unicode_map: cannot read cp_to_ucs2 from file %s. Error was %s\n",
-              unicode_map_file_name, strerror(errno)));
-    goto clean_and_exit;
-  }
-
-  if(fread( (char *)ucs2_to_cp, 1, ucs2_to_cp_size, fp)!=ucs2_to_cp_size) {
-    DEBUG(0,("load_unicode_map: cannot read ucs2_to_cp from file %s. Error was %s\n",
-              unicode_map_file_name, strerror(errno)));
-    goto clean_and_exit;
-  }
-
-  /*
-   * Now ensure the 16 bit values are in the correct endianness.
-   */
-
-  for (i = 0; i < cp_to_ucs2_size/2; i++)
-    cp_to_ucs2[i] = SVAL(cp_to_ucs2,i*2);
-
-  for (i = 0; i < ucs2_to_cp_size/2; i++)
-    ucs2_to_cp[i] = SVAL(ucs2_to_cp,i*2);
-
-  fclose(fp);
-
-  *pp_cp_to_ucs2 = cp_to_ucs2;
-  *pp_ucs2_to_cp = ucs2_to_cp;
-
-  return True;
-
-clean_and_exit:
-
-  /* pseudo destructor :-) */
-
-  if(fp != NULL)
-    fclose(fp);
-
-  free_maps(pp_cp_to_ucs2, pp_ucs2_to_cp);
-
-  default_unicode_map(pp_cp_to_ucs2, pp_ucs2_to_cp);
-
-  return False;
-}
-
-/*******************************************************************
- Load a dos codepage to unicode and vica-versa map.
-********************************************************************/
-
-BOOL load_dos_unicode_map(int codepage)
-{
-  fstring codepage_str;
-
-  slprintf(codepage_str, sizeof(fstring)-1, "%03d", codepage);
-  return load_unicode_map(codepage_str, &doscp_to_ucs2, &ucs2_to_doscp);
-}
-
-/*******************************************************************
- Load a UNIX codepage to unicode and vica-versa map.
-********************************************************************/
-
-BOOL load_unix_unicode_map(const char *unix_char_set)
-{
-  fstring upper_unix_char_set;
-
-  fstrcpy(upper_unix_char_set, unix_char_set);
-  strupper(upper_unix_char_set);
-  return load_unicode_map(upper_unix_char_set, &unixcp_to_ucs2, &ucs2_to_unixcp);
-}
-
-/*******************************************************************
- The following functions reproduce many of the non-UNICODE standard
- string functions in Samba.
-********************************************************************/
-
-/*******************************************************************
- Convert a UNICODE string to multibyte format. Note that the 'src' is in
- native byte order, not little endian. Always zero terminates.
- dst_len is in bytes.
-********************************************************************/
-
-static char *unicode_to_multibyte(char *dst, const smb_ucs2_t *src,
-                                  size_t dst_len, const uint16 *ucs2_to_cp)
-{
-	size_t dst_pos;
-
-	for(dst_pos = 0; (dst_pos < dst_len - 1) && *src;) {
-		smb_ucs2_t val = ucs2_to_cp[*src++];
-		if(val < 256) {
-			dst[dst_pos++] = (char)val;
-		} else {
-
-			if(dst_pos >= dst_len - 2)
-				break;
-
-			/*
-			 * A 2 byte value is always written as
-			 * high/low into the buffer stream.
-			 */
-
-			dst[dst_pos++] = (char)((val >> 8) & 0xff);
-			dst[dst_pos++] = (char)(val & 0xff);
-		}
-	} 	
-
-	dst[dst_pos] = '\0';
-
-	return dst;
-}
-
-/*******************************************************************
- Convert a multibyte string to UNICODE format. Note that the 'dst' is in
- native byte order, not little endian. Always zero terminates.
- dst_len is in bytes.
-********************************************************************/
-
-smb_ucs2_t *multibyte_to_unicode(smb_ucs2_t *dst, const char *src,
-                                 size_t dst_len, smb_ucs2_t *cp_to_ucs2)
-{
-	size_t i;
-
-	dst_len /= sizeof(smb_ucs2_t); /* Convert to smb_ucs2_t units. */
-
-	for(i = 0; (i < (dst_len  - 1)) && src[i];) {
-		size_t skip = skip_multibyte_char(*src);
-		smb_ucs2_t val = (*src & 0xff);
-
-		/*
-		 * If this is a multibyte character
-		 * then work out the index value for the unicode conversion.
-		 */
-
-		if (skip == 2)
-			val = ((val << 8) | (src[1] & 0xff));
-
-		dst[i++] = cp_to_ucs2[val];
-		if (skip)
-			src += skip;
-		else
-			src++;
-	}
-
-	dst[i] = 0;
-
-	return dst;
-}
-
-/*******************************************************************
- Convert a UNICODE string to multibyte format. Note that the 'src' is in
- native byte order, not little endian. Always zero terminates.
- This function may be replaced if the MB  codepage format is an
- encoded one (ie. utf8, hex). See the code in lib/kanji.c
- for details. dst_len is in bytes.
-********************************************************************/
-
-char *unicode_to_unix(char *dst, const smb_ucs2_t *src, size_t dst_len)
-{
-	return unicode_to_multibyte(dst, src, dst_len, ucs2_to_unixcp);
-}
-
-/*******************************************************************
- Convert a UNIX string to UNICODE format. Note that the 'dst' is in
- native byte order, not little endian. Always zero terminates.
- This function may be replaced if the UNIX codepage format is a
- multi-byte one (ie. JIS, SJIS or utf8). See the code in lib/kanji.c
- for details. dst_len is in bytes, not ucs2 units.
-********************************************************************/
-
-smb_ucs2_t *unix_to_unicode(smb_ucs2_t *dst, const char *src, size_t dst_len)
-{
-	return multibyte_to_unicode(dst, src, dst_len, unixcp_to_ucs2);
-}
-
-/*******************************************************************
- Convert a UNICODE string to DOS format. Note that the 'src' is in
- native byte order, not little endian. Always zero terminates. 
- dst_len is in bytes.
-********************************************************************/ 
-
-char *unicode_to_dos(char *dst, const smb_ucs2_t *src, size_t dst_len)
-{
-	return unicode_to_multibyte(dst, src, dst_len, ucs2_to_doscp);
-}
-
-/*******************************************************************
- Convert a single UNICODE character to DOS codepage. Returns the
- number of bytes in the DOS codepage character.
-********************************************************************/ 
-
-size_t unicode_to_dos_char(char *dst, const smb_ucs2_t src)
-{
-	smb_ucs2_t val = ucs2_to_doscp[src];
-	if(val < 256) {
-		*dst = (char)val;
-		return (size_t)1;
-	}
-	/*
-	 * A 2 byte value is always written as
-	 * high/low into the buffer stream.
-	 */
-
-	dst[0] = (char)((val >> 8) & 0xff);
-	dst[1] = (char)(val & 0xff);
-	return (size_t)2;
-}
-
-/*******************************************************************
- Convert a DOS string to UNICODE format. Note that the 'dst' is in
- native byte order, not little endian. Always zero terminates.
- This function may be replaced if the DOS codepage format is a
- multi-byte one (ie. JIS, SJIS or utf8). See the code in lib/kanji.c
- for details. dst_len is in bytes, not ucs2 units.
-********************************************************************/
-
-smb_ucs2_t *dos_to_unicode(smb_ucs2_t *dst, const char *src, size_t dst_len)
-{
-	return multibyte_to_unicode(dst, src, dst_len, doscp_to_ucs2);
-}
-
-/*******************************************************************
- Count the number of characters in a smb_ucs2_t string.
-********************************************************************/
-
-size_t strlen_w(const smb_ucs2_t *src)
-{
-  size_t len;
-
-  for(len = 0; *src++; len++)
-    ;
-
-  return len;
-}
-
-/*******************************************************************
- Safe wstring copy into a known length string. maxlength includes
- the terminating zero. maxlength is in ucs2 units.
-********************************************************************/
-
-smb_ucs2_t *safe_strcpy_w(smb_ucs2_t *dest,const smb_ucs2_t *src, size_t maxlength)
-{
-    size_t ucs2_len;
-
-    if (!dest) {
-        DEBUG(0,("ERROR: NULL dest in safe_strcpy_w\n"));
-        return NULL;
-    }
-
-    if (!src) {
-        *dest = 0;
-        return dest;
-    }
-
-	maxlength /= sizeof(smb_ucs2_t);
-
-	ucs2_len = strlen_w(src);
-
-    if (ucs2_len >= maxlength) {
-		fstring out;
-        DEBUG(0,("ERROR: string overflow by %u bytes in safe_strcpy_w [%.50s]\n",
-			(unsigned int)((ucs2_len-maxlength)*sizeof(smb_ucs2_t)),
-			unicode_to_unix(out,src,sizeof(out))) );
-		ucs2_len = maxlength - 1;
-    }
-
-    memcpy(dest, src, ucs2_len*sizeof(smb_ucs2_t));
-    dest[ucs2_len] = 0;
-    return dest;
-}
-
-/*******************************************************************
- Safe string cat into a string. maxlength includes the terminating zero.
- maxlength is in ucs2 units.
-********************************************************************/
-
-smb_ucs2_t *safe_strcat_w(smb_ucs2_t *dest, const smb_ucs2_t *src, size_t maxlength)
-{
-    size_t ucs2_src_len, ucs2_dest_len;
-
-    if (!dest) {
-        DEBUG(0,("ERROR: NULL dest in safe_strcat_w\n"));
-        return NULL;
-    }
-
-    if (!src)
-        return dest;
-
-    ucs2_src_len = strlen_w(src);
-    ucs2_dest_len = strlen_w(dest);
-
-    if (ucs2_src_len + ucs2_dest_len >= maxlength) {
-		fstring out;
-		int new_len = maxlength - ucs2_dest_len - 1;
-        DEBUG(0,("ERROR: string overflow by %u characters in safe_strcat_w [%.50s]\n",
-			(unsigned int)(sizeof(smb_ucs2_t)*(ucs2_src_len + ucs2_dest_len - maxlength)),
-			unicode_to_unix(out,src,sizeof(out))) );
-        ucs2_src_len = (size_t)(new_len > 0 ? new_len : 0);
-    }
-
-    memcpy(&dest[ucs2_dest_len], src, ucs2_src_len*sizeof(smb_ucs2_t));
-    dest[ucs2_dest_len + ucs2_src_len] = 0;
-    return dest;
-}
-
-/*******************************************************************
- Compare the two strings s1 and s2.
-********************************************************************/
-
-int strcmp_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2)
-{
-	smb_ucs2_t c1, c2;
-
-	for (;;) {
-		c1 = *s1++;
-		c2 = *s2++;
-
-		if (c1 != c2)
-			return c1 - c2;
-
-		if (c1 == 0)
-			break;
-	}
-	return 0;
-}
-
-/*******************************************************************
- Compare the first n characters of s1 to s2. len is in ucs2 units.
-********************************************************************/
-
-int strncmp_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2, size_t len)
-{
-	smb_ucs2_t c1, c2;
-
-	for (; len != 0; --len) {
-		c1 = *s1++;
-		c2 = *s2++;
-
-		if (c1 != c2)
-			return c1 - c2;
-
-		if (c1 == 0)
-			break;
-
-	}
-	return 0;
-}
-
-/*******************************************************************
- Search string s2 from s1.
-********************************************************************/
-
-smb_ucs2_t *strstr_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2)
-{
-	size_t len = strlen_w(s2);
-
-	if (!*s2)
-		return (smb_ucs2_t *)s1;
-
-	for(;*s1; s1++) {
-		if (*s1 == *s2) {
-			if (strncmp_w(s1, s2, len) == 0)
-				return (smb_ucs2_t *)s1;
-		}
-	}
-	return NULL; 
-}
-
-/*******************************************************************
- Search for ucs2 char c from the beginning of s.
-********************************************************************/ 
-
-smb_ucs2_t *strchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
-{
-	do {
-		if (*s == c)
-			return (smb_ucs2_t *)s;
-	} while (*s++);
-
-	return NULL;
-}
-
-/*******************************************************************
- Search for ucs2 char c from the end of s.
-********************************************************************/ 
-
-smb_ucs2_t *strrchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
-{
-	smb_ucs2_t *retval = 0;
-
-	do {
-		if (*s == c)
-			retval = (smb_ucs2_t *)s;
-	} while (*s++);
-
-	return retval;
-}
-
-/*******************************************************************
- Search token from s1 separated by any ucs2 char of s2.
-********************************************************************/
-
-smb_ucs2_t *strtok_w(smb_ucs2_t *s1, const smb_ucs2_t *s2)
-{
-	static smb_ucs2_t *s = NULL;
-	smb_ucs2_t *q;
-
-	if (!s1) {
-		if (!s)
-			return NULL;
-		s1 = s;
-	}
-
-	for (q = s1; *s1; s1++) {
-		smb_ucs2_t *p = strchr_w(s2, *s1);
-		if (p) {
-			if (s1 != q) {
-				s = s1 + 1;
-				*s1 = '\0';
-				return q;
-			}
-			q = s1 + 1;
-		}
-	}
-
-	s = NULL;
-	if (*q)
-		return q;
-
-	return NULL;
-}
-
-/*******************************************************************
- Duplicate a ucs2 string.
-********************************************************************/
-
-smb_ucs2_t *strdup_w(const smb_ucs2_t *s)
-{
-	size_t newlen = (strlen_w(s)+1)*sizeof(smb_ucs2_t);
-	smb_ucs2_t *newstr = (smb_ucs2_t *)malloc(newlen);
-    if (newstr == NULL)
-        return NULL;
-    safe_strcpy_w(newstr, s, newlen);
-    return newstr;
-}
-
-/*******************************************************************
  Mapping tables for UNICODE character. Allows toupper/tolower and
  isXXX functions to work.
 
@@ -1125,33 +197,6 @@ int islower_w( smb_ucs2_t val)
 }
 
 /*******************************************************************
- Is a digit wchar.
-********************************************************************/
-
-int isdigit_w( smb_ucs2_t val)
-{
-	return (map_table_flags(val) & UNI_DIGIT);
-}
-
-/*******************************************************************
- Is a hex digit wchar.
-********************************************************************/
-
-int isxdigit_w( smb_ucs2_t val)
-{
-	return (map_table_flags(val) & UNI_XDIGIT);
-}
-
-/*******************************************************************
- Is a space wchar.
-********************************************************************/
-
-int isspace_w( smb_ucs2_t val)
-{
-	return (map_table_flags(val) & UNI_SPACE);
-}
-
-/*******************************************************************
  Convert a wchar to upper case.
 ********************************************************************/
 
@@ -1170,102 +215,33 @@ smb_ucs2_t tolower_w( smb_ucs2_t val )
 }
 
 /*******************************************************************
- Case insensitive string compararison.
+ Count the number of characters in a smb_ucs2_t string.
 ********************************************************************/
-
-int StrCaseCmp_w(const smb_ucs2_t *s, const smb_ucs2_t *t)
+size_t strlen_w(const smb_ucs2_t *src)
 {
-	/* 
-	 * Compare until we run out of string, either t or s, or find a difference.
-	 */
+	size_t len;
 
-	while (*s && *t && toupper_w(*s) == toupper_w(*t)) {
-		s++;
-		t++;
-	}
+	for(len = 0; *src++; len++) ;
 
-	return(toupper_w(*s) - toupper_w(*t));
+	return len;
 }
 
 /*******************************************************************
- Case insensitive string compararison, length limited.
- n is in ucs2 units.
+wide strchr()
 ********************************************************************/
-
-int StrnCaseCmp_w(const smb_ucs2_t *s, const smb_ucs2_t *t, size_t n)
+smb_ucs2_t *strchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
 {
-	/*
-	 * Compare until we run out of string, either t or s, or chars.
-	 */
-
-	while (n && *s && *t && toupper_w(*s) == toupper_w(*t)) {
+	while (*s != 0) {
+		if (c == *s) return (smb_ucs2_t *)s;
 		s++;
-		t++;
-		n--;
 	}
-
-    /*
-	 * Not run out of chars - strings are different lengths.
-	 */
-
-    if (n) 
-      return(toupper_w(*s) - toupper_w(*t));
-
-    /*
-	 * Identical up to where we run out of chars, 
-	 * and strings are same length.
-	 */
-
-	return(0);
-}
-
-/*******************************************************************
- Compare 2 strings.
-********************************************************************/
-
-BOOL strequal_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2)
-{
-	if (s1 == s2)
-		return(True);
-	if (!s1 || !s2)
-		return(False);
-  
-	return(StrCaseCmp_w(s1,s2)==0);
+	return NULL;
 }
 
-/*******************************************************************
- Compare 2 strings up to and including the nth char. n is in ucs2
- units.
-******************************************************************/
-
-BOOL strnequal_w(const smb_ucs2_t *s1,const smb_ucs2_t *s2,size_t n)
-{
-	if (s1 == s2)
-		return(True);
-	if (!s1 || !s2 || !n)
-		return(False);
-  
-	return(StrnCaseCmp_w(s1,s2,n)==0);
-}
-
-/*******************************************************************
- Compare 2 strings (case sensitive).
-********************************************************************/
-
-BOOL strcsequal_w(const smb_ucs2_t *s1,const smb_ucs2_t *s2)
-{
-	if (s1 == s2)
-		return(True);
-	if (!s1 || !s2)
-		return(False);
-  
-	return(strcmp_w(s1,s2)==0);
-}
 
 /*******************************************************************
  Convert a string to lower case.
 ********************************************************************/
-
 void strlower_w(smb_ucs2_t *s)
 {
 	while (*s) {
@@ -1278,7 +254,6 @@ void strlower_w(smb_ucs2_t *s)
 /*******************************************************************
  Convert a string to upper case.
 ********************************************************************/
-
 void strupper_w(smb_ucs2_t *s)
 {
 	while (*s) {
@@ -1289,547 +264,70 @@ void strupper_w(smb_ucs2_t *s)
 }
 
 /*******************************************************************
- Convert a string to "normal" form.
-********************************************************************/
-
-void strnorm_w(smb_ucs2_t *s)
-{
-	extern int case_default;
-	if (case_default == CASE_UPPER)
-		strupper_w(s);
-	else
-		strlower_w(s);
-}
-
-/*******************************************************************
- Check if a string is in "normal" case.
+case insensitive string comparison
 ********************************************************************/
-
-BOOL strisnormal_w(smb_ucs2_t *s)
+int strcasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b)
 {
-	extern int case_default;
-	if (case_default == CASE_UPPER)
-		return(!strhaslower_w(s));
-
-	return(!strhasupper_w(s));
+	while (*b && tolower_w(*a) == tolower_w(*b)) { a++; b++; }
+	return (tolower_w(*a) - tolower_w(*b));
 }
 
-/****************************************************************************
- String replace.
-****************************************************************************/
 
-void string_replace_w(smb_ucs2_t *s, smb_ucs2_t oldc, smb_ucs2_t newc)
-{
-	while (*s) {
-		if (oldc == *s)
-			*s = newc;
-		s++;
-	}
-}
-
-/*******************************************************************
- Skip past some strings in a buffer. n is in bytes.
-********************************************************************/
-
-smb_ucs2_t *skip_string_w(smb_ucs2_t *buf,size_t n)
-{
-	while (n--)
-		buf += (strlen_w(buf)*sizeof(smb_ucs2_t)) + 1;
-	return(buf);
-}
-
-/*******************************************************************
- Count the number of characters in a string. Same as strlen_w in
- smb_ucs2_t string units.
-********************************************************************/
+/*
+  The *_wa() functions take a combination of 7 bit ascii
+  and wide characters They are used so that you can use string
+  functions combining C string constants with ucs2 strings
 
-size_t str_charnum_w(const smb_ucs2_t *s)
-{
-	return strlen_w(s);
-}
+  The char* arguments must NOT be multibyte - to be completely sure
+  of this only pass string constants */
 
-/*******************************************************************
- Trim the specified elements off the front and back of a string.
-********************************************************************/
 
-BOOL trim_string_w(smb_ucs2_t *s,const smb_ucs2_t *front,const smb_ucs2_t *back)
+void pstrcpy_wa(smb_ucs2_t *dest, const char *src)
 {
-	BOOL ret = False;
-	size_t front_len = (front && *front) ? strlen_w(front) : 0;
-	size_t back_len = (back && *back) ? strlen_w(back) : 0;
-	size_t s_len;
-
-	while (front_len && strncmp_w(s, front, front_len) == 0) {
-		smb_ucs2_t *p = s;
-		ret = True;
-
-		while (1) {
-			if (!(*p = p[front_len]))
-				break;
-			p++;
-		}
-	}
-
-	if(back_len) {
-		s_len = strlen_w(s);
-		while ((s_len >= back_len) && 
-			(strncmp_w(s + s_len - back_len, back, back_len)==0)) {
-			ret = True;
-			s[s_len - back_len] = 0;
-			s_len = strlen_w(s);
-		}
+	int i;
+	for (i=0;i<PSTRING_LEN;i++) {
+		dest[i] = UCS2_CHAR(src[i]);
+		if (src[i] == 0) return;
 	}
-
-	return(ret);
 }
 
-/****************************************************************************
- Does a string have any uppercase chars in it ?
-****************************************************************************/
-
-BOOL strhasupper_w(const smb_ucs2_t *s)
+int strcmp_wa(const smb_ucs2_t *a, const char *b)
 {
-	while (*s) {
-		if (isupper_w(*s))
-			return(True);
-		s++;
-	}
-	return(False);
+	while (*b && *a == UCS2_CHAR(*b)) { a++; b++; }
+	return (*a - UCS2_CHAR(*b));
 }
 
-/****************************************************************************
- Does a string have any lowercase chars in it ?
-****************************************************************************/
-
-BOOL strhaslower_w(const smb_ucs2_t *s)
+smb_ucs2_t *strchr_wa(const smb_ucs2_t *s, char c)
 {
-	while (*s) {
-		if (islower(*s))
-			return(True);
+	while (*s != 0) {
+		if (UCS2_CHAR(c) == *s) return (smb_ucs2_t *)s;
 		s++;
 	}
-	return(False);
+	return NULL;
 }
 
-/****************************************************************************
- Find the number of 'c' chars in a string.
-****************************************************************************/
-
-size_t count_chars_w(const smb_ucs2_t *s,smb_ucs2_t c)
+smb_ucs2_t *strrchr_wa(const smb_ucs2_t *s, char c)
 {
-	size_t count=0;
-
-	while (*s) {
-		if (*s == c)
-			count++;
-		s++;
+	const smb_ucs2_t *p = s;
+	int len = strlen_w(s);
+	if (len == 0) return NULL;
+	p += (len-1);
+	while (p != s) {
+		if (UCS2_CHAR(c) == *p) return (smb_ucs2_t *)p;
+		p--;
 	}
-	return(count);
+	return NULL;
 }
 
-/*******************************************************************
- Return True if a string consists only of one particular character.
-********************************************************************/
-
-BOOL str_is_all_w(const smb_ucs2_t *s,smb_ucs2_t c)
+smb_ucs2_t *strpbrk_wa(const smb_ucs2_t *s, const char *p)
 {
-	if(s == NULL)
-		return False;
-	if(!*s)
-		return False;
-
-	while (*s) {
-		if (*s != c)
-			return False;
+	while (*s != 0) {
+		int i;
+		for (i=0; p[i] && *s != UCS2_CHAR(p[i]); i++) 
+			;
+		if (p[i]) return (smb_ucs2_t *)s;
 		s++;
 	}
-	return True;
-}
-
-/*******************************************************************
- Paranoid strcpy into a buffer of given length (includes terminating
- zero. Strips out all but 'a-Z0-9' and replaces with '_'. Deliberately
- does *NOT* check for multibyte characters. Don't change it !
- maxlength is in ucs2 units.
-********************************************************************/
-
-smb_ucs2_t *alpha_strcpy_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const smb_ucs2_t *other_safe_chars, size_t maxlength)
-{
-	size_t len, i;
-	smb_ucs2_t nullstr_w = (smb_ucs2_t)0;
-
-	if (!dest) {
-		DEBUG(0,("ERROR: NULL dest in alpha_strcpy_w\n"));
-		return NULL;
-	}
-
-	if (!src) {
-		*dest = 0;
-		return dest;
-	}  
-
-	len = strlen_w(src);
-	if (len >= maxlength)
-		len = maxlength - 1;
-
-	if (!other_safe_chars)
-		other_safe_chars = &nullstr_w;
-
-	for(i = 0; i < len; i++) {
-		smb_ucs2_t val = src[i];
-		if(isupper_w(val) ||islower_w(val) || isdigit_w(val) || strchr_w(other_safe_chars, val))
-			dest[i] = src[i];
-		else
-			dest[i] = (smb_ucs2_t)'_';
-	}
-
-	dest[i] = 0;
-
-	return dest;
-}
-
-/****************************************************************************
- Like strncpy but always null terminates. Make sure there is room !
- The variable n should always be one less than the available size and is in
- ucs2 units.
-****************************************************************************/
-
-smb_ucs2_t *StrnCpy_w(smb_ucs2_t *dest,const smb_ucs2_t *src,size_t n)
-{
-	smb_ucs2_t *d = dest;
-	if (!dest)
-		return(NULL);
-	if (!src) {
-		*dest = 0;
-		return(dest);
-	}
-
-	while (n-- && (*d++ = *src++))
-		;
-	*d = 0;
-	return(dest);
-}
-
-/****************************************************************************
- Like strncpy but copies up to the character marker. Always null terminates.
- returns a pointer to the character marker in the source string (src).
- n is in ucs2 units.
-****************************************************************************/
-
-smb_ucs2_t *strncpyn_w(smb_ucs2_t *dest, const smb_ucs2_t *src,size_t n, smb_ucs2_t c)
-{
-	smb_ucs2_t *p;
-	size_t str_len;
-
-	p = strchr_w(src, c);
-	if (p == NULL) {
-		fstring cval;
-		smb_ucs2_t mbcval[2];
-		mbcval[0] = c;
-		mbcval[1] = 0;
-		DEBUG(5, ("strncpyn_w: separator character (%s) not found\n",
-			unicode_to_unix(cval,mbcval,sizeof(cval)) ));
-		return NULL;
-	}
-
-	str_len = PTR_DIFF(p, src) + 1;
-	safe_strcpy_w(dest, src, MIN(n, str_len));
-
-	return p;
-}
-
-/*************************************************************
- Routine to get hex characters and turn them into a 16 byte array.
- The array can be variable length, and any non-hex-numeric
- characters are skipped.  "0xnn" or "0Xnn" is specially catered
- for. len is in bytes.
- Valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
-**************************************************************/
-
-static smb_ucs2_t hexprefix[] = { (smb_ucs2_t)'0', (smb_ucs2_t)'x', 0 };
-static smb_ucs2_t hexchars[] = { (smb_ucs2_t)'0', (smb_ucs2_t)'1', (smb_ucs2_t)'2', (smb_ucs2_t)'3',
-								(smb_ucs2_t)'4', (smb_ucs2_t)'5', (smb_ucs2_t)'6', (smb_ucs2_t)'7',
-								(smb_ucs2_t)'8', (smb_ucs2_t)'9', (smb_ucs2_t)'A', (smb_ucs2_t)'B',
-								(smb_ucs2_t)'C', (smb_ucs2_t)'D', (smb_ucs2_t)'E', (smb_ucs2_t)'F', 0 };
-
-size_t strhex_to_str_w(char *p, size_t len, const smb_ucs2_t *strhex)
-{
-	size_t i;
-	size_t num_chars = 0;
-	unsigned char   lonybble, hinybble;
-	smb_ucs2_t *p1 = NULL, *p2 = NULL;
-
-	/*
-	 * Convert to smb_ucs2_t units.
-	 */
-
-	len /= sizeof(smb_ucs2_t);
-
-	for (i = 0; i < len && strhex[i] != 0; i++) {
-		if (strnequal_w(hexchars, hexprefix, 2)) {
-			i++; /* skip two chars */
-			continue;
-		}
-
-		if (!(p1 = strchr_w(hexchars, toupper_w(strhex[i]))))
-			break;
-
-		i++; /* next hex digit */
-
-		if (!(p2 = strchr_w(hexchars, toupper_w(strhex[i]))))
-			break;
-
-		/* get the two nybbles */
-		hinybble = (PTR_DIFF(p1, hexchars)/sizeof(smb_ucs2_t));
-		lonybble = (PTR_DIFF(p2, hexchars)/sizeof(smb_ucs2_t));
-
-		p[num_chars] = (hinybble << 4) | lonybble;
-		num_chars++;
-
-		p1 = NULL;
-		p2 = NULL;
-	}
-	return num_chars;
-}
-
-
-/* This is used to prevent lots of mallocs of size 2 */
-static smb_ucs2_t *null_string = NULL;
-
-/****************************************************************************
- Set a string value, allocing the space for the string.
-****************************************************************************/
-
-BOOL string_init_w(smb_ucs2_t **dest,const smb_ucs2_t *src)
-{
-	size_t l;
-
-	if (!null_string) {
-		if((null_string = (smb_ucs2_t *)malloc(sizeof(smb_ucs2_t))) == NULL) {
-			DEBUG(0,("string_init_w: malloc fail for null_string.\n"));
-		return False;
-		}
-		*null_string = 0;
-	}
-
-	if (!src)     
-		src = null_string;
-
-	l = strlen_w(src);
-
-	if (l == 0)
-		*dest = null_string;
-	else {
-		(*dest) = (smb_ucs2_t *)malloc(sizeof(smb_ucs2_t)*(l+1));
-		if ((*dest) == NULL) {
-			DEBUG(0,("Out of memory in string_init_w\n"));
-			return False;
-		}
-
-		wpstrcpy(*dest,src);
-	}
-	return(True);
-}
-
-/****************************************************************************
- Free a string value.
-****************************************************************************/
-
-void string_free_w(smb_ucs2_t **s)
-{
-	if (!s || !(*s))
-		return;
-	if (*s == null_string)
-		*s = NULL;
-	if (*s)
-		free((char *)*s);
-	*s = NULL;
-}
-
-/****************************************************************************
- Set a string value, allocing the space for the string, and deallocating any 
- existing space.
-****************************************************************************/
-
-BOOL string_set_w(smb_ucs2_t **dest,const smb_ucs2_t *src)
-{
-	string_free_w(dest);
-
-	return(string_init_w(dest,src));
-}
-
-/****************************************************************************
- Substitute a string for a pattern in another string. Make sure there is 
- enough room !
-
- This routine looks for pattern in s and replaces it with 
- insert. It may do multiple replacements.
-
- Any of " ; ' $ or ` in the insert string are replaced with _
- if len==0 then no length check is performed
- len is in ucs2 units.
-****************************************************************************/
-
-void string_sub_w(smb_ucs2_t *s,const smb_ucs2_t *pattern,const smb_ucs2_t *insert, size_t len)
-{
-	smb_ucs2_t *p;
-	ssize_t ls,lp,li, i;
-
-	if (!insert || !pattern || !s)
-		return;
-
-	ls = (ssize_t)strlen_w(s);
-	lp = (ssize_t)strlen_w(pattern);
-	li = (ssize_t)strlen_w(insert);
-
-	if (!*pattern)
-		return;
-	
-	while (lp <= ls && (p = strstr_w(s,pattern))) {
-		if (len && (ls + (li-lp) >= len)) {
-			fstring out;
-			DEBUG(0,("ERROR: string overflow by %d in string_sub_w(%.50s, %d)\n", 
-				 (int)(sizeof(smb_ucs2_t)*(ls + (li-lp) - len)),
-				 unicode_to_unix(out,pattern,sizeof(out)), (int)len*sizeof(smb_ucs2_t)));
-			break;
-		}
-		if (li != lp)
-			memmove(p+li,p+lp,sizeof(smb_ucs2_t)*(strlen_w(p+lp)+1));
-
-		for (i=0;i<li;i++) {
-			switch (insert[i]) {
-			case (smb_ucs2_t)'`':
-			case (smb_ucs2_t)'"':
-			case (smb_ucs2_t)'\'':
-			case (smb_ucs2_t)';':
-			case (smb_ucs2_t)'$':
-			case (smb_ucs2_t)'%':
-			case (smb_ucs2_t)'\r':
-			case (smb_ucs2_t)'\n':
-				p[i] = (smb_ucs2_t)'_';
-				break;
-			default:
-				p[i] = insert[i];
-			}
-		}
-		s = p + li;
-		ls += (li-lp);
-	}
-}
-
-void fstring_sub_w(smb_ucs2_t *s,const smb_ucs2_t *pattern,const smb_ucs2_t *insert)
-{
-	string_sub_w(s, pattern, insert, sizeof(wfstring));
-}
-
-void pstring_sub_w(smb_ucs2_t *s,const smb_ucs2_t *pattern,smb_ucs2_t *insert)
-{
-	string_sub_w(s, pattern, insert, sizeof(wpstring));
-}
-
-/****************************************************************************
- Similar to string_sub() but allows for any character to be substituted. 
- Use with caution !
- if len==0 then no length check is performed.
-****************************************************************************/
-
-void all_string_sub_w(smb_ucs2_t *s,const smb_ucs2_t *pattern,const smb_ucs2_t *insert, size_t len)
-{
-	smb_ucs2_t *p;
-	ssize_t ls,lp,li;
-
-	if (!insert || !pattern || !s)
-		return;
-
-	ls = (ssize_t)strlen_w(s);
-	lp = (ssize_t)strlen_w(pattern);
-	li = (ssize_t)strlen_w(insert);
-
-	if (!*pattern)
-		return;
-	
-	while (lp <= ls && (p = strstr_w(s,pattern))) {
-		if (len && (ls + (li-lp) >= len)) {
-			fstring out;
-			DEBUG(0,("ERROR: string overflow by %d in all_string_sub_w(%.50s, %d)\n", 
-				 (int)(sizeof(smb_ucs2_t)*(ls + (li-lp) - len)),
-				 unicode_to_unix(out,pattern,sizeof(out)), (int)len*sizeof(smb_ucs2_t)));
-			break;
-		}
-		if (li != lp)
-			memmove(p+li,p+lp,sizeof(smb_ucs2_t)*(strlen_w(p+lp)+1));
-
-		memcpy(p, insert, li*sizeof(smb_ucs2_t));
-		s = p + li;
-		ls += (li-lp);
-	}
-}
-
-/****************************************************************************
- Splits out the front and back at a separator.
-****************************************************************************/
-
-void split_at_last_component_w(smb_ucs2_t *path, smb_ucs2_t *front, smb_ucs2_t sep, smb_ucs2_t *back)
-{
-    smb_ucs2_t *p = strrchr_w(path, sep);
-
-	if (p != NULL)
-		*p = 0;
-
-	if (front != NULL)
-		wpstrcpy(front, path);
-
-	if (p != NULL) {
-		if (back != NULL)
-			wpstrcpy(back, p+1);
-		*p = (smb_ucs2_t)'\\';
-	} else {
-		if (back != NULL)
-			back[0] = 0;
-	}
-}
-
-
-/****************************************************************************
- Write an octal as a string.
-****************************************************************************/
-
-smb_ucs2_t *octal_string_w(int i)
-{
-	static smb_ucs2_t wret[64];
-	char ret[64];
-
-	if (i == -1)
-		slprintf(ret, sizeof(ret)-1, "-1");
-	else 
-		slprintf(ret, sizeof(ret)-1, "0%o", i);
-	return unix_to_unicode(wret, ret, sizeof(wret));
-}
-
-
-/****************************************************************************
- Truncate a string at a specified length.
- length is in ucs2 units.
-****************************************************************************/
-
-smb_ucs2_t *string_truncate_w(smb_ucs2_t *s, size_t length)
-{
-	if (s && strlen_w(s) > length)
-		s[length] = 0;
-
-	return s;
-}
-
-/******************************************************************
- functions for UTF8 support (using in kanji.c)
- ******************************************************************/
-smb_ucs2_t doscp2ucs2(int w)
-{
-  return ((smb_ucs2_t)doscp_to_ucs2[w]);
-}
-
-int ucs2doscp(smb_ucs2_t w)
-{
-  return ((int)ucs2_to_doscp[w]);
+	return NULL;
 }