Convert async_connect to tevent_req

diff --git a/lib/async_req/async_sock.c b/lib/async_req/async_sock.c
index 02ae88068380406366af07c4f6f665f668e31a73..f5e3e5ba33b2cb2c8b1638ceed40ccc2a4999689 100644 (file)
--- a/lib/async_req/async_sock.c
+++ b/lib/async_req/async_sock.c
@@ -22,6 +22,7 @@
 #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>
 
 #ifndef TALLOC_FREE
@@ -633,17 +634,18 @@ static void async_connect_connected(struct tevent_context *ev,
  * connect in an async state. This will be reset when the request is finished.
  */
 
-struct async_req *async_connect_send(TALLOC_CTX *mem_ctx,
-                                    struct tevent_context *ev,
-                                    int fd, const struct sockaddr *address,
-                                    socklen_t address_len)
+struct tevent_req *async_connect_send(TALLOC_CTX *mem_ctx,
+                                     struct tevent_context *ev,
+                                     int fd, const struct sockaddr *address,
+                                     socklen_t address_len)
 {
-       struct async_req *result;
+       struct tevent_req *result;
        struct async_connect_state *state;
        struct tevent_fd *fde;
 
-       if (!async_req_setup(mem_ctx, &result, &state,
-                            struct async_connect_state)) {
+       result = tevent_req_create(
+               mem_ctx, &state, struct async_connect_state);
+       if (result == NULL) {
                return NULL;
        }
 
@@ -664,8 +666,8 @@ struct async_req *async_connect_send(TALLOC_CTX *mem_ctx,
 
        state->result = connect(fd, address, address_len);
        if (state->result == 0) {
-               state->sys_errno = 0;
-               goto post_status;
+               errno = 0;
+               goto post_errno;
        }
 
        /**
@@ -686,22 +688,20 @@ struct async_req *async_connect_send(TALLOC_CTX *mem_ctx,
        fde = tevent_add_fd(ev, state, fd, TEVENT_FD_READ | TEVENT_FD_WRITE,
                           async_connect_connected, result);
        if (fde == NULL) {
-               state->sys_errno = ENOMEM;
-               goto post_status;
+               errno = ENOMEM;
+               goto post_errno;
        }
        return result;
 
  post_errno:
        state->sys_errno = errno;
- post_status:
        fcntl(fd, F_SETFL, state->old_sockflags);
-       if (!async_post_error(result, ev, state->sys_errno)) {
-               goto fail;
+       if (state->sys_errno == 0) {
+               tevent_req_done(result);
+       } else {
+               tevent_req_error(result, state->sys_errno);
        }
-       return result;
- fail:
-       TALLOC_FREE(result);
-       return NULL;
+       return tevent_req_post(result, ev);
 }
 
 /**
@@ -716,10 +716,10 @@ static void async_connect_connected(struct tevent_context *ev,
                                    struct tevent_fd *fde, uint16_t flags,
                                    void *priv)
 {
-       struct async_req *req = talloc_get_type_abort(
-               priv, struct async_req);
+       struct tevent_req *req = talloc_get_type_abort(
+               priv, struct tevent_req);
        struct async_connect_state *state = talloc_get_type_abort(
-               req->private_data, struct async_connect_state);
+               req->private_state, struct async_connect_state);
 
        TALLOC_FREE(fde);
 
@@ -743,27 +743,27 @@ static void async_connect_connected(struct tevent_context *ev,
                DEBUG(10, ("connect returned %s\n", strerror(errno)));
 
                fcntl(state->fd, F_SETFL, state->old_sockflags);
-               async_req_error(req, state->sys_errno);
+               tevent_req_error(req, state->sys_errno);
                return;
        }
 
        state->sys_errno = 0;
-       async_req_done(req);
+       tevent_req_done(req);
 }
 
-int async_connect_recv(struct async_req *req, int *perrno)
+int async_connect_recv(struct tevent_req *req, int *perrno)
 {
        struct async_connect_state *state = talloc_get_type_abort(
-               req->private_data, struct async_connect_state);
+               req->private_state, struct async_connect_state);
        int err;
 
        fcntl(state->fd, F_SETFL, state->old_sockflags);
 
-
-       if (async_req_is_errno(req, &err)) {
+       if (tevent_req_is_unix_error(req, &err)) {
                *perrno = err;
                return -1;
        }
+
        if (state->sys_errno == 0) {
                return 0;
        }

diff --git a/lib/async_req/async_sock.h b/lib/async_req/async_sock.h
index c8739e9ed6b3c383388065b674aa6caae7e13df7..784571ed5a5b02eb6df6fd69cb01a7b0114d6b8b 100644 (file)
--- a/lib/async_req/async_sock.h
+++ b/lib/async_req/async_sock.h
@@ -35,11 +35,12 @@ struct async_req *async_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
 struct async_req *async_recv(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
                             int fd, void *buffer, size_t length,
                             int flags);
-struct async_req *async_connect_send(TALLOC_CTX *mem_ctx,
-                                    struct tevent_context *ev,
-                                    int fd, const struct sockaddr *address,
-                                    socklen_t address_len);
-int async_connect_recv(struct async_req *req, int *perrno);
+
+struct tevent_req *async_connect_send(TALLOC_CTX *mem_ctx,
+                                     struct tevent_context *ev,
+                                     int fd, const struct sockaddr *address,
+                                     socklen_t address_len);
+int async_connect_recv(struct tevent_req *req, int *perrno);
 
 struct async_req *sendall_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
                               int fd, const void *buffer, size_t length,

diff --git a/source3/lib/util_sock.c b/source3/lib/util_sock.c
index c46aa2ac49b75c7b43f5fd66416473a894b2853f..83e8a9d3553b7de2e8837e83feeb0393229a637c 100644 (file)
--- a/source3/lib/util_sock.c
+++ b/source3/lib/util_sock.c
@@ -953,7 +953,7 @@ struct open_socket_out_state {
        int wait_nsec;
 };
 
-static void open_socket_out_connected(struct async_req *subreq);
+static void open_socket_out_connected(struct tevent_req *subreq);
 
 static int open_socket_out_state_destructor(struct open_socket_out_state *s)
 {
@@ -974,7 +974,8 @@ struct async_req *open_socket_out_send(TALLOC_CTX *mem_ctx,
                                       int timeout)
 {
        char addr[INET6_ADDRSTRLEN];
-       struct async_req *result, *subreq;
+       struct async_req *result;
+       struct tevent_req *subreq;
        struct open_socket_out_state *state;
        NTSTATUS status;
 
@@ -1026,13 +1027,14 @@ struct async_req *open_socket_out_send(TALLOC_CTX *mem_ctx,
                                    (struct sockaddr *)&state->ss,
                                    state->salen);
        if ((subreq == NULL)
-           || !async_req_set_timeout(subreq, state->ev,
-                                     timeval_set(0, state->wait_nsec))) {
+           || !tevent_req_set_endtime(
+                   subreq, state->ev,
+                   timeval_current_ofs(0, state->wait_nsec))) {
                status = NT_STATUS_NO_MEMORY;
                goto post_status;
        }
        subreq->async.fn = open_socket_out_connected;
-       subreq->async.priv = result;
+       subreq->async.private_data = result;
        return result;
 
  post_status:
@@ -1045,18 +1047,18 @@ struct async_req *open_socket_out_send(TALLOC_CTX *mem_ctx,
        return NULL;
 }
 
-static void open_socket_out_connected(struct async_req *subreq)
+static void open_socket_out_connected(struct tevent_req *subreq)
 {
        struct async_req *req = talloc_get_type_abort(
-               subreq->async.priv, struct async_req);
+               subreq->async.private_data, struct async_req);
        struct open_socket_out_state *state = talloc_get_type_abort(
                req->private_data, struct open_socket_out_state);
-       int err;
+       int ret;
        int sys_errno;
 
-       err = async_connect_recv(subreq, &sys_errno);
+       ret = async_connect_recv(subreq, &sys_errno);
        TALLOC_FREE(subreq);
-       if (err == 0) {
+       if (ret == 0) {
                async_req_done(req);
                return;
        }
@@ -1083,13 +1085,14 @@ static void open_socket_out_connected(struct async_req *subreq)
                if (async_req_nomem(subreq, req)) {
                        return;
                }
-               if (!async_req_set_timeout(subreq, state->ev,
-                                          timeval_set(0, state->wait_nsec))) {
+               if (!tevent_req_set_endtime(
+                           subreq, state->ev,
+                           timeval_current_ofs(0, state->wait_nsec))) {
                        async_req_error(req, ENOMEM);
                        return;
                }
                subreq->async.fn = open_socket_out_connected;
-               subreq->async.priv = req;
+               subreq->async.private_data = req;
                return;
        }
 

diff --git a/source3/lib/wbclient.c b/source3/lib/wbclient.c
index 4d3a6095301dba783ef07c25d9c9091346337c08..b8d55a944a479edf92aaf295c8c02fff2a892be5 100644 (file)
--- a/source3/lib/wbclient.c
+++ b/source3/lib/wbclient.c
@@ -147,17 +147,30 @@ struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx)
        return result;
 }
 
+struct wb_connect_state {
+       int dummy;
+};
+
+static void wbc_connect_connected(struct tevent_req *subreq);
+
 static struct async_req *wb_connect_send(TALLOC_CTX *mem_ctx,
-                                        struct tevent_context *ev,
-                                        struct wb_context *wb_ctx,
-                                        const char *dir)
+                                         struct tevent_context *ev,
+                                         struct wb_context *wb_ctx,
+                                         const char *dir)
 {
-       struct async_req *req;
+       struct async_req *result;
+       struct tevent_req *subreq;
+       struct wb_connect_state *state;
        struct sockaddr_un sunaddr;
        struct stat st;
        char *path = NULL;
        wbcErr wbc_err;
 
+       if (!async_req_setup(mem_ctx, &result, &state,
+                            struct wb_connect_state)) {
+               return NULL;
+       }
+
        if (wb_ctx->fd != -1) {
                close(wb_ctx->fd);
                wb_ctx->fd = -1;
@@ -205,33 +218,46 @@ static struct async_req *wb_connect_send(TALLOC_CTX *mem_ctx,
                goto post_status;
        }
 
-       req = async_connect_send(mem_ctx, ev, wb_ctx->fd,
-                                (struct sockaddr *)&sunaddr,
-                                sizeof(sunaddr));
-       if (req == NULL) {
+       subreq = async_connect_send(mem_ctx, ev, wb_ctx->fd,
+                                   (struct sockaddr *)&sunaddr,
+                                   sizeof(sunaddr));
+       if (subreq == NULL) {
                goto nomem;
        }
-       if (!async_req_set_timeout(req, ev, timeval_set(30, 0))) {
-               TALLOC_FREE(req);
+       subreq->async.fn = wbc_connect_connected;
+       subreq->async.private_data = result;
+
+       if (!tevent_req_set_endtime(subreq, ev, timeval_current_ofs(30, 0))) {
                goto nomem;
        }
 
-       return req;
+       return result;
 
  nomem:
        wbc_err = WBC_ERR_NO_MEMORY;
  post_status:
-       req = async_req_new(mem_ctx);
-       if (req == NULL) {
-               return NULL;
-       }
-       if (async_post_error(req, ev, wbc_err)) {
-               return req;
+       if (async_post_error(result, ev, wbc_err)) {
+               return result;
        }
-       TALLOC_FREE(req);
+       TALLOC_FREE(result);
        return NULL;
 }
 
+static void wbc_connect_connected(struct tevent_req *subreq)
+{
+       struct async_req *req = talloc_get_type_abort(
+               subreq->async.private_data, struct async_req);
+       int res, err;
+
+       res = async_connect_recv(subreq, &err);
+       TALLOC_FREE(subreq);
+       if (res == -1) {
+               async_req_error(req, map_wbc_err_from_errno(err));
+               return;
+       }
+       async_req_done(req);
+}
+
 static wbcErr wb_connect_recv(struct async_req *req)
 {
        return async_req_simple_recv_wbcerr(req);