Copyright (C) Stefan Metzmacher 2009
- ** NOTE! The following LGPL license applies to the tevent
+ ** NOTE! The following LGPL license applies to the tsocket
** library. This does NOT imply that all of Samba is released
** under the LGPL
*/
#include "replace.h"
-#include "system/network.h"
+#include "system/filesys.h"
#include "tsocket.h"
#include "tsocket_internal.h"
-static int tsocket_context_destructor(struct tsocket_context *sock)
+int tsocket_simple_int_recv(struct tevent_req *req, int *perrno)
{
- tsocket_disconnect(sock);
- return 0;
-}
+ enum tevent_req_state state;
+ uint64_t error;
-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;
+ if (!tevent_req_is_error(req, &state, &error)) {
+ return 0;
}
- 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);
-}
-
-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);
-}
-
-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);
-}
+ switch (state) {
+ case TEVENT_REQ_NO_MEMORY:
+ *perrno = ENOMEM;
+ return -1;
+ case TEVENT_REQ_TIMED_OUT:
+ *perrno = ETIMEDOUT;
+ return -1;
+ case TEVENT_REQ_USER_ERROR:
+ *perrno = (int)error;
+ return -1;
+ default:
+ *perrno = EIO;
+ return -1;
+ }
-void tsocket_disconnect(struct tsocket_context *sock)
-{
- sock->ops->disconnect(sock);
+ *perrno = EIO;
+ return -1;
}
struct tsocket_address *_tsocket_address_create(TALLOC_CTX *mem_ctx,
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;
void *private_data;
+
+ struct tevent_req *recvfrom_req;
+ struct tevent_req *sendto_req;
};
+static int tdgram_context_destructor(struct tdgram_context *dgram)
+{
+ if (dgram->recvfrom_req) {
+ tevent_req_received(dgram->recvfrom_req);
+ }
+
+ if (dgram->sendto_req) {
+ tevent_req_received(dgram->sendto_req);
+ }
+
+ return 0;
+}
+
struct tdgram_context *_tdgram_context_create(TALLOC_CTX *mem_ctx,
const struct tdgram_context_ops *ops,
void *pstate,
if (dgram == NULL) {
return NULL;
}
- dgram->location = location;
- dgram->ops = ops;
+ dgram->location = location;
+ dgram->ops = ops;
+ dgram->recvfrom_req = NULL;
+ dgram->sendto_req = NULL;
state = talloc_size(dgram, psize);
if (state == NULL) {
dgram->private_data = state;
+ talloc_set_destructor(dgram, tdgram_context_destructor);
+
*ppstate = state;
return dgram;
}
struct tdgram_recvfrom_state {
const struct tdgram_context_ops *ops;
+ struct tdgram_context *dgram;
uint8_t *buf;
size_t len;
struct tsocket_address *src;
};
+static int tdgram_recvfrom_destructor(struct tdgram_recvfrom_state *state)
+{
+ if (state->dgram) {
+ state->dgram->recvfrom_req = NULL;
+ }
+
+ return 0;
+}
+
static void tdgram_recvfrom_done(struct tevent_req *subreq);
struct tevent_req *tdgram_recvfrom_send(TALLOC_CTX *mem_ctx,
}
state->ops = dgram->ops;
+ state->dgram = dgram;
+ state->buf = NULL;
+ state->len = 0;
+ state->src = NULL;
+
+ if (dgram->recvfrom_req) {
+ tevent_req_error(req, EBUSY);
+ goto post;
+ }
+ dgram->recvfrom_req = req;
+
+ talloc_set_destructor(state, tdgram_recvfrom_destructor);
subreq = state->ops->recvfrom_send(state, ev, dgram);
if (tevent_req_nomem(subreq, req)) {
struct tdgram_sendto_state {
const struct tdgram_context_ops *ops;
+ struct tdgram_context *dgram;
ssize_t ret;
};
+static int tdgram_sendto_destructor(struct tdgram_sendto_state *state)
+{
+ if (state->dgram) {
+ state->dgram->sendto_req = NULL;
+ }
+
+ return 0;
+}
+
static void tdgram_sendto_done(struct tevent_req *subreq);
struct tevent_req *tdgram_sendto_send(TALLOC_CTX *mem_ctx,
}
state->ops = dgram->ops;
+ state->dgram = dgram;
state->ret = -1;
+ if (len == 0) {
+ tevent_req_error(req, EINVAL);
+ goto post;
+ }
+
+ if (dgram->sendto_req) {
+ tevent_req_error(req, EBUSY);
+ goto post;
+ }
+ dgram->sendto_req = req;
+
+ talloc_set_destructor(state, tdgram_sendto_destructor);
+
subreq = state->ops->sendto_send(state, ev, dgram,
buf, len, dst);
if (tevent_req_nomem(subreq, req)) {
state->ops = dgram->ops;
+ if (dgram->recvfrom_req || dgram->sendto_req) {
+ tevent_req_error(req, EBUSY);
+ goto post;
+ }
+
subreq = state->ops->disconnect_send(state, ev, dgram);
if (tevent_req_nomem(subreq, req)) {
goto post;
return ret;
}
+struct tstream_context {
+ const char *location;
+ const struct tstream_context_ops *ops;
+ void *private_data;
+
+ struct tevent_req *readv_req;
+ struct tevent_req *writev_req;
+};
+
+static int tstream_context_destructor(struct tstream_context *stream)
+{
+ if (stream->readv_req) {
+ tevent_req_received(stream->readv_req);
+ }
+
+ if (stream->writev_req) {
+ tevent_req_received(stream->writev_req);
+ }
+
+ return 0;
+}
+
+struct tstream_context *_tstream_context_create(TALLOC_CTX *mem_ctx,
+ const struct tstream_context_ops *ops,
+ void *pstate,
+ size_t psize,
+ const char *type,
+ const char *location)
+{
+ struct tstream_context *stream;
+ void **ppstate = (void **)pstate;
+ void *state;
+
+ stream = talloc(mem_ctx, struct tstream_context);
+ if (stream == NULL) {
+ return NULL;
+ }
+ stream->location = location;
+ stream->ops = ops;
+ stream->readv_req = NULL;
+ stream->writev_req = NULL;
+
+ state = talloc_size(stream, psize);
+ if (state == NULL) {
+ talloc_free(stream);
+ return NULL;
+ }
+ talloc_set_name_const(state, type);
+
+ stream->private_data = state;
+
+ talloc_set_destructor(stream, tstream_context_destructor);
+
+ *ppstate = state;
+ return stream;
+}
+
+void *_tstream_context_data(struct tstream_context *stream)
+{
+ return stream->private_data;
+}
+
+ssize_t tstream_pending_bytes(struct tstream_context *stream)
+{
+ return stream->ops->pending_bytes(stream);
+}
+
+struct tstream_readv_state {
+ const struct tstream_context_ops *ops;
+ struct tstream_context *stream;
+ int ret;
+};
+
+static int tstream_readv_destructor(struct tstream_readv_state *state)
+{
+ if (state->stream) {
+ state->stream->readv_req = NULL;
+ }
+
+ return 0;
+}
+
+static void tstream_readv_done(struct tevent_req *subreq);
+
+struct tevent_req *tstream_readv_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct tstream_context *stream,
+ struct iovec *vector,
+ size_t count)
+{
+ struct tevent_req *req;
+ struct tstream_readv_state *state;
+ struct tevent_req *subreq;
+ int to_read = 0;
+ size_t i;
+
+ req = tevent_req_create(mem_ctx, &state,
+ struct tstream_readv_state);
+ if (req == NULL) {
+ return NULL;
+ }
+
+ state->ops = stream->ops;
+ state->stream = stream;
+ state->ret = -1;
+
+ /* first check if the input is ok */
+#ifdef IOV_MAX
+ if (count > IOV_MAX) {
+ tevent_req_error(req, EMSGSIZE);
+ goto post;
+ }
+#endif
+
+ for (i=0; i < count; i++) {
+ int tmp = to_read;
+ tmp += vector[i].iov_len;
+
+ if (tmp < to_read) {
+ tevent_req_error(req, EMSGSIZE);
+ goto post;
+ }
+
+ to_read = tmp;
+ }
+
+ if (to_read == 0) {
+ tevent_req_error(req, EINVAL);
+ goto post;
+ }
+
+ if (stream->readv_req) {
+ tevent_req_error(req, EBUSY);
+ goto post;
+ }
+ stream->readv_req = req;
+
+ talloc_set_destructor(state, tstream_readv_destructor);
+
+ subreq = state->ops->readv_send(state, ev, stream, vector, count);
+ if (tevent_req_nomem(subreq, req)) {
+ goto post;
+ }
+ tevent_req_set_callback(subreq, tstream_readv_done, req);
+
+ return req;
+
+ post:
+ tevent_req_post(req, ev);
+ return req;
+}
+
+static void tstream_readv_done(struct tevent_req *subreq)
+{
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct tstream_readv_state *state = tevent_req_data(req,
+ struct tstream_readv_state);
+ ssize_t ret;
+ int sys_errno;
+
+ ret = state->ops->readv_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 tstream_readv_recv(struct tevent_req *req,
+ int *perrno)
+{
+ struct tstream_readv_state *state = tevent_req_data(req,
+ struct tstream_readv_state);
+ int ret;
+
+ ret = tsocket_simple_int_recv(req, perrno);
+ if (ret == 0) {
+ ret = state->ret;
+ }
+
+ tevent_req_received(req);
+ return ret;
+}
+
+struct tstream_writev_state {
+ const struct tstream_context_ops *ops;
+ struct tstream_context *stream;
+ int ret;
+};
+
+static int tstream_writev_destructor(struct tstream_writev_state *state)
+{
+ if (state->stream) {
+ state->stream->writev_req = NULL;
+ }
+
+ return 0;
+}
+
+static void tstream_writev_done(struct tevent_req *subreq);
+
+struct tevent_req *tstream_writev_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct tstream_context *stream,
+ const struct iovec *vector,
+ size_t count)
+{
+ struct tevent_req *req;
+ struct tstream_writev_state *state;
+ struct tevent_req *subreq;
+ int to_write = 0;
+ size_t i;
+
+ req = tevent_req_create(mem_ctx, &state,
+ struct tstream_writev_state);
+ if (req == NULL) {
+ return NULL;
+ }
+
+ state->ops = stream->ops;
+ state->stream = stream;
+ state->ret = -1;
+
+ /* first check if the input is ok */
+#ifdef IOV_MAX
+ if (count > IOV_MAX) {
+ tevent_req_error(req, EMSGSIZE);
+ goto post;
+ }
+#endif
+
+ for (i=0; i < count; i++) {
+ int tmp = to_write;
+ tmp += vector[i].iov_len;
+
+ if (tmp < to_write) {
+ tevent_req_error(req, EMSGSIZE);
+ goto post;
+ }
+
+ to_write = tmp;
+ }
+
+ if (to_write == 0) {
+ tevent_req_error(req, EINVAL);
+ goto post;
+ }
+
+ if (stream->writev_req) {
+ tevent_req_error(req, EBUSY);
+ goto post;
+ }
+ stream->writev_req = req;
+
+ talloc_set_destructor(state, tstream_writev_destructor);
+
+ subreq = state->ops->writev_send(state, ev, stream, vector, count);
+ if (tevent_req_nomem(subreq, req)) {
+ goto post;
+ }
+ tevent_req_set_callback(subreq, tstream_writev_done, req);
+
+ return req;
+
+ post:
+ tevent_req_post(req, ev);
+ return req;
+}
+
+static void tstream_writev_done(struct tevent_req *subreq)
+{
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct tstream_writev_state *state = tevent_req_data(req,
+ struct tstream_writev_state);
+ ssize_t ret;
+ int sys_errno;
+
+ ret = state->ops->writev_recv(subreq, &sys_errno);
+ if (ret == -1) {
+ tevent_req_error(req, sys_errno);
+ return;
+ }
+
+ state->ret = ret;
+
+ tevent_req_done(req);
+}
+
+int tstream_writev_recv(struct tevent_req *req,
+ int *perrno)
+{
+ struct tstream_writev_state *state = tevent_req_data(req,
+ struct tstream_writev_state);
+ int ret;
+
+ ret = tsocket_simple_int_recv(req, perrno);
+ if (ret == 0) {
+ ret = state->ret;
+ }
+
+ tevent_req_received(req);
+ return ret;
+}
+
+struct tstream_disconnect_state {
+ const struct tstream_context_ops *ops;
+};
+
+static void tstream_disconnect_done(struct tevent_req *subreq);
+
+struct tevent_req *tstream_disconnect_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct tstream_context *stream)
+{
+ struct tevent_req *req;
+ struct tstream_disconnect_state *state;
+ struct tevent_req *subreq;
+
+ req = tevent_req_create(mem_ctx, &state,
+ struct tstream_disconnect_state);
+ if (req == NULL) {
+ return NULL;
+ }
+
+ state->ops = stream->ops;
+
+ if (stream->readv_req || stream->writev_req) {
+ tevent_req_error(req, EBUSY);
+ goto post;
+ }
+
+ subreq = state->ops->disconnect_send(state, ev, stream);
+ if (tevent_req_nomem(subreq, req)) {
+ goto post;
+ }
+ tevent_req_set_callback(subreq, tstream_disconnect_done, req);
+
+ return req;
+
+ post:
+ tevent_req_post(req, ev);
+ return req;
+}
+
+static void tstream_disconnect_done(struct tevent_req *subreq)
+{
+ struct tevent_req *req = tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct tstream_disconnect_state *state = tevent_req_data(req,
+ struct tstream_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 tstream_disconnect_recv(struct tevent_req *req,
+ int *perrno)
+{
+ int ret;
+
+ ret = tsocket_simple_int_recv(req, perrno);
+
+ tevent_req_received(req);
+ return ret;
+}
+
git.samba.org / ira / wip.git / blobdiff