TDR_PULL_NEED_BYTES(tdr, el_size*length);
- if (!convert_string_talloc_convenience(ctx, tdr->iconv_convenience, chset, CH_UNIX, tdr->data.data+tdr->offset, el_size*length, discard_const_p(void *, v), &ret, false)) {
+ if (!convert_string_talloc(ctx, chset, CH_UNIX, tdr->data.data+tdr->offset, el_size*length, discard_const_p(void *, v), &ret, false)) {
return NT_STATUS_INVALID_PARAMETER;
}
required = el_size * length;
TDR_PUSH_NEED_BYTES(tdr, required);
- if (!convert_string_convenience(tdr->iconv_convenience, CH_UNIX, chset, *v, strlen(*v), tdr->data.data+tdr->data.length, required, &ret, false)) {
+ ret = convert_string(CH_UNIX, chset, *v, strlen(*v), tdr->data.data+tdr->data.length, required, false);
+ if (ret == -1) {
return NT_STATUS_INVALID_PARAMETER;
}
return NT_STATUS_OK;
}
-struct tdr_push *tdr_push_init(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic)
+struct tdr_push *tdr_push_init(TALLOC_CTX *mem_ctx)
{
struct tdr_push *push = talloc_zero(mem_ctx, struct tdr_push);
if (push == NULL)
return NULL;
- push->iconv_convenience = talloc_reference(push, ic);
-
return push;
}
-struct tdr_pull *tdr_pull_init(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic)
+struct tdr_pull *tdr_pull_init(TALLOC_CTX *mem_ctx)
{
struct tdr_pull *pull = talloc_zero(mem_ctx, struct tdr_pull);
if (pull == NULL)
return NULL;
- pull->iconv_convenience = talloc_reference(pull, ic);
-
return pull;
}
-NTSTATUS tdr_push_to_fd(int fd, struct smb_iconv_convenience *iconv_convenience, tdr_push_fn_t push_fn, const void *p)
+NTSTATUS tdr_push_to_fd(int fd, tdr_push_fn_t push_fn, const void *p)
{
- struct tdr_push *push = tdr_push_init(NULL, iconv_convenience);
+ struct tdr_push *push = tdr_push_init(NULL);
if (push == NULL)
return NT_STATUS_NO_MEMORY;
DATA_BLOB data;
uint32_t offset;
int flags;
- struct smb_iconv_convenience *iconv_convenience;
};
struct tdr_push {
DATA_BLOB data;
int flags;
- struct smb_iconv_convenience *iconv_convenience;
};
struct tdr_print {
static bool test_push_uint8(struct torture_context *tctx)
{
uint8_t v = 4;
- struct tdr_push *tdr = tdr_push_init(tctx, global_iconv_convenience);
+ struct tdr_push *tdr = tdr_push_init(tctx);
torture_assert_ntstatus_ok(tctx, tdr_push_uint8(tdr, &v), "push failed");
torture_assert_int_equal(tctx, tdr->data.length, 1, "length incorrect");
{
uint8_t d = 2;
uint8_t l;
- struct tdr_pull *tdr = tdr_pull_init(tctx, global_iconv_convenience);
+ struct tdr_pull *tdr = tdr_pull_init(tctx);
tdr->data.data = &d;
tdr->data.length = 1;
tdr->offset = 0;
static bool test_push_uint16(struct torture_context *tctx)
{
uint16_t v = 0xF32;
- struct tdr_push *tdr = tdr_push_init(tctx, global_iconv_convenience);
+ struct tdr_push *tdr = tdr_push_init(tctx);
torture_assert_ntstatus_ok(tctx, tdr_push_uint16(tdr, &v), "push failed");
torture_assert_int_equal(tctx, tdr->data.length, 2, "length incorrect");
{
uint8_t d[2] = { 782 & 0xFF, (782 & 0xFF00) / 0x100 };
uint16_t l;
- struct tdr_pull *tdr = tdr_pull_init(tctx, global_iconv_convenience);
+ struct tdr_pull *tdr = tdr_pull_init(tctx);
tdr->data.data = d;
tdr->data.length = 2;
tdr->offset = 0;
static bool test_push_uint32(struct torture_context *tctx)
{
uint32_t v = 0x100F32;
- struct tdr_push *tdr = tdr_push_init(tctx, global_iconv_convenience);
+ struct tdr_push *tdr = tdr_push_init(tctx);
torture_assert_ntstatus_ok(tctx, tdr_push_uint32(tdr, &v), "push failed");
torture_assert_int_equal(tctx, tdr->data.length, 4, "length incorrect");
{
uint8_t d[4] = { 782 & 0xFF, (782 & 0xFF00) / 0x100, 0, 0 };
uint32_t l;
- struct tdr_pull *tdr = tdr_pull_init(tctx, global_iconv_convenience);
+ struct tdr_pull *tdr = tdr_pull_init(tctx);
tdr->data.data = d;
tdr->data.length = 4;
tdr->offset = 0;
static bool test_pull_charset(struct torture_context *tctx)
{
- struct tdr_pull *tdr = tdr_pull_init(tctx, global_iconv_convenience);
+ struct tdr_pull *tdr = tdr_pull_init(tctx);
const char *l = NULL;
tdr->data.data = (uint8_t *)talloc_strdup(tctx, "bla");
tdr->data.length = 4;
static bool test_pull_charset_empty(struct torture_context *tctx)
{
- struct tdr_pull *tdr = tdr_pull_init(tctx, global_iconv_convenience);
+ struct tdr_pull *tdr = tdr_pull_init(tctx);
const char *l = NULL;
tdr->data.data = (uint8_t *)talloc_strdup(tctx, "bla");
tdr->data.length = 4;
static bool test_push_charset(struct torture_context *tctx)
{
const char *l = "bloe";
- struct tdr_push *tdr = tdr_push_init(tctx, global_iconv_convenience);
+ struct tdr_push *tdr = tdr_push_init(tctx);
torture_assert_ntstatus_ok(tctx, tdr_push_charset(tdr, &l, 4, 1, CH_UTF8),
"push failed");
torture_assert_int_equal(tctx, 4, tdr->data.length, "offset invalid");
#include "../librpc/gen_ndr/ndr_ntlmssp.h"
#include "../libcli/auth/ntlmssp_ndr.h"
-#define NTLMSSP_PULL_MESSAGE(type, blob, mem_ctx, ic, r) \
+#define NTLMSSP_PULL_MESSAGE(type, blob, mem_ctx, r) \
do { \
enum ndr_err_code __ndr_err; \
- __ndr_err = ndr_pull_struct_blob(blob, mem_ctx, ic, r, \
+ __ndr_err = ndr_pull_struct_blob(blob, mem_ctx, r, \
(ndr_pull_flags_fn_t)ndr_pull_ ##type); \
if (!NDR_ERR_CODE_IS_SUCCESS(__ndr_err)) { \
return ndr_map_error2ntstatus(__ndr_err); \
NTSTATUS ntlmssp_pull_NEGOTIATE_MESSAGE(const DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
struct NEGOTIATE_MESSAGE *r)
{
- NTLMSSP_PULL_MESSAGE(NEGOTIATE_MESSAGE, blob, mem_ctx, ic, r);
+ NTLMSSP_PULL_MESSAGE(NEGOTIATE_MESSAGE, blob, mem_ctx, r);
}
/**
NTSTATUS ntlmssp_pull_CHALLENGE_MESSAGE(const DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
struct CHALLENGE_MESSAGE *r)
{
- NTLMSSP_PULL_MESSAGE(CHALLENGE_MESSAGE, blob, mem_ctx, ic, r);
+ NTLMSSP_PULL_MESSAGE(CHALLENGE_MESSAGE, blob, mem_ctx, r);
}
/**
NTSTATUS ntlmssp_pull_AUTHENTICATE_MESSAGE(const DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
struct AUTHENTICATE_MESSAGE *r)
{
- NTLMSSP_PULL_MESSAGE(AUTHENTICATE_MESSAGE, blob, mem_ctx, ic, r);
+ NTLMSSP_PULL_MESSAGE(AUTHENTICATE_MESSAGE, blob, mem_ctx, r);
}
/**
NTSTATUS ntlmssp_push_NEGOTIATE_MESSAGE(DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const struct NEGOTIATE_MESSAGE *r)
{
- NTLMSSP_PUSH_MESSAGE(NEGOTIATE_MESSAGE, blob, mem_ctx, ic, r);
+ NTLMSSP_PUSH_MESSAGE(NEGOTIATE_MESSAGE, blob, mem_ctx, r);
}
/**
NTSTATUS ntlmssp_push_CHALLENGE_MESSAGE(DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const struct CHALLENGE_MESSAGE *r)
{
- NTLMSSP_PUSH_MESSAGE(CHALLENGE_MESSAGE, blob, mem_ctx, ic, r);
+ NTLMSSP_PUSH_MESSAGE(CHALLENGE_MESSAGE, blob, mem_ctx, r);
}
/**
NTSTATUS ntlmssp_push_AUTHENTICATE_MESSAGE(DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const struct AUTHENTICATE_MESSAGE *r)
{
- NTLMSSP_PUSH_MESSAGE(AUTHENTICATE_MESSAGE, blob, mem_ctx, ic, r);
+ NTLMSSP_PUSH_MESSAGE(AUTHENTICATE_MESSAGE, blob, mem_ctx, r);
}
NTSTATUS ntlmssp_pull_NEGOTIATE_MESSAGE(const DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
struct NEGOTIATE_MESSAGE *r);
NTSTATUS ntlmssp_pull_CHALLENGE_MESSAGE(const DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
struct CHALLENGE_MESSAGE *r);
NTSTATUS ntlmssp_pull_AUTHENTICATE_MESSAGE(const DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
struct AUTHENTICATE_MESSAGE *r);
NTSTATUS ntlmssp_push_NEGOTIATE_MESSAGE(DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const struct NEGOTIATE_MESSAGE *r);
NTSTATUS ntlmssp_push_CHALLENGE_MESSAGE(DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const struct CHALLENGE_MESSAGE *r);
NTSTATUS ntlmssp_push_AUTHENTICATE_MESSAGE(DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const struct AUTHENTICATE_MESSAGE *r);
#define _LIBCLI_AUTH_SCHANNEL_STATE_H__
NTSTATUS schannel_get_creds_state(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const char *db_priv_dir,
const char *computer_name,
struct netlogon_creds_CredentialState **creds);
NTSTATUS schannel_save_creds_state(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const char *db_priv_dir,
struct netlogon_creds_CredentialState *creds);
NTSTATUS schannel_check_creds_state(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const char *db_priv_dir,
const char *computer_name,
struct netr_Authenticator *received_authenticator,
static
NTSTATUS schannel_store_session_key_tdb(struct tdb_wrap *tdb_sc,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
struct netlogon_creds_CredentialState *creds)
{
enum ndr_err_code ndr_err;
return NT_STATUS_NO_MEMORY;
}
- ndr_err = ndr_push_struct_blob(&blob, mem_ctx, ic, creds,
+ ndr_err = ndr_push_struct_blob(&blob, mem_ctx, creds,
(ndr_push_flags_fn_t)ndr_push_netlogon_creds_CredentialState);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(keystr);
static
NTSTATUS schannel_fetch_session_key_tdb(struct tdb_wrap *tdb_sc,
TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const char *computer_name,
struct netlogon_creds_CredentialState **pcreds)
{
blob = data_blob_const(value.dptr, value.dsize);
- ndr_err = ndr_pull_struct_blob(&blob, creds, ic, creds,
+ ndr_err = ndr_pull_struct_blob(&blob, creds, creds,
(ndr_pull_flags_fn_t)ndr_pull_netlogon_creds_CredentialState);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
*******************************************************************************/
NTSTATUS schannel_get_creds_state(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const char *db_priv_dir,
const char *computer_name,
struct netlogon_creds_CredentialState **_creds)
return NT_STATUS_ACCESS_DENIED;
}
- status = schannel_fetch_session_key_tdb(tdb_sc, tmpctx, ic,
+ status = schannel_fetch_session_key_tdb(tdb_sc, tmpctx,
computer_name, &creds);
if (NT_STATUS_IS_OK(status)) {
*_creds = talloc_steal(mem_ctx, creds);
*******************************************************************************/
NTSTATUS schannel_save_creds_state(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const char *db_priv_dir,
struct netlogon_creds_CredentialState *creds)
{
return NT_STATUS_ACCESS_DENIED;
}
- status = schannel_store_session_key_tdb(tdb_sc, tmpctx, ic, creds);
+ status = schannel_store_session_key_tdb(tdb_sc, tmpctx, creds);
talloc_free(tmpctx);
return status;
********************************************************************/
NTSTATUS schannel_check_creds_state(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const char *db_priv_dir,
const char *computer_name,
struct netr_Authenticator *received_authenticator,
* disconnects) we must update the database every time we
* update the structure */
- status = schannel_fetch_session_key_tdb(tdb_sc, tmpctx, ic,
+ status = schannel_fetch_session_key_tdb(tdb_sc, tmpctx,
computer_name, &creds);
if (!NT_STATUS_IS_OK(status)) {
tdb_transaction_cancel(tdb_sc->tdb);
goto done;
}
- status = schannel_store_session_key_tdb(tdb_sc, tmpctx, ic, creds);
+ status = schannel_store_session_key_tdb(tdb_sc, tmpctx, creds);
if (!NT_STATUS_IS_OK(status)) {
tdb_transaction_cancel(tdb_sc->tdb);
goto done;
receive a cldap netlogon reply
*/
NTSTATUS cldap_netlogon_recv(struct tevent_req *req,
- struct smb_iconv_convenience *iconv_convenience,
TALLOC_CTX *mem_ctx,
struct cldap_netlogon *io)
{
data = state->search.out.response->attributes[0].values;
status = pull_netlogon_samlogon_response(data, mem_ctx,
- iconv_convenience,
&io->out.netlogon);
if (!NT_STATUS_IS_OK(status)) {
goto failed;
sync cldap netlogon search
*/
NTSTATUS cldap_netlogon(struct cldap_socket *cldap,
- struct smb_iconv_convenience *iconv_convenience,
TALLOC_CTX *mem_ctx,
struct cldap_netlogon *io)
{
return NT_STATUS_INTERNAL_ERROR;
}
- status = cldap_netlogon_recv(req, iconv_convenience, mem_ctx, io);
+ status = cldap_netlogon_recv(req, mem_ctx, io);
talloc_free(req);
return status;
send a netlogon reply
*/
NTSTATUS cldap_netlogon_reply(struct cldap_socket *cldap,
- struct smb_iconv_convenience *iconv_convenience,
uint32_t message_id,
struct tsocket_address *dest,
uint32_t version,
DATA_BLOB blob;
status = push_netlogon_samlogon_response(&blob, tmp_ctx,
- iconv_convenience,
netlogon);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(tmp_ctx);
struct cldap_socket *cldap,
const struct cldap_netlogon *io);
NTSTATUS cldap_netlogon_recv(struct tevent_req *req,
- struct smb_iconv_convenience *iconv_convenience,
TALLOC_CTX *mem_ctx,
struct cldap_netlogon *io);
NTSTATUS cldap_netlogon(struct cldap_socket *cldap,
- struct smb_iconv_convenience *iconv_convenience,
TALLOC_CTX *mem_ctx,
struct cldap_netlogon *io);
NTSTATUS cldap_netlogon_reply(struct cldap_socket *cldap,
- struct smb_iconv_convenience *iconv_convenience,
uint32_t message_id,
struct tsocket_address *dst,
uint32_t version,
DATA_BLOB blob;
enum ndr_err_code ndr_err;
char *ret;
- ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, sid,
+ ndr_err = ndr_push_struct_blob(&blob, mem_ctx, sid,
(ndr_push_flags_fn_t)ndr_push_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return NULL;
blob.data = val.data;
blob.length = val.length;
- ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, NULL, guid,
+ ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, guid,
(ndr_pull_flags_fn_t)ndr_pull_GUID);
talloc_free(val.data);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
struct tstream_npa_connect_state {
struct {
struct tevent_context *ev;
- struct smb_iconv_convenience *smb_iconv_c;
} caller;
const char *unix_path;
struct tevent_req *tstream_npa_connect_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
- struct smb_iconv_convenience *smb_iconv_c,
const char *directory,
const char *npipe,
const struct tsocket_address *client,
}
state->caller.ev = ev;
- state->caller.smb_iconv_c = smb_iconv_c;
state->unix_path = talloc_asprintf(state, "%s/%s",
directory,
}
ndr_err = ndr_push_struct_blob(&state->auth_req_blob,
- state, smb_iconv_c, &state->auth_req,
+ state, &state->auth_req,
(ndr_push_flags_fn_t)ndr_push_named_pipe_auth_req);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
tevent_req_error(req, EINVAL);
ndr_err = ndr_pull_struct_blob(
&state->auth_rep_blob, state,
- state->caller.smb_iconv_c, &state->auth_rep,
+ &state->auth_rep,
(ndr_pull_flags_fn_t)ndr_pull_named_pipe_auth_rep);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
struct tevent_req *tstream_npa_connect_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
- struct smb_iconv_convenience *smb_iconv_c,
const char *directory,
const char *npipe,
const struct tsocket_address *client,
struct nbt_name_socket {
struct socket_context *sock;
struct tevent_context *event_ctx;
- struct smb_iconv_convenience *iconv_convenience;
/* a queue of requests pending to be sent */
struct nbt_name_request *send_queue;
};
struct nbt_name_socket *nbt_name_socket_init(TALLOC_CTX *mem_ctx,
- struct tevent_context *event_ctx,
- struct smb_iconv_convenience *iconv_convenience);
+ struct tevent_context *event_ctx);
void nbt_name_socket_handle_response_packet(struct nbt_name_request *req,
struct nbt_name_packet *packet,
struct socket_address *src);
TALLOC_CTX *mem_ctx, struct nbt_name_status *io);
NTSTATUS nbt_name_dup(TALLOC_CTX *mem_ctx, struct nbt_name *name, struct nbt_name *newname);
-NTSTATUS nbt_name_to_blob(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, DATA_BLOB *blob, struct nbt_name *name);
+NTSTATUS nbt_name_to_blob(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, struct nbt_name *name);
NTSTATUS nbt_name_from_blob(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, struct nbt_name *name);
void nbt_choose_called_name(TALLOC_CTX *mem_ctx, struct nbt_name *n, const char *name, int type);
char *nbt_name_string(TALLOC_CTX *mem_ctx, const struct nbt_name *name);
/**
push a nbt name into a blob
*/
-_PUBLIC_ NTSTATUS nbt_name_to_blob(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, DATA_BLOB *blob, struct nbt_name *name)
+_PUBLIC_ NTSTATUS nbt_name_to_blob(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, struct nbt_name *name)
{
enum ndr_err_code ndr_err;
- ndr_err = ndr_push_struct_blob(blob, mem_ctx, iconv_convenience, name, (ndr_push_flags_fn_t)ndr_push_nbt_name);
+ ndr_err = ndr_push_struct_blob(blob, mem_ctx, name, (ndr_push_flags_fn_t)ndr_push_nbt_name);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return ndr_map_error2ntstatus(ndr_err);
}
{
enum ndr_err_code ndr_err;
- ndr_err = ndr_pull_struct_blob(blob, mem_ctx, NULL, name,
+ ndr_err = ndr_pull_struct_blob(blob, mem_ctx, name,
(ndr_pull_flags_fn_t)ndr_pull_nbt_name);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return ndr_map_error2ntstatus(ndr_err);
}
/* parse the request */
- ndr_err = ndr_pull_struct_blob(&blob, packet, nbtsock->iconv_convenience, packet,
+ ndr_err = ndr_pull_struct_blob(&blob, packet, packet,
(ndr_pull_flags_fn_t)ndr_pull_nbt_name_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
then operations will use that event context
*/
_PUBLIC_ struct nbt_name_socket *nbt_name_socket_init(TALLOC_CTX *mem_ctx,
- struct tevent_context *event_ctx,
- struct smb_iconv_convenience *iconv_convenience)
+ struct tevent_context *event_ctx)
{
struct nbt_name_socket *nbtsock;
NTSTATUS status;
nbtsock->num_pending = 0;
nbtsock->incoming.handler = NULL;
nbtsock->unexpected.handler = NULL;
- nbtsock->iconv_convenience = iconv_convenience;
nbtsock->fde = event_add_fd(nbtsock->event_ctx, nbtsock,
socket_get_fd(nbtsock->sock), 0,
talloc_set_destructor(req, nbt_name_request_destructor);
ndr_err = ndr_push_struct_blob(&req->encoded, req,
- req->nbtsock->iconv_convenience,
request,
(ndr_push_flags_fn_t)ndr_push_nbt_name_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) goto failed;
}
ndr_err = ndr_push_struct_blob(&req->encoded, req,
- req->nbtsock->iconv_convenience,
request,
(ndr_push_flags_fn_t)ndr_push_nbt_name_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return NULL;
ev = s4_event_context_init(ret->mem_ctx);
- ret->socket = nbt_name_socket_init(ret->mem_ctx, ev, py_iconv_convenience(ret->mem_ctx));
+ ret->socket = nbt_name_socket_init(ret->mem_ctx, ev);
return (PyObject *)ret;
}
return false;
}
-static PyObject *PyObject_FromNBTName(struct nbt_name_socket *name_socket, struct smb_iconv_convenience *ic,
+static PyObject *PyObject_FromNBTName(struct nbt_name_socket *name_socket,
struct nbt_name *name)
{
if (name->scope) {
return NULL;
PyTuple_SetItem(ret, 0, PyString_FromString(io.out.reply_from));
- py_name = PyObject_FromNBTName(node->socket, py_iconv_convenience(node->socket), &io.out.name);
+ py_name = PyObject_FromNBTName(node->socket, &io.out.name);
if (py_name == NULL)
return NULL;
return NULL;
PyTuple_SetItem(ret, 0, PyString_FromString(io.out.reply_from));
- py_name = PyObject_FromNBTName(node->socket, py_iconv_convenience(NULL), &io.out.name);
+ py_name = PyObject_FromNBTName(node->socket, &io.out.name);
if (py_name == NULL)
return NULL;
return NULL;
PyTuple_SetItem(ret, 0, PyString_FromString(io.out.reply_from));
- py_name = PyObject_FromNBTName(node->socket, py_iconv_convenience(NULL), &io.out.name);
+ py_name = PyObject_FromNBTName(node->socket, &io.out.name);
if (py_name == NULL)
return NULL;
return NULL;
PyTuple_SetItem(ret, 0, PyString_FromString(io.out.reply_from));
- py_name = PyObject_FromNBTName(node->socket, py_iconv_convenience(NULL), &io.out.name);
+ py_name = PyObject_FromNBTName(node->socket, &io.out.name);
if (py_name == NULL)
return NULL;
node_name = talloc_strdup(tmp_ctx, name);
}
- nbtsock = nbt_name_socket_init(tmp_ctx, ev, lp_iconv_convenience(lp_ctx));
+ nbtsock = nbt_name_socket_init(tmp_ctx, ev);
if (options.root_port) {
all_zero_addr = socket_address_from_strings(tmp_ctx, nbtsock->sock->backend_name,
NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->server_site));
NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->client_site));
if (r->nt_version & NETLOGON_NT_VERSION_5EX_WITH_IP) {
- NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->iconv_convenience, ndr->flags)));
+ NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->flags)));
{
struct ndr_push *_ndr_sockaddr;
- NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sockaddr, 0, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->iconv_convenience, ndr->flags)));
+ NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sockaddr, 0, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->flags)));
NDR_CHECK(ndr_push_nbt_sockaddr(_ndr_sockaddr, NDR_SCALARS|NDR_BUFFERS, &r->sockaddr));
- NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sockaddr, 0, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->iconv_convenience, ndr->flags)));
+ NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sockaddr, 0, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->flags)));
}
}
if (r->nt_version & NETLOGON_NT_VERSION_WITH_CLOSEST_SITE) {
#define DEBUGLEVEL 0
NTSTATUS push_netlogon_samlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct netlogon_samlogon_response *response)
{
enum ndr_err_code ndr_err;
if (response->ntver == NETLOGON_NT_VERSION_1) {
ndr_err = ndr_push_struct_blob(data, mem_ctx,
- iconv_convenience,
&response->data.nt4,
(ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_NT40);
} else if (response->ntver & NETLOGON_NT_VERSION_5EX) {
ndr_err = ndr_push_struct_blob(data, mem_ctx,
- iconv_convenience,
&response->data.nt5_ex,
(ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX_with_flags);
} else if (response->ntver & NETLOGON_NT_VERSION_5) {
ndr_err = ndr_push_struct_blob(data, mem_ctx,
- iconv_convenience,
&response->data.nt5,
(ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE);
} else {
}
NTSTATUS pull_netlogon_samlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct netlogon_samlogon_response *response)
{
uint32_t ntver;
if (ntver == NETLOGON_NT_VERSION_1) {
ndr_err = ndr_pull_struct_blob_all(data, mem_ctx,
- iconv_convenience,
&response->data.nt4,
(ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_NT40);
response->ntver = NETLOGON_NT_VERSION_1;
} else if (ntver & NETLOGON_NT_VERSION_5EX) {
struct ndr_pull *ndr;
- ndr = ndr_pull_init_blob(data, mem_ctx, iconv_convenience);
+ ndr = ndr_pull_init_blob(data, mem_ctx);
if (!ndr) {
return NT_STATUS_NO_MEMORY;
}
} else if (ntver & NETLOGON_NT_VERSION_5) {
ndr_err = ndr_pull_struct_blob_all(data, mem_ctx,
- iconv_convenience,
&response->data.nt5,
(ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE);
response->ntver = NETLOGON_NT_VERSION_5;
}
NTSTATUS push_nbt_netlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct nbt_netlogon_response *response)
{
NTSTATUS status = NT_STATUS_INVALID_NETWORK_RESPONSE;
switch (response->response_type) {
case NETLOGON_GET_PDC:
ndr_err = ndr_push_struct_blob(data, mem_ctx,
- iconv_convenience,
&response->data.get_pdc,
(ndr_push_flags_fn_t)ndr_push_nbt_netlogon_response_from_pdc);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
break;
case NETLOGON_SAMLOGON:
status = push_netlogon_samlogon_response(
- data, mem_ctx, iconv_convenience,
+ data, mem_ctx,
&response->data.samlogon);
break;
}
NTSTATUS pull_nbt_netlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct nbt_netlogon_response *response)
{
NTSTATUS status = NT_STATUS_INVALID_NETWORK_RESPONSE;
switch (command) {
case NETLOGON_RESPONSE_FROM_PDC:
ndr_err = ndr_pull_struct_blob_all(data, mem_ctx,
- iconv_convenience,
&response->data.get_pdc,
(ndr_pull_flags_fn_t)ndr_pull_nbt_netlogon_response_from_pdc);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
case LOGON_SAM_LOGON_PAUSE_RESPONSE_EX:
case LOGON_SAM_LOGON_USER_UNKNOWN_EX:
status = pull_netlogon_samlogon_response(
- data, mem_ctx, iconv_convenience,
+ data, mem_ctx,
&response->data.samlogon);
response->response_type = NETLOGON_SAMLOGON;
break;
/* The following definitions come from ../libcli/netlogon.c */
NTSTATUS push_netlogon_samlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct netlogon_samlogon_response *response);
NTSTATUS pull_netlogon_samlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct netlogon_samlogon_response *response);
void map_netlogon_samlogon_response(struct netlogon_samlogon_response *response);
NTSTATUS push_nbt_netlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct nbt_netlogon_response *response);
NTSTATUS pull_nbt_netlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct nbt_netlogon_response *response);
#undef _PRINTF_ATTRIBUTE
#define _PRINTF_ATTRIBUTE(a1, a2)
push a string in unix charset into a REG_SZ UCS2 null terminated blob
********************************************************************/
-bool push_reg_sz(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic,
- DATA_BLOB *blob, const char *s)
+bool push_reg_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *s)
{
union winreg_Data data;
enum ndr_err_code ndr_err;
data.string = s;
- ndr_err = ndr_push_union_blob(blob, mem_ctx, ic, &data, REG_SZ,
+ ndr_err = ndr_push_union_blob(blob, mem_ctx, &data, REG_SZ,
(ndr_push_flags_fn_t)ndr_push_winreg_Data);
return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
}
terminated blob
********************************************************************/
-bool push_reg_multi_sz(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic,
- DATA_BLOB *blob, const char **a)
+bool push_reg_multi_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char **a)
{
union winreg_Data data;
enum ndr_err_code ndr_err;
data.string_array = a;
- ndr_err = ndr_push_union_blob(blob, mem_ctx, ic, &data, REG_MULTI_SZ,
+ ndr_err = ndr_push_union_blob(blob, mem_ctx, &data, REG_MULTI_SZ,
(ndr_push_flags_fn_t)ndr_push_winreg_Data);
return NDR_ERR_CODE_IS_SUCCESS(ndr_err);
}
pull a string in unix charset out of a REG_SZ UCS2 null terminated blob
********************************************************************/
-bool pull_reg_sz(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic,
- const DATA_BLOB *blob, const char **s)
+bool pull_reg_sz(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, const char **s)
{
union winreg_Data data;
enum ndr_err_code ndr_err;
- ndr_err = ndr_pull_union_blob(blob, mem_ctx, ic, &data, REG_SZ,
+ ndr_err = ndr_pull_union_blob(blob, mem_ctx, &data, REG_SZ,
(ndr_pull_flags_fn_t)ndr_pull_winreg_Data);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return false;
terminated blob
********************************************************************/
-bool pull_reg_multi_sz(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic,
+bool pull_reg_multi_sz(TALLOC_CTX *mem_ctx,
const DATA_BLOB *blob, const char ***a)
{
union winreg_Data data;
enum ndr_err_code ndr_err;
- ndr_err = ndr_pull_union_blob(blob, mem_ctx, ic, &data, REG_MULTI_SZ,
+ ndr_err = ndr_pull_union_blob(blob, mem_ctx, &data, REG_MULTI_SZ,
(ndr_pull_flags_fn_t)ndr_pull_winreg_Data);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return false;
user->user_private_info.SensitiveData = data.data;
user->user_private_info.DataLength = data.length;
- ndr_err = ndr_pull_struct_blob(&data, mem_ctx, NULL, &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)) {
dump_data(10, data.data, data.length);
{
t->type = type;
t->flags = flag;
- t->size = ndr_size_dom_sid(sid, NULL, 0) + 8;
+ t->size = ndr_size_dom_sid(sid, 0) + 8;
t->access_mask = mask;
t->trustee = *sid;
(*pp_new)[i].type = SEC_ACE_TYPE_ACCESS_ALLOWED;
(*pp_new)[i].flags = 0;
- (*pp_new)[i].size = SEC_ACE_HEADER_SIZE + ndr_size_dom_sid(sid, NULL, 0);
+ (*pp_new)[i].size = SEC_ACE_HEADER_SIZE + ndr_size_dom_sid(sid, 0);
(*pp_new)[i].access_mask = mask;
(*pp_new)[i].trustee = *sid;
return NT_STATUS_OK;
typedef [public,gensize,flag(NDR_PAHEX)] struct {
/* this includes the 8 bytes of the repsFromToBlob header */
- [value(ndr_size_repsFromTo1(this, ndr->iconv_convenience, ndr->flags)+8)] uint32 blobsize;
+ [value(ndr_size_repsFromTo1(this, ndr->flags)+8)] uint32 blobsize;
uint32 consecutive_sync_failures;
NTTIME_1sec last_success;
NTTIME_1sec last_attempt;
WERROR result_last_attempt;
[relative] repsFromTo1OtherInfo *other_info;
- [value(ndr_size_repsFromTo1OtherInfo(other_info, ndr->iconv_convenience, ndr->flags))] uint32 other_info_length;
+ [value(ndr_size_repsFromTo1OtherInfo(other_info, ndr->flags))] uint32 other_info_length;
drsuapi_DrsOptions replica_flags;
uint8 schedule[84];
[value(0)] uint32 reserved;
} repsFromTo1;
typedef [public,relative_base,gensize] struct {
- [value(ndr_size_repsFromTo2OtherInfo(this,ndr->iconv_convenience, ndr->flags))]
+ [value(ndr_size_repsFromTo2OtherInfo(this,ndr->flags))]
uint32 __ndr_size;
[relative] nstring *dns_name1;
uint32 unknown1;
typedef [public,gensize,flag(NDR_PAHEX)] struct {
/* this includes the 8 bytes of the repsFromToBlob header */
- [value(ndr_size_repsFromTo2(this, ndr->iconv_convenience, ndr->flags)+8)] uint32 blobsize;
+ [value(ndr_size_repsFromTo2(this, ndr->flags)+8)] uint32 blobsize;
uint32 consecutive_sync_failures;
NTTIME_1sec last_success;
NTTIME_1sec last_attempt;
WERROR result_last_attempt;
[relative] repsFromTo2OtherInfo *other_info;
- [value(ndr_size_repsFromTo2OtherInfo(other_info, ndr->iconv_convenience, ndr->flags))] uint32 other_info_length;
+ [value(ndr_size_repsFromTo2OtherInfo(other_info, ndr->flags))] uint32 other_info_length;
drsuapi_DrsOptions replica_flags;
uint8 schedule[84];
[value(0)] uint32 reserved;
typedef [public,gensize] struct {
uint32 num_entries;
- [value(ndr_size_drsuapi_MSPrefixMap_Ctr(r, ndr->iconv_convenience, ndr->flags))] uint32 __ndr_size;
+ [value(ndr_size_drsuapi_MSPrefixMap_Ctr(r, ndr->flags))] uint32 __ndr_size;
drsuapi_MSPrefixMap_Entry entries[num_entries];
} drsuapi_MSPrefixMap_Ctr;
NTTIME time;
uint32 u2;
uint32 u3;
- [value(ndr_size_ldapControlDirSyncExtra(&extra, extra.uptodateness_vector.version, ndr->iconv_convenience, 0))]
+ [value(ndr_size_ldapControlDirSyncExtra(&extra, extra.uptodateness_vector.version, 0))]
uint32 extra_length;
drsuapi_DsReplicaHighWaterMark highwatermark;
GUID guid1;
typedef [public] struct {
[value(0)] uint32 unknown1;
- [value(ndr_size_supplementalCredentialsSubBlob(&sub, ndr->iconv_convenience, ndr->flags))] uint32 __ndr_size;
+ [value(ndr_size_supplementalCredentialsSubBlob(&sub, ndr->flags))] uint32 __ndr_size;
[value(0)] uint32 unknown2;
[subcontext(0),subcontext_size(__ndr_size)] supplementalCredentialsSubBlob sub;
[value(0)] uint8 unknown3;
uint8 confounder[512];
[subcontext(0),subcontext_size(outgoing_size)] trustCurrentPasswords outgoing;
[subcontext(0),subcontext_size(incoming_size)] trustCurrentPasswords incoming;
- [value(ndr_size_trustCurrentPasswords(&outgoing, ndr->iconv_convenience, ndr->flags))] uint32 outgoing_size;
- [value(ndr_size_trustCurrentPasswords(&incoming, ndr->iconv_convenience, ndr->flags))] uint32 incoming_size;
+ [value(ndr_size_trustCurrentPasswords(&outgoing, ndr->flags))] uint32 outgoing_size;
+ [value(ndr_size_trustCurrentPasswords(&incoming, ndr->flags))] uint32 incoming_size;
} trustDomainPasswords;
[nopython] void decode_trustDomainPasswords(
} ForestTrustInfoRecord;
typedef [flag(NDR_NOALIGN)] struct {
- [value(ndr_size_ForestTrustInfoRecord(&record, ndr->iconv_convenience, ndr->flags))] uint32 record_size;
+ [value(ndr_size_ForestTrustInfoRecord(&record, ndr->flags))] uint32 record_size;
ForestTrustInfoRecord record;
} ForestTrustInfoRecordArmor;
/*****************/
/* Function 0x02 */
typedef [public,gensize] struct {
- [value(ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags)-4)] uint32 __ndr_size;
+ [value(ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->flags)-4)] uint32 __ndr_size;
[value(ndr_size_dom_sid28(&sid, ndr->flags))] uint32 __ndr_size_sid;
GUID guid;
dom_sid28 sid;
/* DN String values */
typedef [public,gensize] struct {
- [value(ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags))] uint32 __ndr_size;
+ [value(ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->flags))] uint32 __ndr_size;
[value(ndr_size_dom_sid28(&sid,ndr->flags))] uint32 __ndr_size_sid;
GUID guid;
dom_sid28 sid;
} drsuapi_DsReplicaObjectIdentifier3;
typedef [public] struct {
- [value(ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(r, ndr->iconv_convenience, ndr->flags))] uint32 __ndr_size;
+ [value(ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(r, ndr->flags))] uint32 __ndr_size;
[value(ndr_size_dom_sid28(&sid,ndr->flags))] uint32 __ndr_size_sid;
GUID guid;
dom_sid28 sid;
drsuapi_DsExtendedError extended_ret; /* w2k sends the nc_object_count value here */
uint32 object_count;
/* this +55 is sometimes +56, so I don't know where this comes from... --metze */
- [value(ndr_size_drsuapi_DsGetNCChangesCtr1(r,ndr->iconv_convenience,ndr->flags)+55)] uint32 __ndr_size;
+ [value(ndr_size_drsuapi_DsGetNCChangesCtr1(r,ndr->flags)+55)] uint32 __ndr_size;
drsuapi_DsReplicaObjectListItemEx *first_object;
boolean32 more_data;
} drsuapi_DsGetNCChangesCtr1;
drsuapi_DsExtendedError extended_ret;
uint32 object_count;
/* this +55 is sometimes +56, so I don't know where this comes from... --metze */
- [value(ndr_size_drsuapi_DsGetNCChangesCtr6(r,ndr->iconv_convenience,ndr->flags)+55)] uint32 __ndr_size;
+ [value(ndr_size_drsuapi_DsGetNCChangesCtr6(r,ndr->flags)+55)] uint32 __ndr_size;
drsuapi_DsReplicaObjectListItemEx *first_object;
boolean32 more_data;
uint32 nc_object_count; /* estimated amount of objects in the whole NC */
} epm_tower;
typedef struct {
- [value(ndr_size_epm_tower(&tower, ndr->iconv_convenience, ndr->flags))] uint32 tower_length;
+ [value(ndr_size_epm_tower(&tower, ndr->flags))] uint32 tower_length;
[subcontext(4)] epm_tower tower;
} epm_twr_t;
[value(1)] uint32 cs_id;
[value(pkt_len+12)] uint32 memory_len;
[value(ndr_size_frsrpc_CommPktChunkCtr(r->ctr,
- ndr->iconv_convenience, ndr->flags))]
+ ndr->flags))]
[range(0, 262144)]
uint32 pkt_len;
[value(0)] uint32 upk_len;
typedef [public,gensize] struct {
[flag(NDR_BIG_ENDIAN),
- value(ndr_size_named_pipe_auth_req(r,ndr->iconv_convenience,ndr->flags)-4)]
+ value(ndr_size_named_pipe_auth_req(r,ndr->flags)-4)]
uint32 length;
[charset(DOS),value(NAMED_PIPE_AUTH_MAGIC)] uint8 magic[4];
uint32 level;
typedef [public,gensize] struct {
[flag(NDR_BIG_ENDIAN),
- value(ndr_size_named_pipe_auth_rep(r,ndr->iconv_convenience,ndr->flags)-4)]
+ value(ndr_size_named_pipe_auth_rep(r,ndr->flags)-4)]
uint32 length;
[charset(DOS),value(NAMED_PIPE_AUTH_MAGIC)] uint8 magic[4];
uint32 level;
nbt_string client_site;
/* Optional on NETLOGON_NT_VERSION_5EX_WITH_IP */
- [value(ndr_size_nbt_sockaddr(&sockaddr, ndr->iconv_convenience, ndr->flags))] uint8 sockaddr_size;
+ [value(ndr_size_nbt_sockaddr(&sockaddr, ndr->flags))] uint8 sockaddr_size;
[subcontext(0),subcontext_size(sockaddr_size)] nbt_sockaddr sockaddr;
/* Optional on NETLOGON_NT_VERSION_WITH_CLOSEST_SITE */
[in] [subcontext(4)/*,subcontext_size(change_log_entry_size)*/]
netr_ChangeLogEntry change_log_entry,
[in] [value(ndr_size_netr_ChangeLogEntry(&change_log_entry,
- ndr->iconv_convenience, ndr->flags))]
+ ndr->flags))]
uint32 change_log_entry_size,
[out,ref] netr_DELTA_ENUM_ARRAY **delta_enum_array
);
typedef [public,flag(NDR_NOALIGN)] struct {
ntlmssp_AvId AvId;
- [value(ndr_size_ntlmssp_AvValue(&r->Value, r->AvId, ndr->iconv_convenience, 0))] uint16 AvLen;
+ [value(ndr_size_ntlmssp_AvValue(&r->Value, r->AvId, 0))] uint16 AvLen;
[subcontext(0),subcontext_size(AvLen),switch_is(AvId)] ntlmssp_AvValue Value;
} AV_PAIR;
NEGOTIATE NegotiateFlags;
uint8 ServerChallenge[8];
uint8 Reserved[8];
- [value(ndr_size_AV_PAIR_LIST(TargetInfo, ndr->iconv_convenience, ndr->flags))] uint16 TargetInfoLen;
+ [value(ndr_size_AV_PAIR_LIST(TargetInfo, ndr->flags))] uint16 TargetInfoLen;
[value(TargetInfoLen)] uint16 TargetNameInfoMaxLen;
[relative] [subcontext(0),subcontext_size(TargetInfoLen)] AV_PAIR_LIST *TargetInfo;
[switch_is(NegotiateFlags & NTLMSSP_NEGOTIATE_VERSION)] ntlmssp_Version Version;
typedef [public,nopull,gensize,nosize] struct {
security_ace_type type; /* SEC_ACE_TYPE_* */
security_ace_flags flags; /* SEC_ACE_FLAG_* */
- [value(ndr_size_security_ace(r,ndr->iconv_convenience,ndr->flags))] uint16 size;
+ [value(ndr_size_security_ace(r,ndr->flags))] uint16 size;
uint32 access_mask;
[switch_is(type)] security_ace_object_ctr object;
dom_sid trustee;
typedef [public,gensize,nosize] struct {
security_acl_revision revision;
- [value(ndr_size_security_acl(r,ndr->iconv_convenience,ndr->flags))] uint16 size;
+ [value(ndr_size_security_acl(r,ndr->flags))] uint16 size;
[range(0,1000)] uint32 num_aces;
security_ace aces[num_aces];
} security_acl;
} security_descriptor;
typedef [public] struct {
- [range(0,0x40000),value(ndr_size_security_descriptor(sd,ndr->iconv_convenience,ndr->flags))] uint32 sd_size;
+ [range(0,0x40000),value(ndr_size_security_descriptor(sd,ndr->flags))] uint32 sd_size;
[subcontext(4)] security_descriptor *sd;
} sec_desc_buf;
} spoolss_Time;
typedef struct {
- [value(ndr_size_spoolss_Time(time, ndr->iconv_convenience, ndr->flags))] uint32 size;
+ [value(ndr_size_spoolss_Time(time, ndr->flags))] uint32 size;
[unique] spoolss_Time *time;
} spoolss_TimeCtr;
uint16 caColorfulness;
uint16 caRedGreenTint;
uint16 wCoreJTExpSize;
- [value(ndr_size_spoolss_PSDRVEXTRA(r, ndr->iconv_convenience, ndr->flags) + wCoreJTExpSize)] uint16 wCoreFullSize;
+ [value(ndr_size_spoolss_PSDRVEXTRA(r, ndr->flags) + wCoreJTExpSize)] uint16 wCoreFullSize;
uint32 fxScrFreq;
uint32 fxScrAngle;
spoolss_DMPS_Dialect iDialect;
[value(SPOOLSS_DM_SIGNATURE_UNIDRVEXTRA)] spoolss_DM_Signature dwSignature;
[value(0x0022)] uint16 wVer;
uint16 wCoreJTExpSize;
- [value(ndr_size_spoolss_UNIDRVEXTRA(r, ndr->iconv_convenience, ndr->flags) + wCoreJTExpSize)] uint16 wCoreFullSize;
+ [value(ndr_size_spoolss_UNIDRVEXTRA(r, ndr->flags) + wCoreJTExpSize)] uint16 wCoreFullSize;
uint16 wOEMExtra;
uint32 dwChecksum32;
spoolss_DMUNI_Flags dwFlags;
/******************/
/* Function: 0x01 */
typedef struct {
- [value(_ndr_size_spoolss_DeviceMode(devmode, ndr->iconv_convenience, ndr->flags))] uint32 _ndr_size;
+ [value(_ndr_size_spoolss_DeviceMode(devmode, ndr->flags))] uint32 _ndr_size;
[subcontext(4),subcontext_size(_ndr_size)] spoolss_DeviceMode *devmode;
} spoolss_DevmodeContainer;
/* Function: 0x09 */
typedef [public] struct {
- [value((ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags)-4)/2)] uint32 _ndr_size;
+ [value((ndr_size_spoolss_StringArray(r, ndr->flags)-4)/2)] uint32 _ndr_size;
/*[subcontext(0),subcontext_size(_ndr_size*2)]*/ nstring_array string;
} spoolss_StringArray;
[string,charset(UTF16)] uint16 *help_file;
[string,charset(UTF16)] uint16 *monitor_name;
[string,charset(UTF16)] uint16 *default_datatype;
- [value(((ndr_size_spoolss_StringArray(dependent_files, ndr->iconv_convenience, ndr->flags)-4)/2))] uint32 _ndr_size_dependent_files;
+ [value(((ndr_size_spoolss_StringArray(dependent_files, ndr->flags)-4)/2))] uint32 _ndr_size_dependent_files;
spoolss_StringArray *dependent_files;
} spoolss_AddDriverInfo3;
[string,charset(UTF16)] uint16 *help_file;
[string,charset(UTF16)] uint16 *monitor_name;
[string,charset(UTF16)] uint16 *default_datatype;
- [value(((ndr_size_spoolss_StringArray(dependent_files, ndr->iconv_convenience, ndr->flags)-4)/2))] uint32 _ndr_size_dependent_files;
+ [value(((ndr_size_spoolss_StringArray(dependent_files, ndr->flags)-4)/2))] uint32 _ndr_size_dependent_files;
spoolss_StringArray *dependent_files;
- [value(((ndr_size_spoolss_StringArray(previous_names, ndr->iconv_convenience, ndr->flags)-4)/2))] uint32 _ndr_size_previous_names;
+ [value(((ndr_size_spoolss_StringArray(previous_names, ndr->flags)-4)/2))] uint32 _ndr_size_previous_names;
spoolss_StringArray *previous_names;
} spoolss_AddDriverInfo4;
[string,charset(UTF16)] uint16 *help_file;
[string,charset(UTF16)] uint16 *monitor_name;
[string,charset(UTF16)] uint16 *default_datatype;
- [value(((ndr_size_spoolss_StringArray(dependent_files, ndr->iconv_convenience, ndr->flags)-4)/2))] uint32 _ndr_size_dependent_files;
+ [value(((ndr_size_spoolss_StringArray(dependent_files, ndr->flags)-4)/2))] uint32 _ndr_size_dependent_files;
spoolss_StringArray *dependent_files;
- [value(((ndr_size_spoolss_StringArray(previous_names, ndr->iconv_convenience, ndr->flags)-4)/2))] uint32 _ndr_size_previous_names;
+ [value(((ndr_size_spoolss_StringArray(previous_names, ndr->flags)-4)/2))] uint32 _ndr_size_previous_names;
spoolss_StringArray *previous_names;
NTTIME driver_date;
hyper driver_version;
[string,charset(UTF16)] uint16 *help_file;
[string,charset(UTF16)] uint16 *monitor_name;
[string,charset(UTF16)] uint16 *default_datatype;
- [value(((ndr_size_spoolss_StringArray(dependent_files, ndr->iconv_convenience, ndr->flags)-4)/2))] uint32 _ndr_size_dependent_files;
+ [value(((ndr_size_spoolss_StringArray(dependent_files, ndr->flags)-4)/2))] uint32 _ndr_size_dependent_files;
spoolss_StringArray *dependent_files;
- [value(((ndr_size_spoolss_StringArray(previous_names, ndr->iconv_convenience, ndr->flags)-4)/2))] uint32 _ndr_size_previous_names;
+ [value(((ndr_size_spoolss_StringArray(previous_names, ndr->flags)-4)/2))] uint32 _ndr_size_previous_names;
spoolss_StringArray *previous_names;
NTTIME driver_date;
hyper driver_version;
[string,charset(UTF16)] uint16 *provider;
[string,charset(UTF16)] uint16 *print_processor;
[string,charset(UTF16)] uint16 *vendor_setup;
- [value(((ndr_size_spoolss_StringArray(color_profiles, ndr->iconv_convenience, ndr->flags)-4)/2))] uint32 _ndr_size_color_profiles;
+ [value(((ndr_size_spoolss_StringArray(color_profiles, ndr->flags)-4)/2))] uint32 _ndr_size_color_profiles;
spoolss_StringArray *color_profiles;
[string,charset(UTF16)] uint16 *inf_path;
uint32 printer_driver_attributes;
- [value(((ndr_size_spoolss_StringArray(core_driver_dependencies, ndr->iconv_convenience, ndr->flags)-4)/2))] uint32 _ndr_size_core_driver_dependencies;
+ [value(((ndr_size_spoolss_StringArray(core_driver_dependencies, ndr->flags)-4)/2))] uint32 _ndr_size_core_driver_dependencies;
spoolss_StringArray *core_driver_dependencies;
NTTIME min_inbox_driver_ver_date;
hyper min_inbox_driver_ver_version;
const string SPOOLSS_DEFAULT_SERVER_PATH = "C:\\WINDOWS\\system32\\spool";
typedef [public,gensize] struct {
- [value(ndr_size_spoolss_OSVersion(r,ndr->iconv_convenience,ndr->flags))] uint32 _ndr_size;
+ [value(ndr_size_spoolss_OSVersion(r,ndr->flags))] uint32 _ndr_size;
uint32 major;
uint32 minor;
uint32 build;
} spoolss_OSVersion;
typedef [public,gensize] struct {
- [value(ndr_size_spoolss_OSVersionEx(r,ndr->iconv_convenience,ndr->flags))] uint32 _ndr_size;
+ [value(ndr_size_spoolss_OSVersionEx(r,ndr->flags))] uint32 _ndr_size;
uint32 major;
uint32 minor;
uint32 build;
uint32_t data_size;
uint32_t offset;
- struct smb_iconv_convenience *iconv_convenience;
-
uint32_t relative_highest_offset;
uint32_t relative_base_offset;
struct ndr_token_list *relative_base_list;
/* this is used to ensure we generate unique reference IDs */
uint32_t ptr_count;
-
- struct smb_iconv_convenience *iconv_convenience;
};
/* structure passed to functions that print IDL structures */
uint32_t flags; /* LIBNDR_FLAG_* */
uint32_t depth;
struct ndr_token_list *switch_list;
- struct smb_iconv_convenience *iconv_convenience;
void (*print)(struct ndr_print *, const char *, ...) PRINTF_ATTRIBUTE(2,3);
void *private_data;
};
void ndr_print_ipv4_addr(struct ndr_print *ndr, const char *name, const struct in_addr *_ip);
void ndr_print_GUID(struct ndr_print *ndr, const char *name, const struct GUID *guid);
bool ndr_syntax_id_equal(const struct ndr_syntax_id *i1, const struct ndr_syntax_id *i2);
-enum ndr_err_code ndr_push_struct_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const void *p, ndr_push_flags_fn_t fn);
-enum ndr_err_code ndr_push_union_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, void *p, uint32_t level, ndr_push_flags_fn_t fn);
-size_t ndr_size_struct(const void *p, int flags, ndr_push_flags_fn_t push, struct smb_iconv_convenience *);
-size_t ndr_size_union(const void *p, int flags, uint32_t level, ndr_push_flags_fn_t push, struct smb_iconv_convenience *);
+enum ndr_err_code ndr_push_struct_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, const void *p, ndr_push_flags_fn_t fn);
+enum ndr_err_code ndr_push_union_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p, uint32_t level, ndr_push_flags_fn_t fn);
+size_t ndr_size_struct(const void *p, int flags, ndr_push_flags_fn_t push);
+size_t ndr_size_union(const void *p, int flags, uint32_t level, ndr_push_flags_fn_t push);
uint32_t ndr_push_get_relative_base_offset(struct ndr_push *ndr);
void ndr_push_restore_relative_base_offset(struct ndr_push *ndr, uint32_t offset);
enum ndr_err_code ndr_push_setup_relative_base_offset1(struct ndr_push *ndr, const void *p, uint32_t offset);
enum ndr_err_code ndr_pull_relative_ptr2(struct ndr_pull *ndr, const void *p);
enum ndr_err_code ndr_pull_relative_ptr_short(struct ndr_pull *ndr, uint16_t *v);
size_t ndr_align_size(uint32_t offset, size_t n);
-struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience);
+struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx);
enum ndr_err_code ndr_pull_advance(struct ndr_pull *ndr, uint32_t size);
-struct ndr_push *ndr_push_init_ctx(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience);
+struct ndr_push *ndr_push_init_ctx(TALLOC_CTX *mem_ctx);
DATA_BLOB ndr_push_blob(struct ndr_push *ndr);
enum ndr_err_code ndr_push_expand(struct ndr_push *ndr, uint32_t extra_size);
void ndr_print_debug_helper(struct ndr_print *ndr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
uint32_t ndr_push_get_switch_value(struct ndr_push *ndr, const void *p);
uint32_t ndr_pull_get_switch_value(struct ndr_pull *ndr, const void *p);
uint32_t ndr_print_get_switch_value(struct ndr_print *ndr, const void *p);
-enum ndr_err_code ndr_pull_struct_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, void *p, ndr_pull_flags_fn_t fn);
-enum ndr_err_code ndr_pull_struct_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, void *p, ndr_pull_flags_fn_t fn);
-enum ndr_err_code ndr_pull_union_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, void *p, uint32_t level, ndr_pull_flags_fn_t fn);
-enum ndr_err_code ndr_pull_union_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, void *p, uint32_t level, ndr_pull_flags_fn_t fn);
+enum ndr_err_code ndr_pull_struct_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p, ndr_pull_flags_fn_t fn);
+enum ndr_err_code ndr_pull_struct_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p, ndr_pull_flags_fn_t fn);
+enum ndr_err_code ndr_pull_union_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p, uint32_t level, ndr_pull_flags_fn_t fn);
+enum ndr_err_code ndr_pull_union_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p, uint32_t level, ndr_pull_flags_fn_t fn);
/* from libndr_basic.h */
#define NDR_SCALAR_PROTO(name, type) \
/*
initialise a ndr parse structure from a data blob
*/
-_PUBLIC_ struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience)
+_PUBLIC_ struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
{
struct ndr_pull *ndr;
ndr->data = blob->data;
ndr->data_size = blob->length;
- ndr->iconv_convenience = talloc_reference(ndr, iconv_convenience);
return ndr;
}
}
/* create a ndr_push structure, ready for some marshalling */
-_PUBLIC_ struct ndr_push *ndr_push_init_ctx(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience)
+_PUBLIC_ struct ndr_push *ndr_push_init_ctx(TALLOC_CTX *mem_ctx)
{
struct ndr_push *ndr;
if (!ndr->data) {
return NULL;
}
- ndr->iconv_convenience = talloc_reference(ndr, iconv_convenience);
return ndr;
}
ndr->depth = 1;
ndr->flags = 0;
- /* this is a s4 hack until we build up the courage to pass
- * this all the way down
- */
-#if _SAMBA_BUILD_ == 4
- ndr->iconv_convenience = smb_iconv_convenience_reinit(talloc_autofree_context(),
- "ASCII", "UTF-8", true, NULL);
-#endif
-
fn(ndr, name, flags, ptr);
talloc_free(ndr);
}
ndr->depth = 1;
ndr->flags = 0;
- /* this is a s4 hack until we build up the courage to pass
- * this all the way down
- */
-#if _SAMBA_BUILD_ == 4
- ndr->iconv_convenience = smb_iconv_convenience_reinit(talloc_autofree_context(),
- "ASCII", "UTF-8", true, NULL);
-#endif
-
fn(ndr, name, ptr);
ret = talloc_steal(mem_ctx, (char *)ndr->private_data);
failed:
subndr->data = ndr->data + ndr->offset;
subndr->offset = 0;
subndr->data_size = r_content_size;
- subndr->iconv_convenience = talloc_reference(subndr, ndr->iconv_convenience);
if (force_le) {
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
{
struct ndr_push *subndr;
- subndr = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
+ subndr = ndr_push_init_ctx(ndr);
NDR_ERR_HAVE_NO_MEMORY(subndr);
subndr->flags = ndr->flags & ~LIBNDR_FLAG_NDR64;
/*
pull a struct from a blob using NDR
*/
-_PUBLIC_ enum ndr_err_code ndr_pull_struct_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, void *p,
+_PUBLIC_ enum ndr_err_code ndr_pull_struct_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
ndr_pull_flags_fn_t fn)
{
struct ndr_pull *ndr;
- ndr = ndr_pull_init_blob(blob, mem_ctx, iconv_convenience);
+ ndr = ndr_pull_init_blob(blob, mem_ctx);
NDR_ERR_HAVE_NO_MEMORY(ndr);
NDR_CHECK_FREE(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
talloc_free(ndr);
pull a struct from a blob using NDR - failing if all bytes are not consumed
*/
_PUBLIC_ enum ndr_err_code ndr_pull_struct_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
void *p, ndr_pull_flags_fn_t fn)
{
struct ndr_pull *ndr;
uint32_t highest_ofs;
- ndr = ndr_pull_init_blob(blob, mem_ctx, iconv_convenience);
+ ndr = ndr_pull_init_blob(blob, mem_ctx);
NDR_ERR_HAVE_NO_MEMORY(ndr);
NDR_CHECK_FREE(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
if (ndr->offset > ndr->relative_highest_offset) {
pull a union from a blob using NDR, given the union discriminator
*/
_PUBLIC_ enum ndr_err_code ndr_pull_union_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience, void *p,
+ void *p,
uint32_t level, ndr_pull_flags_fn_t fn)
{
struct ndr_pull *ndr;
- ndr = ndr_pull_init_blob(blob, mem_ctx, iconv_convenience);
+ ndr = ndr_pull_init_blob(blob, mem_ctx);
NDR_ERR_HAVE_NO_MEMORY(ndr);
NDR_CHECK_FREE(ndr_pull_set_switch_value(ndr, p, level));
NDR_CHECK_FREE(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
failing if all bytes are not consumed
*/
_PUBLIC_ enum ndr_err_code ndr_pull_union_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience, void *p,
+ void *p,
uint32_t level, ndr_pull_flags_fn_t fn)
{
struct ndr_pull *ndr;
uint32_t highest_ofs;
- ndr = ndr_pull_init_blob(blob, mem_ctx, iconv_convenience);
+ ndr = ndr_pull_init_blob(blob, mem_ctx);
NDR_ERR_HAVE_NO_MEMORY(ndr);
NDR_CHECK_FREE(ndr_pull_set_switch_value(ndr, p, level));
NDR_CHECK_FREE(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
/*
push a struct to a blob using NDR
*/
-_PUBLIC_ enum ndr_err_code ndr_push_struct_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const void *p, ndr_push_flags_fn_t fn)
+_PUBLIC_ enum ndr_err_code ndr_push_struct_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, const void *p, ndr_push_flags_fn_t fn)
{
struct ndr_push *ndr;
- ndr = ndr_push_init_ctx(mem_ctx, iconv_convenience);
+ ndr = ndr_push_init_ctx(mem_ctx);
NDR_ERR_HAVE_NO_MEMORY(ndr);
NDR_CHECK(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
/*
push a union to a blob using NDR
*/
-_PUBLIC_ enum ndr_err_code ndr_push_union_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, void *p,
+_PUBLIC_ enum ndr_err_code ndr_push_union_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
uint32_t level, ndr_push_flags_fn_t fn)
{
struct ndr_push *ndr;
- ndr = ndr_push_init_ctx(mem_ctx, iconv_convenience);
+ ndr = ndr_push_init_ctx(mem_ctx);
NDR_ERR_HAVE_NO_MEMORY(ndr);
NDR_CHECK(ndr_push_set_switch_value(ndr, p, level));
/*
generic ndr_size_*() handler for structures
*/
-_PUBLIC_ size_t ndr_size_struct(const void *p, int flags, ndr_push_flags_fn_t push, struct smb_iconv_convenience *iconv_convenience)
+_PUBLIC_ size_t ndr_size_struct(const void *p, int flags, ndr_push_flags_fn_t push)
{
struct ndr_push *ndr;
enum ndr_err_code status;
/* avoid recursion */
if (flags & LIBNDR_FLAG_NO_NDR_SIZE) return 0;
- ndr = ndr_push_init_ctx(NULL, iconv_convenience);
+ ndr = ndr_push_init_ctx(NULL);
if (!ndr) return 0;
ndr->flags |= flags | LIBNDR_FLAG_NO_NDR_SIZE;
status = push(ndr, NDR_SCALARS|NDR_BUFFERS, discard_const(p));
/*
generic ndr_size_*() handler for unions
*/
-_PUBLIC_ size_t ndr_size_union(const void *p, int flags, uint32_t level, ndr_push_flags_fn_t push, struct smb_iconv_convenience *iconv_convenience)
+_PUBLIC_ size_t ndr_size_union(const void *p, int flags, uint32_t level, ndr_push_flags_fn_t push)
{
struct ndr_push *ndr;
enum ndr_err_code status;
/* avoid recursion */
if (flags & LIBNDR_FLAG_NO_NDR_SIZE) return 0;
- ndr = ndr_push_init_ctx(NULL, iconv_convenience);
+ ndr = ndr_push_init_ctx(NULL);
if (!ndr) return 0;
ndr->flags |= flags | LIBNDR_FLAG_NO_NDR_SIZE;
bool last = false;
z_stream z;
- ndrpush = ndr_push_init_ctx(subndr, subndr->iconv_convenience);
+ ndrpush = ndr_push_init_ctx(subndr);
NDR_ERR_HAVE_NO_MEMORY(ndrpush);
switch (compression_alg) {
comndr->data_size = uncompressed.length;
comndr->offset = 0;
- comndr->iconv_convenience = talloc_reference(comndr, subndr->iconv_convenience);
-
*_comndr = comndr;
return NDR_ERR_SUCCESS;
}
compression_alg);
}
- uncomndr = ndr_push_init_ctx(subndr, subndr->iconv_convenience);
+ uncomndr = ndr_push_init_ctx(subndr);
NDR_ERR_HAVE_NO_MEMORY(uncomndr);
uncomndr->flags = subndr->flags;
ndrpull->data_size = uncomndr->offset;
ndrpull->offset = 0;
- ndrpull->iconv_convenience = talloc_reference(ndrpull, subndr->iconv_convenience);
-
switch (compression_alg) {
case NDR_COMPRESSION_MSZIP:
ZERO_STRUCT(z);
return NDR_ERR_SUCCESS;
}
-_PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, struct smb_iconv_convenience *ic, int flags)
+_PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, int flags)
{
- return ndr_size_struct((const struct drsuapi_DsReplicaObjectIdentifier3 *)r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
+ return ndr_size_struct((const struct drsuapi_DsReplicaObjectIdentifier3 *)r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
}
_PUBLIC_ void ndr_print_drsuapi_SecBufferType(struct ndr_print *ndr, const char *name, enum drsuapi_SecBufferType r)
void ndr_print_drsuapi_DsReplicaObjectListItemEx(struct ndr_print *ndr, const char *name,
const struct drsuapi_DsReplicaObjectListItemEx *r);
-size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, struct smb_iconv_convenience *ic, int flags);
+size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, int flags);
#endif /* _LIBRPC_NDR_NDR_DRSUAPI_H */
}
size_t ndr_size_frsrpc_CommPktChunkCtr(const struct frsrpc_CommPktChunkCtr *r,
- struct smb_iconv_convenience *ic,
int flags)
{
flags |= LIBNDR_FLAG_NOALIGN;
return ndr_size_struct(r, flags,
- (ndr_push_flags_fn_t)ndr_push_frsrpc_CommPktChunkCtr,
- ic);
+ (ndr_push_flags_fn_t)ndr_push_frsrpc_CommPktChunkCtr);
}
int ndr_flags,
struct frsrpc_CommPktChunkCtr *r);
size_t ndr_size_frsrpc_CommPktChunkCtr(const struct frsrpc_CommPktChunkCtr *r,
- struct smb_iconv_convenience *ic,
int flags);
#endif /* _LIBRPC_NDR_NDR_FRSRPC_H */
#include "includes.h"
#include "librpc/gen_ndr/ndr_krb5pac.h"
-static size_t _ndr_size_PAC_INFO(const union PAC_INFO *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
+static size_t _ndr_size_PAC_INFO(const union PAC_INFO *r, uint32_t level, int flags)
{
- size_t s = ndr_size_PAC_INFO(r, level, ic, flags);
+ size_t s = ndr_size_PAC_INFO(r, level, flags);
switch (level) {
case PAC_TYPE_LOGON_INFO:
return NDR_ROUND(s,8);
}
}
-static size_t _subcontext_size_PAC_INFO(const union PAC_INFO *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
+static size_t _subcontext_size_PAC_INFO(const union PAC_INFO *r, uint32_t level, int flags)
{
- size_t s = ndr_size_PAC_INFO(r, level, ic, flags);
+ size_t s = ndr_size_PAC_INFO(r, level, flags);
return NDR_ROUND(s,8);
}
if (ndr_flags & NDR_SCALARS) {
NDR_CHECK(ndr_push_align(ndr, 4));
NDR_CHECK(ndr_push_PAC_TYPE(ndr, NDR_SCALARS, r->type));
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_PAC_INFO(r->info,r->type,ndr->iconv_convenience,0)));
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_PAC_INFO(r->info,r->type,0)));
{
uint32_t _flags_save_PAC_INFO = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->info));
{
struct ndr_push *_ndr_info;
- NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 0, _subcontext_size_PAC_INFO(r->info,r->type,ndr->iconv_convenience, 0)));
+ NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 0, _subcontext_size_PAC_INFO(r->info,r->type,0)));
NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->info, r->type));
NDR_CHECK(ndr_push_PAC_INFO(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->info));
- NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 0, _subcontext_size_PAC_INFO(r->info,r->type,ndr->iconv_convenience,0)));
+ NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 0, _subcontext_size_PAC_INFO(r->info,r->type,0)));
}
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->info));
}
ndr_print_struct(ndr, name, "PAC_BUFFER");
ndr->depth++;
ndr_print_PAC_TYPE(ndr, "type", r->type);
- ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_PAC_INFO(r->info,r->type,ndr->iconv_convenience,0):r->_ndr_size);
+ ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_PAC_INFO(r->info,r->type,0):r->_ndr_size);
ndr_print_ptr(ndr, "info", r->info);
ndr->depth++;
if (r->info) {
}
_PUBLIC_ void ndr_print_ntlmssp_nt_response(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const DATA_BLOB *nt_response,
bool ntlmv2)
{
if (ntlmv2) {
struct NTLMv2_RESPONSE nt;
if (nt_response->length > 24) {
- ndr_err = ndr_pull_struct_blob(nt_response, mem_ctx, ic, &nt,
+ ndr_err = ndr_pull_struct_blob(nt_response, mem_ctx, &nt,
(ndr_pull_flags_fn_t)ndr_pull_NTLMv2_RESPONSE);
if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NDR_PRINT_DEBUG(NTLMv2_RESPONSE, &nt);
} else {
struct NTLM_RESPONSE nt;
if (nt_response->length == 24) {
- ndr_err = ndr_pull_struct_blob(nt_response, mem_ctx, ic, &nt,
+ ndr_err = ndr_pull_struct_blob(nt_response, mem_ctx, &nt,
(ndr_pull_flags_fn_t)ndr_pull_NTLM_RESPONSE);
if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NDR_PRINT_DEBUG(NTLM_RESPONSE, &nt);
}
_PUBLIC_ void ndr_print_ntlmssp_lm_response(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const DATA_BLOB *lm_response,
bool ntlmv2)
{
if (ntlmv2) {
struct LMv2_RESPONSE lm;
if (lm_response->length == 24) {
- ndr_err = ndr_pull_struct_blob(lm_response, mem_ctx, ic, &lm,
+ ndr_err = ndr_pull_struct_blob(lm_response, mem_ctx, &lm,
(ndr_pull_flags_fn_t)ndr_pull_LMv2_RESPONSE);
if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NDR_PRINT_DEBUG(LMv2_RESPONSE, &lm);
} else {
struct LM_RESPONSE lm;
if (lm_response->length == 24) {
- ndr_err = ndr_pull_struct_blob(lm_response, mem_ctx, ic, &lm,
+ ndr_err = ndr_pull_struct_blob(lm_response, mem_ctx, &lm,
(ndr_pull_flags_fn_t)ndr_pull_LM_RESPONSE);
if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NDR_PRINT_DEBUG(LM_RESPONSE, &lm);
_PUBLIC_ enum ndr_err_code ndr_push_AV_PAIR_LIST(struct ndr_push *ndr, int ndr_flags, const struct AV_PAIR_LIST *r);
_PUBLIC_ enum ndr_err_code ndr_pull_AV_PAIR_LIST(struct ndr_pull *ndr, int ndr_flags, struct AV_PAIR_LIST *r);
_PUBLIC_ void ndr_print_ntlmssp_nt_response(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const DATA_BLOB *nt_response,
bool ntlmv2);
_PUBLIC_ void ndr_print_ntlmssp_lm_response(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
const DATA_BLOB *lm_response,
bool ntlmv2);
_PUBLIC_ void ndr_print_ntlmssp_Version(struct ndr_print *ndr, const char *name, const union ntlmssp_Version *r);
switch (signature_algorithm) {
case NL_SIGN_HMAC_MD5: {
struct NL_AUTH_SIGNATURE r;
- ndr_err = ndr_pull_struct_blob(blob, mem_ctx, NULL, &r,
+ ndr_err = ndr_pull_struct_blob(blob, mem_ctx, &r,
(ndr_pull_flags_fn_t)ndr_pull_NL_AUTH_SIGNATURE);
if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NDR_PRINT_DEBUG(NL_AUTH_SIGNATURE, &r);
}
case NL_SIGN_HMAC_SHA256: {
struct NL_AUTH_SHA2_SIGNATURE r;
- ndr_err = ndr_pull_struct_blob(blob, mem_ctx, NULL, &r,
+ ndr_err = ndr_pull_struct_blob(blob, mem_ctx, &r,
(ndr_pull_flags_fn_t)ndr_pull_NL_AUTH_SHA2_SIGNATURE);
if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NDR_PRINT_DEBUG(NL_AUTH_SHA2_SIGNATURE, &r);
/*
return the wire size of a security_ace
*/
-size_t ndr_size_security_ace(const struct security_ace *ace, struct smb_iconv_convenience *ic, int flags)
+size_t ndr_size_security_ace(const struct security_ace *ace, int flags)
{
size_t ret;
if (!ace) return 0;
- ret = 8 + ndr_size_dom_sid(&ace->trustee, ic, flags);
+ ret = 8 + ndr_size_dom_sid(&ace->trustee, flags);
switch (ace->type) {
case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
/*
return the wire size of a security_acl
*/
-size_t ndr_size_security_acl(const struct security_acl *theacl, struct smb_iconv_convenience *ic, int flags)
+size_t ndr_size_security_acl(const struct security_acl *theacl, int flags)
{
size_t ret;
int i;
if (!theacl) return 0;
ret = 8;
for (i=0;i<theacl->num_aces;i++) {
- ret += ndr_size_security_ace(&theacl->aces[i], ic, flags);
+ ret += ndr_size_security_ace(&theacl->aces[i], flags);
}
return ret;
}
/*
return the wire size of a security descriptor
*/
-size_t ndr_size_security_descriptor(const struct security_descriptor *sd, struct smb_iconv_convenience *ic, int flags)
+size_t ndr_size_security_descriptor(const struct security_descriptor *sd, int flags)
{
size_t ret;
if (!sd) return 0;
ret = 20;
- ret += ndr_size_dom_sid(sd->owner_sid, ic, flags);
- ret += ndr_size_dom_sid(sd->group_sid, ic, flags);
- ret += ndr_size_security_acl(sd->dacl, ic, flags);
- ret += ndr_size_security_acl(sd->sacl, ic, flags);
+ ret += ndr_size_dom_sid(sd->owner_sid, flags);
+ ret += ndr_size_dom_sid(sd->group_sid, flags);
+ ret += ndr_size_security_acl(sd->dacl, flags);
+ ret += ndr_size_security_acl(sd->sacl, flags);
return ret;
}
/*
return the wire size of a dom_sid
*/
-size_t ndr_size_dom_sid(const struct dom_sid *sid, struct smb_iconv_convenience *ic, int flags)
+size_t ndr_size_dom_sid(const struct dom_sid *sid, int flags)
{
if (!sid) return 0;
return 8 + 4*sid->num_auths;
}\
if (r->in.buffer) {\
DATA_BLOB _data_blob_info;\
- _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);\
+ _ndr_info = ndr_push_init_ctx(ndr);\
NDR_ERR_HAVE_NO_MEMORY(_ndr_info);\
_ndr_info->flags= ndr->flags;\
if (r->out.info) {\
if (_r.out.info) {\
struct ndr_pull *_ndr_info;\
NDR_PULL_ALLOC(ndr, *r->out.info);\
- _ndr_info = ndr_pull_init_blob(_r.out.info, *r->out.info, ndr->iconv_convenience);\
+ _ndr_info = ndr_pull_init_blob(_r.out.info, *r->out.info);\
NDR_ERR_HAVE_NO_MEMORY(_ndr_info);\
_ndr_info->flags= ndr->flags;\
if (r->in.offered != _ndr_info->data_size) {\
#define NDR_SPOOLSS_SIZE_ENUM_LEVEL(fn) do { \
struct __##fn __r;\
DATA_BLOB _data_blob_info;\
- struct ndr_push *_ndr_info = ndr_push_init_ctx(mem_ctx, iconv_convenience);\
+ struct ndr_push *_ndr_info = ndr_push_init_ctx(mem_ctx);\
if (!_ndr_info) return 0;\
_ndr_info->flags|=LIBNDR_FLAG_NO_NDR_SIZE;\
__r.in.level = level;\
#define NDR_SPOOLSS_SIZE_ENUM(fn) do { \
struct __##fn __r;\
DATA_BLOB _data_blob_info;\
- struct ndr_push *_ndr_info = ndr_push_init_ctx(mem_ctx, iconv_convenience);\
+ struct ndr_push *_ndr_info = ndr_push_init_ctx(mem_ctx);\
if (!_ndr_info) return 0;\
_ndr_info->flags|=LIBNDR_FLAG_NO_NDR_SIZE;\
__r.in.count = count;\
return NDR_ERR_SUCCESS;
}
-uint32_t ndr_size_spoolss_EnumPrinters_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_PrinterInfo *info)
+uint32_t ndr_size_spoolss_EnumPrinters_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_PrinterInfo *info)
{
NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrinters);
}
return NDR_ERR_SUCCESS;
}
-uint32_t ndr_size_spoolss_EnumJobs_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_JobInfo *info)
+uint32_t ndr_size_spoolss_EnumJobs_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_JobInfo *info)
{
NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumJobs);
}
return NDR_ERR_SUCCESS;
}
-uint32_t ndr_size_spoolss_EnumPrinterDrivers_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_DriverInfo *info)
+uint32_t ndr_size_spoolss_EnumPrinterDrivers_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_DriverInfo *info)
{
NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrinterDrivers);
}
return NDR_ERR_SUCCESS;
}
-uint32_t ndr_size_spoolss_EnumForms_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_FormInfo *info)
+uint32_t ndr_size_spoolss_EnumForms_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_FormInfo *info)
{
NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumForms);
}
return NDR_ERR_SUCCESS;
}
-uint32_t ndr_size_spoolss_EnumPorts_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_PortInfo *info)
+uint32_t ndr_size_spoolss_EnumPorts_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_PortInfo *info)
{
NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPorts);
}
return NDR_ERR_SUCCESS;
}
-uint32_t ndr_size_spoolss_EnumMonitors_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_MonitorInfo *info)
+uint32_t ndr_size_spoolss_EnumMonitors_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_MonitorInfo *info)
{
NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumMonitors);
}
return NDR_ERR_SUCCESS;
}
-uint32_t ndr_size_spoolss_EnumPrintProcessors_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
+uint32_t ndr_size_spoolss_EnumPrintProcessors_info(TALLOC_CTX *mem_ctx,
uint32_t level, uint32_t count, union spoolss_PrintProcessorInfo *info)
{
NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcessors);
return NDR_ERR_SUCCESS;
}
-uint32_t ndr_size_spoolss_EnumPrintProcDataTypes_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
+uint32_t ndr_size_spoolss_EnumPrintProcDataTypes_info(TALLOC_CTX *mem_ctx,
uint32_t level, uint32_t count, union spoolss_PrintProcDataTypesInfo *info)
{
NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcDataTypes);
_r.out.info = data_blob(NULL, 0);
if (r->in.offered >= *r->out.needed) {
struct __spoolss_EnumPrinterDataEx __r;
- _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
+ _ndr_info = ndr_push_init_ctx(ndr);
NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
_ndr_info->flags= ndr->flags;
__r.in.count = *r->out.count;
if (_r.out.info.length) {
struct ndr_pull *_ndr_info;
NDR_PULL_ALLOC(ndr, *r->out.info);
- _ndr_info = ndr_pull_init_blob(&_r.out.info, *r->out.info, ndr->iconv_convenience);
+ _ndr_info = ndr_pull_init_blob(&_r.out.info, *r->out.info);
NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
_ndr_info->flags= ndr->flags;
if (r->in.offered != _ndr_info->data_size) {
return NDR_ERR_SUCCESS;
}
-uint32_t ndr_size_spoolss_EnumPrinterDataEx_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
+uint32_t ndr_size_spoolss_EnumPrinterDataEx_info(TALLOC_CTX *mem_ctx,
uint32_t count, struct spoolss_PrinterEnumValues *info)
{
NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrinterDataEx);
}
-uint32_t _ndr_size_spoolss_DeviceMode(struct spoolss_DeviceMode *devmode, struct smb_iconv_convenience *ic, uint32_t flags)
+uint32_t _ndr_size_spoolss_DeviceMode(struct spoolss_DeviceMode *devmode, uint32_t flags)
{
if (!devmode) return 0;
- return ndr_size_spoolss_DeviceMode(devmode,ic,flags);
+ return ndr_size_spoolss_DeviceMode(devmode, flags);
}
-_PUBLIC_ size_t ndr_size_spoolss_StringArray(const struct spoolss_StringArray *r, struct smb_iconv_convenience *ic, int flags)
+_PUBLIC_ size_t ndr_size_spoolss_StringArray(const struct spoolss_StringArray *r, int flags)
{
if (!r) {
return 4;
}
- return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_StringArray, ic);
+ return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_StringArray);
}
/* hand marshall as pidl cannot (yet) generate a relative pointer to a fixed array of
}
}
-_PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
+_PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, int flags)
{
if (!r) {
return 0;
}
- return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
+ return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData);
}
void ndr_print_spoolss_security_descriptor(struct ndr_print *ndr, const char *name, const struct security_descriptor *r)
enum ndr_err_code ndr_push_spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinters *r);
enum ndr_err_code ndr_pull_spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinters *r);
-uint32_t ndr_size_spoolss_EnumPrinters_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_PrinterInfo *info);
+uint32_t ndr_size_spoolss_EnumPrinters_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_PrinterInfo *info);
enum ndr_err_code ndr_push_spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct spoolss_EnumJobs *r);
enum ndr_err_code ndr_pull_spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct spoolss_EnumJobs *r);
-uint32_t ndr_size_spoolss_EnumJobs_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_JobInfo *info);
+uint32_t ndr_size_spoolss_EnumJobs_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_JobInfo *info);
enum ndr_err_code ndr_push_spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDrivers *r);
enum ndr_err_code ndr_pull_spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDrivers *r);
-uint32_t ndr_size_spoolss_EnumPrinterDrivers_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_DriverInfo *info);
+uint32_t ndr_size_spoolss_EnumPrinterDrivers_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_DriverInfo *info);
enum ndr_err_code ndr_push_spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct spoolss_EnumForms *r);
enum ndr_err_code ndr_pull_spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct spoolss_EnumForms *r);
-uint32_t ndr_size_spoolss_EnumForms_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_FormInfo *info);
+uint32_t ndr_size_spoolss_EnumForms_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_FormInfo *info);
enum ndr_err_code ndr_push_spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct spoolss_EnumPorts *r);
enum ndr_err_code ndr_pull_spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct spoolss_EnumPorts *r);
-uint32_t ndr_size_spoolss_EnumPorts_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_PortInfo *info);
+uint32_t ndr_size_spoolss_EnumPorts_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_PortInfo *info);
enum ndr_err_code ndr_push_spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct spoolss_EnumMonitors *r);
enum ndr_err_code ndr_pull_spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct spoolss_EnumMonitors *r);
-uint32_t ndr_size_spoolss_EnumMonitors_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_MonitorInfo *info);
+uint32_t ndr_size_spoolss_EnumMonitors_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_MonitorInfo *info);
enum ndr_err_code ndr_push_spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcessors *r);
enum ndr_err_code ndr_pull_spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcessors *r);
-uint32_t ndr_size_spoolss_EnumPrintProcessors_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
+uint32_t ndr_size_spoolss_EnumPrintProcessors_info(TALLOC_CTX *mem_ctx,
uint32_t level, uint32_t count, union spoolss_PrintProcessorInfo *info);
enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r);
enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r);
-uint32_t ndr_size_spoolss_EnumPrintProcDataTypes_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
+uint32_t ndr_size_spoolss_EnumPrintProcDataTypes_info(TALLOC_CTX *mem_ctx,
uint32_t level, uint32_t count, union spoolss_PrintProcDataTypesInfo *info);
enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r);
enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r);
-uint32_t ndr_size_spoolss_EnumPrinterDataEx_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
+uint32_t ndr_size_spoolss_EnumPrinterDataEx_info(TALLOC_CTX *mem_ctx,
uint32_t count, struct spoolss_PrinterEnumValues *info);
-uint32_t _ndr_size_spoolss_DeviceMode(struct spoolss_DeviceMode *devmode, struct smb_iconv_convenience *ic, uint32_t flags);
-size_t ndr_size_spoolss_StringArray(const struct spoolss_StringArray *r, struct smb_iconv_convenience *ic, int flags);
+uint32_t _ndr_size_spoolss_DeviceMode(struct spoolss_DeviceMode *devmode, uint32_t flags);
+size_t ndr_size_spoolss_StringArray(const struct spoolss_StringArray *r, int flags);
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo101(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo101 *r);
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo101(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo101 *r);
void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, const union spoolss_Field *r);
-size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags);
+size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, int flags);
void ndr_print_spoolss_security_descriptor(struct ndr_print *ndr, const char *name, const struct security_descriptor *r);
enum ndr_err_code ndr_pull_spoolss_security_descriptor(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor *r);
enum ndr_err_code ndr_push_spoolss_security_descriptor(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor *r);
_PUBLIC_ NTSTATUS GUID_to_ndr_blob(const struct GUID *guid, TALLOC_CTX *mem_ctx, DATA_BLOB *b)
{
enum ndr_err_code ndr_err;
- ndr_err = ndr_push_struct_blob(b, mem_ctx, NULL, guid,
+ ndr_err = ndr_push_struct_blob(b, mem_ctx, guid,
(ndr_push_flags_fn_t)ndr_push_GUID);
return ndr_map_error2ntstatus(ndr_err);
}
mem_ctx = talloc_new(NULL);
NT_STATUS_HAVE_NO_MEMORY(mem_ctx);
- ndr_err = ndr_pull_struct_blob_all(b, mem_ctx, NULL, guid,
+ ndr_err = ndr_pull_struct_blob_all(b, mem_ctx, guid,
(ndr_pull_flags_fn_t)ndr_pull_GUID);
talloc_free(mem_ctx);
return ndr_map_error2ntstatus(ndr_err);
enum ndr_err_code ndr_err;
uint16_t if_version=0;
- ndr = ndr_pull_init_blob(&epm_floor->lhs.lhs_data, mem_ctx, NULL);
+ ndr = ndr_pull_init_blob(&epm_floor->lhs.lhs_data, mem_ctx);
if (ndr == NULL) {
talloc_free(mem_ctx);
return NT_STATUS_NO_MEMORY;
static DATA_BLOB dcerpc_floor_pack_lhs_data(TALLOC_CTX *mem_ctx, const struct ndr_syntax_id *syntax)
{
DATA_BLOB blob;
- struct ndr_push *ndr = ndr_push_init_ctx(mem_ctx, NULL);
+ struct ndr_push *ndr = ndr_push_init_ctx(mem_ctx);
ndr->flags |= LIBNDR_FLAG_NOALIGN;
static DATA_BLOB dcerpc_floor_pack_rhs_if_version_data(TALLOC_CTX *mem_ctx, const struct ndr_syntax_id *syntax)
{
DATA_BLOB blob;
- struct ndr_push *ndr = ndr_push_init_ctx(mem_ctx, NULL);
+ struct ndr_push *ndr = ndr_push_init_ctx(mem_ctx);
ndr->flags |= LIBNDR_FLAG_NOALIGN;
blob.data = data;
blob.length = size;
- ndr_pull = ndr_pull_init_blob(&blob, mem_ctx, lp_iconv_convenience(cmdline_lp_ctx));
+ ndr_pull = ndr_pull_init_blob(&blob, mem_ctx);
ndr_pull->flags |= LIBNDR_FLAG_REF_ALLOC;
if (assume_ndr64) {
ndr_pull->flags |= LIBNDR_FLAG_NDR64;
blob.data = data;
blob.length = size;
- ndr_pull = ndr_pull_init_blob(&blob, mem_ctx, lp_iconv_convenience(cmdline_lp_ctx));
+ ndr_pull = ndr_pull_init_blob(&blob, mem_ctx);
ndr_pull->flags |= LIBNDR_FLAG_REF_ALLOC;
if (assume_ndr64) {
ndr_pull->flags |= LIBNDR_FLAG_NDR64;
uint8_t byte_a, byte_b;
bool differ;
- ndr_v_push = ndr_push_init_ctx(mem_ctx, lp_iconv_convenience(cmdline_lp_ctx));
+ ndr_v_push = ndr_push_init_ctx(mem_ctx);
ndr_err = f->ndr_push(ndr_v_push, flags, st);
status = ndr_map_error2ntstatus(ndr_err);
ndrdump_data(v_blob.data, v_blob.length, dumpdata);
}
- ndr_v_pull = ndr_pull_init_blob(&v_blob, mem_ctx, lp_iconv_convenience(cmdline_lp_ctx));
+ ndr_v_pull = ndr_pull_init_blob(&v_blob, mem_ctx);
ndr_v_pull->flags |= LIBNDR_FLAG_REF_ALLOC;
ndr_err = f->ndr_pull(ndr_v_pull, flags, v_st);
if (my $flags = has_property($t, "flag")) {
$self->pidl("flags |= $flags;");
}
- $self->pidl("return ndr_size_struct($varname, flags, (ndr_push_flags_fn_t)ndr_push_$name, ic);");
+ $self->pidl("return ndr_size_struct($varname, flags, (ndr_push_flags_fn_t)ndr_push_$name);");
}
sub DeclStruct($$$$)
sub ArgsStructNdrSize($$$)
{
my ($d, $name, $varname) = @_;
- return "const struct $name *$varname, struct smb_iconv_convenience *ic, int flags";
+ return "const struct $name *$varname, int flags";
}
$typefamily{STRUCT} = {
$self->pidl("flags |= $flags;");
}
- $self->pidl("return ndr_size_union($varname, flags, level, (ndr_push_flags_fn_t)ndr_push_$name, ic);");
+ $self->pidl("return ndr_size_union($varname, flags, level, (ndr_push_flags_fn_t)ndr_push_$name);");
}
sub ParseUnionPushPrimitives($$$$)
sub ArgsUnionNdrSize($$)
{
my ($d,$name) = @_;
- return "const union $name *r, uint32_t level, struct smb_iconv_convenience *ic, int flags";
+ return "const union $name *r, uint32_t level, int flags";
}
$typefamily{UNION} = {
$self->pidl("$cname *object = ($cname *)py_talloc_get_ptr(py_obj);");
$self->pidl("DATA_BLOB blob;");
$self->pidl("enum ndr_err_code err;");
- $self->pidl("err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, (ndr_push_flags_fn_t)ndr_push_$name);");
+ $self->pidl("err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_$name);");
$self->pidl("if (err != NDR_ERR_SUCCESS) {");
$self->indent;
$self->pidl("PyErr_SetNdrError(err);");
$self->pidl("if (!PyArg_ParseTuple(args, \"s#:__ndr_unpack__\", &blob.data, &blob.length))");
$self->pidl("\treturn NULL;");
$self->pidl("");
- $self->pidl("err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), NULL, object, (ndr_pull_flags_fn_t)ndr_pull_$name);");
+ $self->pidl("err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_$name);");
$self->pidl("if (err != NDR_ERR_SUCCESS) {");
$self->indent;
$self->pidl("PyErr_SetNdrError(err);");
'
uint8_t data[] = { 0x00, 0x00, 0x00, 0x00 };
DATA_BLOB b = { data, 4 };
- struct ndr_pull *ndr = ndr_pull_init_blob(&b, NULL,
- smb_iconv_convenience_reinit(NULL, "ASCII", "UTF8", true, NULL));
+ struct ndr_pull *ndr = ndr_pull_init_blob(&b, NULL);
struct TestString r;
r.in.data = NULL;
uint8_t data[] = { 0x03, 0x00, 0x00, 0x00,
\'f\', \'o\', \'o\', 0 };
DATA_BLOB b = { data, 8 };
- struct ndr_pull *ndr = ndr_pull_init_blob(&b, NULL,
- smb_iconv_convenience_reinit(NULL, "ASCII", "UTF8", true, NULL));
+ struct ndr_pull *ndr = ndr_pull_init_blob(&b, NULL);
struct TestString r;
r.in.data = NULL;
0x02, 0x00, 0x00, 0x00
};
DATA_BLOB b = { data, sizeof(data) };
- struct ndr_pull *ndr = ndr_pull_init_blob(&b, NULL,
- smb_iconv_convenience_reinit(NULL, "ASCII", "UTF8", true, NULL));
+ struct ndr_pull *ndr = ndr_pull_init_blob(&b, NULL);
struct TestString r;
struct TestStringStruct str;
r.in.str = &str;
0x02, 0x00, 0x00, 0x00
};
DATA_BLOB b = { data, sizeof(data) };
- struct ndr_pull *ndr = ndr_pull_init_blob(&b, NULL,
- smb_iconv_convenience_reinit(NULL, "ASCII", "UTF8", true, NULL));
+ struct ndr_pull *ndr = ndr_pull_init_blob(&b, NULL);
struct TestString r;
struct TestStringStruct str;
r.in.str = &str;
0x02, 0x00, 0x00, 0x00
};
DATA_BLOB b = { data, sizeof(data) };
- struct ndr_pull *ndr = ndr_pull_init_blob(&b, NULL,
- smb_iconv_convenience_reinit(NULL, "ASCII", "UTF8", true, NULL));
+ struct ndr_pull *ndr = ndr_pull_init_blob(&b, NULL);
struct TestString r;
struct TestStringStruct str;
r.in.str = &str;
uint8_t data[] = { 0x03, 0x00, 0x00, 0x00,
\'f\', \'o\', \'o\', 0 };
DATA_BLOB b = { data, 8 };
- struct ndr_pull *ndr = ndr_pull_init_blob(&b, NULL,
- smb_iconv_convenience_reinit(NULL, "ASCII", "UTF8", true, NULL));
+ struct ndr_pull *ndr = ndr_pull_init_blob(&b, NULL);
struct TestString r;
char *str = NULL;
r.out.data = &str;
/* Samba 3 doesn't use iconv_convenience: */
extern void *cmdline_lp_ctx;
-struct smb_iconv_convenience *lp_iconv_convenience(void *lp_ctx);
/* Lists, trees, caching, database... */
#include "../lib/util/util.h"
/* The following definitions come from ..libcli/registry/util_reg.c */
const char *str_regtype(int type);
-bool push_reg_sz(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic,
- DATA_BLOB *blob, const char *s);
-bool push_reg_multi_sz(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic,
- DATA_BLOB *blob, const char **a);
-bool pull_reg_sz(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic,
- const DATA_BLOB *blob, const char **s);
-bool pull_reg_multi_sz(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic,
- const DATA_BLOB *blob, const char ***a);
+bool push_reg_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *s);
+bool push_reg_multi_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char **a);
+bool pull_reg_sz(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, const char **s);
+bool pull_reg_multi_sz(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, const char ***a);
/* The following definitions come from lib/util_seaccess.c */
}
void *cmdline_lp_ctx;
-struct smb_iconv_convenience *lp_iconv_convenience(void *lp_ctx)
-{
- return NULL;
-}
const struct ndr_syntax_id null_ndr_syntax_id =
{ { 0, 0, 0, { 0, 0 }, { 0, 0, 0, 0, 0, 0 } }, 0 };
struct gensec_settings {
struct loadparm_context *lp_ctx;
- struct smb_iconv_convenience *iconv_convenience;
const char *target_hostname;
};
*/
if (pac_blob.length) {
nt_status = kerberos_pac_blob_to_server_info(mem_ctx,
- gensec_security->settings->iconv_convenience,
pac_blob,
gensec_gssapi_state->smb_krb5_context->krb5_context,
&server_info);
/* decode and verify the pac */
nt_status = kerberos_pac_logon_info(gensec_krb5_state,
- gensec_security->settings->iconv_convenience,
&logon_info, pac,
gensec_krb5_state->smb_krb5_context->krb5_context,
NULL, gensec_krb5_state->keyblock,
s->target_hostname = PyString_AsString(py_hostname);
s->lp_ctx = lp_from_py_object(s, py_lp_ctx);
- s->iconv_convenience = py_iconv_convenience(s);
return s;
}
bind_schannel.oem_netbios_computer.a = cli_credentials_get_workstation(gensec_security->credentials);
#endif
- ndr_err = ndr_push_struct_blob(out, out_mem_ctx,
- gensec_security->settings->iconv_convenience, &bind_schannel,
+ ndr_err = ndr_push_struct_blob(out, out_mem_ctx, &bind_schannel,
(ndr_push_flags_fn_t)ndr_push_NL_AUTH_MESSAGE);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
}
/* parse the schannel startup blob */
- ndr_err = ndr_pull_struct_blob(&in, out_mem_ctx,
- gensec_security->settings->iconv_convenience,
- &bind_schannel,
+ ndr_err = ndr_pull_struct_blob(&in, out_mem_ctx, &bind_schannel,
(ndr_pull_flags_fn_t)ndr_pull_NL_AUTH_MESSAGE);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
}
status = schannel_get_creds_state(out_mem_ctx,
- gensec_security->settings->iconv_convenience,
lp_private_dir(gensec_security->settings->lp_ctx),
workstation, &creds);
if (!NT_STATUS_IS_OK(status)) {
* any meaning here
* - gd */
- ndr_err = ndr_push_struct_blob(out, out_mem_ctx,
- gensec_security->settings->iconv_convenience, &bind_schannel_ack,
+ ndr_err = ndr_push_struct_blob(out, out_mem_ctx, &bind_schannel_ack,
(ndr_push_flags_fn_t)ndr_push_NL_AUTH_MESSAGE);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
krb5_error_code smb_krb5_kt_free_entry(krb5_context context, krb5_keytab_entry *kt_entry);
char *smb_get_krb5_error_message(krb5_context context, krb5_error_code code, TALLOC_CTX *mem_ctx);
NTSTATUS kerberos_decode_pac(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct PAC_DATA **pac_data_out,
DATA_BLOB blob,
krb5_context context,
time_t tgs_authtime,
krb5_error_code *k5ret);
NTSTATUS kerberos_pac_logon_info(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct PAC_LOGON_INFO **logon_info,
DATA_BLOB blob,
krb5_context context,
time_t tgs_authtime,
krb5_error_code *k5ret);
krb5_error_code kerberos_encode_pac(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct PAC_DATA *pac_data,
krb5_context context,
const krb5_keyblock *krbtgt_keyblock,
const krb5_keyblock *service_keyblock,
DATA_BLOB *pac);
krb5_error_code kerberos_create_pac(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct auth_serversupplied_info *server_info,
krb5_context context,
const krb5_keyblock *krbtgt_keyblock,
}
NTSTATUS kerberos_decode_pac(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct PAC_DATA **pac_data_out,
DATA_BLOB blob,
krb5_context context,
}
ndr_err = ndr_pull_struct_blob(&blob, pac_data,
- iconv_convenience, pac_data,
- (ndr_pull_flags_fn_t)ndr_pull_PAC_DATA);
+ pac_data, (ndr_pull_flags_fn_t)ndr_pull_PAC_DATA);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
DEBUG(0,("can't parse the PAC: %s\n",
}
ndr_err = ndr_pull_struct_blob(&blob, pac_data_raw,
- iconv_convenience, pac_data_raw,
+ pac_data_raw,
(ndr_pull_flags_fn_t)ndr_pull_PAC_DATA_RAW);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
/* We find the data blobs above, now we parse them to get at the exact portion we should zero */
ndr_err = ndr_pull_struct_blob(kdc_sig_blob, kdc_sig_wipe,
- iconv_convenience, kdc_sig_wipe,
+ kdc_sig_wipe,
(ndr_pull_flags_fn_t)ndr_pull_PAC_SIGNATURE_DATA);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
}
ndr_err = ndr_pull_struct_blob(srv_sig_blob, srv_sig_wipe,
- iconv_convenience, srv_sig_wipe,
+ srv_sig_wipe,
(ndr_pull_flags_fn_t)ndr_pull_PAC_SIGNATURE_DATA);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
/* and reencode, back into the same place it came from */
ndr_err = ndr_push_struct_blob(kdc_sig_blob, pac_data_raw,
- iconv_convenience,
kdc_sig_wipe,
(ndr_push_flags_fn_t)ndr_push_PAC_SIGNATURE_DATA);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return status;
}
ndr_err = ndr_push_struct_blob(srv_sig_blob, pac_data_raw,
- iconv_convenience,
srv_sig_wipe,
(ndr_push_flags_fn_t)ndr_push_PAC_SIGNATURE_DATA);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
/* push out the whole structure, but now with zero'ed signatures */
ndr_err = ndr_push_struct_blob(&modified_pac_blob, pac_data_raw,
- iconv_convenience,
pac_data_raw,
(ndr_push_flags_fn_t)ndr_push_PAC_DATA_RAW);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
}
_PUBLIC_ NTSTATUS kerberos_pac_logon_info(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct PAC_LOGON_INFO **logon_info,
DATA_BLOB blob,
krb5_context context,
struct PAC_DATA *pac_data;
int i;
nt_status = kerberos_decode_pac(mem_ctx,
- iconv_convenience,
&pac_data,
blob,
context,
}
krb5_error_code kerberos_encode_pac(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct PAC_DATA *pac_data,
krb5_context context,
const krb5_keyblock *krbtgt_keyblock,
memset(srv_checksum->signature.data, '\0', srv_checksum->signature.length);
ndr_err = ndr_push_struct_blob(&tmp_blob, mem_ctx,
- iconv_convenience,
pac_data,
(ndr_push_flags_fn_t)ndr_push_PAC_DATA);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
/* And push it out again, this time to the world. This relies on determanistic pointer values */
ndr_err = ndr_push_struct_blob(&tmp_blob, mem_ctx,
- iconv_convenience,
pac_data,
(ndr_push_flags_fn_t)ndr_push_PAC_DATA);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
krb5_error_code kerberos_create_pac(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct auth_serversupplied_info *server_info,
krb5_context context,
const krb5_keyblock *krbtgt_keyblock,
unix_to_nt_time(&LOGON_NAME->logon_time, tgs_authtime);
ret = kerberos_encode_pac(mem_ctx,
- iconv_convenience,
pac_data,
context,
krbtgt_keyblock,
}
krb5_error_code kerberos_pac_to_server_info(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
krb5_pac pac,
krb5_context context,
struct auth_serversupplied_info **server_info)
pac_logon_info_in = data_blob_const(k5pac_logon_info_in.data, k5pac_logon_info_in.length);
- ndr_err = ndr_pull_union_blob(&pac_logon_info_in, tmp_ctx, iconv_convenience, &info,
+ ndr_err = ndr_pull_union_blob(&pac_logon_info_in, tmp_ctx, &info,
PAC_TYPE_LOGON_INFO,
(ndr_pull_flags_fn_t)ndr_pull_PAC_INFO);
krb5_data_free(&k5pac_logon_info_in);
pac_srv_checksum_in = data_blob_const(k5pac_srv_checksum_in.data, k5pac_srv_checksum_in.length);
ndr_err = ndr_pull_struct_blob(&pac_srv_checksum_in, server_info_out,
- iconv_convenience, &server_info_out->pac_srv_sig,
+ &server_info_out->pac_srv_sig,
(ndr_pull_flags_fn_t)ndr_pull_PAC_SIGNATURE_DATA);
krb5_data_free(&k5pac_srv_checksum_in);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
pac_kdc_checksum_in = data_blob_const(k5pac_kdc_checksum_in.data, k5pac_kdc_checksum_in.length);
ndr_err = ndr_pull_struct_blob(&pac_kdc_checksum_in, server_info_out,
- iconv_convenience, &server_info_out->pac_kdc_sig,
+ &server_info_out->pac_kdc_sig,
(ndr_pull_flags_fn_t)ndr_pull_PAC_SIGNATURE_DATA);
krb5_data_free(&k5pac_kdc_checksum_in);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS kerberos_pac_blob_to_server_info(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
DATA_BLOB pac_blob,
krb5_context context,
struct auth_serversupplied_info **server_info)
}
- ret = kerberos_pac_to_server_info(mem_ctx, iconv_convenience, pac, context, server_info);
+ ret = kerberos_pac_to_server_info(mem_ctx, pac, context, server_info);
krb5_pac_free(context, pac);
if (ret) {
return map_nt_error_from_unix(ret);
#include "nsswitch/libwbclient/wbclient.h"
#include "libcli/security/dom_sid.h"
-static NTSTATUS get_info3_from_ndr(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, struct winbindd_response *response, struct netr_SamInfo3 *info3)
+static NTSTATUS get_info3_from_ndr(TALLOC_CTX *mem_ctx, struct winbindd_response *response, struct netr_SamInfo3 *info3)
{
size_t len = response->length - sizeof(struct winbindd_response);
if (len > 4) {
blob.data = (uint8_t *)(((char *)response->extra_data.data) + 4);
ndr_err = ndr_pull_struct_blob(&blob, mem_ctx,
- iconv_convenience, info3,
+ info3,
(ndr_pull_flags_fn_t)ndr_pull_netr_SamInfo3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return ndr_map_error2ntstatus(ndr_err);
}
static NTSTATUS get_info3_from_wbcAuthUserInfo(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
struct wbcAuthUserInfo *info,
struct netr_SamInfo3 *info3)
{
if (result == NSS_STATUS_SUCCESS && response.extra_data.data) {
union netr_Validation validation;
- nt_status = get_info3_from_ndr(mem_ctx, lp_iconv_convenience(ctx->auth_ctx->lp_ctx), &response, &info3);
+ nt_status = get_info3_from_ndr(mem_ctx, &response, &info3);
SAFE_FREE(response.extra_data.data);
NT_STATUS_NOT_OK_RETURN(nt_status);
wbcFreeMemory(err);
NT_STATUS_NOT_OK_RETURN(nt_status);
}
- nt_status = get_info3_from_wbcAuthUserInfo(mem_ctx,
- lp_iconv_convenience(ctx->auth_ctx->lp_ctx),
- info, &info3);
+ nt_status = get_info3_from_wbcAuthUserInfo(mem_ctx, info, &info3);
wbcFreeMemory(info);
NT_STATUS_NOT_OK_RETURN(nt_status);
enum ndr_err_code ndr_err;
/* Rather than go via the string, just push into the NDR form */
- ndr_err = ndr_push_struct_blob(&sid_val, mem_ctx, NULL, &sid,
+ ndr_err = ndr_push_struct_blob(&sid_val, mem_ctx, &sid,
(ndr_push_flags_fn_t)ndr_push_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return NT_STATUS_INVALID_PARAMETER;
goto failed;
}
ndr_err = ndr_pull_struct_blob(&t->u.equality.value,
- domain_sid, NULL,
- domain_sid,
+ domain_sid, domain_sid,
(ndr_pull_flags_fn_t)ndr_pull_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(domain_sid);
goto failed;
}
- status = cldap_netlogon_reply(cldap,
- lp_iconv_convenience(cldapd->task->lp_ctx),
- message_id, src, version,
- &netlogon);
+ status = cldap_netlogon_reply(cldap, message_id, src, version, &netlogon);
if (!NT_STATUS_IS_OK(status)) {
goto failed;
}
struct smbcli_options *smb_options,
const char *socket_options,
struct smbcli_session_options *smb_session_options,
- struct smb_iconv_convenience *iconv_convenience,
struct gensec_settings *gensec_settings)
{
int options = 0;
check_arg_numeric("ibs"), options,
socket_options,
smb_options, smb_session_options,
- iconv_convenience,
gensec_settings);
} else if (strcmp(which, "of") == 0) {
options |= DD_WRITE;
check_arg_numeric("obs"), options,
socket_options,
smb_options, smb_session_options,
- iconv_convenience,
gensec_settings);
} else {
SMB_ASSERT(0);
if (!(ifile = open_file(lp_resolve_context(lp_ctx), ev, "if",
lp_smb_ports(lp_ctx), &options,
lp_socket_options(lp_ctx),
- &session_options, lp_iconv_convenience(lp_ctx),
+ &session_options,
lp_gensec_settings(lp_ctx, lp_ctx)))) {
return(FILESYS_EXIT_CODE);
}
lp_smb_ports(lp_ctx), &options,
lp_socket_options(lp_ctx),
&session_options,
- lp_iconv_convenience(lp_ctx),
lp_gensec_settings(lp_ctx, lp_ctx)))) {
return(FILESYS_EXIT_CODE);
}
const char *socket_options,
struct smbcli_options *smb_options,
struct smbcli_session_options *smb_session_options,
- struct smb_iconv_convenience *iconv_convenience,
struct gensec_settings *gensec_settings);
bool dd_fill_block(struct dd_iohandle * h, uint8_t * buf,
uint64_t * buf_size, uint64_t need_size, uint64_t block_size);
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)
{
NTSTATUS ret;
cmdline_credentials, resolve_ctx,
ev, options,
session_options,
- iconv_convenience,
gensec_settings);
if (!NT_STATUS_IS_OK(ret)) {
const char *socket_options,
struct smbcli_options *smb_options,
struct smbcli_session_options *smb_session_options,
- struct smb_iconv_convenience *iconv_convenience,
struct gensec_settings *gensec_settings)
{
struct cifs_handle * smbh;
if ((smbh->cli = init_smb_session(resolve_ctx, ev, host, ports, share,
socket_options,
smb_options, smb_session_options,
- iconv_convenience,
gensec_settings)) == NULL) {
return(NULL);
}
const char *socket_options,
struct smbcli_options *smb_options,
struct smbcli_session_options *smb_session_options,
- struct smb_iconv_convenience *iconv_convenience,
struct gensec_settings *gensec_settings)
{
if (file_exist(path)) {
io_size, options,
socket_options, smb_options,
smb_session_options,
- iconv_convenience,
gensec_settings));
}
struct cli_credentials *cred,
struct smbcli_options *options,
struct smbcli_session_options *session_options,
- struct smb_iconv_convenience *iconv_convenience,
struct gensec_settings *gensec_settings)
{
NTSTATUS status;
socket_options,
cred, resolve_ctx,
ev_ctx, options, session_options,
- iconv_convenience,
gensec_settings);
if (!NT_STATUS_IS_OK(status)) {
d_printf("Connection to \\\\%s\\%s failed - %s\n",
struct tevent_context *ev_ctx,
struct resolve_context *resolve_ctx,
struct smbcli_options *options,
- struct smb_iconv_convenience *iconv_convenience,
const char *socket_options)
{
struct nbt_name called, calling;
if (!(cli = smbcli_state_init(NULL)) ||
!smbcli_socket_connect(cli, server_name, destports,
ev_ctx, resolve_ctx, options,
- iconv_convenience,
socket_options)) {
d_printf("Connection to %s failed\n", server_name);
return 1;
lp_smb_ports(cmdline_lp_ctx), dest_ip,
name_type, ev_ctx,
lp_resolve_context(cmdline_lp_ctx),
- &smb_options, lp_iconv_convenience(cmdline_lp_ctx),
+ &smb_options,
lp_socket_options(cmdline_lp_ctx));
return rc;
}
desthost, lp_smb_ports(cmdline_lp_ctx), service,
lp_socket_options(cmdline_lp_ctx),
cmdline_credentials, &smb_options, &smb_session_options,
- lp_iconv_convenience(cmdline_lp_ctx),
lp_gensec_settings(ctx, cmdline_lp_ctx)))
return 1;
if(!*sd) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ndr_err = ndr_pull_struct_blob(&sd_element->values[0], *sd, NULL, *sd,
+ ndr_err = ndr_pull_struct_blob(&sd_element->values[0], *sd, *sd,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
if (sid == NULL) {
return NULL;
}
- ndr_err = ndr_pull_struct_blob(v, sid, NULL, sid,
+ ndr_err = ndr_pull_struct_blob(v, sid, sid,
(ndr_pull_flags_fn_t)ndr_pull_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(sid);
enum ndr_err_code ndr_err;
ndr_err = ndr_push_struct_blob(&v, mem_ctx,
- lp_iconv_convenience(ldb_get_opaque(sam_ldb, "loadparm")),
sid,
(ndr_push_flags_fn_t)ndr_push_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
for (i=0; i<(*count); i++) {
enum ndr_err_code ndr_err;
ndr_err = ndr_pull_struct_blob(&el->values[i],
- mem_ctx, lp_iconv_convenience(ldb_get_opaque(sam_ctx, "loadparm")),
+ mem_ctx,
&(*r)[i],
(ndr_pull_flags_fn_t)ndr_pull_repsFromToBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
struct ldb_val v;
enum ndr_err_code ndr_err;
- ndr_err = ndr_push_struct_blob(&v, tmp_ctx, lp_iconv_convenience(ldb_get_opaque(sam_ctx, "loadparm")),
+ ndr_err = ndr_push_struct_blob(&v, tmp_ctx,
&r[i],
(ndr_push_flags_fn_t)ndr_push_repsFromToBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
tmp_ctx = talloc_new(NULL);
- ndr_err = ndr_pull_struct_blob_all(sid_blob, tmp_ctx, NULL, sid,
+ ndr_err = ndr_pull_struct_blob_all(sid_blob, tmp_ctx, sid,
(ndr_pull_flags_fn_t)ndr_pull_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
enum ndr_err_code ndr_err;
struct replUpToDateVectorBlob ouv;
- ndr_err = ndr_pull_struct_blob(ouv_value, r,
- lp_iconv_convenience(ldb_get_opaque(samdb, "loadparm")), &ouv,
+ ndr_err = ndr_pull_struct_blob(ouv_value, r, &ouv,
(ndr_pull_flags_fn_t)ndr_pull_replUpToDateVectorBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(r);
}
ndr_err = ndr_pull_struct_blob(omd_value, mem_ctx,
- lp_iconv_convenience(ldb_get_opaque(samdb, "loadparm")), obj_metadata_ctr,
+ obj_metadata_ctr,
(ndr_pull_flags_fn_t)ndr_pull_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(0,(__location__ ": Failed to parse replPropertyMetaData for %s\n",
W_ERROR_HAVE_NO_MEMORY(source);
ndr_err = ndr_pull_struct_blob(val, source,
- lp_iconv_convenience(s->task->lp_ctx), &source->_repsFromBlob,
+ &source->_repsFromBlob,
(ndr_pull_flags_fn_t)ndr_pull_repsFromToBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
if (!user_descriptor) {
return NULL;
}
- ndr_err = ndr_pull_struct_blob(object, user_descriptor, NULL,
+ ndr_err = ndr_pull_struct_blob(object, user_descriptor,
user_descriptor,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!old_descriptor) {
return NULL;
}
- ndr_err = ndr_pull_struct_blob(old_sd, old_descriptor, NULL,
+ ndr_err = ndr_pull_struct_blob(old_sd, old_descriptor,
old_descriptor,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!parent_descriptor) {
return NULL;
}
- ndr_err = ndr_pull_struct_blob(parent, parent_descriptor, NULL,
+ ndr_err = ndr_pull_struct_blob(parent, parent_descriptor,
parent_descriptor,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
}
ndr_err = ndr_push_struct_blob(linear_sd, mem_ctx,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
final_sd,
(ndr_push_flags_fn_t)ndr_push_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
struct security_descriptor *old_sd, *final_sd;
DATA_BLOB *linear_sd;
enum ndr_err_code ndr_err;
- struct ldb_context *ldb = ldb_module_get_ctx(module);
old_sd = talloc(mem_ctx, struct security_descriptor);
if (!old_sd) {
return NULL;
}
- ndr_err = ndr_pull_struct_blob(sd, old_sd, NULL,
+ ndr_err = ndr_pull_struct_blob(sd, old_sd,
old_sd,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
}
ndr_err = ndr_push_struct_blob(linear_sd, mem_ctx,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
final_sd,
(ndr_push_flags_fn_t)ndr_push_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return LDB_ERR_INVALID_DN_SYNTAX;
}
- ndr_err = ndr_push_struct_blob(&sid_blob, NULL, NULL, sid,
+ ndr_err = ndr_push_struct_blob(&sid_blob, NULL, sid,
(ndr_push_flags_fn_t)ndr_push_dom_sid);
talloc_free(sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
}
/* TODO: use ndr_pull_struct_blob_all(), when the ndr layer handles it correct with relative pointers */
- ndr_err = ndr_pull_struct_blob(&blob, io->ac, lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")), &_old_pkb,
+ ndr_err = ndr_pull_struct_blob(&blob, io->ac, &_old_pkb,
(ndr_pull_flags_fn_t)ndr_pull_package_PrimaryKerberosBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
/* TODO: use ndr_pull_struct_blob_all(), when the ndr layer handles it correct with relative pointers */
ndr_err = ndr_pull_struct_blob(&blob, io->ac,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&_old_pkb,
(ndr_pull_flags_fn_t)ndr_pull_package_PrimaryKerberosBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
/* if there's an old supplementaCredentials blob then parse it */
if (io->o.supplemental) {
ndr_err = ndr_pull_struct_blob_all(io->o.supplemental, io->ac,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&_old_scb,
(ndr_pull_flags_fn_t)ndr_pull_supplementalCredentialsBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
}
ndr_err = ndr_push_struct_blob(&pknb_blob, io->ac,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&pknb,
(ndr_push_flags_fn_t)ndr_push_package_PrimaryKerberosBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
}
ndr_err = ndr_push_struct_blob(&pkb_blob, io->ac,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&pkb,
(ndr_push_flags_fn_t)ndr_push_package_PrimaryKerberosBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
}
ndr_err = ndr_push_struct_blob(&pdb_blob, io->ac,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&pdb,
(ndr_push_flags_fn_t)ndr_push_package_PrimaryWDigestBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
pcb.cleartext = *io->n.cleartext_utf16;
ndr_err = ndr_push_struct_blob(&pcb_blob, io->ac,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&pcb,
(ndr_push_flags_fn_t)ndr_push_package_PrimaryCLEARTEXTBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
*/
pb.names = names;
ndr_err = ndr_push_struct_blob(&pb_blob, io->ac,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&pb,
(ndr_push_flags_fn_t)ndr_push_package_PackagesBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
scb.sub.packages = packages;
ndr_err = ndr_push_struct_blob(&io->g.supplemental, io->ac,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&scb,
(ndr_push_flags_fn_t)ndr_push_supplementalCredentialsBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- if (!convert_string_talloc_convenience(io->ac,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
+ if (!convert_string_talloc(io->ac,
CH_UTF8, CH_UTF16,
g->cleartext_utf8->data,
g->cleartext_utf8->length,
return LDB_ERR_OPERATIONS_ERROR;
}
if (!convert_string_talloc_convenience(io->ac,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
CH_UTF16MUNGED, CH_UTF8,
g->cleartext_utf16->data,
g->cleartext_utf16->length,
/* generated NDR encoded values */
ndr_err = ndr_push_struct_blob(&nmd_value, msg,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&nmd,
(ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ndr_err = ndr_pull_struct_blob(omd_value, msg,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")), &omd,
+ ndr_err = ndr_pull_struct_blob(omd_value, msg, &omd,
(ndr_pull_flags_fn_t)ndr_pull_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(0,(__location__ ": Failed to parse replPropertyMetaData for %s\n",
return ret;
}
- ndr_err = ndr_push_struct_blob(md_value, msg,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
- &omd,
+ ndr_err = ndr_push_struct_blob(md_value, msg, &omd,
(ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(0,(__location__ ": Failed to marshall replPropertyMetaData for %s\n",
for (i=0; i < md->ctr.ctr1.count; i++) {
md->ctr.ctr1.array[i].local_usn = ar->seq_num;
}
- ndr_err = ndr_push_struct_blob(&md_value, msg,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
- md,
+ ndr_err = ndr_push_struct_blob(&md_value, msg, md,
(ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
/* find existing meta data */
omd_value = ldb_msg_find_ldb_val(ar->search_msg, "replPropertyMetaData");
if (omd_value) {
- ndr_err = ndr_pull_struct_blob(omd_value, ar,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")), &omd,
+ ndr_err = ndr_pull_struct_blob(omd_value, ar, &omd,
(ndr_pull_flags_fn_t)ndr_pull_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
}
/* create the meta data value */
- ndr_err = ndr_push_struct_blob(&nmd_value, msg,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
- &nmd,
+ ndr_err = ndr_push_struct_blob(&nmd_value, msg, &nmd,
(ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
*/
ouv_value = ldb_msg_find_ldb_val(ar->search_msg, "replUpToDateVector");
if (ouv_value) {
- ndr_err = ndr_pull_struct_blob(ouv_value, ar,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")), &ouv,
+ ndr_err = ndr_pull_struct_blob(ouv_value, ar, &ouv,
(ndr_pull_flags_fn_t)ndr_pull_replUpToDateVectorBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
if (!msg) return replmd_replicated_request_werror(ar, WERR_NOMEM);
msg->dn = ar->search_msg->dn;
- ndr_err = ndr_push_struct_blob(&nuv_value, msg,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
- &nuv,
+ ndr_err = ndr_push_struct_blob(&nuv_value, msg, &nuv,
(ndr_push_flags_fn_t)ndr_push_replUpToDateVectorBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
trf = talloc(ar, struct repsFromToBlob);
if (!trf) return replmd_replicated_request_werror(ar, WERR_NOMEM);
- ndr_err = ndr_pull_struct_blob(&orf_el->values[i], trf, lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")), trf,
+ ndr_err = ndr_pull_struct_blob(&orf_el->values[i], trf, trf,
(ndr_pull_flags_fn_t)ndr_pull_repsFromToBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
/* we now fill the value which is already attached to ldb_message */
ndr_err = ndr_push_struct_blob(nrf_value, msg,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&nrf,
(ndr_push_flags_fn_t)ndr_push_repsFromToBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
TALLOC_CTX *tmp_ctx = talloc_new(module);
msg = messaging_client_init(tmp_ctx, lp_messaging_path(tmp_ctx, lp_ctx),
- lp_iconv_convenience(lp_ctx),
ldb_get_event_context(ldb));
if (!msg) {
DEBUG(3,(__location__ ": Failed to create messaging context\n"));
return;
}
- ndr_err = ndr_pull_struct_blob(sidval, sid, NULL, sid, (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
+ ndr_err = ndr_pull_struct_blob(sidval, sid, sid, (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(sid);
return;
}
ndr_err = ndr_push_struct_blob(&out, ctx,
- NULL,
sid, (ndr_push_flags_fn_t)ndr_push_dom_sid);
talloc_free(sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return out;
}
- ndr_err = ndr_pull_struct_blob(val, sid, NULL, sid,
+ ndr_err = ndr_pull_struct_blob(val, sid, sid,
(ndr_pull_flags_fn_t)ndr_pull_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
goto done;
struct ldb_val v;
enum ndr_err_code ndr_err;
- ndr_err = ndr_push_struct_blob(&v, msg, NULL, sid,
+ ndr_err = ndr_push_struct_blob(&v, msg, sid,
(ndr_push_flags_fn_t)ndr_push_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return false;
}
ret = dsdb_schema_from_ldb_results(tmp_ctx, ldb,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
schema_res, a_res, c_res, schema, &error_string);
if (ret != LDB_SUCCESS) {
ldb_asprintf_errstring(ldb,
W_ERROR_HAVE_NO_MEMORY(temp_ctx);
ndr_err = ndr_pull_struct_blob_all(blob, temp_ctx,
- lp_iconv_convenience(NULL), &schema_info_blob,
+ &schema_info_blob,
(ndr_pull_flags_fn_t)ndr_pull_schemaInfoBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
schema_info_blob.invocation_id = schema_info->invocation_id;
ndr_err = ndr_push_struct_blob(blob, mem_ctx,
- lp_iconv_convenience(NULL), &schema_info_blob,
+ &schema_info_blob,
(ndr_push_flags_fn_t)ndr_push_schemaInfoBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
#include "../lib/util/asn1.h"
-struct dsdb_schema *dsdb_new_schema(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience)
+struct dsdb_schema *dsdb_new_schema(TALLOC_CTX *mem_ctx)
{
struct dsdb_schema *schema = talloc_zero(mem_ctx, struct dsdb_schema);
if (!schema) {
return NULL;
}
- schema->iconv_convenience = iconv_convenience;
return schema;
}
}
static WERROR _dsdb_prefixmap_from_ldb_val(const struct ldb_val *pfm_ldb_val,
- struct smb_iconv_convenience *iconv_convenience,
TALLOC_CTX *mem_ctx,
struct dsdb_schema_prefixmap **_pfm)
{
W_ERROR_HAVE_NO_MEMORY(temp_ctx);
ndr_err = ndr_pull_struct_blob(pfm_ldb_val, temp_ctx,
- iconv_convenience, &pfm_blob,
+ &pfm_blob,
(ndr_pull_flags_fn_t)ndr_pull_prefixMapBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
/* fetch prefixMap */
werr = _dsdb_prefixmap_from_ldb_val(prefixMap,
- schema->iconv_convenience,
mem_ctx, &pfm);
W_ERROR_NOT_OK_GOTO(werr, DONE);
pfm.reserved = 0;
pfm.ctr.dsdb = *ctr;
- ndr_err = ndr_push_struct_blob(prefixMap, mem_ctx, schema->iconv_convenience, &pfm,
+ ndr_err = ndr_push_struct_blob(prefixMap, mem_ctx, &pfm,
(ndr_push_flags_fn_t)ndr_push_prefixMapBlob);
talloc_free(ctr);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
pfm_blob.ctr.dsdb = *ctr;
ndr_err = ndr_push_struct_blob(&ndr_blob, temp_ctx,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
&pfm_blob,
(ndr_push_flags_fn_t)ndr_push_prefixMapBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
WERROR werr;
int ldb_ret;
const struct ldb_val *prefix_val;
- struct smb_iconv_convenience *iconv_convenience;
struct ldb_dn *schema_dn;
struct ldb_result *schema_res = NULL;
static const char *schema_attrs[] = {
return WERR_FOOBAR;
}
- iconv_convenience = lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm"));
-
werr = _dsdb_prefixmap_from_ldb_val(prefix_val,
- iconv_convenience,
mem_ctx,
_pfm);
talloc_free(schema_res);
*/
int dsdb_schema_from_ldb_results(TALLOC_CTX *mem_ctx, struct ldb_context *ldb,
- struct smb_iconv_convenience *iconv_convenience,
struct ldb_result *schema_res,
struct ldb_result *attrs_res, struct ldb_result *objectclass_res,
struct dsdb_schema **schema_out,
struct ldb_val info_val_default;
struct dsdb_schema *schema;
- schema = dsdb_new_schema(mem_ctx, iconv_convenience);
+ schema = dsdb_new_schema(mem_ctx);
if (!schema) {
dsdb_oom(error_string, mem_ctx);
return LDB_ERR_OPERATIONS_ERROR;
} \
if (_a && _a->value_ctr.num_values >= 1) { \
size_t _ret; \
- if (!convert_string_talloc_convenience(mem_ctx, s->iconv_convenience, CH_UTF16, CH_UNIX, \
+ if (!convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, \
_a->value_ctr.values[0].blob->data, \
_a->value_ctr.values[0].blob->length, \
(void **)discard_const(&(p)->elem), &_ret, false)) { \
}
status = dsdb_syntax_one_DN_drsuapi_to_ldb(mem_ctx, ldb, find_syntax_map_by_standard_oid(LDB_SYNTAX_DN),
- schema->iconv_convenience, attr->value_ctr.values[0].blob, &blob);
+ attr->value_ctr.values[0].blob, &blob);
if (!W_ERROR_IS_OK(status)) {
return status;
}
goto nomem;
}
- schema = dsdb_new_schema(mem_ctx, lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")));
+ schema = dsdb_new_schema(mem_ctx);
schema->fsmo.we_are_master = true;
schema->fsmo.master_dn = ldb_dn_new_fmt(schema, ldb, "@PROVISION_SCHEMA_MASTER");
return WERR_FOOBAR;
}
- if (!convert_string_talloc_convenience(out->values,
- schema->iconv_convenience,
+ if (!convert_string_talloc(out->values,
CH_UTF16, CH_UNIX,
in->value_ctr.values[i].blob->data,
in->value_ctr.values[i].blob->length,
for (i=0; i < in->num_values; i++) {
out->value_ctr.values[i].blob = &blobs[i];
- if (!convert_string_talloc_convenience(blobs,
- schema->iconv_convenience, CH_UNIX, CH_UTF16,
+ if (!convert_string_talloc(blobs,
+ CH_UNIX, CH_UTF16,
in->values[i].data, in->values[i].length,
(void **)&blobs[i].data, &blobs[i].length, false)) {
return WERR_FOOBAR;
WERROR dsdb_syntax_one_DN_drsuapi_to_ldb(TALLOC_CTX *mem_ctx, struct ldb_context *ldb,
const struct dsdb_syntax *syntax,
- struct smb_iconv_convenience *iconv_convenience,
const DATA_BLOB *in, DATA_BLOB *out)
{
struct drsuapi_DsReplicaObjectIdentifier3 id3;
/* windows sometimes sends an extra two pad bytes here */
ndr_err = ndr_pull_struct_blob(in,
- tmp_ctx, iconv_convenience, &id3,
+ tmp_ctx, &id3,
(ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
if (id3.__ndr_size_sid) {
DATA_BLOB sid_blob;
- ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, iconv_convenience, &id3.sid,
+ ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, &id3.sid,
(ndr_push_flags_fn_t)ndr_push_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
for (i=0; i < out->num_values; i++) {
WERROR status = dsdb_syntax_one_DN_drsuapi_to_ldb(out->values, ldb, attr->syntax,
- schema->iconv_convenience,
in->value_ctr.values[i].blob,
&out->values[i]);
if (!W_ERROR_IS_OK(status)) {
id3.dn = ldb_dn_get_linearized(dn);
- ndr_err = ndr_push_struct_blob(&blobs[i], blobs, schema->iconv_convenience, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+ ndr_err = ndr_push_struct_blob(&blobs[i], blobs, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
talloc_free(tmp_ctx);
num_components++;
ndr_err = ndr_pull_struct_blob_all(sid_blob,
tmp_ctx,
- schema->iconv_convenience,
&sid,
(ndr_pull_flags_fn_t)ndr_pull_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
/* windows sometimes sends an extra two pad bytes here */
ndr_err = ndr_pull_struct_blob(in->value_ctr.values[i].blob,
- tmp_ctx, schema->iconv_convenience, &id3,
+ tmp_ctx, &id3,
(ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
if (id3.__ndr_size_sid) {
DATA_BLOB sid_blob;
- ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, schema->iconv_convenience, &id3.sid,
+ ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, &id3.sid,
(ndr_push_flags_fn_t)ndr_push_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
if (sid_blob) {
ndr_err = ndr_pull_struct_blob_all(sid_blob,
- tmp_ctx, schema->iconv_convenience, &id3.sid,
+ tmp_ctx, &id3.sid,
(ndr_pull_flags_fn_t)ndr_pull_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
/* get binary stuff */
id3.binary = dsdb_dn->extra_part;
- ndr_err = ndr_push_struct_blob(&blobs[i], blobs, schema->iconv_convenience, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary);
+ ndr_err = ndr_push_struct_blob(&blobs[i], blobs, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
talloc_free(tmp_ctx);
return WERR_FOOBAR;
}
- if (!convert_string_talloc_convenience(out->values, schema->iconv_convenience, CH_UTF16, CH_UNIX,
+ if (!convert_string_talloc(out->values, CH_UTF16, CH_UNIX,
in->value_ctr.values[i].blob->data+4,
in->value_ctr.values[i].blob->length-4,
(void **)&str, NULL, false)) {
out->value_ctr.values[i].blob = &blobs[i];
- if (!convert_string_talloc_convenience(blobs, schema->iconv_convenience, CH_UNIX, CH_UTF16,
+ if (!convert_string_talloc(blobs, CH_UNIX, CH_UTF16,
in->values[i].data,
in->values[i].length,
(void **)&data, &ret, false)) {
}
static krb5_error_code samba_kdc_message2entry_keys(krb5_context context,
- struct smb_iconv_convenience *iconv_convenience,
TALLOC_CTX *mem_ctx,
struct ldb_message *msg,
unsigned int userAccountControl,
/* supplementalCredentials if present */
if (sc_val) {
- ndr_err = ndr_pull_struct_blob_all(sc_val, mem_ctx, iconv_convenience, &scb,
+ ndr_err = ndr_pull_struct_blob_all(sc_val, mem_ctx, &scb,
(ndr_pull_flags_fn_t)ndr_pull_supplementalCredentialsBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
dump_data(0, sc_val->data, sc_val->length);
}
/* we cannot use ndr_pull_struct_blob_all() here, as w2k and w2k3 add padding bytes */
- ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, iconv_convenience, &_pkb,
+ ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &_pkb,
(ndr_pull_flags_fn_t)ndr_pull_package_PrimaryKerberosBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
ret = EINVAL;
entry_ex->entry.generation = NULL;
/* Get keys from the db */
- ret = samba_kdc_message2entry_keys(context, p->kdc_db_ctx->ic_ctx, p,
- msg, userAccountControl, entry_ex);
+ ret = samba_kdc_message2entry_keys(context, p, msg, userAccountControl,
+ entry_ex);
if (ret) {
/* Could be bougus data in the entry, or out of memory */
goto out;
goto out;
}
- ndr_err = ndr_pull_struct_blob(password_val, mem_ctx, p->kdc_db_ctx->ic_ctx, &password_blob,
+ ndr_err = ndr_pull_struct_blob(password_val, mem_ctx, &password_blob,
(ndr_pull_flags_fn_t)ndr_pull_trustAuthInOutBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
ret = EINVAL;
/* There is no reply to this request */
r->out.generic_reply = data_blob(NULL, 0);
- ndr_err = ndr_pull_struct_blob(&r->in.generic_request, msg,
- lp_iconv_convenience(kdc->task->lp_ctx),
- &pac_validate,
+ ndr_err = ndr_pull_struct_blob(&r->in.generic_request, msg, &pac_validate,
(ndr_pull_flags_fn_t)ndr_pull_PAC_Validate);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return NT_STATUS_INVALID_PARAMETER;
static
NTSTATUS samba_get_logon_info_pac_blob(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
struct auth_serversupplied_info *info,
DATA_BLOB *pac_data)
{
pac_info.logon_info.info->info3 = *info3;
- ndr_err = ndr_push_union_blob(pac_data, mem_ctx, ic, &pac_info,
+ ndr_err = ndr_push_union_blob(pac_data, mem_ctx, &pac_info,
PAC_TYPE_LOGON_INFO,
(ndr_push_flags_fn_t)ndr_push_PAC_INFO);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return nt_status;
}
- nt_status = samba_get_logon_info_pac_blob(mem_ctx,
- p->kdc_db_ctx->ic_ctx,
- server_info, pac_blob);
+ nt_status = samba_get_logon_info_pac_blob(mem_ctx, server_info, pac_blob);
if (!NT_STATUS_IS_OK(nt_status)) {
DEBUG(0, ("Building PAC failed: %s\n",
nt_errstr(nt_status)));
NTSTATUS samba_kdc_update_pac_blob(TALLOC_CTX *mem_ctx,
krb5_context context,
- struct smb_iconv_convenience *ic,
krb5_pac *pac, DATA_BLOB *pac_blob)
{
struct auth_serversupplied_info *server_info;
krb5_error_code ret;
NTSTATUS nt_status;
- ret = kerberos_pac_to_server_info(mem_ctx, ic, *pac,
+ ret = kerberos_pac_to_server_info(mem_ctx, *pac,
context, &server_info);
if (ret) {
return NT_STATUS_UNSUCCESSFUL;
}
- nt_status = samba_get_logon_info_pac_blob(mem_ctx, ic,
+ nt_status = samba_get_logon_info_pac_blob(mem_ctx,
server_info, pac_blob);
return nt_status;
}
p = talloc_size(mem_ctx, struct_size);
err = ndr_pull_struct_blob(in, mem_ctx,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
p, pull_fn);
if (err != NDR_ERR_SUCCESS) {
/* fail in not in mask_error mode */
if (sid == NULL) {
return -1;
}
- ndr_err = ndr_push_struct_blob(out, mem_ctx, NULL, sid,
+ ndr_err = ndr_push_struct_blob(out, mem_ctx, sid,
(ndr_push_flags_fn_t)ndr_push_dom_sid);
talloc_free(sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
if (sid == NULL) {
return -1;
}
- ndr_err = ndr_pull_struct_blob_all(in, sid, NULL, sid,
+ ndr_err = ndr_pull_struct_blob_all(in, sid, sid,
(ndr_pull_flags_fn_t)ndr_pull_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(sid);
(const char *)in->data, in->length);
/* Check it looks like a SID */
- ndr_err = ndr_pull_struct_blob_all(out, mem_ctx, NULL, &sid,
+ ndr_err = ndr_pull_struct_blob_all(out, mem_ctx, &sid,
(ndr_pull_flags_fn_t)ndr_pull_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return -1;
return -1;
}
- ndr_err = ndr_pull_struct_blob(in, sd, NULL, sd,
+ ndr_err = ndr_pull_struct_blob(in, sd, sd,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
/* If this does not parse, then it is probably SDDL, and we should try it that way */
}
}
- ndr_err = ndr_push_struct_blob(out, mem_ctx, NULL, sd,
+ ndr_err = ndr_push_struct_blob(out, mem_ctx, sd,
(ndr_push_flags_fn_t)ndr_push_security_descriptor);
talloc_free(sd);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return -1;
}
/* We can't use ndr_pull_struct_blob_all because this contains relative pointers */
- ndr_err = ndr_pull_struct_blob(in, sd, NULL, sd,
+ ndr_err = ndr_pull_struct_blob(in, sd, sd,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(sd);
}
ndr_err = ndr_push_struct_blob(out, mem_ctx,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
blob,
(ndr_push_flags_fn_t)ndr_push_prefixMapBlob);
talloc_free(tmp_ctx);
return -1;
}
ndr_err = ndr_pull_struct_blob_all(in, blob,
- lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
blob,
(ndr_pull_flags_fn_t)ndr_pull_prefixMapBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
struct messaging_context *messaging_init(TALLOC_CTX *mem_ctx,
const char *dir,
struct server_id server_id,
- struct smb_iconv_convenience *iconv_convenience,
struct tevent_context *ev);
struct messaging_context *messaging_client_init(TALLOC_CTX *mem_ctx,
const char *dir,
- struct smb_iconv_convenience *iconv_convenience,
struct tevent_context *ev);
NTSTATUS messaging_send_ptr(struct messaging_context *msg, struct server_id server,
uint32_t msg_type, void *ptr);
struct idr_context *dispatch_tree;
struct messaging_rec *pending;
struct messaging_rec *retry_queue;
- struct smb_iconv_convenience *iconv_convenience;
struct irpc_list *irpc;
struct idr_context *idr;
const char **names;
struct messaging_context *messaging_init(TALLOC_CTX *mem_ctx,
const char *dir,
struct server_id server_id,
- struct smb_iconv_convenience *iconv_convenience,
struct tevent_context *ev)
{
struct messaging_context *msg;
msg->base_path = talloc_reference(msg, dir);
msg->path = messaging_path(msg, server_id);
msg->server_id = server_id;
- msg->iconv_convenience = iconv_convenience;
msg->idr = idr_init(msg);
msg->dispatch_tree = idr_init(msg);
msg->start_time = timeval_current();
*/
struct messaging_context *messaging_client_init(TALLOC_CTX *mem_ctx,
const char *dir,
- struct smb_iconv_convenience *iconv_convenience,
struct tevent_context *ev)
{
struct server_id id;
ZERO_STRUCT(id);
id.id = random() % 0x10000000;
- return messaging_init(mem_ctx, dir, id, iconv_convenience, ev);
+ return messaging_init(mem_ctx, dir, id, ev);
}
/*
a list of registered irpc server functions
m->header.status = status;
/* setup the reply */
- push = ndr_push_init_ctx(m->ndr, m->msg_ctx->iconv_convenience);
+ push = ndr_push_init_ctx(m->ndr);
if (push == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
m->from = src;
- m->ndr = ndr_pull_init_blob(packet, m, msg_ctx->iconv_convenience);
+ m->ndr = ndr_pull_init_blob(packet, m);
if (m->ndr == NULL) goto failed;
m->ndr->flags |= LIBNDR_FLAG_REF_ALLOC;
header.status = NT_STATUS_OK;
/* construct the irpc packet */
- ndr = ndr_push_init_ctx(irpc, msg_ctx->iconv_convenience);
+ ndr = ndr_push_init_ctx(irpc);
if (ndr == NULL) goto failed;
ndr_err = ndr_push_irpc_header(ndr, NDR_SCALARS|NDR_BUFFERS, &header);
ret->msg_ctx = messaging_init(ret->mem_ctx,
messaging_path,
server_id,
- py_iconv_convenience(ret->mem_ctx),
ev);
} else {
ret->msg_ctx = messaging_client_init(ret->mem_ctx,
messaging_path,
- py_iconv_convenience(ret->mem_ctx),
ev);
}
ret->msg_ctx = messaging_init(ret->mem_ctx,
messaging_path,
server_id,
- py_iconv_convenience(ret->mem_ctx),
ev);
} else {
ret->msg_ctx = messaging_client_init(ret->mem_ctx,
messaging_path,
- py_iconv_convenience(ret->mem_ctx),
ev);
}
messaging_init(tctx,
lp_messaging_path(tctx, tctx->lp_ctx),
cluster_id(0, MSG_ID1),
- lp_iconv_convenience(tctx->lp_ctx),
data->ev),
"Failed to init first messaging context");
messaging_init(tctx,
lp_messaging_path(tctx, tctx->lp_ctx),
cluster_id(0, MSG_ID2),
- lp_iconv_convenience(tctx->lp_ctx),
data->ev),
"Failed to init second messaging context");
ev = tctx->ev;
msg_server_ctx = messaging_init(tctx,
- lp_messaging_path(tctx, tctx->lp_ctx),
- cluster_id(0, 1),
- lp_iconv_convenience(tctx->lp_ctx),
+ lp_messaging_path(tctx, tctx->lp_ctx), cluster_id(0, 1),
ev);
torture_assert(tctx, msg_server_ctx != NULL, "Failed to init ping messaging context");
msg_client_ctx = messaging_init(tctx,
lp_messaging_path(tctx, tctx->lp_ctx),
cluster_id(0, 2),
- lp_iconv_convenience(tctx->lp_ctx),
ev);
torture_assert(tctx, msg_client_ctx != NULL,
if (!strncmp(peek, "regf", 4)) {
close(fd);
- return reg_open_regf_file(parent_ctx, location, lp_iconv_convenience(lp_ctx), root);
+ return reg_open_regf_file(parent_ctx, location, root);
} else if (!strncmp(peek, "TDB file", 8)) {
close(fd);
return reg_open_ldb_file(parent_ctx, location, session_info,
_PUBLIC_ WERROR reg_preg_diff_load(int fd,
- struct smb_iconv_convenience *iconv_convenience,
const struct reg_diff_callbacks *callbacks,
void *callback_data);
_PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
- struct smb_iconv_convenience *iconv_convenience,
const struct reg_diff_callbacks *callbacks,
void *callback_data);
* Load diff file
*/
_PUBLIC_ WERROR reg_diff_load(const char *filename,
- struct smb_iconv_convenience *iconv_convenience,
const struct reg_diff_callbacks *callbacks,
void *callback_data)
{
#endif
if (strncmp(hdr, "PReg", 4) == 0) {
/* Must be a GPO Registry.pol file */
- return reg_preg_diff_load(fd, iconv_convenience, callbacks, callback_data);
+ return reg_preg_diff_load(fd, callbacks, callback_data);
} else {
/* Must be a normal .REG file */
- return reg_dotreg_diff_load(fd, iconv_convenience, callbacks, callback_data);
+ return reg_dotreg_diff_load(fd, callbacks, callback_data);
}
}
* Apply diff to a registry context
*/
_PUBLIC_ WERROR reg_diff_apply(struct registry_context *ctx,
- struct smb_iconv_convenience *iconv_convenience,
const char *filename)
{
struct reg_diff_callbacks callbacks;
callbacks.del_all_values = reg_diff_apply_del_all_values;
callbacks.done = NULL;
- return reg_diff_load(filename, iconv_convenience,
- &callbacks, ctx);
+ return reg_diff_load(filename, &callbacks, ctx);
}
struct dotreg_data {
int fd;
- struct smb_iconv_convenience *iconv_convenience;
};
static WERROR reg_dotreg_diff_add_key(void *_data, const char *key_name)
uint32_t value_type, DATA_BLOB value)
{
struct dotreg_data *data = (struct dotreg_data *)_data;
- char *data_string = reg_val_data_string(NULL, data->iconv_convenience,
+ char *data_string = reg_val_data_string(NULL,
value_type, value);
W_ERROR_HAVE_NO_MEMORY(data_string);
fdprintf(data->fd, "\"%s\"=%s:%s\n",
* Save registry diff
*/
_PUBLIC_ WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
- struct smb_iconv_convenience *iconv_convenience,
struct reg_diff_callbacks **callbacks,
void **callback_data)
{
data = talloc_zero(ctx, struct dotreg_data);
*callback_data = data;
- data->iconv_convenience = iconv_convenience;
-
if (filename) {
data->fd = open(filename, O_CREAT|O_WRONLY, 0755);
if (data->fd < 0) {
* Load diff file
*/
_PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
- struct smb_iconv_convenience *iconv_convenience,
const struct reg_diff_callbacks *callbacks,
void *callback_data)
{
q++;
}
- reg_string_to_val(line, iconv_convenience,
+ reg_string_to_val(line,
q?p:"REG_SZ", q?q:p,
&value_type, &value);
* Save registry diff
*/
_PUBLIC_ WERROR reg_preg_diff_save(TALLOC_CTX *ctx, const char *filename,
- struct smb_iconv_convenience *ic,
struct reg_diff_callbacks **callbacks,
void **callback_data)
{
* Load diff file
*/
_PUBLIC_ WERROR reg_preg_diff_load(int fd,
- struct smb_iconv_convenience *iconv_convenience,
const struct reg_diff_callbacks *callbacks,
void *callback_data)
{
#include <tevent.h>
#include "libcli/util/pyerrors.h"
#include "lib/registry/registry.h"
-#include "scripting/python/modules.h" /* for py_iconv_convenience() */
#include "lib/talloc/pytalloc.h"
#include "auth/credentials/pycredentials.h"
#include "param/pyparam.h"
if (!PyArg_ParseTuple(args, "s", &filename))
return NULL;
- result = reg_diff_apply(ctx, py_iconv_convenience(NULL), filename);
+ result = reg_diff_apply(ctx, filename);
PyErr_WERROR_IS_ERR_RAISE(result);
Py_RETURN_NONE;
int fd;
struct hbin_block **hbins;
struct regf_hdr *header;
- struct smb_iconv_convenience *iconv_convenience;
};
static WERROR regf_save_hbin(struct regf_data *data);
static bool hbin_get_tdr(struct regf_data *regf, uint32_t offset,
TALLOC_CTX *ctx, tdr_pull_fn_t pull_fn, void *p)
{
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
pull->data = hbin_get(regf, offset);
if (!pull->data.data) {
static uint32_t hbin_store_tdr(struct regf_data *data,
tdr_push_fn_t push_fn, void *p)
{
- struct tdr_push *push = tdr_push_init(data, data->iconv_convenience);
+ struct tdr_push *push = tdr_push_init(data);
uint32_t ret;
if (NT_STATUS_IS_ERR(push_fn(push, p))) {
tdr_push_fn_t push_fn,
uint32_t orig_offset, void *p)
{
- struct tdr_push *push = tdr_push_init(regf, regf->iconv_convenience);
+ struct tdr_push *push = tdr_push_init(regf);
uint32_t ret;
if (NT_STATUS_IS_ERR(push_fn(push, p))) {
if (!strncmp((char *)data.data, "li", 2)) {
struct li_block li;
- struct tdr_pull *pull = tdr_pull_init(private_data->hive, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(private_data->hive);
DEBUG(10, ("Subkeys in LI list\n"));
pull->data = data;
} else if (!strncmp((char *)data.data, "lf", 2)) {
struct lf_block lf;
- struct tdr_pull *pull = tdr_pull_init(private_data->hive, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(private_data->hive);
DEBUG(10, ("Subkeys in LF list\n"));
pull->data = data;
key_off = lf.hr[idx].nk_offset;
} else if (!strncmp((char *)data.data, "lh", 2)) {
struct lh_block lh;
- struct tdr_pull *pull = tdr_pull_init(private_data->hive, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(private_data->hive);
DEBUG(10, ("Subkeys in LH list\n"));
pull->data = data;
key_off = lh.hr[idx].nk_offset;
} else if (!strncmp((char *)data.data, "ri", 2)) {
struct ri_block ri;
- struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(ctx);
uint16_t i;
uint16_t sublist_count = 0;
return WERR_GENERAL_FAILURE;
}
- pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+ pull = tdr_pull_init(ctx);
pull->data = subkey_data;
if (!strncmp((char *)data.data, "li", 2)) {
struct li_block li;
- struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(ctx);
uint16_t i;
DEBUG(10, ("Subkeys in LI list\n"));
return WERR_BADFILE;
} else if (!strncmp((char *)data.data, "lf", 2)) {
struct lf_block lf;
- struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(ctx);
uint16_t i;
DEBUG(10, ("Subkeys in LF list\n"));
return WERR_BADFILE;
} else if (!strncmp((char *)data.data, "lh", 2)) {
struct lh_block lh;
- struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(ctx);
uint16_t i;
uint32_t hash;
return WERR_BADFILE;
} else if (!strncmp((char *)data.data, "ri", 2)) {
struct ri_block ri;
- struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(ctx);
uint16_t i, j;
DEBUG(10, ("Subkeys in RI list\n"));
(tdr_pull_fn_t) tdr_pull_nk_block, &root);
/* Push the security descriptor to a blob */
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf, NULL,
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf,
sec_desc, (ndr_push_flags_fn_t)ndr_push_security_descriptor))) {
DEBUG(0, ("Unable to push security descriptor\n"));
return WERR_GENERAL_FAILURE;
data.data = sk.sec_desc;
data.length = sk.rec_size;
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_pull_struct_blob(&data, ctx, NULL, *sd,
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_pull_struct_blob(&data, ctx, *sd,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor))) {
DEBUG(0, ("Error parsing security descriptor\n"));
return WERR_GENERAL_FAILURE;
}
if (!strncmp((char *)data.data, "li", 2)) {
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
struct li_block li;
pull->data = data;
talloc_free(li.nk_offset);
} else if (!strncmp((char *)data.data, "lf", 2)) {
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
struct lf_block lf;
pull->data = data;
talloc_free(lf.hr);
} else if (!strncmp((char *)data.data, "lh", 2)) {
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
struct lh_block lh;
pull->data = data;
if (strncmp((char *)data.data, "li", 2) == 0) {
struct li_block li;
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
uint16_t i;
bool found_offset = false;
list_offset, &li);
} else if (strncmp((char *)data.data, "lf", 2) == 0) {
struct lf_block lf;
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
uint16_t i;
bool found_offset = false;
list_offset, &lf);
} else if (strncmp((char *)data.data, "lh", 2) == 0) {
struct lh_block lh;
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
uint16_t i;
bool found_offset = false;
static WERROR regf_save_hbin(struct regf_data *regf)
{
- struct tdr_push *push = tdr_push_init(regf, regf->iconv_convenience);
+ struct tdr_push *push = tdr_push_init(regf);
unsigned int i;
W_ERROR_HAVE_NO_MEMORY(push);
regf->header->chksum = regf_hdr_checksum(push->data.data);
talloc_free(push);
- if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd, regf->iconv_convenience,
+ if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd,
(tdr_push_fn_t)tdr_push_regf_hdr,
regf->header))) {
DEBUG(0, ("Error writing registry file header\n"));
}
for (i = 0; regf->hbins[i]; i++) {
- if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd, regf->iconv_convenience,
+ if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd,
(tdr_push_fn_t)tdr_push_hbin_block,
regf->hbins[i]))) {
DEBUG(0, ("Error writing HBIN block\n"));
}
WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx,
- struct smb_iconv_convenience *iconv_convenience,
const char *location,
int minor_version, struct hive_key **key)
{
regf = (struct regf_data *)talloc_zero(NULL, struct regf_data);
- regf->iconv_convenience = iconv_convenience;
-
W_ERROR_HAVE_NO_MEMORY(regf);
DEBUG(5, ("Attempting to create registry file\n"));
NULL);
/* Push the security descriptor to a blob */
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf, NULL,
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf,
sd, (ndr_push_flags_fn_t)ndr_push_security_descriptor))) {
DEBUG(0, ("Unable to push security descriptor\n"));
return WERR_GENERAL_FAILURE;
}
WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx, const char *location,
- struct smb_iconv_convenience *iconv_convenience, struct hive_key **key)
+ struct hive_key **key)
{
struct regf_data *regf;
struct regf_hdr *regf_hdr;
regf = (struct regf_data *)talloc_zero(parent_ctx, struct regf_data);
- regf->iconv_convenience = iconv_convenience;
-
W_ERROR_HAVE_NO_MEMORY(regf);
DEBUG(5, ("Attempting to load registry file\n"));
return WERR_GENERAL_FAILURE;
}
- pull = tdr_pull_init(regf, regf->iconv_convenience);
+ pull = tdr_pull_init(regf);
pull->data.data = (uint8_t*)fd_load(regf->fd, &pull->data.length, 0, regf);
struct registry_context;
struct loadparm_context;
-struct smb_iconv_convenience;
#include <talloc.h>
#include "libcli/util/werror.h"
WERROR reg_open_directory(TALLOC_CTX *parent_ctx,
const char *location, struct hive_key **key);
WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx,
- const char *location, struct smb_iconv_convenience *iconv_convenience,
- struct hive_key **key);
+ const char *location, struct hive_key **key);
WERROR reg_open_ldb_file(TALLOC_CTX *parent_ctx, const char *location,
struct auth_session_info *session_info,
struct cli_credentials *credentials,
WERROR reg_create_directory(TALLOC_CTX *parent_ctx,
const char *location, struct hive_key **key);
WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx,
- struct smb_iconv_convenience *iconv_convenience,
const char *location,
int major_version,
struct hive_key **key);
/* Utility functions */
const char *str_regtype(int type);
-bool push_reg_sz(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic,
- DATA_BLOB *blob, const char *s);
-bool push_reg_multi_sz(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic,
- DATA_BLOB *blob, const char **a);
-bool pull_reg_sz(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic,
- const DATA_BLOB *blob, const char **s);
-bool pull_reg_multi_sz(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic,
- const DATA_BLOB *blob, const char ***a);
+bool push_reg_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *s);
+bool push_reg_multi_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char **a);
+bool pull_reg_sz(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, const char **s);
+bool pull_reg_multi_sz(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, const char ***a);
int regtype_by_string(const char *str);
-char *reg_val_data_string(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t type, const DATA_BLOB data);
-char *reg_val_description(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const char *name,
+char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type, const DATA_BLOB data);
+char *reg_val_description(TALLOC_CTX *mem_ctx, const char *name,
uint32_t type, const DATA_BLOB data);
-bool reg_string_to_val(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const char *type_str,
+bool reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str,
const char *data_str, uint32_t *type, DATA_BLOB *data);
WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle,
const char *name, struct registry_key **result);
};
WERROR reg_diff_apply(struct registry_context *ctx,
- struct smb_iconv_convenience *ic, const char *filename);
+ const char *filename);
WERROR reg_generate_diff(struct registry_context *ctx1,
struct registry_context *ctx2,
const struct reg_diff_callbacks *callbacks,
void *callback_data);
WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
- struct smb_iconv_convenience *iconv_convenience,
struct reg_diff_callbacks **callbacks,
void **callback_data);
WERROR reg_preg_diff_save(TALLOC_CTX *ctx, const char *filename,
- struct smb_iconv_convenience *ic,
struct reg_diff_callbacks **callbacks,
void **callback_data);
WERROR reg_generate_diff_key(struct registry_key *oldkey,
const struct reg_diff_callbacks *callbacks,
void *callback_data);
WERROR reg_diff_load(const char *filename,
- struct smb_iconv_convenience *iconv_convenience,
const struct reg_diff_callbacks *callbacks,
void *callback_data);
WERROR reg_dotreg_diff_load(int fd,
- struct smb_iconv_convenience *iconv_convenience,
const struct reg_diff_callbacks *callbacks,
void *callback_data);
WERROR reg_preg_diff_load(int fd,
- struct smb_iconv_convenience *iconv_convenience,
const struct reg_diff_callbacks *callbacks,
void *callback_data);
static bool test_diff_load(struct torture_context *tctx, void *tcase_data)
{
struct diff_tcase_data *td = tcase_data;
- struct smb_iconv_convenience *ic;
struct reg_diff_callbacks *callbacks;
void *data;
WERROR error;
- ic = lp_iconv_convenience(tctx->lp_ctx);
-
- error = reg_diff_load(td->filename, iconv_convenience, callbacks, data);
+ error = reg_diff_load(td->filename, callbacks, data);
torture_assert_werr_ok(tctx, error, "reg_diff_load");
return true;
struct registry_key *key;
WERROR error;
- error = reg_diff_apply(td->r1_ctx, lp_iconv_convenience(tctx->lp_ctx), td->filename);
+ error = reg_diff_apply(td->r1_ctx, td->filename);
torture_assert_werr_ok(tctx, error, "reg_diff_apply");
error = td->r1_ctx->ops->get_predefined_key(td->r1_ctx, HKEY_LOCAL_MACHINE, &key);
static bool diff_setup_preg_tcase (struct torture_context *tctx, void **data)
{
struct diff_tcase_data *td;
- struct smb_iconv_convenience *ic;
WERROR error;
diff_setup_tcase(tctx, data);
td = *data;
- ic = lp_iconv_convenience(tctx->lp_ctx);
-
td->filename = talloc_asprintf(tctx, "%s/test.pol", td->tempdir);
- error = reg_preg_diff_save(tctx, td->filename, ic, &td->callbacks, &td->callback_data);
+ error = reg_preg_diff_save(tctx, td->filename, &td->callbacks,
+ &td->callback_data);
torture_assert_werr_ok(tctx, error, "reg_preg_diff_save");
return true;
static bool diff_setup_dotreg_tcase (struct torture_context *tctx, void **data)
{
struct diff_tcase_data *td;
- struct smb_iconv_convenience *ic;
WERROR error;
diff_setup_tcase(tctx, data);
td = *data;
- ic = lp_iconv_convenience(tctx->lp_ctx);
-
td->filename = talloc_asprintf(tctx, "%s/test.reg", td->tempdir);
- error = reg_dotreg_diff_save(tctx, td->filename, ic, &td->callbacks, &td->callback_data);
+ error = reg_dotreg_diff_save(tctx, td->filename, &td->callbacks,
+ &td->callback_data);
torture_assert_werr_ok(tctx, error, "reg_dotreg_diff_save");
return true;
uint8_t d[] = { 0x20, 0x00, 0x00, 0x00 };
DATA_BLOB db = { d, 4 };
torture_assert_str_equal(ctx, "0x00000020",
- reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_DWORD, db),
+ reg_val_data_string(ctx, REG_DWORD, db),
"dword failed");
return true;
}
uint8_t d[] = { 0x20, 0x00, 0x00, 0x00 };
DATA_BLOB db = { d, 4 };
torture_assert_str_equal(ctx, "0x00000020",
- reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_DWORD_BIG_ENDIAN, db),
+ reg_val_data_string(ctx, REG_DWORD_BIG_ENDIAN, db),
"dword failed");
return true;
}
uint8_t d[] = { 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
DATA_BLOB db = { d, 8 };
torture_assert_str_equal(ctx, "0x0000000000000020",
- reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_QWORD, db),
+ reg_val_data_string(ctx, REG_QWORD, db),
"qword failed");
return true;
}
static bool test_reg_val_data_string_sz(struct torture_context *ctx)
{
DATA_BLOB db;
- convert_string_talloc_convenience(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
+ convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
"bla", 3, (void **)&db.data, &db.length, false);
torture_assert_str_equal(ctx, "bla",
- reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_SZ, db),
+ reg_val_data_string(ctx, REG_SZ, db),
"sz failed");
db.length = 4;
torture_assert_str_equal(ctx, "bl",
- reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_SZ, db),
+ reg_val_data_string(ctx, REG_SZ, db),
"sz failed");
return true;
}
uint8_t x[] = { 0x1, 0x2, 0x3, 0x4 };
DATA_BLOB db = { x, 4 };
torture_assert_str_equal(ctx, "01020304",
- reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_BINARY, db),
+ reg_val_data_string(ctx, REG_BINARY, db),
"binary failed");
return true;
}
{
DATA_BLOB db = { NULL, 0 };
torture_assert_str_equal(ctx, "",
- reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_BINARY, db),
+ reg_val_data_string(ctx, REG_BINARY, db),
"empty failed");
return true;
}
static bool test_reg_val_description(struct torture_context *ctx)
{
DATA_BLOB data;
- convert_string_talloc_convenience(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
+ convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
"stationary traveller",
strlen("stationary traveller"),
(void **)&data.data, &data.length, false);
torture_assert_str_equal(ctx, "camel = REG_SZ : stationary traveller",
- reg_val_description(ctx, lp_iconv_convenience(ctx->lp_ctx), "camel", REG_SZ, data),
+ reg_val_description(ctx, "camel", REG_SZ, data),
"reg_val_description failed");
return true;
}
static bool test_reg_val_description_nullname(struct torture_context *ctx)
{
DATA_BLOB data;
- convert_string_talloc_convenience(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
+ convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
"west berlin",
strlen("west berlin"),
(void **)&data.data, &data.length, false);
torture_assert_str_equal(ctx, "<No Name> = REG_SZ : west berlin",
- reg_val_description(ctx, lp_iconv_convenience(ctx->lp_ctx), NULL, REG_SZ, data),
+ reg_val_description(ctx, NULL, REG_SZ, data),
"description with null name failed");
return true;
}
rmdir(dirname);
- error = reg_create_regf_file(tctx, lp_iconv_convenience(tctx->lp_ctx),
- dirname, 5, &key);
+ error = reg_create_regf_file(tctx, dirname, 5, &key);
if (!W_ERROR_IS_OK(error)) {
fprintf(stderr, "Unable to create new regf file\n");
return false;
poptFreeContext(pc);
- error = reg_dotreg_diff_save(ctx, outputfile, lp_iconv_convenience(cmdline_lp_ctx), &callbacks,
- &callback_data);
+ error = reg_dotreg_diff_save(ctx, outputfile, &callbacks, &callback_data);
if (!W_ERROR_IS_OK(error)) {
fprintf(stderr, "Problem saving registry diff to '%s': %s\n",
outputfile, win_errstr(error));
poptFreeContext(pc);
- reg_diff_apply(h, lp_iconv_convenience(cmdline_lp_ctx), patch);
+ reg_diff_apply(h, patch);
return 0;
}
return WERR_INVALID_PARAM;
}
- if (!reg_string_to_val(ctx, lp_iconv_convenience(cmdline_lp_ctx),
- argv[2], argv[3], &val.data_type,
- &val.data)) {
+ if (!reg_string_to_val(ctx, argv[2], argv[3], &val.data_type, &val.data)) {
fprintf(stderr, "Unable to interpret data\n");
return WERR_INVALID_PARAM;
}
}
printf("%s\n%s\n", str_regtype(value_type),
- reg_val_data_string(ctx, lp_iconv_convenience(cmdline_lp_ctx), value_type, value_data));
+ reg_val_data_string(ctx, value_type, value_data));
return WERR_OK;
}
for (i = 0; W_ERROR_IS_OK(error = reg_key_get_value_by_index(ctx,
ctx->current, i, &name, &valuetype, &valuedata)); i++)
printf("V \"%s\" %s %s\n", name, str_regtype(valuetype),
- reg_val_data_string(ctx, lp_iconv_convenience(cmdline_lp_ctx), valuetype, valuedata));
+ reg_val_data_string(ctx, valuetype, valuedata));
return WERR_OK;
}
unsigned int j;
for(j = 0; j < level+1; j++) putchar(' ');
printf("%s\n", reg_val_description(mem_ctx,
- lp_iconv_convenience(cmdline_lp_ctx), valuename,
- valuetype, valuedata));
+ valuename, valuetype, valuedata));
}
talloc_free(mem_ctx);
#include "lib/registry/registry.h"
#include "librpc/gen_ndr/winreg.h"
-_PUBLIC_ char *reg_val_data_string(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
- uint32_t type,
+_PUBLIC_ char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type,
const DATA_BLOB data)
{
char *ret = NULL;
switch (type) {
case REG_EXPAND_SZ:
case REG_SZ:
- convert_string_talloc_convenience(mem_ctx,
- iconv_convenience,
- CH_UTF16, CH_UNIX,
- data.data,
- data.length,
- (void **)&ret,
- NULL, false);
+ convert_string_talloc(mem_ctx,
+ CH_UTF16, CH_UNIX, data.data, data.length,
+ (void **)&ret, NULL, false);
break;
case REG_DWORD:
case REG_DWORD_BIG_ENDIAN:
/** Generate a string that describes a registry value */
_PUBLIC_ char *reg_val_description(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
const char *name,
uint32_t data_type,
const DATA_BLOB data)
{
return talloc_asprintf(mem_ctx, "%s = %s : %s", name?name:"<No Name>",
str_regtype(data_type),
- reg_val_data_string(mem_ctx, iconv_convenience, data_type, data));
+ reg_val_data_string(mem_ctx, data_type, data));
}
-_PUBLIC_ bool reg_string_to_val(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
- const char *type_str,
- const char *data_str, uint32_t *type,
- DATA_BLOB *data)
+_PUBLIC_ bool reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str,
+ const char *data_str, uint32_t *type, DATA_BLOB *data)
{
*type = regtype_by_string(type_str);
switch (*type) {
case REG_SZ:
case REG_EXPAND_SZ:
- return convert_string_talloc_convenience(mem_ctx,
- iconv_convenience,
- CH_UNIX, CH_UTF16,
- data_str,
+ return convert_string_talloc(mem_ctx,
+ CH_UNIX, CH_UTF16, data_str,
strlen(data_str)+1,
(void **)&data->data,
&data->length, false);
struct tevent_context *ev_ctx,
struct resolve_context *resolve_ctx,
struct smbcli_options *options,
- struct smb_iconv_convenience *iconv_convenience,
const char *socket_options)
{
struct smbcli_socket *sock;
if (sock == NULL) return false;
- cli->transport = smbcli_transport_init(sock, cli, true, options,
- iconv_convenience);
+ cli->transport = smbcli_transport_init(sock, cli, true, options);
if (!cli->transport) {
return false;
}
struct tevent_context *ev,
struct smbcli_options *options,
struct smbcli_session_options *session_options,
- struct smb_iconv_convenience *iconv_convenience,
struct gensec_settings *gensec_settings)
{
struct smbcli_tree *tree;
credentials, resolve_ctx, ev,
options,
session_options,
- iconv_convenience,
gensec_settings);
if (!NT_STATUS_IS_OK(status)) {
goto done;
DATA_BLOB blob;
TALLOC_CTX *tmp_ctx = talloc_new(dgmsock);
- ndr_err = ndr_push_struct_blob(&blob, tmp_ctx, dgmsock->iconv_convenience, request,
+ ndr_err = ndr_push_struct_blob(&blob, tmp_ctx, request,
(ndr_push_flags_fn_t)ndr_push_nbt_browse_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(tmp_ctx);
struct nbt_name myname;
struct socket_address *dest;
- ndr_err = ndr_push_struct_blob(&blob, tmp_ctx, dgmsock->iconv_convenience, reply,
+ ndr_err = ndr_push_struct_blob(&blob, tmp_ctx, reply,
(ndr_push_flags_fn_t)ndr_push_nbt_browse_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(tmp_ctx);
DATA_BLOB data = dgram_mailslot_data(dgram);
enum ndr_err_code ndr_err;
- ndr_err = ndr_pull_struct_blob(&data, mem_ctx, dgmslot->dgmsock->iconv_convenience, pkt,
+ ndr_err = ndr_pull_struct_blob(&data, mem_ctx, pkt,
(ndr_pull_flags_fn_t)ndr_pull_nbt_browse_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
}
/* parse the request */
- ndr_err = ndr_pull_struct_blob(&blob, packet, dgmsock->iconv_convenience, packet,
+ ndr_err = ndr_pull_struct_blob(&blob, packet, packet,
(ndr_pull_flags_fn_t)ndr_pull_nbt_dgram_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
then operations will use that event context
*/
struct nbt_dgram_socket *nbt_dgram_socket_init(TALLOC_CTX *mem_ctx,
- struct tevent_context *event_ctx,
- struct smb_iconv_convenience *iconv_convenience)
+ struct tevent_context *event_ctx)
{
struct nbt_dgram_socket *dgmsock;
NTSTATUS status;
dgmsock->send_queue = NULL;
dgmsock->incoming.handler = NULL;
dgmsock->mailslot_handlers = NULL;
- dgmsock->iconv_convenience = iconv_convenience;
return dgmsock;
req->dest = dest;
if (talloc_reference(req, dest) == NULL) goto failed;
- ndr_err = ndr_push_struct_blob(&req->encoded, req, dgmsock->iconv_convenience, packet,
+ ndr_err = ndr_push_struct_blob(&req->encoded, req, packet,
(ndr_push_flags_fn_t)ndr_push_nbt_dgram_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
struct socket_address *),
void *private_data);
struct nbt_dgram_socket *nbt_dgram_socket_init(TALLOC_CTX *mem_ctx,
- struct tevent_context *event_ctx,
- struct smb_iconv_convenience *);
+ struct tevent_context *event_ctx);
const char *dgram_mailslot_name(struct nbt_dgram_packet *packet);
struct dgram_mailslot_handler *dgram_mailslot_find(struct nbt_dgram_socket *dgmsock,
DATA_BLOB blob;
TALLOC_CTX *tmp_ctx = talloc_new(dgmsock);
- ndr_err = ndr_push_struct_blob(&blob, tmp_ctx,
- dgmsock->iconv_convenience,
- request,
+ ndr_err = ndr_push_struct_blob(&blob, tmp_ctx, request,
(ndr_push_flags_fn_t)ndr_push_nbt_netlogon_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(tmp_ctx);
struct nbt_name myname;
struct socket_address *dest;
- status = push_nbt_netlogon_response(&blob, tmp_ctx, dgmsock->iconv_convenience,
- reply);
+ status = push_nbt_netlogon_response(&blob, tmp_ctx, reply);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
DATA_BLOB data = dgram_mailslot_data(dgram);
enum ndr_err_code ndr_err;
- ndr_err = ndr_pull_struct_blob(&data, mem_ctx, dgmslot->dgmsock->iconv_convenience, netlogon,
- (ndr_pull_flags_fn_t)ndr_pull_nbt_netlogon_packet);
+ ndr_err = ndr_pull_struct_blob(&data, mem_ctx, netlogon,
+ (ndr_pull_flags_fn_t)ndr_pull_nbt_netlogon_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
DEBUG(0,("Failed to parse netlogon packet of length %d: %s\n",
NTSTATUS status;
DATA_BLOB data = dgram_mailslot_data(dgram);
- status = pull_nbt_netlogon_response(&data, mem_ctx, dgmslot->dgmsock->iconv_convenience, netlogon);
+ status = pull_nbt_netlogon_response(&data, mem_ctx, netlogon);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
struct nbtd_getdcname r;
struct nbt_name_status node_status;
- struct smb_iconv_convenience *iconv_convenience;
-
int num_dcs;
struct nbt_dc_name *dcs;
uint16_t nbt_port;
const char *domain_name,
int name_type,
struct dom_sid *domain_sid,
- struct smb_iconv_convenience *iconv_convenience,
struct resolve_context *resolve_ctx,
struct tevent_context *event_ctx,
struct messaging_context *msg_ctx)
state->nbt_port = nbt_port;
state->my_netbios_name = talloc_strdup(state, my_netbios_name);
state->domain_name = talloc_strdup(state, domain_name);
- state->iconv_convenience = iconv_convenience;
if (composite_nomem(state->domain_name, c)) return c;
if (domain_sid) {
state->node_status.in.timeout = 1;
state->node_status.in.retries = 2;
- nbtsock = nbt_name_socket_init(state, state->ctx->event_ctx,
- state->iconv_convenience);
+ nbtsock = nbt_name_socket_init(state, state->ctx->event_ctx);
if (composite_nomem(nbtsock, state->ctx)) return;
name_req = nbt_name_status_send(nbtsock, &state->node_status);
uint16_t nbt_port,
const char *domain_name, int name_type,
struct dom_sid *domain_sid,
- struct smb_iconv_convenience *iconv_convenience,
struct resolve_context *resolve_ctx,
struct tevent_context *event_ctx,
struct messaging_context *msg_ctx,
nbt_port,
domain_name, name_type,
domain_sid,
- iconv_convenience,
resolve_ctx,
event_ctx, msg_ctx);
return finddcs_recv(c, mem_ctx, num_dcs, dcs);
struct smbcli_transport *smbcli_transport_init(struct smbcli_socket *sock,
TALLOC_CTX *parent_ctx,
bool primary,
- struct smbcli_options *options,
- struct smb_iconv_convenience *iconv_convenience)
+ struct smbcli_options *options)
{
struct smbcli_transport *transport;
transport->negotiate.protocol = PROTOCOL_NT1;
transport->options = *options;
transport->negotiate.max_xmit = transport->options.max_xmit;
- transport->iconv_convenience = iconv_convenience;
/* setup the stream -> packet parser */
transport->packet = packet_init(transport);
status = nbt_name_dup(transport, called, &transport->called);
if (!NT_STATUS_IS_OK(status)) goto failed;
- status = nbt_name_to_blob(tmp_ctx, transport->iconv_convenience, &calling_blob, calling);
+ status = nbt_name_to_blob(tmp_ctx, &calling_blob, calling);
if (!NT_STATUS_IS_OK(status)) goto failed;
- status = nbt_name_to_blob(tmp_ctx, transport->iconv_convenience, &called_blob, called);
+ status = nbt_name_to_blob(tmp_ctx, &called_blob, called);
if (!NT_STATUS_IS_OK(status)) goto failed;
/* allocate output buffer */
struct tevent_context *ev,
struct smbcli_options *options,
struct smbcli_session_options *session_options,
- struct smb_iconv_convenience *iconv_convenience,
struct gensec_settings *gensec_settings)
{
struct smb_composite_connect io;
io.in.workgroup = "";
io.in.options = *options;
io.in.session_options = *session_options;
- io.in.iconv_convenience = iconv_convenience;
status = smb_composite_connect(&io, parent_ctx, resolve_ctx, ev);
if (NT_STATUS_IS_OK(status)) {
nt.out.data.length = IVAL(nt.out.params.data, 0);
- ndr = ndr_pull_init_blob(&nt.out.data, mem_ctx, NULL);
+ ndr = ndr_pull_init_blob(&nt.out.data, mem_ctx);
if (!ndr) {
return NT_STATUS_INVALID_PARAMETER;
}
nt.in.params.data = params;
nt.in.params.length = 8;
- ndr = ndr_push_init_ctx(NULL, NULL);
+ ndr = ndr_push_init_ctx(NULL);
if (!ndr) return NULL;
ndr_err = ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, io->set_secdesc.in.sd);
if (parms->ntcreatex.in.sec_desc) {
enum ndr_err_code ndr_err;
- ndr_err = ndr_push_struct_blob(&sd_blob, mem_ctx, NULL,
+ ndr_err = ndr_push_struct_blob(&sd_blob, mem_ctx,
parms->ntcreatex.in.sec_desc,
(ndr_push_flags_fn_t)ndr_push_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
parms->query_secdesc.out.sd = talloc(mem_ctx, struct security_descriptor);
NT_STATUS_HAVE_NO_MEMORY(parms->query_secdesc.out.sd);
- ndr_err = ndr_pull_struct_blob(blob, mem_ctx, NULL,
- parms->query_secdesc.out.sd,
- (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
+ ndr_err = ndr_pull_struct_blob(blob, mem_ctx,
+ parms->query_secdesc.out.sd,
+ (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return ndr_map_error2ntstatus(ndr_err);
}
case RAW_FILEINFO_SEC_DESC: {
enum ndr_err_code ndr_err;
- ndr_err = ndr_push_struct_blob(blob, mem_ctx, NULL,
- parms->set_secdesc.in.sd,
+ ndr_err = ndr_push_struct_blob(blob, mem_ctx, parms->set_secdesc.in.sd,
(ndr_push_flags_fn_t)ndr_push_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return false;
return c;
}
- state->nbtsock = nbt_name_socket_init(state, event_ctx,
- global_iconv_convenience);
+ state->nbtsock = nbt_name_socket_init(state, event_ctx);
if (composite_nomem(state->nbtsock, c)) return c;
/* count the address_list size */
if (io->in.sec_desc) {
enum ndr_err_code ndr_err;
DATA_BLOB sd_blob;
- ndr_err = ndr_push_struct_blob(&sd_blob, req, NULL,
- io->in.sec_desc,
+ ndr_err = ndr_push_struct_blob(&sd_blob, req, io->in.sec_desc,
(ndr_push_flags_fn_t)ndr_push_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(req);
/* the socket is up - we can initialise the smbcli transport layer */
state->transport = smbcli_transport_init(state->sock, state, true,
- &io->in.options, io->in.iconv_convenience);
+ &io->in.options);
NT_STATUS_HAVE_NO_MEMORY(state->transport);
if (is_ipaddress(state->sock->hostname) &&
}
lsa->ipc_tree->tid = tcon.tconx.out.tid;
- lsa->pipe = dcerpc_pipe_init(lsa, cli->transport->socket->event.ctx,
- cli->transport->iconv_convenience);
+ lsa->pipe = dcerpc_pipe_init(lsa, cli->transport->socket->event.ctx);
if (lsa->pipe == NULL) {
talloc_free(lsa);
return NT_STATUS_NO_MEMORY;
#define WREPL_SOCKET_REQUEST_TIMEOUT (60)
uint32_t request_timeout;
- struct smb_iconv_convenience *iconv_convenience;
-
struct tevent_queue *request_queue;
struct tstream_context *stream;
operations will use that event context
*/
struct wrepl_socket *wrepl_socket_init(TALLOC_CTX *mem_ctx,
- struct tevent_context *event_ctx,
- struct smb_iconv_convenience *iconv_convenience)
+ struct tevent_context *event_ctx)
{
struct wrepl_socket *wrepl_socket;
goto failed;
}
- wrepl_socket->iconv_convenience = iconv_convenience;
-
wrepl_socket->request_timeout = WREPL_SOCKET_REQUEST_TIMEOUT;
return wrepl_socket;
state->req.wrap.packet = *packet;
ndr_err = ndr_push_struct_blob(&state->req.blob, state,
- wrepl_socket->iconv_convenience,
&state->req.wrap,
(ndr_push_flags_fn_t)ndr_push_wrepl_wrap);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
/* we have a full request - parse it */
ndr_err = ndr_pull_struct_blob(&blob,
state->rep.packet,
- state->caller.wrepl_socket->iconv_convenience,
state->rep.packet,
(ndr_pull_flags_fn_t)ndr_pull_wrepl_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
struct libnet_BecomeDC_state);
struct composite_context *c = s->creq;
- c->status = cldap_netlogon_recv(req,
- lp_iconv_convenience(s->libnet->lp_ctx),
- s, &s->cldap.io);
+ c->status = cldap_netlogon_recv(req, s, &s->cldap.io);
talloc_free(req);
if (!composite_is_ok(c)) {
DEBUG(0,("Failed to send, receive or parse CLDAP reply from server %s for our host %s: %s\n",
struct drsuapi_DsReplicaObjectIdentifier *identifier;
uint32_t num_attrs, i = 0;
struct drsuapi_DsReplicaAttribute *attrs;
- struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(s->libnet->lp_ctx);
enum ndr_err_code ndr_err;
bool w2k3;
struct tevent_req *subreq;
NULL);
if (composite_nomem(v, c)) return;
- ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, v,(ndr_push_flags_fn_t)ndr_push_security_descriptor);
+ ndr_err = ndr_push_struct_blob(&vd[0], vd, v,
+ (ndr_push_flags_fn_t)ndr_push_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
c->status = ndr_map_error2ntstatus(ndr_err);
if (!composite_is_ok(c)) return;
}
if (composite_nomem(v[0].dn, c)) return;
- ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
- (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+ ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
+ (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
c->status = ndr_map_error2ntstatus(ndr_err);
if (!composite_is_ok(c)) return;
v[2].sid = s->zero_sid;
v[2].dn = s->forest.schema_dn_str;
- ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
- (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+ ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
+ (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
c->status = ndr_map_error2ntstatus(ndr_err);
if (!composite_is_ok(c)) return;
}
- ndr_err = ndr_push_struct_blob(&vd[1], vd, iconv_convenience, &v[1],
- (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+ ndr_err = ndr_push_struct_blob(&vd[1], vd, &v[1],
+ (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
c->status = ndr_map_error2ntstatus(ndr_err);
if (!composite_is_ok(c)) return;
}
- ndr_err = ndr_push_struct_blob(&vd[2], vd, iconv_convenience, &v[2],
- (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+ ndr_err = ndr_push_struct_blob(&vd[2], vd, &v[2],
+ (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
c->status = ndr_map_error2ntstatus(ndr_err);
if (!composite_is_ok(c)) return;
v[2].sid = s->zero_sid;
v[2].dn = s->forest.schema_dn_str;
- ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
- (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+ ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
+ (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
c->status = ndr_map_error2ntstatus(ndr_err);
if (!composite_is_ok(c)) return;
}
- ndr_err = ndr_push_struct_blob(&vd[1], vd, iconv_convenience, &v[1],
- (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+ ndr_err = ndr_push_struct_blob(&vd[1], vd, &v[1],
+ (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
c->status = ndr_map_error2ntstatus(ndr_err);
if (!composite_is_ok(c)) return;
}
- ndr_err = ndr_push_struct_blob(&vd[2], vd, iconv_convenience, &v[2],
- (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+ ndr_err = ndr_push_struct_blob(&vd[2], vd, &v[2],
+ (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
c->status = ndr_map_error2ntstatus(ndr_err);
if (!composite_is_ok(c)) return;
v[0].sid = s->zero_sid;
v[0].dn = s->forest.schema_dn_str;
- ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
- (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+ ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
+ (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
c->status = ndr_map_error2ntstatus(ndr_err);
if (!composite_is_ok(c)) return;
v[0].sid = s->zero_sid;
v[0].dn = s->domain.dn_str;
- ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
- (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+ ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
+ (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
c->status = ndr_map_error2ntstatus(ndr_err);
if (!composite_is_ok(c)) return;
v[0].sid = s->zero_sid;
v[0].dn = s->dest_dsa.computer_dn_str;
- ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
- (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+ ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
+ (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
c->status = ndr_map_error2ntstatus(ndr_err);
if (!composite_is_ok(c)) return;
{
struct composite_context *c;
struct messaging_context *msg_ctx =
- messaging_client_init(mem_ctx, lp_messaging_path(mem_ctx, ctx->lp_ctx),
- lp_iconv_convenience(ctx->lp_ctx), ctx->event_ctx);
-
- c = finddcs_send(mem_ctx, lp_netbios_name(ctx->lp_ctx), lp_nbt_port(ctx->lp_ctx),
- io->in.domain_name, io->in.name_type,
- NULL, lp_iconv_convenience(ctx->lp_ctx),
- ctx->resolve_ctx, ctx->event_ctx, msg_ctx);
+ messaging_client_init(mem_ctx,
+ lp_messaging_path(mem_ctx, ctx->lp_ctx),
+ ctx->event_ctx);
+
+ c = finddcs_send(mem_ctx, lp_netbios_name(ctx->lp_ctx),
+ lp_nbt_port(ctx->lp_ctx), io->in.domain_name,
+ io->in.name_type, NULL, ctx->resolve_ctx,
+ ctx->event_ctx, msg_ctx);
return c;
}
r->out.error_string = NULL;
return status;
}
- status = cldap_netlogon(cldap, lp_iconv_convenience(lctx->lp_ctx), tmp_ctx, &search);
+ status = cldap_netlogon(cldap, tmp_ctx, &search);
if (!NT_STATUS_IS_OK(status)
|| !search.out.netlogon.data.nt5_ex.client_site) {
/*
struct libnet_UnbecomeDC_state);
struct composite_context *c = s->creq;
- c->status = cldap_netlogon_recv(req,
- lp_iconv_convenience(s->libnet->lp_ctx),
- s, &s->cldap.io);
+ c->status = cldap_netlogon_recv(req, s, &s->cldap.io);
talloc_free(req);
if (!composite_is_ok(c)) return;
}
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);
} wrepl_packet;
typedef [flag(NDR_BIG_ENDIAN|NDR_PAHEX),public] struct {
- [value(ndr_size_wrepl_packet(&packet, ndr->iconv_convenience, ndr->flags))] uint32 size;
+ [value(ndr_size_wrepl_packet(&packet, ndr->flags))] uint32 size;
wrepl_packet packet;
} wrepl_wrap;
if (len2 == 0) {
as = talloc_strdup(ndr->current_mem_ctx, "");
} else {
- if (!convert_string_talloc_convenience(ndr->current_mem_ctx,
- ndr->iconv_convenience, chset, CH_UNIX,
+ if (!convert_string_talloc(ndr->current_mem_ctx,
+ chset, CH_UNIX,
ndr->data+ndr->offset,
(len2 + c_len_term)*byte_mul,
(void **)&as, &ret, false)) {
if (len1 == 0) {
as = talloc_strdup(ndr->current_mem_ctx, "");
} else {
- if (!convert_string_talloc_convenience(ndr->current_mem_ctx,
- ndr->iconv_convenience,
+ if (!convert_string_talloc(ndr->current_mem_ctx,
chset, CH_UNIX,
ndr->data+ndr->offset,
(len1 + c_len_term)*byte_mul,
if (len1 == 0) {
as = talloc_strdup(ndr->current_mem_ctx, "");
} else {
- if (!convert_string_talloc_convenience(ndr->current_mem_ctx,
- ndr->iconv_convenience,
+ if (!convert_string_talloc(ndr->current_mem_ctx,
chset, CH_UNIX,
ndr->data+ndr->offset,
(len1 + c_len_term)*byte_mul,
if (len3 == 0) {
as = talloc_strdup(ndr->current_mem_ctx, "");
} else {
- if (!convert_string_talloc_convenience(ndr->current_mem_ctx,
- ndr->iconv_convenience,
+ if (!convert_string_talloc(ndr->current_mem_ctx,
chset, CH_UNIX,
ndr->data+ndr->offset,
(len3 + c_len_term)*byte_mul,
if (len3 == 0) {
as = talloc_strdup(ndr->current_mem_ctx, "");
} else {
- if (!convert_string_talloc_convenience(ndr->current_mem_ctx,
- ndr->iconv_convenience,
+ if (!convert_string_talloc(ndr->current_mem_ctx,
chset, CH_UNIX,
ndr->data+ndr->offset,
len3,
} else {
len1 = utf16_len_n(ndr->data+ndr->offset, ndr->data_size - ndr->offset);
}
- if (!convert_string_talloc_convenience(ndr->current_mem_ctx,
- ndr->iconv_convenience, chset, CH_UNIX,
+ if (!convert_string_talloc(ndr->current_mem_ctx,
+ chset, CH_UNIX,
ndr->data+ndr->offset,
len1,
(void **)&as, &ret, false)) {
if (len1 == 0) {
as = talloc_strdup(ndr->current_mem_ctx, "");
} else {
- if (!convert_string_talloc_convenience(ndr->current_mem_ctx,
- ndr->iconv_convenience,
+ if (!convert_string_talloc(ndr->current_mem_ctx,
chset, CH_UNIX,
ndr->data+ndr->offset,
len1,
if (!(flags & LIBNDR_FLAG_STR_NOTERM)) {
s_len++;
}
- if (!convert_string_talloc_convenience(ndr, ndr->iconv_convenience, CH_UNIX, chset, s, s_len, (void **)&dest, &d_len, false)) {
+ if (!convert_string_talloc(ndr, CH_UNIX, chset, s, s_len, (void **)&dest, &d_len, false)) {
return ndr_push_error(ndr, NDR_ERR_CHARCNV,
"Bad character push conversion with flags 0x%x", flags);
}
NDR_PULL_NEED_BYTES(ndr, length*byte_mul);
- if (!convert_string_talloc_convenience(ndr->current_mem_ctx,
- ndr->iconv_convenience,
+ if (!convert_string_talloc(ndr->current_mem_ctx,
chset, CH_UNIX,
ndr->data+ndr->offset,
length*byte_mul,
required = byte_mul * length;
NDR_PUSH_NEED_BYTES(ndr, required);
- if (!convert_string_convenience(ndr->iconv_convenience, CH_UNIX, chset,
- var, strlen(var),
- ndr->data+ndr->offset, required, &ret, false)) {
+ ret = convert_string(CH_UNIX, chset, var, strlen(var),
+ ndr->data+ndr->offset, required, false);
+ if (ret == -1) {
return ndr_push_error(ndr, NDR_ERR_CHARCNV,
"Bad character conversion");
}
the event context is optional
*/
static struct dcerpc_connection *dcerpc_connection_init(TALLOC_CTX *mem_ctx,
- struct tevent_context *ev,
- struct smb_iconv_convenience *ic)
+ struct tevent_context *ev)
{
struct dcerpc_connection *c;
return NULL;
}
- c->iconv_convenience = talloc_reference(c, ic);
-
c->event_ctx = ev;
if (c->event_ctx == NULL) {
}
/* initialise a dcerpc pipe. */
-_PUBLIC_ struct dcerpc_pipe *dcerpc_pipe_init(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
- struct smb_iconv_convenience *ic)
+_PUBLIC_ struct dcerpc_pipe *dcerpc_pipe_init(TALLOC_CTX *mem_ctx, struct tevent_context *ev)
{
struct dcerpc_pipe *p;
return NULL;
}
- p->conn = dcerpc_connection_init(p, ev, ic);
+ p->conn = dcerpc_connection_init(p, ev);
if (p->conn == NULL) {
talloc_free(p);
return NULL;
static struct ndr_pull *ndr_pull_init_flags(struct dcerpc_connection *c,
DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
{
- struct ndr_pull *ndr = ndr_pull_init_blob(blob, mem_ctx, c->iconv_convenience);
+ struct ndr_pull *ndr = ndr_pull_init_blob(blob, mem_ctx);
if (ndr == NULL) return ndr;
/* non-signed packets are simpler */
if (sig_size == 0) {
- return ncacn_push_auth(blob, mem_ctx, c->iconv_convenience, pkt, NULL);
+ return ncacn_push_auth(blob, mem_ctx, pkt, NULL);
}
switch (c->security_state.auth_info->auth_level) {
case DCERPC_AUTH_LEVEL_CONNECT:
/* TODO: let the gensec mech decide if it wants to generate a signature */
- return ncacn_push_auth(blob, mem_ctx, c->iconv_convenience, pkt, NULL);
+ return ncacn_push_auth(blob, mem_ctx, pkt, NULL);
case DCERPC_AUTH_LEVEL_NONE:
- return ncacn_push_auth(blob, mem_ctx, c->iconv_convenience, pkt, NULL);
+ return ncacn_push_auth(blob, mem_ctx, pkt, NULL);
default:
return NT_STATUS_INVALID_LEVEL;
}
- ndr = ndr_push_init_ctx(mem_ctx, c->iconv_convenience);
+ ndr = ndr_push_init_ctx(mem_ctx);
if (!ndr) {
return NT_STATUS_NO_MEMORY;
}
pkt.u.bind.auth_info = data_blob(NULL, 0);
/* construct the NDR form of the packet */
- c->status = ncacn_push_auth(&blob, c, p->conn->iconv_convenience, &pkt,
+ c->status = ncacn_push_auth(&blob, c, &pkt,
p->conn->security_state.auth_info);
if (!composite_is_ok(c)) return c;
/* construct the NDR form of the packet */
status = ncacn_push_auth(&blob, mem_ctx,
- p->conn->iconv_convenience,
&pkt,
p->conn->security_state.auth_info);
if (!NT_STATUS_IS_OK(status)) {
if (req->object) {
pkt.u.request.object.object = *req->object;
pkt.pfc_flags |= DCERPC_PFC_FLAG_OBJECT_UUID;
- chunk_size -= ndr_size_GUID(req->object,NULL,0);
+ chunk_size -= ndr_size_GUID(req->object,0);
}
/* we send a series of pdus without waiting for a reply */
return ndr_map_error2ntstatus(ndr_err);
}
- push = ndr_push_init_ctx(mem_ctx, c->iconv_convenience);
+ push = ndr_push_init_ctx(mem_ctx);
if (!push) {
return NT_STATUS_NO_MEMORY;
}
}
memcpy(st, struct_ptr, struct_size);
- push = ndr_push_init_ctx(mem_ctx, c->iconv_convenience);
+ push = ndr_push_init_ctx(mem_ctx);
if (!push) {
return NT_STATUS_NO_MEMORY;
}
return ndr_map_error2ntstatus(ndr_err);
}
- push = ndr_push_init_ctx(mem_ctx, c->iconv_convenience);
+ push = ndr_push_init_ctx(mem_ctx);
if (!push) {
return NT_STATUS_NO_MEMORY;
}
call = &table->calls[opnum];
/* setup for a ndr_push_* call */
- push = ndr_push_init_ctx(mem_ctx, p->conn->iconv_convenience);
+ push = ndr_push_init_ctx(mem_ctx);
if (!push) {
return NULL;
}
pkt.u.alter.auth_info = data_blob(NULL, 0);
/* construct the NDR form of the packet */
- c->status = ncacn_push_auth(&blob, mem_ctx, p->conn->iconv_convenience, &pkt,
+ c->status = ncacn_push_auth(&blob, mem_ctx, &pkt,
p->conn->security_state.auth_info);
if (!composite_is_ok(c)) return c;
struct dcerpc_security security_state;
const char *binding_string;
struct tevent_context *event_ctx;
- struct smb_iconv_convenience *iconv_convenience;
/** Directory in which to save ndrdump-parseable files */
const char *packet_log_dir;
TALLOC_CTX *mem_ctx,
void *r);
const char *dcerpc_server_name(struct dcerpc_pipe *p);
-struct dcerpc_pipe *dcerpc_pipe_init(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
- struct smb_iconv_convenience *ic);
+struct dcerpc_pipe *dcerpc_pipe_init(TALLOC_CTX *mem_ctx, struct tevent_context *ev);
NTSTATUS dcerpc_pipe_open_smb(struct dcerpc_pipe *p,
struct smbcli_tree *tree,
const char *pipe_name);
conn->in.service_type = NULL;
conn->in.workgroup = lp_workgroup(lp_ctx);
conn->in.gensec_settings = lp_gensec_settings(conn, lp_ctx);
- conn->in.iconv_convenience = lp_iconv_convenience(lp_ctx);
lp_smbcli_options(lp_ctx, &conn->in.options);
lp_smbcli_session_options(lp_ctx, &conn->in.session_options);
c->private_data = s;
/* initialise dcerpc pipe structure */
- s->pipe = dcerpc_pipe_init(c, ev, lp_iconv_convenience(lp_ctx));
+ s->pipe = dcerpc_pipe_init(c, ev);
if (composite_nomem(s->pipe, c)) return c;
if (DEBUGLEVEL >= 10)
s->binding = b;
/* initialise second dcerpc pipe based on primary pipe's event context */
- s->pipe2 = dcerpc_pipe_init(c, s->pipe->conn->event_ctx, s->pipe->conn->iconv_convenience);
+ s->pipe2 = dcerpc_pipe_init(c, s->pipe->conn->event_ctx);
if (composite_nomem(s->pipe2, c)) return c;
if (DEBUGLEVEL >= 10)
push a ncacn_packet into a blob, potentially with auth info
*/
NTSTATUS ncacn_push_auth(DATA_BLOB *blob, TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
struct ncacn_packet *pkt,
struct dcerpc_auth *auth_info)
{
struct ndr_push *ndr;
enum ndr_err_code ndr_err;
- ndr = ndr_push_init_ctx(mem_ctx, iconv_convenience);
+ ndr = ndr_push_init_ctx(mem_ctx);
if (!ndr) {
return NT_STATUS_NO_MEMORY;
}
*auth_length = pkt_auth_blob->length - pad;
- ndr = ndr_pull_init_blob(pkt_auth_blob, mem_ctx, NULL);
+ ndr = ndr_pull_init_blob(pkt_auth_blob, mem_ctx);
if (!ndr) {
return NT_STATUS_NO_MEMORY;
}
if (strcmp("0.0.0.0", iface->netmask) != 0) {
/* listen for broadcasts on port 138 */
- bcast_dgmsock = nbt_dgram_socket_init(iface,
- nbtsrv->task->event_ctx,
- lp_iconv_convenience(nbtsrv->task->lp_ctx));
+ bcast_dgmsock = nbt_dgram_socket_init(iface, nbtsrv->task->event_ctx);
if (!bcast_dgmsock) {
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
}
/* listen for unicasts on port 138 */
- iface->dgmsock = nbt_dgram_socket_init(iface, nbtsrv->task->event_ctx,
- lp_iconv_convenience(nbtsrv->task->lp_ctx));
+ iface->dgmsock = nbt_dgram_socket_init(iface, nbtsrv->task->event_ctx);
if (!iface->dgmsock) {
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
struct nbt_name_socket *bcast_nbtsock;
/* listen for broadcasts on port 137 */
- bcast_nbtsock = nbt_name_socket_init(iface, nbtsrv->task->event_ctx, lp_iconv_convenience(nbtsrv->task->lp_ctx));
+ bcast_nbtsock = nbt_name_socket_init(iface, nbtsrv->task->event_ctx);
if (!bcast_nbtsock) {
talloc_free(iface);
return NT_STATUS_NO_MEMORY;
}
/* listen for unicasts on port 137 */
- iface->nbtsock = nbt_name_socket_init(iface, nbtsrv->task->event_ctx,
- lp_iconv_convenience(nbtsrv->task->lp_ctx));
+ iface->nbtsock = nbt_name_socket_init(iface, nbtsrv->task->event_ctx);
if (!iface->nbtsock) {
talloc_free(iface);
return NT_STATUS_NO_MEMORY;
signed_reply.packet_id = packet_id;
signed_reply.signed_packet = data_blob(NULL, 0);
- ndr_err = ndr_push_struct_blob(output, mem_ctx,
- lp_iconv_convenience(ntp_signdconn->ntp_signd->task->lp_ctx),
- &signed_reply,
+ ndr_err = ndr_push_struct_blob(output, mem_ctx, &signed_reply,
(ndr_push_flags_fn_t)ndr_push_signed_reply);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
int ret;
ndr_err = ndr_pull_struct_blob_all(input, mem_ctx,
- lp_iconv_convenience(ntp_signd_conn->ntp_signd->task->lp_ctx),
&sign_request,
(ndr_pull_flags_fn_t)ndr_pull_sign_request);
/* Place it into the packet for the wire */
- ndr_err = ndr_push_struct_blob(output, mem_ctx,
- lp_iconv_convenience(ntp_signd_conn->ntp_signd->task->lp_ctx),
- &signed_reply,
+ ndr_err = ndr_push_struct_blob(output, mem_ctx, &signed_reply,
(ndr_push_flags_fn_t)ndr_push_signed_reply);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
os.build = server_info->version_build;
os.extra_string = "";
- ndr_err = ndr_push_struct_blob(&blob, mem_ctx, lp_iconv_convenience(server->ntptr->lp_ctx), &os, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
+ ndr_err = ndr_push_struct_blob(&blob, mem_ctx, &os, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return WERR_GENERAL_FAILURE;
}
os_ex.product_type = 0;
os_ex.reserved = 0;
- ndr_err = ndr_push_struct_blob(&blob, mem_ctx, lp_iconv_convenience(server->ntptr->lp_ctx), &os_ex, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx);
+ ndr_err = ndr_push_struct_blob(&blob, mem_ctx, &os_ex, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return WERR_GENERAL_FAILURE;
}
return result;
}
- ndr_err = ndr_push_union_blob(&blob, mem_ctx, lp_iconv_convenience(server->ntptr->lp_ctx),
+ ndr_err = ndr_push_union_blob(&blob, mem_ctx,
&data, *r->out.type, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return WERR_GENERAL_FAILURE;
struct notify_array *array;
int seqnum;
struct sys_notify_context *sys_notify_ctx;
- struct smb_iconv_convenience *iconv_convenience;
};
notify->messaging_ctx = messaging_ctx;
notify->list = NULL;
notify->array = NULL;
- notify->iconv_convenience = lp_iconv_convenience(lp_ctx);
notify->seqnum = tdb_get_seqnum(notify->w->tdb);
talloc_set_destructor(notify, notify_destructor);
blob.data = dbuf.dptr;
blob.length = dbuf.dsize;
- ndr_err = ndr_pull_struct_blob(&blob, notify->array, notify->iconv_convenience,
- notify->array,
+ ndr_err = ndr_pull_struct_blob(&blob, notify->array, notify->array,
(ndr_pull_flags_fn_t)ndr_pull_notify_array);
free(dbuf.dptr);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
tmp_ctx = talloc_new(notify);
NT_STATUS_HAVE_NO_MEMORY(tmp_ctx);
- ndr_err = ndr_push_struct_blob(&blob, tmp_ctx, notify->iconv_convenience, notify->array,
+ ndr_err = ndr_push_struct_blob(&blob, tmp_ctx, notify->array,
(ndr_push_flags_fn_t)ndr_push_notify_array);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(tmp_ctx);
return;
}
- ndr_err = ndr_pull_struct_blob(data, tmp_ctx, notify->iconv_convenience, &ev,
+ ndr_err = ndr_pull_struct_blob(data, tmp_ctx, &ev,
(ndr_pull_flags_fn_t)ndr_pull_notify_event);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(tmp_ctx);
tmp_ctx = talloc_new(notify);
- ndr_err = ndr_push_struct_blob(&data, tmp_ctx, notify->iconv_convenience, &ev, (ndr_push_flags_fn_t)ndr_push_notify_event);
+ ndr_err = ndr_push_struct_blob(&data, tmp_ctx, &ev, (ndr_push_flags_fn_t)ndr_push_notify_event);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(tmp_ctx);
return;
blob.data = dbuf.dptr;
blob.length = dbuf.dsize;
- ndr_err = ndr_pull_struct_blob(&blob, lck, lp_iconv_convenience(lck->odb->ntvfs_ctx->lp_ctx), file, (ndr_pull_flags_fn_t)ndr_pull_opendb_file);
+ ndr_err = ndr_pull_struct_blob(&blob, lck, file, (ndr_pull_flags_fn_t)ndr_pull_opendb_file);
free(dbuf.dptr);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return ndr_map_error2ntstatus(ndr_err);
return NT_STATUS_OK;
}
- ndr_err = ndr_push_struct_blob(&blob, lck, lp_iconv_convenience(lck->odb->ntvfs_ctx->lp_ctx), file, (ndr_push_flags_fn_t)ndr_push_opendb_file);
+ ndr_err = ndr_push_struct_blob(&blob, lck, file, (ndr_push_flags_fn_t)ndr_push_opendb_file);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return ndr_map_error2ntstatus(ndr_err);
}
call->mem_ctx = mem_ctx;
- call->ndr_pull_param = ndr_pull_init_blob(&trans->in.params, mem_ctx, lp_iconv_convenience(lp_ctx));
+ call->ndr_pull_param = ndr_pull_init_blob(&trans->in.params, mem_ctx);
call->ndr_pull_param->flags = RAPNDR_FLAGS;
- call->ndr_pull_data = ndr_pull_init_blob(&trans->in.data, mem_ctx, lp_iconv_convenience(lp_ctx));
+ call->ndr_pull_data = ndr_pull_init_blob(&trans->in.data, mem_ctx);
call->ndr_pull_data->flags = RAPNDR_FLAGS;
call->heap = talloc(mem_ctx, struct rap_string_heap);
NDR_RETURN(ndr_pull_string(call->ndr_pull_param, NDR_SCALARS,
&call->datadesc));
- call->ndr_push_param = ndr_push_init_ctx(call, lp_iconv_convenience(lp_ctx));
- call->ndr_push_data = ndr_push_init_ctx(call, lp_iconv_convenience(lp_ctx));
+ call->ndr_push_param = ndr_push_init_ctx(call);
+ call->ndr_push_data = ndr_push_init_ctx(call);
if ((call->ndr_push_param == NULL) || (call->ndr_push_data == NULL))
return NT_STATUS_NO_MEMORY;
result_param = ndr_push_blob(call->ndr_push_param);
result_data = ndr_push_blob(call->ndr_push_data);
- final_param = ndr_push_init_ctx(call, lp_iconv_convenience(lp_ctx));
- final_data = ndr_push_init_ctx(call, lp_iconv_convenience(lp_ctx));
+ final_param = ndr_push_init_ctx(call);
+ final_data = ndr_push_init_ctx(call);
if ((final_param == NULL) || (final_data == NULL))
return NT_STATUS_NO_MEMORY;
struct pipe_state *p;
struct ipc_private *ipriv = talloc_get_type_abort(ntvfs->private_data,
struct ipc_private);
- struct smb_iconv_convenience *smb_ic
- = lp_iconv_convenience(ipriv->ntvfs->ctx->lp_ctx);
struct ntvfs_handle *h;
struct ipc_open_state *state;
struct tevent_req *subreq;
subreq = tstream_npa_connect_send(p,
ipriv->ntvfs->ctx->event_ctx,
- smb_ic,
directory,
fname,
client_addr,
resolve a wildcard rename pattern. This works on one component of the name
*/
static const char *pvfs_resolve_wildcard_component(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
const char *fname,
const char *pattern)
{
while (*p2) {
codepoint_t c1, c2;
size_t c_size1, c_size2;
- c1 = next_codepoint_convenience(iconv_convenience, p1, &c_size1);
- c2 = next_codepoint_convenience(iconv_convenience, p2, &c_size2);
+ c1 = next_codepoint(p1, &c_size1);
+ c2 = next_codepoint(p2, &c_size2);
if (c2 == '?') {
- d += push_codepoint_convenience(iconv_convenience, d, c1);
+ d += push_codepoint(d, c1);
} else if (c2 == '*') {
memcpy(d, p1, strlen(p1));
d += strlen(p1);
break;
} else {
- d += push_codepoint_convenience(iconv_convenience, d, c2);
+ d += push_codepoint(d, c2);
}
p1 += c_size1;
resolve a wildcard rename pattern.
*/
static const char *pvfs_resolve_wildcard(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
const char *fname,
const char *pattern)
{
return NULL;
}
- base1 = pvfs_resolve_wildcard_component(mem_ctx, iconv_convenience, base1, base2);
- ext1 = pvfs_resolve_wildcard_component(mem_ctx, iconv_convenience, ext1, ext2);
+ base1 = pvfs_resolve_wildcard_component(mem_ctx, base1, base2);
+ ext1 = pvfs_resolve_wildcard_component(mem_ctx, ext1, ext2);
if (base1 == NULL || ext1 == NULL) {
return NULL;
}
NTSTATUS status;
/* resolve the wildcard pattern for this name */
- fname2 = pvfs_resolve_wildcard(mem_ctx, lp_iconv_convenience(pvfs->ntvfs->ctx->lp_ctx), fname1, fname2);
+ fname2 = pvfs_resolve_wildcard(mem_ctx, fname1, fname2);
if (fname2 == NULL) {
return NT_STATUS_NO_MEMORY;
}
/*
parse a alternate data stream name
*/
-static NTSTATUS parse_stream_name(struct smb_iconv_convenience *ic,
- struct pvfs_filename *name,
+static NTSTATUS parse_stream_name(struct pvfs_filename *name,
const char *s)
{
char *p, *stream_name;
while (*p) {
size_t c_size;
- codepoint_t c = next_codepoint_convenience(ic, p, &c_size);
+ codepoint_t c = next_codepoint(p, &c_size);
switch (c) {
case '/':
unsigned int flags, struct pvfs_filename *name)
{
char *ret, *p, *p_start;
- struct smb_iconv_convenience *ic = NULL;
NTSTATUS status;
name->original_name = talloc_strdup(name, cifs_name);
for legal characters */
p_start = p;
- ic = lp_iconv_convenience(pvfs->ntvfs->ctx->lp_ctx);
while (*p) {
size_t c_size;
- codepoint_t c = next_codepoint_convenience(ic, p, &c_size);
+ codepoint_t c = next_codepoint(p, &c_size);
if (c <= 0x1F) {
return NT_STATUS_OBJECT_NAME_INVALID;
if (name->has_wildcard) {
return NT_STATUS_OBJECT_NAME_INVALID;
}
- status = parse_stream_name(ic, name, p);
+ status = parse_stream_name(name, p);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return NULL if it can't be reduced
*/
static NTSTATUS pvfs_reduce_name(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *iconv_convenience,
const char **fname, unsigned int flags)
{
codepoint_t c;
if (s == NULL) return NT_STATUS_NO_MEMORY;
for (num_components=1, p=s; *p; p += c_size) {
- c = next_codepoint_convenience(iconv_convenience, p, &c_size);
+ c = next_codepoint(p, &c_size);
if (c == '\\') num_components++;
}
components[0] = s;
for (i=0, p=s; *p; p += c_size) {
- c = next_codepoint_convenience(iconv_convenience, p, &c_size);
+ c = next_codepoint(p, &c_size);
if (c == '\\') {
*p = 0;
components[++i] = p+1;
if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_SYNTAX_BAD)) {
/* it might contain .. components which need to be reduced */
- status = pvfs_reduce_name(*name, lp_iconv_convenience(pvfs->ntvfs->ctx->lp_ctx), &cifs_name, flags);
+ status = pvfs_reduce_name(*name, &cifs_name, flags);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
/* this is used to reverse the base 36 mapping */
unsigned char base_reverse[256];
-
- struct smb_iconv_convenience *iconv_convenience;
};
{
while (*name) {
size_t c_size;
- codepoint_t c = next_codepoint_convenience(ctx->iconv_convenience, name, &c_size);
+ codepoint_t c = next_codepoint(name, &c_size);
if (c == INVALID_CODEPOINT) {
return false;
}
return NT_STATUS_NO_MEMORY;
}
- ctx->iconv_convenience = lp_iconv_convenience(pvfs->ntvfs->ctx->lp_ctx);
-
/* by default have a max of 512 entries in the cache. */
ctx->cache_size = lp_parm_int(pvfs->ntvfs->ctx->lp_ctx, NULL, "mangle", "cachesize", 512);
}
/* pull the blob */
- ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, lp_iconv_convenience(pvfs->ntvfs->ctx->lp_ctx),
- p, (ndr_pull_flags_fn_t)pull_fn);
+ ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, p,
+ (ndr_pull_flags_fn_t)pull_fn);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return ndr_map_error2ntstatus(ndr_err);
}
NTSTATUS status;
enum ndr_err_code ndr_err;
- ndr_err = ndr_push_struct_blob(&blob, mem_ctx, lp_iconv_convenience(pvfs->ntvfs->ctx->lp_ctx), p, (ndr_push_flags_fn_t)push_fn);
+ ndr_err = ndr_push_struct_blob(&blob, mem_ctx, p, (ndr_push_flags_fn_t)push_fn);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(mem_ctx);
return ndr_map_error2ntstatus(ndr_err);
struct loadparm_global *globals;
struct loadparm_service **services;
struct loadparm_service *sDefault;
+ struct smb_iconv_convenience *iconv_convenience;
int iNumServices;
struct loadparm_service *currentService;
bool bInGlobalSection;
time_t modtime;
} *file_lists;
unsigned int flags[NUMPARAMETERS];
- struct smb_iconv_convenience *iconv_convenience;
};
return NULL;
SMB_ASSERT(lp_ctx != NULL);
settings->lp_ctx = talloc_reference(settings, lp_ctx);
- settings->iconv_convenience = lp_iconv_convenience(lp_ctx);
settings->target_hostname = lp_parm_string(lp_ctx, NULL, "gensec", "target_hostname");
return settings;
}
return NULL;
}
- ndr_err = ndr_pull_struct_blob(v, result, NULL, result,
+ ndr_err = ndr_pull_struct_blob(v, result, result,
(ndr_pull_flags_fn_t)ndr_pull_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
*errstring = talloc_asprintf(mem_ctx, "Failed to parse SID on record for %s in %s",
return NT_STATUS_NO_MEMORY;
}
- status = ncacn_push_auth(&rep->blob, call, lp_iconv_convenience(call->conn->dce_ctx->lp_ctx), &pkt, NULL);
+ status = ncacn_push_auth(&rep->blob, call, &pkt, NULL);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return NT_STATUS_NO_MEMORY;
}
- status = ncacn_push_auth(&rep->blob, call, lp_iconv_convenience(call->conn->dce_ctx->lp_ctx), &pkt, NULL);
+ status = ncacn_push_auth(&rep->blob, call, &pkt, NULL);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return NT_STATUS_NO_MEMORY;
}
- status = ncacn_push_auth(&rep->blob, call, lp_iconv_convenience(call->conn->dce_ctx->lp_ctx), &pkt, call->conn->auth_state.auth_info);
+ status = ncacn_push_auth(&rep->blob, call, &pkt,
+ call->conn->auth_state.auth_info);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(call->context);
call->context = NULL;
return NT_STATUS_NO_MEMORY;
}
- status = ncacn_push_auth(&rep->blob, call, lp_iconv_convenience(call->conn->dce_ctx->lp_ctx), &pkt, call->conn->auth_state.auth_info);
+ status = ncacn_push_auth(&rep->blob, call, &pkt, call->conn->auth_state.auth_info);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return dcesrv_fault(call, DCERPC_FAULT_UNK_IF);
}
- pull = ndr_pull_init_blob(&call->pkt.u.request.stub_and_verifier, call,
- lp_iconv_convenience(call->conn->dce_ctx->lp_ctx));
+ pull = ndr_pull_init_blob(&call->pkt.u.request.stub_and_verifier, call);
NT_STATUS_HAVE_NO_MEMORY(pull);
pull->flags |= LIBNDR_FLAG_REF_ALLOC;
}
/* form the reply NDR */
- push = ndr_push_init_ctx(call, lp_iconv_convenience(call->conn->dce_ctx->lp_ctx));
+ push = ndr_push_init_ctx(call);
NT_STATUS_HAVE_NO_MEMORY(push);
/* carry over the pointer count to the reply in case we are
/* non-signed packets are simple */
if (sig_size == 0) {
- status = ncacn_push_auth(blob, call, lp_iconv_convenience(dce_conn->dce_ctx->lp_ctx), pkt, NULL);
+ status = ncacn_push_auth(blob, call, pkt, NULL);
return NT_STATUS_IS_OK(status);
}
* TODO: let the gensec mech decide if it wants to generate a signature
* that might be needed for schannel...
*/
- status = ncacn_push_auth(blob, call, lp_iconv_convenience(dce_conn->dce_ctx->lp_ctx), pkt, NULL);
+ status = ncacn_push_auth(blob, call, pkt, NULL);
return NT_STATUS_IS_OK(status);
case DCERPC_AUTH_LEVEL_NONE:
- status = ncacn_push_auth(blob, call, lp_iconv_convenience(dce_conn->dce_ctx->lp_ctx), pkt, NULL);
+ status = ncacn_push_auth(blob, call, pkt, NULL);
return NT_STATUS_IS_OK(status);
default:
return false;
}
- ndr = ndr_push_init_ctx(call, lp_iconv_convenience(dce_conn->dce_ctx->lp_ctx));
+ ndr = ndr_push_init_ctx(call);
if (!ndr) {
return false;
}
return WERR_OK;
}
- ndr_err = ndr_pull_struct_blob(md_value, obj,
- lp_iconv_convenience(ldb_get_opaque(sam_ctx, "loadparm")), &md,
+ ndr_err = ndr_pull_struct_blob(md_value, obj, &md,
(ndr_pull_flags_fn_t)ndr_pull_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return WERR_DS_DRA_INTERNAL_ERROR;
arcfour_crypt_blob(auth_blob->data, auth_blob->length, &session_key);
ndr_err = ndr_pull_struct_blob(auth_blob, mem_ctx,
- lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
auth_struct,
(ndr_pull_flags_fn_t)ndr_pull_trustDomainPasswords);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
ioblob.previous->array[i].AuthType = 0;
}
ndr_err = ndr_push_struct_blob(trustauth_blob, mem_ctx,
- lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
&ioblob,
(ndr_push_flags_fn_t)ndr_push_trustAuthInOutBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
/* decode all TDOs forest trust info blobs */
static NTSTATUS get_ft_info(TALLOC_CTX *mem_ctx,
- struct smb_iconv_convenience *ic,
struct ldb_message *msg,
struct ForestTrustInfo *info)
{
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
/* ldb_val is equivalent to DATA_BLOB */
- ndr_err = ndr_pull_struct_blob_all(ft_blob, mem_ctx, ic,
- info,
+ ndr_err = ndr_pull_struct_blob_all(ft_blob, mem_ctx, info,
(ndr_pull_flags_fn_t)ndr_pull_ForestTrustInfo);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return NT_STATUS_INVALID_DOMAIN_STATE;
{
struct dcesrv_handle *h;
struct lsa_policy_state *p_state;
- struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
- struct smb_iconv_convenience *ic = lp_iconv_convenience(lp_ctx);
const char *trust_attrs[] = { "trustPartner", "trustAttributes",
"msDS-TrustForestTrustInfo", NULL };
struct ldb_message **dom_res = NULL;
return NT_STATUS_NO_MEMORY;
}
- nt_status = get_ft_info(mem_ctx, ic, dom_res[i], fti);
+ nt_status = get_ft_info(mem_ctx, dom_res[i], fti);
if (!NT_STATUS_IS_OK(nt_status)) {
if (NT_STATUS_EQUAL(nt_status,
NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
/* not just a check, write info back */
- ndr_err = ndr_push_struct_blob(&ft_blob, mem_ctx, ic,
- nfti,
+ ndr_err = ndr_push_struct_blob(&ft_blob, mem_ctx, nfti,
(ndr_push_flags_fn_t)ndr_push_ForestTrustInfo);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return NT_STATUS_INVALID_PARAMETER;
creds->sid = samdb_result_dom_sid(creds, msgs[0], "objectSid");
nt_status = schannel_save_creds_state(mem_ctx,
- lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
lp_private_dir(dce_call->conn->dce_ctx->lp_ctx),
creds);
}
nt_status = schannel_check_creds_state(mem_ctx,
- lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
lp_private_dir(dce_call->conn->dce_ctx->lp_ctx),
computer_name,
received_authenticator,
struct netlogon_creds_CredentialState *creds;
nt_status = schannel_get_creds_state(mem_ctx,
- lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
lp_private_dir(dce_call->conn->dce_ctx->lp_ctx),
r->in.computer_name, &creds);
if (!NT_STATUS_IS_OK(nt_status)) {
struct dcerpc_read_ncacn_packet_state {
struct {
- struct smb_iconv_convenience *smb_iconv_c;
} caller;
DATA_BLOB buffer;
struct ncacn_packet *pkt;
static struct tevent_req *dcerpc_read_ncacn_packet_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
- struct tstream_context *stream,
- struct smb_iconv_convenience *ic)
+ struct tstream_context *stream)
{
struct tevent_req *req;
struct dcerpc_read_ncacn_packet_state *state;
return NULL;
}
- state->caller.smb_iconv_c = ic;
state->buffer = data_blob_const(NULL, 0);
state->pkt = talloc(state, struct ncacn_packet);
if (tevent_req_nomem(state->pkt, req)) {
return;
}
- ndr = ndr_pull_init_blob(&state->buffer,
- state->pkt,
- state->caller.smb_iconv_c);
+ ndr = ndr_pull_init_blob(&state->buffer, state->pkt);
if (tevent_req_nomem(ndr, req)) {
return;
}
subreq = dcerpc_read_ncacn_packet_send(dcesrv_conn,
dcesrv_conn->event_ctx,
- dcesrv_conn->stream,
- lp_iconv_convenience(lp_ctx));
+ dcesrv_conn->stream);
if (!subreq) {
status = NT_STATUS_NO_MEMORY;
DEBUG(0,("dcesrv_sock_accept: dcerpc_read_fragment_buffer_send(%s)\n",
struct ncacn_packet *pkt;
DATA_BLOB buffer;
NTSTATUS status;
- struct loadparm_context *lp_ctx = dce_conn->dce_ctx->lp_ctx;
status = dcerpc_read_ncacn_packet_recv(subreq, dce_conn,
&pkt, &buffer);
subreq = dcerpc_read_ncacn_packet_send(dce_conn,
dce_conn->event_ctx,
- dce_conn->stream,
- lp_iconv_convenience(lp_ctx));
+ dce_conn->stream);
if (!subreq) {
status = NT_STATUS_NO_MEMORY;
dcesrv_terminate_connection(dce_conn, nt_errstr(status));
SPOOLSS_NOTIFY
};
-#define SPOOLSS_BUFFER_UNION(fn,ic,info,level) \
- ((info)?ndr_size_##fn(info, level, ic, 0):0)
+#define SPOOLSS_BUFFER_UNION(fn,info,level) \
+ ((info)?ndr_size_##fn(info, level, 0):0)
-#define SPOOLSS_BUFFER_UNION_ARRAY(fn,ic,info,level,count) \
- ((info)?ndr_size_##fn##_info(dce_call, ic, level, count, info):0)
+#define SPOOLSS_BUFFER_UNION_ARRAY(fn,info,level,count) \
+ ((info)?ndr_size_##fn##_info(dce_call, level, count, info):0)
#define SPOOLSS_BUFFER_OK(val_true,val_false) ((r->in.offered >= *r->out.needed)?val_true:val_false)
{
struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private_data, struct ntptr_context);
WERROR status;
- struct smb_iconv_convenience *ic = lp_iconv_convenience(ntptr->lp_ctx);
status = dcesrv_spoolss_check_server_name(dce_call, mem_ctx, r->in.server);
W_ERROR_NOT_OK_RETURN(status);
status = ntptr_EnumPrinters(ntptr, mem_ctx, r);
W_ERROR_NOT_OK_RETURN(status);
- *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPrinters, ic, *r->out.info, r->in.level, *r->out.count);
+ *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPrinters, *r->out.info, r->in.level, *r->out.count);
*r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
*r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
{
struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private_data, struct ntptr_context);
WERROR status;
- struct smb_iconv_convenience *ic = lp_iconv_convenience(ntptr->lp_ctx);
status = dcesrv_spoolss_check_server_name(dce_call, mem_ctx, r->in.server);
W_ERROR_NOT_OK_RETURN(status);
status = ntptr_EnumPrinterDrivers(ntptr, mem_ctx, r);
W_ERROR_NOT_OK_RETURN(status);
- *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPrinterDrivers, ic, *r->out.info, r->in.level, *r->out.count);
+ *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPrinterDrivers, *r->out.info, r->in.level, *r->out.count);
*r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
*r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
{
struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private_data, struct ntptr_context);
WERROR status;
- struct smb_iconv_convenience *ic = lp_iconv_convenience(ntptr->lp_ctx);
status = dcesrv_spoolss_check_server_name(dce_call, mem_ctx, r->in.server);
W_ERROR_NOT_OK_RETURN(status);
status = ntptr_GetPrinterDriverDirectory(ntptr, mem_ctx, r);
W_ERROR_NOT_OK_RETURN(status);
- *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, ic, r->out.info, r->in.level);
+ *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_DriverDirectoryInfo, r->out.info, r->in.level);
r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
}
{
struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private_data, struct ntptr_context);
WERROR status;
- struct smb_iconv_convenience *ic = lp_iconv_convenience(ntptr->lp_ctx);
status = dcesrv_spoolss_check_server_name(dce_call, mem_ctx, r->in.server);
W_ERROR_NOT_OK_RETURN(status);
status = ntptr_GetPrintProcessorDirectory(ntptr, mem_ctx, r);
W_ERROR_NOT_OK_RETURN(status);
- *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, ic, r->out.info, r->in.level);
+ *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_PrintProcessorDirectoryInfo, r->out.info, r->in.level);
r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
}
struct ntptr_GenericHandle *handle;
struct dcesrv_handle *h;
WERROR status;
- struct smb_iconv_convenience *ic = lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx);
DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
return WERR_FOOBAR;
}
- *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, ic, r->out.info, r->in.level);
+ *r->out.needed = SPOOLSS_BUFFER_UNION(spoolss_FormInfo, r->out.info, r->in.level);
r->out.info = SPOOLSS_BUFFER_OK(r->out.info, NULL);
return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
}
struct ntptr_GenericHandle *handle;
struct dcesrv_handle *h;
WERROR status;
- struct smb_iconv_convenience *ic = lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx);
DCESRV_PULL_HANDLE_WERR(h, r->in.handle, DCESRV_HANDLE_ANY);
handle = talloc_get_type(h->data, struct ntptr_GenericHandle);
return WERR_FOOBAR;
}
- *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumForms, ic, *r->out.info, r->in.level, *r->out.count);
+ *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumForms, *r->out.info, r->in.level, *r->out.count);
*r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
*r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
{
struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private_data, struct ntptr_context);
WERROR status;
- struct smb_iconv_convenience *ic = lp_iconv_convenience(ntptr->lp_ctx);
status = dcesrv_spoolss_check_server_name(dce_call, mem_ctx, r->in.servername);
W_ERROR_NOT_OK_RETURN(status);
status = ntptr_EnumPorts(ntptr, mem_ctx, r);
W_ERROR_NOT_OK_RETURN(status);
- *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPorts, ic, *r->out.info, r->in.level, *r->out.count);
+ *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumPorts, *r->out.info, r->in.level, *r->out.count);
*r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
*r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
{
struct ntptr_context *ntptr = talloc_get_type(dce_call->context->private_data, struct ntptr_context);
WERROR status;
- struct smb_iconv_convenience *ic = lp_iconv_convenience(ntptr->lp_ctx);
status = dcesrv_spoolss_check_server_name(dce_call, mem_ctx, r->in.servername);
W_ERROR_NOT_OK_RETURN(status);
status = ntptr_EnumMonitors(ntptr, mem_ctx, r);
W_ERROR_NOT_OK_RETURN(status);
- *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumMonitors, ic, *r->out.info, r->in.level, *r->out.count);
+ *r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(spoolss_EnumMonitors, *r->out.info, r->in.level, *r->out.count);
*r->out.info = SPOOLSS_BUFFER_OK(*r->out.info, NULL);
*r->out.count = SPOOLSS_BUFFER_OK(*r->out.count, 0);
return SPOOLSS_BUFFER_OK(WERR_OK, WERR_INSUFFICIENT_BUFFER);
if (sdblob.data == NULL) {
return WERR_INVALID_PARAM;
}
- ndr_err = ndr_pull_struct_blob_all(&sdblob, mem_ctx, NULL, &sd,
+ ndr_err = ndr_pull_struct_blob_all(&sdblob, mem_ctx, &sd,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return WERR_INVALID_PARAM;
void py_load_samba_modules(void);
bool py_update_path(const char *bindir);
-#define py_iconv_convenience(mem_ctx) smb_iconv_convenience_reinit(mem_ctx, "ASCII", \
- PyUnicode_GetDefaultEncoding(), true, NULL)
-
#endif /* __SAMBA_PYTHON_MODULES_H__ */
if (io->ntcreatex.in.sec_desc == NULL) {
return NT_STATUS_NO_MEMORY;
}
- ndr_err = ndr_pull_struct_blob(&blob, io, NULL,
+ ndr_err = ndr_pull_struct_blob(&blob, io,
io->ntcreatex.in.sec_desc,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NT_STATUS_NOT_OK_RETURN(status);
params = op->trans->out.params.data;
- ndr_err = ndr_push_struct_blob(&op->trans->out.data, op, NULL,
+ ndr_err = ndr_push_struct_blob(&op->trans->out.data, op,
io->query_secdesc.out.sd,
(ndr_push_flags_fn_t)ndr_push_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
io->set_secdesc.in.sd = talloc(io, struct security_descriptor);
NT_STATUS_HAVE_NO_MEMORY(io->set_secdesc.in.sd);
- ndr_err = ndr_pull_struct_blob(&trans->in.data, req, NULL,
+ ndr_err = ndr_pull_struct_blob(&trans->in.data, req,
io->set_secdesc.in.sd,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
union smb_fileinfo *io = talloc_get_type(op->io_ptr, union smb_fileinfo);
enum ndr_err_code ndr_err;
- ndr_err = ndr_push_struct_blob(&op->info->out.blob, op->req, NULL,
+ ndr_err = ndr_push_struct_blob(&op->info->out.blob, op->req,
io->query_secdesc.out.sd,
(ndr_push_flags_fn_t)ndr_push_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
io->set_secdesc.in.sd = talloc(io, struct security_descriptor);
NT_STATUS_HAVE_NO_MEMORY(io->set_secdesc.in.sd);
- ndr_err = ndr_pull_struct_blob(&op->info->in.blob, io, NULL,
+ ndr_err = ndr_pull_struct_blob(&op->info->in.blob, io,
io->set_secdesc.in.sd,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
smb2srv_send_error(req, NT_STATUS_NO_MEMORY);
return;
}
- ndr_err = ndr_pull_struct_blob(&io->smb2.in.blobs.blobs[i].data, io, NULL,
+ ndr_err = ndr_pull_struct_blob(&io->smb2.in.blobs.blobs[i].data, io,
io->smb2.in.sec_desc,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
msg = messaging_init(talloc_autofree_context(),
lp_messaging_path(event_ctx, lp_ctx),
- cluster_id(0, SAMBA_PARENT_TASKID),
- lp_iconv_convenience(lp_ctx),
- event_ctx);
+ cluster_id(0, SAMBA_PARENT_TASKID), event_ctx);
NT_STATUS_HAVE_NO_MEMORY(msg);
irpc_add_name(msg, "samba");
ndr_err = ndr_pull_struct_blob_all(
&call->in,
pipe_conn,
- lp_iconv_convenience(conn->lp_ctx),
&pipe_request,
(ndr_pull_flags_fn_t) ndr_pull_named_pipe_auth_req);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
reply:
/* create the output */
ndr_err = ndr_push_struct_blob(&call->out, pipe_conn,
- lp_iconv_convenience(conn->lp_ctx),
&pipe_reply,
(ndr_push_flags_fn_t)ndr_push_named_pipe_auth_rep);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
/* setup to receive internal messages on this connection */
srv_conn->msg_ctx = messaging_init(srv_conn,
lp_messaging_path(srv_conn, lp_ctx),
- srv_conn->server_id,
- lp_iconv_convenience(lp_ctx),
- ev);
+ srv_conn->server_id, ev);
if (!srv_conn->msg_ctx) {
stream_terminate_connection(srv_conn, "messaging_init() failed");
return;
task->msg_ctx = messaging_init(task,
lp_messaging_path(task, task->lp_ctx),
task->server_id,
- lp_iconv_convenience(task->lp_ctx),
task->event_ctx);
if (!task->msg_ctx) {
task_server_terminate(task, "messaging_init() failed", true);
/* 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,
/* 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,
/* 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);
/* 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,
/* 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,
/* 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);
/* 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,
}
ret = kerberos_encode_pac(mem_ctx,
- lp_iconv_convenience(tctx->lp_ctx),
pac_data,
smb_krb5_context->krb5_context,
krbtgt_keyblock_p,
}
ret = kerberos_create_pac(mem_ctx,
- lp_iconv_convenience(tctx->lp_ctx),
server_info_out,
smb_krb5_context->krb5_context,
krbtgt_keyblock_p,
*/
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");
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");
/* 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,
}
nt_status = kerberos_decode_pac(mem_ctx,
- lp_iconv_convenience(tctx->lp_ctx),
&pac_data,
tmp_blob,
smb_krb5_context->krb5_context,
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,
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;
/****************************************************************************
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;
{
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,
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);
}
}
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);
}
-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];
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;
}
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,
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 */
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;
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;
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 */
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)) {
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;
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;
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);
}
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);
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);
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, "");
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, "");
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");
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, "");
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);
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);
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);
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);
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);
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);
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;
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;
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;
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;
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++;
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;
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;
}
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);
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);
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;
socket_options,
cmdline_credentials, resolve_ctx, ev,
options, session_options,
- iconv_convenience,
gensec_settings);
if (!NT_STATUS_IS_OK(status)) {
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));
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;
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;
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;
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,
*/
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;
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);
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);
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);
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");
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);
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 */
}
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 */
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);
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;
/* 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");
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),
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,
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),
"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");
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");
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) {
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;
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;
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;
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");
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");
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");
"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) {
"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");
}
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");
}
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");
}
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++) {
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++) {
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");
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");
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");
"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");
}
"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");
}
"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++) {
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");
#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;
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;
}
static NTSTATUS rap_cli_do_call(struct smbcli_tree *tree,
- struct smb_iconv_convenience *iconv_convenience,
struct rap_call *call)
{
NTSTATUS result;
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;
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;
static NTSTATUS smbcli_rap_netshareenum(struct smbcli_tree *tree,
- struct smb_iconv_convenience *iconv_convenience,
TALLOC_CTX *mem_ctx,
struct rap_NetShareEnum *r)
{
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;
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;
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,
}
static NTSTATUS smbcli_rap_netserverenum2(struct smbcli_tree *tree,
- struct smb_iconv_convenience *iconv_convenience,
TALLOC_CTX *mem_ctx,
struct rap_NetServerEnum2 *r)
{
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;
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;
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) {
}
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;
}
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;
}
NTSTATUS smbcli_rap_netprintqenum(struct smbcli_tree *tree,
- struct smb_iconv_convenience *iconv_convenience,
TALLOC_CTX *mem_ctx,
struct rap_NetPrintQEnum *r)
{
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
NTSTATUS smbcli_rap_netprintjobenum(struct smbcli_tree *tree,
- struct smb_iconv_convenience *iconv_convenience,
TALLOC_CTX *mem_ctx,
struct rap_NetPrintJobEnum *r)
{
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
NTSTATUS smbcli_rap_netprintdestenum(struct smbcli_tree *tree,
- struct smb_iconv_convenience *iconv_convenience,
TALLOC_CTX *mem_ctx,
struct rap_NetPrintDestEnum *r)
{
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;
}
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;
}
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;
}
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;
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");
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;
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");
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");
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",
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;
}
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)) {
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);
}
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");
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;
}
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 {
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);
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",
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",
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");
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");
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");
/* 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");
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",
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;
}
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;
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",
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;
}
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;
}
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;
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",
"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");
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;
}
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));
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",
}
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;
}
}
static NTSTATUS get_servername(TALLOC_CTX *mem_ctx, struct smbcli_tree *tree,
- struct smb_iconv_convenience *iconv_convenience,
char **name)
{
struct rap_WserverGetInfo r;
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;
}
"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);
"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;
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;
};
/*
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)) {
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));
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;
#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);\
}\
} 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);\
}\
} 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);\
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;
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;
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;
*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;
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;
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;
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);
}
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;
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;
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;
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;
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;
}
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;
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");
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;
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;
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;
}
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);
}
}
}
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;
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,
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");
"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 {\
"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),\
"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),\
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],\
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,
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);
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);
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);
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");
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;
}
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;
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");
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) {
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");
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");
}
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");
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)) {
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)) {
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));
const char *winbind_method[] = { "winbind", NULL };
struct auth_context *auth_context;
- msg = messaging_client_init(state, lp_messaging_path(state, lp_ctx),
- lp_iconv_convenience(lp_ctx), ev);
+ msg = messaging_client_init(state, lp_messaging_path(state, lp_ctx), ev);
if (!msg) {
talloc_free(mem_ctx);
exit(1);
struct ldb_val val;
enum ndr_err_code ndr_err;
- ndr_err = ndr_push_struct_blob(&val, mem_ctx,
- lp_iconv_convenience(idmap_ctx->lp_ctx),
- sid,
+ ndr_err = ndr_push_struct_blob(&val, mem_ctx, sid,
(ndr_push_flags_fn_t)ndr_push_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return NULL;
}
- ndr_err = ndr_pull_struct_blob(val, sid, NULL, sid,
+ ndr_err = ndr_pull_struct_blob(val, sid, sid,
(ndr_pull_flags_fn_t)ndr_pull_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(sid);
lp_nbt_port(service->task->lp_ctx),
domain_name, NBT_NAME_LOGON,
dom_sid,
- lp_iconv_convenience(service->task->lp_ctx),
lp_resolve_context(service->task->lp_ctx),
service->task->event_ctx,
service->task->msg_ctx);
if (!composite_is_ok(state->ctx)) return;
ndr_err = ndr_push_struct_blob(
- &tmp_blob, state, lp_iconv_convenience(state->lp_ctx),
- state->req->out.validation.sam3,
+ &tmp_blob, state, state->req->out.validation.sam3,
(ndr_push_flags_fn_t)ndr_push_netr_SamInfo3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
state->ctx->status = ndr_map_error2ntstatus(ndr_err);
ndr_err = ndr_pull_struct_blob(&info3b,
mem_ctx,
- lp_iconv_convenience(s3call->wbconn->lp_ctx),
info3,
(ndr_pull_flags_fn_t)ndr_pull_netr_SamInfo3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
wrepl_out->assoc_ctx.our_ctx = wrepl_in->assoc_ctx.our_ctx;
wrepl_out->assoc_ctx.peer_ctx = wrepl_in->assoc_ctx.peer_ctx;
wrepl_out->sock = wrepl_socket_init(wrepl_out,
- wrepl_in->conn->event.ctx,
- lp_iconv_convenience(wrepl_in->service->task->lp_ctx));
+ wrepl_in->conn->event.ctx);
+
NT_STATUS_HAVE_NO_MEMORY_AND_FREE(wrepl_out->sock, update_state);
TALLOC_FREE(wrepl_in->send_queue);
struct wreplsrv_in_call *call = *_call;
ndr_err = ndr_pull_struct_blob(&call->in, call,
- lp_iconv_convenience(wrepl_conn->service->task->lp_ctx),
&call->req_packet,
(ndr_pull_flags_fn_t)ndr_pull_wrepl_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
/* and now encode the reply */
packet_out_wrap.packet = call->rep_packet;
ndr_err = ndr_push_struct_blob(&call->out, call,
- lp_iconv_convenience(wrepl_conn->service->task->lp_ctx),
&packet_out_wrap,
(ndr_push_flags_fn_t) ndr_push_wrepl_wrap);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
wreplconn->service = service;
wreplconn->partner = partner;
- wreplconn->sock = wrepl_socket_init(wreplconn, service->task->event_ctx, lp_iconv_convenience(service->task->lp_ctx));
+ wreplconn->sock = wrepl_socket_init(wreplconn, service->task->event_ctx);
if (!wreplconn->sock) goto failed;
state->stage = WREPLSRV_OUT_CONNECT_STAGE_WAIT_SOCKET;