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

17 files changed, 187 insertions, 275 deletions

diff --git a/lib/async_req/async_req.c b/lib/async_req/async_req.c
index 054c9f97cc..4dfe809738 100644
--- a/lib/async_req/async_req.c
+++ b/lib/async_req/async_req.c
@@ -194,48 +194,6 @@ bool async_req_is_error(struct async_req *req, enum async_req_state *state,
 	return true;
 }
 
-static void async_req_timedout(struct tevent_context *ev,
-			       struct tevent_timer *te,
-			       struct timeval now,
-			       void *priv)
-{
-	struct async_req *req = talloc_get_type_abort(priv, struct async_req);
-	TALLOC_FREE(te);
-	async_req_finish(req, ASYNC_REQ_TIMED_OUT);
-}
-
-bool async_req_set_timeout(struct async_req *req, struct tevent_context *ev,
-			   struct timeval to)
-{
-	return (tevent_add_timer(
-			ev, req,
-			tevent_timeval_current_ofs(to.tv_sec, to.tv_usec),
-			async_req_timedout, req)
-		!= NULL);
-}
-
-struct async_req *async_wait_send(TALLOC_CTX *mem_ctx,
-				  struct tevent_context *ev,
-				  struct timeval to)
-{
-	struct async_req *result;
-
-	result = async_req_new(mem_ctx);
-	if (result == NULL) {
-		return result;
-	}
-	if (!async_req_set_timeout(result, ev, to)) {
-		TALLOC_FREE(result);
-		return NULL;
-	}
-	return result;
-}
-
-bool async_wait_recv(struct async_req *req)
-{
-	return true;
-}
-
 struct async_queue_entry {
 	struct async_queue_entry *prev, *next;
 	struct async_req_queue *queue;
diff --git a/lib/async_req/async_req.h b/lib/async_req/async_req.h
index fc849880cd..fdec1b708e 100644
--- a/lib/async_req/async_req.h
+++ b/lib/async_req/async_req.h
@@ -139,15 +139,6 @@ bool async_post_error(struct async_req *req, struct tevent_context *ev,
 bool async_req_is_error(struct async_req *req, enum async_req_state *state,
 			uint64_t *error);
 
-bool async_req_set_timeout(struct async_req *req, struct tevent_context *ev,
-			   struct timeval to);
-
-struct async_req *async_wait_send(TALLOC_CTX *mem_ctx,
-				  struct tevent_context *ev,
-				  struct timeval to);
-
-bool async_wait_recv(struct async_req *req);
-
 struct async_req_queue;
 
 struct async_req_queue *async_req_queue_init(TALLOC_CTX *mem_ctx);
diff --git a/lib/replace/libreplace_network.m4 b/lib/replace/libreplace_network.m4
index 1dc1c44ed8..9223d94b75 100644
--- a/lib/replace/libreplace_network.m4
+++ b/lib/replace/libreplace_network.m4
@@ -242,7 +242,7 @@ AC_CHECK_MEMBERS([struct sockaddr.sa_len],
 
 dnl test for getifaddrs and freeifaddrs
 AC_CACHE_CHECK([for getifaddrs and freeifaddrs],libreplace_cv_HAVE_GETIFADDRS,[
-AC_TRY_COMPILE([
+AC_TRY_LINK([
 #include <sys/types.h>
 #if STDC_HEADERS
 #include <stdlib.h>
diff --git a/lib/talloc/configure.ac b/lib/talloc/configure.ac
index 39cea393ce..00e8242d4e 100644
--- a/lib/talloc/configure.ac
+++ b/lib/talloc/configure.ac
@@ -1,5 +1,5 @@
 AC_PREREQ(2.50)
-AC_INIT(talloc, 1.2.1)
+AC_INIT(talloc, 1.3.0)
 AC_CONFIG_SRCDIR([talloc.c])
 AC_SUBST(datarootdir)
 AC_CONFIG_HEADER(config.h)
diff --git a/lib/talloc/talloc.h b/lib/talloc/talloc.h
index b62393494b..5c8d5c5fe2 100644
--- a/lib/talloc/talloc.h
+++ b/lib/talloc/talloc.h
@@ -94,6 +94,7 @@ typedef void TALLOC_CTX;
 #define talloc_array(ctx, type, count) (type *)_talloc_array(ctx, sizeof(type), count, #type)
 #define talloc_array_size(ctx, size, count) _talloc_array(ctx, size, count, __location__)
 #define talloc_array_ptrtype(ctx, ptr, count) (_TALLOC_TYPEOF(ptr))talloc_array_size(ctx, sizeof(*(ptr)), count)
+#define talloc_array_length(ctx) ((ctx) ? talloc_get_size(ctx)/sizeof(*ctx) : 0)
 
 #define talloc_realloc(ctx, p, type, count) (type *)_talloc_realloc_array(ctx, p, sizeof(type), count, #type)
 #define talloc_realloc_size(ctx, ptr, size) _talloc_realloc(ctx, ptr, size, __location__)
@@ -115,6 +116,8 @@ typedef void TALLOC_CTX;
 #define talloc_append_string(c, s, a) (s?talloc_strdup_append(s,a):talloc_strdup(c, a))
 #endif
 
+#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
+
 /* The following definitions come from talloc.c  */
 void *_talloc(const void *context, size_t size);
 void *talloc_pool(const void *context, size_t size);
diff --git a/nsswitch/pam_winbind.h b/nsswitch/pam_winbind.h
index 0395a1fd5b..25d673e231 100644
--- a/nsswitch/pam_winbind.h
+++ b/nsswitch/pam_winbind.h
@@ -171,6 +171,8 @@ struct pwb_context {
 	uint32_t ctrl;
 };
 
+#ifndef TALLOC_FREE
 #define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
+#endif
 #define TALLOC_ZERO_P(ctx, type) (type *)_talloc_zero(ctx, sizeof(type), #type)
 #define TALLOC_P(ctx, type) (type *)talloc_named_const(ctx, sizeof(type), #type)
diff --git a/source3/configure.in b/source3/configure.in
index 98f41d61e5..70876b913e 100644
--- a/source3/configure.in
+++ b/source3/configure.in
@@ -31,7 +31,7 @@ if test "x$enable_external_libtalloc" != xno
 then
 	PKG_CHECK_MODULES(TALLOC, talloc >= 1.3.0, 
 		[ enable_external_libtalloc=yes ],
-		[ if x$enable_external_libtalloc = xyes; then 
+		[ if test x$enable_external_libtalloc = xyes; then
 		 	AC_MSG_ERROR([Unable to find libtalloc])
 	      else 
 			enable_external_libtalloc=no
diff --git a/source3/include/proto.h b/source3/include/proto.h
index f992f0686a..6016ae751b 100644
--- a/source3/include/proto.h
+++ b/source3/include/proto.h
@@ -1072,26 +1072,26 @@ const char *my_netbios_names(int i);
 bool set_netbios_aliases(const char **str_array);
 bool init_names(void);
 struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx);
-const char *get_cmdline_auth_info_username(struct user_auth_info *auth_info);
+const char *get_cmdline_auth_info_username(const struct user_auth_info *auth_info);
 void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
 				    const char *username);
 void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
 				    const char *password);
-const char *get_cmdline_auth_info_password(struct user_auth_info *auth_info);
+const char *get_cmdline_auth_info_password(const struct user_auth_info *auth_info);
 bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
 					 const char *arg);
-int get_cmdline_auth_info_signing_state(struct user_auth_info *auth_info);
+int get_cmdline_auth_info_signing_state(const struct user_auth_info *auth_info);
 void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
 					bool b);
-bool get_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info);
+bool get_cmdline_auth_info_use_kerberos(const struct user_auth_info *auth_info);
 void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info);
 void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info);
 void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info);
-bool get_cmdline_auth_info_got_pass(struct user_auth_info *auth_info);
-bool get_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info);
-bool get_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info);
+bool get_cmdline_auth_info_got_pass(const struct user_auth_info *auth_info);
+bool get_cmdline_auth_info_smb_encrypt(const struct user_auth_info *auth_info);
+bool get_cmdline_auth_info_use_machine_account(const struct user_auth_info *auth_info);
 struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
-						 struct user_auth_info *info);
+						 const struct user_auth_info *info);
 bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info);
 bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
 			     gid_t **gids, size_t *num_gids);
@@ -1396,13 +1396,13 @@ struct tevent_req *open_socket_out_send(TALLOC_CTX *mem_ctx,
 					uint16_t port,
 					int timeout);
 NTSTATUS open_socket_out_recv(struct tevent_req *req, int *pfd);
-struct async_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
-					     struct event_context *ev,
-					     struct timeval wait_time,
-					     const struct sockaddr_storage *pss,
-					     uint16_t port,
-					     int timeout);
-NTSTATUS open_socket_out_defer_recv(struct async_req *req, int *pfd);
+struct tevent_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
+					      struct event_context *ev,
+					      struct timeval wait_time,
+					      const struct sockaddr_storage *pss,
+					      uint16_t port,
+					      int timeout);
+NTSTATUS open_socket_out_defer_recv(struct tevent_req *req, int *pfd);
 bool open_any_socket_out(struct sockaddr_storage *addrs, int num_addrs,
 			 int timeout, int *fd_index, int *fd);
 int open_udp_socket(const char *host, int port);
diff --git a/source3/include/smb_macros.h b/source3/include/smb_macros.h
index fd1bba16a7..22cfaaf581 100644
--- a/source3/include/smb_macros.h
+++ b/source3/include/smb_macros.h
@@ -256,7 +256,9 @@ NULL returns on zero request. JRA.
 #define TALLOC_REALLOC(ctx, ptr, count) _talloc_realloc(ctx, ptr, count, __location__)
 #define TALLOC_REALLOC_ARRAY(ctx, ptr, type, count) (type *)_talloc_realloc_array(ctx, ptr, sizeof(type), count, #type)
 #define talloc_destroy(ctx) talloc_free(ctx)
+#ifndef TALLOC_FREE
 #define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
+#endif
 
 /* only define PARANOID_MALLOC_CHECKER with --enable-developer */
 
diff --git a/source3/include/wbc_async.h b/source3/include/wbc_async.h
index fd9b669710..eaec0d11da 100644
--- a/source3/include/wbc_async.h
+++ b/source3/include/wbc_async.h
@@ -22,23 +22,18 @@
 
 #include "nsswitch/libwbclient/wbclient.h"
 
-struct wb_context {
-	struct async_req_queue *queue;
-	int fd;
-	bool is_priv;
-};
+struct wb_context;
 
-struct async_req *wb_trans_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
-				struct wb_context *wb_ctx, bool need_priv,
-				struct winbindd_request *wb_req);
-wbcErr wb_trans_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
+struct tevent_req *wb_trans_send(TALLOC_CTX *mem_ctx,
+				 struct tevent_context *ev,
+				 struct wb_context *wb_ctx, bool need_priv,
+				 struct winbindd_request *wb_req);
+wbcErr wb_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 		     struct winbindd_response **presponse);
 struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx);
 
 /* Definitions from wb_reqtrans.c */
-bool async_req_is_wbcerr(struct async_req *req, wbcErr *pwbc_err);
 wbcErr map_wbc_err_from_errno(int error);
-wbcErr async_req_simple_recv_wbcerr(struct async_req *req);
 
 bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err);
 wbcErr tevent_req_simple_recv_wbcerr(struct tevent_req *req);
diff --git a/source3/lib/util.c b/source3/lib/util.c
index ec794ca74e..613cc1eae7 100644
--- a/source3/lib/util.c
+++ b/source3/lib/util.c
@@ -290,7 +290,7 @@ struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx)
 	return result;
 }
 
-const char *get_cmdline_auth_info_username(struct user_auth_info *auth_info)
+const char *get_cmdline_auth_info_username(const struct user_auth_info *auth_info)
 {
 	if (!auth_info->username) {
 		return "";
@@ -308,7 +308,7 @@ void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
 	}
 }
 
-const char *get_cmdline_auth_info_password(struct user_auth_info *auth_info)
+const char *get_cmdline_auth_info_password(const struct user_auth_info *auth_info)
 {
 	if (!auth_info->password) {
 		return "";
@@ -346,7 +346,7 @@ bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
 	return true;
 }
 
-int get_cmdline_auth_info_signing_state(struct user_auth_info *auth_info)
+int get_cmdline_auth_info_signing_state(const struct user_auth_info *auth_info)
 {
 	return auth_info->signing_state;
 }
@@ -357,7 +357,7 @@ void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
         auth_info->use_kerberos = b;
 }
 
-bool get_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info)
+bool get_cmdline_auth_info_use_kerberos(const struct user_auth_info *auth_info)
 {
 	return auth_info->use_kerberos;
 }
@@ -380,23 +380,23 @@ void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
 	auth_info->use_machine_account = true;
 }
 
-bool get_cmdline_auth_info_got_pass(struct user_auth_info *auth_info)
+bool get_cmdline_auth_info_got_pass(const struct user_auth_info *auth_info)
 {
 	return auth_info->got_pass;
 }
 
-bool get_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
+bool get_cmdline_auth_info_smb_encrypt(const struct user_auth_info *auth_info)
 {
 	return auth_info->smb_encrypt;
 }
 
-bool get_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
+bool get_cmdline_auth_info_use_machine_account(const struct user_auth_info *auth_info)
 {
 	return auth_info->use_machine_account;
 }
 
 struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
-						  struct user_auth_info *src)
+						  const struct user_auth_info *src)
 {
 	struct user_auth_info *result;
 
diff --git a/source3/lib/util_sock.c b/source3/lib/util_sock.c
index 3604be369f..de5b232aac 100644
--- a/source3/lib/util_sock.c
+++ b/source3/lib/util_sock.c
@@ -1152,22 +1152,22 @@ struct open_socket_out_defer_state {
 	int fd;
 };
 
-static void open_socket_out_defer_waited(struct async_req *subreq);
+static void open_socket_out_defer_waited(struct tevent_req *subreq);
 static void open_socket_out_defer_connected(struct tevent_req *subreq);
 
-struct async_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
-					     struct event_context *ev,
-					     struct timeval wait_time,
-					     const struct sockaddr_storage *pss,
-					     uint16_t port,
-					     int timeout)
+struct tevent_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
+					      struct event_context *ev,
+					      struct timeval wait_time,
+					      const struct sockaddr_storage *pss,
+					      uint16_t port,
+					      int timeout)
 {
-	struct async_req *result, *subreq;
+	struct tevent_req *req, *subreq;
 	struct open_socket_out_defer_state *state;
-	NTSTATUS status;
 
-	if (!async_req_setup(mem_ctx, &result, &state,
-			     struct open_socket_out_defer_state)) {
+	req = tevent_req_create(mem_ctx, &state,
+				struct open_socket_out_defer_state);
+	if (req == NULL) {
 		return NULL;
 	}
 	state->ev = ev;
@@ -1175,73 +1175,66 @@ struct async_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
 	state->port = port;
 	state->timeout = timeout;
 
-	subreq = async_wait_send(state, ev, wait_time);
+	subreq = tevent_wakeup_send(
+		state, ev,
+		timeval_current_ofs(wait_time.tv_sec, wait_time.tv_usec));
 	if (subreq == NULL) {
-		status = NT_STATUS_NO_MEMORY;
-		goto post_status;
-	}
-	subreq->async.fn = open_socket_out_defer_waited;
-	subreq->async.priv = result;
-	return result;
-
- post_status:
-	if (!async_post_ntstatus(result, ev, status)) {
 		goto fail;
 	}
-	return result;
+	tevent_req_set_callback(subreq, open_socket_out_defer_waited, req);
+	return req;
  fail:
-	TALLOC_FREE(result);
+	TALLOC_FREE(req);
 	return NULL;
 }
 
-static void open_socket_out_defer_waited(struct async_req *subreq)
+static void open_socket_out_defer_waited(struct tevent_req *subreq)
 {
-	struct async_req *req = talloc_get_type_abort(
-		subreq->async.priv, struct async_req);
-	struct open_socket_out_defer_state *state = talloc_get_type_abort(
-		req->private_data, struct open_socket_out_defer_state);
-	struct tevent_req *subreq2;
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct open_socket_out_defer_state *state = tevent_req_data(
+		req, struct open_socket_out_defer_state);
 	bool ret;
 
-	ret = async_wait_recv(subreq);
+	ret = tevent_wakeup_recv(subreq);
 	TALLOC_FREE(subreq);
 	if (!ret) {
-		async_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
+		tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
 		return;
 	}
 
-	subreq2 = open_socket_out_send(state, state->ev, &state->ss,
-				       state->port, state->timeout);
-	if (async_req_nomem(subreq2, req)) {
+	subreq = open_socket_out_send(state, state->ev, &state->ss,
+				      state->port, state->timeout);
+	if (tevent_req_nomem(subreq, req)) {
 		return;
 	}
-	tevent_req_set_callback(subreq2, open_socket_out_defer_connected, req);
+	tevent_req_set_callback(subreq, open_socket_out_defer_connected, req);
 }
 
 static void open_socket_out_defer_connected(struct tevent_req *subreq)
 {
-	struct async_req *req =
-		tevent_req_callback_data(subreq, struct async_req);
-	struct open_socket_out_defer_state *state = talloc_get_type_abort(
-		req->private_data, struct open_socket_out_defer_state);
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct open_socket_out_defer_state *state = tevent_req_data(
+		req, struct open_socket_out_defer_state);
 	NTSTATUS status;
 
 	status = open_socket_out_recv(subreq, &state->fd);
 	TALLOC_FREE(subreq);
 	if (!NT_STATUS_IS_OK(status)) {
-		async_req_nterror(req, status);
+		tevent_req_nterror(req, status);
 		return;
 	}
-	async_req_done(req);
+	tevent_req_done(req);
 }
 
-NTSTATUS open_socket_out_defer_recv(struct async_req *req, int *pfd)
+NTSTATUS open_socket_out_defer_recv(struct tevent_req *req, int *pfd)
 {
-	struct open_socket_out_defer_state *state = talloc_get_type_abort(
-		req->private_data, struct open_socket_out_defer_state);
+	struct open_socket_out_defer_state *state = tevent_req_data(
+		req, struct open_socket_out_defer_state);
 	NTSTATUS status;
 
-	if (async_req_is_nterror(req, &status)) {
+	if (tevent_req_is_nterror(req, &status)) {
 		return status;
 	}
 	*pfd = state->fd;
diff --git a/source3/lib/wb_reqtrans.c b/source3/lib/wb_reqtrans.c
index e1c67491c0..dbea8b6686 100644
--- a/source3/lib/wb_reqtrans.c
+++ b/source3/lib/wb_reqtrans.c
@@ -25,32 +25,6 @@
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_WINBIND
 
-bool async_req_is_wbcerr(struct async_req *req, wbcErr *pwbc_err)
-{
-	enum async_req_state state;
-	uint64_t error;
-	if (!async_req_is_error(req, &state, &error)) {
-		*pwbc_err = WBC_ERR_SUCCESS;
-		return false;
-	}
-
-	switch (state) {
-	case ASYNC_REQ_USER_ERROR:
-		*pwbc_err = error;
-		break;
-	case ASYNC_REQ_TIMED_OUT:
-		*pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
-		break;
-	case ASYNC_REQ_NO_MEMORY:
-		*pwbc_err = WBC_ERR_NO_MEMORY;
-		break;
-	default:
-		*pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
-		break;
-	}
-	return true;
-}
-
 wbcErr map_wbc_err_from_errno(int error)
 {
 	switch(error) {
@@ -65,17 +39,6 @@ wbcErr map_wbc_err_from_errno(int error)
 	}
 }
 
-wbcErr async_req_simple_recv_wbcerr(struct async_req *req)
-{
-	wbcErr wbc_err;
-
-	if (async_req_is_wbcerr(req, &wbc_err)) {
-		return wbc_err;
-	}
-
-	return WBC_ERR_SUCCESS;
-}
-
 bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err)
 {
 	enum tevent_req_state state;
diff --git a/source3/lib/wbclient.c b/source3/lib/wbclient.c
index 80937641e6..3cf992c7de 100644
--- a/source3/lib/wbclient.c
+++ b/source3/lib/wbclient.c
@@ -20,6 +20,12 @@
 #include "includes.h"
 #include "wbc_async.h"
 
+struct wb_context {
+	struct tevent_queue *queue;
+	int fd;
+	bool is_priv;
+};
+
 static int make_nonstd_fd(int fd)
 {
 	int i;
@@ -138,7 +144,7 @@ struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx)
 	if (result == NULL) {
 		return NULL;
 	}
-	result->queue = async_req_queue_init(result);
+	result->queue = tevent_queue_create(result, "wb_trans");
 	if (result->queue == NULL) {
 		TALLOC_FREE(result);
 		return NULL;
@@ -545,43 +551,18 @@ struct wb_trans_state {
 
 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_trans_retry_wait_done(struct tevent_req *subreq);
 
-static void wb_trigger_trans(struct async_req *req)
+struct tevent_req *wb_trans_send(TALLOC_CTX *mem_ctx,
+				 struct tevent_context *ev,
+				 struct wb_context *wb_ctx, bool need_priv,
+				 struct winbindd_request *wb_req)
 {
-	struct wb_trans_state *state = talloc_get_type_abort(
-		req->private_data, struct wb_trans_state);
-	struct tevent_req *subreq;
-
-	if ((state->wb_ctx->fd == -1)
-	    || (state->need_priv && !state->wb_ctx->is_priv)) {
-
-		subreq = wb_open_pipe_send(state, state->ev, state->wb_ctx,
-					   state->need_priv);
-		if (async_req_nomem(subreq, req)) {
-			return;
-		}
-		tevent_req_set_callback(subreq, wb_trans_connect_done, req);
-		return;
-	}
-
-	subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
-				   state->wb_req);
-	if (async_req_nomem(subreq, req)) {
-		return;
-	}
-	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,
-				struct winbindd_request *wb_req)
-{
-	struct async_req *result;
+	struct tevent_req *req, *subreq;
 	struct wb_trans_state *state;
 
-	if (!async_req_setup(mem_ctx, &result, &state,
-			     struct wb_trans_state)) {
+	req = tevent_req_create(mem_ctx, &state, struct wb_trans_state);
+	if (req == NULL) {
 		return NULL;
 	}
 	state->wb_ctx = wb_ctx;
@@ -590,21 +571,32 @@ struct async_req *wb_trans_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
 	state->num_retries = 10;
 	state->need_priv = need_priv;
 
-	if (!async_req_enqueue(wb_ctx->queue, ev, result, wb_trigger_trans)) {
-		goto fail;
+	if ((wb_ctx->fd == -1) || (need_priv && !wb_ctx->is_priv)) {
+		subreq = wb_open_pipe_send(state, ev, wb_ctx, need_priv);
+		if (subreq == NULL) {
+			goto fail;
+		}
+		tevent_req_set_callback(subreq, wb_trans_connect_done, req);
+		return req;
 	}
-	return result;
 
+	subreq = wb_int_trans_send(state, ev, wb_ctx->queue, wb_ctx->fd,
+				   wb_req);
+	if (subreq == NULL) {
+		goto fail;
+	}
+	tevent_req_set_callback(subreq, wb_trans_done, req);
+	return req;
  fail:
-	TALLOC_FREE(result);
+	TALLOC_FREE(req);
 	return NULL;
 }
 
-static bool wb_trans_retry(struct async_req *req,
+static bool wb_trans_retry(struct tevent_req *req,
 			   struct wb_trans_state *state,
 			   wbcErr wbc_err)
 {
-	struct async_req *subreq;
+	struct tevent_req *subreq;
 
 	if (WBC_ERROR_IS_OK(wbc_err)) {
 		return false;
@@ -615,13 +607,13 @@ static bool wb_trans_retry(struct async_req *req,
 		 * Winbind not around or we can't connect to the pipe. Fail
 		 * immediately.
 		 */
-		async_req_error(req, wbc_err);
+		tevent_req_error(req, wbc_err);
 		return true;
 	}
 
 	state->num_retries -= 1;
 	if (state->num_retries == 0) {
-		async_req_error(req, wbc_err);
+		tevent_req_error(req, wbc_err);
 		return true;
 	}
 
@@ -634,47 +626,44 @@ static bool wb_trans_retry(struct async_req *req,
 		state->wb_ctx->fd = -1;
 	}
 
-	subreq = async_wait_send(state, state->ev, timeval_set(1, 0));
-	if (async_req_nomem(subreq, req)) {
+	subreq = tevent_wakeup_send(state, state->ev,
+				    timeval_current_ofs(1, 0));
+	if (tevent_req_nomem(subreq, req)) {
 		return true;
 	}
-
-	subreq->async.fn = wb_trans_retry_wait_done;
-	subreq->async.priv = req;
+	tevent_req_set_callback(subreq, wb_trans_retry_wait_done, req);
 	return true;
 }
 
-static void wb_trans_retry_wait_done(struct async_req *subreq)
+static void wb_trans_retry_wait_done(struct tevent_req *subreq)
 {
-	struct async_req *req = talloc_get_type_abort(
-		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;
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct wb_trans_state *state = tevent_req_data(
+		req, struct wb_trans_state);
 	bool ret;
 
-	ret = async_wait_recv(subreq);
+	ret = tevent_wakeup_recv(subreq);
 	TALLOC_FREE(subreq);
-	if (ret) {
-		async_req_error(req, WBC_ERR_UNKNOWN_FAILURE);
+	if (!ret) {
+		tevent_req_error(req, WBC_ERR_UNKNOWN_FAILURE);
 		return;
 	}
 
-	subreq2 = wb_open_pipe_send(state, state->ev, state->wb_ctx,
-				    state->need_priv);
-	if (async_req_nomem(subreq2, req)) {
+	subreq = wb_open_pipe_send(state, state->ev, state->wb_ctx,
+				   state->need_priv);
+	if (tevent_req_nomem(subreq, req)) {
 		return;
 	}
-	tevent_req_set_callback(subreq2, wb_trans_connect_done, req);
+	tevent_req_set_callback(subreq, wb_trans_connect_done, req);
 }
 
 static void wb_trans_connect_done(struct tevent_req *subreq)
 {
-	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;
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct wb_trans_state *state = tevent_req_data(
+		req, struct wb_trans_state);
 	wbcErr wbc_err;
 
 	wbc_err = wb_open_pipe_recv(subreq);
@@ -684,20 +673,20 @@ static void wb_trans_connect_done(struct tevent_req *subreq)
 		return;
 	}
 
-	subreq2 = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
-				    state->wb_req);
-	if (async_req_nomem(subreq2, req)) {
+	subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
+				   state->wb_req);
+	if (tevent_req_nomem(subreq, req)) {
 		return;
 	}
-	tevent_req_set_callback(subreq2, wb_trans_done, req);
+	tevent_req_set_callback(subreq, wb_trans_done, req);
 }
 
 static void wb_trans_done(struct tevent_req *subreq)
 {
-	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 *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct wb_trans_state *state = tevent_req_data(
+		req, struct wb_trans_state);
 	wbcErr wbc_err;
 
 	wbc_err = wb_int_trans_recv(subreq, state, &state->wb_resp);
@@ -707,17 +696,17 @@ static void wb_trans_done(struct tevent_req *subreq)
 		return;
 	}
 
-	async_req_done(req);
+	tevent_req_done(req);
 }
 
-wbcErr wb_trans_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
+wbcErr wb_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 		     struct winbindd_response **presponse)
 {
-	struct wb_trans_state *state = talloc_get_type_abort(
-		req->private_data, struct wb_trans_state);
+	struct wb_trans_state *state = tevent_req_data(
+		req, struct wb_trans_state);
 	wbcErr wbc_err;
 
-	if (async_req_is_wbcerr(req, &wbc_err)) {
+	if (tevent_req_is_wbcerr(req, &wbc_err)) {
 		return wbc_err;
 	}
 
diff --git a/source3/libaddns/dns.h b/source3/libaddns/dns.h
index 57a9b6a002..a04a13bfd9 100644
--- a/source3/libaddns/dns.h
+++ b/source3/libaddns/dns.h
@@ -133,7 +133,9 @@ void *talloc_zeronull(const void *context, size_t size, const char *name);
 #define TALLOC_REALLOC(ctx, ptr, count) _talloc_realloc(ctx, ptr, count, __location__)
 #define TALLOC_REALLOC_ARRAY(ctx, ptr, type, count) (type *)_talloc_realloc_array(ctx, ptr, sizeof(type), count, #type)
 #define talloc_destroy(ctx) talloc_free(ctx)
+#ifndef TALLOC_FREE
 #define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
+#endif
 
 /*******************************************************************
    Type definitions for int16, int32, uint16 and uint32.  Needed
diff --git a/source3/libsmb/cliconnect.c b/source3/libsmb/cliconnect.c
index 43326e912c..ebb01c44a6 100644
--- a/source3/libsmb/cliconnect.c
+++ b/source3/libsmb/cliconnect.c
@@ -1785,15 +1785,20 @@ bool cli_session_request(struct cli_state *cli,
 	return(True);
 }
 
-static void smb_sock_connected(struct async_req *req)
+struct fd_struct {
+	int fd;
+};
+
+static void smb_sock_connected(struct tevent_req *req)
 {
-	int *pfd = (int *)req->async.priv;
+	struct fd_struct *pfd = tevent_req_callback_data(
+		req, struct fd_struct);
 	int fd;
 	NTSTATUS status;
 
 	status = open_socket_out_defer_recv(req, &fd);
 	if (NT_STATUS_IS_OK(status)) {
-		*pfd = fd;
+		pfd->fd = fd;
 	}
 }
 
@@ -1801,10 +1806,9 @@ static NTSTATUS open_smb_socket(const struct sockaddr_storage *pss,
 				uint16_t *port, int timeout, int *pfd)
 {
 	struct event_context *ev;
-	struct async_req *r139, *r445;
-	int fd139 = -1;
-	int fd445 = -1;
-	NTSTATUS status;
+	struct tevent_req *r139, *r445;
+	struct fd_struct *fd139, *fd445;
+	NTSTATUS status = NT_STATUS_NO_MEMORY;
 
 	if (*port != 0) {
 		return open_socket_out(pss, *port, timeout, pfd);
@@ -1815,43 +1819,54 @@ static NTSTATUS open_smb_socket(const struct sockaddr_storage *pss,
 		return NT_STATUS_NO_MEMORY;
 	}
 
+	fd139 = talloc(ev, struct fd_struct);
+	if (fd139 == NULL) {
+		goto done;
+	}
+	fd139->fd = -1;
+
+	fd445 = talloc(ev, struct fd_struct);
+	if (fd445 == NULL) {
+		goto done;
+	}
+	fd445->fd = -1;
+
 	r445 = open_socket_out_defer_send(ev, ev, timeval_set(0, 0),
 					  pss, 445, timeout);
 	r139 = open_socket_out_defer_send(ev, ev, timeval_set(0, 3000),
 					  pss, 139, timeout);
 	if ((r445 == NULL) || (r139 == NULL)) {
-		status = NT_STATUS_NO_MEMORY;
 		goto done;
 	}
-	r445->async.fn = smb_sock_connected;
-	r445->async.priv = &fd445;
-	r139->async.fn = smb_sock_connected;
-	r139->async.priv = &fd139;
+	tevent_req_set_callback(r445, smb_sock_connected, fd445);
+	tevent_req_set_callback(r139, smb_sock_connected, fd139);
 
-	while ((fd139 == -1) && (r139->state < ASYNC_REQ_DONE)
-	       && (fd445 == -1) && (r445->state < ASYNC_REQ_DONE)) {
+	while ((fd139->fd == -1)
+	       && tevent_req_is_in_progress(r139)
+	       && (fd445->fd == -1)
+	       && tevent_req_is_in_progress(r445)) {
 		event_loop_once(ev);
 	}
 
-	if ((fd139 != -1) && (fd445 != -1)) {
-		close(fd139);
-		fd139 = -1;
+	if ((fd139->fd != -1) && (fd445->fd != -1)) {
+		close(fd139->fd);
+		fd139->fd = -1;
 	}
 
-	if (fd445 != -1) {
+	if (fd445->fd != -1) {
 		*port = 445;
-		*pfd = fd445;
+		*pfd = fd445->fd;
 		status = NT_STATUS_OK;
 		goto done;
 	}
-	if (fd139 != -1) {
+	if (fd139->fd != -1) {
 		*port = 139;
-		*pfd = fd139;
+		*pfd = fd139->fd;
 		status = NT_STATUS_OK;
 		goto done;
 	}
 
-	status = open_socket_out_defer_recv(r445, &fd445);
+	status = open_socket_out_defer_recv(r445, &fd445->fd);
  done:
 	TALLOC_FREE(ev);
 	return status;
diff --git a/source3/torture/torture.c b/source3/torture/torture.c
index e2d1497b28..19849a84a8 100644
--- a/source3/torture/torture.c
+++ b/source3/torture/torture.c
@@ -5613,11 +5613,11 @@ static bool run_local_memcache(int dummy)
 	return ret;
 }
 
-static void wbclient_done(struct async_req *req)
+static void wbclient_done(struct tevent_req *req)
 {
 	wbcErr wbc_err;
 	struct winbindd_response *wb_resp;
-	int *i = (int *)req->async.priv;
+	int *i = (int *)tevent_req_callback_data_void(req);
 
 	wbc_err = wb_trans_recv(req, req, &wb_resp);
 	TALLOC_FREE(req);
@@ -5654,14 +5654,13 @@ static bool run_local_wbclient(int dummy)
 			goto fail;
 		}
 		for (j=0; j<5; j++) {
-			struct async_req *req;
+			struct tevent_req *req;
 			req = wb_trans_send(ev, ev, wb_ctx[i],
 					    (j % 2) == 0, &wb_req);
 			if (req == NULL) {
 				goto fail;
 			}
-			req->async.fn = wbclient_done;
-			req->async.priv = &i;
+			tevent_req_set_callback(req, wbclient_done, &i);
 		}
 	}