Merge branch 'master' of ssh://git.samba.org/data/git/samba into wspp-schema

18 files changed, 362 insertions, 363 deletions

diff --git a/lib/async_req/async_sock.c b/lib/async_req/async_sock.c
index 424da952eb..f803b9cc36 100644
--- a/lib/async_req/async_sock.c
+++ b/lib/async_req/async_sock.c
@@ -379,11 +379,13 @@ struct writev_state {
 	size_t total_size;
 };
 
+static void writev_trigger(struct tevent_req *req, void *private_data);
 static void writev_handler(struct tevent_context *ev, struct tevent_fd *fde,
 			   uint16_t flags, void *private_data);
 
 struct tevent_req *writev_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
-			       int fd, struct iovec *iov, int count)
+			       struct tevent_queue *queue, int fd,
+			       struct iovec *iov, int count)
 {
 	struct tevent_req *result;
 	struct writev_state *state;
@@ -403,18 +405,42 @@ struct tevent_req *writev_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
 		goto fail;
 	}
 
+	/*
+	 * This if () should go away once our callers are converted to always
+	 * pass in a queue.
+	 */
+
+	if (queue != NULL) {
+		if (!tevent_queue_add(queue, ev, result, writev_trigger,
+				      NULL)) {
+			goto fail;
+		}
+		return result;
+	}
+
 	fde = tevent_add_fd(ev, state, fd, TEVENT_FD_WRITE, writev_handler,
 			    result);
 	if (fde == NULL) {
 		goto fail;
 	}
 	return result;
-
  fail:
 	TALLOC_FREE(result);
 	return NULL;
 }
 
+static void writev_trigger(struct tevent_req *req, void *private_data)
+{
+	struct writev_state *state = tevent_req_data(req, struct writev_state);
+	struct tevent_fd *fde;
+
+	fde = tevent_add_fd(state->ev, state, state->fd, TEVENT_FD_WRITE,
+			    writev_handler, req);
+	if (fde == NULL) {
+		tevent_req_error(req, ENOMEM);
+	}
+}
+
 static void writev_handler(struct tevent_context *ev, struct tevent_fd *fde,
 			   uint16_t flags, void *private_data)
 {
diff --git a/lib/async_req/async_sock.h b/lib/async_req/async_sock.h
index e001709d27..c5d9400eb6 100644
--- a/lib/async_req/async_sock.h
+++ b/lib/async_req/async_sock.h
@@ -43,7 +43,8 @@ struct tevent_req *async_connect_send(TALLOC_CTX *mem_ctx,
 int async_connect_recv(struct tevent_req *req, int *perrno);
 
 struct tevent_req *writev_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
-			       int fd, struct iovec *iov, int count);
+			       struct tevent_queue *queue, int fd,
+			       struct iovec *iov, int count);
 ssize_t writev_recv(struct tevent_req *req, int *perrno);
 
 struct tevent_req *read_packet_send(TALLOC_CTX *mem_ctx,
diff --git a/lib/socket_wrapper/socket_wrapper.c b/lib/socket_wrapper/socket_wrapper.c
index 8ad9e1d93e..97e60468c4 100644
--- a/lib/socket_wrapper/socket_wrapper.c
+++ b/lib/socket_wrapper/socket_wrapper.c
@@ -149,11 +149,24 @@
 /*
  * FD00::5357:5FXX
  */
-static const struct in6_addr swrap_ipv6 =
-{ { {
-0xFD,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x53,0x57,0x5F,0x00
-} } };
+static const struct in6_addr *swrap_ipv6(void)
+{
+	static struct in6_addr v;
+	static int initialized;
+	int ret;
+
+	if (initialized) {
+		return &v;
+	}
+	initialized = 1;
+
+	ret = inet_pton(AF_INET6, "FD00::5357:5F00", &v);
+	if (ret <= 0) {
+		abort();
+	}
+
+	return &v;
+}
 #endif
 
 static struct sockaddr *sockaddr_dup(const void *data, socklen_t len)
@@ -202,6 +215,7 @@ struct socket_info
 	int bound;
 	int bcast;
 	int is_server;
+	int connected;
 
 	char *path;
 	char *tmp_path;
@@ -304,7 +318,7 @@ static int convert_un_in(const struct sockaddr_un *un, struct sockaddr *in, sock
 
 		memset(in2, 0, sizeof(*in2));
 		in2->sin6_family = AF_INET6;
-		in2->sin6_addr = swrap_ipv6;
+		in2->sin6_addr = *swrap_ipv6();
 		in2->sin6_addr.s6_addr[15] = iface;
 		in2->sin6_port = htons(prt);
 
@@ -394,7 +408,7 @@ static int convert_in_un_remote(struct socket_info *si, const struct sockaddr *i
 
 		cmp = in->sin6_addr;
 		cmp.s6_addr[15] = 0;
-		if (IN6_ARE_ADDR_EQUAL(&swrap_ipv6, &cmp)) {
+		if (IN6_ARE_ADDR_EQUAL(swrap_ipv6(), &cmp)) {
 			iface = in->sin6_addr.s6_addr[15];
 		} else {
 			errno = ENETUNREACH;
@@ -510,7 +524,9 @@ static int convert_in_un_alloc(struct socket_info *si, const struct sockaddr *in
 
 		cmp = in->sin6_addr;
 		cmp.s6_addr[15] = 0;
-		if (IN6_ARE_ADDR_EQUAL(&swrap_ipv6, &cmp)) {
+		if (IN6_IS_ADDR_UNSPECIFIED(&in->sin6_addr)) {
+			iface = socket_wrapper_default_iface();
+		} else if (IN6_ARE_ADDR_EQUAL(swrap_ipv6(), &cmp)) {
 			iface = in->sin6_addr.s6_addr[15];
 		} else {
 			errno = EADDRNOTAVAIL;
@@ -1485,6 +1501,7 @@ _PUBLIC_ int swrap_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
 	child_si->protocol = parent_si->protocol;
 	child_si->bound = 1;
 	child_si->is_server = 1;
+	child_si->connected = 1;
 
 	child_si->peername_len = len;
 	child_si->peername = sockaddr_dup(my_addr, len);
@@ -1532,8 +1549,10 @@ static int autobind_start;
 /* using sendto() or connect() on an unbound socket would give the
    recipient no way to reply, as unlike UDP and TCP, a unix domain
    socket can't auto-assign emphemeral port numbers, so we need to
-   assign it here */
-static int swrap_auto_bind(struct socket_info *si)
+   assign it here.
+   Note: this might change the family from ipv6 to ipv4
+*/
+static int swrap_auto_bind(struct socket_info *si, int family)
 {
 	struct sockaddr_un un_addr;
 	int i;
@@ -1551,7 +1570,7 @@ static int swrap_auto_bind(struct socket_info *si)
 
 	un_addr.sun_family = AF_UNIX;
 
-	switch (si->family) {
+	switch (family) {
 	case AF_INET: {
 		struct sockaddr_in in;
 
@@ -1580,6 +1599,11 @@ static int swrap_auto_bind(struct socket_info *si)
 	case AF_INET6: {
 		struct sockaddr_in6 in6;
 
+		if (si->family != family) {
+			errno = ENETUNREACH;
+			return -1;
+		}
+
 		switch (si->type) {
 		case SOCK_STREAM:
 			type = SOCKET_TYPE_CHAR_TCP_V6;
@@ -1594,7 +1618,7 @@ static int swrap_auto_bind(struct socket_info *si)
 
 		memset(&in6, 0, sizeof(in6));
 		in6.sin6_family = AF_INET6;
-		in6.sin6_addr = swrap_ipv6;
+		in6.sin6_addr = *swrap_ipv6();
 		in6.sin6_addr.s6_addr[15] = socket_wrapper_default_iface();
 		si->myname_len = sizeof(in6);
 		si->myname = sockaddr_dup(&in6, si->myname_len);
@@ -1630,6 +1654,7 @@ static int swrap_auto_bind(struct socket_info *si)
 		return -1;
 	}
 
+	si->family = family;
 	set_port(si->family, port, si->myname);
 
 	return 0;
@@ -1647,7 +1672,7 @@ _PUBLIC_ int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t ad
 	}
 
 	if (si->bound == 0) {
-		ret = swrap_auto_bind(si);
+		ret = swrap_auto_bind(si, serv_addr->sa_family);
 		if (ret == -1) return -1;
 	}
 
@@ -1672,7 +1697,14 @@ _PUBLIC_ int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t ad
 	if (ret == 0) {
 		si->peername_len = addrlen;
 		si->peername = sockaddr_dup(serv_addr, addrlen);
+		si->connected = 1;
+	}
 
+	if (si->type != SOCK_STREAM) {
+		return ret;
+	}
+
+	if (ret == 0) {
 		swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_RECV, NULL, 0);
 		swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_ACK, NULL, 0);
 	} else {
@@ -1801,11 +1833,18 @@ _PUBLIC_ ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct
 	socklen_t un_addrlen = sizeof(un_addr);
 	int ret;
 	struct socket_info *si = find_socket_info(s);
+	struct sockaddr_storage ss;
+	socklen_t ss_len = sizeof(ss);
 
 	if (!si) {
 		return real_recvfrom(s, buf, len, flags, from, fromlen);
 	}
 
+	if (!from) {
+		from = (struct sockaddr *)&ss;
+		fromlen = &ss_len;
+	}
+
 	len = MIN(len, 1500);
 
 	/* irix 6.4 forgets to null terminate the sun_path string :-( */
@@ -1836,6 +1875,16 @@ _PUBLIC_ ssize_t swrap_sendto(int s, const void *buf, size_t len, int flags, con
 		return real_sendto(s, buf, len, flags, to, tolen);
 	}
 
+	if (si->connected) {
+		if (to) {
+			errno = EISCONN;
+			return -1;
+		}
+
+		to = si->peername;
+		tolen = si->peername_len;
+	}
+
 	len = MIN(len, 1500);
 
 	switch (si->type) {
@@ -1844,7 +1893,7 @@ _PUBLIC_ ssize_t swrap_sendto(int s, const void *buf, size_t len, int flags, con
 		break;
 	case SOCK_DGRAM:
 		if (si->bound == 0) {
-			ret = swrap_auto_bind(si);
+			ret = swrap_auto_bind(si, si->family);
 			if (ret == -1) return -1;
 		}
 		
diff --git a/lib/util/charset/charcnv.c b/lib/util/charset/charcnv.c
index 258730ec82..94d47a9f7f 100644
--- a/lib/util/charset/charcnv.c
+++ b/lib/util/charset/charcnv.c
@@ -169,9 +169,10 @@ static smb_iconv_t get_conv_handle(struct smb_iconv_convenience *ic,
 _PUBLIC_ ssize_t iconv_talloc(TALLOC_CTX *ctx, 
 				       smb_iconv_t cd,
 				       void const *src, size_t srclen, 
-				       void **dest)
+				       void *dst)
 {
 	size_t i_len, o_len, destlen;
+	void **dest = (void **)dst;
 	size_t retval;
 	const char *inbuf = (const char *)src;
 	char *outbuf, *ob;
@@ -314,9 +315,10 @@ _PUBLIC_ bool convert_string_talloc_convenience(TALLOC_CTX *ctx,
 				       struct smb_iconv_convenience *ic, 
 				       charset_t from, charset_t to, 
 				       void const *src, size_t srclen, 
-				       void **dest, size_t *converted_size, 
+				       void *dst, size_t *converted_size, 
 					   bool allow_badcharcnv)
 {
+	void **dest = (void **)dst;
 	smb_iconv_t descriptor;
 	ssize_t ret;
 
diff --git a/lib/util/charset/charset.h b/lib/util/charset/charset.h
index 655bae7bcd..37c5acafaf 100644
--- a/lib/util/charset/charset.h
+++ b/lib/util/charset/charset.h
@@ -136,7 +136,7 @@ ssize_t pull_string(char *dest, const void *src, size_t dest_len, size_t src_len
 bool convert_string_talloc(TALLOC_CTX *ctx, 
 				       charset_t from, charset_t to, 
 				       void const *src, size_t srclen, 
-				       void **dest, size_t *converted_size, 
+				       void *dest, size_t *converted_size, 
 					   bool allow_badcharcnv);
 
 size_t convert_string(charset_t from, charset_t to,
@@ -146,7 +146,7 @@ size_t convert_string(charset_t from, charset_t to,
 ssize_t iconv_talloc(TALLOC_CTX *mem_ctx, 
 				       smb_iconv_t cd,
 				       void const *src, size_t srclen, 
-				       void **dest);
+				       void *dest);
 
 extern struct smb_iconv_convenience *global_iconv_convenience;
 
@@ -176,7 +176,7 @@ bool convert_string_talloc_convenience(TALLOC_CTX *ctx,
 				       struct smb_iconv_convenience *ic, 
 				       charset_t from, charset_t to, 
 				       void const *src, size_t srclen, 
-				       void **dest, size_t *converted_size, bool allow_badcharcnv);
+				       void *dest, size_t *converted_size, bool allow_badcharcnv);
 /* iconv */
 smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode);
 int smb_iconv_close(smb_iconv_t cd);
diff --git a/lib/util/charset/util_unistr.c b/lib/util/charset/util_unistr.c
index ec88e784d0..ea2bfeab9f 100644
--- a/lib/util/charset/util_unistr.c
+++ b/lib/util/charset/util_unistr.c
@@ -978,7 +978,7 @@ _PUBLIC_ size_t convert_string(charset_t from, charset_t to,
 _PUBLIC_ bool convert_string_talloc(TALLOC_CTX *ctx, 
 				       charset_t from, charset_t to, 
 				       void const *src, size_t srclen, 
-				       void **dest, size_t *converted_size, 
+				       void *dest, size_t *converted_size, 
 					   bool allow_badcharcnv)
 {
 	return convert_string_talloc_convenience(ctx, get_iconv_convenience(),
diff --git a/packaging/RHEL/samba.spec.tmpl b/packaging/RHEL/samba.spec.tmpl
index f674e8386c..94794ccfd0 100644
--- a/packaging/RHEL/samba.spec.tmpl
+++ b/packaging/RHEL/samba.spec.tmpl
@@ -348,6 +348,7 @@ fi
 %{_mandir}/man1/vfstest.1*
 %{_mandir}/man5/smbpasswd.5*
 %{_mandir}/man7/samba.7*
+%{_mandir}/man7/winbind_krb5_locator.7*
 %{_mandir}/man8/nmbd.8*
 %{_mandir}/man8/pdbedit.8*
 %{_mandir}/man8/smbd.8*
@@ -396,6 +397,7 @@ fi
 
 %{_bindir}/rpcclient
 %{_bindir}/smbcacls
+%{_bindir}/sharesec
 %{_bindir}/findsmb
 %{_bindir}/smbcquotas
 %{_bindir}/nmblookup
@@ -417,6 +419,7 @@ fi
 %{_mandir}/man1/nmblookup.1*
 %{_mandir}/man1/rpcclient.1*
 %{_mandir}/man1/smbcacls.1*
+%{_mandir}/man1/sharesec.1*
 %{_mandir}/man1/smbclient.1*
 %{_mandir}/man1/smbtar.1*
 %{_mandir}/man1/smbtree.1*
@@ -437,6 +440,7 @@ fi
 %attr(755,root,root) /%{_libarch}/libnss_winbind.so*
 %attr(755,root,root) /%{_libarch}/security/pam_winbind.so
 %attr(755,root,root) /%{_libarch}/security/pam_smbpass.so
+/usr/share/locale/de/LC_MESSAGES/pam_winbind.mo
 
 %{_includedir}/libsmbclient.h
 %{_libarchdir}/libsmbclient.*
@@ -464,6 +468,7 @@ fi
 %{_bindir}/ldbdel
 %{_bindir}/ldbedit
 %{_bindir}/ldbmodify
+%{_bindir}/ldbrename
 %{_bindir}/ldbsearch
 
 %{_mandir}/man1/profiles.1*
@@ -478,6 +483,7 @@ fi
 %{_mandir}/man1/ldbdel.1*
 %{_mandir}/man1/ldbedit.1*
 %{_mandir}/man1/ldbmodify.1*
+%{_mandir}/man1/ldbrename.1*
 %{_mandir}/man1/ldbsearch.1*
 
 %changelog
diff --git a/packaging/bin/fill-templates b/packaging/bin/fill-templates
index 204003c53b..cbd49337ed 100755
--- a/packaging/bin/fill-templates
+++ b/packaging/bin/fill-templates
@@ -4,7 +4,7 @@
 # information that is created by mkversion in advance.
 #
 # This is a standalone wrapper for update-pkginfo, which
-# is ususally called from release-scripts/create-tarball.
+# is usually called from release-scripts/create-tarball.
 # This allows for testing some aspects of packaging without
 # the need to go through all of create-tarball.
 #
diff --git a/source3/include/client.h b/source3/include/client.h
index d62d1c05d2..646d54aa05 100644
--- a/source3/include/client.h
+++ b/source3/include/client.h
@@ -104,7 +104,7 @@ struct rpc_cli_transport {
 					uint32_t max_rdata_len,
 					void *priv);
 	/**
-	 * Get the result from the read_send operation.
+	 * Get the result from the trans_send operation.
 	 */
 	NTSTATUS (*trans_recv)(struct async_req *req, TALLOC_CTX *mem_ctx,
 			       uint8_t **prdata, uint32_t *prdata_len);
diff --git a/source3/include/proto.h b/source3/include/proto.h
index b6ddacca75..a1cafb6837 100644
--- a/source3/include/proto.h
+++ b/source3/include/proto.h
@@ -347,9 +347,6 @@ size_t convert_string(charset_t from, charset_t to,
 bool convert_string_allocate(TALLOC_CTX *ctx, charset_t from, charset_t to,
 			     void const *src, size_t srclen, void *dst,
 			     size_t *converted_size, bool allow_bad_conv);
-bool convert_string_talloc(TALLOC_CTX *ctx, charset_t from, charset_t to,
-			   void const *src, size_t srclen, void **dst,
-			   size_t *converted_size, bool allow_bad_conv);
 size_t unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen);
 char *strdup_upper(const char *s);
 char *talloc_strdup_upper(TALLOC_CTX *ctx, const char *s);
diff --git a/source3/include/wbc_async.h b/source3/include/wbc_async.h
index 7a8768029a..b5e769f8c3 100644
--- a/source3/include/wbc_async.h
+++ b/source3/include/wbc_async.h
@@ -30,7 +30,7 @@ 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,
-				const struct winbindd_request *wb_req);
+				struct winbindd_request *wb_req);
 wbcErr wb_trans_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
 		     struct winbindd_response **presponse);
 struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx);
@@ -40,29 +40,29 @@ 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);
 
-struct async_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
-				   struct tevent_context *ev,
-				   int fd, size_t max_extra_data);
+bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err);
+wbcErr tevent_req_simple_recv_wbcerr(struct tevent_req *req);
 
-wbcErr wb_req_read_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
+struct tevent_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
+				    struct tevent_context *ev,
+				    int fd, size_t max_extra_data);
+wbcErr wb_req_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 			struct winbindd_request **preq);
 
-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);
+wbcErr wb_req_write_recv(struct tevent_req *req);
 
-wbcErr wb_req_write_recv(struct async_req *req);
-
-struct async_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
-				    struct tevent_context *ev, int fd);
-
-wbcErr wb_resp_read_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
+struct tevent_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
+				     struct tevent_context *ev, int fd);
+wbcErr wb_resp_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 			 struct winbindd_response **presp);
 
-struct async_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
-				    struct tevent_context *ev, int fd,
-				    struct winbindd_response *wb_resp);
-
-wbcErr wb_resp_write_recv(struct async_req *req);
+struct tevent_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
+				      struct tevent_context *ev, int fd,
+				      struct winbindd_response *wb_resp);
+wbcErr wb_resp_write_recv(struct tevent_req *req);
 
 #endif /*_WBC_ASYNC_H_*/
diff --git a/source3/lib/charcnv.c b/source3/lib/charcnv.c
index 81cb9a5094..c3b345142f 100644
--- a/source3/lib/charcnv.c
+++ b/source3/lib/charcnv.c
@@ -763,7 +763,7 @@ bool convert_string_allocate(TALLOC_CTX *ctx, charset_t from, charset_t to,
  * converted.
  */
 bool convert_string_talloc(TALLOC_CTX *ctx, charset_t from, charset_t to,
-			   void const *src, size_t srclen, void **dst,
+			   void const *src, size_t srclen, void *dst,
 			   size_t *converted_size, bool allow_bad_conv)
 {
 	void **dest = (void **)dst;
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;
diff --git a/source3/rpc_server/srv_pipe_hnd.c b/source3/rpc_server/srv_pipe_hnd.c
index a5d059c06a..fb7aca5c0f 100644
--- a/source3/rpc_server/srv_pipe_hnd.c
+++ b/source3/rpc_server/srv_pipe_hnd.c
@@ -1243,7 +1243,8 @@ static void np_write_trigger(struct async_req *req)
 		req->private_data, struct np_write_state);
 	struct tevent_req *subreq;
 
-	subreq = writev_send(state, state->ev, state->p->fd, &state->iov, 1);
+	subreq = writev_send(state, state->ev, NULL, state->p->fd,
+			     &state->iov, 1);
 	if (async_req_nomem(subreq, req)) {
 		return;
 	}
diff --git a/source3/script/tests/selftest.sh b/source3/script/tests/selftest.sh
index 94621841f5..a430d01a0e 100755
--- a/source3/script/tests/selftest.sh
+++ b/source3/script/tests/selftest.sh
@@ -104,13 +104,14 @@ SAMBA4SHAREDDIR="$SAMBA4BINDIR/shared"
 export SAMBA4SHAREDDIR
 export SMBTORTURE4
 
-if test x"$LD_LIBRARY_PATH" != x""; then
-	LD_LIBRARY_PATH="$BINDIR:$SAMBA4SHAREDDIR:$LD_LIBRARY_PATH"
-else
-	LD_LIBRARY_PATH="$BINDIR:$SAMBA4SHAREDDIR"
+if [ -z "$LIB_PATH_VAR" ] ; then
+	echo "Warning: LIB_PATH_VAR not set. Using best guess LD_LIBRARY_PATH." >&2
+	LIB_PATH_VAR=LD_LIBRARY_PATH
+	export LIB_PATH_VAR
 fi
-echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH"
-export LD_LIBRARY_PATH
+
+eval $LIB_PATH_VAR=$BINDIR:$SAMBA4SHAREDDIR:\$$LIB_PATH_VAR
+export $LIB_PATH_VAR
 
 ##
 ## verify that we were built with --enable-socket-wrapper