Changeset 740 for vendor/current/libcli/nbt/namerefresh.c

Timestamp:

Nov 14, 2012, 12:59:34 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

File:

• vendor/current/libcli/nbt/namerefresh.c (modified) (5 diffs)

vendor/current/libcli/nbt/namerefresh.c

@@ -21 +21 @@
 
 #include "includes.h"
+#include <tevent.h>
 #include "../libcli/nbt/libnbt.h"
 #include "../libcli/nbt/nbt_proto.h"
-#include "libcli/composite/composite.h"
 #include "lib/socket/socket.h"
+#include "lib/util/tevent_ntstatus.h"
 
 /*
@@ -143 +144 @@
   reply for each address
 */
-struct refresh_wins_state {
+struct nbt_name_refresh_wins_state {
         struct nbt_name_socket *nbtsock;
         struct nbt_name_refresh *io;
-        const char **wins_servers;
+        char **wins_servers;
         uint16_t wins_port;
-        const char **addresses;
+        char **addresses;
         int address_idx;
-        struct nbt_name_request *req;
 };
 
-
-/**
-  state handler for WINS multi-homed multi-server name refresh
-*/
-static void name_refresh_wins_handler(struct nbt_name_request *req)
-{
-        struct composite_context *c = talloc_get_type(req->async.private_data,
-                                                      struct composite_context);
-        struct refresh_wins_state *state = talloc_get_type(c->private_data,
-                                                            struct refresh_wins_state);
-        NTSTATUS status;
-
-        status = nbt_name_refresh_recv(state->req, state, state->io);
-        if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
-                /* the refresh timed out - try the next WINS server */
-                state->wins_servers++;
-                state->address_idx = 0;
-                if (state->wins_servers[0] == NULL) {
-                        c->state = COMPOSITE_STATE_ERROR;
-                        c->status = status;
-                        goto done;
-                }
-                state->io->in.dest_addr = state->wins_servers[0];
-                state->io->in.dest_port = state->wins_port;
-                state->io->in.address   = state->addresses[0];
-                state->req = nbt_name_refresh_send(state->nbtsock, state->io);
-                if (state->req == NULL) {
-                        c->state = COMPOSITE_STATE_ERROR;
-                        c->status = NT_STATUS_NO_MEMORY;
-                } else {
-                        state->req->async.fn      = name_refresh_wins_handler;
-                        state->req->async.private_data = c;
-                }
-        } else if (!NT_STATUS_IS_OK(status)) {
-                c->state = COMPOSITE_STATE_ERROR;
-                c->status = status;
-        } else {
-                if (state->io->out.rcode == 0 &&
-                    state->addresses[state->address_idx+1] != NULL) {
-                        /* refresh our next address */
-                        state->io->in.address = state->addresses[++(state->address_idx)];
-                        state->req = nbt_name_refresh_send(state->nbtsock, state->io);
-                        if (state->req == NULL) {
-                                c->state = COMPOSITE_STATE_ERROR;
-                                c->status = NT_STATUS_NO_MEMORY;
-                        } else {
-                                state->req->async.fn      = name_refresh_wins_handler;
-                                state->req->async.private_data = c;
-                        }
-                } else {
-                        c->state = COMPOSITE_STATE_DONE;
-                        c->status = NT_STATUS_OK;
-                }
-        }
-
-done:
-        if (c->state >= COMPOSITE_STATE_DONE &&
-            c->async.fn) {
-                c->async.fn(c);
-        }
-}
+static void nbt_name_refresh_wins_handler(struct nbt_name_request *subreq);
 
 /**
   the async send call for a multi-server WINS refresh
 */
-_PUBLIC_ struct composite_context *nbt_name_refresh_wins_send(struct nbt_name_socket *nbtsock,
-                                                      struct nbt_name_refresh_wins *io)
-{
-        struct composite_context *c;
-        struct refresh_wins_state *state;
-
-        c = talloc_zero(nbtsock, struct composite_context);
-        if (c == NULL) goto failed;
-
-        state = talloc(c, struct refresh_wins_state);
-        if (state == NULL) goto failed;
+_PUBLIC_ struct tevent_req *nbt_name_refresh_wins_send(TALLOC_CTX *mem_ctx,
+                                                struct tevent_context *ev,
+                                                struct nbt_name_socket *nbtsock,
+                                                struct nbt_name_refresh_wins *io)
+{
+        struct tevent_req *req;
+        struct nbt_name_refresh_wins_state *state;
+        struct nbt_name_request *subreq;
+
+        req = tevent_req_create(mem_ctx, &state,
+                                struct nbt_name_refresh_wins_state);
+        if (req == NULL) {
+                return NULL;
+        }
 
         state->io = talloc(state, struct nbt_name_refresh);
-        if (state->io == NULL) goto failed;
+        if (tevent_req_nomem(state->io, req)) {
+                return tevent_req_post(req, ev);
+        }
+
+        if (io->in.wins_servers == NULL) {
+                tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
+                return tevent_req_post(req, ev);
+        }
+
+        if (io->in.wins_servers[0] == NULL) {
+                tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
+                return tevent_req_post(req, ev);
+        }
+
+        if (io->in.addresses == NULL) {
+                tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
+                return tevent_req_post(req, ev);
+        }
+
+        if (io->in.addresses[0] == NULL) {
+                tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
+                return tevent_req_post(req, ev);
+        }
 
         state->wins_port = io->in.wins_port;
-        state->wins_servers = (const char **)str_list_copy(state, io->in.wins_servers);
-        if (state->wins_servers == NULL ||
-            state->wins_servers[0] == NULL) goto failed;
-
-        state->addresses = (const char **)str_list_copy(state, io->in.addresses);
-        if (state->addresses == NULL ||
-            state->addresses[0] == NULL) goto failed;
+        state->wins_servers = str_list_copy(state, io->in.wins_servers);
+        if (tevent_req_nomem(state->wins_servers, req)) {
+                return tevent_req_post(req, ev);
+        }
+
+        state->addresses = str_list_copy(state, io->in.addresses);
+        if (tevent_req_nomem(state->addresses, req)) {
+                return tevent_req_post(req, ev);
+        }
 
         state->io->in.name            = io->in.name;
@@ -255 +222 @@
         state->address_idx = 0;
 
-        state->req = nbt_name_refresh_send(nbtsock, state->io);
-        if (state->req == NULL) goto failed;
-
-        state->req->async.fn      = name_refresh_wins_handler;
-        state->req->async.private_data = c;
-
-        c->private_data = state;
-        c->state        = COMPOSITE_STATE_IN_PROGRESS;
-        c->event_ctx    = nbtsock->event_ctx;
-
-        return c;
-
-failed:
-        talloc_free(c);
-        return NULL;
+        subreq = nbt_name_refresh_send(nbtsock, state->io);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+
+        subreq->async.fn = nbt_name_refresh_wins_handler;
+        subreq->async.private_data = req;
+
+        return req;
+}
+
+static void nbt_name_refresh_wins_handler(struct nbt_name_request *subreq)
+{
+        struct tevent_req *req =
+                talloc_get_type_abort(subreq->async.private_data,
+                struct tevent_req);
+        struct nbt_name_refresh_wins_state *state =
+                tevent_req_data(req,
+                struct nbt_name_refresh_wins_state);
+        NTSTATUS status;
+
+        status = nbt_name_refresh_recv(subreq, state, state->io);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
+                /* the refresh timed out - try the next WINS server */
+                state->wins_servers++;
+                if (state->wins_servers[0] == NULL) {
+                        tevent_req_nterror(req, status);
+                        return;
+                }
+
+                state->address_idx = 0;
+                state->io->in.dest_addr = state->wins_servers[0];
+                state->io->in.dest_port = state->wins_port;
+                state->io->in.address   = state->addresses[0];
+
+                subreq = nbt_name_refresh_send(state->nbtsock, state->io);
+                if (tevent_req_nomem(subreq, req)) {
+                        return;
+                }
+                subreq->async.fn = nbt_name_refresh_wins_handler;
+                subreq->async.private_data = req;
+        } else if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+
+        if (state->io->out.rcode == 0 &&
+            state->addresses[state->address_idx+1] != NULL) {
+                /* refresh our next address */
+                state->io->in.address = state->addresses[++(state->address_idx)];
+                subreq = nbt_name_refresh_send(state->nbtsock, state->io);
+                if (tevent_req_nomem(subreq, req)) {
+                        return;
+                }
+                subreq->async.fn = nbt_name_refresh_wins_handler;
+                subreq->async.private_data = req;
+                return;
+        }
+
+        tevent_req_done(req);
 }
 
@@ -275 +287 @@
   multi-homed WINS name refresh - recv side
 */
-_PUBLIC_ NTSTATUS nbt_name_refresh_wins_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
-                                     struct nbt_name_refresh_wins *io)
-{
+_PUBLIC_ NTSTATUS nbt_name_refresh_wins_recv(struct tevent_req *req,
+                                             TALLOC_CTX *mem_ctx,
+                                             struct nbt_name_refresh_wins *io)
+{
+        struct nbt_name_refresh_wins_state *state =
+                tevent_req_data(req,
+                struct nbt_name_refresh_wins_state);
         NTSTATUS status;
-        status = composite_wait(c);
-        if (NT_STATUS_IS_OK(status)) {
-                struct refresh_wins_state *state =
-                        talloc_get_type(c->private_data, struct refresh_wins_state);
-                io->out.wins_server = talloc_steal(mem_ctx, state->wins_servers[0]);
-                io->out.rcode = state->io->out.rcode;
-        }
-        talloc_free(c);
-        return status;
+
+        if (tevent_req_is_nterror(req, &status)) {
+                tevent_req_received(req);
+                return status;
+        }
+
+        io->out.wins_server = talloc_move(mem_ctx, &state->wins_servers[0]);
+        io->out.rcode = state->io->out.rcode;
+
+        tevent_req_received(req);
+        return NT_STATUS_OK;
 }
 
@@ -294 +312 @@
 */
 _PUBLIC_ NTSTATUS nbt_name_refresh_wins(struct nbt_name_socket *nbtsock,
-                                TALLOC_CTX *mem_ctx,
-                                struct nbt_name_refresh_wins *io)
-{
-        struct composite_context *c = nbt_name_refresh_wins_send(nbtsock, io);
-        return nbt_name_refresh_wins_recv(c, mem_ctx, io);
-}
+                                        TALLOC_CTX *mem_ctx,
+                                        struct nbt_name_refresh_wins *io)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct tevent_context *ev;
+        struct tevent_req *subreq;
+        NTSTATUS status;
+
+        /*
+         * TODO: create a temporary event context
+         */
+        ev = nbtsock->event_ctx;
+
+        subreq = nbt_name_refresh_wins_send(frame, ev, nbtsock, io);
+        if (subreq == NULL) {
+                talloc_free(frame);
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        if (!tevent_req_poll(subreq, ev)) {
+                status = map_nt_error_from_unix(errno);
+                talloc_free(frame);
+                return status;
+        }
+
+        status = nbt_name_refresh_wins_recv(subreq, mem_ctx, io);
+        if (!NT_STATUS_IS_OK(status)) {
+                talloc_free(frame);
+                return status;
+        }
+
+        TALLOC_FREE(frame);
+        return NT_STATUS_OK;
+}