return result;
failed:
- composite_trigger_error(result);
+ composite_error(result, result->status);
return result;
}
return result;
failed:
- composite_trigger_error(result);
+ composite_error(result, result->status);
return result;
}
{
if (c == NULL) return NT_STATUS_NO_MEMORY;
+ c->used_wait = True;
+
while (c->state < COMPOSITE_STATE_DONE) {
if (event_loop_once(c->event_ctx) != 0) {
return NT_STATUS_UNSUCCESSFUL;
}
-/*
- callback from composite_trigger_done() and composite_trigger_error()
-*/
-static void composite_trigger(struct event_context *ev, struct timed_event *te,
- struct timeval t, void *ptr)
-{
- struct composite_context *c = talloc_get_type(ptr, struct composite_context);
- if (c->async.fn) {
- c->async.fn(c);
- }
-}
-
-
-/*
- trigger an immediate 'done' event on a composite context
- this is used when the composite code works out that the call
- can be completed without waiting for any external event
-*/
-void composite_trigger_done(struct composite_context *c)
-{
- c->state = COMPOSITE_STATE_DONE;
- /* a zero timeout means immediate */
- event_add_timed(c->event_ctx, c, timeval_zero(), composite_trigger, c);
-}
-
-void composite_trigger_error(struct composite_context *c)
-{
- c->state = COMPOSITE_STATE_ERROR;
- /* a zero timeout means immediate */
- event_add_timed(c->event_ctx, c, timeval_zero(), composite_trigger, c);
-}
-
-
/*
* Some composite helpers that are handy if you write larger composite
* functions.
*/
-
BOOL composite_is_ok(struct composite_context *ctx)
{
if (NT_STATUS_IS_OK(ctx->status)) {
return False;
}
+/*
+ callback from composite_done() and composite_error()
+
+ this is used to allow for a composite function to complete without
+ going through any state transitions. When that happens the caller
+ has had no opportunity to fill in the async callback fields
+ (ctx->async.fn and ctx->async.private) which means the usual way of
+ dealing with composite functions doesn't work. To cope with this,
+ we trigger a timer event that will happen then the event loop is
+ re-entered. This gives the caller a chance to setup the callback,
+ and allows the caller to ignore the fact that the composite
+ function completed early
+*/
+static void composite_trigger(struct event_context *ev, struct timed_event *te,
+ struct timeval t, void *ptr)
+{
+ struct composite_context *c = talloc_get_type(ptr, struct composite_context);
+ if (c->async.fn) {
+ c->async.fn(c);
+ }
+}
+
+
void composite_error(struct composite_context *ctx, NTSTATUS status)
{
+ if (!ctx->used_wait && !ctx->async.fn) {
+ event_add_timed(ctx->event_ctx, ctx, timeval_zero(), composite_trigger, ctx);
+ }
ctx->status = status;
SMB_ASSERT(!composite_is_ok(ctx));
}
void composite_done(struct composite_context *ctx)
{
+ if (!ctx->used_wait && !ctx->async.fn) {
+ event_add_timed(ctx->event_ctx, ctx, timeval_zero(), composite_trigger, ctx);
+ }
ctx->state = COMPOSITE_STATE_DONE;
if (ctx->async.fn != NULL) {
ctx->async.fn(ctx);
void (*fn)(struct composite_context *);
void *private_data;
} async;
+
+ BOOL used_wait;
};
state->ctx->status = ldap_parse_basic_url(conn, url, &conn->host,
&conn->port, &conn->ldaps);
if (!NT_STATUS_IS_OK(state->ctx->status)) {
- composite_trigger_error(state->ctx);
+ composite_error(state->ctx, state->ctx->status);
return result;
}
struct ipv4_addr ip = interpret_addr2(state->name.name);
state->reply_addr = talloc_strdup(state, sys_inet_ntoa(ip));
if (!state->reply_addr) goto failed;
- composite_trigger_done(c);
+ composite_done(c);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
if (!NT_STATUS_IS_OK(c->status)) {
DEBUG(2,("Invalid uuid string in "
"dcerpc_bind_auth_none_send\n"));
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
NT_STATUS_EQUAL(c->status, NT_STATUS_MORE_PROCESSING_REQUIRED);
if (state->credentials.length == 0) {
- composite_trigger_done(c);
+ composite_done(c);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
return c;
failed:
- composite_trigger_error(c);
+ composite_error(c, c->status);
return c;
}
state->domain = find_domain_from_sid(service, sid);
if (state->domain != NULL) {
result->status = NT_STATUS_OK;
- composite_trigger_done(result);
+ composite_done(result);
return result;
}
if (!wreplconn->sock->dead) {
state->stage = WREPLSRV_OUT_CONNECT_STAGE_DONE;
state->wreplconn= wreplconn;
- composite_trigger_done(c);
+ composite_done(c);
return c;
} else if (!cached_connection) {
state->stage = WREPLSRV_OUT_CONNECT_STAGE_DONE;
state->wreplconn= NULL;
- composite_trigger_done(c);
+ composite_done(c);
return c;
} else {
talloc_free(wreplconn);
state->table_io.out.num_partners = io->in.num_owners;
state->table_io.out.partners = io->in.owners;
state->stage = WREPLSRV_PULL_TABLE_STAGE_DONE;
- composite_trigger_done(c);
+ composite_done(c);
return c;
}
git.samba.org / jra / samba / .git / commitdiff