r16573: Fixes in comments.
[bbaumbach/samba-autobuild/.git] / source4 / libnet / libnet_domain.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    Copyright (C) Rafal Szczesniak 2005
5    
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.
10    
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.
15    
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.
19 */
20
21 /*
22   a composite function for domain handling on samr pipe
23 */
24
25 #include "includes.h"
26 #include "libcli/composite/composite.h"
27 #include "libnet/libnet.h"
28 #include "librpc/gen_ndr/ndr_samr_c.h"
29
30 static void domain_open_handler(struct rpc_request*);
31
32 enum domain_open_stage { DOMOPEN_CONNECT, DOMOPEN_LOOKUP, DOMOPEN_OPEN,
33                          DOMOPEN_CLOSE_EXISTING, DOMOPEN_RPC_CONNECT };
34
35 struct domain_open_state {
36         enum domain_open_stage    stage;
37         struct libnet_context     *ctx;
38         struct dcerpc_pipe        *pipe;
39         struct rpc_request        *req;
40         struct composite_context  *rpcconn_req;
41         struct samr_Connect       connect;
42         struct samr_LookupDomain  lookup;
43         struct samr_OpenDomain    open;
44         struct samr_Close         close;
45         struct libnet_RpcConnect  rpcconn;
46         struct lsa_String         domain_name;
47         uint32_t                  access_mask;
48         struct policy_handle      connect_handle;
49         struct policy_handle      domain_handle;
50 };
51
52
53 /**
54  * Stage 0.5 (optional): Connect to samr rpc pipe
55  */
56 static void domain_open_rpc_connect(struct composite_context *ctx)
57 {
58         struct composite_context *c;
59         struct domain_open_state *s;
60
61         c = talloc_get_type(ctx->async.private_data, struct composite_context);
62         s = talloc_get_type(c->private_data, struct domain_open_state);
63
64         c->status = libnet_RpcConnect_recv(ctx, s->ctx, c, &s->rpcconn);
65         if (!composite_is_ok(c)) return;
66
67         s->pipe = s->rpcconn.out.dcerpc_pipe;
68
69         /* preparing parameters for samr_Connect rpc call */
70         s->connect.in.system_name      = 0;
71         s->connect.in.access_mask      = s->access_mask;
72         s->connect.out.connect_handle  = &s->connect_handle;
73
74         /* send request */
75         s->req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
76         if (composite_nomem(s->req, c)) return;
77
78         /* callback handler */
79         s->req->async.callback = domain_open_handler;
80         s->req->async.private  = c;
81         s->stage = DOMOPEN_CONNECT;
82 }
83
84
85 /**
86  * Stage 0.5 (optional): Close existing (in libnet context) domain
87  * handle
88  */
89 static NTSTATUS domain_open_close(struct composite_context *c,
90                                   struct domain_open_state *s)
91 {
92         /* receive samr_Close reply */
93         c->status = dcerpc_ndr_request_recv(s->req);
94         NT_STATUS_NOT_OK_RETURN(c->status);
95
96         /* reset domain handle and associated data in libnet_context */
97         s->ctx->domain.name        = NULL;
98         s->ctx->domain.access_mask = 0;
99         ZERO_STRUCT(s->ctx->domain.handle);
100
101         /* preparing parameters for samr_Connect rpc call */
102         s->connect.in.system_name      = 0;
103         s->connect.in.access_mask      = s->access_mask;
104         s->connect.out.connect_handle  = &s->connect_handle;
105         
106         /* send request */
107         s->req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
108         if (s->req == NULL) return NT_STATUS_NO_MEMORY;
109
110         /* callback handler */
111         s->req->async.callback = domain_open_handler;
112         s->req->async.private  = c;
113         s->stage = DOMOPEN_CONNECT;
114         
115         return NT_STATUS_OK;
116 }
117
118
119 /**
120  * Stage 1: Connect to SAM server.
121  */
122 static NTSTATUS domain_open_connect(struct composite_context *c,
123                                     struct domain_open_state *s)
124 {
125         struct samr_LookupDomain *r = &s->lookup;
126
127         /* receive samr_Connect reply */
128         c->status = dcerpc_ndr_request_recv(s->req);
129         NT_STATUS_NOT_OK_RETURN(c->status);
130
131         /* prepare for samr_LookupDomain call */
132         r->in.connect_handle = &s->connect_handle;
133         r->in.domain_name    = &s->domain_name;
134
135         s->req = dcerpc_samr_LookupDomain_send(s->pipe, c, r);
136         if (s->req == NULL) goto failure;
137
138         s->req->async.callback = domain_open_handler;
139         s->req->async.private  = c;
140         s->stage = DOMOPEN_LOOKUP;
141
142         return NT_STATUS_OK;
143
144 failure:
145         return NT_STATUS_UNSUCCESSFUL;
146 }
147
148
149 /**
150  * Stage 2: Lookup domain by name.
151  */
152 static NTSTATUS domain_open_lookup(struct composite_context *c,
153                                    struct domain_open_state *s)
154 {
155         struct samr_OpenDomain *r = &s->open;
156
157         /* receive samr_LookupDomain reply */
158         c->status = dcerpc_ndr_request_recv(s->req);
159         NT_STATUS_NOT_OK_RETURN(c->status);
160
161         /* prepare for samr_OpenDomain call */
162         r->in.connect_handle = &s->connect_handle;
163         r->in.access_mask    = SEC_FLAG_MAXIMUM_ALLOWED;
164         r->in.sid            = s->lookup.out.sid;
165         r->out.domain_handle = &s->domain_handle;
166
167         s->req = dcerpc_samr_OpenDomain_send(s->pipe, c, r);
168         if (s->req == NULL) goto failure;
169
170         s->req->async.callback = domain_open_handler;
171         s->req->async.private  = c;
172         s->stage = DOMOPEN_OPEN;
173
174         return NT_STATUS_OK;
175
176 failure:
177         return NT_STATUS_UNSUCCESSFUL;
178 }
179
180
181 /*
182  * Stage 3: Open domain.
183  */
184 static NTSTATUS domain_open_open(struct composite_context *c,
185                                  struct domain_open_state *s)
186 {
187         /* receive samr_OpenDomain reply */
188         c->status = dcerpc_ndr_request_recv(s->req);
189         NT_STATUS_NOT_OK_RETURN(c->status);
190
191         c->state = COMPOSITE_STATE_DONE;
192         
193         return NT_STATUS_OK;
194 }
195
196
197 /**
198  * Event handler for asynchronous request. Handles transition through
199  * intermediate stages of the call.
200  *
201  * @param req rpc call context
202  */
203 static void domain_open_handler(struct rpc_request *req)
204 {
205         struct composite_context *c = req->async.private;
206         struct domain_open_state *s = talloc_get_type(c->private_data, struct domain_open_state);
207
208         /* Stages of the call */
209         switch (s->stage) {
210         case DOMOPEN_CONNECT:
211                 c->status = domain_open_connect(c, s);
212                 break;
213         case DOMOPEN_LOOKUP:
214                 c->status = domain_open_lookup(c, s);
215                 break;
216         case DOMOPEN_OPEN:
217                 c->status = domain_open_open(c, s);
218                 break;
219         case DOMOPEN_CLOSE_EXISTING:
220                 c->status = domain_open_close(c, s);
221                 break;
222         case DOMOPEN_RPC_CONNECT:
223                 /* this state shouldn't be handled here */
224                 c->status = NT_STATUS_UNSUCCESSFUL;
225                 break;
226         }
227
228         if (!NT_STATUS_IS_OK(c->status)) {
229                 c->state = COMPOSITE_STATE_ERROR;
230         }
231
232         if (c->state == COMPOSITE_STATE_DONE) {
233                 composite_done(c);
234         }
235 }
236
237
238 /**
239  * Sends asynchronous DomainOpen request
240  *
241  * @param ctx initialised libnet context
242  * @param io arguments and results of the call
243  * @param monitor pointer to monitor function that is passed monitor message
244  */
245
246 struct composite_context *libnet_DomainOpen_send(struct libnet_context *ctx,
247                                                  struct libnet_DomainOpen *io,
248                                                  void (*monitor)(struct monitor_msg*))
249 {
250         struct composite_context *c;
251         struct domain_open_state *s;
252
253         c = talloc_zero(ctx, struct composite_context);
254         if (c == NULL) return NULL;
255
256         s = talloc_zero(c, struct domain_open_state);
257         if (composite_nomem(s, c)) return c;
258
259         c->state        = COMPOSITE_STATE_IN_PROGRESS;
260         c->private_data = s;
261         c->event_ctx    = ctx->event_ctx;
262
263         s->ctx                 = ctx;
264         s->pipe                = ctx->samr_pipe;
265         s->access_mask         = io->in.access_mask;
266         s->domain_name.string  = io->in.domain_name;
267
268         if (ctx->samr_pipe == NULL) {
269                 s->rpcconn.level           = LIBNET_RPC_CONNECT_DC;
270                 s->rpcconn.in.name         = io->in.domain_name;
271                 s->rpcconn.in.dcerpc_iface = &dcerpc_table_samr;
272
273                 s->rpcconn_req = libnet_RpcConnect_send(ctx, c, &s->rpcconn);
274                 if (composite_nomem(s->rpcconn_req, c)) return c;
275
276                 s->rpcconn_req->async.fn = domain_open_rpc_connect;
277                 s->rpcconn_req->async.private_data  = c;
278                 s->stage = DOMOPEN_RPC_CONNECT;
279
280                 return c;
281         }
282
283         /* libnet context's domain handle is not empty, so check out what
284            was opened first, before doing anything */
285         if (!policy_handle_empty(&ctx->domain.handle)) {
286                 if (strequal(ctx->domain.name, io->in.domain_name) &&
287                     ctx->domain.access_mask == io->in.access_mask) {
288
289                         /* this domain is already opened */
290                         composite_done(c);
291                         return c;
292
293                 } else {
294                         /* another domain or access rights have been
295                            requested - close the existing handle first */
296                         s->close.in.handle = &ctx->domain.handle;
297
298                         /* send request to close domain handle */
299                         s->req = dcerpc_samr_Close_send(s->pipe, c, &s->close);
300                         if (composite_nomem(s->req, c)) return c;
301
302                         /* callback handler */
303                         s->req->async.callback = domain_open_handler;
304                         s->req->async.private  = c;
305                         s->stage = DOMOPEN_CLOSE_EXISTING;
306
307                         return c;
308                 }
309         }
310
311         /* preparing parameters for samr_Connect rpc call */
312         s->connect.in.system_name      = 0;
313         s->connect.in.access_mask      = s->access_mask;
314         s->connect.out.connect_handle  = &s->connect_handle;
315         
316         /* send request */
317         s->req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
318         if (composite_nomem(s->req, c)) return c;
319
320         /* callback handler */
321         s->req->async.callback = domain_open_handler;
322         s->req->async.private  = c;
323         s->stage = DOMOPEN_CONNECT;
324
325         return c;
326 }
327
328
329 /**
330  * Waits for and receives result of asynchronous DomainOpen call
331  * 
332  * @param c composite context returned by asynchronous DomainOpen call
333  * @param ctx initialised libnet context
334  * @param mem_ctx memory context of the call
335  * @param io pointer to results (and arguments) of the call
336  * @return nt status code of execution
337  */
338
339 NTSTATUS libnet_DomainOpen_recv(struct composite_context *c, struct libnet_context *ctx,
340                                 TALLOC_CTX *mem_ctx, struct libnet_DomainOpen *io)
341 {
342         NTSTATUS status;
343         struct domain_open_state *s;
344
345         /* wait for results of sending request */
346         status = composite_wait(c);
347         
348         if (NT_STATUS_IS_OK(status) && io) {
349                 s = talloc_get_type(c->private_data, struct domain_open_state);
350                 io->out.domain_handle = s->domain_handle;
351
352                 /* store the resulting handle and related data for use by other
353                    libnet functions */
354                 ctx->domain.handle      = s->domain_handle;
355                 ctx->domain.name        = talloc_strdup(ctx, s->domain_name.string);
356                 ctx->domain.access_mask = s->access_mask;
357         }
358
359         talloc_free(c);
360         return status;
361 }
362
363
364 /**
365  * Synchronous version of DomainOpen call
366  *
367  * @param ctx initialised libnet context
368  * @param mem_ctx memory context for the call
369  * @param io arguments and results of the call
370  * @return nt status code of execution
371  */
372
373 NTSTATUS libnet_DomainOpen(struct libnet_context *ctx,
374                            TALLOC_CTX *mem_ctx,
375                            struct libnet_DomainOpen *io)
376 {
377         struct composite_context *c = libnet_DomainOpen_send(ctx, io, NULL);
378         return libnet_DomainOpen_recv(c, ctx, mem_ctx, io);
379 }