svn commit: samba r22519 - in branches/SAMBA_4_0/source/libnet: .
mimir at samba.org
mimir at samba.org
Wed Apr 25 15:24:02 GMT 2007
Author: mimir
Date: 2007-04-25 15:24:01 +0000 (Wed, 25 Apr 2007)
New Revision: 22519
WebSVN: http://websvn.samba.org/cgi-bin/viewcvs.cgi?view=rev&root=samba&rev=22519
Log:
convert libnet_DomainOpenSamr function from state-handling routine
to composite_continue.
rafal
Modified:
branches/SAMBA_4_0/source/libnet/libnet_domain.c
Changeset:
Modified: branches/SAMBA_4_0/source/libnet/libnet_domain.c
===================================================================
--- branches/SAMBA_4_0/source/libnet/libnet_domain.c 2007-04-25 14:18:22 UTC (rev 22518)
+++ branches/SAMBA_4_0/source/libnet/libnet_domain.c 2007-04-25 15:24:01 UTC (rev 22519)
@@ -1,4 +1,4 @@
-/*
+ /*
Unix SMB/CIFS implementation.
Copyright (C) Rafal Szczesniak 2005
@@ -28,22 +28,15 @@
#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;
@@ -54,13 +47,20 @@
};
+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);
@@ -76,13 +76,11 @@
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);
}
@@ -90,12 +88,18 @@
* 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;
@@ -108,135 +112,100 @@
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.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
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);
+ struct composite_context *c;
+ struct domain_open_samr_state *s;
- c->state = COMPOSITE_STATE_DONE;
-
- return NT_STATUS_OK;
-}
+ c = talloc_get_type(req->async.private, struct composite_context);
+ s = talloc_get_type(c->private_data, struct domain_open_samr_state);
+ /* receive samr_OpenDomain reply */
+ c->status = dcerpc_ndr_request_recv(req);
+ if (!composite_is_ok(c)) return;
-/**
- * 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;
- }
-
- if (!NT_STATUS_IS_OK(c->status)) {
- c->state = COMPOSITE_STATE_ERROR;
- }
-
- if (c->state == COMPOSITE_STATE_DONE) {
- composite_done(c);
- }
+ composite_done(c);
}
@@ -254,6 +223,8 @@
{
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;
@@ -278,13 +249,10 @@
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;
+ rpcconn_req = libnet_RpcConnect_send(ctx, c, &s->rpcconn);
+ if (composite_nomem(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;
-
+ composite_continue(c, rpcconn_req, continue_domain_open_rpc_connect, c);
return c;
}
@@ -304,14 +272,11 @@
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;
}
}
@@ -322,14 +287,11 @@
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;
}
More information about the samba-cvs
mailing list