-/*
+ /*
Unix SMB/CIFS implementation.
Copyright (C) Rafal Szczesniak 2005
#include "librpc/gen_ndr/ndr_samr_c.h"
#include "librpc/gen_ndr/ndr_lsa_c.h"
-static void domain_open_handler(struct rpc_request*);
-
-enum domain_open_stage { DOMOPEN_CONNECT, DOMOPEN_LOOKUP, DOMOPEN_OPEN,
- DOMOPEN_CLOSE_EXISTING, DOMOPEN_RPC_CONNECT };
struct domain_open_samr_state {
- enum domain_open_stage stage;
struct libnet_context *ctx;
struct dcerpc_pipe *pipe;
- struct rpc_request *req;
- struct composite_context *rpcconn_req;
+ struct libnet_RpcConnect rpcconn;
struct samr_Connect connect;
struct samr_LookupDomain lookup;
struct samr_OpenDomain open;
struct samr_Close close;
- struct libnet_RpcConnect rpcconn;
struct lsa_String domain_name;
uint32_t access_mask;
struct policy_handle connect_handle;
};
+static void continue_domain_open_close(struct rpc_request *req);
+static void continue_domain_open_connect(struct rpc_request *req);
+static void continue_domain_open_lookup(struct rpc_request *req);
+static void continue_domain_open_open(struct rpc_request *req);
+
+
/**
* Stage 0.5 (optional): Connect to samr rpc pipe
*/
-static void domain_open_rpc_connect(struct composite_context *ctx)
+static void continue_domain_open_rpc_connect(struct composite_context *ctx)
{
struct composite_context *c;
struct domain_open_samr_state *s;
+ struct rpc_request *conn_req;
c = talloc_get_type(ctx->async.private_data, struct composite_context);
s = talloc_get_type(c->private_data, struct domain_open_samr_state);
s->connect.out.connect_handle = &s->connect_handle;
/* send request */
- s->req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
- if (composite_nomem(s->req, c)) return;
+ conn_req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
+ if (composite_nomem(conn_req, c)) return;
/* callback handler */
- s->req->async.callback = domain_open_handler;
- s->req->async.private = c;
- s->stage = DOMOPEN_CONNECT;
+ composite_continue_rpc(c, conn_req, continue_domain_open_connect, c);
}
* Stage 0.5 (optional): Close existing (in libnet context) domain
* handle
*/
-static NTSTATUS domain_open_close(struct composite_context *c,
- struct domain_open_samr_state *s)
+static void continue_domain_open_close(struct rpc_request *req)
{
+ struct composite_context *c;
+ struct domain_open_samr_state *s;
+ struct rpc_request *conn_req;
+
+ c = talloc_get_type(req->async.private, struct composite_context);
+ s = talloc_get_type(c->private_data, struct domain_open_samr_state);
+
/* receive samr_Close reply */
- c->status = dcerpc_ndr_request_recv(s->req);
- NT_STATUS_NOT_OK_RETURN(c->status);
+ c->status = dcerpc_ndr_request_recv(req);
+ if (!composite_is_ok(c)) return;
/* reset domain handle and associated data in libnet_context */
s->ctx->samr.name = NULL;
s->connect.out.connect_handle = &s->connect_handle;
/* send request */
- s->req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
- if (s->req == NULL) return NT_STATUS_NO_MEMORY;
+ conn_req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
+ if (composite_nomem(conn_req, c)) return;
/* callback handler */
- s->req->async.callback = domain_open_handler;
- s->req->async.private = c;
- s->stage = DOMOPEN_CONNECT;
-
- return NT_STATUS_OK;
+ composite_continue_rpc(c, conn_req, continue_domain_open_connect, c);
}
/**
* Stage 1: Connect to SAM server.
*/
-static NTSTATUS domain_open_connect(struct composite_context *c,
- struct domain_open_samr_state *s)
+static void continue_domain_open_connect(struct rpc_request *req)
{
- struct samr_LookupDomain *r = &s->lookup;
+ struct composite_context *c;
+ struct domain_open_samr_state *s;
+ struct rpc_request *lookup_req;
+ struct samr_LookupDomain *r;
+
+ c = talloc_get_type(req->async.private, struct composite_context);
+ s = talloc_get_type(c->private_data, struct domain_open_samr_state);
/* receive samr_Connect reply */
- c->status = dcerpc_ndr_request_recv(s->req);
- NT_STATUS_NOT_OK_RETURN(c->status);
+ c->status = dcerpc_ndr_request_recv(req);
+ if (!composite_is_ok(c)) return;
+
+ r = &s->lookup;
/* prepare for samr_LookupDomain call */
r->in.connect_handle = &s->connect_handle;
r->in.domain_name = &s->domain_name;
- s->req = dcerpc_samr_LookupDomain_send(s->pipe, c, r);
- if (s->req == NULL) goto failure;
+ lookup_req = dcerpc_samr_LookupDomain_send(s->pipe, c, r);
+ if (composite_nomem(lookup_req, c)) return;
- s->req->async.callback = domain_open_handler;
- s->req->async.private = c;
- s->stage = DOMOPEN_LOOKUP;
-
- return NT_STATUS_OK;
-
-failure:
- return NT_STATUS_UNSUCCESSFUL;
+ composite_continue_rpc(c, lookup_req, continue_domain_open_lookup, c);
}
/**
* Stage 2: Lookup domain by name.
*/
-static NTSTATUS domain_open_lookup(struct composite_context *c,
- struct domain_open_samr_state *s)
+static void continue_domain_open_lookup(struct rpc_request *req)
{
- struct samr_OpenDomain *r = &s->open;
+ struct composite_context *c;
+ struct domain_open_samr_state *s;
+ struct rpc_request *opendom_req;
+ struct samr_OpenDomain *r;
+ c = talloc_get_type(req->async.private, struct composite_context);
+ s = talloc_get_type(c->private_data, struct domain_open_samr_state);
+
/* receive samr_LookupDomain reply */
- c->status = dcerpc_ndr_request_recv(s->req);
- NT_STATUS_NOT_OK_RETURN(c->status);
+ c->status = dcerpc_ndr_request_recv(req);
+
+ r = &s->open;
+
+ /* check the rpc layer status */
+ if (!composite_is_ok(c));
+
+ /* check the rpc call itself status */
+ if (!NT_STATUS_IS_OK(s->lookup.out.result)) {
+ composite_error(c, s->lookup.out.result);
+ return;
+ }
/* prepare for samr_OpenDomain call */
r->in.connect_handle = &s->connect_handle;
r->in.sid = s->lookup.out.sid;
r->out.domain_handle = &s->domain_handle;
- s->req = dcerpc_samr_OpenDomain_send(s->pipe, c, r);
- if (s->req == NULL) goto failure;
+ opendom_req = dcerpc_samr_OpenDomain_send(s->pipe, c, r);
+ if (composite_nomem(opendom_req, c)) return;
- s->req->async.callback = domain_open_handler;
- s->req->async.private = c;
- s->stage = DOMOPEN_OPEN;
-
- return NT_STATUS_OK;
-
-failure:
- return NT_STATUS_UNSUCCESSFUL;
+ composite_continue_rpc(c, opendom_req, continue_domain_open_open, c);
}
/*
* Stage 3: Open domain.
*/
-static NTSTATUS domain_open_open(struct composite_context *c,
- struct domain_open_samr_state *s)
+static void continue_domain_open_open(struct rpc_request *req)
{
- /* receive samr_OpenDomain reply */
- c->status = dcerpc_ndr_request_recv(s->req);
- NT_STATUS_NOT_OK_RETURN(c->status);
-
- c->state = COMPOSITE_STATE_DONE;
-
- return NT_STATUS_OK;
-}
-
+ struct composite_context *c;
+ struct domain_open_samr_state *s;
-/**
- * Event handler for asynchronous request. Handles transition through
- * intermediate stages of the call.
- *
- * @param req rpc call context
- */
-static void domain_open_handler(struct rpc_request *req)
-{
- struct composite_context *c = req->async.private;
- struct domain_open_samr_state *s = talloc_get_type(c->private_data,
- struct domain_open_samr_state);
-
- /* Stages of the call */
- switch (s->stage) {
- case DOMOPEN_CONNECT:
- c->status = domain_open_connect(c, s);
- break;
- case DOMOPEN_LOOKUP:
- c->status = domain_open_lookup(c, s);
- break;
- case DOMOPEN_OPEN:
- c->status = domain_open_open(c, s);
- break;
- case DOMOPEN_CLOSE_EXISTING:
- c->status = domain_open_close(c, s);
- break;
- case DOMOPEN_RPC_CONNECT:
- /* this state shouldn't be handled here */
- c->status = NT_STATUS_UNSUCCESSFUL;
- break;
- }
+ c = talloc_get_type(req->async.private, struct composite_context);
+ s = talloc_get_type(c->private_data, struct domain_open_samr_state);
- if (!NT_STATUS_IS_OK(c->status)) {
- c->state = COMPOSITE_STATE_ERROR;
- }
+ /* receive samr_OpenDomain reply */
+ c->status = dcerpc_ndr_request_recv(req);
+ if (!composite_is_ok(c)) return;
- if (c->state == COMPOSITE_STATE_DONE) {
- composite_done(c);
- }
+ composite_done(c);
}
{
struct composite_context *c;
struct domain_open_samr_state *s;
+ struct composite_context *rpcconn_req;
+ struct rpc_request *close_req, *conn_req;
c = composite_create(ctx, ctx->event_ctx);
if (c == NULL) return NULL;
s->rpcconn.in.dcerpc_iface = &dcerpc_table_samr;
/* send rpc pipe connect request */
- s->rpcconn_req = libnet_RpcConnect_send(ctx, c, &s->rpcconn);
- if (composite_nomem(s->rpcconn_req, c)) return c;
-
- s->rpcconn_req->async.fn = domain_open_rpc_connect;
- s->rpcconn_req->async.private_data = c;
- s->stage = DOMOPEN_RPC_CONNECT;
+ rpcconn_req = libnet_RpcConnect_send(ctx, c, &s->rpcconn);
+ if (composite_nomem(rpcconn_req, c)) return c;
+ composite_continue(c, rpcconn_req, continue_domain_open_rpc_connect, c);
return c;
}
s->close.in.handle = &ctx->samr.handle;
/* send request to close domain handle */
- s->req = dcerpc_samr_Close_send(s->pipe, c, &s->close);
- if (composite_nomem(s->req, c)) return c;
+ close_req = dcerpc_samr_Close_send(s->pipe, c, &s->close);
+ if (composite_nomem(close_req, c)) return c;
/* callback handler */
- s->req->async.callback = domain_open_handler;
- s->req->async.private = c;
- s->stage = DOMOPEN_CLOSE_EXISTING;
-
+ composite_continue_rpc(c, close_req, continue_domain_open_close, c);
return c;
}
}
s->connect.out.connect_handle = &s->connect_handle;
/* send request */
- s->req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
- if (composite_nomem(s->req, c)) return c;
+ conn_req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
+ if (composite_nomem(conn_req, c)) return c;
/* callback handler */
- s->req->async.callback = domain_open_handler;
- s->req->async.private = c;
- s->stage = DOMOPEN_CONNECT;
-
+ composite_continue_rpc(c, conn_req, continue_domain_open_connect, c);
return c;
}
git.samba.org / bbaumbach / samba-autobuild / .git / commitdiff