lib/util/charset: Remove 'display charset'

As discussed in 'CH_DISPLAY and gettext' on the samba-technical list:
http://lists.samba.org/archive/samba-technical/2011-June/078190.html

Setting this to a value other than 'unix charset' does not make sense,
as any system where the filesytem charset does not equal the terminal
charset will already have problems with programs as simple as 'ls'.
It also means that our output could not be pasted as our input in
interactive programs or onto our command line, as we never did
translate in the DISPLAY -> UNIX direction.

The d_printf() calls are retained in case we need to revisit this, and
to support display_set_stderr().

Andrew Bartlett

13 files changed, 63 insertions, 157 deletions

diff --git a/lib/util/charset/charset.h b/lib/util/charset/charset.h
index a7e554204bc..b36c461003b 100644
--- a/lib/util/charset/charset.h
+++ b/lib/util/charset/charset.h
@@ -28,7 +28,7 @@
 #include <talloc.h>
 
 /* this defines the charset types used in samba */
-typedef enum {CH_UTF16LE=0, CH_UTF16=0, CH_UNIX, CH_DISPLAY, CH_DOS, CH_UTF8, CH_UTF16BE, CH_UTF16MUNGED} charset_t;
+typedef enum {CH_UTF16LE=0, CH_UTF16=0, CH_UNIX, CH_DOS, CH_UTF8, CH_UTF16BE, CH_UTF16MUNGED} charset_t;
 
 #define NUM_CHARSETS 7
 
@@ -182,8 +182,7 @@ extern struct smb_iconv_handle *global_iconv_handle;
 struct smb_iconv_handle *get_iconv_handle(void);
 struct smb_iconv_handle *get_iconv_testing_handle(TALLOC_CTX *mem_ctx, 
 						  const char *dos_charset, 
-						  const char *unix_charset, 
-						  const char *display_charset);
+						  const char *unix_charset);
 smb_iconv_t get_conv_handle(struct smb_iconv_handle *ic,
 			    charset_t from, charset_t to);
 const char *charset_name(struct smb_iconv_handle *ic, charset_t ch);
@@ -212,7 +211,6 @@ int codepoint_cmpi(codepoint_t c1, codepoint_t c2);
 struct smb_iconv_handle *smb_iconv_handle_reinit(TALLOC_CTX *mem_ctx,
 							   const char *dos_charset,
 							   const char *unix_charset,
-							   const char *display_charset,
 							   bool native_iconv,
 							   struct smb_iconv_handle *old_ic);
 
diff --git a/lib/util/charset/codepoints.c b/lib/util/charset/codepoints.c
index 71611bfc4c1..305bfd717fa 100644
--- a/lib/util/charset/codepoints.c
+++ b/lib/util/charset/codepoints.c
@@ -168,17 +168,16 @@ struct smb_iconv_handle *get_iconv_handle(void)
 {
 	if (global_iconv_handle == NULL)
 		global_iconv_handle = smb_iconv_handle_reinit(talloc_autofree_context(),
-									"ASCII", "UTF-8", "ASCII", true, NULL);
+							      "ASCII", "UTF-8", true, NULL);
 	return global_iconv_handle;
 }
 
 struct smb_iconv_handle *get_iconv_testing_handle(TALLOC_CTX *mem_ctx, 
 						  const char *dos_charset, 
-						  const char *unix_charset, 
-						  const char *display_charset)
+						  const char *unix_charset)
 {
 	return smb_iconv_handle_reinit(mem_ctx,
-				       dos_charset, unix_charset, display_charset, true, NULL);
+				       dos_charset, unix_charset, true, NULL);
 }
 
 /**
@@ -190,7 +189,6 @@ const char *charset_name(struct smb_iconv_handle *ic, charset_t ch)
 	case CH_UTF16: return "UTF-16LE";
 	case CH_UNIX: return ic->unix_charset;
 	case CH_DOS: return ic->dos_charset;
-	case CH_DISPLAY: return ic->display_charset;
 	case CH_UTF8: return "UTF8";
 	case CH_UTF16BE: return "UTF-16BE";
 	case CH_UTF16MUNGED: return "UTF16_MUNGED";
@@ -261,14 +259,11 @@ static const char *map_locale(const char *charset)
 _PUBLIC_ struct smb_iconv_handle *smb_iconv_handle_reinit(TALLOC_CTX *mem_ctx,
 								    const char *dos_charset,
 								    const char *unix_charset,
-								    const char *display_charset,
 								    bool native_iconv,
 								    struct smb_iconv_handle *old_ic)
 {
 	struct smb_iconv_handle *ret;
 
-	display_charset = map_locale(display_charset);
-
 	if (old_ic != NULL) {
 		ret = old_ic;
 		close_iconv_handle(ret);
@@ -297,7 +292,6 @@ _PUBLIC_ struct smb_iconv_handle *smb_iconv_handle_reinit(TALLOC_CTX *mem_ctx,
 
 	ret->dos_charset = talloc_strdup(ret->child_ctx, dos_charset);
 	ret->unix_charset = talloc_strdup(ret->child_ctx, unix_charset);
-	ret->display_charset = talloc_strdup(ret->child_ctx, display_charset);
 	ret->native_iconv = native_iconv;
 
 	return ret;
diff --git a/lib/util/charset/tests/convert_string.c b/lib/util/charset/tests/convert_string.c
index bd140d59db8..9a5d974fe35 100644
--- a/lib/util/charset/tests/convert_string.c
+++ b/lib/util/charset/tests/convert_string.c
@@ -105,7 +105,7 @@ static bool test_gd_iso8859_cp850_handle(struct torture_context *tctx)
 	talloc_steal(tctx, gd_iso8859_1.data);
 	talloc_steal(tctx, gd_utf16le.data);
 
-	iconv_handle = get_iconv_testing_handle(tctx, "ISO8859-1", "CP850", "UTF8");
+	iconv_handle = get_iconv_testing_handle(tctx, "ISO8859-1", "CP850");
 	torture_assert(tctx, iconv_handle, "getting iconv handle");
 		
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
@@ -199,11 +199,11 @@ static bool test_gd_iso8859_cp850_handle(struct torture_context *tctx)
 	torture_assert_data_blob_equal(tctx, gd_output, gd_cp850, "conversion from UTF8 to (unix charset) CP850 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
-						    CH_UTF8, CH_DISPLAY, 
+						    CH_UTF8, CH_UTF8, 
 						    gd_utf8.data, gd_utf8.length, 
 						    (void *)&gd_output.data, &gd_output.length), 
-		       "conversion from UTF8 to (display charset) UTF8");
-	torture_assert_data_blob_equal(tctx, gd_output, gd_utf8, "conversion from UTF8 to (display charset) UTF8 incorrect");
+		       "conversion from UTF8 to UTF8");
+	torture_assert_data_blob_equal(tctx, gd_output, gd_utf8, "conversion from UTF8 to UTF8 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
 						    CH_UTF16LE, CH_DOS, 
@@ -227,11 +227,11 @@ static bool test_gd_iso8859_cp850_handle(struct torture_context *tctx)
 	torture_assert_data_blob_equal(tctx, gd_output, gd_cp850, "conversion from UTF16LE to (unix charset) CP850 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
-						    CH_UTF16LE, CH_DISPLAY, 
+						    CH_UTF16LE, CH_UTF8, 
 						    gd_utf16le.data, gd_utf16le.length, 
 						    (void *)&gd_output.data, &gd_output.length), 
-		       "conversion from UTF16LE to (display charset) UTF8");
-	torture_assert_data_blob_equal(tctx, gd_output, gd_utf8, "conversion from UTF16LE to (display charset) UTF8 incorrect");
+		       "conversion from UTF16LE to UTF8");
+	torture_assert_data_blob_equal(tctx, gd_output, gd_utf8, "conversion from UTF16LE to UTF8 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
 						    CH_DOS, CH_DOS, 
@@ -248,11 +248,11 @@ static bool test_gd_iso8859_cp850_handle(struct torture_context *tctx)
 	torture_assert_data_blob_equal(tctx, gd_output, gd_cp850, "conversion from UTF16LE to (unix charset) CP850 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
-						    CH_DOS, CH_DISPLAY, 
+						    CH_DOS, CH_UTF8, 
 						    gd_iso8859_1.data, gd_iso8859_1.length, 
 						    (void *)&gd_output.data, &gd_output.length), 
-		       "conversion from (dos charset) ISO8859-1 to (display charset) UTF8");
-	torture_assert_data_blob_equal(tctx, gd_output, gd_utf8, "conversion from UTF16LE to (display charset) UTF8 incorrect");
+		       "conversion from (dos charset) ISO8859-1 to UTF8");
+	torture_assert_data_blob_equal(tctx, gd_output, gd_utf8, "conversion from UTF16LE to UTF8 incorrect");
 
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
 						    CH_DOS, CH_UTF16LE, 
@@ -265,7 +265,7 @@ static bool test_gd_iso8859_cp850_handle(struct torture_context *tctx)
 						     (const char *)gd_iso8859_1.data,
 						     CH_DOS, CH_UTF16LE),
 				 gd_output.length / 2,
-				 "checking strlen_m_ext of round trip conversion of UTF16 latin charset greek to display charset UTF8 and back again");
+				 "checking strlen_m_ext of round trip conversion of UTF16 latin charset greek to UTF8 and back again");
 
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle,
 						    CH_DOS, CH_UTF8,
@@ -297,7 +297,7 @@ static bool test_gd_minus_1_handle(struct torture_context *tctx)
 	talloc_steal(tctx, gd_cp850.data);
 	talloc_steal(tctx, gd_utf16le.data);
 
-	iconv_handle = get_iconv_testing_handle(tctx, "CP850", "CP850", "UTF8");
+	iconv_handle = get_iconv_testing_handle(tctx, "CP850", "CP850");
 	torture_assert(tctx, iconv_handle, "getting iconv handle");
 
 	gd_utf8_terminated = data_blob_talloc(tctx, NULL, gd_utf8.length + 1);
@@ -481,7 +481,7 @@ static bool test_gd_ascii_handle(struct torture_context *tctx)
 	talloc_steal(tctx, gd_iso8859_1.data);
 	talloc_steal(tctx, gd_utf16le.data);
 
-	iconv_handle = get_iconv_testing_handle(tctx, "ASCII", "UTF8", "UTF8");
+	iconv_handle = get_iconv_testing_handle(tctx, "ASCII", "UTF8");
 	torture_assert(tctx, iconv_handle, "getting iconv handle");
 
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle,
@@ -550,7 +550,7 @@ static bool test_plato_english_iso8859_cp850_handle(struct torture_context *tctx
 	
 	talloc_steal(tctx, plato_english_utf16le.data);
 
-	iconv_handle = get_iconv_testing_handle(tctx, "ISO8859-1", "CP850", "UTF8");
+	iconv_handle = get_iconv_testing_handle(tctx, "ISO8859-1", "CP850");
 	torture_assert(tctx, iconv_handle, "getting iconv handle");
 		
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
@@ -568,11 +568,11 @@ static bool test_plato_english_iso8859_cp850_handle(struct torture_context *tctx
 	torture_assert_data_blob_equal(tctx, plato_english_output, plato_english_cp850, "conversion from UTF8 to (unix charset) CP850 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
-						    CH_UTF8, CH_DISPLAY, 
+						    CH_UTF8, CH_UTF8, 
 						    plato_english_utf8.data, plato_english_utf8.length, 
 						    (void *)&plato_english_output.data, &plato_english_output.length), 
-		       "conversion from UTF8 to (display charset) UTF8");
-	torture_assert_data_blob_equal(tctx, plato_english_output, plato_english_utf8, "conversion from UTF8 to (display charset) UTF8 incorrect");
+		       "conversion from UTF8 to UTF8");
+	torture_assert_data_blob_equal(tctx, plato_english_output, plato_english_utf8, "conversion from UTF8 to UTF8 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
 						    CH_UTF16LE, CH_DOS, 
@@ -621,11 +621,11 @@ static bool test_plato_english_iso8859_cp850_handle(struct torture_context *tctx
 	torture_assert_data_blob_equal(tctx, plato_english_output, plato_english_cp850, "conversion from UTF16LE to (unix charset) CP850 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
-						    CH_UTF16LE, CH_DISPLAY, 
+						    CH_UTF16LE, CH_UTF8, 
 						    plato_english_utf16le.data, plato_english_utf16le.length, 
 						    (void *)&plato_english_output.data, &plato_english_output.length), 
-		       "conversion from UTF16LE to (display charset) UTF8");
-	torture_assert_data_blob_equal(tctx, plato_english_output, plato_english_utf8, "conversion from UTF16LE to (display charset) UTF8 incorrect");
+		       "conversion from UTF16LE to UTF8");
+	torture_assert_data_blob_equal(tctx, plato_english_output, plato_english_utf8, "conversion from UTF16LE to UTF8 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
 						    CH_DOS, CH_DOS, 
@@ -642,11 +642,11 @@ static bool test_plato_english_iso8859_cp850_handle(struct torture_context *tctx
 	torture_assert_data_blob_equal(tctx, plato_english_output, plato_english_cp850, "conversion from UTF16LE to (unix charset) CP850 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
-						    CH_DOS, CH_DISPLAY, 
+						    CH_DOS, CH_UTF8, 
 						    plato_english_iso8859_1.data, plato_english_iso8859_1.length, 
 						    (void *)&plato_english_output.data, &plato_english_output.length), 
-		       "conversion from (dos charset) ISO8859-1 to (display charset) UTF8");
-	torture_assert_data_blob_equal(tctx, plato_english_output, plato_english_utf8, "conversion from UTF16LE to (display charset) UTF8 incorrect");
+		       "conversion from (dos charset) ISO8859-1 to UTF8");
+	torture_assert_data_blob_equal(tctx, plato_english_output, plato_english_utf8, "conversion from UTF16LE to UTF8 incorrect");
 
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
 						    CH_DOS, CH_UTF16LE, 
@@ -668,7 +668,7 @@ static bool test_plato_english_minus_1_handle(struct torture_context *tctx)
 	
 	talloc_steal(tctx, plato_english_utf16le.data);
 
-	iconv_handle = get_iconv_testing_handle(tctx, "ISO8859-1", "CP850", "UTF8");
+	iconv_handle = get_iconv_testing_handle(tctx, "ISO8859-1", "CP850");
 	torture_assert(tctx, iconv_handle, "getting iconv handle");
 
 	plato_english_utf8_terminated = data_blob_talloc(tctx, NULL, plato_english_utf8.length + 1);
@@ -809,7 +809,7 @@ static bool test_plato_minus_1_handle(struct torture_context *tctx)
 	talloc_steal(tctx, plato_utf8.data);
 	talloc_steal(tctx, plato_utf16le.data);
 
-	iconv_handle = get_iconv_testing_handle(tctx, "ISO8859-1", "CP850", "UTF8");
+	iconv_handle = get_iconv_testing_handle(tctx, "ISO8859-1", "CP850");
 	torture_assert(tctx, iconv_handle, "getting iconv handle");
 
 	plato_utf8_terminated = data_blob_talloc(tctx, NULL, plato_utf8.length + 1);
@@ -923,7 +923,7 @@ static bool test_plato_cp850_utf8_handle(struct torture_context *tctx)
 	talloc_steal(tctx, plato_utf8.data);
 	talloc_steal(tctx, plato_utf16le.data);
 
-	iconv_handle = get_iconv_testing_handle(tctx, "CP850", "UTF8", "UTF8");
+	iconv_handle = get_iconv_testing_handle(tctx, "CP850", "UTF8");
 	torture_assert(tctx, iconv_handle, "creating iconv handle");
 		
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
@@ -1008,11 +1008,11 @@ static bool test_plato_cp850_utf8_handle(struct torture_context *tctx)
 	torture_assert_data_blob_equal(tctx, plato_output, plato_utf8, "conversion from UTF8 to (unix charset) UTF8 incorrect");
 
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
-						    CH_UTF8, CH_DISPLAY, 
+						    CH_UTF8, CH_UTF8, 
 						    plato_utf8.data, plato_utf8.length, 
 						    (void *)&plato_output.data, &plato_output.length),
 		       "conversion of UTF16 ancient greek to unix charset UTF8 failed");
-	torture_assert_data_blob_equal(tctx, plato_output, plato_utf8, "conversion from UTF8 to (display charset) UTF8 incorrect");
+	torture_assert_data_blob_equal(tctx, plato_output, plato_utf8, "conversion from UTF8 to UTF8 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
 						    CH_UTF16LE, CH_DOS, 
@@ -1067,39 +1067,39 @@ static bool test_plato_cp850_utf8_handle(struct torture_context *tctx)
 		       "conversion of UTF16 ancient greek to UTF8 failed");
 	torture_assert_data_blob_equal(tctx, plato_output, plato_utf8, "conversion from UTF16LE to UTF8 incorrect");
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
-							  CH_UTF16LE, CH_DISPLAY, 
+							  CH_UTF16LE, CH_UTF8, 
 							  plato_utf16le.data, plato_utf16le.length, 
 							  (void *)&plato_output.data, &plato_output.length),
-		       "conversion of UTF16 ancient greek to display charset UTF8 failed");
-	torture_assert_data_blob_equal(tctx, plato_output, plato_utf8, "conversion from UTF16LE to (display charset) UTF8 incorrect");
+		       "conversion of UTF16 ancient greek to UTF8 failed");
+	torture_assert_data_blob_equal(tctx, plato_output, plato_utf8, "conversion from UTF16LE to UTF8 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
-							  CH_DISPLAY, CH_UTF16LE, 
+							  CH_UTF8, CH_UTF16LE, 
 							  plato_output.data, plato_output.length, 
 							  (void *)&plato_output2.data, &plato_output2.length),
-		       "round trip conversion of UTF16 ancient greek to display charset UTF8 and back again failed");
+		       "round trip conversion of UTF16 ancient greek to UTF8 and back again failed");
 	torture_assert_data_blob_equal(tctx, plato_output2, plato_utf16le,
-				       "round trip conversion of UTF16 ancient greek to display charset UTF8 and back again failed");
+				       "round trip conversion of UTF16 ancient greek to UTF8 and back again failed");
 	torture_assert_int_equal(tctx,
 				 strlen_m_ext_handle(iconv_handle,
 						     (const char *)plato_output.data,
-						     CH_DISPLAY, CH_UTF16LE),
+						     CH_UTF8, CH_UTF16LE),
 				 plato_output2.length / 2,
-				 "checking strlen_m_ext of round trip conversion of UTF16 latin charset greek to display charset UTF8 and back again");
+				 "checking strlen_m_ext of round trip conversion of UTF16 latin charset greek to UTF8 and back again");
 
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle,
-							  CH_DISPLAY, CH_UTF8,
+							  CH_UTF8, CH_UTF8,
 							  plato_output.data, plato_output.length,
 							  (void *)&plato_output2.data, &plato_output2.length),
-		       "conversion of display charset UTF8 to UTF8");
+		       "conversion of UTF8 to UTF8");
 	torture_assert_data_blob_equal(tctx, plato_output2, plato_utf8,
-				       "conversion of display charset UTF8 to UTF8");
+				       "conversion of UTF8 to UTF8");
 	torture_assert_int_equal(tctx,
 				 strlen_m_ext_handle(iconv_handle,
 						     (const char *)plato_output.data,
-						     CH_DISPLAY, CH_UTF8),
+						     CH_UTF8, CH_UTF8),
 				 plato_output2.length,
-				 "checking strlen_m_ext of conversion of display charset UTF8 to UTF8");
+				 "checking strlen_m_ext of conversion of UTF8 to UTF8");
 	return true;
 }
 
@@ -1114,7 +1114,7 @@ static bool test_plato_latin_cp850_utf8_handle(struct torture_context *tctx)
 	talloc_steal(tctx, plato_latin_utf8.data);
 	talloc_steal(tctx, plato_latin_utf16le.data);
 
-	iconv_handle = get_iconv_testing_handle(tctx, "CP850", "UTF8", "UTF8");
+	iconv_handle = get_iconv_testing_handle(tctx, "CP850", "UTF8");
 	torture_assert(tctx, iconv_handle, "creating iconv handle");
 		
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
@@ -1131,11 +1131,11 @@ static bool test_plato_latin_cp850_utf8_handle(struct torture_context *tctx)
 	torture_assert_data_blob_equal(tctx, plato_latin_output, plato_latin_utf8, "conversion from UTF8 to (unix charset) UTF8 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
-						    CH_UTF8, CH_DISPLAY, 
+						    CH_UTF8, CH_UTF8, 
 						    plato_latin_utf8.data, plato_latin_utf8.length, 
 						    (void *)&plato_latin_output.data, &plato_latin_output.length),
 		       "conversion of UTF16 latin charset greek to unix charset UTF8 failed");
-	torture_assert_data_blob_equal(tctx, plato_latin_output, plato_latin_utf8, "conversion from UTF8 to (display charset) UTF8 incorrect");
+	torture_assert_data_blob_equal(tctx, plato_latin_output, plato_latin_utf8, "conversion from UTF8 to UTF8 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
 						    CH_UTF16LE, CH_DOS, 
@@ -1151,25 +1151,25 @@ static bool test_plato_latin_cp850_utf8_handle(struct torture_context *tctx)
 	torture_assert_data_blob_equal(tctx, plato_latin_output, plato_latin_utf8, "conversion from UTF16LE to (unix charset) CP850 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
-							  CH_UTF16LE, CH_DISPLAY, 
+							  CH_UTF16LE, CH_UTF8, 
 							  plato_latin_utf16le.data, plato_latin_utf16le.length, 
 							  (void *)&plato_latin_output.data, &plato_latin_output.length),
-		       "conversion of UTF16 latin charset greek to display charset UTF8 failed");
-	torture_assert_data_blob_equal(tctx, plato_latin_output, plato_latin_utf8, "conversion from UTF16LE to (display charset) UTF8 incorrect");
+		       "conversion of UTF16 latin charset greek to UTF8 failed");
+	torture_assert_data_blob_equal(tctx, plato_latin_output, plato_latin_utf8, "conversion from UTF16LE to UTF8 incorrect");
 	
 	torture_assert(tctx, convert_string_talloc_handle(tctx, iconv_handle, 
-							  CH_DISPLAY, CH_UTF16LE, 
+							  CH_UTF8, CH_UTF16LE, 
 							  plato_latin_output.data, plato_latin_output.length, 
 							  (void *)&plato_latin_output2.data, &plato_latin_output2.length),
-		       "round trip conversion of UTF16 latin charset greek to display charset UTF8 and back again failed");
+		       "round trip conversion of UTF16 latin charset greek to UTF8 and back again failed");
 	torture_assert_data_blob_equal(tctx, plato_latin_output2, plato_latin_utf16le,
-				       "round trip conversion of UTF16 latin charset greek to display charset UTF8 and back again failed");
+				       "round trip conversion of UTF16 latin charset greek to UTF8 and back again failed");
 	torture_assert_int_equal(tctx,
 				 strlen_m_ext_handle(iconv_handle,
 						     (const char *)plato_latin_output.data,
-						     CH_DISPLAY, CH_UTF16LE),
+						     CH_UTF8, CH_UTF16LE),
 				 plato_latin_output2.length / 2,
-				 "checking strlen_m_ext of round trip conversion of UTF16 latin charset greek to display charset UTF8 and back again");
+				 "checking strlen_m_ext of round trip conversion of UTF16 latin charset greek to UTF8 and back again");
 	return true;
 }
 
@@ -1182,7 +1182,7 @@ static bool test_gd_case_utf8_handle(struct torture_context *tctx)
 	char *gd_lower, *gd_upper;
 	talloc_steal(tctx, gd_utf8.data);
 
-	iconv_handle = get_iconv_testing_handle(tctx, "ASCII", "UTF8", "UTF8");
+	iconv_handle = get_iconv_testing_handle(tctx, "ASCII", "UTF8");
 	torture_assert(tctx, iconv_handle, "getting utf8 iconv handle");
 
 	torture_assert(tctx,
@@ -1245,7 +1245,7 @@ static bool test_gd_case_cp850_handle(struct torture_context *tctx)
 	char *gd_lower, *gd_upper;
 	talloc_steal(tctx, gd_cp850.data);
 
-	iconv_handle = get_iconv_testing_handle(tctx, "ASCII", "CP850", "CP850");
+	iconv_handle = get_iconv_testing_handle(tctx, "ASCII", "CP850");
 	torture_assert(tctx, iconv_handle, "getting cp850 iconv handle");
 
 	torture_assert(tctx,
@@ -1306,7 +1306,7 @@ static bool test_plato_case_utf8_handle(struct torture_context *tctx)
 	char *plato_lower, *plato_upper;
 	talloc_steal(tctx, plato_utf8.data);
 
-	iconv_handle = get_iconv_testing_handle(tctx, "ASCII", "UTF8", "UTF8");
+	iconv_handle = get_iconv_testing_handle(tctx, "ASCII", "UTF8");
 	torture_assert(tctx, iconv_handle, "getting utf8 iconv handle");
 
 	torture_assert(tctx,
diff --git a/lib/util/charset/util_str.c b/lib/util/charset/util_str.c
index 80e5bde354f..688ab5a0a1c 100644
--- a/lib/util/charset/util_str.c
+++ b/lib/util/charset/util_str.c
@@ -169,7 +169,6 @@ _PUBLIC_ size_t strlen_m_ext_handle(struct smb_iconv_handle *ic,
 	switch (dst_charset) {
 	case CH_DOS:
 	case CH_UNIX:
-	case CH_DISPLAY:
 		smb_panic("cannot call strlen_m_ext() with a variable dest charset (must be UTF16* or UTF8)");
 	default:
 		break;
diff --git a/lib/util/dprintf.c b/lib/util/dprintf.c
index 376eb4c75e4..90ca36c1ae5 100644
--- a/lib/util/dprintf.c
+++ b/lib/util/dprintf.c
@@ -36,40 +36,7 @@
 
 static int d_vfprintf(FILE *f, const char *format, va_list ap) 
 {
-	char *p, *p2;
-	int ret;
-	size_t clen;
-	bool cret;
-	va_list ap2;
-
-	va_copy(ap2, ap);
-	ret = vasprintf(&p, format, ap2);
-	va_end(ap2);
-
-	if (ret <= 0) return ret;
-
-	cret = convert_string_talloc(NULL, CH_UNIX, CH_DISPLAY, p, ret, (void **)&p2, &clen);
-        if (!cret) {
-		/* the string can't be converted - do the best we can,
-		   filling in non-printing chars with '?' */
-		int i;
-		for (i=0;i<ret;i++) {
-			if (isprint(p[i]) || isspace(p[i])) {
-				fwrite(p+i, 1, 1, f);
-			} else {
-				fwrite("?", 1, 1, f);
-			}
-		}
-		SAFE_FREE(p);
-		return ret;
-        }
-
-	/* good, its converted OK */
-	SAFE_FREE(p);
-	ret = fwrite(p2, 1, clen, f);
-	talloc_free(p2);
-
-	return ret;
+	return vfprintf(f, format, ap);
 }
 
 
diff --git a/librpc/ndr/ndr_string.c b/librpc/ndr/ndr_string.c
index 4510a71082f..840776fa3a9 100644
--- a/librpc/ndr/ndr_string.c
+++ b/librpc/ndr/ndr_string.c
@@ -645,7 +645,6 @@ _PUBLIC_ uint32_t ndr_charset_length(const void *var, charset_t chset)
 	case CH_UTF16MUNGED:
 	case CH_UTF8:
 		return strlen_m_ext_term((const char *)var, CH_UNIX, chset);
-	case CH_DISPLAY:
 	case CH_DOS:
 	case CH_UNIX:
 		return strlen((const char *)var)+1;
diff --git a/source3/build/charset.py b/source3/build/charset.py
index 03ba2493677..44852a6c52a 100644
--- a/source3/build/charset.py
+++ b/source3/build/charset.py
@@ -8,7 +8,6 @@ def CHECK_SAMBA3_CHARSET(conf, crossbuild=False):
     '''
     if conf.CHECK_ICONV(define='HAVE_NATIVE_ICONV'):
         default_dos_charset=False
-        default_display_charset=False
         default_unix_charset=False
 
         # check for default dos charset name
@@ -17,12 +16,6 @@ def CHECK_SAMBA3_CHARSET(conf, crossbuild=False):
                 default_dos_charset=charset
                 break
 
-        # check for default display charset name
-        for charset in ['ASCII', '646']:
-            if conf.CHECK_CHARSET_EXISTS(charset, headers='iconv.h'):
-                default_display_charset=charset
-                break
-
         # check for default unix charset name
         for charset in ['UTF-8', 'UTF8']:
             if conf.CHECK_CHARSET_EXISTS(charset, headers='iconv.h'):
@@ -37,16 +30,13 @@ def CHECK_SAMBA3_CHARSET(conf, crossbuild=False):
 	# match the results we get at runtime anyway.
 	if crossbuild:
 	    default_dos_charset="CP850"
-	    default_display_charset="ASCII"
 	    default_unix_charset="UTF-8"
             # TODO: this used to warn about the set charset on cross builds
 
         conf.DEFINE('DEFAULT_DOS_CHARSET', default_dos_charset, quote=True)
-        conf.DEFINE('DEFAULT_DISPLAY_CHARSET', default_display_charset, quote=True)
         conf.DEFINE('DEFAULT_UNIX_CHARSET', default_unix_charset, quote=True)
 
     else:
         conf.DEFINE('DEFAULT_DOS_CHARSET', "ASCII", quote=True)
-        conf.DEFINE('DEFAULT_DISPLAY_CHARSET', "ASCII", quote=True)
         conf.DEFINE('DEFAULT_UNIX_CHARSET', "UTF8", quote=True)
 
diff --git a/source3/configure.in b/source3/configure.in
index e8662da0e7c..e85d9f1f470 100644
--- a/source3/configure.in
+++ b/source3/configure.in
@@ -2693,7 +2693,6 @@ for i in $ICONV_LOOK_DIRS ; do
         export LDFLAGS LIBS CPPFLAGS
 
 	default_dos_charset=no
-	default_display_charset=no
 	default_unix_charset=no
 
 	# check for default dos charset name
@@ -2705,15 +2704,6 @@ for i in $ICONV_LOOK_DIRS ; do
 	    fi
 	done
 
-	# check for default display charset name
-	for j in ASCII 646 ; do
-	    rjs_CHARSET($j)
-	    default_display_charset="$ICONV_CHARSET"
-	    if test x"$default_display_charset" = x"$j"; then
-		break
-	    fi
-	done
-
 	# check for default unix charset name
 	for j in UTF-8 UTF8 ; do
 	    rjs_CHARSET($j)
@@ -2725,15 +2715,12 @@ for i in $ICONV_LOOK_DIRS ; do
 
 	if test "$default_dos_charset" != "no" -a \
 		"$default_dos_charset" != "cross" -a \
-		"$default_display_charset" != "no" -a \
-		"$default_display_charset" != "cross" -a \
 		"$default_unix_charset" != "no" -a \
 		"$default_unix_charset" != "cross"
 	then
 		samba_cv_HAVE_NATIVE_ICONV=yes
 	else
 	    if test "$default_dos_charset" = "cross" -o \
-		     "$default_display_charset" = "cross" -o \
 		     "$default_unix_charset" = "cross"
 	    then
 		    samba_cv_HAVE_NATIVE_ICONV=cross
@@ -2750,11 +2737,10 @@ for i in $ICONV_LOOK_DIRS ; do
 	# match the results we get at runtime anyway.
 	if test x"$samba_cv_HAVE_NATIVE_ICONV" = x"cross" ; then
 	    default_dos_charset="CP850"
-	    default_display_charset="ASCII"
 	    default_unix_charset="UTF-8"
 	    samba_cv_HAVE_NATIVE_ICONV=yes
 	    AC_MSG_WARN(assuming the libiconv in $iconv_current_LDFLAGS can convert)
-	    AC_MSG_WARN([$default_dos_charset, $default_display_charset and $default_unix_charset to UCS-16LE])
+	    AC_MSG_WARN([$default_dos_charset and $default_unix_charset to UCS-16LE])
 	fi
 
         if test x"$samba_cv_HAVE_NATIVE_ICONV" = x"yes" ; then
@@ -2773,12 +2759,10 @@ for i in $ICONV_LOOK_DIRS ; do
 
 	    # Turn the #defines into string literals
 	    default_dos_charset="\"$default_dos_charset\""
-	    default_display_charset="\"$default_display_charset\""
 	    default_unix_charset="\"$default_unix_charset\""
 
 	    AC_DEFINE(HAVE_NATIVE_ICONV,1,[Whether to use native iconv])
 	    AC_DEFINE_UNQUOTED(DEFAULT_DOS_CHARSET,$default_dos_charset,[Default dos charset name])
-	    AC_DEFINE_UNQUOTED(DEFAULT_DISPLAY_CHARSET,$default_display_charset,[Default display charset name])
 	    AC_DEFINE_UNQUOTED(DEFAULT_UNIX_CHARSET,$default_unix_charset,[Default unix charset name])
 
            break
@@ -2800,7 +2784,6 @@ if test x"$ICONV_FOUND" = x"no" -o x"$samba_cv_HAVE_NATIVE_ICONV" != x"yes" ; th
     AC_MSG_WARN([Sufficient support for iconv function was not found.
     Install libiconv from http://freshmeat.net/projects/libiconv/ for better charset compatibility!])
    AC_DEFINE_UNQUOTED(DEFAULT_DOS_CHARSET,"ASCII",[Default dos charset name])
-   AC_DEFINE_UNQUOTED(DEFAULT_DISPLAY_CHARSET,"ASCII",[Default display charset name])
    AC_DEFINE_UNQUOTED(DEFAULT_UNIX_CHARSET,"UTF8",[Default unix charset name])
 fi
 
diff --git a/source3/include/proto.h b/source3/include/proto.h
index ef8be4f9878..31c75189fc1 100644
--- a/source3/include/proto.h
+++ b/source3/include/proto.h
@@ -1174,7 +1174,6 @@ NTSTATUS change_trust_account_password( const char *domain, const char *remote_m
 const char *lp_smb_ports(void);
 const char *lp_dos_charset(void);
 const char *lp_unix_charset(void);
-const char *lp_display_charset(void);
 char *lp_logfile(void);
 char *lp_configfile(void);
 const char *lp_smb_passwd_file(void);
diff --git a/source3/param/loadparm.c b/source3/param/loadparm.c
index 16353738277..18fdc75834c 100644
--- a/source3/param/loadparm.c
+++ b/source3/param/loadparm.c
@@ -130,7 +130,6 @@ struct global {
 	char *smb_ports;
 	char *dos_charset;
 	char *unix_charset;
-	char *display_charset;
 	char *szPrintcapname;
 	char *szAddPortCommand;
 	char *szEnumPortsCommand;
@@ -970,15 +969,6 @@ static struct parm_struct parm_table[] = {
 		.flags		= FLAG_ADVANCED
 	},
 	{
-		.label		= "display charset",
-		.type		= P_STRING,
-		.p_class	= P_GLOBAL,
-		.ptr		= &Globals.display_charset,
-		.special	= handle_charset,
-		.enum_list	= NULL,
-		.flags		= FLAG_ADVANCED
-	},
-	{
 		.label		= "comment",
 		.type		= P_STRING,
 		.p_class	= P_LOCAL,
@@ -5186,14 +5176,6 @@ static void init_globals(bool reinit_globals)
 	/* using UTF8 by default allows us to support all chars */
 	string_set(&Globals.unix_charset, DEFAULT_UNIX_CHARSET);
 
-#if defined(HAVE_NL_LANGINFO) && defined(CODESET)
-	/* If the system supports nl_langinfo(), try to grab the value
-	   from the user's locale */
-	string_set(&Globals.display_charset, "LOCALE");
-#else
-	string_set(&Globals.display_charset, DEFAULT_DISPLAY_CHARSET);
-#endif
-
 	/* Use codepage 850 as a default for the dos character set */
 	string_set(&Globals.dos_charset, DEFAULT_DOS_CHARSET);
 
@@ -5556,7 +5538,6 @@ static char *lp_string(const char *s)
 FN_GLOBAL_CONST_STRING(lp_smb_ports, smb_ports)
 FN_GLOBAL_CONST_STRING(lp_dos_charset, dos_charset)
 FN_GLOBAL_CONST_STRING(lp_unix_charset, unix_charset)
-FN_GLOBAL_CONST_STRING(lp_display_charset, display_charset)
 FN_GLOBAL_STRING(lp_logfile, szLogFile)
 FN_GLOBAL_STRING(lp_configfile, szConfigFile)
 FN_GLOBAL_CONST_STRING(lp_smb_passwd_file, szSMBPasswdFile)
@@ -7507,7 +7488,7 @@ bool lp_file_list_changed(void)
 static void init_iconv(void)
 {
 	global_iconv_handle = smb_iconv_handle_reinit(NULL, lp_dos_charset(),
-						      lp_unix_charset(), lp_display_charset(),
+						      lp_unix_charset(),
 						      true, global_iconv_handle);
 }
 
diff --git a/source3/param/loadparm_ctx.c b/source3/param/loadparm_ctx.c
index 33e854d6e9e..e80f6f18444 100644
--- a/source3/param/loadparm_ctx.c
+++ b/source3/param/loadparm_ctx.c
@@ -41,7 +41,6 @@ static const struct loadparm_s3_context s3_fns =
 
 	.dos_charset = lp_dos_charset,
 	.unix_charset = lp_unix_charset,
-	.display_charset = lp_display_charset,
 
 	.realm = lp_realm,
 	.dnsdomain = lp_dnsdomain,
diff --git a/source4/param/loadparm.c b/source4/param/loadparm.c
index 67a782ded02..4ad555626a4 100644
--- a/source4/param/loadparm.c
+++ b/source4/param/loadparm.c
@@ -209,7 +209,6 @@ static struct parm_struct parm_table[] = {
 	{"dos charset", P_STRING, P_GLOBAL, GLOBAL_VAR(dos_charset), NULL, NULL},
 	{"unix charset", P_STRING, P_GLOBAL, GLOBAL_VAR(unix_charset), NULL, NULL},
 	{"ncalrpc dir", P_STRING, P_GLOBAL, GLOBAL_VAR(ncalrpc_dir), NULL, NULL},
-	{"display charset", P_STRING, P_GLOBAL, GLOBAL_VAR(display_charset), NULL, NULL},
 	{"comment", P_STRING, P_LOCAL, LOCAL_VAR(comment), NULL, NULL},
 	{"path", P_STRING, P_LOCAL, LOCAL_VAR(szPath), NULL, NULL},
 	{"directory", P_STRING, P_LOCAL, LOCAL_VAR(szPath), NULL, NULL},
@@ -572,7 +571,6 @@ FN_GLOBAL_STRING(lockdir, szLockDir)
 FN_GLOBAL_STRING(ncalrpc_dir, ncalrpc_dir)
 FN_GLOBAL_STRING(dos_charset, dos_charset)
 FN_GLOBAL_STRING(unix_charset, unix_charset)
-FN_GLOBAL_STRING(display_charset, display_charset)
 FN_GLOBAL_STRING(piddir, szPidDir)
 FN_GLOBAL_LIST(rndc_command, szRNDCCommand)
 FN_GLOBAL_LIST(dns_update_command, szDNSUpdateCommand)
diff --git a/source4/param/util.c b/source4/param/util.c
index 139a8acc74f..b1a7a571e65 100644
--- a/source4/param/util.c
+++ b/source4/param/util.c
@@ -296,7 +296,6 @@ struct smb_iconv_handle *smb_iconv_handle_reinit_lp(TALLOC_CTX *mem_ctx,
 {
 	return smb_iconv_handle_reinit(mem_ctx, lpcfg_dos_charset(lp_ctx),
 					    lpcfg_unix_charset(lp_ctx),
-					    lpcfg_display_charset(lp_ctx),
 					    lpcfg_parm_bool(lp_ctx, NULL, "iconv", "native", true),
 					    old_ic);
 }