r8762: Attempt to fix the winbindd crashing bug on Solaris (can't remember

the bugid). Make the functions in lib/util_unistr.c odd-alignment
safe using some evil macros. Needs testing on bigendian.
Jeremy.
(This used to be commit 871c647bc3ee465e613cba260d9cd7e66e47b68a)

1 files changed, 253 insertions, 113 deletions

diff --git a/source3/lib/util_unistr.c b/source3/lib/util_unistr.c
index 678eb22d2c..8ae86a7c61 100644
--- a/source3/lib/util_unistr.c
+++ b/source3/lib/util_unistr.c
@@ -3,6 +3,7 @@
    Samba utility functions
    Copyright (C) Andrew Tridgell 1992-2001
    Copyright (C) Simo Sorce 2001
+   Copyright (C) Jeremy Allison 2005
    
    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
@@ -46,12 +47,15 @@ static uint8 doschar_table[8192]; /* 65536 characters / 8 bits/byte */
  * The case tables are defined in UCS2 and don't depend on any
  * configured parameters, so they never need to be reloaded.
  **/
+
 void load_case_tables(void)
 {
 	static int initialised;
 	int i;
 
-	if (initialised) return;
+	if (initialised) {
+		return;
+	}
 	initialised = 1;
 
 	upcase_table = map_file(lib_path("upcase.dat"), 0x20000);
@@ -94,6 +98,7 @@ void load_case_tables(void)
   see if a ucs2 character can be mapped correctly to a dos character
   and mapped back to the same character in ucs2
 */
+
 int check_dos_char(smb_ucs2_t c)
 {
 	lazy_initialize_conv();
@@ -109,10 +114,15 @@ static int check_dos_char_slowly(smb_ucs2_t c)
 	char buf[10];
 	smb_ucs2_t c2 = 0;
 	int len1, len2;
+
 	len1 = convert_string(CH_UCS2, CH_DOS, &c, 2, buf, sizeof(buf),False);
-	if (len1 == 0) return 0;
+	if (len1 == 0) {
+		return 0;
+	}
 	len2 = convert_string(CH_DOS, CH_UCS2, buf, len1, &c2, 2,False);
-	if (len2 != 2) return 0;
+	if (len2 != 2) {
+		return 0;
+	}
 	return (c == c2);
 }
 
@@ -120,6 +130,7 @@ static int check_dos_char_slowly(smb_ucs2_t c)
 /**
  * Fill out doschar table the hard way, by examining each character
  **/
+
 void init_doschar_table(void)
 {
 	int i, j, byteval;
@@ -133,8 +144,9 @@ void init_doschar_table(void)
 
 			c = i + j;
 			
-			if (check_dos_char_slowly(c))
+			if (check_dos_char_slowly(c)) {
 				byteval |= 1 << j;
+			}
 		}
 		doschar_table[i/8] = byteval;
 	}
@@ -149,6 +161,7 @@ void init_doschar_table(void)
  * However, the valid character table is not changed if it's loaded
  * from a file, because we can't unmap files.
  **/
+
 void init_valid_table(void)
 {
 	static int mapped_file;
@@ -176,8 +189,9 @@ void init_valid_table(void)
 
 	DEBUG(2,("creating default valid table\n"));
 	valid_table = SMB_MALLOC(0x10000);
-	for (i=0;i<128;i++)
+	for (i=0;i<128;i++) {
 		valid_table[i] = isalnum(i) || strchr(allowed,i);
+	}
 	
 	for (;i<0x10000;i++) {
 		smb_ucs2_t c;
@@ -186,8 +200,6 @@ void init_valid_table(void)
 	}
 }
 
-
-
 /*******************************************************************
  Write a string in (little-endian) unicode format. src is in
  the current DOS codepage. len is the length in bytes of the
@@ -213,27 +225,32 @@ size_t dos_PutUniCode(char *dst,const char *src, ssize_t len, BOOL null_terminat
 
 char *skip_unibuf(char *src, size_t len)
 {
-    char *srcend = src + len;
+	char *srcend = src + len;
 
-    while (src < srcend && SVAL(src,0))
-        src += 2;
+	while (src < srcend && SVAL(src,0)) {
+		src += 2;
+	}
 
-    if(!SVAL(src,0))
-        src += 2;
+	if(!SVAL(src,0)) {
+		src += 2;
+	}
 
-    return src;
+	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 (!src) {
 		dest[0] = 0;
 		return 0;
 	}
-	if(dest_len==-1) dest_len=MAXUNI-3;
+	if(dest_len==-1) {
+		dest_len=MAXUNI-3;
+	}
 	return pull_ucs2(NULL, dest, src, dest_len, src_len, flags|STR_UNICODE|STR_NOALIGN);
 }
 
@@ -249,14 +266,16 @@ int rpcstr_pull_unistr2_fstring(char *dest, UNISTR2 *src)
 
 /* 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);
 }
 
 /*******************************************************************
- Convert a (little-endian) UNISTR2 structure to an ASCII string
+ Convert a (little-endian) UNISTR2 structure to an ASCII string.
 ********************************************************************/
+
 void unistr2_to_ascii(char *dest, const UNISTR2 *str, size_t maxlen)
 {
 	if (str == NULL) {
@@ -267,8 +286,9 @@ void unistr2_to_ascii(char *dest, const UNISTR2 *str, size_t maxlen)
 }
 
 /*******************************************************************
- Convert a (little-endian) UNISTR3 structure to an ASCII string
+ Convert a (little-endian) UNISTR3 structure to an ASCII string.
 ********************************************************************/
+
 void unistr3_to_ascii(char *dest, const UNISTR3 *str, size_t maxlen)
 {
 	if (str == NULL) {
@@ -280,8 +300,9 @@ void unistr3_to_ascii(char *dest, const UNISTR3 *str, size_t maxlen)
 }
 	
 /*******************************************************************
-give a static string for displaying a UNISTR2
+ Give a static string for displaying a UNISTR2.
 ********************************************************************/
+
 const char *unistr2_static(const UNISTR2 *str)
 {
 	static pstring ret;
@@ -289,24 +310,26 @@ const char *unistr2_static(const UNISTR2 *str)
 	return ret;
 }
 
-
 /*******************************************************************
- duplicate a UNISTR2 string into a null terminated char*
- using a talloc context
+ Duplicate a UNISTR2 string into a null terminated char*
+ using a talloc context.
 ********************************************************************/
+
 char *unistr2_tdup(TALLOC_CTX *ctx, const UNISTR2 *str)
 {
 	char *s;
 	int maxlen = (str->uni_str_len+1)*4;
-	if (!str->buffer) return NULL;
+	if (!str->buffer) {
+		return NULL;
+	}
 	s = (char *)TALLOC(ctx, maxlen); /* convervative */
-	if (!s) return NULL;
-	pull_ucs2(NULL, s, str->buffer, maxlen, str->uni_str_len*2, 
-		  STR_NOALIGN);
+	if (!s) {
+		return NULL;
+	}
+	pull_ucs2(NULL, s, str->buffer, maxlen, str->uni_str_len*2, STR_NOALIGN);
 	return s;
 }
 
-
 /*******************************************************************
  Convert a wchar to upper case.
 ********************************************************************/
@@ -323,29 +346,30 @@ smb_ucs2_t toupper_w(smb_ucs2_t val)
 smb_ucs2_t tolower_w( smb_ucs2_t val )
 {
 	return lowcase_table[SVAL(&val,0)];
-
 }
 
 /*******************************************************************
-determine if a character is lowercase
+ Determine if a character is lowercase.
 ********************************************************************/
+
 BOOL islower_w(smb_ucs2_t c)
 {
 	return upcase_table[SVAL(&c,0)] != c;
 }
 
 /*******************************************************************
-determine if a character is uppercase
+ Determine if a character is uppercase.
 ********************************************************************/
+
 BOOL isupper_w(smb_ucs2_t c)
 {
 	return lowcase_table[SVAL(&c,0)] != c;
 }
 
-
 /*******************************************************************
-determine if a character is valid in a 8.3 name
+ Determine if a character is valid in a 8.3 name.
 ********************************************************************/
+
 BOOL isvalid83_w(smb_ucs2_t c)
 {
 	return valid_table[SVAL(&c,0)] != 0;
@@ -354,11 +378,15 @@ BOOL isvalid83_w(smb_ucs2_t c)
 /*******************************************************************
  Count the number of characters in a smb_ucs2_t string.
 ********************************************************************/
+
 size_t strlen_w(const smb_ucs2_t *src)
 {
 	size_t len;
+	smb_ucs2_t c;
 
-	for(len = 0; *src++; len++) ;
+	for(len = 0; *(COPY_UCS2_CHAR(&c,src)); src++, len++) {
+		;
+	}
 
 	return len;
 }
@@ -366,11 +394,15 @@ size_t strlen_w(const smb_ucs2_t *src)
 /*******************************************************************
  Count up to max number of characters in a smb_ucs2_t string.
 ********************************************************************/
+
 size_t strnlen_w(const smb_ucs2_t *src, size_t max)
 {
 	size_t len;
+	smb_ucs2_t c;
 
-	for(len = 0; *src++ && (len < max); len++) ;
+	for(len = 0; *(COPY_UCS2_CHAR(&c,src)) && (len < max); src++, len++) {
+		;
+	}
 
 	return len;
 }
@@ -381,11 +413,16 @@ size_t strnlen_w(const smb_ucs2_t *src, size_t max)
 
 smb_ucs2_t *strchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
 {
-	while (*s != 0) {
-		if (c == *s) return (smb_ucs2_t *)s;
+	smb_ucs2_t cp;
+	while (*(COPY_UCS2_CHAR(&cp,s))) {
+		if (c == cp) {
+			return (smb_ucs2_t *)s;
+		}
 		s++;
 	}
-	if (c == *s) return (smb_ucs2_t *)s;
+	if (c == cp) {
+		return (smb_ucs2_t *)s;
+	}
 
 	return NULL;
 }
@@ -401,12 +438,18 @@ smb_ucs2_t *strchr_wa(const smb_ucs2_t *s, char c)
 
 smb_ucs2_t *strrchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
 {
+	smb_ucs2_t cp;
 	const smb_ucs2_t *p = s;
 	int len = strlen_w(s);
-	if (len == 0) return NULL;
+
+	if (len == 0) {
+		return NULL;
+	}
 	p += (len - 1);
 	do {
-		if (c == *p) return (smb_ucs2_t *)p;
+		if (c == *(COPY_UCS2_CHAR(&cp,p))) {
+			return (smb_ucs2_t *)p;
+		}
 	} while (p-- != s);
 	return NULL;
 }
@@ -417,17 +460,22 @@ smb_ucs2_t *strrchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
 
 smb_ucs2_t *strnrchr_w(const smb_ucs2_t *s, smb_ucs2_t c, unsigned int n)
 {
+	smb_ucs2_t cp;
 	const smb_ucs2_t *p = s;
 	int len = strlen_w(s);
-	if (len == 0 || !n)
+
+	if (len == 0 || !n) {
 		return NULL;
+	}
 	p += (len - 1);
 	do {
-		if (c == *p)
+		if (c == *(COPY_UCS2_CHAR(&cp,p))) {
 			n--;
+		}
 
-		if (!n)
+		if (!n) {
 			return (smb_ucs2_t *)p;
+		}
 	} while (p-- != s);
 	return NULL;
 }
@@ -441,15 +489,17 @@ smb_ucs2_t *strstr_w(const smb_ucs2_t *s, const smb_ucs2_t *ins)
 	smb_ucs2_t *r;
 	size_t inslen;
 
-	if (!s || !*s || !ins || !*ins) 
+	if (!s || !*s || !ins || !*ins) {
 		return NULL;
+	}
 
 	inslen = strlen_w(ins);
 	r = (smb_ucs2_t *)s;
 
 	while ((r = strchr_w(r, *ins))) {
-		if (strncmp_w(r, ins, inslen) == 0) 
+		if (strncmp_w(r, ins, inslen) == 0) {
 			return r;
+		}
 		r++;
 	}
 
@@ -460,13 +510,16 @@ smb_ucs2_t *strstr_w(const smb_ucs2_t *s, const smb_ucs2_t *ins)
  Convert a string to lower case.
  return True if any char is converted
 ********************************************************************/
+
 BOOL strlower_w(smb_ucs2_t *s)
 {
+	smb_ucs2_t cp;
 	BOOL ret = False;
-	while (*s) {
-		smb_ucs2_t v = tolower_w(*s);
-		if (v != *s) {
-			*s = v;
+
+	while (*(COPY_UCS2_CHAR(&cp,s))) {
+		smb_ucs2_t v = tolower_w(cp);
+		if (v != cp) {
+			COPY_UCS2_CHAR(s,&v);
 			ret = True;
 		}
 		s++;
@@ -478,13 +531,15 @@ BOOL strlower_w(smb_ucs2_t *s)
  Convert a string to upper case.
  return True if any char is converted
 ********************************************************************/
+
 BOOL strupper_w(smb_ucs2_t *s)
 {
+	smb_ucs2_t cp;
 	BOOL ret = False;
-	while (*s) {
-		smb_ucs2_t v = toupper_w(*s);
-		if (v != *s) {
-			*s = v;
+	while (*(COPY_UCS2_CHAR(&cp,s))) {
+		smb_ucs2_t v = toupper_w(cp);
+		if (v != cp) {
+			COPY_UCS2_CHAR(s,&v);
 			ret = True;
 		}
 		s++;
@@ -493,88 +548,127 @@ BOOL strupper_w(smb_ucs2_t *s)
 }
 
 /*******************************************************************
-  convert a string to "normal" form
+ Convert a string to "normal" form.
 ********************************************************************/
 
 void strnorm_w(smb_ucs2_t *s, int case_default)
 {
-	if (case_default == CASE_UPPER)
+	if (case_default == CASE_UPPER) {
 		strupper_w(s);
-	else
+	} else {
 		strlower_w(s);
+	}
 }
 
 int strcmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b)
 {
-	while (*b && *a == *b) { a++; b++; }
-	return (*a - *b);
-	/* warning: if *a != *b and both are not 0 we retrun a random
+	smb_ucs2_t cpa, cpb;
+
+	while ((*(COPY_UCS2_CHAR(&cpb,b))) && (*(COPY_UCS2_CHAR(&cpa,a)) == cpb)) {
+		a++;
+		b++;
+	}
+	return cpa - cpb;
+	/* warning: if *a != *b and both are not 0 we return a random
 		greater or lesser than 0 number not realted to which
 		string is longer */
 }
 
 int strncmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len)
 {
+	smb_ucs2_t cpa, cpb;
 	size_t n = 0;
-	while ((n < len) && *b && *a == *b) { a++; b++; n++;}
-	return (len - n)?(*a - *b):0;	
+
+	while ((n < len) && (*(COPY_UCS2_CHAR(&cpb,b))) && (*(COPY_UCS2_CHAR(&cpa,a)) == cpb)) {
+		a++;
+		b++;
+		n++;
+	}
+	return (len - n)?(cpa - cpb):0;
 }
 
 /*******************************************************************
-case insensitive string comparison
+ Case insensitive string comparison.
 ********************************************************************/
+
 int strcasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b)
 {
-	while (*b && toupper_w(*a) == toupper_w(*b)) { a++; b++; }
-	return (tolower_w(*a) - tolower_w(*b));
+	smb_ucs2_t cpa, cpb;
+
+	while ((*COPY_UCS2_CHAR(&cpb,b)) && toupper_w(*(COPY_UCS2_CHAR(&cpa,a))) == toupper_w(cpb)) {
+		a++;
+		b++;
+	}
+	return (tolower_w(cpa) - tolower_w(cpb));
 }
 
 /*******************************************************************
-case insensitive string comparison, lenght limited
+ Case insensitive string comparison, length limited.
 ********************************************************************/
+
 int strncasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len)
 {
+	smb_ucs2_t cpa, cpb;
 	size_t n = 0;
-	while ((n < len) && *b && (toupper_w(*a) == toupper_w(*b))) { a++; b++; n++; }
-	return (len - n)?(tolower_w(*a) - tolower_w(*b)):0;
+
+	while ((n < len) && *COPY_UCS2_CHAR(&cpb,b) && (toupper_w(*(COPY_UCS2_CHAR(&cpa,a))) == toupper_w(cpb))) {
+		a++;
+		b++;
+		n++;
+	}
+	return (len - n)?(tolower_w(cpa) - tolower_w(cpb)):0;
 }
 
 /*******************************************************************
-  compare 2 strings 
+ 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);
+	if (s1 == s2) {
+		return(True);
+	}
+	if (!s1 || !s2) {
+		return(False);
+	}
   
 	return(strcasecmp_w(s1,s2)==0);
 }
 
 /*******************************************************************
-  compare 2 strings up to and including the nth char.
-  ******************************************************************/
+ Compare 2 strings up to and including the nth char.
+******************************************************************/
+
 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);
+	if (s1 == s2) {
+		return(True);
+	}
+	if (!s1 || !s2 || !n) {
+		return(False);
+	}
   
-  return(strncasecmp_w(s1,s2,n)==0);
+	return(strncasecmp_w(s1,s2,n)==0);
 }
 
 /*******************************************************************
-duplicate string
+ Duplicate string.
 ********************************************************************/
+
 smb_ucs2_t *strdup_w(const smb_ucs2_t *src)
 {
 	return strndup_w(src, 0);
 }
 
 /* if len == 0 then duplicate the whole string */
+
 smb_ucs2_t *strndup_w(const smb_ucs2_t *src, size_t len)
 {
 	smb_ucs2_t *dest;
 	
-	if (!len) len = strlen_w(src);
+	if (!len) {
+		len = strlen_w(src);
+	}
 	dest = SMB_MALLOC_ARRAY(smb_ucs2_t, len + 1);
 	if (!dest) {
 		DEBUG(0,("strdup_w: out of memory!\n"));
@@ -583,46 +677,53 @@ smb_ucs2_t *strndup_w(const smb_ucs2_t *src, size_t len)
 
 	memcpy(dest, src, len * sizeof(smb_ucs2_t));
 	dest[len] = 0;
-	
 	return dest;
 }
 
 /*******************************************************************
-copy a string with max len
+ Copy a string with max len.
 ********************************************************************/
 
 smb_ucs2_t *strncpy_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max)
 {
+	smb_ucs2_t cp;
 	size_t len;
 	
-	if (!dest || !src) return NULL;
+	if (!dest || !src) {
+		return NULL;
+	}
 	
-	for (len = 0; (src[len] != 0) && (len < max); len++)
-		dest[len] = src[len];
-	while (len < max)
-		dest[len++] = 0;
+	for (len = 0; (*COPY_UCS2_CHAR(&cp,(src+len))) && (len < max); len++) {
+		cp = *COPY_UCS2_CHAR(dest+len,src+len);
+	}
+	cp = 0;
+	while (len < max) {
+		cp = *COPY_UCS2_CHAR(dest+len,&cp);
+	}
 	
 	return dest;
 }
 
-
 /*******************************************************************
-append a string of len bytes and add a terminator
+ Append a string of len bytes and add a terminator.
 ********************************************************************/
 
 smb_ucs2_t *strncat_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max)
 {	
 	size_t start;
 	size_t len;	
-	
-	if (!dest || !src) return NULL;
+	smb_ucs2_t z = 0;
+
+	if (!dest || !src) {
+		return NULL;
+	}
 	
 	start = strlen_w(dest);
 	len = strnlen_w(src, max);
 
 	memcpy(&dest[start], src, len*sizeof(smb_ucs2_t));			
-	dest[start+len] = 0;
-	
+	z = *COPY_UCS2_CHAR(dest+start+len,&z);
+
 	return dest;
 }
 
@@ -630,32 +731,39 @@ smb_ucs2_t *strcat_w(smb_ucs2_t *dest, const smb_ucs2_t *src)
 {	
 	size_t start;
 	size_t len;	
+	smb_ucs2_t z = 0;
 	
-	if (!dest || !src) return NULL;
+	if (!dest || !src) {
+		return NULL;
+	}
 	
 	start = strlen_w(dest);
 	len = strlen_w(src);
 
 	memcpy(&dest[start], src, len*sizeof(smb_ucs2_t));			
-	dest[start+len] = 0;
+	z = *COPY_UCS2_CHAR(dest+start+len,&z);
 	
 	return dest;
 }
 
 
 /*******************************************************************
-replace any occurence of oldc with newc in unicode string
+ Replace any occurence of oldc with newc in unicode string.
 ********************************************************************/
 
 void string_replace_w(smb_ucs2_t *s, smb_ucs2_t oldc, smb_ucs2_t newc)
 {
-	for(;*s;s++) {
-		if(*s==oldc) *s=newc;
+	smb_ucs2_t cp;
+
+	for(;*(COPY_UCS2_CHAR(&cp,s));s++) {
+		if(cp==oldc) {
+			COPY_UCS2_CHAR(s,&newc);
+		}
 	}
 }
 
 /*******************************************************************
-trim unicode string
+ Trim unicode string.
 ********************************************************************/
 
 BOOL trim_string_w(smb_ucs2_t *s, const smb_ucs2_t *front,
@@ -664,7 +772,9 @@ BOOL trim_string_w(smb_ucs2_t *s, const smb_ucs2_t *front,
 	BOOL ret = False;
 	size_t len, front_len, back_len;
 
-	if (!s || !*s) return False;
+	if (!s) {
+		return False;
+	}
 
 	len = strlen_w(s);
 
@@ -699,24 +809,39 @@ BOOL trim_string_w(smb_ucs2_t *s, const smb_ucs2_t *front,
 
 int strcmp_wa(const smb_ucs2_t *a, const char *b)
 {
-	while (*b && *a == UCS2_CHAR(*b)) { a++; b++; }
-	return (*a - UCS2_CHAR(*b));
+	smb_ucs2_t cp = 0;
+
+	while (*b && *(COPY_UCS2_CHAR(&cp,a)) == UCS2_CHAR(*b)) {
+		a++;
+		b++;
+	}
+	return (cp - UCS2_CHAR(*b));
 }
 
 int strncmp_wa(const smb_ucs2_t *a, const char *b, size_t len)
 {
+	smb_ucs2_t cp = 0;
 	size_t n = 0;
-	while ((n < len) && *b && *a == UCS2_CHAR(*b)) { a++; b++; n++;}
-	return (len - n)?(*a - UCS2_CHAR(*b)):0;
+
+	while ((n < len) && *b && *(COPY_UCS2_CHAR(&cp,a)) == UCS2_CHAR(*b)) {
+		a++;
+		b++;
+		n++;
+	}
+	return (len - n)?(cp - UCS2_CHAR(*b)):0;
 }
 
 smb_ucs2_t *strpbrk_wa(const smb_ucs2_t *s, const char *p)
 {
-	while (*s != 0) {
+	smb_ucs2_t cp;
+
+	while (*(COPY_UCS2_CHAR(&cp,s))) {
 		int i;
-		for (i=0; p[i] && *s != UCS2_CHAR(p[i]); i++) 
+		for (i=0; p[i] && cp != UCS2_CHAR(p[i]); i++) 
 			;
-		if (p[i]) return (smb_ucs2_t *)s;
+		if (p[i]) {
+			return (smb_ucs2_t *)s;
+		}
 		s++;
 	}
 	return NULL;
@@ -727,8 +852,9 @@ smb_ucs2_t *strstr_wa(const smb_ucs2_t *s, const char *ins)
 	smb_ucs2_t *r;
 	size_t inslen;
 
-	if (!s || !*s || !ins || !*ins) 
+	if (!s || !ins) { 
 		return NULL;
+	}
 
 	inslen = strlen(ins);
 	r = (smb_ucs2_t *)s;
@@ -747,37 +873,48 @@ BOOL trim_string_wa(smb_ucs2_t *s, const char *front,
 {
 	wpstring f, b;
 
-	if (front) push_ucs2(NULL, f, front, sizeof(wpstring) - 1, STR_TERMINATE);
-	else *f = 0;
-	if (back) push_ucs2(NULL, b, back, sizeof(wpstring) - 1, STR_TERMINATE);
-	else *b = 0;
+	if (front) {
+		push_ucs2(NULL, f, front, sizeof(wpstring) - 1, STR_TERMINATE);
+	} else {
+		*f = 0;
+	}
+	if (back) {
+		push_ucs2(NULL, b, back, sizeof(wpstring) - 1, STR_TERMINATE);
+	} else {
+		*b = 0;
+	}
 	return trim_string_w(s, f, b);
 }
 
 /*******************************************************************
- returns the length in number of wide characters
- ******************************************************************/
+ Returns the length in number of wide characters.
+******************************************************************/
+
 int unistrlen(uint16 *s)
 {
 	int len;
 
-	if (!s)
+	if (!s) {
 		return -1;
+	}
 
-	for (len=0; *s; s++,len++);
+	for (len=0; SVAL(s,0); s++,len++) {
+		;
+	}
 
 	return len;
 }
 
 /*******************************************************************
- Strcpy for unicode strings.  returns length (in num of wide chars)
+ Strcpy for unicode strings. Returns length (in num of wide chars).
+ Not odd align safe.
 ********************************************************************/
 
 int unistrcpy(uint16 *dst, uint16 *src)
 {
 	int num_wchars = 0;
 
-	while (*src) {
+	while (SVAL(src,0)) {
 		*dst++ = *src++;
 		num_wchars++;
 	}
@@ -798,12 +935,15 @@ int unistrcpy(uint16 *dst, uint16 *src)
  *
  * @return copied UNISTR2 destination
  **/
+
 UNISTR2* ucs2_to_unistr2(TALLOC_CTX *ctx, UNISTR2* dst, smb_ucs2_t* src)
 {
 	size_t len;
 
-	if (!src)
+	if (!src) {
 		return NULL;
+	}
+
 	len = strlen_w(src);
 	
 	/* allocate UNISTR2 destination if not given */