r2163: converted samba3 to use the new utf-16 aware iconv code. Also changed

iconv to recognise UCS-2LE and UTF-16LE as synonyms, which means this
change should be more robust when applied in trees that treat UCS-2LE
or UTF-16LE as correct.
(This used to be commit 92c9fcaec4299ddc16f9d6568a695b1fe161be33)

1 files changed, 208 insertions, 64 deletions

diff --git a/source3/lib/iconv.c b/source3/lib/iconv.c
index e10e42328c6..17cafdcbd6b 100644
--- a/source3/lib/iconv.c
+++ b/source3/lib/iconv.c
@@ -66,6 +66,7 @@ static struct charset_functions builtin_functions[] = {
 	{"UCS-2LE",  iconv_copy, iconv_copy},
 	{"UTF-16LE",  iconv_copy, iconv_copy},
 	{"UCS-2BE",  iconv_swab, iconv_swab},
+	{"UTF-16BE",  iconv_swab, iconv_swab},
 
 	/* we include the UTF-8 alias to cope with differing locale settings */
 	{"UTF8",   utf8_pull,  utf8_push},
@@ -189,6 +190,13 @@ size_t smb_iconv(smb_iconv_t cd,
 	return 0;
 }
 
+
+static BOOL is_utf16(const char *name)
+{
+	return strcasecmp(name, "UCS-2LE") == 0 ||
+		strcasecmp(name, "UTF-16LE") == 0;
+}
+
 /*
   simple iconv_open() wrapper
  */
@@ -227,13 +235,17 @@ smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode)
 	/* check if we can use iconv for this conversion */
 #ifdef HAVE_NATIVE_ICONV
 	if (!ret->pull) {
-		ret->cd_pull = iconv_open("UCS-2LE", fromcode);
+		ret->cd_pull = iconv_open("UTF-16LE", fromcode);
+		if (ret->cd_pull == (iconv_t)-1)
+			ret->cd_pull = iconv_open("UCS-2LE", fromcode);
 		if (ret->cd_pull != (iconv_t)-1)
 			ret->pull = sys_iconv;
 	}
 
 	if (!ret->push) {
-		ret->cd_push = iconv_open(tocode, "UCS-2LE");
+		ret->cd_push = iconv_open(tocode, "UTF-16LE");
+		if (ret->cd_push == (iconv_t)-1)
+			ret->cd_push = iconv_open(tocode, "UCS-2LE");
 		if (ret->cd_push != (iconv_t)-1)
 			ret->push = sys_iconv;
 	}
@@ -263,13 +275,13 @@ smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode)
 	}
 
 	/* check for conversion to/from ucs2 */
-	if (strcasecmp(fromcode, "UCS-2LE") == 0 && to) {
+	if (is_utf16(fromcode) && to) {
 		ret->direct = to->push;
 		ret->push = ret->pull = NULL;
 		return ret;
 	}
 
-	if (strcasecmp(tocode, "UCS-2LE") == 0 && from) {
+	if (is_utf16(tocode) && from) {
 		ret->direct = from->pull;
 		ret->push = ret->pull = NULL;
 		return ret;
@@ -277,13 +289,13 @@ smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode)
 
 	/* Check if we can do the conversion direct */
 #ifdef HAVE_NATIVE_ICONV
-	if (strcasecmp(fromcode, "UCS-2LE") == 0) {
+	if (is_utf16(fromcode)) {
 		ret->direct = sys_iconv;
 		ret->cd_direct = ret->cd_push;
 		ret->cd_push = NULL;
 		return ret;
 	}
-	if (strcasecmp(tocode, "UCS-2LE") == 0) {
+	if (is_utf16(tocode)) {
 		ret->direct = sys_iconv;
 		ret->cd_direct = ret->cd_pull;
 		ret->cd_pull = NULL;
@@ -528,99 +540,231 @@ static size_t iconv_copy(void *cd, const char **inbuf, size_t *inbytesleft,
 static size_t utf8_pull(void *cd, const char **inbuf, size_t *inbytesleft,
 			 char **outbuf, size_t *outbytesleft)
 {
-	while (*inbytesleft >= 1 && *outbytesleft >= 2) {
-		const unsigned char *c = (const unsigned char *)*inbuf;
-		unsigned char *uc = (unsigned char *)*outbuf;
-		int len = 1;
+	size_t in_left=*inbytesleft, out_left=*outbytesleft;
+	const uint8_t *c = (const uint8_t *)*inbuf;
+	uint8_t *uc = (uint8_t *)*outbuf;
 
+	while (in_left >= 1 && out_left >= 2) {
 		if ((c[0] & 0x80) == 0) {
 			uc[0] = c[0];
 			uc[1] = 0;
-		} else if ((c[0] & 0xf0) == 0xe0) {
-			if (*inbytesleft < 3) {
-				DEBUG(0,("short utf8 char\n"));
-				goto badseq;
+			c  += 1;
+			in_left  -= 1;
+			out_left -= 2;
+			uc += 2;
+			continue;
+		}
+
+		if ((c[0] & 0xe0) == 0xc0) {
+			if (in_left < 2 ||
+			    (c[1] & 0xc0) != 0x80) {
+				errno = EILSEQ;
+				goto error;
+			}
+			uc[1] = (c[0]>>2) & 0x7;
+			uc[0] = (c[0]<<6) | (c[1]&0x3f);
+			c  += 2;
+			in_left  -= 2;
+			out_left -= 2;
+			uc += 2;
+			continue;
+		}
+
+		if ((c[0] & 0xf0) == 0xe0) {
+			if (in_left < 3 ||
+			    (c[1] & 0xc0) != 0x80 || 
+			    (c[2] & 0xc0) != 0x80) {
+				errno = EILSEQ;
+				goto error;
 			}
 			uc[1] = ((c[0]&0xF)<<4) | ((c[1]>>2)&0xF);
 			uc[0] = (c[1]<<6) | (c[2]&0x3f);
-			len = 3;
-		} else if ((c[0] & 0xe0) == 0xc0) {
-			if (*inbytesleft < 2) {
-				DEBUG(0,("short utf8 char\n"));
-				goto badseq;
+			c  += 3;
+			in_left  -= 3;
+			out_left -= 2;
+			uc += 2;
+			continue;
+		}
+
+		if ((c[0] & 0xf8) == 0xf0) {
+			unsigned int codepoint;
+			if (in_left < 4 ||
+			    (c[1] & 0xc0) != 0x80 || 
+			    (c[2] & 0xc0) != 0x80 ||
+			    (c[3] & 0xc0) != 0x80) {
+				errno = EILSEQ;
+				goto error;
 			}
-			uc[1] = (c[0]>>2) & 0x7;
-			uc[0] = (c[0]<<6) | (c[1]&0x3f);
-			len = 2;
+			codepoint = 
+				(c[3]&0x3f) | 
+				((c[2]&0x3f)<<6) | 
+				((c[1]&0x3f)<<12) |
+				((c[0]&0x7)<<18);
+			if (codepoint < 0x10000) {
+				/* accept UTF-8 characters that are not
+				   minimally packed, but pack the result */
+				uc[0] = (codepoint & 0xFF);
+				uc[1] = (codepoint >> 8);
+				c += 4;
+				in_left -= 4;
+				out_left -= 2;
+				uc += 2;
+				continue;
+			}
+
+			codepoint -= 0x10000;
+
+			if (out_left < 4) {
+				errno = E2BIG;
+				goto error;
+			}
+
+			uc[0] = (codepoint>>10) & 0xFF;
+			uc[1] = (codepoint>>18) | 0xd8;
+			uc[2] = codepoint & 0xFF;
+			uc[3] = ((codepoint>>8) & 0x3) | 0xdc;
+			c  += 4;
+			in_left  -= 4;
+			out_left -= 4;
+			uc += 4;
+			continue;
 		}
 
-		(*inbuf)  += len;
-		(*inbytesleft)  -= len;
-		(*outbytesleft) -= 2;
-		(*outbuf) += 2;
+		/* we don't handle 5 byte sequences */
+		errno = EINVAL;
+		goto error;
 	}
 
-	if (*inbytesleft > 0) {
+	if (in_left > 0) {
 		errno = E2BIG;
-		return -1;
+		goto error;
 	}
-	
+
+	*inbytesleft = in_left;
+	*outbytesleft = out_left;
+	*inbuf = c;
+	*outbuf = uc;	
 	return 0;
 
-badseq:
-	errno = EINVAL;
+error:
+	*inbytesleft = in_left;
+	*outbytesleft = out_left;
+	*inbuf = c;
+	*outbuf = uc;
 	return -1;
 }
 
 static size_t utf8_push(void *cd, const char **inbuf, size_t *inbytesleft,
-			 char **outbuf, size_t *outbytesleft)
+			char **outbuf, size_t *outbytesleft)
 {
-	while (*inbytesleft >= 2 && *outbytesleft >= 1) {
-		unsigned char *c = (unsigned char *)*outbuf;
-		const unsigned char *uc = (const unsigned char *)*inbuf;
-		int len=1;
-
-		if (uc[1] & 0xf8) {
-			if (*outbytesleft < 3) {
-				DEBUG(0,("short utf8 write\n"));
-				goto toobig;
+	size_t in_left=*inbytesleft, out_left=*outbytesleft;
+	uint8_t *c = (uint8_t *)*outbuf;
+	const uint8_t *uc = (const uint8_t *)*inbuf;
+
+	while (in_left >= 2 && out_left >= 1) {
+		unsigned int codepoint;
+
+		if (uc[1] == 0 && !(uc[0] & 0x80)) {
+			/* simplest case */
+			c[0] = uc[0];
+			in_left  -= 2;
+			out_left -= 1;
+			uc += 2;
+			c  += 1;
+			continue;
+		}
+
+		if ((uc[1]&0xf8) == 0) {
+			/* next simplest case */
+			if (out_left < 2) {
+				errno = E2BIG;
+				goto error;
 			}
-			c[0] = 0xe0 | (uc[1]>>4);
-			c[1] = 0x80 | ((uc[1]&0xF)<<2) | (uc[0]>>6);
-			c[2] = 0x80 | (uc[0]&0x3f);
-			len = 3;
-		} else if (uc[1] | (uc[0] & 0x80)) {
-			if (*outbytesleft < 2) {
-				DEBUG(0,("short utf8 write\n"));
-				goto toobig;
+			c[0] = 0xc0 | (uc[0]>>6) | (uc[1]<<2);
+			c[1] = 0x80 | (uc[0] & 0x3f);
+			in_left  -= 2;
+			out_left -= 2;
+			uc += 2;
+			c  += 2;
+			continue;
+		}
+
+		if ((uc[1] & 0xfc) == 0xdc) {
+			/* its the second part of a 4 byte sequence. Illegal */
+			if (in_left < 4) {
+				errno = EINVAL;
+			} else {
+				errno = EILSEQ;
 			}
-			c[0] = 0xc0 | (uc[1]<<2) | (uc[0]>>6);
-			c[1] = 0x80 | (uc[0]&0x3f);
-			len = 2;
-		} else {
-			c[0] = uc[0];
+			goto error;
 		}
 
+		if ((uc[1] & 0xfc) != 0xd8) {
+			codepoint = uc[0] | (uc[1]<<8);
+			if (out_left < 3) {
+				errno = E2BIG;
+				goto error;
+			}
+			c[0] = 0xe0 | (codepoint >> 12);
+			c[1] = 0x80 | ((codepoint >> 6) & 0x3f);
+			c[2] = 0x80 | (codepoint & 0x3f);
+			
+			in_left  -= 2;
+			out_left -= 3;
+			uc  += 2;
+			c   += 3;
+			continue;
+		}
 
-		(*inbytesleft)  -= 2;
-		(*outbytesleft) -= len;
-		(*inbuf)  += 2;
-		(*outbuf) += len;
+		/* its the first part of a 4 byte sequence */
+		if (in_left < 4) {
+			errno = EINVAL;
+			goto error;
+		}
+		if ((uc[3] & 0xfc) != 0xdc) {
+			errno = EILSEQ;
+			goto error;
+		}
+		codepoint = 0x10000 + (uc[2] | ((uc[3] & 0x3)<<8) | 
+				       (uc[0]<<10) | ((uc[1] & 0x3)<<18));
+		
+		if (out_left < 4) {
+			errno = E2BIG;
+			goto error;
+		}
+		c[0] = 0xf0 | (codepoint >> 18);
+		c[1] = 0x80 | ((codepoint >> 12) & 0x3f);
+		c[2] = 0x80 | ((codepoint >> 6) & 0x3f);
+		c[3] = 0x80 | (codepoint & 0x3f);
+		
+		in_left  -= 4;
+		out_left -= 4;
+		uc       += 4;
+		c        += 4;
 	}
 
-	if (*inbytesleft == 1) {
+	if (in_left == 1) {
 		errno = EINVAL;
-		return -1;
+		goto error;
 	}
 
-	if (*inbytesleft > 1) {
+	if (in_left > 1) {
 		errno = E2BIG;
-		return -1;
+		goto error;
 	}
+
+	*inbytesleft = in_left;
+	*outbytesleft = out_left;
+	*inbuf  = uc;
+	*outbuf = c;
 	
 	return 0;
 
-toobig:
-	errno = E2BIG;
+error:
+	*inbytesleft = in_left;
+	*outbytesleft = out_left;
+	*inbuf  = uc;
+	*outbuf = c;
 	return -1;
 }
+