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

20 files changed, 1810 insertions, 1186 deletions

diff --git a/lib/async_req/async_req.c b/lib/async_req/async_req.c
deleted file mode 100644
index 4dfe809738..0000000000
--- a/lib/async_req/async_req.c
+++ /dev/null
@@ -1,297 +0,0 @@
-/*
-   Unix SMB/CIFS implementation.
-   Infrastructure for async requests
-   Copyright (C) Volker Lendecke 2008
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "includes.h"
-#include "lib/tevent/tevent.h"
-#include "lib/talloc/talloc.h"
-#include "lib/util/dlinklist.h"
-#include "lib/async_req/async_req.h"
-
-#ifndef TALLOC_FREE
-#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
-#endif
-
-/**
- * @brief Print an async_req structure
- * @param[in] mem_ctx	The memory context for the result
- * @param[in] req	The request to be printed
- * @retval		Text representation of req
- *
- * This is a default print function for async requests. Implementations should
- * override this with more specific information.
- *
- * This function should not be used by async API users, this is non-static
- * only to allow implementations to easily provide default information in
- * their specific functions.
- */
-
-char *async_req_print(TALLOC_CTX *mem_ctx, struct async_req *req)
-{
-	return talloc_asprintf(mem_ctx, "async_req: state=%d, error=%d, "
-			       "priv=%s", req->state, (int)req->error,
-			       talloc_get_name(req->private_data));
-}
-
-/**
- * @brief Create an async request
- * @param[in] mem_ctx	The memory context for the result
- * @param[in] ev	The event context this async request will be driven by
- * @retval		A new async request
- *
- * The new async request will be initialized in state ASYNC_REQ_IN_PROGRESS
- */
-
-struct async_req *async_req_new(TALLOC_CTX *mem_ctx)
-{
-	struct async_req *result;
-
-	result = talloc_zero(mem_ctx, struct async_req);
-	if (result == NULL) {
-		return NULL;
-	}
-	result->state = ASYNC_REQ_IN_PROGRESS;
-	result->print = async_req_print;
-	return result;
-}
-
-static void async_req_finish(struct async_req *req, enum async_req_state state)
-{
-	req->state = state;
-	if (req->async.fn != NULL) {
-		req->async.fn(req);
-	}
-}
-
-/**
- * @brief An async request has successfully finished
- * @param[in] req	The finished request
- *
- * async_req_done is to be used by implementors of async requests. When a
- * request is successfully finished, this function calls the user's completion
- * function.
- */
-
-void async_req_done(struct async_req *req)
-{
-	async_req_finish(req, ASYNC_REQ_DONE);
-}
-
-/**
- * @brief An async request has seen an error
- * @param[in] req	The request with an error
- * @param[in] error	The error code
- *
- * async_req_done is to be used by implementors of async requests. When a
- * request can not successfully completed, the implementation should call this
- * function with the appropriate status code.
- */
-
-void async_req_error(struct async_req *req, uint64_t error)
-{
-	req->error = error;
-	async_req_finish(req, ASYNC_REQ_USER_ERROR);
-}
-
-/**
- * @brief Timed event callback
- * @param[in] ev	Event context
- * @param[in] te	The timed event
- * @param[in] now	zero time
- * @param[in] priv	The async request to be finished
- */
-
-static void async_trigger(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);
-	if (req->error == 0) {
-		async_req_done(req);
-	}
-	else {
-		async_req_error(req, req->error);
-	}
-}
-
-/**
- * @brief Helper function for nomem check
- * @param[in] p		The pointer to be checked
- * @param[in] req	The request being processed
- *
- * Convenience helper to easily check alloc failure within a callback
- * implementing the next step of an async request.
- *
- * Call pattern would be
- * \code
- * p = talloc(mem_ctx, bla);
- * if (async_req_ntnomem(p, req)) {
- *	return;
- * }
- * \endcode
- */
-
-bool async_req_nomem(const void *p, struct async_req *req)
-{
-	if (p != NULL) {
-		return false;
-	}
-	async_req_finish(req, ASYNC_REQ_NO_MEMORY);
-	return true;
-}
-
-/**
- * @brief Finish a request before it started processing
- * @param[in] req	The finished request
- * @param[in] status	The success code
- *
- * An implementation of an async request might find that it can either finish
- * the request without waiting for an external event, or it can't even start
- * the engine. To present the illusion of a callback to the user of the API,
- * the implementation can call this helper function which triggers an
- * immediate timed event. This way the caller can use the same calling
- * conventions, independent of whether the request was actually deferred.
- */
-
-bool async_post_error(struct async_req *req, struct tevent_context *ev,
-		      uint64_t error)
-{
-	req->error = error;
-
-	if (tevent_add_timer(ev, req, tevent_timeval_zero(),
-			    async_trigger, req) == NULL) {
-		return false;
-	}
-	return true;
-}
-
-bool async_req_is_error(struct async_req *req, enum async_req_state *state,
-			uint64_t *error)
-{
-	if (req->state == ASYNC_REQ_DONE) {
-		return false;
-	}
-	if (req->state == ASYNC_REQ_USER_ERROR) {
-		*error = req->error;
-	}
-	*state = req->state;
-	return true;
-}
-
-struct async_queue_entry {
-	struct async_queue_entry *prev, *next;
-	struct async_req_queue *queue;
-	struct async_req *req;
-	void (*trigger)(struct async_req *req);
-};
-
-struct async_req_queue {
-	struct async_queue_entry *queue;
-};
-
-struct async_req_queue *async_req_queue_init(TALLOC_CTX *mem_ctx)
-{
-	return talloc_zero(mem_ctx, struct async_req_queue);
-}
-
-static int async_queue_entry_destructor(struct async_queue_entry *e)
-{
-	struct async_req_queue *queue = e->queue;
-
-	DLIST_REMOVE(queue->queue, e);
-
-	if (queue->queue != NULL) {
-		queue->queue->trigger(queue->queue->req);
-	}
-
-	return 0;
-}
-
-static void async_req_immediate_trigger(struct tevent_context *ev,
-					struct tevent_timer *te,
-					struct timeval now,
-					void *priv)
-{
-	struct async_queue_entry *e = talloc_get_type_abort(
-		priv, struct async_queue_entry);
-
-	TALLOC_FREE(te);
-	e->trigger(e->req);
-}
-
-bool async_req_enqueue(struct async_req_queue *queue, struct tevent_context *ev,
-		       struct async_req *req,
-		       void (*trigger)(struct async_req *req))
-{
-	struct async_queue_entry *e;
-	bool busy;
-
-	busy = (queue->queue != NULL);
-
-	e = talloc(req, struct async_queue_entry);
-	if (e == NULL) {
-		return false;
-	}
-
-	e->req = req;
-	e->trigger = trigger;
-	e->queue = queue;
-
-	DLIST_ADD_END(queue->queue, e, struct async_queue_entry *);
-	talloc_set_destructor(e, async_queue_entry_destructor);
-
-	if (!busy) {
-		struct tevent_timer *te;
-
-		te = tevent_add_timer(ev, e, tevent_timeval_zero(),
-				     async_req_immediate_trigger,
-				     e);
-		if (te == NULL) {
-			TALLOC_FREE(e);
-			return false;
-		}
-	}
-
-	return true;
-}
-
-bool _async_req_setup(TALLOC_CTX *mem_ctx, struct async_req **preq,
-		      void *pstate, size_t state_size, const char *typename)
-{
-	struct async_req *req;
-	void **ppstate = (void **)pstate;
-	void *state;
-
-	req = async_req_new(mem_ctx);
-	if (req == NULL) {
-		return false;
-	}
-	state = talloc_size(req, state_size);
-	if (state == NULL) {
-		TALLOC_FREE(req);
-		return false;
-	}
-	talloc_set_name_const(state, typename);
-	req->private_data = state;
-
-	*preq = req;
-	*ppstate = state;
-
-	return true;
-}
diff --git a/lib/async_req/async_req.h b/lib/async_req/async_req.h
deleted file mode 100644
index fdec1b708e..0000000000
--- a/lib/async_req/async_req.h
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
-   Unix SMB/CIFS implementation.
-   Infrastructure for async requests
-   Copyright (C) Volker Lendecke 2008
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef __ASYNC_REQ_H__
-#define __ASYNC_REQ_H__
-
-#include "lib/talloc/talloc.h"
-
-/**
- * An async request moves between the following 4 states:
- */
-
-enum async_req_state {
-	/**
-	 * we are creating the request
-	 */
-	ASYNC_REQ_INIT,
-	/**
-	 * we are waiting the request to complete
-	 */
-	ASYNC_REQ_IN_PROGRESS,
-	/**
-	 * the request is finished
-	 */
-	ASYNC_REQ_DONE,
-	/**
-	 * A user error has occured
-	 */
-	ASYNC_REQ_USER_ERROR,
-	/**
-	 * Request timed out
-	 */
-	ASYNC_REQ_TIMED_OUT,
-	/**
-	 * No memory in between
-	 */
-	ASYNC_REQ_NO_MEMORY
-};
-
-/**
- * @brief An async request
- *
- * This represents an async request being processed by callbacks via an event
- * context. A user can issue for example a write request to a socket, giving
- * an implementation function the fd, the buffer and the number of bytes to
- * transfer. The function issuing the request will immediately return without
- * blocking most likely without having sent anything. The API user then fills
- * in req->async.fn and req->async.priv, functions that are called when the
- * request is finished.
- *
- * It is up to the user of the async request to talloc_free it after it has
- * finished. This can happen while the completion function is called.
- */
-
-struct async_req {
-	/**
-	 * @brief The external state - will be queried by the caller
-	 *
-	 * While the async request is being processed, state will remain in
-	 * ASYNC_REQ_IN_PROGRESS. A request is finished if
-	 * req->state>=ASYNC_REQ_DONE.
-	 */
-	enum async_req_state state;
-
-	/**
-	 * @brief Private pointer for the actual implementation
-	 *
-	 * The implementation doing the work for the async request needs a
-	 * current state like for example a fd event. The user of an async
-	 * request should not touch this.
-	 */
-	void *private_data;
-
-	/**
-	 * @brief Print yourself, for debugging purposes
-	 *
-	 * Async requests are opaque data structures. The implementation of an
-	 * async request can define a custom function to print more debug
-	 * info.
-	 */
-	char *(*print)(TALLOC_CTX *mem_ctx, struct async_req *);
-
-	/**
-	 * @brief status code when finished
-	 *
-	 * This status can be queried in the async completion function. It
-	 * will be set to 0 when everything went fine.
-	 **/
-	uint64_t error;
-
-	/**
-	 * @brief What to do on completion
-	 *
-	 * This is used for the user of an async request, fn is called when
-	 * the request completes, either successfully or with an error.
-	 */
-	struct {
-		/**
-		 * @brief Completion function
-		 * Completion function, to be filled by the API user
-		 */
-		void (*fn)(struct async_req *);
-		/**
-		 * @brief Private data for the completion function
-		 */
-		void *priv;
-	} async;
-};
-
-struct async_req *async_req_new(TALLOC_CTX *mem_ctx);
-
-char *async_req_print(TALLOC_CTX *mem_ctx, struct async_req *req);
-
-void async_req_done(struct async_req *req);
-
-void async_req_error(struct async_req *req, uint64_t error);
-
-bool async_req_nomem(const void *p, struct async_req *req);
-
-bool async_post_error(struct async_req *req, struct tevent_context *ev,
-		      uint64_t error);
-
-bool async_req_is_error(struct async_req *req, enum async_req_state *state,
-			uint64_t *error);
-
-struct async_req_queue;
-
-struct async_req_queue *async_req_queue_init(TALLOC_CTX *mem_ctx);
-
-bool async_req_enqueue(struct async_req_queue *queue,
-		       struct tevent_context *ev,
-		       struct async_req *req,
-		       void (*trigger)(struct async_req *req));
-
-bool _async_req_setup(TALLOC_CTX *mem_ctx, struct async_req **preq,
-		      void *pstate, size_t state_size, const char *typename);
-
-#define async_req_setup(_mem_ctx, _preq, _pstate, type) \
-	_async_req_setup((_mem_ctx), (_preq), (_pstate), sizeof(type), #type)
-
-
-#endif
diff --git a/lib/async_req/async_req_ntstatus.c b/lib/async_req/async_req_ntstatus.c
deleted file mode 100644
index 65bc0f6510..0000000000
--- a/lib/async_req/async_req_ntstatus.c
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-   Unix SMB/CIFS implementation.
-   NTSTATUS wrappers for async_req.h
-   Copyright (C) Volker Lendecke 2008, 2009
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "includes.h"
-#include "lib/tevent/tevent.h"
-#include "lib/talloc/talloc.h"
-#include "lib/util/dlinklist.h"
-#include "lib/async_req/async_req_ntstatus.h"
-
-void async_req_nterror(struct async_req *req, NTSTATUS status)
-{
-	async_req_error(req, NT_STATUS_V(status));
-}
-
-bool async_post_ntstatus(struct async_req *req, struct tevent_context *ev,
-			 NTSTATUS status)
-{
-	return async_post_error(req, ev, NT_STATUS_V(status));
-}
-
-bool async_req_is_nterror(struct async_req *req, NTSTATUS *status)
-{
-	enum async_req_state state;
-	uint64_t error;
-
-	if (!async_req_is_error(req, &state, &error)) {
-		return false;
-	}
-	switch (state) {
-	case ASYNC_REQ_USER_ERROR:
-		*status = NT_STATUS(error);
-		break;
-	case ASYNC_REQ_TIMED_OUT:
-		*status = NT_STATUS_IO_TIMEOUT;
-		break;
-	case ASYNC_REQ_NO_MEMORY:
-		*status = NT_STATUS_NO_MEMORY;
-		break;
-	default:
-		*status = NT_STATUS_INTERNAL_ERROR;
-		break;
-	}
-	return true;
-}
-
-NTSTATUS async_req_simple_recv_ntstatus(struct async_req *req)
-{
-	NTSTATUS status;
-
-	if (async_req_is_nterror(req, &status)) {
-		return status;
-	}
-	return NT_STATUS_OK;
-}
diff --git a/lib/async_req/async_req_ntstatus.h b/lib/async_req/async_req_ntstatus.h
deleted file mode 100644
index 7555aac603..0000000000
--- a/lib/async_req/async_req_ntstatus.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-   Unix SMB/CIFS implementation.
-   NTSTATUS wrappers for async_req.h
-   Copyright (C) Volker Lendecke 2008, 2009
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef __ASYNC_REQ_NTSTATUS_H__
-#define __ASYNC_REQ_NTSTATUS_H__
-
-#include "lib/async_req/async_req.h"
-#include "includes.h"
-
-void async_req_nterror(struct async_req *req, NTSTATUS status);
-
-bool async_post_ntstatus(struct async_req *req, struct tevent_context *ev,
-			 NTSTATUS status);
-
-bool async_req_is_nterror(struct async_req *req, NTSTATUS *status);
-
-NTSTATUS async_req_simple_recv_ntstatus(struct async_req *req);
-
-#endif
diff --git a/lib/async_req/async_sock.c b/lib/async_req/async_sock.c
index 77df406044..543972815d 100644
--- a/lib/async_req/async_sock.c
+++ b/lib/async_req/async_sock.c
@@ -20,7 +20,6 @@
 #include "includes.h"
 #include "lib/talloc/talloc.h"
 #include "lib/tevent/tevent.h"
-#include "lib/async_req/async_req.h"
 #include "lib/async_req/async_sock.h"
 #include "lib/util/tevent_unix.h"
 #include <fcntl.h>
@@ -29,55 +28,6 @@
 #define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
 #endif
 
-/**
- * @brief Map async_req states to unix-style errnos
- * @param[in]  req	The async req to get the state from
- * @param[out] err	Pointer to take the unix-style errno
- *
- * @return true if the async_req is in an error state, false otherwise
- */
-
-bool async_req_is_errno(struct async_req *req, int *err)
-{
-	enum async_req_state state;
-	uint64_t error;
-
-	if (!async_req_is_error(req, &state, &error)) {
-		return false;
-	}
-
-	switch (state) {
-	case ASYNC_REQ_USER_ERROR:
-		*err = (int)error;
-		break;
-	case ASYNC_REQ_TIMED_OUT:
-#ifdef ETIMEDOUT
-		*err = ETIMEDOUT;
-#else
-		*err = EAGAIN;
-#endif
-		break;
-	case ASYNC_REQ_NO_MEMORY:
-		*err = ENOMEM;
-		break;
-	default:
-		*err = EIO;
-		break;
-	}
-	return true;
-}
-
-int async_req_simple_recv_errno(struct async_req *req)
-{
-	int err;
-
-	if (async_req_is_errno(req, &err)) {
-		return err;
-	}
-
-	return 0;
-}
-
 struct async_send_state {
 	int fd;
 	const void *buf;
@@ -547,7 +497,8 @@ static void read_packet_handler(struct tevent_context *ev,
 	ssize_t nread, more;
 	uint8_t *tmp;
 
-	nread = read(state->fd, state->buf+state->nread, total-state->nread);
+	nread = recv(state->fd, state->buf+state->nread, total-state->nread,
+		     0);
 	if (nread == -1) {
 		tevent_req_error(req, errno);
 		return;
diff --git a/lib/async_req/async_sock.h b/lib/async_req/async_sock.h
index c5d9400eb6..ec859dc0ae 100644
--- a/lib/async_req/async_sock.h
+++ b/lib/async_req/async_sock.h
@@ -22,9 +22,6 @@
 
 #include "includes.h"
 
-bool async_req_is_errno(struct async_req *req, int *err);
-int async_req_simple_recv_errno(struct async_req *req);
-
 struct tevent_req *async_send_send(TALLOC_CTX *mem_ctx,
 				   struct tevent_context *ev,
 				   int fd, const void *buf, size_t len,
diff --git a/lib/async_req/config.mk b/lib/async_req/config.mk
index 820f890fd0..bf0fd6a2db 100644
--- a/lib/async_req/config.mk
+++ b/lib/async_req/config.mk
@@ -1,3 +1,3 @@
 [SUBSYSTEM::LIBASYNC_REQ]
 
-LIBASYNC_REQ_OBJ_FILES = $(addprefix ../lib/async_req/, async_req.o async_sock.o async_req_ntstatus.o)
+LIBASYNC_REQ_OBJ_FILES = $(addprefix ../lib/async_req/, async_sock.o)
diff --git a/lib/popt/popt.h b/lib/popt/popt.h
index 08701d73b5..7b94a98d03 100644
--- a/lib/popt/popt.h
+++ b/lib/popt/popt.h
@@ -83,7 +83,7 @@
 #define POPT_ERROR_NOARG	-10	/*!< missing argument */
 #define POPT_ERROR_BADOPT	-11	/*!< unknown option */
 #define POPT_ERROR_OPTSTOODEEP	-13	/*!< aliases nested too deeply */
-#define POPT_ERROR_BADQUOTE	-15	/*!< error in paramter quoting */
+#define POPT_ERROR_BADQUOTE	-15	/*!< error in parameter quoting */
 #define POPT_ERROR_ERRNO	-16	/*!< errno set, use strerror(errno) */
 #define POPT_ERROR_BADNUMBER	-17	/*!< invalid numeric value */
 #define POPT_ERROR_OVERFLOW	-18	/*!< number too large or too small */
diff --git a/lib/tsocket/config.mk b/lib/tsocket/config.mk
index c35f0afd6f..2e05f544c9 100644
--- a/lib/tsocket/config.mk
+++ b/lib/tsocket/config.mk
@@ -5,8 +5,6 @@ LIBTSOCKET_OBJ_FILES = $(addprefix ../lib/tsocket/, \
 					tsocket.o \
 					tsocket_helpers.o \
 					tsocket_bsd.o \
-					tsocket_recvfrom.o \
-					tsocket_sendto.o \
 					tsocket_connect.o \
 					tsocket_writev.o \
 					tsocket_readv.o)
diff --git a/lib/tsocket/tsocket.c b/lib/tsocket/tsocket.c
index 1a12e691a9..076c6474a0 100644
--- a/lib/tsocket/tsocket.c
+++ b/lib/tsocket/tsocket.c
@@ -118,21 +118,6 @@ int tsocket_writev(struct tsocket_context *sock,
 	return sock->ops->writev_data(sock, vector, count);
 }
 
-ssize_t tsocket_recvfrom(struct tsocket_context *sock,
-			 uint8_t *data, size_t len,
-			 TALLOC_CTX *addr_ctx,
-			 struct tsocket_address **src_addr)
-{
-	return sock->ops->recvfrom_data(sock, data, len, addr_ctx, src_addr);
-}
-
-ssize_t tsocket_sendto(struct tsocket_context *sock,
-		       const uint8_t *data, size_t len,
-		       const struct tsocket_address *dest_addr)
-{
-	return sock->ops->sendto_data(sock, data, len, dest_addr);
-}
-
 int tsocket_get_status(const struct tsocket_context *sock)
 {
 	return sock->ops->get_status(sock);
@@ -229,3 +214,397 @@ int _tsocket_address_create_socket(const struct tsocket_address *addr,
 	return addr->ops->create_socket(addr, type, mem_ctx, sock, location);
 }
 
+struct tdgram_context {
+	const char *location;
+	const struct tdgram_context_ops *ops;
+	void *private_data;
+};
+
+struct tdgram_context *_tdgram_context_create(TALLOC_CTX *mem_ctx,
+					const struct tdgram_context_ops *ops,
+					void *pstate,
+					size_t psize,
+					const char *type,
+					const char *location)
+{
+	struct tdgram_context *dgram;
+	void **ppstate = (void **)pstate;
+	void *state;
+
+	dgram = talloc(mem_ctx, struct tdgram_context);
+	if (dgram == NULL) {
+		return NULL;
+	}
+	dgram->location	= location;
+	dgram->ops	= ops;
+
+	state = talloc_size(dgram, psize);
+	if (state == NULL) {
+		talloc_free(dgram);
+		return NULL;
+	}
+	talloc_set_name_const(state, type);
+
+	dgram->private_data = state;
+
+	*ppstate = state;
+	return dgram;
+}
+
+void *_tdgram_context_data(struct tdgram_context *dgram)
+{
+	return dgram->private_data;
+}
+
+struct tdgram_recvfrom_state {
+	const struct tdgram_context_ops *ops;
+	uint8_t *buf;
+	size_t len;
+	struct tsocket_address *src;
+};
+
+static void tdgram_recvfrom_done(struct tevent_req *subreq);
+
+struct tevent_req *tdgram_recvfrom_send(TALLOC_CTX *mem_ctx,
+					struct tevent_context *ev,
+					struct tdgram_context *dgram)
+{
+	struct tevent_req *req;
+	struct tdgram_recvfrom_state *state;
+	struct tevent_req *subreq;
+
+	req = tevent_req_create(mem_ctx, &state,
+				struct tdgram_recvfrom_state);
+	if (req == NULL) {
+		return NULL;
+	}
+
+	state->ops = dgram->ops;
+
+	subreq = state->ops->recvfrom_send(state, ev, dgram);
+	if (tevent_req_nomem(subreq, req)) {
+		goto post;
+	}
+	tevent_req_set_callback(subreq, tdgram_recvfrom_done, req);
+
+	return req;
+
+ post:
+	tevent_req_post(req, ev);
+	return req;
+}
+
+static void tdgram_recvfrom_done(struct tevent_req *subreq)
+{
+	struct tevent_req *req = tevent_req_callback_data(subreq,
+				 struct tevent_req);
+	struct tdgram_recvfrom_state *state = tevent_req_data(req,
+					      struct tdgram_recvfrom_state);
+	ssize_t ret;
+	int sys_errno;
+
+	ret = state->ops->recvfrom_recv(subreq, &sys_errno, state,
+					&state->buf, &state->src);
+	if (ret == -1) {
+		tevent_req_error(req, sys_errno);
+		return;
+	}
+
+	state->len = ret;
+
+	tevent_req_done(req);
+}
+
+ssize_t tdgram_recvfrom_recv(struct tevent_req *req,
+			     int *perrno,
+			     TALLOC_CTX *mem_ctx,
+			     uint8_t **buf,
+			     struct tsocket_address **src)
+{
+	struct tdgram_recvfrom_state *state = tevent_req_data(req,
+					      struct tdgram_recvfrom_state);
+	ssize_t ret;
+
+	ret = tsocket_simple_int_recv(req, perrno);
+	if (ret == 0) {
+		*buf = talloc_move(mem_ctx, &state->buf);
+		ret = state->len;
+		if (src) {
+			*src = talloc_move(mem_ctx, &state->src);
+		}
+	}
+
+	tevent_req_received(req);
+	return ret;
+}
+
+struct tdgram_sendto_state {
+	const struct tdgram_context_ops *ops;
+	ssize_t ret;
+};
+
+static void tdgram_sendto_done(struct tevent_req *subreq);
+
+struct tevent_req *tdgram_sendto_send(TALLOC_CTX *mem_ctx,
+				      struct tevent_context *ev,
+				      struct tdgram_context *dgram,
+				      const uint8_t *buf, size_t len,
+				      const struct tsocket_address *dst)
+{
+	struct tevent_req *req;
+	struct tdgram_sendto_state *state;
+	struct tevent_req *subreq;
+
+	req = tevent_req_create(mem_ctx, &state,
+				struct tdgram_sendto_state);
+	if (req == NULL) {
+		return NULL;
+	}
+
+	state->ops = dgram->ops;
+	state->ret = -1;
+
+	subreq = state->ops->sendto_send(state, ev, dgram,
+					 buf, len, dst);
+	if (tevent_req_nomem(subreq, req)) {
+		goto post;
+	}
+	tevent_req_set_callback(subreq, tdgram_sendto_done, req);
+
+	return req;
+
+ post:
+	tevent_req_post(req, ev);
+	return req;
+}
+
+static void tdgram_sendto_done(struct tevent_req *subreq)
+{
+	struct tevent_req *req = tevent_req_callback_data(subreq,
+				 struct tevent_req);
+	struct tdgram_sendto_state *state = tevent_req_data(req,
+					    struct tdgram_sendto_state);
+	ssize_t ret;
+	int sys_errno;
+
+	ret = state->ops->sendto_recv(subreq, &sys_errno);
+	if (ret == -1) {
+		tevent_req_error(req, sys_errno);
+		return;
+	}
+
+	state->ret = ret;
+
+	tevent_req_done(req);
+}
+
+ssize_t tdgram_sendto_recv(struct tevent_req *req,
+			   int *perrno)
+{
+	struct tdgram_sendto_state *state = tevent_req_data(req,
+					    struct tdgram_sendto_state);
+	ssize_t ret;
+
+	ret = tsocket_simple_int_recv(req, perrno);
+	if (ret == 0) {
+		ret = state->ret;
+	}
+
+	tevent_req_received(req);
+	return ret;
+}
+
+struct tdgram_disconnect_state {
+	const struct tdgram_context_ops *ops;
+};
+
+static void tdgram_disconnect_done(struct tevent_req *subreq);
+
+struct tevent_req *tdgram_disconnect_send(TALLOC_CTX *mem_ctx,
+					  struct tevent_context *ev,
+					  struct tdgram_context *dgram)
+{
+	struct tevent_req *req;
+	struct tdgram_disconnect_state *state;
+	struct tevent_req *subreq;
+
+	req = tevent_req_create(mem_ctx, &state,
+				struct tdgram_disconnect_state);
+	if (req == NULL) {
+		return NULL;
+	}
+
+	state->ops = dgram->ops;
+
+	subreq = state->ops->disconnect_send(state, ev, dgram);
+	if (tevent_req_nomem(subreq, req)) {
+		goto post;
+	}
+	tevent_req_set_callback(subreq, tdgram_disconnect_done, req);
+
+	return req;
+
+ post:
+	tevent_req_post(req, ev);
+	return req;
+}
+
+static void tdgram_disconnect_done(struct tevent_req *subreq)
+{
+	struct tevent_req *req = tevent_req_callback_data(subreq,
+				 struct tevent_req);
+	struct tdgram_disconnect_state *state = tevent_req_data(req,
+						struct tdgram_disconnect_state);
+	int ret;
+	int sys_errno;
+
+	ret = state->ops->disconnect_recv(subreq, &sys_errno);
+	if (ret == -1) {
+		tevent_req_error(req, sys_errno);
+		return;
+	}
+
+	tevent_req_done(req);
+}
+
+int tdgram_disconnect_recv(struct tevent_req *req,
+			   int *perrno)
+{
+	int ret;
+
+	ret = tsocket_simple_int_recv(req, perrno);
+
+	tevent_req_received(req);
+	return ret;
+}
+
+struct tdgram_sendto_queue_state {
+	/* this structs are owned by the caller */
+	struct {
+		struct tevent_context *ev;
+		struct tdgram_context *dgram;
+		const uint8_t *buf;
+		size_t len;
+		const struct tsocket_address *dst;
+	} caller;
+	ssize_t ret;
+};
+
+static void tdgram_sendto_queue_trigger(struct tevent_req *req,
+					 void *private_data);
+static void tdgram_sendto_queue_done(struct tevent_req *subreq);
+
+/**
+ * @brief Queue a dgram blob for sending through the socket
+ * @param[in] mem_ctx	The memory context for the result
+ * @param[in] ev	The event context the operation should work on
+ * @param[in] dgram	The tdgram_context to send the message buffer
+ * @param[in] queue	The existing dgram queue
+ * @param[in] buf	The message buffer
+ * @param[in] len	The message length
+ * @param[in] dst	The destination socket address
+ * @retval		The async request handle
+ *
+ * This function queues a blob for sending to destination through an existing
+ * dgram socket. The async callback is triggered when the whole blob is
+ * delivered to the underlying system socket.
+ *
+ * The caller needs to make sure that all non-scalar input parameters hang
+ * arround for the whole lifetime of the request.
+ */
+struct tevent_req *tdgram_sendto_queue_send(TALLOC_CTX *mem_ctx,
+					    struct tevent_context *ev,
+					    struct tdgram_context *dgram,
+					    struct tevent_queue *queue,
+					    const uint8_t *buf,
+					    size_t len,
+					    struct tsocket_address *dst)
+{
+	struct tevent_req *req;
+	struct tdgram_sendto_queue_state *state;
+	bool ok;
+
+	req = tevent_req_create(mem_ctx, &state,
+				struct tdgram_sendto_queue_state);
+	if (!req) {
+		return NULL;
+	}
+
+	state->caller.ev	= ev;
+	state->caller.dgram	= dgram;
+	state->caller.buf	= buf;
+	state->caller.len	= len;
+	state->caller.dst	= dst;
+	state->ret		= -1;
+
+	ok = tevent_queue_add(queue,
+			      ev,
+			      req,
+			      tdgram_sendto_queue_trigger,
+			      NULL);
+	if (!ok) {
+		tevent_req_nomem(NULL, req);
+		goto post;
+	}
+
+	return req;
+
+ post:
+	tevent_req_post(req, ev);
+	return req;
+}
+
+static void tdgram_sendto_queue_trigger(struct tevent_req *req,
+					 void *private_data)
+{
+	struct tdgram_sendto_queue_state *state = tevent_req_data(req,
+					struct tdgram_sendto_queue_state);
+	struct tevent_req *subreq;
+
+	subreq = tdgram_sendto_send(state,
+				    state->caller.ev,
+				    state->caller.dgram,
+				    state->caller.buf,
+				    state->caller.len,
+				    state->caller.dst);
+	if (tevent_req_nomem(subreq, req)) {
+		return;
+	}
+	tevent_req_set_callback(subreq, tdgram_sendto_queue_done, req);
+}
+
+static void tdgram_sendto_queue_done(struct tevent_req *subreq)
+{
+	struct tevent_req *req = tevent_req_callback_data(subreq,
+				 struct tevent_req);
+	struct tdgram_sendto_queue_state *state = tevent_req_data(req,
+					struct tdgram_sendto_queue_state);
+	ssize_t ret;
+	int sys_errno;
+
+	ret = tdgram_sendto_recv(subreq, &sys_errno);
+	talloc_free(subreq);
+	if (ret == -1) {
+		tevent_req_error(req, sys_errno);
+		return;
+	}
+	state->ret = ret;
+
+	tevent_req_done(req);
+}
+
+ssize_t tdgram_sendto_queue_recv(struct tevent_req *req, int *perrno)
+{
+	struct tdgram_sendto_queue_state *state = tevent_req_data(req,
+					struct tdgram_sendto_queue_state);
+	ssize_t ret;
+
+	ret = tsocket_simple_int_recv(req, perrno);
+	if (ret == 0) {
+		ret = state->ret;
+	}
+
+	tevent_req_received(req);
+	return ret;
+}
+
diff --git a/lib/tsocket/tsocket.h b/lib/tsocket/tsocket.h
index 9bcfb5cb7e..8f69490012 100644
--- a/lib/tsocket/tsocket.h
+++ b/lib/tsocket/tsocket.h
@@ -29,11 +29,11 @@
 
 struct tsocket_context;
 struct tsocket_address;
+struct tdgram_context;
 struct iovec;
 
 enum tsocket_type {
 	TSOCKET_TYPE_STREAM = 1,
-	TSOCKET_TYPE_DGRAM,
 	TSOCKET_TYPE_MESSAGE
 };
 
@@ -67,14 +67,6 @@ int tsocket_readv(struct tsocket_context *sock,
 int tsocket_writev(struct tsocket_context *sock,
 		   const struct iovec *vector, size_t count);
 
-ssize_t tsocket_recvfrom(struct tsocket_context *sock,
-			 uint8_t *data, size_t len,
-			 TALLOC_CTX *addr_ctx,
-			 struct tsocket_address **src_addr);
-ssize_t tsocket_sendto(struct tsocket_context *sock,
-		       const uint8_t *data, size_t len,
-		       const struct tsocket_address *dest_addr);
-
 int tsocket_get_status(const struct tsocket_context *sock);
 
 int _tsocket_get_local_address(const struct tsocket_context *sock,
@@ -121,6 +113,32 @@ int _tsocket_address_create_socket(const struct tsocket_address *addr,
 				       __location__)
 
 /*
+ * tdgram_context related functions
+ */
+struct tevent_req *tdgram_recvfrom_send(TALLOC_CTX *mem_ctx,
+					struct tevent_context *ev,
+					struct tdgram_context *dgram);
+ssize_t tdgram_recvfrom_recv(struct tevent_req *req,
+			     int *perrno,
+			     TALLOC_CTX *mem_ctx,
+			     uint8_t **buf,
+			     struct tsocket_address **src);
+
+struct tevent_req *tdgram_sendto_send(TALLOC_CTX *mem_ctx,
+				      struct tevent_context *ev,
+				      struct tdgram_context *dgram,
+				      const uint8_t *buf, size_t len,
+				      const struct tsocket_address *dst);
+ssize_t tdgram_sendto_recv(struct tevent_req *req,
+			   int *perrno);
+
+struct tevent_req *tdgram_disconnect_send(TALLOC_CTX *mem_ctx,
+					  struct tevent_context *ev,
+					  struct tdgram_context *dgram);
+int tdgram_disconnect_recv(struct tevent_req *req,
+			   int *perrno);
+
+/*
  * BSD sockets: inet, inet6 and unix
  */
 
@@ -160,32 +178,25 @@ int _tsocket_context_bsd_wrap_existing(TALLOC_CTX *mem_ctx,
 	_tsocket_context_bsd_wrap_existing(mem_ctx, fd, cod, _sock, \
 					   __location__)
 
-/*
- * Async helpers
- */
+int _tdgram_inet_udp_socket(const struct tsocket_address *local,
+			    const struct tsocket_address *remote,
+			    TALLOC_CTX *mem_ctx,
+			    struct tdgram_context **dgram,
+			    const char *location);
+#define tdgram_inet_udp_socket(local, remote, mem_ctx, dgram) \
+	_tdgram_inet_udp_socket(local, remote, mem_ctx, dgram, __location__)
 
-struct tevent_req *tsocket_recvfrom_send(struct tsocket_context *sock,
-					 TALLOC_CTX *mem_ctx);
-ssize_t tsocket_recvfrom_recv(struct tevent_req *req,
-			      int *perrno,
+int _tdgram_unix_dgram_socket(const struct tsocket_address *local,
+			      const struct tsocket_address *remote,
 			      TALLOC_CTX *mem_ctx,
-			      uint8_t **buf,
-			      struct tsocket_address **src);
-
-struct tevent_req *tsocket_sendto_send(struct tsocket_context *sock,
-				       TALLOC_CTX *mem_ctx,
-				       const uint8_t *buf,
-				       size_t len,
-				       const struct tsocket_address *dst);
-ssize_t tsocket_sendto_recv(struct tevent_req *req, int *perrno);
+			      struct tdgram_context **dgram,
+			      const char *location);
+#define tdgram_unix_dgram_socket(local, remote, mem_ctx, dgram) \
+	_tdgram_unix_dgram_socket(local, remote, mem_ctx, dgram, __location__)
 
-struct tevent_req *tsocket_sendto_queue_send(TALLOC_CTX *mem_ctx,
-					     struct tsocket_context *sock,
-					     struct tevent_queue *queue,
-					     const uint8_t *buf,
-					     size_t len,
-					     struct tsocket_address *dst);
-ssize_t tsocket_sendto_queue_recv(struct tevent_req *req, int *perrno);
+/*
+ * Async helpers
+ */
 
 struct tevent_req *tsocket_connect_send(struct tsocket_context *sock,
 					TALLOC_CTX *mem_ctx,
@@ -216,5 +227,18 @@ struct tevent_req *tsocket_readv_send(struct tsocket_context *sock,
 				      void *private_data);
 int tsocket_readv_recv(struct tevent_req *req, int *perrno);
 
+/*
+ * Queue helpers
+ */
+
+struct tevent_req *tdgram_sendto_queue_send(TALLOC_CTX *mem_ctx,
+					    struct tevent_context *ev,
+					    struct tdgram_context *dgram,
+					    struct tevent_queue *queue,
+					    const uint8_t *buf,
+					    size_t len,
+					    struct tsocket_address *dst);
+ssize_t tdgram_sendto_queue_recv(struct tevent_req *req, int *perrno);
+
 #endif /* _TSOCKET_H */
 
diff --git a/lib/tsocket/tsocket_bsd.c b/lib/tsocket/tsocket_bsd.c
index 8254f5d9d3..87586e08e3 100644
--- a/lib/tsocket/tsocket_bsd.c
+++ b/lib/tsocket/tsocket_bsd.c
@@ -24,9 +24,168 @@
 #include "replace.h"
 #include "system/filesys.h"
 #include "system/network.h"
+#include "system/filesys.h"
 #include "tsocket.h"
 #include "tsocket_internal.h"
 
+static int tsocket_bsd_error_from_errno(int ret,
+					int sys_errno,
+					bool *retry)
+{
+	*retry = false;
+
+	if (ret >= 0) {
+		return 0;
+	}
+
+	if (ret != -1) {
+		return EIO;
+	}
+
+	if (sys_errno == 0) {
+		return EIO;
+	}
+
+	if (sys_errno == EINTR) {
+		*retry = true;
+		return sys_errno;
+	}
+
+	if (sys_errno == EINPROGRESS) {
+		*retry = true;
+		return sys_errno;
+	}
+
+	if (sys_errno == EAGAIN) {
+		*retry = true;
+		return sys_errno;
+	}
+
+#ifdef EWOULDBLOCK
+	if (sys_errno == EWOULDBLOCK) {
+		*retry = true;
+		return sys_errno;
+	}
+#endif
+
+	return sys_errno;
+}
+
+static int tsocket_bsd_common_prepare_fd(int fd, bool high_fd)
+{
+	int i;
+	int sys_errno = 0;
+	int fds[3];
+	int num_fds = 0;
+
+	int result, flags;
+
+	if (fd == -1) {
+		return -1;
+	}
+
+	/* first make a fd >= 3 */
+	if (high_fd) {
+		while (fd < 3) {
+			fds[num_fds++] = fd;
+			fd = dup(fd);
+			if (fd == -1) {
+				sys_errno = errno;
+				break;
+			}
+		}
+		for (i=0; i<num_fds; i++) {
+			close(fds[i]);
+		}
+		if (fd == -1) {
+			errno = sys_errno;
+			return fd;
+		}
+	}
+
+	/* fd should be nonblocking. */
+
+#ifdef O_NONBLOCK
+#define FLAG_TO_SET O_NONBLOCK
+#else
+#ifdef SYSV
+#define FLAG_TO_SET O_NDELAY
+#else /* BSD */
+#define FLAG_TO_SET FNDELAY
+#endif
+#endif
+
+	if ((flags = fcntl(fd, F_GETFL)) == -1) {
+		goto fail;
+	}
+
+	flags |= FLAG_TO_SET;
+	if (fcntl(fd, F_SETFL, flags) == -1) {
+		goto fail;
+	}
+
+#undef FLAG_TO_SET
+
+	/* fd should be closed on exec() */
+#ifdef FD_CLOEXEC
+	result = flags = fcntl(fd, F_GETFD, 0);
+	if (flags >= 0) {
+		flags |= FD_CLOEXEC;
+		result = fcntl(fd, F_SETFD, flags);
+	}
+	if (result < 0) {
+		goto fail;
+	}
+#endif
+	return fd;
+
+ fail:
+	if (fd != -1) {
+		sys_errno = errno;
+		close(fd);
+		errno = sys_errno;
+	}
+	return -1;
+}
+
+static ssize_t tsocket_bsd_pending(int fd)
+{
+	int ret;
+	int value = 0;
+
+	ret = ioctl(fd, FIONREAD, &value);
+	if (ret == -1) {
+		return ret;
+	}
+
+	if (ret == 0) {
+		if (value == 0) {
+			int error=0;
+			socklen_t len = sizeof(error);
+			/*
+			 * if no data is available check if the socket
+			 * is in error state. For dgram sockets
+			 * it's the way to return ICMP error messages
+			 * of connected sockets to the caller.
+			 */
+			ret = getsockopt(fd, SOL_SOCKET, SO_ERROR,
+					 &error, &len);
+			if (ret == -1) {
+				return ret;
+			}
+			if (error != 0) {
+				errno = error;
+				return -1;
+			}
+		}
+		return value;
+	}
+
+	/* this should not be reached */
+	errno = EIO;
+	return -1;
+}
+
 static const struct tsocket_context_ops tsocket_context_bsd_ops;
 static const struct tsocket_address_ops tsocket_address_bsd_ops;
 
@@ -456,9 +615,6 @@ static int tsocket_address_bsd_create_socket(const struct tsocket_address *addr,
 		}
 		bsd_type = SOCK_STREAM;
 		break;
-	case TSOCKET_TYPE_DGRAM:
-		bsd_type = SOCK_DGRAM;
-		break;
 	default:
 		errno = EPROTONOSUPPORT;
 		return -1;
@@ -785,73 +941,6 @@ static int tsocket_context_bsd_writev_data(struct tsocket_context *sock,
 	return ret;
 }
 
-static ssize_t tsocket_context_bsd_recvfrom_data(struct tsocket_context *sock,
-						  uint8_t *data, size_t len,
-						  TALLOC_CTX *addr_ctx,
-						  struct tsocket_address **remote)
-{
-	struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
-					   struct tsocket_context_bsd);
-	struct tsocket_address *addr = NULL;
-	struct tsocket_address_bsd *bsda;
-	ssize_t ret;
-	struct sockaddr *sa = NULL;
-	socklen_t sa_len = 0;
-
-	if (remote) {
-		addr = tsocket_address_create(addr_ctx,
-					      &tsocket_address_bsd_ops,
-					      &bsda,
-					      struct tsocket_address_bsd,
-					      __location__ "recvfrom");
-		if (!addr) {
-			return -1;
-		}
-
-		ZERO_STRUCTP(bsda);
-
-		sa = &bsda->u.sa;
-		sa_len = sizeof(bsda->u.ss);
-	}
-
-	ret = recvfrom(bsds->fd, data, len, 0, sa, &sa_len);
-	if (ret < 0) {
-		int saved_errno = errno;
-		talloc_free(addr);
-		errno = saved_errno;
-		return ret;
-	}
-
-	if (remote) {
-		*remote = addr;
-	}
-	return ret;
-}
-
-static ssize_t tsocket_context_bsd_sendto_data(struct tsocket_context *sock,
-						const uint8_t *data, size_t len,
-						const struct tsocket_address *remote)
-{
-	struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
-					   struct tsocket_context_bsd);
-	struct sockaddr *sa = NULL;
-	socklen_t sa_len = 0;
-	ssize_t ret;
-
-	if (remote) {
-		struct tsocket_address_bsd *bsda =
-			talloc_get_type(remote->private_data,
-			struct tsocket_address_bsd);
-
-		sa = &bsda->u.sa;
-		sa_len = sizeof(bsda->u.ss);
-	}
-
-	ret = sendto(bsds->fd, data, len, 0, sa, sa_len);
-
-	return ret;
-}
-
 static int tsocket_context_bsd_get_status(const struct tsocket_context *sock)
 {
 	struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
@@ -1113,8 +1202,6 @@ static const struct tsocket_context_ops tsocket_context_bsd_ops = {
 	.pending_data		= tsocket_context_bsd_pending_data,
 	.readv_data		= tsocket_context_bsd_readv_data,
 	.writev_data		= tsocket_context_bsd_writev_data,
-	.recvfrom_data		= tsocket_context_bsd_recvfrom_data,
-	.sendto_data		= tsocket_context_bsd_sendto_data,
 
 	.get_status		= tsocket_context_bsd_get_status,
 	.get_local_address	= tsocket_context_bsd_get_local_address,
@@ -1125,3 +1212,709 @@ static const struct tsocket_context_ops tsocket_context_bsd_ops = {
 
 	.disconnect		= tsocket_context_bsd_disconnect
 };
+
+struct tdgram_bsd {
+	int fd;
+
+	void *event_ptr;
+	struct tevent_fd *fde;
+
+	void *readable_private;
+	void (*readable_handler)(void *private_data);
+	void *writeable_private;
+	void (*writeable_handler)(void *private_data);
+
+	struct tevent_req *read_req;
+	struct tevent_req *write_req;
+};
+
+static void tdgram_bsd_fde_handler(struct tevent_context *ev,
+				   struct tevent_fd *fde,
+				   uint16_t flags,
+				   void *private_data)
+{
+	struct tdgram_bsd *bsds = talloc_get_type_abort(private_data,
+				  struct tdgram_bsd);
+
+	if (flags & TEVENT_FD_WRITE) {
+		bsds->writeable_handler(bsds->writeable_private);
+		return;
+	}
+	if (flags & TEVENT_FD_READ) {
+		if (!bsds->readable_handler) {
+			TEVENT_FD_NOT_READABLE(bsds->fde);
+			return;
+		}
+		bsds->readable_handler(bsds->readable_private);
+		return;
+	}
+}
+
+static int tdgram_bsd_set_readable_handler(struct tdgram_bsd *bsds,
+					   struct tevent_context *ev,
+					   void (*handler)(void *private_data),
+					   void *private_data)
+{
+	if (ev == NULL) {
+		if (handler) {
+			errno = EINVAL;
+			return -1;
+		}
+		if (!bsds->readable_handler) {
+			return 0;
+		}
+		bsds->readable_handler = NULL;
+		bsds->readable_private = NULL;
+
+		return 0;
+	}
+
+	/* read and write must use the same tevent_context */
+	if (bsds->event_ptr != ev) {
+		if (bsds->readable_handler || bsds->writeable_handler) {
+			errno = EINVAL;
+			return -1;
+		}
+		bsds->event_ptr = NULL;
+		TALLOC_FREE(bsds->fde);
+	}
+
+	if (bsds->fde == NULL) {
+		bsds->fde = tevent_add_fd(ev, bsds,
+					  bsds->fd, TEVENT_FD_READ,
+					  tdgram_bsd_fde_handler,
+					  bsds);
+		if (!bsds->fde) {
+			return -1;
+		}
+
+		/* cache the event context we're running on */
+		bsds->event_ptr = ev;
+	} else if (!bsds->readable_handler) {
+		TEVENT_FD_READABLE(bsds->fde);
+	}
+
+	bsds->readable_handler = handler;
+	bsds->readable_private = private_data;
+
+	return 0;
+}
+
+static int tdgram_bsd_set_writeable_handler(struct tdgram_bsd *bsds,
+					    struct tevent_context *ev,
+					    void (*handler)(void *private_data),
+					    void *private_data)
+{
+	if (ev == NULL) {
+		if (handler) {
+			errno = EINVAL;
+			return -1;
+		}
+		if (!bsds->writeable_handler) {
+			return 0;
+		}
+		bsds->writeable_handler = NULL;
+		bsds->writeable_private = NULL;
+		TEVENT_FD_NOT_WRITEABLE(bsds->fde);
+
+		return 0;
+	}
+
+	/* read and write must use the same tevent_context */
+	if (bsds->event_ptr != ev) {
+		if (bsds->readable_handler || bsds->writeable_handler) {
+			errno = EINVAL;
+			return -1;
+		}
+		bsds->event_ptr = NULL;
+		TALLOC_FREE(bsds->fde);
+	}
+
+	if (bsds->fde == NULL) {
+		bsds->fde = tevent_add_fd(ev, bsds,
+					  bsds->fd, TEVENT_FD_WRITE,
+					  tdgram_bsd_fde_handler,
+					  bsds);
+		if (!bsds->fde) {
+			return -1;
+		}
+
+		/* cache the event context we're running on */
+		bsds->event_ptr = ev;
+	} else if (!bsds->writeable_handler) {
+		TEVENT_FD_WRITEABLE(bsds->fde);
+	}
+
+	bsds->writeable_handler = handler;
+	bsds->writeable_private = private_data;
+
+	return 0;
+}
+
+struct tdgram_bsd_recvfrom_state {
+	struct tdgram_context *dgram;
+
+	uint8_t *buf;
+	size_t len;
+	struct tsocket_address *src;
+};
+
+static int tdgram_bsd_recvfrom_destructor(struct tdgram_bsd_recvfrom_state *state)
+{
+	struct tdgram_bsd *bsds = tdgram_context_data(state->dgram,
+				  struct tdgram_bsd);
+
+	bsds->read_req = NULL;
+	tdgram_bsd_set_readable_handler(bsds, NULL, NULL, NULL);
+
+	return 0;
+}
+
+static void tdgram_bsd_recvfrom_handler(void *private_data);
+
+static struct tevent_req *tdgram_bsd_recvfrom_send(TALLOC_CTX *mem_ctx,
+					struct tevent_context *ev,
+					struct tdgram_context *dgram)
+{
+	struct tevent_req *req;
+	struct tdgram_bsd_recvfrom_state *state;
+	struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
+	int ret;
+
+	req = tevent_req_create(mem_ctx, &state,
+				struct tdgram_bsd_recvfrom_state);
+	if (!req) {
+		return NULL;
+	}
+
+	state->dgram	= dgram;
+	state->buf	= NULL;
+	state->len	= 0;
+	state->src	= NULL;
+
+	if (bsds->read_req) {
+		tevent_req_error(req, EBUSY);
+		goto post;
+	}
+	bsds->read_req = req;
+
+	talloc_set_destructor(state, tdgram_bsd_recvfrom_destructor);
+
+	if (bsds->fd == -1) {
+		tevent_req_error(req, ENOTCONN);
+		goto post;
+	}
+
+	/*
+	 * this is a fast path, not waiting for the
+	 * socket to become explicit readable gains
+	 * about 10%-20% performance in benchmark tests.
+	 */
+	tdgram_bsd_recvfrom_handler(req);
+	if (!tevent_req_is_in_progress(req)) {
+		goto post;
+	}
+
+	ret = tdgram_bsd_set_readable_handler(bsds, ev,
+					      tdgram_bsd_recvfrom_handler,
+					      req);
+	if (ret == -1) {
+		tevent_req_error(req, errno);
+		goto post;
+	}
+
+	return req;
+
+ post:
+	tevent_req_post(req, ev);
+	return req;
+}
+
+static void tdgram_bsd_recvfrom_handler(void *private_data)
+{
+	struct tevent_req *req = talloc_get_type_abort(private_data,
+				 struct tevent_req);
+	struct tdgram_bsd_recvfrom_state *state = tevent_req_data(req,
+					struct tdgram_bsd_recvfrom_state);
+	struct tdgram_context *dgram = state->dgram;
+	struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
+	struct tsocket_address_bsd *bsda;
+	ssize_t ret;
+	struct sockaddr *sa = NULL;
+	socklen_t sa_len = 0;
+	int err;
+	bool retry;
+
+	ret = tsocket_bsd_pending(bsds->fd);
+	if (ret == 0) {
+		/* retry later */
+		return;
+	}
+	err = tsocket_bsd_error_from_errno(ret, errno, &retry);
+	if (retry) {
+		/* retry later */
+		return;
+	}
+	if (tevent_req_error(req, err)) {
+		return;
+	}
+
+	state->buf = talloc_array(state, uint8_t, ret);
+	if (tevent_req_nomem(state->buf, req)) {
+		return;
+	}
+	state->len = ret;
+
+	state->src = tsocket_address_create(state,
+					    &tsocket_address_bsd_ops,
+					    &bsda,
+					    struct tsocket_address_bsd,
+					    __location__ "bsd_recvfrom");
+	if (tevent_req_nomem(state->src, req)) {
+		return;
+	}
+
+	ZERO_STRUCTP(bsda);
+
+	sa = &bsda->u.sa;
+	sa_len = sizeof(bsda->u.ss);
+
+	ret = recvfrom(bsds->fd, state->buf, state->len, 0, sa, &sa_len);
+	err = tsocket_error_from_errno(ret, errno, &retry);
+	if (retry) {
+		/* retry later */
+		return;
+	}
+	if (tevent_req_error(req, err)) {
+		return;
+	}
+
+	if (ret != state->len) {
+		tevent_req_error(req, EIO);
+		return;
+	}
+
+	tevent_req_done(req);
+}
+
+static ssize_t tdgram_bsd_recvfrom_recv(struct tevent_req *req,
+					int *perrno,
+					TALLOC_CTX *mem_ctx,
+					uint8_t **buf,
+					struct tsocket_address **src)
+{
+	struct tdgram_bsd_recvfrom_state *state = tevent_req_data(req,
+					struct tdgram_bsd_recvfrom_state);
+	ssize_t ret;
+
+	ret = tsocket_simple_int_recv(req, perrno);
+	if (ret == 0) {
+		*buf = talloc_move(mem_ctx, &state->buf);
+		ret = state->len;
+		if (src) {
+			*src = talloc_move(mem_ctx, &state->src);
+		}
+	}
+
+	tevent_req_received(req);
+	return ret;
+}
+
+struct tdgram_bsd_sendto_state {
+	struct tdgram_context *dgram;
+
+	const uint8_t *buf;
+	size_t len;
+	const struct tsocket_address *dst;
+
+	ssize_t ret;
+};
+
+static int tdgram_bsd_sendto_destructor(struct tdgram_bsd_sendto_state *state)
+{
+	struct tdgram_bsd *bsds = tdgram_context_data(state->dgram,
+				  struct tdgram_bsd);
+
+	bsds->write_req = NULL;
+	tdgram_bsd_set_writeable_handler(bsds, NULL, NULL, NULL);
+	return 0;
+}
+
+static void tdgram_bsd_sendto_handler(void *private_data);
+
+static struct tevent_req *tdgram_bsd_sendto_send(TALLOC_CTX *mem_ctx,
+						 struct tevent_context *ev,
+						 struct tdgram_context *dgram,
+						 const uint8_t *buf,
+						 size_t len,
+						 const struct tsocket_address *dst)
+{
+	struct tevent_req *req;
+	struct tdgram_bsd_sendto_state *state;
+	struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
+	int ret;
+
+	req = tevent_req_create(mem_ctx, &state,
+				struct tdgram_bsd_sendto_state);
+	if (!req) {
+		return NULL;
+	}
+
+	state->dgram	= dgram;
+	state->buf	= buf;
+	state->len	= len;
+	state->dst	= dst;
+	state->ret	= -1;
+
+	if (bsds->write_req) {
+		tevent_req_error(req, EBUSY);
+		goto post;
+	}
+	bsds->write_req = req;
+
+	talloc_set_destructor(state, tdgram_bsd_sendto_destructor);
+
+	if (bsds->fd == -1) {
+		tevent_req_error(req, ENOTCONN);
+		goto post;
+	}
+
+	/*
+	 * this is a fast path, not waiting for the
+	 * socket to become explicit writeable gains
+	 * about 10%-20% performance in benchmark tests.
+	 */
+	tdgram_bsd_sendto_handler(req);
+	if (!tevent_req_is_in_progress(req)) {
+		goto post;
+	}
+
+	ret = tdgram_bsd_set_writeable_handler(bsds, ev,
+					       tdgram_bsd_sendto_handler,
+					       req);
+	if (ret == -1) {
+		tevent_req_error(req, errno);
+		goto post;
+	}
+
+	return req;
+
+ post:
+	tevent_req_post(req, ev);
+	return req;
+}
+
+static void tdgram_bsd_sendto_handler(void *private_data)
+{
+	struct tevent_req *req = talloc_get_type_abort(private_data,
+				 struct tevent_req);
+	struct tdgram_bsd_sendto_state *state = tevent_req_data(req,
+					struct tdgram_bsd_sendto_state);
+	struct tdgram_context *dgram = state->dgram;
+	struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
+	struct sockaddr *sa = NULL;
+	socklen_t sa_len = 0;
+	ssize_t ret;
+	int err;
+	bool retry;
+
+	if (state->dst) {
+		struct tsocket_address_bsd *bsda =
+			talloc_get_type(state->dst->private_data,
+			struct tsocket_address_bsd);
+
+		sa = &bsda->u.sa;
+		sa_len = sizeof(bsda->u.ss);
+	}
+
+	ret = sendto(bsds->fd, state->buf, state->len, 0, sa, sa_len);
+	err = tsocket_error_from_errno(ret, errno, &retry);
+	if (retry) {
+		/* retry later */
+		return;
+	}
+	if (tevent_req_error(req, err)) {
+		return;
+	}
+
+	state->ret = ret;
+
+	tevent_req_done(req);
+}
+
+static ssize_t tdgram_bsd_sendto_recv(struct tevent_req *req, int *perrno)
+{
+	struct tdgram_bsd_sendto_state *state = tevent_req_data(req,
+					struct tdgram_bsd_sendto_state);
+	ssize_t ret;
+
+	ret = tsocket_simple_int_recv(req, perrno);
+	if (ret == 0) {
+		ret = state->ret;
+	}
+
+	tevent_req_received(req);
+	return ret;
+}
+
+struct tdgram_bsd_disconnect_state {
+	uint8_t __dummy;
+};
+
+static struct tevent_req *tdgram_bsd_disconnect_send(TALLOC_CTX *mem_ctx,
+						     struct tevent_context *ev,
+						     struct tdgram_context *dgram)
+{
+	struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
+	struct tevent_req *req;
+	struct tdgram_bsd_disconnect_state *state;
+	int ret;
+	int err;
+	bool dummy;
+
+	req = tevent_req_create(mem_ctx, &state,
+				struct tdgram_bsd_disconnect_state);
+	if (req == NULL) {
+		return NULL;
+	}
+
+	if (bsds->read_req || bsds->write_req) {
+		tevent_req_error(req, EBUSY);
+		goto post;
+	}
+
+	if (bsds->fd == -1) {
+		tevent_req_error(req, ENOTCONN);
+		goto post;
+	}
+
+	ret = close(bsds->fd);
+	bsds->fd = -1;
+	err = tsocket_error_from_errno(ret, errno, &dummy);
+	if (tevent_req_error(req, err)) {
+		goto post;
+	}
+
+	tevent_req_done(req);
+post:
+	tevent_req_post(req, ev);
+	return req;
+}
+
+static int tdgram_bsd_disconnect_recv(struct tevent_req *req,
+				      int *perrno)
+{
+	int ret;
+
+	ret = tsocket_simple_int_recv(req, perrno);
+
+	tevent_req_received(req);
+	return ret;
+}
+
+static const struct tdgram_context_ops tdgram_bsd_ops = {
+	.name			= "bsd",
+
+	.recvfrom_send		= tdgram_bsd_recvfrom_send,
+	.recvfrom_recv		= tdgram_bsd_recvfrom_recv,
+
+	.sendto_send		= tdgram_bsd_sendto_send,
+	.sendto_recv		= tdgram_bsd_sendto_recv,
+
+	.disconnect_send	= tdgram_bsd_disconnect_send,
+	.disconnect_recv	= tdgram_bsd_disconnect_recv,
+};
+
+static int tdgram_bsd_destructor(struct tdgram_bsd *bsds)
+{
+	TALLOC_FREE(bsds->fde);
+	if (bsds->fd != -1) {
+		close(bsds->fd);
+		bsds->fd = -1;
+	}
+	return 0;
+}
+
+static int tdgram_bsd_dgram_socket(const struct tsocket_address *local,
+				   const struct tsocket_address *remote,
+				   TALLOC_CTX *mem_ctx,
+				   struct tdgram_context **_dgram,
+				   const char *location)
+{
+	struct tsocket_address_bsd *lbsda =
+		talloc_get_type_abort(local->private_data,
+		struct tsocket_address_bsd);
+	struct tsocket_address_bsd *rbsda = NULL;
+	struct tdgram_context *dgram;
+	struct tdgram_bsd *bsds;
+	int fd;
+	int ret;
+	bool do_bind = false;
+	bool do_reuseaddr = false;
+
+	if (remote) {
+		rbsda = talloc_get_type_abort(remote->private_data,
+			struct tsocket_address_bsd);
+	}
+
+	switch (lbsda->u.sa.sa_family) {
+	case AF_UNIX:
+		if (lbsda->u.un.sun_path[0] != 0) {
+			do_reuseaddr = true;
+			do_bind = true;
+		}
+		break;
+	case AF_INET:
+		if (lbsda->u.in.sin_port != 0) {
+			do_reuseaddr = true;
+			do_bind = true;
+		}
+		if (lbsda->u.in.sin_addr.s_addr == INADDR_ANY) {
+			do_bind = true;
+		}
+		break;
+#ifdef HAVE_IPV6
+	case AF_INET6:
+		if (lbsda->u.in6.sin6_port != 0) {
+			do_reuseaddr = true;
+			do_bind = true;
+		}
+		if (memcmp(&in6addr_any,
+			   &lbsda->u.in6.sin6_addr,
+			   sizeof(in6addr_any)) != 0) {
+			do_bind = true;
+		}
+		break;
+#endif
+	default:
+		errno = EINVAL;
+		return -1;
+	}
+
+	fd = socket(lbsda->u.sa.sa_family, SOCK_DGRAM, 0);
+	if (fd < 0) {
+		return fd;
+	}
+
+	fd = tsocket_bsd_common_prepare_fd(fd, true);
+	if (fd < 0) {
+		return fd;
+	}
+
+	dgram = tdgram_context_create(mem_ctx,
+				      &tdgram_bsd_ops,
+				      &bsds,
+				      struct tdgram_bsd,
+				      location);
+	if (!dgram) {
+		int saved_errno = errno;
+		close(fd);
+		errno = saved_errno;
+		return -1;
+	}
+	ZERO_STRUCTP(bsds);
+	bsds->fd = fd;
+	talloc_set_destructor(bsds, tdgram_bsd_destructor);
+
+	if (lbsda->broadcast) {
+		int val = 1;
+
+		ret = setsockopt(fd, SOL_SOCKET, SO_BROADCAST,
+				 (const void *)&val, sizeof(val));
+		if (ret == -1) {
+			int saved_errno = errno;
+			talloc_free(dgram);
+			errno = saved_errno;
+			return ret;
+		}
+	}
+
+	if (do_reuseaddr) {
+		int val = 1;
+
+		ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
+				 (const void *)&val, sizeof(val));
+		if (ret == -1) {
+			int saved_errno = errno;
+			talloc_free(dgram);
+			errno = saved_errno;
+			return ret;
+		}
+	}
+
+	if (do_bind) {
+		ret = bind(fd, &lbsda->u.sa, sizeof(lbsda->u.ss));
+		if (ret == -1) {
+			int saved_errno = errno;
+			talloc_free(dgram);
+			errno = saved_errno;
+			return ret;
+		}
+	}
+
+	if (rbsda) {
+		ret = connect(fd, &rbsda->u.sa, sizeof(rbsda->u.ss));
+		if (ret == -1) {
+			int saved_errno = errno;
+			talloc_free(dgram);
+			errno = saved_errno;
+			return ret;
+		}
+	}
+
+	*_dgram = dgram;
+	return 0;
+}
+
+int _tdgram_inet_udp_socket(const struct tsocket_address *local,
+			    const struct tsocket_address *remote,
+			    TALLOC_CTX *mem_ctx,
+			    struct tdgram_context **dgram,
+			    const char *location)
+{
+	struct tsocket_address_bsd *lbsda =
+		talloc_get_type_abort(local->private_data,
+		struct tsocket_address_bsd);
+	int ret;
+
+	switch (lbsda->u.sa.sa_family) {
+	case AF_INET:
+		break;
+#ifdef HAVE_IPV6
+	case AF_INET6:
+		break;
+#endif
+	default:
+		errno = EINVAL;
+		return -1;
+	}
+
+	ret = tdgram_bsd_dgram_socket(local, remote, mem_ctx, dgram, location);
+
+	return ret;
+}
+
+int _tdgram_unix_dgram_socket(const struct tsocket_address *local,
+			      const struct tsocket_address *remote,
+			      TALLOC_CTX *mem_ctx,
+			      struct tdgram_context **dgram,
+			      const char *location)
+{
+	struct tsocket_address_bsd *lbsda =
+		talloc_get_type_abort(local->private_data,
+		struct tsocket_address_bsd);
+	int ret;
+
+	switch (lbsda->u.sa.sa_family) {
+	case AF_UNIX:
+		break;
+	default:
+		errno = EINVAL;
+		return -1;
+	}
+
+	ret = tdgram_bsd_dgram_socket(local, remote, mem_ctx, dgram, location);
+
+	return ret;
+}
+
diff --git a/lib/tsocket/tsocket_internal.h b/lib/tsocket/tsocket_internal.h
index e4a4908f3e..893394405f 100644
--- a/lib/tsocket/tsocket_internal.h
+++ b/lib/tsocket/tsocket_internal.h
@@ -57,14 +57,6 @@ struct tsocket_context_ops {
 	int (*writev_data)(struct tsocket_context *sock,
 			   const struct iovec *vector, size_t count);
 
-	ssize_t (*recvfrom_data)(struct tsocket_context *sock,
-				 uint8_t *data, size_t len,
-				 TALLOC_CTX *addr_ctx,
-				 struct tsocket_address **remote_addr);
-	ssize_t (*sendto_data)(struct tsocket_context *sock,
-			       const uint8_t *data, size_t len,
-			       const struct tsocket_address *remote_addr);
-
 	/* info */
 	int (*get_status)(const struct tsocket_context *sock);
 	int (*get_local_address)(const struct tsocket_context *sock,
@@ -149,6 +141,47 @@ struct tsocket_address *_tsocket_address_create(TALLOC_CTX *mem_ctx,
 	_tsocket_address_create(mem_ctx, ops, state, sizeof(type), \
 				#type, location)
 
+struct tdgram_context_ops {
+	const char *name;
+
+	struct tevent_req *(*recvfrom_send)(TALLOC_CTX *mem_ctx,
+					    struct tevent_context *ev,
+					    struct tdgram_context *dgram);
+	ssize_t (*recvfrom_recv)(struct tevent_req *req,
+				 int *perrno,
+				 TALLOC_CTX *mem_ctx,
+				 uint8_t **buf,
+				 struct tsocket_address **src);
+
+	struct tevent_req *(*sendto_send)(TALLOC_CTX *mem_ctx,
+					  struct tevent_context *ev,
+					  struct tdgram_context *dgram,
+					  const uint8_t *buf, size_t len,
+					  const struct tsocket_address *dst);
+	ssize_t (*sendto_recv)(struct tevent_req *req,
+			       int *perrno);
+
+	struct tevent_req *(*disconnect_send)(TALLOC_CTX *mem_ctx,
+					      struct tevent_context *ev,
+					      struct tdgram_context *dgram);
+	int (*disconnect_recv)(struct tevent_req *req,
+			       int *perrno);
+};
+
+struct tdgram_context *_tdgram_context_create(TALLOC_CTX *mem_ctx,
+					const struct tdgram_context_ops *ops,
+					void *pstate,
+					size_t psize,
+					const char *type,
+					const char *location);
+#define tdgram_context_create(mem_ctx, ops, state, type, location) \
+	_tdgram_context_create(mem_ctx, ops, state, sizeof(type), \
+				#type, location)
+
+void *_tdgram_context_data(struct tdgram_context *dgram);
+#define tdgram_context_data(_req, _type) \
+	talloc_get_type_abort(_tdgram_context_data(_req), _type)
+
 int tsocket_error_from_errno(int ret, int sys_errno, bool *retry);
 int tsocket_simple_int_recv(struct tevent_req *req, int *perrno);
 int tsocket_common_prepare_fd(int fd, bool high_fd);
diff --git a/lib/tsocket/tsocket_recvfrom.c b/lib/tsocket/tsocket_recvfrom.c
deleted file mode 100644
index 467738cfc2..0000000000
--- a/lib/tsocket/tsocket_recvfrom.c
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
-   Unix SMB/CIFS implementation.
-
-   Copyright (C) Stefan Metzmacher 2009
-
-     ** NOTE! The following LGPL license applies to the tevent
-     ** library. This does NOT imply that all of Samba is released
-     ** under the LGPL
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 3 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "replace.h"
-#include "system/network.h"
-#include "tsocket.h"
-#include "tsocket_internal.h"
-
-struct tsocket_recvfrom_state {
-	/* this structs are owned by the caller */
-	struct {
-		struct tsocket_context *sock;
-	} caller;
-
-	uint8_t *buf;
-	size_t len;
-	struct tsocket_address *src;
-};
-
-static int tsocket_recvfrom_state_destructor(struct tsocket_recvfrom_state *state)
-{
-	if (state->caller.sock) {
-		tsocket_set_readable_handler(state->caller.sock, NULL, NULL);
-	}
-	ZERO_STRUCT(state->caller);
-
-	return 0;
-}
-
-static void tsocket_recvfrom_handler(struct tsocket_context *sock,
-				     void *private_data);
-
-struct tevent_req *tsocket_recvfrom_send(struct tsocket_context *sock,
-					 TALLOC_CTX *mem_ctx)
-{
-	struct tevent_req *req;
-	struct tsocket_recvfrom_state *state;
-	int ret;
-	int err;
-	bool dummy;
-
-	req = tevent_req_create(mem_ctx, &state,
-				struct tsocket_recvfrom_state);
-	if (!req) {
-		return NULL;
-	}
-
-	state->caller.sock	= sock;
-	state->buf		= NULL;
-	state->len		= 0;
-	state->src		= NULL;
-
-	talloc_set_destructor(state, tsocket_recvfrom_state_destructor);
-
-	ret = tsocket_set_readable_handler(sock,
-					   tsocket_recvfrom_handler,
-					   req);
-	err = tsocket_error_from_errno(ret, errno, &dummy);
-	if (tevent_req_error(req, err)) {
-		goto post;
-	}
-
-	return req;
-
- post:
-	return tevent_req_post(req, sock->event.ctx);
-}
-
-static void tsocket_recvfrom_handler(struct tsocket_context *sock,
-				     void *private_data)
-{
-	struct tevent_req *req = talloc_get_type(private_data,
-				 struct tevent_req);
-	struct tsocket_recvfrom_state *state = tevent_req_data(req,
-					       struct tsocket_recvfrom_state);
-	ssize_t ret;
-	int err;
-	bool retry;
-
-	ret = tsocket_pending(state->caller.sock);
-	if (ret == 0) {
-		/* retry later */
-		return;
-	}
-	err = tsocket_error_from_errno(ret, errno, &retry);
-	if (retry) {
-		/* retry later */
-		return;
-	}
-	if (tevent_req_error(req, err)) {
-		return;
-	}
-
-	state->buf = talloc_array(state, uint8_t, ret);
-	if (tevent_req_nomem(state->buf, req)) {
-		return;
-	}
-	state->len = ret;
-
-	ret = tsocket_recvfrom(state->caller.sock,
-			       state->buf,
-			       state->len,
-			       state,
-			       &state->src);
-	err = tsocket_error_from_errno(ret, errno, &retry);
-	if (retry) {
-		/* retry later */
-		return;
-	}
-	if (tevent_req_error(req, err)) {
-		return;
-	}
-
-	if (ret != state->len) {
-		tevent_req_error(req, EIO);
-		return;
-	}
-
-	tevent_req_done(req);
-}
-
-ssize_t tsocket_recvfrom_recv(struct tevent_req *req,
-			      int *perrno,
-			      TALLOC_CTX *mem_ctx,
-			      uint8_t **buf,
-			      struct tsocket_address **src)
-{
-	struct tsocket_recvfrom_state *state = tevent_req_data(req,
-					       struct tsocket_recvfrom_state);
-	ssize_t ret;
-
-	ret = tsocket_simple_int_recv(req, perrno);
-	if (ret == 0) {
-		*buf = talloc_move(mem_ctx, &state->buf);
-		ret = state->len;
-		if (src) {
-			*src = talloc_move(mem_ctx, &state->src);
-		}
-	}
-
-	tevent_req_received(req);
-	return ret;
-}
-
diff --git a/lib/tsocket/tsocket_sendto.c b/lib/tsocket/tsocket_sendto.c
deleted file mode 100644
index 9c0a76bf16..0000000000
--- a/lib/tsocket/tsocket_sendto.c
+++ /dev/null
@@ -1,271 +0,0 @@
-/*
-   Unix SMB/CIFS implementation.
-
-   Copyright (C) Stefan Metzmacher 2009
-
-     ** NOTE! The following LGPL license applies to the tevent
-     ** library. This does NOT imply that all of Samba is released
-     ** under the LGPL
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 3 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "replace.h"
-#include "system/network.h"
-#include "tsocket.h"
-#include "tsocket_internal.h"
-
-struct tsocket_sendto_state {
-	/* this structs are owned by the caller */
-	struct {
-		struct tsocket_context *sock;
-		const uint8_t *buf;
-		size_t len;
-		const struct tsocket_address *dst;
-	} caller;
-
-	ssize_t ret;
-};
-
-static int tsocket_sendto_state_destructor(struct tsocket_sendto_state *state)
-{
-	if (state->caller.sock) {
-		tsocket_set_writeable_handler(state->caller.sock, NULL, NULL);
-	}
-	ZERO_STRUCT(state->caller);
-
-	return 0;
-}
-
-static void tsocket_sendto_handler(struct tsocket_context *sock,
-				   void *private_data);
-
-struct tevent_req *tsocket_sendto_send(struct tsocket_context *sock,
-				       TALLOC_CTX *mem_ctx,
-				       const uint8_t *buf,
-				       size_t len,
-				       const struct tsocket_address *dst)
-{
-	struct tevent_req *req;
-	struct tsocket_sendto_state *state;
-	int ret;
-	int err;
-	bool dummy;
-
-	req = tevent_req_create(mem_ctx, &state,
-				struct tsocket_sendto_state);
-	if (!req) {
-		return NULL;
-	}
-
-	state->caller.sock	= sock;
-	state->caller.buf	= buf;
-	state->caller.len	= len;
-	state->caller.dst	= dst;
-	state->ret		= -1;
-
-	/*
-	 * this is a fast path, not waiting for the
-	 * socket to become explicit writeable gains
-	 * about 10%-20% performance in benchmark tests.
-	 */
-	tsocket_sendto_handler(sock, req);
-	if (!tevent_req_is_in_progress(req)) {
-		goto post;
-	}
-
-	talloc_set_destructor(state, tsocket_sendto_state_destructor);
-
-	ret = tsocket_set_writeable_handler(sock,
-					    tsocket_sendto_handler,
-					    req);
-	err = tsocket_error_from_errno(ret, errno, &dummy);
-	if (tevent_req_error(req, err)) {
-		goto post;
-	}
-
-	return req;
-
- post:
-	return tevent_req_post(req, sock->event.ctx);
-}
-
-static void tsocket_sendto_handler(struct tsocket_context *sock,
-				   void *private_data)
-{
-	struct tevent_req *req = talloc_get_type(private_data,
-				 struct tevent_req);
-	struct tsocket_sendto_state *state = tevent_req_data(req,
-					     struct tsocket_sendto_state);
-	ssize_t ret;
-	int err;
-	bool retry;
-
-	ret = tsocket_sendto(state->caller.sock,
-			     state->caller.buf,
-			     state->caller.len,
-			     state->caller.dst);
-	err = tsocket_error_from_errno(ret, errno, &retry);
-	if (retry) {
-		/* retry later */
-		return;
-	}
-	if (tevent_req_error(req, err)) {
-		return;
-	}
-
-	state->ret = ret;
-
-	tevent_req_done(req);
-}
-
-ssize_t tsocket_sendto_recv(struct tevent_req *req, int *perrno)
-{
-	struct tsocket_sendto_state *state = tevent_req_data(req,
-					     struct tsocket_sendto_state);
-	ssize_t ret;
-
-	ret = tsocket_simple_int_recv(req, perrno);
-	if (ret == 0) {
-		ret = state->ret;
-	}
-
-	tevent_req_received(req);
-	return ret;
-}
-
-struct tsocket_sendto_queue_state {
-	/* this structs are owned by the caller */
-	struct {
-		struct tsocket_context *sock;
-		const uint8_t *buf;
-		size_t len;
-		const struct tsocket_address *dst;
-	} caller;
-	ssize_t ret;
-};
-
-static void tsocket_sendto_queue_trigger(struct tevent_req *req,
-					 void *private_data);
-static void tsocket_sendto_queue_done(struct tevent_req *subreq);
-
-/**
- * @brief Queue a dgram blob for sending through the socket
- * @param[in] mem_ctx	The memory context for the result
- * @param[in] sock	The socket to send the message buffer
- * @param[in] queue	The existing dgram queue
- * @param[in] buf	The message buffer
- * @param[in] len	The message length
- * @param[in] dst	The destination socket address
- * @retval		The async request handle
- *
- * This function queues a blob for sending to destination through an existing
- * dgram socket. The async callback is triggered when the whole blob is
- * delivered to the underlying system socket.
- *
- * The caller needs to make sure that all non-scalar input parameters hang
- * arround for the whole lifetime of the request.
- */
-struct tevent_req *tsocket_sendto_queue_send(TALLOC_CTX *mem_ctx,
-					     struct tsocket_context *sock,
-					     struct tevent_queue *queue,
-					     const uint8_t *buf,
-					     size_t len,
-					     struct tsocket_address *dst)
-{
-	struct tevent_req *req;
-	struct tsocket_sendto_queue_state *state;
-	bool ok;
-
-	req = tevent_req_create(mem_ctx, &state,
-				struct tsocket_sendto_queue_state);
-	if (!req) {
-		return NULL;
-	}
-
-	state->caller.sock	= sock;
-	state->caller.buf	= buf;
-	state->caller.len	= len;
-	state->caller.dst	= dst;
-	state->ret		= -1;
-
-	ok = tevent_queue_add(queue,
-			      sock->event.ctx,
-			      req,
-			      tsocket_sendto_queue_trigger,
-			      NULL);
-	if (!ok) {
-		tevent_req_nomem(NULL, req);
-		goto post;
-	}
-
-	return req;
-
- post:
-	return tevent_req_post(req, sock->event.ctx);
-}
-
-static void tsocket_sendto_queue_trigger(struct tevent_req *req,
-					 void *private_data)
-{
-	struct tsocket_sendto_queue_state *state = tevent_req_data(req,
-					struct tsocket_sendto_queue_state);
-	struct tevent_req *subreq;
-
-	subreq = tsocket_sendto_send(state->caller.sock,
-				     state,
-				     state->caller.buf,
-				     state->caller.len,
-				     state->caller.dst);
-	if (tevent_req_nomem(subreq, req)) {
-		return;
-	}
-	tevent_req_set_callback(subreq, tsocket_sendto_queue_done ,req);
-}
-
-static void tsocket_sendto_queue_done(struct tevent_req *subreq)
-{
-	struct tevent_req *req = tevent_req_callback_data(subreq,
-				 struct tevent_req);
-	struct tsocket_sendto_queue_state *state = tevent_req_data(req,
-					struct tsocket_sendto_queue_state);
-	ssize_t ret;
-	int sys_errno;
-
-	ret = tsocket_sendto_recv(subreq, &sys_errno);
-	talloc_free(subreq);
-	if (ret == -1) {
-		tevent_req_error(req, sys_errno);
-		return;
-	}
-	state->ret = ret;
-
-	tevent_req_done(req);
-}
-
-ssize_t tsocket_sendto_queue_recv(struct tevent_req *req, int *perrno)
-{
-	struct tsocket_sendto_queue_state *state = tevent_req_data(req,
-					struct tsocket_sendto_queue_state);
-	ssize_t ret;
-
-	ret = tsocket_simple_int_recv(req, perrno);
-	if (ret == 0) {
-		ret = state->ret;
-	}
-
-	tevent_req_received(req);
-	return ret;
-}
-
diff --git a/lib/util/smb_threads.c b/lib/util/smb_threads.c
new file mode 100644
index 0000000000..84dec4d874
--- /dev/null
+++ b/lib/util/smb_threads.c
@@ -0,0 +1,105 @@
+/*
+   Unix SMB/CIFS implementation.
+   SMB client library implementation (thread interface functions).
+   Copyright (C) Jeremy Allison, 2009.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*
+ * This code is based in the ideas in openssl
+ * but somewhat simpler and expended to include
+ * thread local storage.
+ */
+
+#include "includes.h"
+
+#define NUM_GLOBAL_LOCKS 1
+
+/*********************************************************
+ Functions to vector the locking primitives used internally
+ by libsmbclient.
+*********************************************************/
+
+const struct smb_thread_functions *global_tfp;
+
+/*********************************************************
+ Dynamic lock array.
+*********************************************************/
+
+void **global_lock_array;
+
+/*********************************************************
+ Function to set the locking primitives used by libsmbclient.
+*********************************************************/
+
+int smb_thread_set_functions(const struct smb_thread_functions *tf)
+{
+	int i;
+
+	global_tfp = tf;
+
+	/* Here we initialize any static locks we're using. */
+	global_lock_array = (void **)SMB_MALLOC_ARRAY(void *, NUM_GLOBAL_LOCKS);
+	if (global_lock_array == NULL) {
+		return ENOMEM;
+	}
+
+	for (i = 0; i < NUM_GLOBAL_LOCKS; i++) {
+		char *name = NULL;
+		if (asprintf(&name, "global_lock_%d", i) == -1) {
+			SAFE_FREE(global_lock_array);
+			return ENOMEM;
+		}
+		global_tfp->create_mutex(name,
+				&global_lock_array[i],
+				__location__);
+		SAFE_FREE(name);
+	}
+
+	return 0;
+}
+
+#if 0
+/* Test. - pthread implementations. */
+#include <pthread.h>
+
+#ifdef malloc
+#undef malloc
+#endif
+
+SMB_THREADS_DEF_PTHREAD_IMPLEMENTATION(tf);
+
+/* Test function. */
+int test_threads(void)
+{
+	int ret;
+	void *plock = NULL;
+
+	smb_thread_set_functions(&tf);
+
+	if ((ret = SMB_THREAD_CREATE_MUTEX("test", plock)) != 0) {
+		printf("Create lock error: %d\n", ret);
+	}
+	if ((ret = SMB_THREAD_LOCK(plock, SMB_THREAD_LOCK)) != 0) {
+		printf("lock error: %d\n", ret);
+	}
+	if ((SMB_THREAD_LOCK(plock, SMB_THREAD_UNLOCK)) != 0) {
+		printf("unlock error: %d\n", ret);
+	}
+	SMB_THREAD_DESTROY_MUTEX(plock);
+
+	return 0;
+}
+#endif
diff --git a/lib/util/smb_threads.h b/lib/util/smb_threads.h
new file mode 100644
index 0000000000..2ca163be9a
--- /dev/null
+++ b/lib/util/smb_threads.h
@@ -0,0 +1,120 @@
+/*
+	Unix SMB/CIFS implementation.
+	SMB thread interface functions.
+	Copyright (C) Jeremy Allison, 2009.
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _smb_threads_h_
+#define _smb_threads_h_
+
+enum smb_thread_lock_type {
+	SMB_THREAD_LOCK = 1,
+	SMB_THREAD_UNLOCK
+};
+
+struct smb_thread_functions {
+	/* Mutex and tls functions. */
+	int (*create_mutex)(const char *lockname,
+			void **pplock,
+			const char *location);
+	void (*destroy_mutex)(void *plock,
+			const char *location);
+	int (*lock_mutex)(void *plock, enum smb_thread_lock_type lock_type,
+			const char *location);
+
+	/* Thread local storage. */
+	int (*create_tls)(const char *keyname,
+			void **ppkey,
+			const char *location);
+	void (*destroy_tls)(void *pkey,
+			const char *location);
+	int (*set_tls)(void *pkey, const void *pval, const char *location);
+	void *(*get_tls)(void *pkey, const char *location);
+};
+
+extern const struct smb_thread_functions *global_tfp;
+
+/* Define the pthread version of the functions. */
+
+#define SMB_THREADS_DEF_PTHREAD_IMPLEMENTATION(tf) \
+ \
+static int smb_create_mutex_pthread(const char *lockname, void **pplock, const char *location) \
+{ \
+        pthread_mutex_t *pmut = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)); \
+        if (!pmut) { \
+                return ENOMEM; \
+        } \
+        pthread_mutex_init(pmut, NULL); \
+        *pplock = (void *)pmut; \
+        return 0; \
+} \
+ \
+static void smb_destroy_mutex_pthread(void *plock, const char *location) \
+{ \
+        pthread_mutex_destroy((pthread_mutex_t *)plock); \
+	free(plock); \
+} \
+ \
+static int smb_lock_pthread(void *plock, enum smb_thread_lock_type lock_type, const char *location) \
+{ \
+        if (lock_type == SMB_THREAD_UNLOCK) { \
+                return pthread_mutex_unlock((pthread_mutex_t *)plock); \
+        } else { \
+                return pthread_mutex_lock((pthread_mutex_t *)plock); \
+        } \
+} \
+ \
+static int smb_create_tls_pthread(const char *keyname, void **ppkey, const char *location) \
+{ \
+        int ret; \
+        pthread_key_t *pkey = (pthread_key_t *)malloc(sizeof(pthread_key_t)); \
+        if (!pkey) { \
+                return ENOMEM; \
+        } \
+        ret = pthread_key_create(pkey, NULL); \
+        if (ret) { \
+                return ret; \
+        } \
+        *ppkey = (void *)pkey; \
+        return 0; \
+} \
+ \
+static void smb_destroy_tls_pthread(void *pkey, const char *location) \
+{ \
+        pthread_key_delete(*(pthread_key_t *)pkey); \
+        free(pkey); \
+} \
+ \
+static int smb_set_tls_pthread(void *pkey, const void *pval, const char *location) \
+{ \
+        return pthread_setspecific(*(pthread_key_t *)pkey, pval); \
+} \
+ \
+static void *smb_get_tls_pthread(void *pkey, const char *location) \
+{ \
+        return pthread_getspecific(*(pthread_key_t *)pkey); \
+} \
+ \
+static const struct smb_thread_functions (tf) = { \
+                        smb_create_mutex_pthread, \
+                        smb_destroy_mutex_pthread, \
+                        smb_lock_pthread, \
+                        smb_create_tls_pthread, \
+                        smb_destroy_tls_pthread, \
+                        smb_set_tls_pthread, \
+                        smb_get_tls_pthread }
+
+#endif
diff --git a/lib/util/smb_threads_internal.h b/lib/util/smb_threads_internal.h
new file mode 100644
index 0000000000..3208bc27e1
--- /dev/null
+++ b/lib/util/smb_threads_internal.h
@@ -0,0 +1,52 @@
+/*
+	SMB/CIFS implementation.
+	SMB thread interface internal macros.
+	Copyright (C) Jeremy Allison, 2009.
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _smb_threads_internal_h_
+#define _smb_threads_internal_h_
+
+#define SMB_THREAD_CREATE_MUTEX(name, lockvar) \
+	(global_tfp ? global_tfp->create_mutex((name), &(lockvar), __location__) : 0)
+
+#define SMB_THREAD_DESTROY_MUTEX(plock) \
+	do { \
+		if (global_tfp) { \
+			global_tfp->destroy_mutex(plock, __location__); \
+		}; \
+	} while (0)
+
+#define SMB_THREAD_LOCK(plock, type) \
+	(global_tfp ? global_tfp->lock_mutex((plock), (type), __location__) : 0)
+
+#define SMB_THREAD_CREATE_TLS(keyname, key) \
+	(global_tfp ? global_tfp->create_tls((keyname), &(key), __location__) : 0)
+
+#define SMB_THREAD_DESTROY_TLS(key) \
+	do { \
+		if (global_tfp) { \
+			global_tfp->destroy_tls(key); \
+		}; \
+	} while (0)
+
+#define SMB_THREAD_SET_TLS(key, val) \
+	(global_tfp ? global_tfp->set_tls((key),(val),__location__) : 0)
+
+#define SMB_THREAD_GET_TLS(key) \
+	(global_tfp ? global_tfp->get_tls((key), __location__) : NULL)
+
+#endif
diff --git a/lib/util/util.h b/lib/util/util.h
index defef127d9..81c7edfbdf 100644
--- a/lib/util/util.h
+++ b/lib/util/util.h
@@ -422,7 +422,7 @@ _PUBLIC_ char *str_list_join_shell(TALLOC_CTX *mem_ctx, const char **list, char
 /**
   return the number of elements in a string list
 */
-_PUBLIC_ size_t str_list_length(const char * const *list);
+_PUBLIC_ size_t str_list_length(const char **list);
 
 /**
   copy a string list
@@ -437,7 +437,7 @@ _PUBLIC_ bool str_list_equal(const char **list1, const char **list2);
 /**
   add an entry to a string list
 */
-_PUBLIC_ const char **str_list_add(const char **list, const char *s);
+_PUBLIC_ char **str_list_add(char **list, const char *s);
 
 /**
   remove an entry from a string list
@@ -453,6 +453,40 @@ _PUBLIC_ bool str_list_check(const char **list, const char *s);
   return true if a string is in a list, case insensitively
 */
 _PUBLIC_ bool str_list_check_ci(const char **list, const char *s);
+/**
+  append one list to another - expanding list1
+*/
+_PUBLIC_ char **str_list_append(char **list1, const char **list2);
+
+/**
+ remove duplicate elements from a list 
+*/
+_PUBLIC_ char **str_list_unique(char **list);
+
+/*
+  very useful when debugging complex list related code
+ */
+_PUBLIC_ void str_list_show(const char **list);
+
+
+/**
+  append one list to another - expanding list1
+  this assumes the elements of list2 are const pointers, so we can re-use them
+*/
+_PUBLIC_ char **str_list_append_const(char **list1, const char **list2);
+
+/**
+  add an entry to a string list
+  this assumes s will not change
+*/
+_PUBLIC_ char **str_list_add_const(char **list, const char *s);
+
+/**
+  copy a string list
+  this assumes list will not change
+*/
+_PUBLIC_ char **str_list_copy_const(TALLOC_CTX *mem_ctx, const char **list);
+
 
 /* The following definitions come from lib/util/util_file.c  */
 
diff --git a/lib/util/util_strlist.c b/lib/util/util_strlist.c
index b069a11e38..bd7bd00888 100644
--- a/lib/util/util_strlist.c
+++ b/lib/util/util_strlist.c
@@ -187,7 +187,7 @@ _PUBLIC_ char *str_list_join_shell(TALLOC_CTX *mem_ctx, const char **list, char
 /**
   return the number of elements in a string list
 */
-_PUBLIC_ size_t str_list_length(const char * const*list)
+_PUBLIC_ size_t str_list_length(const char **list)
 {
 	size_t ret;
 	for (ret=0;list && list[ret];ret++) /* noop */ ;
@@ -247,12 +247,12 @@ _PUBLIC_ bool str_list_equal(const char **list1, const char **list2)
 /**
   add an entry to a string list
 */
-_PUBLIC_ const char **str_list_add(const char **list, const char *s)
+_PUBLIC_ char **str_list_add(char **list, const char *s)
 {
 	size_t len = str_list_length(list);
-	const char **ret;
+	char **ret;
 
-	ret = talloc_realloc(NULL, list, const char *, len+2);
+	ret = talloc_realloc(NULL, list, char *, len+2);
 	if (ret == NULL) return NULL;
 
 	ret[len] = talloc_strdup(ret, s);
@@ -308,3 +308,136 @@ _PUBLIC_ bool str_list_check_ci(const char **list, const char *s)
 }
 
 
+/**
+  append one list to another - expanding list1
+*/
+_PUBLIC_ char **str_list_append(char **list1, const char **list2)
+{
+	size_t len1 = str_list_length(list1);
+	size_t len2 = str_list_length(list2);
+	char **ret;
+	int i;
+
+	ret = talloc_realloc(NULL, list1, char *, len1+len2+1);
+	if (ret == NULL) return NULL;
+
+	for (i=len1;i<len1+len2;i++) {
+		ret[i] = talloc_strdup(ret, list2[i-len1]);
+		if (ret[i] == NULL) {
+			return NULL;
+		}
+	}
+	ret[i] = NULL;
+
+	return ret;
+}
+
+static int list_cmp(const char **el1, const char **el2)
+{
+	return strcmp(*el1, *el2);
+}
+
+/*
+  return a list that only contains the unique elements of a list,
+  removing any duplicates
+ */
+_PUBLIC_ char **str_list_unique(char **list)
+{
+	size_t len = str_list_length(list);
+	char **list2;
+	int i, j;
+	if (len < 2) {
+		return list;
+	}
+	list2 = (char **)talloc_memdup(list, list, sizeof(list[0])*(len+1));
+	qsort(list2, len, sizeof(list2[0]), QSORT_CAST list_cmp);
+	list[0] = list2[0];
+	for (i=j=1;i<len;i++) {
+		if (strcmp(list2[i], list[j-1]) != 0) {
+			list[j] = list2[i];
+			j++;
+		}
+	}
+	list[j] = NULL;
+	list = talloc_realloc(NULL, list, char *, j);
+	talloc_free(list2);
+	return list;
+}
+
+/*
+  very useful when debugging complex list related code
+ */
+_PUBLIC_ void str_list_show(const char **list)
+{
+	int i;
+	DEBUG(0,("{ "));
+	for (i=0;list && list[i];i++) {
+		DEBUG(0,("\"%s\", ", list[i]));
+	}
+	DEBUG(0,("}\n"));
+}
+
+
+
+/**
+  append one list to another - expanding list1
+  this assumes the elements of list2 are const pointers, so we can re-use them
+*/
+_PUBLIC_ char **str_list_append_const(char **list1, const char **list2)
+{
+	size_t len1 = str_list_length(list1);
+	size_t len2 = str_list_length(list2);
+	char **ret;
+	int i;
+
+	ret = talloc_realloc(NULL, list1, char *, len1+len2+1);
+	if (ret == NULL) return NULL;
+
+	for (i=len1;i<len1+len2;i++) {
+		ret[i] = list2[i-len1];
+	}
+	ret[i] = NULL;
+
+	return ret;
+}
+
+/**
+  add an entry to a string list
+  this assumes s will not change
+*/
+_PUBLIC_ char **str_list_add_const(char **list, const char *s)
+{
+	size_t len = str_list_length(list);
+	char **ret;
+
+	ret = talloc_realloc(NULL, list, char *, len+2);
+	if (ret == NULL) return NULL;
+
+	ret[len] = s;
+	ret[len+1] = NULL;
+
+	return ret;
+}
+
+/**
+  copy a string list
+  this assumes list will not change
+*/
+_PUBLIC_ char **str_list_copy_const(TALLOC_CTX *mem_ctx, const char **list)
+{
+	int i;
+	char **ret;
+
+	if (list == NULL)
+		return NULL;
+	
+	ret = talloc_array(mem_ctx, char *, str_list_length(list)+1);
+	if (ret == NULL) 
+		return NULL;
+
+	for (i=0;list && list[i];i++) {
+		ret[i] = list[i];
+	}
+	ret[i] = NULL;
+	return ret;
+}