2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 2005
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 composite API helper functions
25 #include "lib/events/events.h"
26 #include "libcli/raw/libcliraw.h"
27 #include "libcli/composite/composite.h"
28 #include "lib/messaging/irpc.h"
29 #include "libcli/nbt/libnbt.h"
32 block until a composite function has completed, then return the status
34 NTSTATUS composite_wait(struct composite_context *c)
36 if (c == NULL) return NT_STATUS_NO_MEMORY;
40 while (c->state < COMPOSITE_STATE_DONE) {
41 if (event_loop_once(c->event_ctx) != 0) {
42 return NT_STATUS_UNSUCCESSFUL;
51 * Some composite helpers that are handy if you write larger composite
54 BOOL composite_is_ok(struct composite_context *ctx)
56 if (NT_STATUS_IS_OK(ctx->status)) {
59 ctx->state = COMPOSITE_STATE_ERROR;
60 if (ctx->async.fn != NULL) {
67 callback from composite_done() and composite_error()
69 this is used to allow for a composite function to complete without
70 going through any state transitions. When that happens the caller
71 has had no opportunity to fill in the async callback fields
72 (ctx->async.fn and ctx->async.private) which means the usual way of
73 dealing with composite functions doesn't work. To cope with this,
74 we trigger a timer event that will happen then the event loop is
75 re-entered. This gives the caller a chance to setup the callback,
76 and allows the caller to ignore the fact that the composite
77 function completed early
79 static void composite_trigger(struct event_context *ev, struct timed_event *te,
80 struct timeval t, void *ptr)
82 struct composite_context *c = talloc_get_type(ptr, struct composite_context);
89 void composite_error(struct composite_context *ctx, NTSTATUS status)
91 if (!ctx->used_wait && !ctx->async.fn) {
92 event_add_timed(ctx->event_ctx, ctx, timeval_zero(), composite_trigger, ctx);
95 SMB_ASSERT(!composite_is_ok(ctx));
98 BOOL composite_nomem(const void *p, struct composite_context *ctx)
103 composite_error(ctx, NT_STATUS_NO_MEMORY);
107 void composite_done(struct composite_context *ctx)
109 if (!ctx->used_wait && !ctx->async.fn) {
110 event_add_timed(ctx->event_ctx, ctx, timeval_zero(), composite_trigger, ctx);
112 ctx->state = COMPOSITE_STATE_DONE;
113 if (ctx->async.fn != NULL) {
118 void composite_continue(struct composite_context *ctx,
119 struct composite_context *new_ctx,
120 void (*continuation)(struct composite_context *),
123 if (composite_nomem(new_ctx, ctx)) return;
124 new_ctx->async.fn = continuation;
125 new_ctx->async.private_data = private_data;
128 void composite_continue_rpc(struct composite_context *ctx,
129 struct rpc_request *new_req,
130 void (*continuation)(struct rpc_request *),
133 if (composite_nomem(new_req, ctx)) return;
134 new_req->async.callback = continuation;
135 new_req->async.private = private_data;
138 void composite_continue_irpc(struct composite_context *ctx,
139 struct irpc_request *new_req,
140 void (*continuation)(struct irpc_request *),
143 if (composite_nomem(new_req, ctx)) return;
144 new_req->async.fn = continuation;
145 new_req->async.private = private_data;
148 void composite_continue_smb(struct composite_context *ctx,
149 struct smbcli_request *new_req,
150 void (*continuation)(struct smbcli_request *),
153 if (composite_nomem(new_req, ctx)) return;
154 new_req->async.fn = continuation;
155 new_req->async.private = private_data;
158 void composite_continue_nbt(struct composite_context *ctx,
159 struct nbt_name_request *new_req,
160 void (*continuation)(struct nbt_name_request *),
163 if (composite_nomem(new_req, ctx)) return;
164 new_req->async.fn = continuation;
165 new_req->async.private = private_data;