/* client functions auto-generated by pidl */

#include "includes.h"
#include <tevent.h>
#include "lib/util/tevent_ntstatus.h"
#include "librpc/gen_ndr/ndr_wzcsvc.h"
#include "librpc/gen_ndr/ndr_wzcsvc_c.h"

/* wzcsvc - client functions generated by pidl */

struct dcerpc_wzcsvc_EnumInterfaces_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EnumInterfaces_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EnumInterfaces_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_EnumInterfaces *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EnumInterfaces_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EnumInterfaces_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_ENUMINTERFACES, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EnumInterfaces_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_EnumInterfaces_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EnumInterfaces_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EnumInterfaces_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_EnumInterfaces_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EnumInterfaces_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_EnumInterfaces *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_ENUMINTERFACES, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_EnumInterfaces_state {
	struct wzcsvc_EnumInterfaces orig;
	struct wzcsvc_EnumInterfaces tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EnumInterfaces_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EnumInterfaces_send(TALLOC_CTX *mem_ctx,
						     struct tevent_context *ev,
						     struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EnumInterfaces_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EnumInterfaces_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_EnumInterfaces_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EnumInterfaces_done, req);
	return req;
}

static void dcerpc_wzcsvc_EnumInterfaces_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_EnumInterfaces_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EnumInterfaces_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_EnumInterfaces_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EnumInterfaces_recv(struct tevent_req *req,
					   TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EnumInterfaces_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EnumInterfaces_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EnumInterfaces(struct dcerpc_binding_handle *h,
				      TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_EnumInterfaces r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_EnumInterfaces_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_QueryInterface_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_QueryInterface_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_QueryInterface_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_QueryInterface *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_QueryInterface_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_QueryInterface_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_QUERYINTERFACE, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_QueryInterface_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_QueryInterface_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_QueryInterface_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_QueryInterface_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_QueryInterface_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_QueryInterface_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_QueryInterface *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_QUERYINTERFACE, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_QueryInterface_state {
	struct wzcsvc_QueryInterface orig;
	struct wzcsvc_QueryInterface tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_QueryInterface_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_QueryInterface_send(TALLOC_CTX *mem_ctx,
						     struct tevent_context *ev,
						     struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_QueryInterface_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_QueryInterface_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_QueryInterface_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_QueryInterface_done, req);
	return req;
}

static void dcerpc_wzcsvc_QueryInterface_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_QueryInterface_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_QueryInterface_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_QueryInterface_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_QueryInterface_recv(struct tevent_req *req,
					   TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_QueryInterface_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_QueryInterface_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_QueryInterface(struct dcerpc_binding_handle *h,
				      TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_QueryInterface r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_QueryInterface_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_SetInterface_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_SetInterface_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_SetInterface_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_SetInterface *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_SetInterface_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_SetInterface_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_SETINTERFACE, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_SetInterface_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_SetInterface_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_SetInterface_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_SetInterface_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_SetInterface_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_SetInterface_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_SetInterface *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_SETINTERFACE, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_SetInterface_state {
	struct wzcsvc_SetInterface orig;
	struct wzcsvc_SetInterface tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_SetInterface_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_SetInterface_send(TALLOC_CTX *mem_ctx,
						   struct tevent_context *ev,
						   struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_SetInterface_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_SetInterface_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_SetInterface_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_SetInterface_done, req);
	return req;
}

static void dcerpc_wzcsvc_SetInterface_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_SetInterface_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_SetInterface_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_SetInterface_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_SetInterface_recv(struct tevent_req *req,
					 TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_SetInterface_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_SetInterface_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_SetInterface(struct dcerpc_binding_handle *h,
				    TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_SetInterface r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_SetInterface_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_RefreshInterface_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_RefreshInterface_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_RefreshInterface_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_RefreshInterface *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_RefreshInterface_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_RefreshInterface_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_REFRESHINTERFACE, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_RefreshInterface_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_RefreshInterface_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_RefreshInterface_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_RefreshInterface_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_RefreshInterface_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_RefreshInterface_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_RefreshInterface *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_REFRESHINTERFACE, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_RefreshInterface_state {
	struct wzcsvc_RefreshInterface orig;
	struct wzcsvc_RefreshInterface tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_RefreshInterface_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_RefreshInterface_send(TALLOC_CTX *mem_ctx,
						       struct tevent_context *ev,
						       struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_RefreshInterface_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_RefreshInterface_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_RefreshInterface_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_RefreshInterface_done, req);
	return req;
}

static void dcerpc_wzcsvc_RefreshInterface_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_RefreshInterface_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_RefreshInterface_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_RefreshInterface_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_RefreshInterface_recv(struct tevent_req *req,
					     TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_RefreshInterface_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_RefreshInterface_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_RefreshInterface(struct dcerpc_binding_handle *h,
					TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_RefreshInterface r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_RefreshInterface_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_QueryContext_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_QueryContext_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_QueryContext_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_QueryContext *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_QueryContext_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_QueryContext_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_QUERYCONTEXT, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_QueryContext_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_QueryContext_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_QueryContext_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_QueryContext_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_QueryContext_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_QueryContext_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_QueryContext *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_QUERYCONTEXT, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_QueryContext_state {
	struct wzcsvc_QueryContext orig;
	struct wzcsvc_QueryContext tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_QueryContext_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_QueryContext_send(TALLOC_CTX *mem_ctx,
						   struct tevent_context *ev,
						   struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_QueryContext_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_QueryContext_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_QueryContext_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_QueryContext_done, req);
	return req;
}

static void dcerpc_wzcsvc_QueryContext_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_QueryContext_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_QueryContext_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_QueryContext_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_QueryContext_recv(struct tevent_req *req,
					 TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_QueryContext_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_QueryContext_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_QueryContext(struct dcerpc_binding_handle *h,
				    TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_QueryContext r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_QueryContext_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_SetContext_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_SetContext_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_SetContext_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_SetContext *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_SetContext_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_SetContext_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_SETCONTEXT, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_SetContext_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_SetContext_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_SetContext_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_SetContext_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_SetContext_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_SetContext_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_SetContext *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_SETCONTEXT, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_SetContext_state {
	struct wzcsvc_SetContext orig;
	struct wzcsvc_SetContext tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_SetContext_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_SetContext_send(TALLOC_CTX *mem_ctx,
						 struct tevent_context *ev,
						 struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_SetContext_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_SetContext_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_SetContext_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_SetContext_done, req);
	return req;
}

static void dcerpc_wzcsvc_SetContext_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_SetContext_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_SetContext_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_SetContext_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_SetContext_recv(struct tevent_req *req,
				       TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_SetContext_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_SetContext_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_SetContext(struct dcerpc_binding_handle *h,
				  TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_SetContext r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_SetContext_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_EapolUIResponse_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolUIResponse_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolUIResponse_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_EapolUIResponse *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolUIResponse_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolUIResponse_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLUIRESPONSE, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolUIResponse_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_EapolUIResponse_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolUIResponse_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolUIResponse_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_EapolUIResponse_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolUIResponse_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_EapolUIResponse *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLUIRESPONSE, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_EapolUIResponse_state {
	struct wzcsvc_EapolUIResponse orig;
	struct wzcsvc_EapolUIResponse tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolUIResponse_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolUIResponse_send(TALLOC_CTX *mem_ctx,
						      struct tevent_context *ev,
						      struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolUIResponse_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolUIResponse_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_EapolUIResponse_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolUIResponse_done, req);
	return req;
}

static void dcerpc_wzcsvc_EapolUIResponse_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_EapolUIResponse_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolUIResponse_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_EapolUIResponse_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolUIResponse_recv(struct tevent_req *req,
					    TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolUIResponse_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolUIResponse_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolUIResponse(struct dcerpc_binding_handle *h,
				       TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_EapolUIResponse r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_EapolUIResponse_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_EapolGetCustomAuthData_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolGetCustomAuthData_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolGetCustomAuthData_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_EapolGetCustomAuthData *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolGetCustomAuthData_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolGetCustomAuthData_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLGETCUSTOMAUTHDATA, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolGetCustomAuthData_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_EapolGetCustomAuthData_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolGetCustomAuthData_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolGetCustomAuthData_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_EapolGetCustomAuthData_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolGetCustomAuthData_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_EapolGetCustomAuthData *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLGETCUSTOMAUTHDATA, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_EapolGetCustomAuthData_state {
	struct wzcsvc_EapolGetCustomAuthData orig;
	struct wzcsvc_EapolGetCustomAuthData tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolGetCustomAuthData_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolGetCustomAuthData_send(TALLOC_CTX *mem_ctx,
							     struct tevent_context *ev,
							     struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolGetCustomAuthData_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolGetCustomAuthData_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_EapolGetCustomAuthData_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolGetCustomAuthData_done, req);
	return req;
}

static void dcerpc_wzcsvc_EapolGetCustomAuthData_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_EapolGetCustomAuthData_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolGetCustomAuthData_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_EapolGetCustomAuthData_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolGetCustomAuthData_recv(struct tevent_req *req,
						   TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolGetCustomAuthData_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolGetCustomAuthData_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolGetCustomAuthData(struct dcerpc_binding_handle *h,
					      TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_EapolGetCustomAuthData r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_EapolGetCustomAuthData_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_EapolSetCustomAuthData_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolSetCustomAuthData_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolSetCustomAuthData_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_EapolSetCustomAuthData *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolSetCustomAuthData_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolSetCustomAuthData_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLSETCUSTOMAUTHDATA, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolSetCustomAuthData_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_EapolSetCustomAuthData_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolSetCustomAuthData_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolSetCustomAuthData_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_EapolSetCustomAuthData_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolSetCustomAuthData_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_EapolSetCustomAuthData *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLSETCUSTOMAUTHDATA, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_EapolSetCustomAuthData_state {
	struct wzcsvc_EapolSetCustomAuthData orig;
	struct wzcsvc_EapolSetCustomAuthData tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolSetCustomAuthData_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolSetCustomAuthData_send(TALLOC_CTX *mem_ctx,
							     struct tevent_context *ev,
							     struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolSetCustomAuthData_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolSetCustomAuthData_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_EapolSetCustomAuthData_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolSetCustomAuthData_done, req);
	return req;
}

static void dcerpc_wzcsvc_EapolSetCustomAuthData_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_EapolSetCustomAuthData_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolSetCustomAuthData_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_EapolSetCustomAuthData_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolSetCustomAuthData_recv(struct tevent_req *req,
						   TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolSetCustomAuthData_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolSetCustomAuthData_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolSetCustomAuthData(struct dcerpc_binding_handle *h,
					      TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_EapolSetCustomAuthData r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_EapolSetCustomAuthData_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_EapolGetInterfaceParams_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolGetInterfaceParams_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolGetInterfaceParams_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_EapolGetInterfaceParams *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolGetInterfaceParams_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolGetInterfaceParams_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLGETINTERFACEPARAMS, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolGetInterfaceParams_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_EapolGetInterfaceParams_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolGetInterfaceParams_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolGetInterfaceParams_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_EapolGetInterfaceParams_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolGetInterfaceParams_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_EapolGetInterfaceParams *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLGETINTERFACEPARAMS, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_EapolGetInterfaceParams_state {
	struct wzcsvc_EapolGetInterfaceParams orig;
	struct wzcsvc_EapolGetInterfaceParams tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolGetInterfaceParams_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolGetInterfaceParams_send(TALLOC_CTX *mem_ctx,
							      struct tevent_context *ev,
							      struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolGetInterfaceParams_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolGetInterfaceParams_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_EapolGetInterfaceParams_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolGetInterfaceParams_done, req);
	return req;
}

static void dcerpc_wzcsvc_EapolGetInterfaceParams_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_EapolGetInterfaceParams_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolGetInterfaceParams_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_EapolGetInterfaceParams_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolGetInterfaceParams_recv(struct tevent_req *req,
						    TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolGetInterfaceParams_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolGetInterfaceParams_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolGetInterfaceParams(struct dcerpc_binding_handle *h,
					       TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_EapolGetInterfaceParams r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_EapolGetInterfaceParams_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_EapolSetInterfaceParams_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolSetInterfaceParams_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolSetInterfaceParams_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_EapolSetInterfaceParams *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolSetInterfaceParams_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolSetInterfaceParams_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLSETINTERFACEPARAMS, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolSetInterfaceParams_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_EapolSetInterfaceParams_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolSetInterfaceParams_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolSetInterfaceParams_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_EapolSetInterfaceParams_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolSetInterfaceParams_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_EapolSetInterfaceParams *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLSETINTERFACEPARAMS, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_EapolSetInterfaceParams_state {
	struct wzcsvc_EapolSetInterfaceParams orig;
	struct wzcsvc_EapolSetInterfaceParams tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolSetInterfaceParams_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolSetInterfaceParams_send(TALLOC_CTX *mem_ctx,
							      struct tevent_context *ev,
							      struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolSetInterfaceParams_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolSetInterfaceParams_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_EapolSetInterfaceParams_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolSetInterfaceParams_done, req);
	return req;
}

static void dcerpc_wzcsvc_EapolSetInterfaceParams_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_EapolSetInterfaceParams_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolSetInterfaceParams_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_EapolSetInterfaceParams_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolSetInterfaceParams_recv(struct tevent_req *req,
						    TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolSetInterfaceParams_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolSetInterfaceParams_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolSetInterfaceParams(struct dcerpc_binding_handle *h,
					       TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_EapolSetInterfaceParams r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_EapolSetInterfaceParams_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_EapolReAuthenticateInterface_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolReAuthenticateInterface_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolReAuthenticateInterface_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_EapolReAuthenticateInterface *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolReAuthenticateInterface_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolReAuthenticateInterface_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLREAUTHENTICATEINTERFACE, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolReAuthenticateInterface_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_EapolReAuthenticateInterface_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolReAuthenticateInterface_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolReAuthenticateInterface_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_EapolReAuthenticateInterface_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolReAuthenticateInterface_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_EapolReAuthenticateInterface *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLREAUTHENTICATEINTERFACE, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_EapolReAuthenticateInterface_state {
	struct wzcsvc_EapolReAuthenticateInterface orig;
	struct wzcsvc_EapolReAuthenticateInterface tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolReAuthenticateInterface_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolReAuthenticateInterface_send(TALLOC_CTX *mem_ctx,
								   struct tevent_context *ev,
								   struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolReAuthenticateInterface_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolReAuthenticateInterface_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_EapolReAuthenticateInterface_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolReAuthenticateInterface_done, req);
	return req;
}

static void dcerpc_wzcsvc_EapolReAuthenticateInterface_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_EapolReAuthenticateInterface_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolReAuthenticateInterface_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_EapolReAuthenticateInterface_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolReAuthenticateInterface_recv(struct tevent_req *req,
							 TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolReAuthenticateInterface_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolReAuthenticateInterface_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolReAuthenticateInterface(struct dcerpc_binding_handle *h,
						    TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_EapolReAuthenticateInterface r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_EapolReAuthenticateInterface_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_EapolQueryInterfaceState_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolQueryInterfaceState_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolQueryInterfaceState_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_EapolQueryInterfaceState *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolQueryInterfaceState_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolQueryInterfaceState_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLQUERYINTERFACESTATE, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolQueryInterfaceState_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_EapolQueryInterfaceState_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolQueryInterfaceState_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolQueryInterfaceState_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_EapolQueryInterfaceState_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolQueryInterfaceState_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_EapolQueryInterfaceState *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_EAPOLQUERYINTERFACESTATE, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_EapolQueryInterfaceState_state {
	struct wzcsvc_EapolQueryInterfaceState orig;
	struct wzcsvc_EapolQueryInterfaceState tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EapolQueryInterfaceState_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EapolQueryInterfaceState_send(TALLOC_CTX *mem_ctx,
							       struct tevent_context *ev,
							       struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EapolQueryInterfaceState_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EapolQueryInterfaceState_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_EapolQueryInterfaceState_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EapolQueryInterfaceState_done, req);
	return req;
}

static void dcerpc_wzcsvc_EapolQueryInterfaceState_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_EapolQueryInterfaceState_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolQueryInterfaceState_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_EapolQueryInterfaceState_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EapolQueryInterfaceState_recv(struct tevent_req *req,
						     TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EapolQueryInterfaceState_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EapolQueryInterfaceState_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EapolQueryInterfaceState(struct dcerpc_binding_handle *h,
						TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_EapolQueryInterfaceState r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_EapolQueryInterfaceState_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_OpenWZCDbLogSession_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_OpenWZCDbLogSession_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_OpenWZCDbLogSession_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_OpenWZCDbLogSession *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_OpenWZCDbLogSession_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_OpenWZCDbLogSession_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_OPENWZCDBLOGSESSION, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_OpenWZCDbLogSession_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_OpenWZCDbLogSession_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_OpenWZCDbLogSession_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_OpenWZCDbLogSession_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_OpenWZCDbLogSession_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_OpenWZCDbLogSession_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_OpenWZCDbLogSession *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_OPENWZCDBLOGSESSION, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_OpenWZCDbLogSession_state {
	struct wzcsvc_OpenWZCDbLogSession orig;
	struct wzcsvc_OpenWZCDbLogSession tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_OpenWZCDbLogSession_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_OpenWZCDbLogSession_send(TALLOC_CTX *mem_ctx,
							  struct tevent_context *ev,
							  struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_OpenWZCDbLogSession_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_OpenWZCDbLogSession_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_OpenWZCDbLogSession_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_OpenWZCDbLogSession_done, req);
	return req;
}

static void dcerpc_wzcsvc_OpenWZCDbLogSession_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_OpenWZCDbLogSession_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_OpenWZCDbLogSession_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_OpenWZCDbLogSession_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_OpenWZCDbLogSession_recv(struct tevent_req *req,
						TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_OpenWZCDbLogSession_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_OpenWZCDbLogSession_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_OpenWZCDbLogSession(struct dcerpc_binding_handle *h,
					   TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_OpenWZCDbLogSession r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_OpenWZCDbLogSession_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_CloseWZCDbLogSession_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_CloseWZCDbLogSession_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_CloseWZCDbLogSession_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_CloseWZCDbLogSession *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_CloseWZCDbLogSession_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_CloseWZCDbLogSession_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_CLOSEWZCDBLOGSESSION, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_CloseWZCDbLogSession_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_CloseWZCDbLogSession_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_CloseWZCDbLogSession_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_CloseWZCDbLogSession_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_CloseWZCDbLogSession_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_CloseWZCDbLogSession_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_CloseWZCDbLogSession *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_CLOSEWZCDBLOGSESSION, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_CloseWZCDbLogSession_state {
	struct wzcsvc_CloseWZCDbLogSession orig;
	struct wzcsvc_CloseWZCDbLogSession tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_CloseWZCDbLogSession_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_CloseWZCDbLogSession_send(TALLOC_CTX *mem_ctx,
							   struct tevent_context *ev,
							   struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_CloseWZCDbLogSession_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_CloseWZCDbLogSession_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_CloseWZCDbLogSession_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_CloseWZCDbLogSession_done, req);
	return req;
}

static void dcerpc_wzcsvc_CloseWZCDbLogSession_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_CloseWZCDbLogSession_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_CloseWZCDbLogSession_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_CloseWZCDbLogSession_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_CloseWZCDbLogSession_recv(struct tevent_req *req,
						 TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_CloseWZCDbLogSession_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_CloseWZCDbLogSession_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_CloseWZCDbLogSession(struct dcerpc_binding_handle *h,
					    TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_CloseWZCDbLogSession r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_CloseWZCDbLogSession_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_EnumWZCDbLogRecords_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EnumWZCDbLogRecords_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EnumWZCDbLogRecords_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_EnumWZCDbLogRecords *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EnumWZCDbLogRecords_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EnumWZCDbLogRecords_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_ENUMWZCDBLOGRECORDS, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EnumWZCDbLogRecords_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_EnumWZCDbLogRecords_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EnumWZCDbLogRecords_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EnumWZCDbLogRecords_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_EnumWZCDbLogRecords_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EnumWZCDbLogRecords_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_EnumWZCDbLogRecords *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_ENUMWZCDBLOGRECORDS, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_EnumWZCDbLogRecords_state {
	struct wzcsvc_EnumWZCDbLogRecords orig;
	struct wzcsvc_EnumWZCDbLogRecords tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_EnumWZCDbLogRecords_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_EnumWZCDbLogRecords_send(TALLOC_CTX *mem_ctx,
							  struct tevent_context *ev,
							  struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_EnumWZCDbLogRecords_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_EnumWZCDbLogRecords_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_EnumWZCDbLogRecords_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_EnumWZCDbLogRecords_done, req);
	return req;
}

static void dcerpc_wzcsvc_EnumWZCDbLogRecords_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_EnumWZCDbLogRecords_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EnumWZCDbLogRecords_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_EnumWZCDbLogRecords_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_EnumWZCDbLogRecords_recv(struct tevent_req *req,
						TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_EnumWZCDbLogRecords_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_EnumWZCDbLogRecords_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_EnumWZCDbLogRecords(struct dcerpc_binding_handle *h,
					   TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_EnumWZCDbLogRecords r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_EnumWZCDbLogRecords_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_FlushWZCdbLog_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_FlushWZCdbLog_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_FlushWZCdbLog_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_FlushWZCdbLog *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_FlushWZCdbLog_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_FlushWZCdbLog_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_FLUSHWZCDBLOG, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_FlushWZCdbLog_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_FlushWZCdbLog_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_FlushWZCdbLog_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_FlushWZCdbLog_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_FlushWZCdbLog_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_FlushWZCdbLog_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_FlushWZCdbLog *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_FLUSHWZCDBLOG, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_FlushWZCdbLog_state {
	struct wzcsvc_FlushWZCdbLog orig;
	struct wzcsvc_FlushWZCdbLog tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_FlushWZCdbLog_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_FlushWZCdbLog_send(TALLOC_CTX *mem_ctx,
						    struct tevent_context *ev,
						    struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_FlushWZCdbLog_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_FlushWZCdbLog_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_FlushWZCdbLog_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_FlushWZCdbLog_done, req);
	return req;
}

static void dcerpc_wzcsvc_FlushWZCdbLog_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_FlushWZCdbLog_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_FlushWZCdbLog_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_FlushWZCdbLog_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_FlushWZCdbLog_recv(struct tevent_req *req,
					  TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_FlushWZCdbLog_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_FlushWZCdbLog_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_FlushWZCdbLog(struct dcerpc_binding_handle *h,
				     TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_FlushWZCdbLog r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_FlushWZCdbLog_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}

struct dcerpc_wzcsvc_GetWZCDbLogRecord_r_state {
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_GetWZCDbLogRecord_r_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_GetWZCDbLogRecord_r_send(TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct dcerpc_binding_handle *h,
	struct wzcsvc_GetWZCDbLogRecord *r)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_GetWZCDbLogRecord_r_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_GetWZCDbLogRecord_r_state);
	if (req == NULL) {
		return NULL;
	}

	state->out_mem_ctx = NULL;

	subreq = dcerpc_binding_handle_call_send(state, ev, h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_GETWZCDBLOGRECORD, state, r);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_GetWZCDbLogRecord_r_done, req);

	return req;
}

static void dcerpc_wzcsvc_GetWZCDbLogRecord_r_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	NTSTATUS status;

	status = dcerpc_binding_handle_call_recv(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_GetWZCDbLogRecord_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_GetWZCDbLogRecord_r_state *state =
		tevent_req_data(req,
		struct dcerpc_wzcsvc_GetWZCDbLogRecord_r_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_GetWZCDbLogRecord_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wzcsvc_GetWZCDbLogRecord *r)
{
	NTSTATUS status;

	status = dcerpc_binding_handle_call(h,
			NULL, &ndr_table_wzcsvc,
			NDR_WZCSVC_GETWZCDBLOGRECORD, mem_ctx, r);

	return status;
}

struct dcerpc_wzcsvc_GetWZCDbLogRecord_state {
	struct wzcsvc_GetWZCDbLogRecord orig;
	struct wzcsvc_GetWZCDbLogRecord tmp;
	TALLOC_CTX *out_mem_ctx;
};

static void dcerpc_wzcsvc_GetWZCDbLogRecord_done(struct tevent_req *subreq);

struct tevent_req *dcerpc_wzcsvc_GetWZCDbLogRecord_send(TALLOC_CTX *mem_ctx,
							struct tevent_context *ev,
							struct dcerpc_binding_handle *h)
{
	struct tevent_req *req;
	struct dcerpc_wzcsvc_GetWZCDbLogRecord_state *state;
	struct tevent_req *subreq;

	req = tevent_req_create(mem_ctx, &state,
				struct dcerpc_wzcsvc_GetWZCDbLogRecord_state);
	if (req == NULL) {
		return NULL;
	}
	state->out_mem_ctx = NULL;

	/* In parameters */

	/* Out parameters */

	/* make a temporary copy, that we pass to the dispatch function */
	state->tmp = state->orig;

	subreq = dcerpc_wzcsvc_GetWZCDbLogRecord_r_send(state, ev, h, &state->tmp);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, dcerpc_wzcsvc_GetWZCDbLogRecord_done, req);
	return req;
}

static void dcerpc_wzcsvc_GetWZCDbLogRecord_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct dcerpc_wzcsvc_GetWZCDbLogRecord_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_GetWZCDbLogRecord_state);
	NTSTATUS status;
	TALLOC_CTX *mem_ctx;

	if (state->out_mem_ctx) {
		mem_ctx = state->out_mem_ctx;
	} else {
		mem_ctx = state;
	}

	status = dcerpc_wzcsvc_GetWZCDbLogRecord_r_recv(subreq, mem_ctx);
	TALLOC_FREE(subreq);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	/* Copy out parameters */

	/* Reset temporary structure */
	ZERO_STRUCT(state->tmp);

	tevent_req_done(req);
}

NTSTATUS dcerpc_wzcsvc_GetWZCDbLogRecord_recv(struct tevent_req *req,
					      TALLOC_CTX *mem_ctx)
{
	struct dcerpc_wzcsvc_GetWZCDbLogRecord_state *state = tevent_req_data(
		req, struct dcerpc_wzcsvc_GetWZCDbLogRecord_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	/* Steal possible out parameters to the callers context */
	talloc_steal(mem_ctx, state->out_mem_ctx);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

NTSTATUS dcerpc_wzcsvc_GetWZCDbLogRecord(struct dcerpc_binding_handle *h,
					 TALLOC_CTX *mem_ctx)
{
	struct wzcsvc_GetWZCDbLogRecord r;
	NTSTATUS status;

	/* In parameters */

	status = dcerpc_wzcsvc_GetWZCDbLogRecord_r(h, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/* Return variables */

	/* Return result */

	return NT_STATUS_OK;
}