r22519: convert libnet_DomainOpenSamr function from state-handling routine
authorRafal Szczesniak <mimir@samba.org>
Wed, 25 Apr 2007 15:24:01 +0000 (15:24 +0000)
committerGerald (Jerry) Carter <jerry@samba.org>
Wed, 10 Oct 2007 19:51:36 +0000 (14:51 -0500)
to composite_continue.

rafal
(This used to be commit 4a2839d95d18fe05152abbd88676c4fef4d59ace)

source4/libnet/libnet_domain.c

index 57c0ce6..7d8bbc8 100644 (file)
@@ -1,4 +1,4 @@
-/* 
+ /* 
    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;
@@ -54,13 +47,20 @@ struct domain_open_samr_state {
 };
 
 
+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 @@ static void domain_open_rpc_connect(struct composite_context *ctx)
        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 @@ static void domain_open_rpc_connect(struct composite_context *ctx)
  * 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,59 +112,70 @@ static NTSTATUS domain_open_close(struct composite_context *c,
        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;
@@ -168,75 +183,29 @@ static NTSTATUS domain_open_lookup(struct composite_context *c,
        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);
 }
 
 
@@ -254,6 +223,8 @@ struct composite_context *libnet_DomainOpenSamr_send(struct libnet_context *ctx,
 {
        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 @@ struct composite_context *libnet_DomainOpenSamr_send(struct libnet_context *ctx,
                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;
        }
 
@@ -304,14 +272,11 @@ struct composite_context *libnet_DomainOpenSamr_send(struct libnet_context *ctx,
                        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 @@ struct composite_context *libnet_DomainOpenSamr_send(struct libnet_context *ctx,
        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;
 }