Merge branch 'master' of ssh://git.samba.org/data/git/samba

5 files changed, 227 insertions, 308 deletions

diff --git a/source3/lib/errmap_unix.c b/source3/lib/errmap_unix.c
index 9adb237096..bb09726ee0 100644
--- a/source3/lib/errmap_unix.c
+++ b/source3/lib/errmap_unix.c
@@ -95,6 +95,9 @@ const struct unix_error_map unix_dos_nt_errmap[] = {
 #ifdef ENOATTR
 	{ ENOATTR, ERRDOS, ERRbadfile, NT_STATUS_NOT_FOUND },
 #endif
+#ifdef ECANCELED
+	{ ECANCELED, ERRDOS, ERRbadfid, NT_STATUS_CANCELLED},
+#endif
 
 	{ 0, 0, 0, NT_STATUS_OK }
 };
diff --git a/source3/lib/interfaces.c b/source3/lib/interfaces.c
index 4567fe457b..2535418d99 100644
--- a/source3/lib/interfaces.c
+++ b/source3/lib/interfaces.c
@@ -18,79 +18,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-/* working out the interfaces for a OS is an incredibly non-portable
-   thing. We have several possible implementations below, and autoconf
-   tries each of them to see what works
-
-   Note that this file does _not_ include includes.h. That is so this code
-   can be called directly from the autoconf tests. That also means
-   this code cannot use any of the normal Samba debug stuff or defines.
-   This is standalone code.
-
-*/
-
-#ifndef AUTOCONF_TEST
-#include "config.h"
-#endif
-
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <netdb.h>
-#include <sys/ioctl.h>
-#include <netdb.h>
-#include <sys/ioctl.h>
-#include <sys/time.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
-#ifdef HAVE_IFADDRS_H
-#include <ifaddrs.h>
-#endif
-
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-
-#ifndef SIOCGIFCONF
-#ifdef HAVE_SYS_SOCKIO_H
-#include <sys/sockio.h>
-#endif
-#endif
-
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-
-#ifdef HAVE_STRINGS_H
-#include <strings.h>
-#endif
-
-#ifdef __COMPAR_FN_T
-#define QSORT_CAST (__compar_fn_t)
-#endif
-
-#ifndef QSORT_CAST
-#define QSORT_CAST (int (*)(const void *, const void *))
-#endif
-
-#ifdef HAVE_NET_IF_H
-#include <net/if.h>
-#endif
-
-#define SOCKET_WRAPPER_NOT_REPLACE
-#include "interfaces.h"
-#include "../replace/replace.h"
-
-/****************************************************************************
- Utility functions.
-****************************************************************************/
+#include "includes.h"
 
 /****************************************************************************
  Create a struct sockaddr_storage with the netmask bits set to 1.
diff --git a/source3/lib/smbconf/testsuite.c b/source3/lib/smbconf/testsuite.c
index b31dec0438..c83eeb805d 100644
--- a/source3/lib/smbconf/testsuite.c
+++ b/source3/lib/smbconf/testsuite.c
@@ -214,7 +214,7 @@ static bool torture_smbconf_txt(void)
 	printf("TEST: init\n");
 	werr = smbconf_init_txt(mem_ctx, &conf_ctx, filename);
 	if (!W_ERROR_IS_OK(werr)) {
-		printf("FAIL: text backend\[ failed: %s\n", win_errstr(werr));
+		printf("FAIL: text backend failed: %s\n", win_errstr(werr));
 		ret = false;
 		goto done;
 	}
diff --git a/source3/lib/wb_reqtrans.c b/source3/lib/wb_reqtrans.c
index 222b64667c..6ae1d1bb9b 100644
--- a/source3/lib/wb_reqtrans.c
+++ b/source3/lib/wb_reqtrans.c
@@ -25,11 +25,6 @@
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_WINBIND
 
-struct req_read_state {
-	struct winbindd_request *wb_req;
-	size_t max_extra_data;
-};
-
 bool async_req_is_wbcerr(struct async_req *req, wbcErr *pwbc_err)
 {
 	enum async_req_state state;
@@ -81,19 +76,60 @@ wbcErr async_req_simple_recv_wbcerr(struct async_req *req)
 	return WBC_ERR_SUCCESS;
 }
 
+bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err)
+{
+	enum tevent_req_state state;
+	uint64_t error;
+	if (!tevent_req_is_error(req, &state, &error)) {
+		*pwbc_err = WBC_ERR_SUCCESS;
+		return false;
+	}
+
+	switch (state) {
+	case TEVENT_REQ_USER_ERROR:
+		*pwbc_err = error;
+		break;
+	case TEVENT_REQ_TIMED_OUT:
+		*pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
+		break;
+	case TEVENT_REQ_NO_MEMORY:
+		*pwbc_err = WBC_ERR_NO_MEMORY;
+		break;
+	default:
+		*pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
+		break;
+	}
+	return true;
+}
+
+wbcErr tevent_req_simple_recv_wbcerr(struct tevent_req *req)
+{
+	wbcErr wbc_err;
+
+	if (tevent_req_is_wbcerr(req, &wbc_err)) {
+		return wbc_err;
+	}
+
+	return WBC_ERR_SUCCESS;
+}
+
+struct req_read_state {
+	struct winbindd_request *wb_req;
+	size_t max_extra_data;
+};
+
 static ssize_t wb_req_more(uint8_t *buf, size_t buflen, void *private_data);
 static void wb_req_read_done(struct tevent_req *subreq);
 
-struct async_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
-				   struct tevent_context *ev,
-				   int fd, size_t max_extra_data)
+struct tevent_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
+				    struct tevent_context *ev,
+				    int fd, size_t max_extra_data)
 {
-	struct async_req *result;
-	struct tevent_req *subreq;
+	struct tevent_req *result, *subreq;
 	struct req_read_state *state;
 
-	if (!async_req_setup(mem_ctx, &result, &state,
-			     struct req_read_state)) {
+	result = tevent_req_create(mem_ctx, &state, struct req_read_state);
+	if (result == NULL) {
 		return NULL;
 	}
 	state->max_extra_data = max_extra_data;
@@ -139,10 +175,10 @@ static ssize_t wb_req_more(uint8_t *buf, size_t buflen, void *private_data)
 
 static void wb_req_read_done(struct tevent_req *subreq)
 {
-	struct async_req *req =
-		tevent_req_callback_data(subreq, struct async_req);
-	struct req_read_state *state = talloc_get_type_abort(
-		req->private_data, struct req_read_state);
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct req_read_state *state = tevent_req_data(
+		req, struct req_read_state);
 	int err;
 	ssize_t ret;
 	uint8_t *buf;
@@ -150,7 +186,7 @@ static void wb_req_read_done(struct tevent_req *subreq)
 	ret = read_packet_recv(subreq, state, &buf, &err);
 	TALLOC_FREE(subreq);
 	if (ret == -1) {
-		async_req_error(req, map_wbc_err_from_errno(err));
+		tevent_req_error(req, map_wbc_err_from_errno(err));
 		return;
 	}
 
@@ -162,17 +198,17 @@ static void wb_req_read_done(struct tevent_req *subreq)
 	} else {
 		state->wb_req->extra_data.data = NULL;
 	}
-	async_req_done(req);
+	tevent_req_done(req);
 }
 
-wbcErr wb_req_read_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
+wbcErr wb_req_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 			struct winbindd_request **preq)
 {
-	struct req_read_state *state = talloc_get_type_abort(
-		req->private_data, struct req_read_state);
+	struct req_read_state *state = tevent_req_data(
+		req, struct req_read_state);
 	wbcErr wbc_err;
 
-	if (async_req_is_wbcerr(req, &wbc_err)) {
+	if (tevent_req_is_wbcerr(req, &wbc_err)) {
 		return wbc_err;
 	}
 	*preq = talloc_move(mem_ctx, &state->wb_req);
@@ -185,17 +221,17 @@ struct req_write_state {
 
 static void wb_req_write_done(struct tevent_req *subreq);
 
-struct async_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
-				    struct tevent_context *ev, int fd,
-				    struct winbindd_request *wb_req)
+struct tevent_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
+				     struct tevent_context *ev,
+				     struct tevent_queue *queue, int fd,
+				     struct winbindd_request *wb_req)
 {
-	struct async_req *result;
-	struct tevent_req *subreq;
+	struct tevent_req *result, *subreq;
 	struct req_write_state *state;
 	int count = 1;
 
-	if (!async_req_setup(mem_ctx, &result, &state,
-			     struct req_write_state)) {
+	result = tevent_req_create(mem_ctx, &state, struct req_write_state);
+	if (result == NULL) {
 		return NULL;
 	}
 
@@ -208,7 +244,7 @@ struct async_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
 		count = 2;
 	}
 
-	subreq = writev_send(state, ev, fd, state->iov, count);
+	subreq = writev_send(state, ev, queue, fd, state->iov, count);
 	if (subreq == NULL) {
 		goto fail;
 	}
@@ -222,23 +258,23 @@ struct async_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
 
 static void wb_req_write_done(struct tevent_req *subreq)
 {
-	struct async_req *req =
-		tevent_req_callback_data(subreq, struct async_req);
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
 	int err;
 	ssize_t ret;
 
 	ret = writev_recv(subreq, &err);
 	TALLOC_FREE(subreq);
 	if (ret < 0) {
-		async_req_error(req, map_wbc_err_from_errno(err));
+		tevent_req_error(req, map_wbc_err_from_errno(err));
 		return;
 	}
-	async_req_done(req);
+	tevent_req_done(req);
 }
 
-wbcErr wb_req_write_recv(struct async_req *req)
+wbcErr wb_req_write_recv(struct tevent_req *req)
 {
-	return async_req_simple_recv_wbcerr(req);
+	return tevent_req_simple_recv_wbcerr(req);
 }
 
 struct resp_read_state {
@@ -248,15 +284,14 @@ struct resp_read_state {
 static ssize_t wb_resp_more(uint8_t *buf, size_t buflen, void *private_data);
 static void wb_resp_read_done(struct tevent_req *subreq);
 
-struct async_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
-				    struct tevent_context *ev, int fd)
+struct tevent_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
+				     struct tevent_context *ev, int fd)
 {
-	struct async_req *result;
-	struct tevent_req *subreq;
+	struct tevent_req *result, *subreq;
 	struct resp_read_state *state;
 
-	if (!async_req_setup(mem_ctx, &result, &state,
-			     struct resp_read_state)) {
+	result = tevent_req_create(mem_ctx, &state, struct resp_read_state);
+	if (result == NULL) {
 		return NULL;
 	}
 
@@ -290,10 +325,10 @@ static ssize_t wb_resp_more(uint8_t *buf, size_t buflen, void *private_data)
 
 static void wb_resp_read_done(struct tevent_req *subreq)
 {
-	struct async_req *req =
-		tevent_req_callback_data(subreq, struct async_req);
-	struct resp_read_state *state = talloc_get_type_abort(
-		req->private_data, struct resp_read_state);
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct resp_read_state *state = tevent_req_data(
+		req, struct resp_read_state);
 	uint8_t *buf;
 	int err;
 	ssize_t ret;
@@ -301,7 +336,7 @@ static void wb_resp_read_done(struct tevent_req *subreq)
 	ret = read_packet_recv(subreq, state, &buf, &err);
 	TALLOC_FREE(subreq);
 	if (ret == -1) {
-		async_req_error(req, map_wbc_err_from_errno(err));
+		tevent_req_error(req, map_wbc_err_from_errno(err));
 		return;
 	}
 
@@ -313,17 +348,17 @@ static void wb_resp_read_done(struct tevent_req *subreq)
 	} else {
 		state->wb_resp->extra_data.data = NULL;
 	}
-	async_req_done(req);
+	tevent_req_done(req);
 }
 
-wbcErr wb_resp_read_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
+wbcErr wb_resp_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 			 struct winbindd_response **presp)
 {
-	struct resp_read_state *state = talloc_get_type_abort(
-		req->private_data, struct resp_read_state);
+	struct resp_read_state *state = tevent_req_data(
+		req, struct resp_read_state);
 	wbcErr wbc_err;
 
-	if (async_req_is_wbcerr(req, &wbc_err)) {
+	if (tevent_req_is_wbcerr(req, &wbc_err)) {
 		return wbc_err;
 	}
 	*presp = talloc_move(mem_ctx, &state->wb_resp);
@@ -336,17 +371,16 @@ struct resp_write_state {
 
 static void wb_resp_write_done(struct tevent_req *subreq);
 
-struct async_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
-				    struct tevent_context *ev, int fd,
-				    struct winbindd_response *wb_resp)
+struct tevent_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
+				      struct tevent_context *ev, int fd,
+				      struct winbindd_response *wb_resp)
 {
-	struct async_req *result;
-	struct tevent_req *subreq;
+	struct tevent_req *result, *subreq;
 	struct resp_write_state *state;
 	int count = 1;
 
-	if (!async_req_setup(mem_ctx, &result, &state,
-			     struct resp_write_state)) {
+	result = tevent_req_create(mem_ctx, &state, struct resp_write_state);
+	if (result == NULL) {
 		return NULL;
 	}
 
@@ -360,7 +394,7 @@ struct async_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
 		count = 2;
 	}
 
-	subreq = writev_send(state, ev, fd, state->iov, count);
+	subreq = writev_send(state, ev, NULL, fd, state->iov, count);
 	if (subreq == NULL) {
 		goto fail;
 	}
@@ -374,21 +408,21 @@ struct async_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
 
 static void wb_resp_write_done(struct tevent_req *subreq)
 {
-	struct async_req *req =
-		tevent_req_callback_data(subreq, struct async_req);
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
 	int err;
 	ssize_t ret;
 
 	ret = writev_recv(subreq, &err);
 	TALLOC_FREE(subreq);
 	if (ret < 0) {
-		async_req_error(req, map_wbc_err_from_errno(err));
+		tevent_req_error(req, map_wbc_err_from_errno(err));
 		return;
 	}
-	async_req_done(req);
+	tevent_req_done(req);
 }
 
-wbcErr wb_resp_write_recv(struct async_req *req)
+wbcErr wb_resp_write_recv(struct tevent_req *req)
 {
-	return async_req_simple_recv_wbcerr(req);
+	return tevent_req_simple_recv_wbcerr(req);
 }
diff --git a/source3/lib/wbclient.c b/source3/lib/wbclient.c
index 7034e668ed..80937641e6 100644
--- a/source3/lib/wbclient.c
+++ b/source3/lib/wbclient.c
@@ -153,21 +153,20 @@ struct wb_connect_state {
 
 static void wbc_connect_connected(struct tevent_req *subreq);
 
-static struct async_req *wb_connect_send(TALLOC_CTX *mem_ctx,
+static struct tevent_req *wb_connect_send(TALLOC_CTX *mem_ctx,
 					  struct tevent_context *ev,
 					  struct wb_context *wb_ctx,
 					  const char *dir)
 {
-	struct async_req *result;
-	struct tevent_req *subreq;
+	struct tevent_req *result, *subreq;
 	struct wb_connect_state *state;
 	struct sockaddr_un sunaddr;
 	struct stat st;
 	char *path = NULL;
 	wbcErr wbc_err;
 
-	if (!async_req_setup(mem_ctx, &result, &state,
-			     struct wb_connect_state)) {
+	result = tevent_req_create(mem_ctx, &state, struct wb_connect_state);
+	if (result == NULL) {
 		return NULL;
 	}
 
@@ -232,59 +231,32 @@ static struct async_req *wb_connect_send(TALLOC_CTX *mem_ctx,
 
 	return result;
 
- nomem:
-	wbc_err = WBC_ERR_NO_MEMORY;
  post_status:
-	if (async_post_error(result, ev, wbc_err)) {
-		return result;
-	}
+	tevent_req_error(result, wbc_err);
+	return tevent_req_post(result, ev);
+ nomem:
 	TALLOC_FREE(result);
 	return NULL;
 }
 
 static void wbc_connect_connected(struct tevent_req *subreq)
 {
-	struct async_req *req =
-		tevent_req_callback_data(subreq, struct async_req);
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
 	int res, err;
 
 	res = async_connect_recv(subreq, &err);
 	TALLOC_FREE(subreq);
 	if (res == -1) {
-		async_req_error(req, map_wbc_err_from_errno(err));
+		tevent_req_error(req, map_wbc_err_from_errno(err));
 		return;
 	}
-	async_req_done(req);
-}
-
-static wbcErr wb_connect_recv(struct async_req *req)
-{
-	return async_req_simple_recv_wbcerr(req);
+	tevent_req_done(req);
 }
 
-static struct winbindd_request *winbindd_request_copy(
-	TALLOC_CTX *mem_ctx,
-	const struct winbindd_request *req)
+static wbcErr wb_connect_recv(struct tevent_req *req)
 {
-	struct winbindd_request *result;
-
-	result = (struct winbindd_request *)TALLOC_MEMDUP(
-		mem_ctx, req, sizeof(struct winbindd_request));
-	if (result == NULL) {
-		return NULL;
-	}
-
-	if (result->extra_len == 0) {
-		return result;
-	}
-
-	result->extra_data.data = (char *)TALLOC_MEMDUP(
-		result, result->extra_data.data, result->extra_len);
-	if (result->extra_data.data == NULL) {
-		TALLOC_FREE(result);
-		return NULL;
-	}
-	return result;
+	return tevent_req_simple_recv_wbcerr(req);
 }
 
 struct wb_int_trans_state {
@@ -294,43 +266,40 @@ struct wb_int_trans_state {
 	struct winbindd_response *wb_resp;
 };
 
-static void wb_int_trans_write_done(struct async_req *subreq);
-static void wb_int_trans_read_done(struct async_req *subreq);
+static void wb_int_trans_write_done(struct tevent_req *subreq);
+static void wb_int_trans_read_done(struct tevent_req *subreq);
 
-static struct async_req *wb_int_trans_send(TALLOC_CTX *mem_ctx,
-					   struct tevent_context *ev, int fd,
-					   struct winbindd_request *wb_req)
+static struct tevent_req *wb_int_trans_send(TALLOC_CTX *mem_ctx,
+					    struct tevent_context *ev,
+					    struct tevent_queue *queue, int fd,
+					    struct winbindd_request *wb_req)
 {
-	struct async_req *result;
-	struct async_req *subreq;
+	struct tevent_req *result, *subreq;
 	struct wb_int_trans_state *state;
 
-	if (!async_req_setup(mem_ctx, &result, &state,
-			     struct wb_int_trans_state)) {
+	result = tevent_req_create(mem_ctx, &state,
+				   struct wb_int_trans_state);
+	if (result == NULL) {
 		return NULL;
 	}
 
 	if (winbind_closed_fd(fd)) {
-		if (!async_post_error(result, ev,
-				      WBC_ERR_WINBIND_NOT_AVAILABLE)) {
-			goto fail;
-		}
-		return result;
+		tevent_req_error(result, WBC_ERR_WINBIND_NOT_AVAILABLE);
+		return tevent_req_post(result, ev);
 	}
 
 	state->ev = ev;
 	state->fd = fd;
 	state->wb_req = wb_req;
-
 	state->wb_req->length = sizeof(struct winbindd_request);
 	state->wb_req->pid = getpid();
 
-	subreq = wb_req_write_send(state, state->ev, state->fd, state->wb_req);
+	subreq = wb_req_write_send(state, state->ev, queue, state->fd,
+				   state->wb_req);
 	if (subreq == NULL) {
 		goto fail;
 	}
-	subreq->async.fn = wb_int_trans_write_done;
-	subreq->async.priv = result;
+	tevent_req_set_callback(subreq, wb_int_trans_write_done, result);
 
 	return result;
 
@@ -339,56 +308,55 @@ static struct async_req *wb_int_trans_send(TALLOC_CTX *mem_ctx,
 	return NULL;
 }
 
-static void wb_int_trans_write_done(struct async_req *subreq)
+static void wb_int_trans_write_done(struct tevent_req *subreq)
 {
-	struct async_req *req = talloc_get_type_abort(
-		subreq->async.priv, struct async_req);
-	struct wb_int_trans_state *state = talloc_get_type_abort(
-		req->private_data, struct wb_int_trans_state);
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct wb_int_trans_state *state = tevent_req_data(
+		req, struct wb_int_trans_state);
 	wbcErr wbc_err;
 
 	wbc_err = wb_req_write_recv(subreq);
 	TALLOC_FREE(subreq);
 	if (!WBC_ERROR_IS_OK(wbc_err)) {
-		async_req_error(req, wbc_err);
+		tevent_req_error(req, wbc_err);
 		return;
 	}
 
 	subreq = wb_resp_read_send(state, state->ev, state->fd);
-	if (subreq == NULL) {
-		async_req_error(req, WBC_ERR_NO_MEMORY);
+	if (tevent_req_nomem(subreq, req)) {
+		return;
 	}
-	subreq->async.fn = wb_int_trans_read_done;
-	subreq->async.priv = req;
+	tevent_req_set_callback(subreq, wb_int_trans_read_done, req);
 }
 
-static void wb_int_trans_read_done(struct async_req *subreq)
+static void wb_int_trans_read_done(struct tevent_req *subreq)
 {
-	struct async_req *req = talloc_get_type_abort(
-		subreq->async.priv, struct async_req);
-	struct wb_int_trans_state *state = talloc_get_type_abort(
-		req->private_data, struct wb_int_trans_state);
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct wb_int_trans_state *state = tevent_req_data(
+		req, struct wb_int_trans_state);
 	wbcErr wbc_err;
 
 	wbc_err = wb_resp_read_recv(subreq, state, &state->wb_resp);
 	TALLOC_FREE(subreq);
 	if (!WBC_ERROR_IS_OK(wbc_err)) {
-		async_req_error(req, wbc_err);
+		tevent_req_error(req, wbc_err);
 		return;
 	}
 
-	async_req_done(req);
+	tevent_req_done(req);
 }
 
-static wbcErr wb_int_trans_recv(struct async_req *req,
+static wbcErr wb_int_trans_recv(struct tevent_req *req,
 				TALLOC_CTX *mem_ctx,
 				struct winbindd_response **presponse)
 {
-	struct wb_int_trans_state *state = talloc_get_type_abort(
-		req->private_data, struct wb_int_trans_state);
+	struct wb_int_trans_state *state = tevent_req_data(
+		req, struct wb_int_trans_state);
 	wbcErr wbc_err;
 
-	if (async_req_is_wbcerr(req, &wbc_err)) {
+	if (tevent_req_is_wbcerr(req, &wbc_err)) {
 		return wbc_err;
 	}
 
@@ -417,22 +385,21 @@ struct wb_open_pipe_state {
 	struct winbindd_request wb_req;
 };
 
-static void wb_open_pipe_connect_nonpriv_done(struct async_req *subreq);
-static void wb_open_pipe_ping_done(struct async_req *subreq);
-static void wb_open_pipe_getpriv_done(struct async_req *subreq);
-static void wb_open_pipe_connect_priv_done(struct async_req *subreq);
+static void wb_open_pipe_connect_nonpriv_done(struct tevent_req *subreq);
+static void wb_open_pipe_ping_done(struct tevent_req *subreq);
+static void wb_open_pipe_getpriv_done(struct tevent_req *subreq);
+static void wb_open_pipe_connect_priv_done(struct tevent_req *subreq);
 
-static struct async_req *wb_open_pipe_send(TALLOC_CTX *mem_ctx,
-					   struct tevent_context *ev,
-					   struct wb_context *wb_ctx,
-					   bool need_priv)
+static struct tevent_req *wb_open_pipe_send(TALLOC_CTX *mem_ctx,
+					    struct tevent_context *ev,
+					    struct wb_context *wb_ctx,
+					    bool need_priv)
 {
-	struct async_req *result;
-	struct async_req *subreq;
+	struct tevent_req *result, *subreq;
 	struct wb_open_pipe_state *state;
 
-	if (!async_req_setup(mem_ctx, &result, &state,
-			     struct wb_open_pipe_state)) {
+	result = tevent_req_create(mem_ctx, &state, struct wb_open_pipe_state);
+	if (result == NULL) {
 		return NULL;
 	}
 	state->wb_ctx = wb_ctx;
@@ -448,9 +415,8 @@ static struct async_req *wb_open_pipe_send(TALLOC_CTX *mem_ctx,
 	if (subreq == NULL) {
 		goto fail;
 	}
-
-	subreq->async.fn = wb_open_pipe_connect_nonpriv_done;
-	subreq->async.priv = result;
+	tevent_req_set_callback(subreq, wb_open_pipe_connect_nonpriv_done,
+				result);
 	return result;
 
  fail:
@@ -458,81 +424,77 @@ static struct async_req *wb_open_pipe_send(TALLOC_CTX *mem_ctx,
 	return NULL;
 }
 
-static void wb_open_pipe_connect_nonpriv_done(struct async_req *subreq)
+static void wb_open_pipe_connect_nonpriv_done(struct tevent_req *subreq)
 {
-	struct async_req *req = talloc_get_type_abort(
-		subreq->async.priv, struct async_req);
-	struct wb_open_pipe_state *state = talloc_get_type_abort(
-		req->private_data, struct wb_open_pipe_state);
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct wb_open_pipe_state *state = tevent_req_data(
+		req, struct wb_open_pipe_state);
 	wbcErr wbc_err;
 
 	wbc_err = wb_connect_recv(subreq);
 	TALLOC_FREE(subreq);
 	if (!WBC_ERROR_IS_OK(wbc_err)) {
 		state->wb_ctx->is_priv = true;
-		async_req_error(req, wbc_err);
+		tevent_req_error(req, wbc_err);
 		return;
 	}
 
 	ZERO_STRUCT(state->wb_req);
 	state->wb_req.cmd = WINBINDD_INTERFACE_VERSION;
 
-	subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->fd,
+	subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
 				   &state->wb_req);
-	if (async_req_nomem(subreq, req)) {
+	if (tevent_req_nomem(subreq, req)) {
 		return;
 	}
-
-	subreq->async.fn = wb_open_pipe_ping_done;
-	subreq->async.priv = req;
+	tevent_req_set_callback(subreq, wb_open_pipe_ping_done, req);
 }
 
-static void wb_open_pipe_ping_done(struct async_req *subreq)
+static void wb_open_pipe_ping_done(struct tevent_req *subreq)
 {
-	struct async_req *req = talloc_get_type_abort(
-		subreq->async.priv, struct async_req);
-	struct wb_open_pipe_state *state = talloc_get_type_abort(
-		req->private_data, struct wb_open_pipe_state);
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct wb_open_pipe_state *state = tevent_req_data(
+		req, struct wb_open_pipe_state);
 	struct winbindd_response *wb_resp;
 	wbcErr wbc_err;
 
 	wbc_err = wb_int_trans_recv(subreq, state, &wb_resp);
 	TALLOC_FREE(subreq);
 	if (!WBC_ERROR_IS_OK(wbc_err)) {
-		async_req_error(req, wbc_err);
+		tevent_req_error(req, wbc_err);
 		return;
 	}
 
 	if (!state->need_priv) {
-		async_req_done(req);
+		tevent_req_done(req);
 		return;
 	}
 
 	state->wb_req.cmd = WINBINDD_PRIV_PIPE_DIR;
 
-	subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->fd,
+	subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
 				   &state->wb_req);
-	if (async_req_nomem(subreq, req)) {
+	if (tevent_req_nomem(subreq, req)) {
 		return;
 	}
-
-	subreq->async.fn = wb_open_pipe_getpriv_done;
-	subreq->async.priv = req;
+	tevent_req_set_callback(subreq, wb_open_pipe_getpriv_done, req);
 }
 
-static void wb_open_pipe_getpriv_done(struct async_req *subreq)
+static void wb_open_pipe_getpriv_done(struct tevent_req *subreq)
 {
-	struct async_req *req = talloc_get_type_abort(
-		subreq->async.priv, struct async_req);
-	struct wb_open_pipe_state *state = talloc_get_type_abort(
-		req->private_data, struct wb_open_pipe_state);
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct wb_open_pipe_state *state = tevent_req_data(
+		req, struct wb_open_pipe_state);
 	struct winbindd_response *wb_resp = NULL;
 	wbcErr wbc_err;
 
 	wbc_err = wb_int_trans_recv(subreq, state, &wb_resp);
 	TALLOC_FREE(subreq);
 	if (!WBC_ERROR_IS_OK(wbc_err)) {
-		async_req_error(req, wbc_err);
+		tevent_req_error(req, wbc_err);
 		return;
 	}
 
@@ -540,37 +502,35 @@ static void wb_open_pipe_getpriv_done(struct async_req *subreq)
 	state->wb_ctx->fd = -1;
 
 	subreq = wb_connect_send(state, state->ev, state->wb_ctx,
-				 (char *)wb_resp->extra_data.data);
+				  (char *)wb_resp->extra_data.data);
 	TALLOC_FREE(wb_resp);
-	if (async_req_nomem(subreq, req)) {
+	if (tevent_req_nomem(subreq, req)) {
 		return;
 	}
-
-	subreq->async.fn = wb_open_pipe_connect_priv_done;
-	subreq->async.priv = req;
+	tevent_req_set_callback(subreq, wb_open_pipe_connect_priv_done, req);
 }
 
-static void wb_open_pipe_connect_priv_done(struct async_req *subreq)
+static void wb_open_pipe_connect_priv_done(struct tevent_req *subreq)
 {
-	struct async_req *req = talloc_get_type_abort(
-		subreq->async.priv, struct async_req);
-	struct wb_open_pipe_state *state = talloc_get_type_abort(
-		req->private_data, struct wb_open_pipe_state);
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct wb_open_pipe_state *state = tevent_req_data(
+		req, struct wb_open_pipe_state);
 	wbcErr wbc_err;
 
 	wbc_err = wb_connect_recv(subreq);
 	TALLOC_FREE(subreq);
 	if (!WBC_ERROR_IS_OK(wbc_err)) {
-		async_req_error(req, wbc_err);
+		tevent_req_error(req, wbc_err);
 		return;
 	}
 	state->wb_ctx->is_priv = true;
-	async_req_done(req);
+	tevent_req_done(req);
 }
 
-static wbcErr wb_open_pipe_recv(struct async_req *req)
+static wbcErr wb_open_pipe_recv(struct tevent_req *req)
 {
-	return async_req_simple_recv_wbcerr(req);
+	return tevent_req_simple_recv_wbcerr(req);
 }
 
 struct wb_trans_state {
@@ -583,15 +543,15 @@ struct wb_trans_state {
 	bool need_priv;
 };
 
-static void wb_trans_connect_done(struct async_req *subreq);
-static void wb_trans_done(struct async_req *subreq);
+static void wb_trans_connect_done(struct tevent_req *subreq);
+static void wb_trans_done(struct tevent_req *subreq);
 static void wb_trans_retry_wait_done(struct async_req *subreq);
 
 static void wb_trigger_trans(struct async_req *req)
 {
 	struct wb_trans_state *state = talloc_get_type_abort(
 		req->private_data, struct wb_trans_state);
-	struct async_req *subreq;
+	struct tevent_req *subreq;
 
 	if ((state->wb_ctx->fd == -1)
 	    || (state->need_priv && !state->wb_ctx->is_priv)) {
@@ -601,23 +561,21 @@ static void wb_trigger_trans(struct async_req *req)
 		if (async_req_nomem(subreq, req)) {
 			return;
 		}
-		subreq->async.fn = wb_trans_connect_done;
-		subreq->async.priv = req;
+		tevent_req_set_callback(subreq, wb_trans_connect_done, req);
 		return;
 	}
 
-	subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->fd,
+	subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
 				   state->wb_req);
 	if (async_req_nomem(subreq, req)) {
 		return;
 	}
-	subreq->async.fn = wb_trans_done;
-	subreq->async.priv = req;
+	tevent_req_set_callback(subreq, wb_trans_done, req);
 }
 
 struct async_req *wb_trans_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
 				struct wb_context *wb_ctx, bool need_priv,
-				const struct winbindd_request *wb_req)
+				struct winbindd_request *wb_req)
 {
 	struct async_req *result;
 	struct wb_trans_state *state;
@@ -628,10 +586,7 @@ struct async_req *wb_trans_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
 	}
 	state->wb_ctx = wb_ctx;
 	state->ev = ev;
-	state->wb_req = winbindd_request_copy(state, wb_req);
-	if (state->wb_req == NULL) {
-		goto fail;
-	}
+	state->wb_req = wb_req;
 	state->num_retries = 10;
 	state->need_priv = need_priv;
 
@@ -695,6 +650,7 @@ static void wb_trans_retry_wait_done(struct async_req *subreq)
 		subreq->async.priv, struct async_req);
 	struct wb_trans_state *state = talloc_get_type_abort(
 		req->private_data, struct wb_trans_state);
+	struct tevent_req *subreq2;
 	bool ret;
 
 	ret = async_wait_recv(subreq);
@@ -704,21 +660,21 @@ static void wb_trans_retry_wait_done(struct async_req *subreq)
 		return;
 	}
 
-	subreq = wb_open_pipe_send(state, state->ev, state->wb_ctx,
-				   state->need_priv);
-	if (async_req_nomem(subreq, req)) {
+	subreq2 = wb_open_pipe_send(state, state->ev, state->wb_ctx,
+				    state->need_priv);
+	if (async_req_nomem(subreq2, req)) {
 		return;
 	}
-	subreq->async.fn = wb_trans_connect_done;
-	subreq->async.priv = req;
+	tevent_req_set_callback(subreq2, wb_trans_connect_done, req);
 }
 
-static void wb_trans_connect_done(struct async_req *subreq)
+static void wb_trans_connect_done(struct tevent_req *subreq)
 {
-	struct async_req *req = talloc_get_type_abort(
-		subreq->async.priv, struct async_req);
+	struct async_req *req = tevent_req_callback_data(
+		subreq, struct async_req);
 	struct wb_trans_state *state = talloc_get_type_abort(
 		req->private_data, struct wb_trans_state);
+	struct tevent_req *subreq2;
 	wbcErr wbc_err;
 
 	wbc_err = wb_open_pipe_recv(subreq);
@@ -728,20 +684,18 @@ static void wb_trans_connect_done(struct async_req *subreq)
 		return;
 	}
 
-	subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->fd,
-				   state->wb_req);
-	if (async_req_nomem(subreq, req)) {
+	subreq2 = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
+				    state->wb_req);
+	if (async_req_nomem(subreq2, req)) {
 		return;
 	}
-
-	subreq->async.fn = wb_trans_done;
-	subreq->async.priv = req;
+	tevent_req_set_callback(subreq2, wb_trans_done, req);
 }
 
-static void wb_trans_done(struct async_req *subreq)
+static void wb_trans_done(struct tevent_req *subreq)
 {
-	struct async_req *req = talloc_get_type_abort(
-		subreq->async.priv, struct async_req);
+	struct async_req *req = tevent_req_callback_data(
+		subreq, struct async_req);
 	struct wb_trans_state *state = talloc_get_type_abort(
 		req->private_data, struct wb_trans_state);
 	wbcErr wbc_err;