lib/tsocket: make use of tevent_req_set_cleanup_fn() instead of talloc_set_destructor()

Signed-off-by: Stefan Metzmacher <metze@samba.org>
Reviewed-by: Volker Lendecke <vl@samba.org>

diff --git a/lib/tsocket/tsocket.c b/lib/tsocket/tsocket.c
index b589959f771a2ed796d4c5462a94a7ff32152866..9a734b2739f5f15d81a979c73d588a8a419bc5e2 100644 (file)
--- a/lib/tsocket/tsocket.c
+++ b/lib/tsocket/tsocket.c
@@ -167,13 +167,16 @@ struct tdgram_recvfrom_state {
        struct tsocket_address *src;
 };
 
-static int tdgram_recvfrom_destructor(struct tdgram_recvfrom_state *state)
+static void tdgram_recvfrom_cleanup(struct tevent_req *req,
+                                   enum tevent_req_state req_state)
 {
+       struct tdgram_recvfrom_state *state = tevent_req_data(req,
+                                             struct tdgram_recvfrom_state);
+
        if (state->dgram) {
                state->dgram->recvfrom_req = NULL;
+               state->dgram = NULL;
        }
-
-       return 0;
 }
 
 static void tdgram_recvfrom_done(struct tevent_req *subreq);
@@ -204,7 +207,7 @@ struct tevent_req *tdgram_recvfrom_send(TALLOC_CTX *mem_ctx,
        }
        dgram->recvfrom_req = req;
 
-       talloc_set_destructor(state, tdgram_recvfrom_destructor);
+       tevent_req_set_cleanup_fn(req, tdgram_recvfrom_cleanup);
 
        subreq = state->ops->recvfrom_send(state, ev, dgram);
        if (tevent_req_nomem(subreq, req)) {
@@ -269,13 +272,16 @@ struct tdgram_sendto_state {
        ssize_t ret;
 };
 
-static int tdgram_sendto_destructor(struct tdgram_sendto_state *state)
+static void tdgram_sendto_cleanup(struct tevent_req *req,
+                                 enum tevent_req_state req_state)
 {
+       struct tdgram_sendto_state *state = tevent_req_data(req,
+                                           struct tdgram_sendto_state);
+
        if (state->dgram) {
                state->dgram->sendto_req = NULL;
+               state->dgram = NULL;
        }
-
-       return 0;
 }
 
 static void tdgram_sendto_done(struct tevent_req *subreq);
@@ -311,7 +317,7 @@ struct tevent_req *tdgram_sendto_send(TALLOC_CTX *mem_ctx,
        }
        dgram->sendto_req = req;
 
-       talloc_set_destructor(state, tdgram_sendto_destructor);
+       tevent_req_set_cleanup_fn(req, tdgram_sendto_cleanup);
 
        subreq = state->ops->sendto_send(state, ev, dgram,
                                         buf, len, dst);
@@ -505,13 +511,16 @@ struct tstream_readv_state {
        int ret;
 };
 
-static int tstream_readv_destructor(struct tstream_readv_state *state)
+static void tstream_readv_cleanup(struct tevent_req *req,
+                                 enum tevent_req_state req_state)
 {
+       struct tstream_readv_state *state = tevent_req_data(req,
+                                           struct tstream_readv_state);
+
        if (state->stream) {
                state->stream->readv_req = NULL;
+               state->stream = NULL;
        }
-
-       return 0;
 }
 
 static void tstream_readv_done(struct tevent_req *subreq);
@@ -563,7 +572,7 @@ struct tevent_req *tstream_readv_send(TALLOC_CTX *mem_ctx,
        }
        stream->readv_req = req;
 
-       talloc_set_destructor(state, tstream_readv_destructor);
+       tevent_req_set_cleanup_fn(req, tstream_readv_cleanup);
 
        subreq = state->ops->readv_send(state, ev, stream, vector, count);
        if (tevent_req_nomem(subreq, req)) {
@@ -621,13 +630,16 @@ struct tstream_writev_state {
        int ret;
 };
 
-static int tstream_writev_destructor(struct tstream_writev_state *state)
+static void tstream_writev_cleanup(struct tevent_req *req,
+                                  enum tevent_req_state req_state)
 {
+       struct tstream_writev_state *state = tevent_req_data(req,
+                                            struct tstream_writev_state);
+
        if (state->stream) {
                state->stream->writev_req = NULL;
+               state->stream = NULL;
        }
-
-       return 0;
 }
 
 static void tstream_writev_done(struct tevent_req *subreq);
@@ -678,7 +690,7 @@ struct tevent_req *tstream_writev_send(TALLOC_CTX *mem_ctx,
        }
        stream->writev_req = req;
 
-       talloc_set_destructor(state, tstream_writev_destructor);
+       tevent_req_set_cleanup_fn(req, tstream_writev_cleanup);
 
        subreq = state->ops->writev_send(state, ev, stream, vector, count);
        if (tevent_req_nomem(subreq, req)) {

diff --git a/lib/tsocket/tsocket_bsd.c b/lib/tsocket/tsocket_bsd.c
index 4483b03b19f21d9a5137c046c6abf01d5161ba96..f736f27e89ad7ff20f8d477cdc3032929d0835d3 100644 (file)
--- a/lib/tsocket/tsocket_bsd.c
+++ b/lib/tsocket/tsocket_bsd.c
@@ -928,14 +928,21 @@ struct tdgram_bsd_recvfrom_state {
        struct tsocket_address *src;
 };
 
-static int tdgram_bsd_recvfrom_destructor(struct tdgram_bsd_recvfrom_state *state)
+static void tdgram_bsd_recvfrom_cleanup(struct tevent_req *req,
+                                       enum tevent_req_state req_state)
 {
-       struct tdgram_bsd *bsds = tdgram_context_data(state->dgram,
-                                 struct tdgram_bsd);
+       struct tdgram_bsd_recvfrom_state *state =
+               tevent_req_data(req,
+               struct tdgram_bsd_recvfrom_state);
 
-       tdgram_bsd_set_readable_handler(bsds, NULL, NULL, NULL);
+       if (state->dgram != NULL) {
+               struct tdgram_bsd *bsds =
+                       tdgram_context_data(state->dgram,
+                       struct tdgram_bsd);
 
-       return 0;
+               tdgram_bsd_set_readable_handler(bsds, NULL, NULL, NULL);
+               state->dgram = NULL;
+       }
 }
 
 static void tdgram_bsd_recvfrom_handler(void *private_data);
@@ -961,7 +968,7 @@ static struct tevent_req *tdgram_bsd_recvfrom_send(TALLOC_CTX *mem_ctx,
        state->len      = 0;
        state->src      = NULL;
 
-       talloc_set_destructor(state, tdgram_bsd_recvfrom_destructor);
+       tevent_req_set_cleanup_fn(req, tdgram_bsd_recvfrom_cleanup);
 
        if (bsds->fd == -1) {
                tevent_req_error(req, ENOTCONN);
@@ -1120,14 +1127,21 @@ struct tdgram_bsd_sendto_state {
        ssize_t ret;
 };
 
-static int tdgram_bsd_sendto_destructor(struct tdgram_bsd_sendto_state *state)
+static void tdgram_bsd_sendto_cleanup(struct tevent_req *req,
+                                     enum tevent_req_state req_state)
 {
-       struct tdgram_bsd *bsds = tdgram_context_data(state->dgram,
-                                 struct tdgram_bsd);
+       struct tdgram_bsd_sendto_state *state =
+               tevent_req_data(req,
+               struct tdgram_bsd_sendto_state);
 
-       tdgram_bsd_set_writeable_handler(bsds, NULL, NULL, NULL);
+       if (state->dgram != NULL) {
+               struct tdgram_bsd *bsds =
+                       tdgram_context_data(state->dgram,
+                       struct tdgram_bsd);
 
-       return 0;
+               tdgram_bsd_set_writeable_handler(bsds, NULL, NULL, NULL);
+               state->dgram = NULL;
+       }
 }
 
 static void tdgram_bsd_sendto_handler(void *private_data);
@@ -1156,7 +1170,7 @@ static struct tevent_req *tdgram_bsd_sendto_send(TALLOC_CTX *mem_ctx,
        state->dst      = dst;
        state->ret      = -1;
 
-       talloc_set_destructor(state, tdgram_bsd_sendto_destructor);
+       tevent_req_set_cleanup_fn(req, tdgram_bsd_sendto_cleanup);
 
        if (bsds->fd == -1) {
                tevent_req_error(req, ENOTCONN);
@@ -1982,14 +1996,21 @@ struct tstream_bsd_readv_state {
        int ret;
 };
 
-static int tstream_bsd_readv_destructor(struct tstream_bsd_readv_state *state)
+static void tstream_bsd_readv_cleanup(struct tevent_req *req,
+                                     enum tevent_req_state req_state)
 {
-       struct tstream_bsd *bsds = tstream_context_data(state->stream,
-                                  struct tstream_bsd);
+       struct tstream_bsd_readv_state *state =
+               tevent_req_data(req,
+               struct tstream_bsd_readv_state);
 
-       tstream_bsd_set_readable_handler(bsds, NULL, NULL, NULL);
+       if (state->stream != NULL) {
+               struct tstream_bsd *bsds =
+                       tstream_context_data(state->stream,
+                       struct tstream_bsd);
 
-       return 0;
+               tstream_bsd_set_readable_handler(bsds, NULL, NULL, NULL);
+               state->stream = NULL;
+       }
 }
 
 static void tstream_bsd_readv_handler(void *private_data);
@@ -2021,7 +2042,7 @@ static struct tevent_req *tstream_bsd_readv_send(TALLOC_CTX *mem_ctx,
        state->count    = count;
        state->ret      = 0;
 
-       talloc_set_destructor(state, tstream_bsd_readv_destructor);
+       tevent_req_set_cleanup_fn(req, tstream_bsd_readv_cleanup);
 
        if (bsds->fd == -1) {
                tevent_req_error(req, ENOTCONN);
@@ -2148,14 +2169,21 @@ struct tstream_bsd_writev_state {
        int ret;
 };
 
-static int tstream_bsd_writev_destructor(struct tstream_bsd_writev_state *state)
+static void tstream_bsd_writev_cleanup(struct tevent_req *req,
+                                      enum tevent_req_state req_state)
 {
-       struct tstream_bsd *bsds = tstream_context_data(state->stream,
-                                 struct tstream_bsd);
+       struct tstream_bsd_writev_state *state =
+               tevent_req_data(req,
+               struct tstream_bsd_writev_state);
 
-       tstream_bsd_set_writeable_handler(bsds, NULL, NULL, NULL);
+       if (state->stream != NULL) {
+               struct tstream_bsd *bsds =
+                       tstream_context_data(state->stream,
+                       struct tstream_bsd);
 
-       return 0;
+               tstream_bsd_set_writeable_handler(bsds, NULL, NULL, NULL);
+               state->stream = NULL;
+       }
 }
 
 static void tstream_bsd_writev_handler(void *private_data);
@@ -2187,7 +2215,7 @@ static struct tevent_req *tstream_bsd_writev_send(TALLOC_CTX *mem_ctx,
        state->count    = count;
        state->ret      = 0;
 
-       talloc_set_destructor(state, tstream_bsd_writev_destructor);
+       tevent_req_set_cleanup_fn(req, tstream_bsd_writev_cleanup);
 
        if (bsds->fd == -1) {
                tevent_req_error(req, ENOTCONN);
@@ -2401,19 +2429,25 @@ int _tstream_bsd_existing_socket(TALLOC_CTX *mem_ctx,
 struct tstream_bsd_connect_state {
        int fd;
        struct tevent_fd *fde;
-       struct tstream_conext *stream;
        struct tsocket_address *local;
 };
 
-static int tstream_bsd_connect_destructor(struct tstream_bsd_connect_state *state)
+static void tstream_bsd_connect_cleanup(struct tevent_req *req,
+                                       enum tevent_req_state req_state)
 {
+       struct tstream_bsd_connect_state *state =
+               tevent_req_data(req,
+               struct tstream_bsd_connect_state);
+
+       if (req_state == TEVENT_REQ_DONE) {
+               return;
+       }
+
        TALLOC_FREE(state->fde);
        if (state->fd != -1) {
                close(state->fd);
                state->fd = -1;
        }
-
-       return 0;
 }
 
 static void tstream_bsd_connect_fde_handler(struct tevent_context *ev,
@@ -2451,7 +2485,7 @@ static struct tevent_req *tstream_bsd_connect_send(TALLOC_CTX *mem_ctx,
        state->fd = -1;
        state->fde = NULL;
 
-       talloc_set_destructor(state, tstream_bsd_connect_destructor);
+       tevent_req_set_cleanup_fn(req, tstream_bsd_connect_cleanup);
 
        /* give the wrappers a chance to report an error */
        if (sys_errno != 0) {