Finish removal of iconv_convenience in public API's.

40 files changed, 199 insertions, 278 deletions

diff --git a/source4/torture/auth/pac.c b/source4/torture/auth/pac.c
index 182478a465..2223f39161 100644
--- a/source4/torture/auth/pac.c
+++ b/source4/torture/auth/pac.c
@@ -114,7 +114,6 @@ static bool torture_pac_self_check(struct torture_context *tctx)
 
 	/* OK, go ahead and make a PAC */
 	ret = kerberos_create_pac(mem_ctx, 
-				  lp_iconv_convenience(tctx->lp_ctx),
 				  server_info, 
 				  smb_krb5_context->krb5_context,  
 				  &krbtgt_keyblock,
@@ -141,7 +140,6 @@ static bool torture_pac_self_check(struct torture_context *tctx)
 
 	/* Now check that we can read it back (using full decode and validate) */
 	nt_status = kerberos_decode_pac(mem_ctx, 
-					lp_iconv_convenience(tctx->lp_ctx),
 					&pac_data,
 					tmp_blob,
 					smb_krb5_context->krb5_context,
@@ -165,7 +163,6 @@ static bool torture_pac_self_check(struct torture_context *tctx)
 
 	/* Now check we can read it back (using Heimdal's pac parsing) */
 	nt_status = kerberos_pac_blob_to_server_info(mem_ctx, 
-						     lp_iconv_convenience(tctx->lp_ctx),
 						     tmp_blob, 
 						     smb_krb5_context->krb5_context,
 						     &server_info_out);
@@ -189,7 +186,6 @@ static bool torture_pac_self_check(struct torture_context *tctx)
 
 	/* Now check that we can read it back (yet again) */
 	nt_status = kerberos_pac_logon_info(mem_ctx, 
-					    lp_iconv_convenience(tctx->lp_ctx),
 					    &logon_info,
 					    tmp_blob,
 					    smb_krb5_context->krb5_context,
@@ -409,7 +405,6 @@ static bool torture_pac_saved_check(struct torture_context *tctx)
 
 	/* Decode and verify the signaure on the PAC */
 	nt_status = kerberos_decode_pac(mem_ctx, 
-					lp_iconv_convenience(tctx->lp_ctx),
 					&pac_data,
 					tmp_blob,
 					smb_krb5_context->krb5_context,
@@ -430,7 +425,6 @@ static bool torture_pac_saved_check(struct torture_context *tctx)
 
 	/* Now check we can read it back (using Heimdal's pac parsing) */
 	nt_status = kerberos_pac_blob_to_server_info(mem_ctx, 
-						     lp_iconv_convenience(tctx->lp_ctx),
 						     tmp_blob, 
 						     smb_krb5_context->krb5_context,
 						     &server_info_out);
@@ -468,7 +462,6 @@ static bool torture_pac_saved_check(struct torture_context *tctx)
 
 	/* Parse the PAC again, for the logon info this time (using Samba4's parsing) */
 	nt_status = kerberos_pac_logon_info(mem_ctx, 
-					    lp_iconv_convenience(tctx->lp_ctx),
 					    &logon_info,
 					    tmp_blob,
 					    smb_krb5_context->krb5_context,
@@ -533,7 +526,6 @@ static bool torture_pac_saved_check(struct torture_context *tctx)
 	}
 
 	ret = kerberos_encode_pac(mem_ctx, 
-				  lp_iconv_convenience(tctx->lp_ctx),
 				  pac_data,
 				  smb_krb5_context->krb5_context,
 				  krbtgt_keyblock_p,
@@ -585,7 +577,6 @@ static bool torture_pac_saved_check(struct torture_context *tctx)
 	}
 
 	ret = kerberos_create_pac(mem_ctx, 
-				  lp_iconv_convenience(tctx->lp_ctx),
 				  server_info_out,
 				  smb_krb5_context->krb5_context,
 				  krbtgt_keyblock_p,
@@ -611,7 +602,7 @@ static bool torture_pac_saved_check(struct torture_context *tctx)
 	 */
 	if (tmp_blob.length != validate_blob.length) {
 		ndr_err = ndr_pull_struct_blob(&validate_blob, mem_ctx, 
-					       lp_iconv_convenience(tctx->lp_ctx), &pac_data2,
+					       &pac_data2,
 					       (ndr_pull_flags_fn_t)ndr_pull_PAC_DATA);
 		nt_status = ndr_map_error2ntstatus(ndr_err);
 		torture_assert_ntstatus_ok(tctx, nt_status, "can't parse the PAC");
@@ -633,7 +624,7 @@ static bool torture_pac_saved_check(struct torture_context *tctx)
 
 	if (memcmp(tmp_blob.data, validate_blob.data, tmp_blob.length) != 0) {
 		ndr_err = ndr_pull_struct_blob(&validate_blob, mem_ctx, 
-					       lp_iconv_convenience(tctx->lp_ctx), &pac_data2,
+					       &pac_data2,
 					       (ndr_pull_flags_fn_t)ndr_pull_PAC_DATA);
 		nt_status = ndr_map_error2ntstatus(ndr_err);
 		torture_assert_ntstatus_ok(tctx, nt_status, "can't parse the PAC");
@@ -659,7 +650,6 @@ static bool torture_pac_saved_check(struct torture_context *tctx)
 
 	/* Break the auth time, to ensure we check this vital detail (not setting this caused all the pain in the first place... */
 	nt_status = kerberos_decode_pac(mem_ctx, 
-					lp_iconv_convenience(tctx->lp_ctx),
 					&pac_data,
 					tmp_blob,
 					smb_krb5_context->krb5_context,
@@ -697,7 +687,6 @@ static bool torture_pac_saved_check(struct torture_context *tctx)
 	}
 
 	nt_status = kerberos_decode_pac(mem_ctx, 
-					lp_iconv_convenience(tctx->lp_ctx),
 					&pac_data,
 					tmp_blob,
 					smb_krb5_context->krb5_context,
@@ -717,7 +706,6 @@ static bool torture_pac_saved_check(struct torture_context *tctx)
 	tmp_blob.data[tmp_blob.length - 2]++;
 
 	nt_status = kerberos_decode_pac(mem_ctx, 
-					lp_iconv_convenience(tctx->lp_ctx),
 					&pac_data,
 					tmp_blob,
 					smb_krb5_context->krb5_context,
diff --git a/source4/torture/basic/base.c b/source4/torture/basic/base.c
index 309a394476..b2d523283a 100644
--- a/source4/torture/basic/base.c
+++ b/source4/torture/basic/base.c
@@ -55,7 +55,6 @@ static struct smbcli_state *open_nbt_connection(struct torture_context *tctx)
 
 	if (!smbcli_socket_connect(cli, host, lp_smb_ports(tctx->lp_ctx), tctx->ev,
 				   lp_resolve_context(tctx->lp_ctx), &options, 
-				   lp_iconv_convenience(tctx->lp_ctx),
                    lp_socket_options(tctx->lp_ctx))) {
 		torture_comment(tctx, "Failed to connect with %s\n", host);
 		goto failed;
diff --git a/source4/torture/basic/scanner.c b/source4/torture/basic/scanner.c
index 37c1f43c39..a4d8674db9 100644
--- a/source4/torture/basic/scanner.c
+++ b/source4/torture/basic/scanner.c
@@ -435,8 +435,7 @@ static NTSTATUS try_nttrans_len(struct smbcli_state *cli,
 /****************************************************************************
 check for existance of a nttrans call
 ****************************************************************************/
-static bool scan_nttrans(struct smb_iconv_convenience *iconv_convenience,
-			 struct smbcli_state *cli, int op, int level,
+static bool scan_nttrans(struct smbcli_state *cli, int op, int level,
 			int fnum, int dnum, const char *fname)
 {
 	int data_len = 0;
@@ -546,7 +545,6 @@ bool torture_nttrans_scan(struct torture_context *torture,
 {
 	int op, level;
 	const char *fname = "\\scanner.dat";
-	struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(torture->lp_ctx);
 	int fnum, dnum;
 
 	fnum = smbcli_open(cli->tree, fname, O_RDWR | O_CREAT | O_TRUNC, 
@@ -556,18 +554,15 @@ bool torture_nttrans_scan(struct torture_context *torture,
 	for (op=OP_MIN; op<=OP_MAX; op++) {
 		printf("Scanning op=%d\n", op);
 		for (level = 0; level <= 50; level++) {
-			scan_nttrans(iconv_convenience,
-				     cli, op, level, fnum, dnum, fname);
+			scan_nttrans(cli, op, level, fnum, dnum, fname);
 		}
 
 		for (level = 0x100; level <= 0x130; level++) {
-			scan_nttrans(iconv_convenience,
-				     cli, op, level, fnum, dnum, fname);
+			scan_nttrans(cli, op, level, fnum, dnum, fname);
 		}
 
 		for (level = 1000; level < 1050; level++) {
-			scan_nttrans(iconv_convenience,
-				     cli, op, level, fnum, dnum, fname);
+			scan_nttrans(cli, op, level, fnum, dnum, fname);
 		}
 	}
 
diff --git a/source4/torture/basic/utable.c b/source4/torture/basic/utable.c
index 158418a284..682bc0963e 100644
--- a/source4/torture/basic/utable.c
+++ b/source4/torture/basic/utable.c
@@ -49,9 +49,9 @@ bool torture_utable(struct torture_context *tctx,
 		SSVAL(c2, 0, c);
 		strncpy(fname, "\\utable\\x", sizeof(fname)-1);
 		p = fname+strlen(fname);
-		convert_string_convenience(lp_iconv_convenience(tctx->lp_ctx), CH_UTF16, CH_UNIX, 
+		len = convert_string(CH_UTF16, CH_UNIX, 
 				     c2, 2, 
-				     p, sizeof(fname)-strlen(fname), &len, false);
+				     p, sizeof(fname)-strlen(fname), false);
 		p[len] = 0;
 		strncat(fname,"_a_long_extension",sizeof(fname)-1);
 
@@ -97,7 +97,7 @@ bool torture_utable(struct torture_context *tctx,
 }
 
 
-static char *form_name(struct smb_iconv_convenience *iconv_convenience, int c)
+static char *form_name(int c)
 {
 	static char fname[256];
 	uint8_t c2[4];
@@ -108,9 +108,11 @@ static char *form_name(struct smb_iconv_convenience *iconv_convenience, int c)
 	p = fname+strlen(fname);
 	SSVAL(c2, 0, c);
 
-	convert_string_convenience(iconv_convenience, CH_UTF16, CH_UNIX, 
+	len = convert_string(CH_UTF16, CH_UNIX, 
 			     c2, 2, 
-			     p, sizeof(fname)-strlen(fname), &len, false);
+			     p, sizeof(fname)-strlen(fname), false);
+	if (len == -1)
+		return NULL;
 	p[len] = 0;
 	return fname;
 }
@@ -138,7 +140,7 @@ bool torture_casetable(struct torture_context *tctx,
 
 		torture_comment(tctx, "%04x (%c)\n", c, isprint(c)?c:'.');
 
-		fname = form_name(lp_iconv_convenience(tctx->lp_ctx), c);
+		fname = form_name(c);
 		fnum = smbcli_nt_create_full(cli->tree, fname, 0,
 #if 0
 					     SEC_RIGHT_MAXIMUM_ALLOWED, 
diff --git a/source4/torture/drs/unit/prefixmap_tests.c b/source4/torture/drs/unit/prefixmap_tests.c
index 4282e26a6c..a4521eb675 100644
--- a/source4/torture/drs/unit/prefixmap_tests.c
+++ b/source4/torture/drs/unit/prefixmap_tests.c
@@ -500,7 +500,7 @@ static bool torture_drs_unit_pfm_to_from_ldb_val(struct torture_context *tctx, s
 	mem_ctx = talloc_new(tctx);
 	torture_assert(tctx, mem_ctx, "Unexpected: Have no memory!");
 
-	schema = dsdb_new_schema(mem_ctx, lp_iconv_convenience(tctx->lp_ctx));
+	schema = dsdb_new_schema(mem_ctx);
 	torture_assert(tctx, schema, "Unexpected: failed to allocate schema object");
 
 	/* set priv->pfm_full as prefixMap for new schema object */
@@ -552,7 +552,7 @@ static bool torture_drs_unit_pfm_read_write_ldb(struct torture_context *tctx, st
 	torture_assert(tctx, mem_ctx, "Unexpected: Have no memory!");
 
 	/* makeup a dsdb_schema to test with */
-	schema = dsdb_new_schema(mem_ctx, lp_iconv_convenience(tctx->lp_ctx));
+	schema = dsdb_new_schema(mem_ctx);
 	torture_assert(tctx, schema, "Unexpected: failed to allocate schema object");
 	/* set priv->pfm_full as prefixMap for new schema object */
 	schema->prefixmap = priv->pfm_full;
@@ -606,7 +606,7 @@ static bool torture_drs_unit_dsdb_create_prefix_mapping(struct torture_context *
 	torture_assert(tctx, mem_ctx, "Unexpected: Have no memory!");
 
 	/* makeup a dsdb_schema to test with */
-	schema = dsdb_new_schema(mem_ctx, lp_iconv_convenience(tctx->lp_ctx));
+	schema = dsdb_new_schema(mem_ctx);
 	torture_assert(tctx, schema, "Unexpected: failed to allocate schema object");
 	/* set priv->pfm_full as prefixMap for new schema object */
 	schema->schema_info = priv->schi_default_str;
diff --git a/source4/torture/drs/unit/schemainfo_tests.c b/source4/torture/drs/unit/schemainfo_tests.c
index f197b479e9..a69e8a80cc 100644
--- a/source4/torture/drs/unit/schemainfo_tests.c
+++ b/source4/torture/drs/unit/schemainfo_tests.c
@@ -513,7 +513,7 @@ static bool torture_drs_unit_schemainfo_setup(struct torture_context *tctx,
 	torture_assert(tctx, priv->ldb_module, "Not enough memory!");
 
 	/* create schema mockup object */
-	priv->schema = dsdb_new_schema(priv, lp_iconv_convenience(tctx->lp_ctx));
+	priv->schema = dsdb_new_schema(priv);
 
 	/* pre-cache invocationId for samdb_ntds_invocation_id()
 	 * to work with our mock ldb */
diff --git a/source4/torture/gentest.c b/source4/torture/gentest.c
index 4b7128f3ab..10a1370b9d 100644
--- a/source4/torture/gentest.c
+++ b/source4/torture/gentest.c
@@ -247,7 +247,6 @@ static bool connect_servers(struct tevent_context *ev,
 								     lp_resolve_context(lp_ctx), ev,
 								     &smb_options,
 								     &smb_session_options,
-									 lp_iconv_convenience(lp_ctx),
 									 lp_gensec_settings(lp_ctx, lp_ctx));
 			}
 			if (!NT_STATUS_IS_OK(status)) {
diff --git a/source4/torture/ldap/cldap.c b/source4/torture/ldap/cldap.c
index 05af0a6403..73bbcd15cb 100644
--- a/source4/torture/ldap/cldap.c
+++ b/source4/torture/ldap/cldap.c
@@ -45,7 +45,6 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 	struct netlogon_samlogon_response n1;
 	struct GUID guid;
 	int i;
-	struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(tctx->lp_ctx);
 	struct tsocket_address *dest_addr;
 	int ret;
 
@@ -69,7 +68,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 
 	printf("Trying without any attributes\n");
 	search = empty_search;
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 
 	n1 = search.out.netlogon;
@@ -82,7 +81,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 	for (i=0;i<256;i++) {
 		search.in.version = i;
 		printf("Trying netlogon level %d\n", i);
-		status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+		status = cldap_netlogon(cldap, tctx, &search);
 		CHECK_STATUS(status, NT_STATUS_OK);
 	}
 
@@ -90,42 +89,42 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 	for (i=0;i<31;i++) {
 		search.in.version = (1<<i);
 		printf("Trying netlogon level 0x%x\n", i);
-		status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+		status = cldap_netlogon(cldap, tctx, &search);
 		CHECK_STATUS(status, NT_STATUS_OK);
 	}
 
 	search.in.version = NETLOGON_NT_VERSION_5|NETLOGON_NT_VERSION_5EX|NETLOGON_NT_VERSION_IP;
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 
 	printf("Trying with User=NULL\n");
 	search.in.user = NULL;
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
 
 	printf("Trying with User=Administrator\n");
 	search.in.user = "Administrator";
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
 
 	search.in.version = NETLOGON_NT_VERSION_5;
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 
 	printf("Trying with User=NULL\n");
 	search.in.user = NULL;
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
 
 	printf("Trying with User=Administrator\n");
 	search.in.user = "Administrator";
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
@@ -135,7 +134,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 	printf("Trying with a GUID\n");
 	search.in.realm       = NULL;
 	search.in.domain_guid = GUID_string(tctx, &n1.data.nt5_ex.domain_uuid);
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
 	CHECK_STRING(GUID_string(tctx, &search.out.netlogon.data.nt5_ex.domain_uuid), search.in.domain_guid);
@@ -144,13 +143,13 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 	guid = GUID_random();
 	search.in.user        = NULL;
 	search.in.domain_guid = GUID_string(tctx, &guid);
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_NOT_FOUND);
 
 	printf("Trying with a AAC\n");
 	search.in.acct_control = ACB_WSTRUST|ACB_SVRTRUST;
 	search.in.realm = n1.data.nt5_ex.dns_domain;
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
@@ -158,7 +157,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 	printf("Trying with a zero AAC\n");
 	search.in.acct_control = 0x0;
 	search.in.realm = n1.data.nt5_ex.dns_domain;
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
@@ -167,7 +166,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 	search.in.acct_control = 0x0;
 	search.in.user = "Administrator";
 	search.in.realm = n1.data.nt5_ex.dns_domain;
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "Administrator");
@@ -176,7 +175,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 	search.in.user = NULL;
 	search.in.acct_control = 0xFF00FF00;
 	search.in.realm = n1.data.nt5_ex.dns_domain;
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
@@ -184,7 +183,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 	printf("Trying with a user only\n");
 	search = empty_search;
 	search.in.user = "Administrator";
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
@@ -196,7 +195,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 
 	printf("Trying with just a bad username\n");
 	search.in.user = "___no_such_user___";
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
@@ -210,12 +209,12 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 	printf("Trying with just a bad domain\n");
 	search = empty_search;
 	search.in.realm = "___no_such_domain___";
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_NOT_FOUND);
 
 	printf("Trying with a incorrect domain and correct guid\n");
 	search.in.domain_guid = GUID_string(tctx, &n1.data.nt5_ex.domain_uuid);
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
@@ -228,7 +227,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 
 	printf("Trying with a incorrect domain and incorrect guid\n");
 	search.in.domain_guid = GUID_string(tctx, &guid);
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_NOT_FOUND);
 	CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
@@ -242,7 +241,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 	printf("Trying with a incorrect GUID and correct domain\n");
 	search.in.domain_guid = GUID_string(tctx, &guid);
 	search.in.realm = n1.data.nt5_ex.dns_domain;
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
@@ -255,7 +254,7 @@ static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
 
 	printf("Proof other results\n");
 	search.in.user = "Administrator";
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.forest, n1.data.nt5_ex.dns_domain);
 	CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
@@ -279,7 +278,6 @@ static bool test_cldap_netlogon_flags(struct torture_context *tctx,
 	struct cldap_netlogon search;
 	struct netlogon_samlogon_response n1;
 	uint32_t server_type;
-	struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(tctx->lp_ctx);
 	struct tsocket_address *dest_addr;
 	int ret;
 
@@ -302,7 +300,7 @@ static bool test_cldap_netlogon_flags(struct torture_context *tctx,
 	search.in.version = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
 	search.in.map_response = true;
 
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 
 	n1 = search.out.netlogon;
@@ -399,7 +397,6 @@ static bool test_cldap_netlogon_flag_ds_dns_forest(struct torture_context *tctx,
 	struct cldap_netlogon search;
 	uint32_t server_type;
 	struct netlogon_samlogon_response n1;
-	struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(tctx->lp_ctx);
 	bool result = true;
 	struct tsocket_address *dest_addr;
 	int ret;
@@ -423,7 +420,7 @@ static bool test_cldap_netlogon_flag_ds_dns_forest(struct torture_context *tctx,
 	search.in.version = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
 	search.in.map_response = true;
 
-	status = cldap_netlogon(cldap, iconv_convenience, tctx, &search);
+	status = cldap_netlogon(cldap, tctx, &search);
 	CHECK_STATUS(status, NT_STATUS_OK);
 
 	n1 = search.out.netlogon;
diff --git a/source4/torture/ldap/cldapbench.c b/source4/torture/ldap/cldapbench.c
index a63c78944b..27c0746e9a 100644
--- a/source4/torture/ldap/cldapbench.c
+++ b/source4/torture/ldap/cldapbench.c
@@ -40,9 +40,7 @@ static void request_netlogon_handler(struct tevent_req *req)
 	NTSTATUS status;
 	TALLOC_CTX *tmp_ctx = talloc_new(NULL);
 	io.in.version = 6;
-	status = cldap_netlogon_recv(req,
-				     lp_iconv_convenience(state->tctx->lp_ctx),
-				     tmp_ctx, &io);
+	status = cldap_netlogon_recv(req, tmp_ctx, &io);
 	talloc_free(req);
 	if (NT_STATUS_IS_OK(status)) {
 		state->pass_count++;
diff --git a/source4/torture/ldap/uptodatevector.c b/source4/torture/ldap/uptodatevector.c
index 0921cf779b..76eb45c5c1 100644
--- a/source4/torture/ldap/uptodatevector.c
+++ b/source4/torture/ldap/uptodatevector.c
@@ -65,7 +65,7 @@ static bool test_check_uptodatevector(struct torture_context *torture,
 	utdv_val1 = ldb_msg_find_ldb_val(r->msgs[0], "replUpToDateVector");
 	if (utdv_val1) {
 		ndr_err = ndr_pull_struct_blob_all(utdv_val1, torture, 
-						   lp_iconv_convenience(torture->lp_ctx), &utdv1,
+						   &utdv1,
 						   (ndr_pull_flags_fn_t)ndr_pull_replUpToDateVectorBlob);
 		if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 			return false;
@@ -111,7 +111,7 @@ static bool test_check_uptodatevector(struct torture_context *torture,
 		utdv_val = ldb_msg_find_ldb_val(r->msgs[0], "replUpToDateVector");
 		if (utdv_val) {
 			ndr_err = ndr_pull_struct_blob_all(utdv_val, torture, 
-							   lp_iconv_convenience(torture->lp_ctx), &utdv,
+							   &utdv,
 							   (ndr_pull_flags_fn_t)ndr_pull_replUpToDateVectorBlob);
 			if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 				return false;
diff --git a/source4/torture/libnet/libnet_BecomeDC.c b/source4/torture/libnet/libnet_BecomeDC.c
index dd9e173b54..b674e0eddb 100644
--- a/source4/torture/libnet/libnet_BecomeDC.c
+++ b/source4/torture/libnet/libnet_BecomeDC.c
@@ -398,7 +398,7 @@ static NTSTATUS test_become_dc_schema_chunk(void *private_data,
 	}
 
 	if (!s->schema) {
-		s->self_made_schema = dsdb_new_schema(s, lp_iconv_convenience(s->lp_ctx));
+		s->self_made_schema = dsdb_new_schema(s);
 
 		NT_STATUS_HAVE_NO_MEMORY(s->self_made_schema);
 
diff --git a/source4/torture/locktest.c b/source4/torture/locktest.c
index b3ee8fc28f..a09b54cfd6 100644
--- a/source4/torture/locktest.c
+++ b/source4/torture/locktest.c
@@ -167,7 +167,6 @@ static struct smbcli_state *connect_one(struct tevent_context *ev,
 						servers[snum], 
 						lp_resolve_context(lp_ctx),
 						ev, &options, &session_options,
-						lp_iconv_convenience(lp_ctx),
 						lp_gensec_settings(mem_ctx, lp_ctx));
 		if (!NT_STATUS_IS_OK(status)) {
 			sleep(2);
diff --git a/source4/torture/masktest.c b/source4/torture/masktest.c
index 0dd6a8f929..e61eb868a4 100644
--- a/source4/torture/masktest.c
+++ b/source4/torture/masktest.c
@@ -77,7 +77,6 @@ static struct smbcli_state *connect_one(struct resolve_context *resolve_ctx,
 					const char *socket_options,
 					struct smbcli_options *options,
 					struct smbcli_session_options *session_options,
-					struct smb_iconv_convenience *iconv_convenience,
 					struct gensec_settings *gensec_settings)
 {
 	struct smbcli_state *c;
@@ -99,7 +98,6 @@ static struct smbcli_state *connect_one(struct resolve_context *resolve_ctx,
 					socket_options,
 					cmdline_credentials, resolve_ctx, ev,
 					options, session_options,
-					iconv_convenience,
 					gensec_settings);
 
 	if (!NT_STATUS_IS_OK(status)) {
@@ -372,7 +370,6 @@ static void usage(poptContext pc)
 	cli = connect_one(lp_resolve_context(lp_ctx), ev, mem_ctx, share, 
 			  lp_smb_ports(lp_ctx), lp_socket_options(lp_ctx), 
 			  &options, &session_options,
-			  lp_iconv_convenience(lp_ctx),
 			  lp_gensec_settings(mem_ctx, lp_ctx));
 	if (!cli) {
 		DEBUG(0,("Failed to connect to %s\n", share));
diff --git a/source4/torture/nbt/dgram.c b/source4/torture/nbt/dgram.c
index 09aaa41c68..7d1199ec2a 100644
--- a/source4/torture/nbt/dgram.c
+++ b/source4/torture/nbt/dgram.c
@@ -64,8 +64,7 @@ static void netlogon_handler(struct dgram_mailslot_handler *dgmslot,
 static bool nbt_test_netlogon(struct torture_context *tctx)
 {
 	struct dgram_mailslot_handler *dgmslot;
-	struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev, 
-								 lp_iconv_convenience(tctx->lp_ctx));
+	struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev);
 	struct socket_address *dest;
 	const char *myaddress;
 	struct nbt_netlogon_packet logon;
@@ -155,8 +154,7 @@ static bool nbt_test_netlogon(struct torture_context *tctx)
 static bool nbt_test_netlogon2(struct torture_context *tctx)
 {
 	struct dgram_mailslot_handler *dgmslot;
-	struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev,
-								 lp_iconv_convenience(tctx->lp_ctx));
+	struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev);
 	struct socket_address *dest;
 	const char *myaddress;
 	struct nbt_netlogon_packet logon;
@@ -425,8 +423,7 @@ static bool nbt_test_netlogon2(struct torture_context *tctx)
 static bool nbt_test_ntlogon(struct torture_context *tctx)
 {
 	struct dgram_mailslot_handler *dgmslot;
-	struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev,
-								 lp_iconv_convenience(tctx->lp_ctx));
+	struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev);
 	struct socket_address *dest;
 	struct test_join *join_ctx;
 	const struct dom_sid *dom_sid;
diff --git a/source4/torture/nbt/nbt.c b/source4/torture/nbt/nbt.c
index aee0c54358..1dcfa563df 100644
--- a/source4/torture/nbt/nbt.c
+++ b/source4/torture/nbt/nbt.c
@@ -27,7 +27,7 @@
 
 struct nbt_name_socket *torture_init_nbt_socket(struct torture_context *tctx)
 {
-	return nbt_name_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
+	return nbt_name_socket_init(tctx, tctx->ev);
 }
 
 bool torture_nbt_get_name(struct torture_context *tctx, 
diff --git a/source4/torture/nbt/winsbench.c b/source4/torture/nbt/winsbench.c
index bea3d4f9cf..226f388f35 100644
--- a/source4/torture/nbt/winsbench.c
+++ b/source4/torture/nbt/winsbench.c
@@ -225,7 +225,7 @@ static void generate_request(struct nbt_name_socket *nbtsock, struct wins_state
 */
 static bool bench_wins(struct torture_context *tctx)
 {
-	struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
+	struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, tctx->ev);
 	int num_sent=0;
 	struct timeval tv = timeval_current();
 	bool ret = true;
diff --git a/source4/torture/nbt/winsreplication.c b/source4/torture/nbt/winsreplication.c
index 9a7be03199..b8152f79d6 100644
--- a/source4/torture/nbt/winsreplication.c
+++ b/source4/torture/nbt/winsreplication.c
@@ -102,8 +102,8 @@ static bool test_assoc_ctx1(struct torture_context *tctx)
 
 	torture_comment(tctx, "Test if assoc_ctx is only valid on the conection it was created on\n");
 
-	wrepl_socket1 = wrepl_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
-	wrepl_socket2 = wrepl_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
+	wrepl_socket1 = wrepl_socket_init(tctx, tctx->ev);
+	wrepl_socket2 = wrepl_socket_init(tctx, tctx->ev);
 
 	torture_comment(tctx, "Setup 2 wrepl connections\n");
 	status = wrepl_connect(wrepl_socket1, wrepl_best_ip(tctx->lp_ctx, address), address);
@@ -193,7 +193,7 @@ static bool test_assoc_ctx2(struct torture_context *tctx)
 
 	torture_comment(tctx, "Test if we always get back the same assoc_ctx\n");
 
-	wrepl_socket = wrepl_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
+	wrepl_socket = wrepl_socket_init(tctx, tctx->ev);
 	
 	torture_comment(tctx, "Setup wrepl connections\n");
 	status = wrepl_connect(wrepl_socket, wrepl_best_ip(tctx->lp_ctx, address), address);
@@ -262,7 +262,7 @@ static bool test_wins_replication(struct torture_context *tctx)
 
 	torture_comment(tctx, "Test one pull replication cycle\n");
 
-	wrepl_socket = wrepl_socket_init(tctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
+	wrepl_socket = wrepl_socket_init(tctx, tctx->ev);
 	
 	torture_comment(tctx, "Setup wrepl connections\n");
 	status = wrepl_connect(wrepl_socket, wrepl_best_ip(tctx->lp_ctx, address), address);
@@ -555,7 +555,7 @@ static struct test_wrepl_conflict_conn *test_create_conflict_ctx(
 	if (!ctx) return NULL;
 
 	ctx->address	= address;
-	ctx->pull	= wrepl_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
+	ctx->pull	= wrepl_socket_init(ctx, tctx->ev);
 	if (!ctx->pull) return NULL;
 
 	torture_comment(tctx, "Setup wrepl conflict pull connection\n");
@@ -612,7 +612,7 @@ static struct test_wrepl_conflict_conn *test_create_conflict_ctx(
 
 	talloc_free(pull_table.out.partners);
 
-	ctx->nbtsock = nbt_name_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
+	ctx->nbtsock = nbt_name_socket_init(ctx, tctx->ev);
 	if (!ctx->nbtsock) return NULL;
 
 	load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
@@ -630,7 +630,7 @@ static struct test_wrepl_conflict_conn *test_create_conflict_ctx(
 	status = socket_listen(ctx->nbtsock->sock, ctx->myaddr, 0, 0);
 	if (!NT_STATUS_IS_OK(status)) return NULL;
 
-	ctx->nbtsock_srv = nbt_name_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
+	ctx->nbtsock_srv = nbt_name_socket_init(ctx, tctx->ev);
 	if (!ctx->nbtsock_srv) return NULL;
 
 	/* Make a port 137 version of ctx->myaddr */
@@ -647,13 +647,13 @@ static struct test_wrepl_conflict_conn *test_create_conflict_ctx(
 	}
 
 	if (ctx->myaddr2 && ctx->nbtsock_srv) {
-		ctx->nbtsock2 = nbt_name_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
+		ctx->nbtsock2 = nbt_name_socket_init(ctx, tctx->ev);
 		if (!ctx->nbtsock2) return NULL;
 
 		status = socket_listen(ctx->nbtsock2->sock, ctx->myaddr2, 0, 0);
 		if (!NT_STATUS_IS_OK(status)) return NULL;
 
-		ctx->nbtsock_srv2 = nbt_name_socket_init(ctx, ctx->nbtsock_srv->event_ctx, lp_iconv_convenience(tctx->lp_ctx));
+		ctx->nbtsock_srv2 = nbt_name_socket_init(ctx, ctx->nbtsock_srv->event_ctx);
 		if (!ctx->nbtsock_srv2) return NULL;
 
 		/* Make a port 137 version of ctx->myaddr2 */
@@ -724,7 +724,7 @@ static bool test_wrepl_update_one(struct torture_context *tctx,
 	uint32_t assoc_ctx;
 	NTSTATUS status;
 
-	wrepl_socket = wrepl_socket_init(ctx, tctx->ev, lp_iconv_convenience(tctx->lp_ctx));
+	wrepl_socket = wrepl_socket_init(ctx, tctx->ev);
 
 	status = wrepl_connect(wrepl_socket, wrepl_best_ip(tctx->lp_ctx, ctx->address), ctx->address);
 	CHECK_STATUS(tctx, status, NT_STATUS_OK);
diff --git a/source4/torture/ndr/ndr.c b/source4/torture/ndr/ndr.c
index 24f5fba282..6068e108b5 100644
--- a/source4/torture/ndr/ndr.c
+++ b/source4/torture/ndr/ndr.c
@@ -38,7 +38,7 @@ static bool wrap_ndr_pull_test(struct torture_context *tctx,
 	bool (*check_fn) (struct torture_context *ctx, void *data) = test->fn;
 	const struct ndr_pull_test_data *data = (const struct ndr_pull_test_data *)test->data;
 	void *ds = talloc_zero_size(tctx, data->struct_size);
-	struct ndr_pull *ndr = ndr_pull_init_blob(&(data->data), tctx, lp_iconv_convenience(tctx->lp_ctx));
+	struct ndr_pull *ndr = ndr_pull_init_blob(&(data->data), tctx);
 
 	ndr->flags |= LIBNDR_FLAG_REF_ALLOC;
 
@@ -97,7 +97,7 @@ static bool test_check_string_terminator(struct torture_context *tctx)
 	/* Simple test */
 	blob = strhex_to_data_blob(tctx, "0000");
 	
-	ndr = ndr_pull_init_blob(&blob, mem_ctx, lp_iconv_convenience(tctx->lp_ctx));
+	ndr = ndr_pull_init_blob(&blob, mem_ctx);
 
 	torture_assert_ndr_success(tctx, ndr_check_string_terminator(ndr, 1, 2),
 				   "simple check_string_terminator test failed");
@@ -115,7 +115,7 @@ static bool test_check_string_terminator(struct torture_context *tctx)
 	talloc_free(ndr);
 
 	blob = strhex_to_data_blob(tctx, "11220000");
-	ndr = ndr_pull_init_blob(&blob, mem_ctx, lp_iconv_convenience(tctx->lp_ctx));
+	ndr = ndr_pull_init_blob(&blob, mem_ctx);
 
 	torture_assert_ndr_success(tctx,
 		ndr_check_string_terminator(ndr, 4, 1),
diff --git a/source4/torture/ntp/ntp_signd.c b/source4/torture/ntp/ntp_signd.c
index bf631f4445..9b4b9c3a4e 100644
--- a/source4/torture/ntp/ntp_signd.c
+++ b/source4/torture/ntp/ntp_signd.c
@@ -137,7 +137,6 @@ static bool test_ntp_signd(struct torture_context *tctx,
 	
 	ndr_err = ndr_push_struct_blob(&sign_req_blob,
 				       mem_ctx,
-				       NULL,
 				       &sign_req,
 				       (ndr_push_flags_fn_t)ndr_push_sign_request);
 	torture_assert(tctx,
@@ -246,7 +245,6 @@ static bool test_ntp_signd(struct torture_context *tctx,
 	torture_comment(tctx, "Validating the reply buffer\n");
 	ndr_err = ndr_pull_struct_blob_all(&signd_client->reply,
 					   mem_ctx,
-					   lp_iconv_convenience(tctx->lp_ctx),
 					   &signed_reply,
 					   (ndr_pull_flags_fn_t)ndr_pull_signed_reply);
 	torture_assert(tctx, NDR_ERR_CODE_IS_SUCCESS(ndr_err),
diff --git a/source4/torture/rap/printing.c b/source4/torture/rap/printing.c
index a8a30366cf..e2ef9663be 100644
--- a/source4/torture/rap/printing.c
+++ b/source4/torture/rap/printing.c
@@ -87,7 +87,7 @@ static bool test_netprintqenum(struct torture_context *tctx,
 			"Testing rap_NetPrintQEnum level %d\n", r.in.level);
 
 		torture_assert_ntstatus_ok(tctx,
-			smbcli_rap_netprintqenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+			smbcli_rap_netprintqenum(cli->tree, tctx, &r),
 			"smbcli_rap_netprintqenum failed");
 		torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 			"failed to enum printq");
@@ -116,7 +116,7 @@ static bool test_netprintqgetinfo(struct torture_context *tctx,
 	r_enum.in.bufsize = 8192;
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintqenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r_enum),
+		smbcli_rap_netprintqenum(cli->tree, tctx, &r_enum),
 		"failed to enum printq");
 	torture_assert_werr_ok(tctx, W_ERROR(r_enum.out.status),
 		"failed to enum printq");
@@ -133,7 +133,7 @@ static bool test_netprintqgetinfo(struct torture_context *tctx,
 				r.in.PrintQueueName, r.in.level);
 
 			torture_assert_ntstatus_ok(tctx,
-				smbcli_rap_netprintqgetinfo(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+				smbcli_rap_netprintqgetinfo(cli->tree, tctx, &r),
 				"smbcli_rap_netprintqgetinfo failed");
 
 			switch (r.in.level) {
@@ -158,7 +158,7 @@ static bool test_netprintjob_pause(struct torture_context *tctx,
 	torture_comment(tctx, "Testing rap_NetPrintJobPause(%d)\n", r.in.JobID);
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintjobpause(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintjobpause(cli->tree, tctx, &r),
 		"smbcli_rap_netprintjobpause failed");
 
 	return true;
@@ -175,7 +175,7 @@ static bool test_netprintjob_continue(struct torture_context *tctx,
 	torture_comment(tctx, "Testing rap_NetPrintJobContinue(%d)\n", r.in.JobID);
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintjobcontinue(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintjobcontinue(cli->tree, tctx, &r),
 		"smbcli_rap_netprintjobcontinue failed");
 
 	return true;
@@ -192,7 +192,7 @@ static bool test_netprintjob_delete(struct torture_context *tctx,
 	torture_comment(tctx, "Testing rap_NetPrintJobDelete(%d)\n", r.in.JobID);
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintjobdelete(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintjobdelete(cli->tree, tctx, &r),
 		"smbcli_rap_netprintjobdelete failed");
 
 	return true;
@@ -227,7 +227,7 @@ static bool test_netprintq_pause(struct torture_context *tctx,
 	torture_comment(tctx, "Testing rap_NetPrintQueuePause(%s)\n", r.in.PrintQueueName);
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintqueuepause(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintqueuepause(cli->tree, tctx, &r),
 		"smbcli_rap_netprintqueuepause failed");
 	torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 		"smbcli_rap_netprintqueuepause failed");
@@ -246,7 +246,7 @@ static bool test_netprintq_resume(struct torture_context *tctx,
 	torture_comment(tctx, "Testing rap_NetPrintQueueResume(%s)\n", r.in.PrintQueueName);
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintqueueresume(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintqueueresume(cli->tree, tctx, &r),
 		"smbcli_rap_netprintqueueresume failed");
 	torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 		"smbcli_rap_netprintqueueresume failed");
@@ -264,7 +264,7 @@ static bool test_netprintq(struct torture_context *tctx,
 	r.in.bufsize = 8192;
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintqenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintqenum(cli->tree, tctx, &r),
 		"failed to enum printq");
 	torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 		"failed to enum printq");
@@ -302,7 +302,7 @@ static bool test_netprintjobenum_args(struct torture_context *tctx,
 		"Testing rap_NetPrintJobEnum(%s) level %d\n", r.in.PrintQueueName, r.in.level);
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintjobenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintjobenum(cli->tree, tctx, &r),
 		"smbcli_rap_netprintjobenum failed");
 
 	if (count_p) {
@@ -334,7 +334,7 @@ static bool test_netprintjobenum_one(struct torture_context *tctx,
 			"Testing rap_NetPrintJobEnum(%s) level %d\n", r.in.PrintQueueName, r.in.level);
 
 		torture_assert_ntstatus_ok(tctx,
-			smbcli_rap_netprintjobenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+			smbcli_rap_netprintjobenum(cli->tree, tctx, &r),
 			"smbcli_rap_netprintjobenum failed");
 	}
 
@@ -359,7 +359,7 @@ static bool test_netprintjobgetinfo_byid(struct torture_context *tctx,
 		torture_comment(tctx, "Testing rap_NetPrintJobGetInfo(%d) level %d\n", r.in.JobID, r.in.level);
 
 		torture_assert_ntstatus_ok(tctx,
-			smbcli_rap_netprintjobgetinfo(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+			smbcli_rap_netprintjobgetinfo(cli->tree, tctx, &r),
 			"smbcli_rap_netprintjobgetinfo failed");
 	}
 
@@ -387,7 +387,7 @@ static bool test_netprintjobsetinfo_byid(struct torture_context *tctx,
 		torture_comment(tctx, "Testing rap_NetPrintJobSetInfo(%d) level %d\n", r.in.JobID, r.in.level);
 
 		torture_assert_ntstatus_ok(tctx,
-			smbcli_rap_netprintjobsetinfo(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+			smbcli_rap_netprintjobsetinfo(cli->tree, tctx, &r),
 			"smbcli_rap_netprintjobsetinfo failed");
 	}
 
@@ -407,7 +407,7 @@ static bool test_netprintjobgetinfo_byqueue(struct torture_context *tctx,
 	r.in.level = 0;
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintjobenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintjobenum(cli->tree, tctx, &r),
 		"failed to enumerate jobs");
 
 	for (i=0; i < r.out.count; i++) {
@@ -432,7 +432,7 @@ static bool test_netprintjobsetinfo_byqueue(struct torture_context *tctx,
 	r.in.level = 0;
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintjobenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintjobenum(cli->tree, tctx, &r),
 		"failed to enumerate jobs");
 
 	for (i=0; i < r.out.count; i++) {
@@ -455,7 +455,7 @@ static bool test_netprintjobenum(struct torture_context *tctx,
 	r.in.bufsize = 8192;
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintqenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintqenum(cli->tree, tctx, &r),
 		"failed to enum printq");
 	torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 		"failed to enum printq");
@@ -482,7 +482,7 @@ static bool test_netprintjobgetinfo(struct torture_context *tctx,
 	r.in.bufsize = 8192;
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintqenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintqenum(cli->tree, tctx, &r),
 		"failed to enum printq");
 	torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 		"failed to enum printq");
@@ -509,7 +509,7 @@ static bool test_netprintjobsetinfo(struct torture_context *tctx,
 	r.in.bufsize = 8192;
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintqenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintqenum(cli->tree, tctx, &r),
 		"failed to enum printq");
 	torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 		"failed to enum printq");
@@ -542,7 +542,7 @@ static bool test_netprintdestenum(struct torture_context *tctx,
 			"Testing rap_NetPrintDestEnum level %d\n", r.in.level);
 
 		torture_assert_ntstatus_ok(tctx,
-			smbcli_rap_netprintdestenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+			smbcli_rap_netprintdestenum(cli->tree, tctx, &r),
 			"smbcli_rap_netprintdestenum failed");
 	}
 
@@ -567,7 +567,7 @@ static bool test_netprintdestgetinfo_bydest(struct torture_context *tctx,
 			"Testing rap_NetPrintDestGetInfo(%s) level %d\n", r.in.PrintDestName, r.in.level);
 
 		torture_assert_ntstatus_ok(tctx,
-			smbcli_rap_netprintdestgetinfo(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+			smbcli_rap_netprintdestgetinfo(cli->tree, tctx, &r),
 			"smbcli_rap_netprintdestgetinfo failed");
 	}
 
@@ -588,7 +588,7 @@ static bool test_netprintdestgetinfo(struct torture_context *tctx,
 		"Testing rap_NetPrintDestEnum level %d\n", r.in.level);
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintdestenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintdestenum(cli->tree, tctx, &r),
 		"smbcli_rap_netprintdestenum failed");
 
 	for (i=0; i < r.out.count; i++) {
@@ -612,7 +612,7 @@ static bool test_rap_print(struct torture_context *tctx,
 	r.in.bufsize = 8192;
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netprintqenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netprintqenum(cli->tree, tctx, &r),
 		"failed to enum printq");
 	torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 		"failed to enum printq");
diff --git a/source4/torture/rap/rap.c b/source4/torture/rap/rap.c
index 5412c1b52d..37edd20ed7 100644
--- a/source4/torture/rap/rap.c
+++ b/source4/torture/rap/rap.c
@@ -82,7 +82,7 @@ struct rap_call {
 
 #define RAPNDR_FLAGS (LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 
-static struct rap_call *new_rap_cli_call(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint16_t callno)
+static struct rap_call *new_rap_cli_call(TALLOC_CTX *mem_ctx, uint16_t callno)
 {
 	struct rap_call *call;
 
@@ -98,10 +98,10 @@ static struct rap_call *new_rap_cli_call(TALLOC_CTX *mem_ctx, struct smb_iconv_c
 	call->datadesc = NULL;
 	call->auxdatadesc = NULL;
 
-	call->ndr_push_param = ndr_push_init_ctx(mem_ctx, iconv_convenience);
+	call->ndr_push_param = ndr_push_init_ctx(mem_ctx);
 	call->ndr_push_param->flags = RAPNDR_FLAGS;
 
-	call->ndr_push_data = ndr_push_init_ctx(mem_ctx, iconv_convenience);
+	call->ndr_push_data = ndr_push_init_ctx(mem_ctx);
 	call->ndr_push_data->flags = RAPNDR_FLAGS;
 
 	return call;
@@ -218,7 +218,6 @@ static NTSTATUS rap_pull_string(TALLOC_CTX *mem_ctx, struct ndr_pull *ndr,
 }
 
 static NTSTATUS rap_cli_do_call(struct smbcli_tree *tree, 
-				struct smb_iconv_convenience *iconv_convenience,
 				struct rap_call *call)
 {
 	NTSTATUS result;
@@ -228,7 +227,7 @@ static NTSTATUS rap_cli_do_call(struct smbcli_tree *tree,
 	struct ndr_push *data;
 	struct smb_trans2 trans;
 
-	params = ndr_push_init_ctx(call, iconv_convenience);
+	params = ndr_push_init_ctx(call);
 
 	if (params == NULL)
 		return NT_STATUS_NO_MEMORY;
@@ -276,12 +275,10 @@ static NTSTATUS rap_cli_do_call(struct smbcli_tree *tree,
 	if (!NT_STATUS_IS_OK(result))
 		return result;
 
-	call->ndr_pull_param = ndr_pull_init_blob(&trans.out.params, call,
-						  iconv_convenience);
+	call->ndr_pull_param = ndr_pull_init_blob(&trans.out.params, call);
 	call->ndr_pull_param->flags = RAPNDR_FLAGS;
 
-	call->ndr_pull_data = ndr_pull_init_blob(&trans.out.data, call,
-						 iconv_convenience);
+	call->ndr_pull_data = ndr_pull_init_blob(&trans.out.data, call);
 	call->ndr_pull_data->flags = RAPNDR_FLAGS;
 
 	return result;
@@ -289,7 +286,6 @@ static NTSTATUS rap_cli_do_call(struct smbcli_tree *tree,
 
 
 static NTSTATUS smbcli_rap_netshareenum(struct smbcli_tree *tree,
-					struct smb_iconv_convenience *iconv_convenience,
 					TALLOC_CTX *mem_ctx,
 					struct rap_NetShareEnum *r)
 {
@@ -297,7 +293,7 @@ static NTSTATUS smbcli_rap_netshareenum(struct smbcli_tree *tree,
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 	int i;
 
-	call = new_rap_cli_call(tree, iconv_convenience, RAP_WshareEnum);
+	call = new_rap_cli_call(tree, RAP_WshareEnum);
 
 	if (call == NULL)
 		return NT_STATUS_NO_MEMORY;
@@ -319,7 +315,7 @@ static NTSTATUS smbcli_rap_netshareenum(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetShareEnum, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -376,7 +372,7 @@ static bool test_netshareenum(struct torture_context *tctx,
 	r.in.bufsize = 8192;
 
 	torture_assert_ntstatus_ok(tctx, 
-		smbcli_rap_netshareenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r), "");
+		smbcli_rap_netshareenum(cli->tree, tctx, &r), "");
 
 	for (i=0; i<r.out.count; i++) {
 		printf("%s %d %s\n", r.out.info[i].info1.share_name,
@@ -388,7 +384,6 @@ static bool test_netshareenum(struct torture_context *tctx,
 }
 
 static NTSTATUS smbcli_rap_netserverenum2(struct smbcli_tree *tree,
-					  struct smb_iconv_convenience *iconv_convenience, 
 					  TALLOC_CTX *mem_ctx,
 					  struct rap_NetServerEnum2 *r)
 {
@@ -396,7 +391,7 @@ static NTSTATUS smbcli_rap_netserverenum2(struct smbcli_tree *tree,
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 	int i;
 
-	call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_NetServerEnum2);
+	call = new_rap_cli_call(mem_ctx, RAP_NetServerEnum2);
 
 	if (call == NULL)
 		return NT_STATUS_NO_MEMORY;
@@ -420,7 +415,7 @@ static NTSTATUS smbcli_rap_netserverenum2(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetServerEnum2, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -484,7 +479,7 @@ static bool test_netserverenum(struct torture_context *tctx,
 	r.in.domain = NULL;
 
 	torture_assert_ntstatus_ok(tctx, 
-		   smbcli_rap_netserverenum2(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r), "");
+		   smbcli_rap_netserverenum2(cli->tree, tctx, &r), "");
 
 	for (i=0; i<r.out.count; i++) {
 		switch (r.in.level) {
@@ -503,14 +498,13 @@ static bool test_netserverenum(struct torture_context *tctx,
 }
 
 NTSTATUS smbcli_rap_netservergetinfo(struct smbcli_tree *tree,
-					      struct smb_iconv_convenience *iconv_convenience, 
 				     TALLOC_CTX *mem_ctx,
 				     struct rap_WserverGetInfo *r)
 {
 	struct rap_call *call;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WserverGetInfo))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WserverGetInfo))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -534,7 +528,7 @@ NTSTATUS smbcli_rap_netservergetinfo(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_WserverGetInfo, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -718,7 +712,6 @@ static NTSTATUS rap_pull_rap_PrintQueue5(TALLOC_CTX *mem_ctx, struct ndr_pull *n
 }
 
 NTSTATUS smbcli_rap_netprintqenum(struct smbcli_tree *tree,
-				  struct smb_iconv_convenience *iconv_convenience,
 				  TALLOC_CTX *mem_ctx,
 				  struct rap_NetPrintQEnum *r)
 {
@@ -726,7 +719,7 @@ NTSTATUS smbcli_rap_netprintqenum(struct smbcli_tree *tree,
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 	int i;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WPrintQEnum))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQEnum))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -765,7 +758,7 @@ NTSTATUS smbcli_rap_netprintqenum(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetPrintQEnum, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -823,14 +816,13 @@ NTSTATUS smbcli_rap_netprintqenum(struct smbcli_tree *tree,
 }
 
 NTSTATUS smbcli_rap_netprintqgetinfo(struct smbcli_tree *tree,
-				     struct smb_iconv_convenience *iconv_convenience,
 				     TALLOC_CTX *mem_ctx,
 				     struct rap_NetPrintQGetInfo *r)
 {
 	struct rap_call *call;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WPrintQGetInfo))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQGetInfo))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -870,7 +862,7 @@ NTSTATUS smbcli_rap_netprintqgetinfo(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetPrintQGetInfo, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -916,14 +908,13 @@ NTSTATUS smbcli_rap_netprintqgetinfo(struct smbcli_tree *tree,
 }
 
 NTSTATUS smbcli_rap_netprintjobpause(struct smbcli_tree *tree,
-				     struct smb_iconv_convenience *iconv_convenience,
 				     TALLOC_CTX *mem_ctx,
 				     struct rap_NetPrintJobPause *r)
 {
 	struct rap_call *call;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WPrintJobPause))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobPause))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -935,7 +926,7 @@ NTSTATUS smbcli_rap_netprintjobpause(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetPrintJobPause, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -953,14 +944,13 @@ NTSTATUS smbcli_rap_netprintjobpause(struct smbcli_tree *tree,
 }
 
 NTSTATUS smbcli_rap_netprintjobcontinue(struct smbcli_tree *tree,
-					struct smb_iconv_convenience *iconv_convenience,
 					TALLOC_CTX *mem_ctx,
 					struct rap_NetPrintJobContinue *r)
 {
 	struct rap_call *call;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WPrintJobContinue))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobContinue))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -972,7 +962,7 @@ NTSTATUS smbcli_rap_netprintjobcontinue(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetPrintJobContinue, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -990,14 +980,13 @@ NTSTATUS smbcli_rap_netprintjobcontinue(struct smbcli_tree *tree,
 }
 
 NTSTATUS smbcli_rap_netprintjobdelete(struct smbcli_tree *tree,
-				      struct smb_iconv_convenience *iconv_convenience,
 				      TALLOC_CTX *mem_ctx,
 				      struct rap_NetPrintJobDelete *r)
 {
 	struct rap_call *call;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WPrintJobDel))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobDel))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -1009,7 +998,7 @@ NTSTATUS smbcli_rap_netprintjobdelete(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetPrintJobDelete, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -1027,14 +1016,13 @@ NTSTATUS smbcli_rap_netprintjobdelete(struct smbcli_tree *tree,
 }
 
 NTSTATUS smbcli_rap_netprintqueuepause(struct smbcli_tree *tree,
-				       struct smb_iconv_convenience *iconv_convenience,
 				       TALLOC_CTX *mem_ctx,
 				       struct rap_NetPrintQueuePause *r)
 {
 	struct rap_call *call;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WPrintQPause))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQPause))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -1046,7 +1034,7 @@ NTSTATUS smbcli_rap_netprintqueuepause(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetPrintQueuePause, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -1064,14 +1052,13 @@ NTSTATUS smbcli_rap_netprintqueuepause(struct smbcli_tree *tree,
 }
 
 NTSTATUS smbcli_rap_netprintqueueresume(struct smbcli_tree *tree,
-					struct smb_iconv_convenience *iconv_convenience,
 					TALLOC_CTX *mem_ctx,
 					struct rap_NetPrintQueueResume *r)
 {
 	struct rap_call *call;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WPrintQContinue))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQContinue))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -1083,7 +1070,7 @@ NTSTATUS smbcli_rap_netprintqueueresume(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetPrintQueueResume, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -1101,14 +1088,13 @@ NTSTATUS smbcli_rap_netprintqueueresume(struct smbcli_tree *tree,
 }
 
 NTSTATUS smbcli_rap_netprintqueuepurge(struct smbcli_tree *tree,
-				       struct smb_iconv_convenience *iconv_convenience,
 				       TALLOC_CTX *mem_ctx,
 				       struct rap_NetPrintQueuePurge *r)
 {
 	struct rap_call *call;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WPrintQPurge))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQPurge))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -1120,7 +1106,7 @@ NTSTATUS smbcli_rap_netprintqueuepurge(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetPrintQueuePurge, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -1138,7 +1124,6 @@ NTSTATUS smbcli_rap_netprintqueuepurge(struct smbcli_tree *tree,
 }
 
 NTSTATUS smbcli_rap_netprintjobenum(struct smbcli_tree *tree,
-				    struct smb_iconv_convenience *iconv_convenience,
 				    TALLOC_CTX *mem_ctx,
 				    struct rap_NetPrintJobEnum *r)
 {
@@ -1146,7 +1131,7 @@ NTSTATUS smbcli_rap_netprintjobenum(struct smbcli_tree *tree,
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 	int i;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WPrintJobEnum))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobEnum))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -1180,7 +1165,7 @@ NTSTATUS smbcli_rap_netprintjobenum(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetPrintJobEnum, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -1234,14 +1219,13 @@ NTSTATUS smbcli_rap_netprintjobenum(struct smbcli_tree *tree,
 }
 
 NTSTATUS smbcli_rap_netprintjobgetinfo(struct smbcli_tree *tree,
-				       struct smb_iconv_convenience *iconv_convenience,
 				       TALLOC_CTX *mem_ctx,
 				       struct rap_NetPrintJobGetInfo *r)
 {
 	struct rap_call *call;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WPrintJobGetInfo))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobGetInfo))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -1275,7 +1259,7 @@ NTSTATUS smbcli_rap_netprintjobgetinfo(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetPrintJobGetInfo, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -1319,14 +1303,13 @@ NTSTATUS smbcli_rap_netprintjobgetinfo(struct smbcli_tree *tree,
 }
 
 NTSTATUS smbcli_rap_netprintjobsetinfo(struct smbcli_tree *tree,
-				       struct smb_iconv_convenience *iconv_convenience,
 				       TALLOC_CTX *mem_ctx,
 				       struct rap_NetPrintJobSetInfo *r)
 {
 	struct rap_call *call;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WPrintJobSetInfo))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobSetInfo))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -1365,7 +1348,7 @@ NTSTATUS smbcli_rap_netprintjobsetinfo(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetPrintJobSetInfo, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -1434,7 +1417,6 @@ static NTSTATUS rap_pull_rap_PrintDest3(TALLOC_CTX *mem_ctx, struct ndr_pull *nd
 }
 
 NTSTATUS smbcli_rap_netprintdestenum(struct smbcli_tree *tree,
-				     struct smb_iconv_convenience *iconv_convenience,
 				     TALLOC_CTX *mem_ctx,
 				     struct rap_NetPrintDestEnum *r)
 {
@@ -1442,7 +1424,7 @@ NTSTATUS smbcli_rap_netprintdestenum(struct smbcli_tree *tree,
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 	int i;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WPrintDestEnum))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintDestEnum))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -1472,7 +1454,7 @@ NTSTATUS smbcli_rap_netprintdestenum(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetPrintDestEnum, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -1526,14 +1508,13 @@ NTSTATUS smbcli_rap_netprintdestenum(struct smbcli_tree *tree,
 }
 
 NTSTATUS smbcli_rap_netprintdestgetinfo(struct smbcli_tree *tree,
-					struct smb_iconv_convenience *iconv_convenience,
 					TALLOC_CTX *mem_ctx,
 					struct rap_NetPrintDestGetInfo *r)
 {
 	struct rap_call *call;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WPrintDestGetInfo))) {
+	if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintDestGetInfo))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -1564,7 +1545,7 @@ NTSTATUS smbcli_rap_netprintdestgetinfo(struct smbcli_tree *tree,
 		NDR_PRINT_IN_DEBUG(rap_NetPrintDestGetInfo, r);
 	}
 
-	result = rap_cli_do_call(tree, iconv_convenience, call);
+	result = rap_cli_do_call(tree, call);
 
 	if (!NT_STATUS_IS_OK(result))
 		goto done;
@@ -1718,14 +1699,14 @@ static bool test_netservergetinfo(struct torture_context *tctx,
 
 	r.in.level = 0;
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netservergetinfo(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netservergetinfo(cli->tree, tctx, &r),
 		"rap_netservergetinfo level 0 failed");
 	torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 		"rap_netservergetinfo level 0 failed");
 
 	r.in.level = 1;
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netservergetinfo(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netservergetinfo(cli->tree, tctx, &r),
 		"rap_netservergetinfo level 1 failed");
 	torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
 		"rap_netservergetinfo level 1 failed");
@@ -1738,10 +1719,10 @@ bool torture_rap_scan(struct torture_context *torture, struct smbcli_state *cli)
 	int callno;
 
 	for (callno = 0; callno < 0xffff; callno++) {
-		struct rap_call *call = new_rap_cli_call(torture, lp_iconv_convenience(torture->lp_ctx), callno);
+		struct rap_call *call = new_rap_cli_call(torture, callno);
 		NTSTATUS result;
 
-		result = rap_cli_do_call(cli->tree, lp_iconv_convenience(torture->lp_ctx), call);
+		result = rap_cli_do_call(cli->tree, call);
 
 		if (!NT_STATUS_EQUAL(result, NT_STATUS_INVALID_PARAMETER))
 			continue;
diff --git a/source4/torture/rap/rpc.c b/source4/torture/rap/rpc.c
index 4528240310..6335a54b35 100644
--- a/source4/torture/rap/rpc.c
+++ b/source4/torture/rap/rpc.c
@@ -58,7 +58,7 @@ static bool test_rpc_netservergetinfo(struct torture_context *tctx,
 	r.in.level = 0;
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netservergetinfo(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netservergetinfo(cli->tree, tctx, &r),
 		"rap_netservergetinfo level 0 failed");
 	torture_assert_int_equal(tctx, r.out.status, 0,
 		"rap_netservergetinfo level 0 failed");
@@ -70,7 +70,7 @@ static bool test_rpc_netservergetinfo(struct torture_context *tctx,
 	r.in.level = 1;
 
 	torture_assert_ntstatus_ok(tctx,
-		smbcli_rap_netservergetinfo(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+		smbcli_rap_netservergetinfo(cli->tree, tctx, &r),
 		"rap_netservergetinfo level 1 failed");
 	torture_assert_int_equal(tctx, r.out.status, 0,
 		"rap_netservergetinfo level 1 failed");
diff --git a/source4/torture/raw/oplock.c b/source4/torture/raw/oplock.c
index 5ae396412e..2a1d8e5ace 100644
--- a/source4/torture/raw/oplock.c
+++ b/source4/torture/raw/oplock.c
@@ -188,7 +188,6 @@ static bool open_connection_no_level2_oplocks(struct torture_context *tctx,
 					NULL, lp_socket_options(tctx->lp_ctx), cmdline_credentials,
 					lp_resolve_context(tctx->lp_ctx),
 					tctx->ev, &options, &session_options,
-					lp_iconv_convenience(tctx->lp_ctx),
 					lp_gensec_settings(tctx, tctx->lp_ctx));
 	if (!NT_STATUS_IS_OK(status)) {
 		torture_comment(tctx, "Failed to open connection - %s\n",
diff --git a/source4/torture/raw/qfileinfo.c b/source4/torture/raw/qfileinfo.c
index a854ac8857..12897ef499 100644
--- a/source4/torture/raw/qfileinfo.c
+++ b/source4/torture/raw/qfileinfo.c
@@ -877,8 +877,7 @@ bool torture_raw_qfileinfo_pipe(struct torture_context *torture,
 	struct smbcli_tree *ipc_tree;
 	NTSTATUS status;
 
-	if (!(p = dcerpc_pipe_init(torture, cli->tree->session->transport->socket->event.ctx,
-				   lp_iconv_convenience(torture->lp_ctx)))) {
+	if (!(p = dcerpc_pipe_init(torture, cli->tree->session->transport->socket->event.ctx))) {
 		return false;
 	}
 
diff --git a/source4/torture/raw/tconrate.c b/source4/torture/raw/tconrate.c
index 06cb7650c1..66fc3c01d6 100644
--- a/source4/torture/raw/tconrate.c
+++ b/source4/torture/raw/tconrate.c
@@ -102,7 +102,6 @@ static int fork_tcon_client(struct torture_context *tctx,
 				NULL, lp_socket_options(tctx->lp_ctx), cmdline_credentials,
 				lp_resolve_context(tctx->lp_ctx),
 				tctx->ev, &options, &session_options,
-				lp_iconv_convenience(tctx->lp_ctx),
 				lp_gensec_settings(tctx, tctx->lp_ctx));
 
 		if (!NT_STATUS_IS_OK(status)) {
diff --git a/source4/torture/rpc/autoidl.c b/source4/torture/rpc/autoidl.c
index 77bb761e0c..3bf7dab764 100644
--- a/source4/torture/rpc/autoidl.c
+++ b/source4/torture/rpc/autoidl.c
@@ -81,7 +81,7 @@ static void fill_blob_handle(DATA_BLOB *blob, TALLOC_CTX *mem_ctx,
 		return;
 	}
 
-	ndr_push_struct_blob(&b2, mem_ctx, NULL, handle, (ndr_push_flags_fn_t)ndr_push_policy_handle);
+	ndr_push_struct_blob(&b2, mem_ctx, handle, (ndr_push_flags_fn_t)ndr_push_policy_handle);
 
 	memcpy(blob->data, b2.data, 20);
 }
diff --git a/source4/torture/rpc/dssync.c b/source4/torture/rpc/dssync.c
index 2e5edfdb88..d6ed191284 100644
--- a/source4/torture/rpc/dssync.c
+++ b/source4/torture/rpc/dssync.c
@@ -361,7 +361,7 @@ static bool test_GetInfo(struct torture_context *tctx, struct DsSyncTest *ctx)
 	search.in.acct_control = -1;
 	search.in.version		= NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
 	search.in.map_response = true;
-	status = cldap_netlogon(cldap, lp_iconv_convenience(tctx->lp_ctx), ctx, &search);
+	status = cldap_netlogon(cldap, ctx, &search);
 	if (!NT_STATUS_IS_OK(status)) {
 		const char *errstr = nt_errstr(status);
 		ctx->site_name = talloc_asprintf(ctx, "%s", "Default-First-Site-Name");
@@ -407,7 +407,7 @@ static bool test_analyse_objects(struct torture_context *tctx,
 		struct ldb_result *a_res;
 		struct ldb_result *c_res;
 		struct ldb_dn *schema_dn = ldb_get_schema_basedn(ldb);
-		ldap_schema = dsdb_new_schema(ctx, lp_iconv_convenience(tctx->lp_ctx));
+		ldap_schema = dsdb_new_schema(ctx);
 		if (!ldap_schema) {
 			return false;
 		}
@@ -727,8 +727,7 @@ static bool test_analyse_objects(struct torture_context *tctx,
 				if (pull_fn) {
 					/* Can't use '_all' because of PIDL bugs with relative pointers */
 					ndr_err = ndr_pull_struct_blob(&plain_data, ptr,
-								       lp_iconv_convenience(tctx->lp_ctx), ptr,
-								       pull_fn);
+								       ptr, pull_fn);
 					if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 						ndr_print_debug(print_fn, name, ptr);
 					} else {
diff --git a/source4/torture/rpc/eventlog.c b/source4/torture/rpc/eventlog.c
index 1fcc0a6f3f..3b6c70e068 100644
--- a/source4/torture/rpc/eventlog.c
+++ b/source4/torture/rpc/eventlog.c
@@ -171,8 +171,7 @@ static bool test_ReadEventLog(struct torture_context *tctx,
 			blob = data_blob_const(r.out.data + pos, size);
 			dump_data(0, blob.data, blob.length);
 
-			ndr_err = ndr_pull_struct_blob_all(&blob, tctx,
-				lp_iconv_convenience(tctx->lp_ctx), &rec,
+			ndr_err = ndr_pull_struct_blob_all(&blob, tctx, &rec,
 				(ndr_pull_flags_fn_t)ndr_pull_EVENTLOGRECORD);
 			if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 				status = ndr_map_error2ntstatus(ndr_err);
diff --git a/source4/torture/rpc/join.c b/source4/torture/rpc/join.c
index b02510930a..09519d03a5 100644
--- a/source4/torture/rpc/join.c
+++ b/source4/torture/rpc/join.c
@@ -41,7 +41,6 @@ bool torture_rpc_join(struct torture_context *torture)
 					machine_account,
 					lp_resolve_context(torture->lp_ctx),
 					torture->ev, &options, &session_options,
-					lp_iconv_convenience(torture->lp_ctx),
 					lp_gensec_settings(torture, torture->lp_ctx));
 	if (!NT_STATUS_IS_OK(status)) {
 		DEBUG(0, ("%s failed to connect to IPC$ with workstation credentials\n",
@@ -70,7 +69,6 @@ bool torture_rpc_join(struct torture_context *torture)
 					machine_account,
 					lp_resolve_context(torture->lp_ctx),
 					torture->ev, &options, &session_options,
-					lp_iconv_convenience(torture->lp_ctx),
 					lp_gensec_settings(torture, torture->lp_ctx));
 	if (!NT_STATUS_IS_OK(status)) {
 		DEBUG(0, ("%s failed to connect to IPC$ with workstation credentials\n",
diff --git a/source4/torture/rpc/lsa.c b/source4/torture/rpc/lsa.c
index 3f91afedd6..c66725672e 100644
--- a/source4/torture/rpc/lsa.c
+++ b/source4/torture/rpc/lsa.c
@@ -2438,7 +2438,7 @@ static bool test_CreateTrustedDomainEx2(struct dcerpc_pipe *p,
 		auth_struct.outgoing.count = 0;
 		auth_struct.incoming.count = 0;
 
-		ndr_err = ndr_push_struct_blob(&auth_blob, tctx, lp_iconv_convenience(tctx->lp_ctx), &auth_struct,
+		ndr_err = ndr_push_struct_blob(&auth_blob, tctx, &auth_struct,
 					       (ndr_push_flags_fn_t)ndr_push_trustDomainPasswords);
 		if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 			torture_comment(tctx, "ndr_push_struct_blob of trustDomainPasswords structure failed");
diff --git a/source4/torture/rpc/remote_pac.c b/source4/torture/rpc/remote_pac.c
index eab835aad1..9358d44ca8 100644
--- a/source4/torture/rpc/remote_pac.c
+++ b/source4/torture/rpc/remote_pac.c
@@ -139,7 +139,7 @@ static bool test_PACVerify(struct torture_context *tctx,
 	       session_info->server_info->pac_kdc_sig.signature.data, 
 	       pac_wrapped_struct.SignatureLength);
 
-	ndr_err = ndr_push_struct_blob(&pac_wrapped, tmp_ctx, lp_iconv_convenience(tctx->lp_ctx), &pac_wrapped_struct,
+	ndr_err = ndr_push_struct_blob(&pac_wrapped, tmp_ctx, &pac_wrapped_struct,
 				       (ndr_push_flags_fn_t)ndr_push_PAC_Validate);
 	torture_assert(tctx, NDR_ERR_CODE_IS_SUCCESS(ndr_err), "ndr_push_struct_blob of PACValidate structure failed");
 		
@@ -245,7 +245,7 @@ static bool test_PACVerify(struct torture_context *tctx,
 	       session_info->server_info->pac_kdc_sig.signature.data, 
 	       pac_wrapped_struct.SignatureLength);
 	
-	ndr_err = ndr_push_struct_blob(&pac_wrapped, tmp_ctx, lp_iconv_convenience(tctx->lp_ctx), &pac_wrapped_struct,
+	ndr_err = ndr_push_struct_blob(&pac_wrapped, tmp_ctx, &pac_wrapped_struct,
 				       (ndr_push_flags_fn_t)ndr_push_PAC_Validate);
 	torture_assert(tctx, NDR_ERR_CODE_IS_SUCCESS(ndr_err), "ndr_push_struct_blob of PACValidate structure failed");
 	
@@ -293,7 +293,7 @@ static bool test_PACVerify(struct torture_context *tctx,
 	/* Break the signature length */
 	pac_wrapped_struct.SignatureLength++;
 
-	ndr_err = ndr_push_struct_blob(&pac_wrapped, tmp_ctx, lp_iconv_convenience(tctx->lp_ctx), &pac_wrapped_struct,
+	ndr_err = ndr_push_struct_blob(&pac_wrapped, tmp_ctx, &pac_wrapped_struct,
 				       (ndr_push_flags_fn_t)ndr_push_PAC_Validate);
 	torture_assert(tctx, NDR_ERR_CODE_IS_SUCCESS(ndr_err), "ndr_push_struct_blob of PACValidate structure failed");
 	
diff --git a/source4/torture/rpc/samba3rpc.c b/source4/torture/rpc/samba3rpc.c
index 96d2b5ca52..d09e80283a 100644
--- a/source4/torture/rpc/samba3rpc.c
+++ b/source4/torture/rpc/samba3rpc.c
@@ -84,7 +84,6 @@ bool torture_bind_authcontext(struct torture_context *torture)
 					cmdline_credentials,
 					lp_resolve_context(torture->lp_ctx),
 					torture->ev, &options, &session_options,
-					lp_iconv_convenience(torture->lp_ctx),
 					lp_gensec_settings(torture, torture->lp_ctx));
 	if (!NT_STATUS_IS_OK(status)) {
 		torture_comment(torture, "smbcli_full_connection failed: %s\n",
@@ -92,8 +91,7 @@ bool torture_bind_authcontext(struct torture_context *torture)
 		goto done;
 	}
 
-	lsa_pipe = dcerpc_pipe_init(mem_ctx, cli->transport->socket->event.ctx,
-				    lp_iconv_convenience(torture->lp_ctx));
+	lsa_pipe = dcerpc_pipe_init(mem_ctx, cli->transport->socket->event.ctx);
 	if (lsa_pipe == NULL) {
 		torture_comment(torture, "dcerpc_pipe_init failed\n");
 		goto done;
@@ -224,8 +222,7 @@ static bool bindtest(struct torture_context *tctx,
 	}
 
 	lsa_pipe = dcerpc_pipe_init(mem_ctx,
-				    cli->transport->socket->event.ctx,
-				    lp_iconv_convenience(tctx->lp_ctx));
+				    cli->transport->socket->event.ctx); 
 	if (lsa_pipe == NULL) {
 		torture_comment(tctx, "dcerpc_pipe_init failed\n");
 		goto done;
@@ -336,7 +333,6 @@ static bool torture_bind_samba3(struct torture_context *torture)
 					cmdline_credentials,
 					lp_resolve_context(torture->lp_ctx),
 					torture->ev, &options, &session_options,
-					lp_iconv_convenience(torture->lp_ctx),
 					lp_gensec_settings(torture, torture->lp_ctx));
 	if (!NT_STATUS_IS_OK(status)) {
 		torture_comment(torture, "smbcli_full_connection failed: %s\n",
@@ -397,8 +393,7 @@ static bool get_usr_handle(struct torture_context *tctx,
 	uint32_t user_rid,access_granted;
 
 	samr_pipe = dcerpc_pipe_init(mem_ctx,
-				     cli->transport->socket->event.ctx,
-				     lp_iconv_convenience(tctx->lp_ctx));
+				     cli->transport->socket->event.ctx);
 	torture_assert(tctx, samr_pipe, "dcerpc_pipe_init failed");
 
 	samr_handle = samr_pipe->binding_handle;
@@ -953,8 +948,7 @@ static bool auth2(struct torture_context *tctx,
 	}
 
 	net_pipe = dcerpc_pipe_init(mem_ctx,
-				    cli->transport->socket->event.ctx,
-				    lp_iconv_convenience(tctx->lp_ctx));
+				    cli->transport->socket->event.ctx);
 	if (net_pipe == NULL) {
 		torture_comment(tctx, "dcerpc_pipe_init failed\n");
 		goto done;
@@ -1070,8 +1064,7 @@ static bool schan(struct torture_context *tctx,
 	}
 
 	net_pipe = dcerpc_pipe_init(mem_ctx,
-				    cli->transport->socket->event.ctx,
-				    lp_iconv_convenience(tctx->lp_ctx));
+				    cli->transport->socket->event.ctx);
 	if (net_pipe == NULL) {
 		torture_comment(tctx, "dcerpc_pipe_init failed\n");
 		goto done;
@@ -1342,7 +1335,6 @@ static bool torture_netlogon_samba3(struct torture_context *torture)
 					anon_creds,
 					lp_resolve_context(torture->lp_ctx),
 					torture->ev, &options, &session_options,
-					lp_iconv_convenience(torture->lp_ctx),
 					lp_gensec_settings(torture, torture->lp_ctx));
 	if (!NT_STATUS_IS_OK(status)) {
 		torture_comment(torture, "smbcli_full_connection failed: %s\n",
@@ -1432,7 +1424,6 @@ static bool test_join3(struct torture_context *tctx,
 					"IPC$", NULL, lp_socket_options(tctx->lp_ctx),
 					smb_creds, lp_resolve_context(tctx->lp_ctx),
 					tctx->ev, &options, &session_options,
-					lp_iconv_convenience(tctx->lp_ctx),
 					lp_gensec_settings(tctx, tctx->lp_ctx));
 	torture_assert_ntstatus_ok(tctx, status,
 		"smbcli_full_connection failed");
@@ -1541,8 +1532,7 @@ static NTSTATUS pipe_bind_smb(struct torture_context *tctx,
 	NTSTATUS status;
 
 	if (!(result = dcerpc_pipe_init(
-		      mem_ctx, tree->session->transport->socket->event.ctx,
-		      lp_iconv_convenience(tctx->lp_ctx)))) {
+		      mem_ctx, tree->session->transport->socket->event.ctx))) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
@@ -1809,10 +1799,8 @@ static bool torture_samba3_rpc_getusername(struct torture_context *torture)
 		mem_ctx, &cli, torture_setting_string(torture, "host", NULL),
 		lp_smb_ports(torture->lp_ctx),
 		"IPC$", NULL, lp_socket_options(torture->lp_ctx), cmdline_credentials,
-		lp_resolve_context(torture->lp_ctx),
-		torture->ev, &options, &session_options,
-		lp_iconv_convenience(torture->lp_ctx),
-		lp_gensec_settings(torture, torture->lp_ctx));
+		lp_resolve_context(torture->lp_ctx), torture->ev, &options,
+		&session_options, lp_gensec_settings(torture, torture->lp_ctx));
 	if (!NT_STATUS_IS_OK(status)) {
 		torture_warning(torture, "smbcli_full_connection failed: %s\n",
 			 nt_errstr(status));
@@ -1839,7 +1827,6 @@ static bool torture_samba3_rpc_getusername(struct torture_context *torture)
 		lp_socket_options(torture->lp_ctx), anon_creds,
 		lp_resolve_context(torture->lp_ctx),
 		torture->ev, &options, &session_options,
-		lp_iconv_convenience(torture->lp_ctx),
 		lp_gensec_settings(torture, torture->lp_ctx));
 	if (!NT_STATUS_IS_OK(status)) {
 		torture_warning(torture, "anon smbcli_full_connection failed: %s\n",
@@ -2154,8 +2141,7 @@ static bool torture_samba3_rpc_randomauth2(struct torture_context *torture)
 	}
 
 	if (!(net_pipe = dcerpc_pipe_init(
-		      mem_ctx, cli->transport->socket->event.ctx,
-		      lp_iconv_convenience(torture->lp_ctx)))) {
+		      mem_ctx, cli->transport->socket->event.ctx))) {
 		torture_comment(torture, "dcerpc_pipe_init failed\n");
 		goto done;
 	}
@@ -2556,7 +2542,6 @@ static bool torture_samba3_rpc_lsa(struct torture_context *torture)
 }
 
 static NTSTATUS get_servername(TALLOC_CTX *mem_ctx, struct smbcli_tree *tree,
-			       struct smb_iconv_convenience *iconv_convenience,
 			       char **name)
 {
 	struct rap_WserverGetInfo r;
@@ -2566,7 +2551,7 @@ static NTSTATUS get_servername(TALLOC_CTX *mem_ctx, struct smbcli_tree *tree,
 	r.in.level = 0;
 	r.in.bufsize = 0xffff;
 
-	status = smbcli_rap_netservergetinfo(tree, iconv_convenience, mem_ctx, &r);
+	status = smbcli_rap_netservergetinfo(tree, mem_ctx, &r);
 	if (!NT_STATUS_IS_OK(status)) {
 		return status;
 	}
@@ -2592,7 +2577,7 @@ static bool rap_get_servername(struct torture_context *tctx,
 		"IPC$ connection failed");
 
 	torture_assert_ntstatus_ok(tctx,
-		get_servername(tctx, cli->tree, lp_iconv_convenience(tctx->lp_ctx), servername),
+		get_servername(tctx, cli->tree, servername),
 		"get_servername failed");
 
 	talloc_free(cli);
@@ -3241,7 +3226,7 @@ static bool torture_samba3_setconfig(struct torture_context *tctx,
 		"OpenKey failed");
 
 	torture_assert(tctx,
-		reg_string_to_val(tctx, lp_iconv_convenience(tctx->lp_ctx), "REG_SZ", value, &type, &val),
+		reg_string_to_val(tctx, "REG_SZ", value, &type, &val),
 		"reg_string_to_val failed");
 
 	s.in.handle = &key_handle;
diff --git a/source4/torture/rpc/samlogon.c b/source4/torture/rpc/samlogon.c
index 2da0041c73..c59e447443 100644
--- a/source4/torture/rpc/samlogon.c
+++ b/source4/torture/rpc/samlogon.c
@@ -65,7 +65,6 @@ struct samlogon_state {
 	NTSTATUS expected_error;
 	bool old_password; /* Allow an old password to be accepted or rejected without error, as well as session key bugs */
 	DATA_BLOB chall;
-	struct smb_iconv_convenience *iconv_convenience;
 };
 
 /* 
@@ -1190,8 +1189,7 @@ static bool test_plaintext(struct samlogon_state *samlogon_state, enum ntlm_brea
 
 	password = strupper_talloc(samlogon_state->mem_ctx, samlogon_state->password);
 
-	if (!convert_string_talloc_convenience(samlogon_state->mem_ctx, 
-				   samlogon_state->iconv_convenience,
+	if (!convert_string_talloc(samlogon_state->mem_ctx, 
 				   CH_UNIX, CH_DOS, 
 				   password, strlen(password)+1, 
 				   (void**)&dospw, NULL, false)) {
@@ -1372,7 +1370,6 @@ static bool test_SamLogon(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
 	samlogon_state.chall = data_blob_talloc(fn_ctx, NULL, 8);
 	samlogon_state.parameter_control = parameter_control;
 	samlogon_state.old_password = old_password;
-	samlogon_state.iconv_convenience = lp_iconv_convenience(tctx->lp_ctx);
 
 	generate_random_buffer(samlogon_state.chall.data, 8);
 	samlogon_state.r_flags.in.server_name = talloc_asprintf(fn_ctx, "\\\\%s", dcerpc_server_name(p));
diff --git a/source4/torture/rpc/samsync.c b/source4/torture/rpc/samsync.c
index e59bf3a3a8..6e0d9471d1 100644
--- a/source4/torture/rpc/samsync.c
+++ b/source4/torture/rpc/samsync.c
@@ -598,7 +598,7 @@ static bool samsync_handle_user(struct torture_context *tctx, TALLOC_CTX *mem_ct
 		enum ndr_err_code ndr_err;
 		data.data = user->user_private_info.SensitiveData;
 		data.length = user->user_private_info.DataLength;
-		ndr_err = ndr_pull_struct_blob(&data, mem_ctx, lp_iconv_convenience(tctx->lp_ctx), &keys, (ndr_pull_flags_fn_t)ndr_pull_netr_USER_KEYS);
+		ndr_err = ndr_pull_struct_blob(&data, mem_ctx, &keys, (ndr_pull_flags_fn_t)ndr_pull_netr_USER_KEYS);
 		if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 			if (keys.keys.keys2.lmpassword.length == 16) {
 				lm_hash_p = &lm_hash;
diff --git a/source4/torture/rpc/spoolss.c b/source4/torture/rpc/spoolss.c
index 61d1bccaa4..efe975c76e 100644
--- a/source4/torture/rpc/spoolss.c
+++ b/source4/torture/rpc/spoolss.c
@@ -174,9 +174,9 @@ static bool test_AddPrinterDriver_args_level_3(struct torture_context *tctx,
 
 #define DO_ROUND(size, n) (((size)+((n)-1)) & ~((n)-1))
 
-#define CHECK_NEEDED_SIZE_ENUM_LEVEL(fn, info, level, count, ic, needed, align) do { \
+#define CHECK_NEEDED_SIZE_ENUM_LEVEL(fn, info, level, count, needed, align) do { \
 	if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
-	uint32_t size = ndr_size_##fn##_info(tctx, ic, level, count, info);\
+	uint32_t size = ndr_size_##fn##_info(tctx, level, count, info);\
 	uint32_t round_size = DO_ROUND(size, align);\
 	if (round_size != needed) {\
 		torture_warning(tctx, __location__": "#fn" level %d (count: %d) got unexpected needed size: %d, we calculated: %d", level, count, needed, round_size);\
@@ -185,9 +185,9 @@ static bool test_AddPrinterDriver_args_level_3(struct torture_context *tctx,
 	}\
 } while(0)
 
-#define CHECK_NEEDED_SIZE_ENUM(fn, info, count, ic, needed, align) do { \
+#define CHECK_NEEDED_SIZE_ENUM(fn, info, count, needed, align) do { \
 	if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
-	uint32_t size = ndr_size_##fn##_info(tctx, ic, count, info);\
+	uint32_t size = ndr_size_##fn##_info(tctx, count, info);\
 	uint32_t round_size = DO_ROUND(size, align);\
 	if (round_size != needed) {\
 		torture_warning(tctx, __location__": "#fn" (count: %d) got unexpected needed size: %d, we calculated: %d", count, needed, round_size);\
@@ -196,9 +196,9 @@ static bool test_AddPrinterDriver_args_level_3(struct torture_context *tctx,
 	}\
 } while(0)
 
-#define CHECK_NEEDED_SIZE_LEVEL(fn, info, level, ic, needed, align) do { \
+#define CHECK_NEEDED_SIZE_LEVEL(fn, info, level, needed, align) do { \
 	if (torture_setting_bool(tctx, "spoolss_check_size", false)) {\
-	uint32_t size = ndr_size_##fn(info, level, ic, 0);\
+	uint32_t size = ndr_size_##fn(info, level, 0);\
 	uint32_t round_size = DO_ROUND(size, align);\
 	if (round_size != needed) {\
 		torture_warning(tctx, __location__": "#fn" level %d got unexpected needed size: %d, we calculated: %d", level, needed, round_size);\
@@ -323,7 +323,7 @@ static bool test_EnumPorts(struct torture_context *tctx,
 
 		torture_assert(tctx, info, "EnumPorts returned no info");
 
-		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, r.in.level, count, needed, 4);
 
 		ctx->port_count[level]	= count;
 		ctx->ports[level]	= info;
@@ -414,7 +414,7 @@ static bool test_GetPrintProcessorDirectory(struct torture_context *tctx,
 
 		torture_assert_werr_ok(tctx, r.out.result, "GetPrintProcessorDirectory failed");
 
-		CHECK_NEEDED_SIZE_LEVEL(spoolss_PrintProcessorDirectoryInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 2);
+		CHECK_NEEDED_SIZE_LEVEL(spoolss_PrintProcessorDirectoryInfo, r.out.info, r.in.level, needed, 2);
 	}
 
 	return true;
@@ -479,7 +479,7 @@ static bool test_GetPrinterDriverDirectory(struct torture_context *tctx,
 
 		torture_assert_werr_ok(tctx, r.out.result, "GetPrinterDriverDirectory failed");
 
-		CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverDirectoryInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 2);
+		CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverDirectoryInfo, r.out.info, r.in.level, needed, 2);
 	}
 
 	return true;
@@ -533,7 +533,7 @@ static bool test_EnumPrinterDrivers_args(struct torture_context *tctx,
 		*info_p = info;
 	}
 
-	CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinterDrivers, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+	CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinterDrivers, info, r.in.level, count, needed, 4);
 
 	return true;
 
@@ -755,7 +755,7 @@ static bool test_EnumMonitors(struct torture_context *tctx,
 
 		torture_assert_werr_ok(tctx, r.out.result, "EnumMonitors failed");
 
-		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumMonitors, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumMonitors, info, r.in.level, count, needed, 4);
 
 		ctx->monitor_count[level]	= count;
 		ctx->monitors[level]		= info;
@@ -833,7 +833,7 @@ static bool test_EnumPrintProcessors(struct torture_context *tctx,
 
 		torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcessors failed");
 
-		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcessors, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcessors, info, r.in.level, count, needed, 4);
 
 		ctx->print_processor_count[level]	= count;
 		ctx->print_processors[level]		= info;
@@ -908,7 +908,7 @@ static bool test_EnumPrintProcDataTypes(struct torture_context *tctx,
 
 		torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcDataTypes failed");
 
-		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcDataTypes, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcDataTypes, info, r.in.level, count, needed, 4);
 
 	}
 
@@ -961,7 +961,7 @@ static bool test_EnumPrinters(struct torture_context *tctx,
 
 		torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
 
-		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, needed, 4);
 
 		ctx->printer_count[level]	= count;
 		ctx->printers[level]		= info;
@@ -1080,7 +1080,7 @@ bool test_GetPrinter_level(struct torture_context *tctx,
 
 	torture_assert_werr_ok(tctx, r.out.result, "GetPrinter failed");
 
-	CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+	CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterInfo, r.out.info, r.in.level, needed, 4);
 
 	if (info && r.out.info) {
 		*info = *r.out.info;
@@ -2370,7 +2370,7 @@ static bool test_GetForm_args(struct torture_context *tctx,
 
 	torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
 
-	CHECK_NEEDED_SIZE_LEVEL(spoolss_FormInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+	CHECK_NEEDED_SIZE_LEVEL(spoolss_FormInfo, r.out.info, r.in.level, needed, 4);
 
 	if (info_p) {
 		*info_p = *r.out.info;
@@ -2437,7 +2437,7 @@ static bool test_EnumForms(struct torture_context *tctx,
 
 	torture_assert_werr_ok(tctx, r.out.result, "EnumForms failed");
 
-	CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumForms, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+	CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumForms, info, r.in.level, count, needed, 4);
 
 	if (info_p) {
 		*info_p = info;
@@ -2857,7 +2857,7 @@ static bool test_EnumPorts_old(struct torture_context *tctx,
 
 	torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
 
-	CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, 2, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+	CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPorts, info, 2, count, needed, 4);
 
 	return true;
 }
@@ -2934,7 +2934,7 @@ static bool test_GetJob_args(struct torture_context *tctx,
 	torture_assert_werr_ok(tctx, r.out.result, "GetJob failed");
 	torture_assert(tctx, r.out.info, "No job info returned");
 
-	CHECK_NEEDED_SIZE_LEVEL(spoolss_JobInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+	CHECK_NEEDED_SIZE_LEVEL(spoolss_JobInfo, r.out.info, r.in.level, needed, 4);
 
 	if (info_p) {
 		*info_p = *r.out.info;
@@ -3083,7 +3083,7 @@ static bool test_EnumJobs_args(struct torture_context *tctx,
 		torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
 		torture_assert(tctx, info, "No jobs returned");
 
-		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumJobs, *r.out.info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumJobs, *r.out.info, r.in.level, count, needed, 4);
 
 	} else {
 		torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
@@ -3375,7 +3375,7 @@ static bool test_GetPrinterData(struct torture_context *tctx,
 	torture_assert_werr_ok(tctx, r.out.result,
 		talloc_asprintf(tctx, "GetPrinterData(%s) failed", r.in.value_name));
 
-	CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, lp_iconv_convenience(tctx->lp_ctx), needed, 1);
+	CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, needed, 1);
 
 	if (type_p) {
 		*type_p = type;
@@ -3437,7 +3437,7 @@ static bool test_GetPrinterDataEx(struct torture_context *tctx,
 	torture_assert_werr_ok(tctx, r.out.result,
 		talloc_asprintf(tctx, "GetPrinterDataEx(%s - %s) failed", r.in.key_name, r.in.value_name));
 
-	CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, lp_iconv_convenience(tctx->lp_ctx), needed, 1);
+	CHECK_NEEDED_SIZE_LEVEL(spoolss_PrinterData, &data, type, needed, 1);
 
 	if (type_p) {
 		*type_p = type;
@@ -3471,7 +3471,7 @@ static bool test_get_environment(struct torture_context *tctx,
 	torture_assert_int_equal(tctx, type, REG_SZ, "unexpected type");
 
 	blob = data_blob_const(data, needed);
-	*architecture = reg_val_data_string(tctx, lp_iconv_convenience(tctx->lp_ctx), REG_SZ, blob);
+	*architecture = reg_val_data_string(tctx, REG_SZ, blob);
 
 	return true;
 }
@@ -3515,7 +3515,7 @@ static bool test_GetPrinterData_list(struct torture_context *tctx,
 		if (strequal(list[i], "Architecture")) {
 			if (architecture) {
 				DATA_BLOB blob = data_blob_const(data, needed);
-				*architecture = reg_val_data_string(tctx, lp_iconv_convenience(tctx->lp_ctx), REG_SZ, blob);
+				*architecture = reg_val_data_string(tctx, REG_SZ, blob);
 			}
 		}
 	}
@@ -3656,7 +3656,7 @@ static bool test_EnumPrinterDataEx(struct torture_context *tctx,
 
 	torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDataEx failed");
 
-	CHECK_NEEDED_SIZE_ENUM(spoolss_EnumPrinterDataEx, info, count, lp_iconv_convenience(tctx->lp_ctx), needed, 1);
+	CHECK_NEEDED_SIZE_ENUM(spoolss_EnumPrinterDataEx, info, count, needed, 1);
 
 	if (count_p) {
 		*count_p = count;
@@ -3698,7 +3698,7 @@ static bool test_EnumPrinterData_consistency(struct torture_context *tctx,
 	torture_comment(tctx, "Testing EnumPrinterData vs EnumPrinterDataEx consistency\n");
 
 	torture_assert(tctx,
-		reg_string_to_val(tctx, lp_iconv_convenience(tctx->lp_ctx),
+		reg_string_to_val(tctx, 
 				  "REG_SZ", "torture_data1", &type, &blob), "");
 
 	torture_assert(tctx,
@@ -4093,7 +4093,7 @@ static bool test_winreg_symbolic_link(struct torture_context *tctx,
 	torture_assert_int_equal(tctx, w_type, REG_LINK, "unexpected type");
 
 	blob = data_blob(w_data, w_size);
-	str = reg_val_data_string(tctx, lp_iconv_convenience(tctx->lp_ctx), REG_SZ, blob);
+	str = reg_val_data_string(tctx, REG_SZ, blob);
 
 	torture_assert_str_equal(tctx, str, symlink_destination, "unexpected symlink target string");
 
@@ -4162,7 +4162,7 @@ do {\
 		"failed to query winreg");\
 	torture_assert_int_equal(tctx, w_type, REG_SZ, "unexpected type");\
 	blob = data_blob(w_data, w_size);\
-	str = reg_val_data_string(tctx, lp_iconv_convenience(tctx->lp_ctx), REG_SZ, blob);\
+	str = reg_val_data_string(tctx, REG_SZ, blob);\
 	if (w_size == 2 && iname == NULL) {\
 		/*torture_comment(tctx, "%s: \"\", %s: (null)\n", #wname, #iname);\ */\
 	} else {\
@@ -4205,7 +4205,7 @@ do {\
 		"failed to query winreg");\
 	torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");\
 	blob = data_blob(w_data, w_size);\
-	ndr_err = ndr_pull_struct_blob(&blob, tctx, lp_iconv_convenience(tctx->lp_ctx), &dm,\
+	ndr_err = ndr_pull_struct_blob(&blob, tctx, &dm,\
 		(ndr_pull_flags_fn_t)ndr_pull_spoolss_DeviceMode);\
 	torture_assert_ndr_success(tctx, ndr_err, "failed to unmarshall dm");\
 	torture_assert(tctx, test_devicemode_equal(tctx, &dm, iname),\
@@ -4227,7 +4227,7 @@ do {\
 		"failed to query winreg");\
 	torture_assert_int_equal(tctx, w_type, REG_BINARY, "unexpected type");\
 	blob = data_blob(w_data, w_size);\
-	ndr_err = ndr_pull_struct_blob(&blob, tctx, lp_iconv_convenience(tctx->lp_ctx), &sd,\
+	ndr_err = ndr_pull_struct_blob(&blob, tctx, &sd,\
 		(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);\
 	torture_assert_ndr_success(tctx, ndr_err, "failed to unmarshall sd");\
 	torture_assert(tctx, test_security_descriptor_equal(tctx, &sd, iname),\
@@ -4250,7 +4250,7 @@ do {\
 	torture_assert_int_equal(tctx, w_type, REG_MULTI_SZ, "unexpected type");\
 	blob = data_blob(w_data, w_size);\
 	torture_assert(tctx, \
-		pull_reg_multi_sz(tctx, lp_iconv_convenience(tctx->lp_ctx), &blob, &array),\
+		pull_reg_multi_sz(tctx, &blob, &array),\
 		"failed to pull multi sz");\
 	for (i=0; array[i] != NULL; i++) {\
 		torture_assert_str_equal(tctx, array[i], iname[i],\
@@ -4591,7 +4591,7 @@ static bool test_SetPrinterData_matrix(struct torture_context *tctx,
 		uint32_t needed;
 
 		torture_assert(tctx,
-			reg_string_to_val(tctx, lp_iconv_convenience(tctx->lp_ctx),
+			reg_string_to_val(tctx, 
 					  "REG_SZ", "dog", &type, &blob), "");
 
 		torture_assert(tctx,
@@ -4748,14 +4748,14 @@ static bool test_SetPrinterDataEx_matrix(struct torture_context *tctx,
 			break;
 		case REG_SZ:
 			torture_assert(tctx,
-				reg_string_to_val(tctx, lp_iconv_convenience(tctx->lp_ctx),
+				reg_string_to_val(tctx, 
 						  "REG_SZ", string, &type, &data), "");
 			offered = data.length;
 			/*strlen_m_term(data.string)*2;*/
 			break;
 		case REG_MULTI_SZ:
 			torture_assert(tctx,
-				reg_string_to_val(tctx, lp_iconv_convenience(tctx->lp_ctx),
+				reg_string_to_val(tctx, 
 						  "REG_SZ", string, &type, &data), "");
 			torture_assert(tctx, data_blob_realloc(tctx, &data, data.length + 2), "");
 			memset(&data.data[data.length - 2], '\0', 2);
@@ -5004,7 +5004,7 @@ do {\
 	torture_assert_int_equal(tctx, type, REG_SZ, "unexpected type");\
 	blob = data_blob_const(data, needed);\
 	torture_assert(tctx,\
-		pull_reg_sz(tctx, lp_iconv_convenience(tctx->lp_ctx), &blob, &str),\
+		pull_reg_sz(tctx, &blob, &str),\
 		"failed to pull REG_SZ");\
 	torture_assert_str_equal(tctx, str, iname, "unexpected result");\
 } while(0);
@@ -5027,7 +5027,7 @@ do {\
 	torture_assert_int_equal(tctx, type, REG_SZ, "unexpected type");\
 	blob = data_blob_const(data, needed);\
 	torture_assert(tctx,\
-		pull_reg_sz(tctx, lp_iconv_convenience(tctx->lp_ctx), &blob, &str),\
+		pull_reg_sz(tctx, &blob, &str),\
 		"failed to pull REG_SZ");\
 	torture_assert_str_equal(tctx, str, val, "unexpected result");\
 } while(0);
@@ -5675,7 +5675,7 @@ static bool test_EnumPrinters_old(struct torture_context *tctx,
 
 		torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
 
-		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+		CHECK_NEEDED_SIZE_ENUM_LEVEL(spoolss_EnumPrinters, info, r.in.level, count, needed, 4);
 
 		if (!info) {
 			torture_comment(tctx, "No printers returned\n");
@@ -5738,7 +5738,7 @@ static bool test_GetPrinterDriver(struct torture_context *tctx,
 	torture_assert_werr_ok(tctx, r.out.result,
 		"failed to call GetPrinterDriver");
 
-	CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+	CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, needed, 4);
 
 	return true;
 }
@@ -5806,7 +5806,7 @@ static bool test_GetPrinterDriver2_level(struct torture_context *tctx,
 	torture_assert_werr_ok(tctx, r.out.result,
 		"failed to call GetPrinterDriver2");
 
-	CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, lp_iconv_convenience(tctx->lp_ctx), needed, 4);
+	CHECK_NEEDED_SIZE_LEVEL(spoolss_DriverInfo, r.out.info, r.in.level, needed, 4);
 
 	if (info_p) {
 		*info_p = *r.out.info;
@@ -7658,7 +7658,6 @@ static bool connect_printer_driver_share(struct torture_context *tctx,
 					tctx->ev,
 					&smb_options,
 					&smb_session_options,
-					lp_iconv_convenience(tctx->lp_ctx),
 					lp_gensec_settings(tctx, tctx->lp_ctx)),
 		"failed to open driver share");
 
diff --git a/source4/torture/rpc/svcctl.c b/source4/torture/rpc/svcctl.c
index 47efb77bfb..8f9ec1aed8 100644
--- a/source4/torture/rpc/svcctl.c
+++ b/source4/torture/rpc/svcctl.c
@@ -438,7 +438,7 @@ static bool test_EnumServicesStatus(struct torture_context *tctx, struct dcerpc_
 		blob.length = r.in.offered;
 		blob.data = talloc_steal(tctx, r.out.service);
 
-		ndr = ndr_pull_init_blob(&blob, tctx, lp_iconv_convenience(tctx->lp_ctx));
+		ndr = ndr_pull_init_blob(&blob, tctx);
 
 		service = talloc_array(tctx, struct ENUM_SERVICE_STATUSW, services_returned);
 		if (!service) {
diff --git a/source4/torture/rpc/winreg.c b/source4/torture/rpc/winreg.c
index 3da8c9125a..216a30c7a8 100644
--- a/source4/torture/rpc/winreg.c
+++ b/source4/torture/rpc/winreg.c
@@ -193,7 +193,7 @@ static bool test_CreateKey_sd(struct dcerpc_binding_handle *b,
 					NULL);
 
 	torture_assert_ndr_success(tctx,
-		ndr_push_struct_blob(&sdblob, tctx, NULL, sd,
+		ndr_push_struct_blob(&sdblob, tctx, sd,
 				     (ndr_push_flags_fn_t)ndr_push_security_descriptor),
 				     "Failed to push security_descriptor ?!\n");
 
@@ -260,7 +260,7 @@ static bool _test_GetKeySecurity(struct dcerpc_pipe *p,
 	sd = talloc_zero(tctx, struct security_descriptor);
 
 	torture_assert_ndr_success(tctx,
-		ndr_pull_struct_blob(&sdblob, tctx, NULL, sd,
+		ndr_pull_struct_blob(&sdblob, tctx, sd,
 				     (ndr_pull_flags_fn_t)ndr_pull_security_descriptor),
 				     "pull_security_descriptor failed");
 
@@ -305,7 +305,7 @@ static bool _test_SetKeySecurity(struct dcerpc_pipe *p,
 	}
 
 	torture_assert_ndr_success(tctx,
-		ndr_push_struct_blob(&sdblob, tctx, NULL, sd,
+		ndr_push_struct_blob(&sdblob, tctx, sd,
 				     (ndr_push_flags_fn_t)ndr_push_security_descriptor),
 				     "push_security_descriptor failed");
 
diff --git a/source4/torture/unix/unix_info2.c b/source4/torture/unix/unix_info2.c
index 2068d5d97c..32cc9ac487 100644
--- a/source4/torture/unix/unix_info2.c
+++ b/source4/torture/unix/unix_info2.c
@@ -62,7 +62,6 @@ static struct smbcli_state *connect_to_server(struct torture_context *tctx)
 					cmdline_credentials, 
 					lp_resolve_context(tctx->lp_ctx),
 					tctx->ev, &options, &session_options,
-					lp_iconv_convenience(tctx->lp_ctx),
 					lp_gensec_settings(tctx, tctx->lp_ctx));
 
 	if (!NT_STATUS_IS_OK(status)) {
diff --git a/source4/torture/unix/whoami.c b/source4/torture/unix/whoami.c
index f07c619b30..c1849962a3 100644
--- a/source4/torture/unix/whoami.c
+++ b/source4/torture/unix/whoami.c
@@ -85,7 +85,6 @@ static struct smbcli_state *connect_to_server(struct torture_context *tctx,
 					share, NULL, lp_socket_options(tctx->lp_ctx),
 					creds, lp_resolve_context(tctx->lp_ctx),
 					tctx->ev, &options, &session_options,
-					lp_iconv_convenience(tctx->lp_ctx),
 					lp_gensec_settings(tctx, tctx->lp_ctx));
 
 	if (!NT_STATUS_IS_OK(status)) {
diff --git a/source4/torture/util_smb.c b/source4/torture/util_smb.c
index 216927ce70..708055096b 100644
--- a/source4/torture/util_smb.c
+++ b/source4/torture/util_smb.c
@@ -515,7 +515,6 @@ _PUBLIC_ bool torture_open_connection_share(TALLOC_CTX *mem_ctx,
 					cmdline_credentials, 
 					lp_resolve_context(tctx->lp_ctx),
 					ev, &options, &session_options,
-					lp_iconv_convenience(tctx->lp_ctx),
 					lp_gensec_settings(tctx, tctx->lp_ctx));
 	if (!NT_STATUS_IS_OK(status)) {
 		printf("Failed to open connection - %s\n", nt_errstr(status));