It will be replaced by tdgram_context and tstream_context.
metze
LIBTSOCKET_OBJ_FILES = $(addprefix ../lib/tsocket/, \
tsocket.o \
tsocket_helpers.o \
- tsocket_bsd.o \
- tsocket_connect.o \
- tsocket_writev.o \
- tsocket_readv.o)
+ tsocket_bsd.o)
PUBLIC_HEADERS += $(addprefix ../lib/tsocket/, \
tsocket.h\
#include "tsocket.h"
#include "tsocket_internal.h"
-static int tsocket_context_destructor(struct tsocket_context *sock)
-{
- tsocket_disconnect(sock);
- return 0;
-}
-
-struct tsocket_context *_tsocket_context_create(TALLOC_CTX *mem_ctx,
- const struct tsocket_context_ops *ops,
- void *pstate,
- size_t psize,
- const char *type,
- const char *location)
-{
- void **ppstate = (void **)pstate;
- struct tsocket_context *sock;
-
- sock = talloc_zero(mem_ctx, struct tsocket_context);
- if (!sock) {
- return NULL;
- }
- sock->ops = ops;
- sock->location = location;
- sock->private_data = talloc_size(sock, psize);
- if (!sock->private_data) {
- talloc_free(sock);
- return NULL;
- }
- talloc_set_name_const(sock->private_data, type);
-
- talloc_set_destructor(sock, tsocket_context_destructor);
-
- *ppstate = sock->private_data;
- return sock;
-}
-
-int tsocket_set_event_context(struct tsocket_context *sock,
- struct tevent_context *ev)
-{
- return sock->ops->set_event_context(sock, ev);
-}
-
-int tsocket_set_readable_handler(struct tsocket_context *sock,
- tsocket_event_handler_t handler,
- void *private_data)
-{
- return sock->ops->set_read_handler(sock, handler, private_data);
-}
-
-int tsocket_set_writeable_handler(struct tsocket_context *sock,
- tsocket_event_handler_t handler,
- void *private_data)
-{
- return sock->ops->set_write_handler(sock, handler, private_data);
-}
-
-int tsocket_connect(struct tsocket_context *sock,
- const struct tsocket_address *remote_addr)
-{
- return sock->ops->connect_to(sock, remote_addr);
-}
-
-int tsocket_listen(struct tsocket_context *sock,
- int queue_size)
-{
- return sock->ops->listen_on(sock, queue_size);
-}
-
-int _tsocket_accept(struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- struct tsocket_context **new_sock,
- const char *location)
-{
- return sock->ops->accept_new(sock, mem_ctx, new_sock, location);
-}
-
-ssize_t tsocket_pending(struct tsocket_context *sock)
-{
- return sock->ops->pending_data(sock);
-}
-
-int tsocket_readv(struct tsocket_context *sock,
- const struct iovec *vector, size_t count)
-{
- return sock->ops->readv_data(sock, vector, count);
-}
-
-int tsocket_writev(struct tsocket_context *sock,
- const struct iovec *vector, size_t count)
-{
- return sock->ops->writev_data(sock, vector, count);
-}
-
-int tsocket_get_status(const struct tsocket_context *sock)
-{
- return sock->ops->get_status(sock);
-}
-
-int _tsocket_get_local_address(const struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- struct tsocket_address **local_addr,
- const char *location)
-{
- return sock->ops->get_local_address(sock, mem_ctx,
- local_addr, location);
-}
-
-int _tsocket_get_remote_address(const struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- struct tsocket_address **remote_addr,
- const char *location)
-{
- return sock->ops->get_remote_address(sock, mem_ctx,
- remote_addr, location);
-}
-
-int tsocket_get_option(const struct tsocket_context *sock,
- const char *option,
- TALLOC_CTX *mem_ctx,
- char **value)
-{
- return sock->ops->get_option(sock, option, mem_ctx, value);
-}
-
-int tsocket_set_option(const struct tsocket_context *sock,
- const char *option,
- bool force,
- const char *value)
-{
- return sock->ops->set_option(sock, option, force, value);
-}
-
-void tsocket_disconnect(struct tsocket_context *sock)
-{
- sock->ops->disconnect(sock);
-}
-
struct tsocket_address *_tsocket_address_create(TALLOC_CTX *mem_ctx,
const struct tsocket_address_ops *ops,
void *pstate,
return addr->ops->copy(addr, mem_ctx, location);
}
-int _tsocket_address_create_socket(const struct tsocket_address *addr,
- enum tsocket_type type,
- TALLOC_CTX *mem_ctx,
- struct tsocket_context **sock,
- const char *location)
-{
- return addr->ops->create_socket(addr, type, mem_ctx, sock, location);
-}
-
struct tdgram_context {
const char *location;
const struct tdgram_context_ops *ops;
#include <talloc.h>
#include <tevent.h>
-struct tsocket_context;
struct tsocket_address;
struct tdgram_context;
struct iovec;
-enum tsocket_type {
- TSOCKET_TYPE_STREAM = 1,
- TSOCKET_TYPE_MESSAGE
-};
-
-typedef void (*tsocket_event_handler_t)(struct tsocket_context *, void *);
-int tsocket_set_event_context(struct tsocket_context *sock,
- struct tevent_context *ev);
-int tsocket_set_readable_handler(struct tsocket_context *sock,
- tsocket_event_handler_t handler,
- void *private_data);
-int tsocket_set_writeable_handler(struct tsocket_context *sock,
- tsocket_event_handler_t handler,
- void *private_data);
-
-int tsocket_connect(struct tsocket_context *sock,
- const struct tsocket_address *remote_addr);
-
-int tsocket_listen(struct tsocket_context *sock,
- int queue_size);
-
-int _tsocket_accept(struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- struct tsocket_context **new_sock,
- const char *location);
-#define tsocket_accept(sock, mem_ctx, new_sock) \
- _tsocket_accept(sock, mem_ctx, new_sock, __location__)
-
-ssize_t tsocket_pending(struct tsocket_context *sock);
-
-int tsocket_readv(struct tsocket_context *sock,
- const struct iovec *vector, size_t count);
-int tsocket_writev(struct tsocket_context *sock,
- const struct iovec *vector, size_t count);
-
-int tsocket_get_status(const struct tsocket_context *sock);
-
-int _tsocket_get_local_address(const struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- struct tsocket_address **local_addr,
- const char *location);
-#define tsocket_get_local_address(sock, mem_ctx, local_addr) \
- _tsocket_get_local_address(sock, mem_ctx, local_addr, __location__)
-int _tsocket_get_remote_address(const struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- struct tsocket_address **remote_addr,
- const char *location);
-#define tsocket_get_remote_address(sock, mem_ctx, remote_addr) \
- _tsocket_get_remote_address(sock, mem_ctx, remote_addr, __location__)
-
-int tsocket_get_option(const struct tsocket_context *sock,
- const char *option,
- TALLOC_CTX *mem_ctx,
- char **value);
-int tsocket_set_option(const struct tsocket_context *sock,
- const char *option,
- bool force,
- const char *value);
-
-void tsocket_disconnect(struct tsocket_context *sock);
-
+/*
+ * tsocket_address related functions
+ */
char *tsocket_address_string(const struct tsocket_address *addr,
TALLOC_CTX *mem_ctx);
#define tsocket_address_copy(addr, mem_ctx) \
_tsocket_address_copy(addr, mem_ctx, __location__)
-int _tsocket_address_create_socket(const struct tsocket_address *addr,
- enum tsocket_type type,
- TALLOC_CTX *mem_ctx,
- struct tsocket_context **sock,
- const char *location);
-#define tsocket_address_create_socket(addr, type, mem_ctx, sock) \
- _tsocket_address_create_socket(addr, type, mem_ctx, sock,\
- __location__)
-
/*
* tdgram_context related functions
*/
char *tsocket_address_unix_path(const struct tsocket_address *addr,
TALLOC_CTX *mem_ctx);
-int _tsocket_context_bsd_wrap_existing(TALLOC_CTX *mem_ctx,
- int fd, bool close_on_disconnect,
- struct tsocket_context **_sock,
- const char *location);
-#define tsocket_context_bsd_wrap_existing(mem_ctx, fd, cod, _sock) \
- _tsocket_context_bsd_wrap_existing(mem_ctx, fd, cod, _sock, \
- __location__)
-
int _tdgram_inet_udp_socket(const struct tsocket_address *local,
const struct tsocket_address *remote,
TALLOC_CTX *mem_ctx,
#define tdgram_unix_dgram_socket(local, remote, mem_ctx, dgram) \
_tdgram_unix_dgram_socket(local, remote, mem_ctx, dgram, __location__)
-/*
- * Async helpers
- */
-
-struct tevent_req *tsocket_connect_send(struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- const struct tsocket_address *dst);
-int tsocket_connect_recv(struct tevent_req *req, int *perrno);
-
-struct tevent_req *tsocket_writev_send(struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- const struct iovec *vector,
- size_t count);
-int tsocket_writev_recv(struct tevent_req *req, int *perrno);
-
-struct tevent_req *tsocket_writev_queue_send(TALLOC_CTX *mem_ctx,
- struct tsocket_context *sock,
- struct tevent_queue *queue,
- const struct iovec *vector,
- size_t count);
-int tsocket_writev_queue_recv(struct tevent_req *req, int *perrno);
-
-typedef int (*tsocket_readv_next_iovec_t)(struct tsocket_context *sock,
- void *private_data,
- TALLOC_CTX *mem_ctx,
- struct iovec **vector,
- size_t *count);
-struct tevent_req *tsocket_readv_send(struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- tsocket_readv_next_iovec_t next_iovec_fn,
- void *private_data);
-int tsocket_readv_recv(struct tevent_req *req, int *perrno);
-
/*
* Queue helpers
*/
#include "replace.h"
#include "system/filesys.h"
#include "system/network.h"
-#include "system/filesys.h"
#include "tsocket.h"
#include "tsocket_internal.h"
return -1;
}
-static const struct tsocket_context_ops tsocket_context_bsd_ops;
static const struct tsocket_address_ops tsocket_address_bsd_ops;
-static int tsocket_context_bsd_set_option(const struct tsocket_context *sock,
- const char *option,
- bool force,
- const char *value);
-
-struct tsocket_context_bsd {
- bool close_on_disconnect;
- int fd;
- struct tevent_fd *fde;
-};
-
struct tsocket_address_bsd {
- bool broadcast;
union {
struct sockaddr sa;
struct sockaddr_in in;
return 0;
}
-void tsocket_address_inet_set_broadcast(struct tsocket_address *addr,
- bool broadcast)
-{
- struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
- struct tsocket_address_bsd);
-
- if (!bsda) {
- return;
- }
-
- bsda->broadcast = broadcast;
-}
-
int _tsocket_address_unix_from_path(TALLOC_CTX *mem_ctx,
const char *path,
struct tsocket_address **_addr,
return NULL;
}
- tsocket_address_inet_set_broadcast(copy, bsda->broadcast);
return copy;
}
-int _tsocket_context_bsd_wrap_existing(TALLOC_CTX *mem_ctx,
- int fd, bool close_on_disconnect,
- struct tsocket_context **_sock,
- const char *location)
-{
- struct tsocket_context *sock;
- struct tsocket_context_bsd *bsds;
-
- sock = tsocket_context_create(mem_ctx,
- &tsocket_context_bsd_ops,
- &bsds,
- struct tsocket_context_bsd,
- location);
- if (!sock) {
- return -1;
- }
-
- bsds->close_on_disconnect = close_on_disconnect;
- bsds->fd = fd;
- bsds->fde = NULL;
-
- *_sock = sock;
- return 0;
-}
-
-static int tsocket_address_bsd_create_socket(const struct tsocket_address *addr,
- enum tsocket_type type,
- TALLOC_CTX *mem_ctx,
- struct tsocket_context **_sock,
- const char *location)
-{
- struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
- struct tsocket_address_bsd);
- struct tsocket_context *sock;
- int bsd_type;
- int fd;
- int ret;
- bool do_bind = false;
- bool do_reuseaddr = false;
-
- switch (type) {
- case TSOCKET_TYPE_STREAM:
- if (bsda->broadcast) {
- errno = EINVAL;
- return -1;
- }
- bsd_type = SOCK_STREAM;
- break;
- default:
- errno = EPROTONOSUPPORT;
- return -1;
- }
-
- switch (bsda->u.sa.sa_family) {
- case AF_UNIX:
- if (bsda->broadcast) {
- errno = EINVAL;
- return -1;
- }
- if (bsda->u.un.sun_path[0] != 0) {
- do_bind = true;
- }
- break;
- case AF_INET:
- if (bsda->u.in.sin_port != 0) {
- do_reuseaddr = true;
- do_bind = true;
- }
- if (bsda->u.in.sin_addr.s_addr == INADDR_ANY) {
- do_bind = true;
- }
- break;
-#ifdef HAVE_IPV6
- case AF_INET6:
- if (bsda->u.in6.sin6_port != 0) {
- do_reuseaddr = true;
- do_bind = true;
- }
- if (memcmp(&in6addr_any,
- &bsda->u.in6.sin6_addr,
- sizeof(in6addr_any)) != 0) {
- do_bind = true;
- }
- break;
-#endif
- default:
- errno = EINVAL;
- return -1;
- }
-
- fd = socket(bsda->u.sa.sa_family, bsd_type, 0);
- if (fd < 0) {
- return fd;
- }
-
- fd = tsocket_common_prepare_fd(fd, true);
- if (fd < 0) {
- return fd;
- }
-
- ret = _tsocket_context_bsd_wrap_existing(mem_ctx, fd, true,
- &sock, location);
- if (ret != 0) {
- int saved_errno = errno;
- close(fd);
- errno = saved_errno;
- return ret;
- }
-
- if (bsda->broadcast) {
- ret = tsocket_context_bsd_set_option(sock, "SO_BROADCAST", true, "1");
- if (ret != 0) {
- int saved_errno = errno;
- talloc_free(sock);
- errno = saved_errno;
- return ret;
- }
- }
-
- if (do_reuseaddr) {
- ret = tsocket_context_bsd_set_option(sock, "SO_REUSEADDR", true, "1");
- if (ret != 0) {
- int saved_errno = errno;
- talloc_free(sock);
- errno = saved_errno;
- return ret;
- }
- }
-
- if (do_bind) {
- ret = bind(fd, &bsda->u.sa, sizeof(bsda->u.ss));
- if (ret != 0) {
- int saved_errno = errno;
- talloc_free(sock);
- errno = saved_errno;
- return ret;
- }
- }
-
- *_sock = sock;
- return 0;
-}
-
static const struct tsocket_address_ops tsocket_address_bsd_ops = {
.name = "bsd",
.string = tsocket_address_bsd_string,
.copy = tsocket_address_bsd_copy,
- .create_socket = tsocket_address_bsd_create_socket
-};
-
-static void tsocket_context_bsd_fde_handler(struct tevent_context *ev,
- struct tevent_fd *fde,
- uint16_t flags,
- void *private_data)
-{
- struct tsocket_context *sock = talloc_get_type(private_data,
- struct tsocket_context);
-
- if (flags & TEVENT_FD_WRITE) {
- sock->event.write_handler(sock, sock->event.write_private);
- return;
- }
- if (flags & TEVENT_FD_READ) {
- sock->event.read_handler(sock, sock->event.read_private);
- return;
- }
-}
-
-static int tsocket_context_bsd_set_event_context(struct tsocket_context *sock,
- struct tevent_context *ev)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
-
- talloc_free(bsds->fde);
- bsds->fde = NULL;
- ZERO_STRUCT(sock->event);
-
- if (!ev) {
- return 0;
- }
-
- bsds->fde = tevent_add_fd(ev, bsds,
- bsds->fd,
- 0,
- tsocket_context_bsd_fde_handler,
- sock);
- if (!bsds->fde) {
- if (errno == 0) {
- errno = ENOMEM;
- }
- return -1;
- }
-
- sock->event.ctx = ev;
-
- return 0;
-}
-
-static int tsocket_context_bsd_set_read_handler(struct tsocket_context *sock,
- tsocket_event_handler_t handler,
- void *private_data)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
-
- if (sock->event.read_handler && !handler) {
- TEVENT_FD_NOT_READABLE(bsds->fde);
- } else if (!sock->event.read_handler && handler) {
- TEVENT_FD_READABLE(bsds->fde);
- }
-
- sock->event.read_handler = handler;
- sock->event.read_private = private_data;
-
- return 0;
-}
-
-static int tsocket_context_bsd_set_write_handler(struct tsocket_context *sock,
- tsocket_event_handler_t handler,
- void *private_data)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
-
- if (sock->event.write_handler && !handler) {
- TEVENT_FD_NOT_WRITEABLE(bsds->fde);
- } else if (!sock->event.write_handler && handler) {
- TEVENT_FD_WRITEABLE(bsds->fde);
- }
-
- sock->event.write_handler = handler;
- sock->event.write_private = private_data;
-
- return 0;
-}
-
-static int tsocket_context_bsd_connect_to(struct tsocket_context *sock,
- const struct tsocket_address *remote)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
- struct tsocket_address_bsd *bsda = talloc_get_type(remote->private_data,
- struct tsocket_address_bsd);
- int ret;
-
- ret = connect(bsds->fd, &bsda->u.sa,
- sizeof(bsda->u.ss));
-
- return ret;
-}
-
-static int tsocket_context_bsd_listen_on(struct tsocket_context *sock,
- int queue_size)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
- int ret;
-
- ret = listen(bsds->fd, queue_size);
-
- return ret;
-}
-
-static int tsocket_context_bsd_accept_new(struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- struct tsocket_context **_new_sock,
- const char *location)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
- int new_fd;
- struct tsocket_context *new_sock;
- struct tsocket_context_bsd *new_bsds;
- struct sockaddr_storage ss;
- void *p = &ss;
- socklen_t ss_len = sizeof(ss);
-
- new_fd = accept(bsds->fd, (struct sockaddr *)p, &ss_len);
- if (new_fd < 0) {
- return new_fd;
- }
-
- new_fd = tsocket_common_prepare_fd(new_fd, true);
- if (new_fd < 0) {
- return new_fd;
- }
-
- new_sock = tsocket_context_create(mem_ctx,
- &tsocket_context_bsd_ops,
- &new_bsds,
- struct tsocket_context_bsd,
- location);
- if (!new_sock) {
- int saved_errno = errno;
- close(new_fd);
- errno = saved_errno;
- return -1;
- }
-
- new_bsds->close_on_disconnect = true;
- new_bsds->fd = new_fd;
- new_bsds->fde = NULL;
-
- *_new_sock = new_sock;
- return 0;
-}
-
-static ssize_t tsocket_context_bsd_pending_data(struct tsocket_context *sock)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
- int ret;
- int value = 0;
-
- ret = ioctl(bsds->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(bsds->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 int tsocket_context_bsd_readv_data(struct tsocket_context *sock,
- const struct iovec *vector,
- size_t count)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
- int ret;
-
- ret = readv(bsds->fd, vector, count);
-
- return ret;
-}
-
-static int tsocket_context_bsd_writev_data(struct tsocket_context *sock,
- const struct iovec *vector,
- size_t count)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
- int ret;
-
- ret = writev(bsds->fd, vector, count);
-
- 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,
- struct tsocket_context_bsd);
- int ret;
- int error=0;
- socklen_t len = sizeof(error);
-
- if (bsds->fd == -1) {
- errno = EPIPE;
- return -1;
- }
-
- ret = getsockopt(bsds->fd, SOL_SOCKET, SO_ERROR, &error, &len);
- if (ret == -1) {
- return ret;
- }
- if (error != 0) {
- errno = error;
- return -1;
- }
-
- return 0;
-}
-
-static int tsocket_context_bsd_get_local_address(const struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- struct tsocket_address **_addr,
- const char *location)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
- struct tsocket_address *addr;
- struct tsocket_address_bsd *bsda;
- ssize_t ret;
- socklen_t sa_len;
-
- addr = tsocket_address_create(mem_ctx,
- &tsocket_address_bsd_ops,
- &bsda,
- struct tsocket_address_bsd,
- location);
- if (!addr) {
- return -1;
- }
-
- ZERO_STRUCTP(bsda);
-
- sa_len = sizeof(bsda->u.ss);
- ret = getsockname(bsds->fd, &bsda->u.sa, &sa_len);
- if (ret < 0) {
- int saved_errno = errno;
- talloc_free(addr);
- errno = saved_errno;
- return ret;
- }
-
- *_addr = addr;
- return 0;
-}
-
-static int tsocket_context_bsd_get_remote_address(const struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- struct tsocket_address **_addr,
- const char *location)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
- struct tsocket_address *addr;
- struct tsocket_address_bsd *bsda;
- ssize_t ret;
- socklen_t sa_len;
-
- addr = tsocket_address_create(mem_ctx,
- &tsocket_address_bsd_ops,
- &bsda,
- struct tsocket_address_bsd,
- location);
- if (!addr) {
- return -1;
- }
-
- ZERO_STRUCTP(bsda);
-
- sa_len = sizeof(bsda->u.ss);
- ret = getpeername(bsds->fd, &bsda->u.sa, &sa_len);
- if (ret < 0) {
- int saved_errno = errno;
- talloc_free(addr);
- errno = saved_errno;
- return ret;
- }
-
- *_addr = addr;
- return 0;
-}
-
-static const struct tsocket_context_bsd_option {
- const char *name;
- int level;
- int optnum;
- int optval;
-} tsocket_context_bsd_options[] = {
-#define TSOCKET_OPTION(_level, _optnum, _optval) { \
- .name = #_optnum, \
- .level = _level, \
- .optnum = _optnum, \
- .optval = _optval \
-}
- TSOCKET_OPTION(SOL_SOCKET, SO_REUSEADDR, 0),
- TSOCKET_OPTION(SOL_SOCKET, SO_BROADCAST, 0)
-};
-
-static int tsocket_context_bsd_get_option(const struct tsocket_context *sock,
- const char *option,
- TALLOC_CTX *mem_ctx,
- char **_value)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
- const struct tsocket_context_bsd_option *opt = NULL;
- uint32_t i;
- int optval;
- socklen_t optval_len = sizeof(optval);
- char *value;
- int ret;
-
- for (i=0; i < ARRAY_SIZE(tsocket_context_bsd_options); i++) {
- if (strcmp(option, tsocket_context_bsd_options[i].name) != 0) {
- continue;
- }
-
- opt = &tsocket_context_bsd_options[i];
- break;
- }
-
- if (!opt) {
- goto nosys;
- }
-
- ret = getsockopt(bsds->fd, opt->level, opt->optnum,
- (void *)&optval, &optval_len);
- if (ret != 0) {
- return ret;
- }
-
- if (optval_len != sizeof(optval)) {
- value = NULL;
- } if (opt->optval != 0) {
- if (optval == opt->optval) {
- value = talloc_strdup(mem_ctx, "1");
- } else {
- value = talloc_strdup(mem_ctx, "0");
- }
- if (!value) {
- goto nomem;
- }
- } else {
- value = talloc_asprintf(mem_ctx, "%d", optval);
- if (!value) {
- goto nomem;
- }
- }
-
- *_value = value;
- return 0;
-
- nomem:
- errno = ENOMEM;
- return -1;
- nosys:
- errno = ENOSYS;
- return -1;
-}
-
-static int tsocket_context_bsd_set_option(const struct tsocket_context *sock,
- const char *option,
- bool force,
- const char *value)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
- const struct tsocket_context_bsd_option *opt = NULL;
- uint32_t i;
- int optval;
- int ret;
-
- for (i=0; i < ARRAY_SIZE(tsocket_context_bsd_options); i++) {
- if (strcmp(option, tsocket_context_bsd_options[i].name) != 0) {
- continue;
- }
-
- opt = &tsocket_context_bsd_options[i];
- break;
- }
-
- if (!opt) {
- goto nosys;
- }
-
- if (value) {
- if (opt->optval != 0) {
- errno = EINVAL;
- return -1;
- }
-
- optval = atoi(value);
- } else {
- optval = opt->optval;
- }
-
- ret = setsockopt(bsds->fd, opt->level, opt->optnum,
- (const void *)&optval, sizeof(optval));
- if (ret != 0) {
- if (!force) {
- errno = 0;
- return 0;
- }
- return ret;
- }
-
- return 0;
-
- nosys:
- if (!force) {
- return 0;
- }
-
- errno = ENOSYS;
- return -1;
-}
-
-static void tsocket_context_bsd_disconnect(struct tsocket_context *sock)
-{
- struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
- struct tsocket_context_bsd);
-
- tsocket_context_bsd_set_event_context(sock, NULL);
-
- if (bsds->fd != -1) {
- if (bsds->close_on_disconnect) {
- close(bsds->fd);
- }
- bsds->fd = -1;
- }
-}
-
-static const struct tsocket_context_ops tsocket_context_bsd_ops = {
- .name = "bsd",
-
- .set_event_context = tsocket_context_bsd_set_event_context,
- .set_read_handler = tsocket_context_bsd_set_read_handler,
- .set_write_handler = tsocket_context_bsd_set_write_handler,
-
- .connect_to = tsocket_context_bsd_connect_to,
- .listen_on = tsocket_context_bsd_listen_on,
- .accept_new = tsocket_context_bsd_accept_new,
-
- .pending_data = tsocket_context_bsd_pending_data,
- .readv_data = tsocket_context_bsd_readv_data,
- .writev_data = tsocket_context_bsd_writev_data,
-
- .get_status = tsocket_context_bsd_get_status,
- .get_local_address = tsocket_context_bsd_get_local_address,
- .get_remote_address = tsocket_context_bsd_get_remote_address,
-
- .get_option = tsocket_context_bsd_get_option,
- .set_option = tsocket_context_bsd_set_option,
-
- .disconnect = tsocket_context_bsd_disconnect
};
struct tdgram_bsd {
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);
+ err = tsocket_bsd_error_from_errno(ret, errno, &retry);
if (retry) {
/* retry later */
return;
}
ret = sendto(bsds->fd, state->buf, state->len, 0, sa, sa_len);
- err = tsocket_error_from_errno(ret, errno, &retry);
+ err = tsocket_bsd_error_from_errno(ret, errno, &retry);
if (retry) {
/* retry later */
return;
ret = close(bsds->fd);
bsds->fd = -1;
- err = tsocket_error_from_errno(ret, errno, &dummy);
+ err = tsocket_bsd_error_from_errno(ret, errno, &dummy);
if (tevent_req_error(req, err)) {
goto post;
}
static int tdgram_bsd_dgram_socket(const struct tsocket_address *local,
const struct tsocket_address *remote,
+ bool broadcast,
TALLOC_CTX *mem_ctx,
struct tdgram_context **_dgram,
const char *location)
switch (lbsda->u.sa.sa_family) {
case AF_UNIX:
+ if (broadcast) {
+ errno = EINVAL;
+ return -1;
+ }
if (lbsda->u.un.sun_path[0] != 0) {
do_reuseaddr = true;
do_bind = true;
bsds->fd = fd;
talloc_set_destructor(bsds, tdgram_bsd_destructor);
- if (lbsda->broadcast) {
+ if (broadcast) {
int val = 1;
ret = setsockopt(fd, SOL_SOCKET, SO_BROADCAST,
return -1;
}
- ret = tdgram_bsd_dgram_socket(local, remote, mem_ctx, dgram, location);
+ ret = tdgram_bsd_dgram_socket(local, remote, false,
+ mem_ctx, dgram, location);
return ret;
}
return -1;
}
- ret = tdgram_bsd_dgram_socket(local, remote, mem_ctx, dgram, location);
+ ret = tdgram_bsd_dgram_socket(local, remote, false,
+ mem_ctx, dgram, location);
return ret;
}
+++ /dev/null
-/*
- 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_connect_state {
- /* this structs are owned by the caller */
- struct {
- struct tsocket_context *sock;
- const struct tsocket_address *dst;
- } caller;
-};
-
-static void tsocket_connect_handler(struct tsocket_context *sock,
- void *private_data);
-
-struct tevent_req *tsocket_connect_send(struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- const struct tsocket_address *dst)
-{
- struct tevent_req *req;
- struct tsocket_connect_state *state;
- int ret;
- int err;
- bool retry;
- bool dummy;
-
- req = tevent_req_create(mem_ctx, &state,
- struct tsocket_connect_state);
- if (!req) {
- return NULL;
- }
-
- state->caller.sock = sock;
- state->caller.dst = dst;
-
- ret = tsocket_connect(state->caller.sock,
- state->caller.dst);
- err = tsocket_error_from_errno(ret, errno, &retry);
- if (retry) {
- /* retry later */
- goto async;
- }
- if (tevent_req_error(req, err)) {
- goto post;
- }
-
- tevent_req_done(req);
- goto post;
-
- async:
- ret = tsocket_set_readable_handler(state->caller.sock,
- tsocket_connect_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_connect_handler(struct tsocket_context *sock,
- void *private_data)
-{
- struct tevent_req *req = talloc_get_type(private_data,
- struct tevent_req);
- struct tsocket_connect_state *state = tevent_req_data(req,
- struct tsocket_connect_state);
- int ret;
- int err;
- bool retry;
-
- ret = tsocket_get_status(state->caller.sock);
- err = tsocket_error_from_errno(ret, errno, &retry);
- if (retry) {
- /* retry later */
- return;
- }
- if (tevent_req_error(req, err)) {
- return;
- }
-
- tevent_req_done(req);
-}
-
-int tsocket_connect_recv(struct tevent_req *req, int *perrno)
-{
- int ret;
-
- ret = tsocket_simple_int_recv(req, perrno);
-
- tevent_req_received(req);
- return ret;
-}
-
#include "tsocket.h"
#include "tsocket_internal.h"
-int tsocket_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;
-}
-
int tsocket_simple_int_recv(struct tevent_req *req, int *perrno)
{
enum tevent_req_state state;
*perrno = EIO;
return -1;
}
-
-int tsocket_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;
-}
-
#ifndef _TSOCKET_INTERNAL_H
#define _TSOCKET_INTERNAL_H
-struct tsocket_context_ops {
- const char *name;
-
- /* event handling */
- int (*set_event_context)(struct tsocket_context *sock,
- struct tevent_context *ev);
- int (*set_read_handler)(struct tsocket_context *sock,
- tsocket_event_handler_t handler,
- void *private_data);
- int (*set_write_handler)(struct tsocket_context *sock,
- tsocket_event_handler_t handler,
- void *private_data);
-
- /* client ops */
- int (*connect_to)(struct tsocket_context *sock,
- const struct tsocket_address *remote_addr);
-
- /* server ops */
- int (*listen_on)(struct tsocket_context *sock,
- int queue_size);
- int (*accept_new)(struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- struct tsocket_context **new_sock,
- const char *location);
-
- /* general ops */
- ssize_t (*pending_data)(struct tsocket_context *sock);
-
- int (*readv_data)(struct tsocket_context *sock,
- const struct iovec *vector, size_t count);
- int (*writev_data)(struct tsocket_context *sock,
- const struct iovec *vector, size_t count);
-
- /* info */
- int (*get_status)(const struct tsocket_context *sock);
- int (*get_local_address)(const struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- struct tsocket_address **local_addr,
- const char *location);
- int (*get_remote_address)(const struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- struct tsocket_address **remote_addr,
- const char *location);
-
- /* options */
- int (*get_option)(const struct tsocket_context *sock,
- const char *option,
- TALLOC_CTX *mem_ctx,
- char **value);
- int (*set_option)(const struct tsocket_context *sock,
- const char *option,
- bool force,
- const char *value);
-
- /* close/disconnect */
- void (*disconnect)(struct tsocket_context *sock);
-};
-
-struct tsocket_context {
- const char *location;
- const struct tsocket_context_ops *ops;
-
- void *private_data;
-
- struct {
- struct tevent_context *ctx;
- void *read_private;
- tsocket_event_handler_t read_handler;
- void *write_private;
- tsocket_event_handler_t write_handler;
- } event;
-};
-
-struct tsocket_context *_tsocket_context_create(TALLOC_CTX *mem_ctx,
- const struct tsocket_context_ops *ops,
- void *pstate,
- size_t psize,
- const char *type,
- const char *location);
-#define tsocket_context_create(mem_ctx, ops, state, type, location) \
- _tsocket_context_create(mem_ctx, ops, state, sizeof(type), \
- #type, location)
-
struct tsocket_address_ops {
const char *name;
struct tsocket_address *(*copy)(const struct tsocket_address *addr,
TALLOC_CTX *mem_ctx,
const char *location);
-
- int (*create_socket)(const struct tsocket_address *addr,
- enum tsocket_type,
- TALLOC_CTX *mem_ctx,
- struct tsocket_context **sock,
- const char *location);
};
struct tsocket_address {
#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);
#endif /* _TSOCKET_H */
+++ /dev/null
-/*
- 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_readv_state {
- /* this structs are owned by the caller */
- struct {
- struct tsocket_context *sock;
- tsocket_readv_next_iovec_t next_iovec_fn;
- void *private_data;
- } caller;
-
- /*
- * Each call to the callback resets iov and count
- * the callback allocated the iov as child of our state,
- * that means we are allowed to modify and free it.
- *
- * we should call the callback every time we filled the given
- * vector and ask for a new vector. We return if the callback
- * ask for 0 bytes.
- */
- struct iovec *iov;
- size_t count;
-
- /*
- * the total number of bytes we read,
- * the return value of the _recv function
- */
- int total_read;
-};
-
-static int tsocket_readv_state_destructor(struct tsocket_readv_state *state)
-{
- if (state->caller.sock) {
- tsocket_set_readable_handler(state->caller.sock, NULL, NULL);
- }
- ZERO_STRUCT(state->caller);
-
- return 0;
-}
-
-static bool tsocket_readv_ask_for_next_vector(struct tevent_req *req,
- struct tsocket_readv_state *state)
-{
- int ret;
- int err;
- bool dummy;
- size_t to_read = 0;
- size_t i;
-
- talloc_free(state->iov);
- state->iov = NULL;
- state->count = 0;
-
- ret = state->caller.next_iovec_fn(state->caller.sock,
- state->caller.private_data,
- state, &state->iov, &state->count);
- err = tsocket_error_from_errno(ret, errno, &dummy);
- if (tevent_req_error(req, err)) {
- return false;
- }
-
- for (i=0; i < state->count; i++) {
- size_t tmp = to_read;
- tmp += state->iov[i].iov_len;
-
- if (tmp < to_read) {
- tevent_req_error(req, EMSGSIZE);
- return false;
- }
-
- to_read = tmp;
- }
-
- if (to_read == 0) {
- tevent_req_done(req);
- return false;
- }
-
- if (state->total_read + to_read < state->total_read) {
- tevent_req_error(req, EMSGSIZE);
- return false;
- }
-
- return true;
-}
-
-static void tsocket_readv_handler(struct tsocket_context *sock,
- void *private_data);
-
-struct tevent_req *tsocket_readv_send(struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- tsocket_readv_next_iovec_t next_iovec_fn,
- void *private_data)
-{
- struct tevent_req *req;
- struct tsocket_readv_state *state;
- int ret;
- int err;
- bool dummy;
-
- req = tevent_req_create(mem_ctx, &state,
- struct tsocket_readv_state);
- if (!req) {
- return NULL;
- }
-
- state->caller.sock = sock;
- state->caller.next_iovec_fn = next_iovec_fn;
- state->caller.private_data = private_data;
-
- state->iov = NULL;
- state->count = 0;
- state->total_read = 0;
-
- if (!tsocket_readv_ask_for_next_vector(req, state)) {
- goto post;
- }
-
- talloc_set_destructor(state, tsocket_readv_state_destructor);
-
- ret = tsocket_set_readable_handler(sock,
- tsocket_readv_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_readv_handler(struct tsocket_context *sock,
- void *private_data)
-{
- struct tevent_req *req = talloc_get_type(private_data,
- struct tevent_req);
- struct tsocket_readv_state *state = tevent_req_data(req,
- struct tsocket_readv_state);
- ssize_t ret;
- int err;
- bool retry;
-
- ret = tsocket_readv(state->caller.sock,
- state->iov,
- state->count);
- err = tsocket_error_from_errno(ret, errno, &retry);
- if (retry) {
- /* retry later */
- return;
- }
- if (tevent_req_error(req, err)) {
- return;
- }
-
- state->total_read += ret;
-
- while (ret > 0) {
- if (ret < state->iov[0].iov_len) {
- uint8_t *base;
- base = (uint8_t *)state->iov[0].iov_base;
- base += ret;
- state->iov[0].iov_base = base;
- state->iov[0].iov_len -= ret;
- break;
- }
- ret -= state->iov[0].iov_len;
- state->iov += 1;
- state->count -= 1;
- }
-
- if (state->count) {
- /* we have more to read */
- return;
- }
-
- /* ask the callback for a new vector we should fill */
- tsocket_readv_ask_for_next_vector(req, state);
-}
-
-int tsocket_readv_recv(struct tevent_req *req, int *perrno)
-{
- struct tsocket_readv_state *state = tevent_req_data(req,
- struct tsocket_readv_state);
- int ret;
-
- ret = tsocket_simple_int_recv(req, perrno);
- if (ret == 0) {
- ret = state->total_read;
- }
-
- tevent_req_received(req);
- return ret;
-}
-
+++ /dev/null
-/*
- 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_writev_state {
- /* this structs are owned by the caller */
- struct {
- struct tsocket_context *sock;
- const struct iovec *vector;
- size_t count;
- } caller;
-
- struct iovec *iov;
- size_t count;
- int total_written;
-};
-
-static int tsocket_writev_state_destructor(struct tsocket_writev_state *state)
-{
- if (state->caller.sock) {
- tsocket_set_writeable_handler(state->caller.sock, NULL, NULL);
- }
- ZERO_STRUCT(state->caller);
-
- return 0;
-}
-
-static void tsocket_writev_handler(struct tsocket_context *sock,
- void *private_data);
-
-struct tevent_req *tsocket_writev_send(struct tsocket_context *sock,
- TALLOC_CTX *mem_ctx,
- const struct iovec *vector,
- size_t count)
-{
- struct tevent_req *req;
- struct tsocket_writev_state *state;
- int ret;
- int err;
- bool dummy;
- int to_write = 0;
- size_t i;
-
- req = tevent_req_create(mem_ctx, &state,
- struct tsocket_writev_state);
- if (!req) {
- return NULL;
- }
-
- state->caller.sock = sock;
- state->caller.vector = vector;
- state->caller.count = count;
-
- state->iov = NULL;
- state->count = count;
- state->total_written = 0;
-
- state->iov = talloc_array(state, struct iovec, count);
- if (tevent_req_nomem(state->iov, req)) {
- goto post;
- }
- memcpy(state->iov, vector, sizeof(struct iovec) * count);
-
- for (i=0; i < count; i++) {
- int tmp = to_write;
-
- tmp += state->iov[i].iov_len;
-
- if (tmp < to_write) {
- tevent_req_error(req, EMSGSIZE);
- goto post;
- }
-
- to_write = tmp;
- }
-
- if (to_write == 0) {
- tevent_req_done(req);
- goto post;
- }
-
- /*
- * this is a fast path, not waiting for the
- * socket to become explicit writeable gains
- * about 10%-20% performance in benchmark tests.
- */
- tsocket_writev_handler(sock, req);
- if (!tevent_req_is_in_progress(req)) {
- goto post;
- }
-
- talloc_set_destructor(state, tsocket_writev_state_destructor);
-
- ret = tsocket_set_writeable_handler(sock,
- tsocket_writev_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_writev_handler(struct tsocket_context *sock,
- void *private_data)
-{
- struct tevent_req *req = talloc_get_type(private_data,
- struct tevent_req);
- struct tsocket_writev_state *state = tevent_req_data(req,
- struct tsocket_writev_state);
- int ret;
- int err;
- bool retry;
-
- ret = tsocket_writev(state->caller.sock,
- state->iov,
- state->count);
- err = tsocket_error_from_errno(ret, errno, &retry);
- if (retry) {
- /* retry later */
- return;
- }
- if (tevent_req_error(req, err)) {
- return;
- }
-
- state->total_written += ret;
-
- /*
- * we have not written everything yet, so we need to truncate
- * the already written bytes from our iov copy
- */
- while (ret > 0) {
- if (ret < state->iov[0].iov_len) {
- uint8_t *base;
- base = (uint8_t *)state->iov[0].iov_base;
- base += ret;
- state->iov[0].iov_base = base;
- state->iov[0].iov_len -= ret;
- break;
- }
- ret -= state->iov[0].iov_len;
- state->iov += 1;
- state->count -= 1;
- }
-
- if (state->count > 0) {
- /* more to write */
- return;
- }
-
- tevent_req_done(req);
-}
-
-int tsocket_writev_recv(struct tevent_req *req, int *perrno)
-{
- struct tsocket_writev_state *state = tevent_req_data(req,
- struct tsocket_writev_state);
- int ret;
-
- ret = tsocket_simple_int_recv(req, perrno);
- if (ret == 0) {
- ret = state->total_written;
- }
-
- tevent_req_received(req);
- return ret;
-}
-
-struct tsocket_writev_queue_state {
- /* this structs are owned by the caller */
- struct {
- struct tsocket_context *sock;
- const struct iovec *vector;
- size_t count;
- } caller;
- int ret;
-};
-
-static void tsocket_writev_queue_trigger(struct tevent_req *req,
- void *private_data);
-static void tsocket_writev_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 data through
- * @param[in] queue The existing send queue
- * @param[in] vector The iovec vector so write
- * @param[in] count The size of the vector
- * @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_writev_queue_send(TALLOC_CTX *mem_ctx,
- struct tsocket_context *sock,
- struct tevent_queue *queue,
- const struct iovec *vector,
- size_t count)
-{
- struct tevent_req *req;
- struct tsocket_writev_queue_state *state;
- bool ok;
-
- req = tevent_req_create(mem_ctx, &state,
- struct tsocket_writev_queue_state);
- if (!req) {
- return NULL;
- }
-
- state->caller.sock = sock;
- state->caller.vector = vector;
- state->caller.count = count;
- state->ret = -1;
-
- ok = tevent_queue_add(queue,
- sock->event.ctx,
- req,
- tsocket_writev_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_writev_queue_trigger(struct tevent_req *req,
- void *private_data)
-{
- struct tsocket_writev_queue_state *state = tevent_req_data(req,
- struct tsocket_writev_queue_state);
- struct tevent_req *subreq;
-
- subreq = tsocket_writev_send(state->caller.sock,
- state,
- state->caller.vector,
- state->caller.count);
- if (tevent_req_nomem(subreq, req)) {
- return;
- }
- tevent_req_set_callback(subreq, tsocket_writev_queue_done ,req);
-}
-
-static void tsocket_writev_queue_done(struct tevent_req *subreq)
-{
- struct tevent_req *req = tevent_req_callback_data(subreq,
- struct tevent_req);
- struct tsocket_writev_queue_state *state = tevent_req_data(req,
- struct tsocket_writev_queue_state);
- int ret;
- int sys_errno;
-
- ret = tsocket_writev_recv(subreq, &sys_errno);
- talloc_free(subreq);
- if (ret == -1) {
- tevent_req_error(req, sys_errno);
- return;
- }
- state->ret = ret;
-
- tevent_req_done(req);
-}
-
-int tsocket_writev_queue_recv(struct tevent_req *req, int *perrno)
-{
- struct tsocket_writev_queue_state *state = tevent_req_data(req,
- struct tsocket_writev_queue_state);
- int ret;
-
- ret = tsocket_simple_int_recv(req, perrno);
- if (ret == 0) {
- ret = state->ret;
- }
-
- tevent_req_received(req);
- return ret;
-}
-
LIBTSOCKET_OBJ = ../lib/tsocket/tsocket.o \
../lib/tsocket/tsocket_helpers.o \
- ../lib/tsocket/tsocket_bsd.o \
- ../lib/tsocket/tsocket_connect.o \
- ../lib/tsocket/tsocket_writev.o \
- ../lib/tsocket/tsocket_readv.o
+ ../lib/tsocket/tsocket_bsd.o
CLDAP_OBJ = libads/cldap.o \
../libcli/cldap/cldap.o \
git.samba.org / jra / samba / .git / commitdiff