r2159: converted samba4 over to UTF-16.

I had previously thought this was unnecessary, as windows doesn't use
standards compliant UTF-16, and for filesystem operations treats bytes
as UCS-2, but Bjoern Jacke has pointed out to me that this means we
don't correctly store extended UTF-16 characters as UTF-8 on
disk. This can be seen with (for example) the gothic characters with
codepoints above 64k.

This commit also adds a LOCAL-ICONV torture test that tests the first
1 million codepoints against the system iconv library, and tests 5
million random UTF-16LE buffers for identical error handling to the
system iconv library.

the lib/iconv.c changes need backporting to samba3
(This used to be commit 756f28ac95feaa84b42402723d5f7286865c78db)

1 files changed, 197 insertions, 65 deletions

diff --git a/source4/lib/iconv.c b/source4/lib/iconv.c
index c869c253cf..9f6526faa5 100644
--- a/source4/lib/iconv.c
+++ b/source4/lib/iconv.c
@@ -39,8 +39,8 @@
  *
  * Note that the only function provided by iconv is conversion between
  * characters.  It doesn't directly support operations like
- * uppercasing or comparison.  We have to convert to UCS-2 and compare
- * there.
+ * uppercasing or comparison.  We have to convert to UTF-16LE and
+ * compare there.
  *
  * @sa Samba Developers Guide
  **/
@@ -55,10 +55,11 @@ static size_t iconv_copy  (void *,const char **, size_t *, char **, size_t *);
 static size_t iconv_swab  (void *,const char **, size_t *, char **, size_t *);
 
 static const struct charset_functions const builtin_functions[] = {
-	/* windows is really neither UCS-2 not UTF-16 */
+	/* windows is closest to UTF-16 */
 	{"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},
@@ -217,23 +218,23 @@ smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode)
 #endif
 
 	/* check for conversion to/from ucs2 */
-	if (strcasecmp(fromcode, "UCS-2LE") == 0 && to) {
+	if (strcasecmp(fromcode, "UTF-16LE") == 0 && to) {
 		ret->direct = to->push;
 		return ret;
 	}
-	if (strcasecmp(tocode, "UCS-2LE") == 0 && from) {
+	if (strcasecmp(tocode, "UTF-16LE") == 0 && from) {
 		ret->direct = from->pull;
 		return ret;
 	}
 
 #ifdef HAVE_NATIVE_ICONV
-	if (strcasecmp(fromcode, "UCS-2LE") == 0) {
+	if (strcasecmp(fromcode, "UTF-16LE") == 0) {
 		ret->direct = sys_iconv;
 		ret->cd_direct = ret->cd_push;
 		ret->cd_push = NULL;
 		return ret;
 	}
-	if (strcasecmp(tocode, "UCS-2LE") == 0) {
+	if (strcasecmp(tocode, "UTF-16LE") == 0) {
 		ret->direct = sys_iconv;
 		ret->cd_direct = ret->cd_pull;
 		ret->cd_pull = NULL;
@@ -460,100 +461,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 uint8_t *c = (const uint8_t *)*inbuf;
-		uint8_t *uc = (uint8_t *)*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) {
-		uint8_t *c = (uint8_t *)*outbuf;
-		const uint8_t *uc = (const uint8_t *)*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;
 }