r24557: rename 'dcerpc_table_' -> 'ndr_table_'
[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 3 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, see <http://www.gnu.org/licenses/>.
18 */
19
20 /*
21   a composite function for domain handling on samr and lsa pipes
22 */
23
24 #include "includes.h"
25 #include "libcli/composite/composite.h"
26 #include "libnet/libnet.h"
27 #include "librpc/gen_ndr/ndr_samr_c.h"
28 #include "librpc/gen_ndr/ndr_lsa_c.h"
29
30
31 struct domain_open_samr_state {
32         struct libnet_context     *ctx;
33         struct dcerpc_pipe        *pipe;
34         struct libnet_RpcConnect  rpcconn;
35         struct samr_Connect       connect;
36         struct samr_LookupDomain  lookup;
37         struct samr_OpenDomain    open;
38         struct samr_Close         close;
39         struct lsa_String         domain_name;
40         uint32_t                  access_mask;
41         struct policy_handle      connect_handle;
42         struct policy_handle      domain_handle;
43
44         /* information about the progress */
45         void (*monitor_fn)(struct monitor_msg*);
46 };
47
48
49 static void continue_domain_open_close(struct rpc_request *req);
50 static void continue_domain_open_connect(struct rpc_request *req);
51 static void continue_domain_open_lookup(struct rpc_request *req);
52 static void continue_domain_open_open(struct rpc_request *req);
53
54
55 /**
56  * Stage 0.5 (optional): Connect to samr rpc pipe
57  */
58 static void continue_domain_open_rpc_connect(struct composite_context *ctx)
59 {
60         struct composite_context *c;
61         struct domain_open_samr_state *s;
62         struct rpc_request *conn_req;
63
64         c = talloc_get_type(ctx->async.private_data, struct composite_context);
65         s = talloc_get_type(c->private_data, struct domain_open_samr_state);
66
67         c->status = libnet_RpcConnect_recv(ctx, s->ctx, c, &s->rpcconn);
68         if (!composite_is_ok(c)) return;
69
70         s->pipe = s->rpcconn.out.dcerpc_pipe;
71
72         /* preparing parameters for samr_Connect rpc call */
73         s->connect.in.system_name      = 0;
74         s->connect.in.access_mask      = s->access_mask;
75         s->connect.out.connect_handle  = &s->connect_handle;
76
77         /* send request */
78         conn_req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
79         if (composite_nomem(conn_req, c)) return;
80
81         /* callback handler */
82         composite_continue_rpc(c, conn_req, continue_domain_open_connect, c);
83 }
84
85
86 /**
87  * Stage 0.5 (optional): Close existing (in libnet context) domain
88  * handle
89  */
90 static void continue_domain_open_close(struct rpc_request *req)
91 {
92         struct composite_context *c;
93         struct domain_open_samr_state *s;
94         struct rpc_request *conn_req;
95
96         c = talloc_get_type(req->async.private_data, struct composite_context);
97         s = talloc_get_type(c->private_data, struct domain_open_samr_state);
98
99         /* receive samr_Close reply */
100         c->status = dcerpc_ndr_request_recv(req);
101         if (!composite_is_ok(c)) return;
102
103         if (s->monitor_fn) {
104                 struct monitor_msg msg;
105                 
106                 msg.type = mon_SamrClose;
107                 msg.data = NULL;
108                 msg.data_size = 0;
109                 s->monitor_fn(&msg);
110         }
111
112         /* reset domain handle and associated data in libnet_context */
113         s->ctx->samr.name        = NULL;
114         s->ctx->samr.access_mask = 0;
115         ZERO_STRUCT(s->ctx->samr.handle);
116
117         /* preparing parameters for samr_Connect rpc call */
118         s->connect.in.system_name      = 0;
119         s->connect.in.access_mask      = s->access_mask;
120         s->connect.out.connect_handle  = &s->connect_handle;
121         
122         /* send request */
123         conn_req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
124         if (composite_nomem(conn_req, c)) return;
125
126         /* callback handler */
127         composite_continue_rpc(c, conn_req, continue_domain_open_connect, c);
128 }
129
130
131 /**
132  * Stage 1: Connect to SAM server.
133  */
134 static void continue_domain_open_connect(struct rpc_request *req)
135 {
136         struct composite_context *c;
137         struct domain_open_samr_state *s;
138         struct rpc_request *lookup_req;
139         struct samr_LookupDomain *r;
140         
141         c = talloc_get_type(req->async.private_data, struct composite_context);
142         s = talloc_get_type(c->private_data, struct domain_open_samr_state);
143
144         /* receive samr_Connect reply */
145         c->status = dcerpc_ndr_request_recv(req);
146         if (!composite_is_ok(c)) return;
147
148         if (s->monitor_fn) {
149                 struct monitor_msg msg;
150
151                 msg.type = mon_SamrConnect;
152                 msg.data = NULL;
153                 msg.data_size = 0;
154                 s->monitor_fn(&msg);
155         }
156
157         r = &s->lookup;
158
159         /* prepare for samr_LookupDomain call */
160         r->in.connect_handle = &s->connect_handle;
161         r->in.domain_name    = &s->domain_name;
162
163         lookup_req = dcerpc_samr_LookupDomain_send(s->pipe, c, r);
164         if (composite_nomem(lookup_req, c)) return;
165
166         composite_continue_rpc(c, lookup_req, continue_domain_open_lookup, c);
167 }
168
169
170 /**
171  * Stage 2: Lookup domain by name.
172  */
173 static void continue_domain_open_lookup(struct rpc_request *req)
174 {
175         struct composite_context *c;
176         struct domain_open_samr_state *s;
177         struct rpc_request *opendom_req;
178         struct samr_OpenDomain *r;
179
180         c = talloc_get_type(req->async.private_data, struct composite_context);
181         s = talloc_get_type(c->private_data, struct domain_open_samr_state);
182         
183         /* receive samr_LookupDomain reply */
184         c->status = dcerpc_ndr_request_recv(req);
185
186         if (s->monitor_fn) {
187                 struct monitor_msg msg;
188                 struct msg_rpc_lookup_domain data;
189
190                 data.domain_name = s->domain_name.string;
191
192                 msg.type = mon_SamrLookupDomain;
193                 msg.data = (void*)&data;
194                 msg.data_size = sizeof(data);
195                 s->monitor_fn(&msg);
196         }
197
198         r = &s->open;
199
200         /* check the rpc layer status */
201         if (!composite_is_ok(c));
202
203         /* check the rpc call itself status */
204         if (!NT_STATUS_IS_OK(s->lookup.out.result)) {
205                 composite_error(c, s->lookup.out.result);
206                 return;
207         }
208
209         /* prepare for samr_OpenDomain call */
210         r->in.connect_handle = &s->connect_handle;
211         r->in.access_mask    = SEC_FLAG_MAXIMUM_ALLOWED;
212         r->in.sid            = s->lookup.out.sid;
213         r->out.domain_handle = &s->domain_handle;
214
215         opendom_req = dcerpc_samr_OpenDomain_send(s->pipe, c, r);
216         if (composite_nomem(opendom_req, c)) return;
217
218         composite_continue_rpc(c, opendom_req, continue_domain_open_open, c);
219 }
220
221
222 /*
223  * Stage 3: Open domain.
224  */
225 static void continue_domain_open_open(struct rpc_request *req)
226 {
227         struct composite_context *c;
228         struct domain_open_samr_state *s;
229
230         c = talloc_get_type(req->async.private_data, struct composite_context);
231         s = talloc_get_type(c->private_data, struct domain_open_samr_state);
232
233         /* receive samr_OpenDomain reply */
234         c->status = dcerpc_ndr_request_recv(req);
235         if (!composite_is_ok(c)) return;
236
237         if (s->monitor_fn) {
238                 struct monitor_msg msg;
239                 
240                 msg.type = mon_SamrOpenDomain;
241                 msg.data = NULL;
242                 msg.data_size = 0;
243                 s->monitor_fn(&msg);
244         }
245
246         composite_done(c);
247 }
248
249
250 /**
251  * Sends asynchronous DomainOpenSamr request
252  *
253  * @param ctx initialised libnet context
254  * @param io arguments and results of the call
255  * @param monitor pointer to monitor function that is passed monitor message
256  */
257
258 struct composite_context *libnet_DomainOpenSamr_send(struct libnet_context *ctx,
259                                                      struct libnet_DomainOpen *io,
260                                                      void (*monitor)(struct monitor_msg*))
261 {
262         struct composite_context *c;
263         struct domain_open_samr_state *s;
264         struct composite_context *rpcconn_req;
265         struct rpc_request *close_req, *conn_req;
266
267         c = composite_create(ctx, ctx->event_ctx);
268         if (c == NULL) return NULL;
269
270         s = talloc_zero(c, struct domain_open_samr_state);
271         if (composite_nomem(s, c)) return c;
272
273         c->private_data = s;
274         s->monitor_fn   = monitor;
275
276         s->ctx                 = ctx;
277         s->pipe                = ctx->samr.pipe;
278         s->access_mask         = io->in.access_mask;
279         s->domain_name.string  = talloc_strdup(c, io->in.domain_name);
280
281         /* check, if there's samr pipe opened already, before opening a domain */
282         if (ctx->samr.pipe == NULL) {
283
284                 /* attempting to connect a domain controller */
285                 s->rpcconn.level           = LIBNET_RPC_CONNECT_DC;
286                 s->rpcconn.in.name         = io->in.domain_name;
287                 s->rpcconn.in.dcerpc_iface = &ndr_table_samr;
288                 
289                 /* send rpc pipe connect request */
290                 rpcconn_req = libnet_RpcConnect_send(ctx, c, &s->rpcconn, s->monitor_fn);
291                 if (composite_nomem(rpcconn_req, c)) return c;
292
293                 composite_continue(c, rpcconn_req, continue_domain_open_rpc_connect, c);
294                 return c;
295         }
296
297         /* libnet context's domain handle is not empty, so check out what
298            was opened first, before doing anything */
299         if (!policy_handle_empty(&ctx->samr.handle)) {
300                 if (strequal(ctx->samr.name, io->in.domain_name) &&
301                     ctx->samr.access_mask == io->in.access_mask) {
302
303                         /* this domain is already opened */
304                         composite_done(c);
305                         return c;
306
307                 } else {
308                         /* another domain or access rights have been
309                            requested - close the existing handle first */
310                         s->close.in.handle = &ctx->samr.handle;
311
312                         /* send request to close domain handle */
313                         close_req = dcerpc_samr_Close_send(s->pipe, c, &s->close);
314                         if (composite_nomem(close_req, c)) return c;
315
316                         /* callback handler */
317                         composite_continue_rpc(c, close_req, continue_domain_open_close, c);
318                         return c;
319                 }
320         }
321
322         /* preparing parameters for samr_Connect rpc call */
323         s->connect.in.system_name      = 0;
324         s->connect.in.access_mask      = s->access_mask;
325         s->connect.out.connect_handle  = &s->connect_handle;
326         
327         /* send request */
328         conn_req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
329         if (composite_nomem(conn_req, c)) return c;
330
331         /* callback handler */
332         composite_continue_rpc(c, conn_req, continue_domain_open_connect, c);
333         return c;
334 }
335
336
337 /**
338  * Waits for and receives result of asynchronous DomainOpenSamr call
339  * 
340  * @param c composite context returned by asynchronous DomainOpen call
341  * @param ctx initialised libnet context
342  * @param mem_ctx memory context of the call
343  * @param io pointer to results (and arguments) of the call
344  * @return nt status code of execution
345  */
346
347 NTSTATUS libnet_DomainOpenSamr_recv(struct composite_context *c, struct libnet_context *ctx,
348                                     TALLOC_CTX *mem_ctx, struct libnet_DomainOpen *io)
349 {
350         NTSTATUS status;
351         struct domain_open_samr_state *s;
352
353         /* wait for results of sending request */
354         status = composite_wait(c);
355         
356         if (NT_STATUS_IS_OK(status) && io) {
357                 s = talloc_get_type(c->private_data, struct domain_open_samr_state);
358                 io->out.domain_handle = s->domain_handle;
359
360                 /* store the resulting handle and related data for use by other
361                    libnet functions */
362                 ctx->samr.connect_handle = s->connect_handle;
363                 ctx->samr.handle      = s->domain_handle;
364                 ctx->samr.sid         = talloc_steal(ctx, s->lookup.out.sid);
365                 ctx->samr.name        = talloc_steal(ctx, s->domain_name.string);
366                 ctx->samr.access_mask = s->access_mask;
367         }
368
369         talloc_free(c);
370         return status;
371 }
372
373
374 struct domain_open_lsa_state {
375         const char *name;
376         uint32_t access_mask;
377         struct libnet_context *ctx;
378         struct libnet_RpcConnect rpcconn;
379         struct lsa_OpenPolicy2   openpol;
380         struct policy_handle handle;
381         struct dcerpc_pipe *pipe;
382
383         /* information about the progress */
384         void (*monitor_fn)(struct monitor_msg*);
385 };
386
387
388 static void continue_rpc_connect_lsa(struct composite_context *ctx);
389 static void continue_lsa_policy_open(struct rpc_request *req);
390
391
392 /**
393  * Sends asynchronous DomainOpenLsa request
394  *
395  * @param ctx initialised libnet context
396  * @param io arguments and results of the call
397  * @param monitor pointer to monitor function that is passed monitor message
398  */
399
400 struct composite_context* libnet_DomainOpenLsa_send(struct libnet_context *ctx,
401                                                     struct libnet_DomainOpen *io,
402                                                     void (*monitor)(struct monitor_msg*))
403 {
404         struct composite_context *c;
405         struct domain_open_lsa_state *s;
406         struct composite_context *rpcconn_req;
407         struct rpc_request *openpol_req;
408         struct lsa_QosInfo *qos;
409
410         /* create composite context and state */
411         c = composite_create(ctx, ctx->event_ctx);
412         if (c == NULL) return c;
413
414         s = talloc_zero(c, struct domain_open_lsa_state);
415         if (composite_nomem(s, c)) return c;
416
417         c->private_data = s;
418
419         /* store arguments in the state structure */
420         s->name         = talloc_strdup(c, io->in.domain_name);
421         s->access_mask  = io->in.access_mask;
422         s->ctx          = ctx;
423
424         /* check, if there's lsa pipe opened already, before opening a handle */
425         if (ctx->lsa.pipe == NULL) {
426
427                 /* attempting to connect a domain controller */
428                 s->rpcconn.level           = LIBNET_RPC_CONNECT_DC;
429                 s->rpcconn.in.name         = talloc_strdup(c, io->in.domain_name);
430                 s->rpcconn.in.dcerpc_iface = &ndr_table_lsarpc;
431                 
432                 /* send rpc pipe connect request */
433                 rpcconn_req = libnet_RpcConnect_send(ctx, c, &s->rpcconn, s->monitor_fn);
434                 if (composite_nomem(rpcconn_req, c)) return c;
435
436                 composite_continue(c, rpcconn_req, continue_rpc_connect_lsa, c);
437                 return c;
438         }
439
440         s->pipe = ctx->lsa.pipe;
441
442         /* preparing parameters for lsa_OpenPolicy2 rpc call */
443         s->openpol.in.system_name = s->name;
444         s->openpol.in.access_mask = s->access_mask;
445         s->openpol.in.attr        = talloc_zero(c, struct lsa_ObjectAttribute);
446
447         qos = talloc_zero(c, struct lsa_QosInfo);
448         qos->len                 = 0;
449         qos->impersonation_level = 2;
450         qos->context_mode        = 1;
451         qos->effective_only      = 0;
452
453         s->openpol.in.attr->sec_qos = qos;
454         s->openpol.out.handle       = &s->handle;
455         
456         /* send rpc request */
457         openpol_req = dcerpc_lsa_OpenPolicy2_send(s->pipe, c, &s->openpol);
458         if (composite_nomem(openpol_req, c)) return c;
459
460         composite_continue_rpc(c, openpol_req, continue_lsa_policy_open, c);
461         return c;
462 }
463
464
465 /*
466   Stage 0.5 (optional): Rpc pipe connected, send lsa open policy request
467  */
468 static void continue_rpc_connect_lsa(struct composite_context *ctx)
469 {
470         struct composite_context *c;
471         struct domain_open_lsa_state *s;
472         struct lsa_QosInfo *qos;
473         struct rpc_request *openpol_req;
474
475         c = talloc_get_type(ctx->async.private_data, struct composite_context);
476         s = talloc_get_type(c->private_data, struct domain_open_lsa_state);
477
478         /* receive rpc connection */
479         c->status = libnet_RpcConnect_recv(ctx, s->ctx, c, &s->rpcconn);
480         if (!composite_is_ok(c)) return;
481
482         /* RpcConnect function leaves the pipe in libnet context,
483            so get it from there */
484         s->pipe = s->ctx->lsa.pipe;
485
486         /* prepare lsa_OpenPolicy2 call */
487         s->openpol.in.system_name = s->name;
488         s->openpol.in.access_mask = s->access_mask;
489         s->openpol.in.attr        = talloc_zero(c, struct lsa_ObjectAttribute);
490
491         qos = talloc_zero(c, struct lsa_QosInfo);
492         qos->len                 = 0;
493         qos->impersonation_level = 2;
494         qos->context_mode        = 1;
495         qos->effective_only      = 0;
496
497         s->openpol.in.attr->sec_qos = qos;
498         s->openpol.out.handle       = &s->handle;
499
500         /* send rpc request */
501         openpol_req = dcerpc_lsa_OpenPolicy2_send(s->pipe, c, &s->openpol);
502         if (composite_nomem(openpol_req, c)) return;
503
504         composite_continue_rpc(c, openpol_req, continue_lsa_policy_open, c);
505 }
506
507
508 /*
509   Stage 1: Lsa policy opened - we're done, if successfully
510  */
511 static void continue_lsa_policy_open(struct rpc_request *req)
512 {
513         struct composite_context *c;
514         struct domain_open_lsa_state *s;
515
516         c = talloc_get_type(req->async.private_data, struct composite_context);
517         s = talloc_get_type(c->private_data, struct domain_open_lsa_state);
518
519         c->status = dcerpc_ndr_request_recv(req);
520         if (!composite_is_ok(c)) return;
521
522         if (s->monitor_fn) {
523                 struct monitor_msg msg;
524                 
525                 msg.type      = mon_LsaOpenPolicy;
526                 msg.data      = NULL;
527                 msg.data_size = 0;
528                 s->monitor_fn(&msg);
529         }
530
531         composite_done(c);
532 }
533
534
535 /**
536  * Receives result of asynchronous DomainOpenLsa call
537  *
538  * @param c composite context returned by asynchronous DomainOpenLsa call
539  * @param ctx initialised libnet context
540  * @param mem_ctx memory context of the call
541  * @param io pointer to results (and arguments) of the call
542  * @return nt status code of execution
543  */
544
545 NTSTATUS libnet_DomainOpenLsa_recv(struct composite_context *c, struct libnet_context *ctx,
546                                    TALLOC_CTX *mem_ctx, struct libnet_DomainOpen *io)
547 {
548         NTSTATUS status;
549         struct domain_open_lsa_state *s;
550
551         status = composite_wait(c);
552
553         if (NT_STATUS_IS_OK(status) && io) {
554                 /* everything went fine - get the results and
555                    return the error string */
556                 s = talloc_get_type(c->private_data, struct domain_open_lsa_state);
557                 io->out.domain_handle = s->handle;
558
559                 ctx->lsa.handle      = s->handle;
560                 ctx->lsa.name        = talloc_steal(ctx, s->name);
561                 ctx->lsa.access_mask = s->access_mask;
562                 
563                 io->out.error_string = talloc_strdup(mem_ctx, "Success");
564
565         } else if (!NT_STATUS_IS_OK(status)) {
566                 /* there was an error, so provide nt status code description */
567                 io->out.error_string = talloc_asprintf(mem_ctx,
568                                                        "Failed to open domain: %s",
569                                                        nt_errstr(status));
570         }
571
572         talloc_free(c);
573         return status;
574 }
575
576
577 /**
578  * Sends a request to open a domain in desired service
579  *
580  * @param ctx initalised libnet context
581  * @param io arguments and results of the call
582  * @param monitor pointer to monitor function that is passed monitor message
583  */
584
585 struct composite_context* libnet_DomainOpen_send(struct libnet_context *ctx,
586                                                  struct libnet_DomainOpen *io,
587                                                  void (*monitor)(struct monitor_msg*))
588 {
589         struct composite_context *c;
590
591         switch (io->in.type) {
592         case DOMAIN_LSA:
593                 /* reques to open a policy handle on \pipe\lsarpc */
594                 c = libnet_DomainOpenLsa_send(ctx, io, monitor);
595                 break;
596
597         case DOMAIN_SAMR:
598         default:
599                 /* request to open a domain policy handle on \pipe\samr */
600                 c = libnet_DomainOpenSamr_send(ctx, io, monitor);
601                 break;
602         }
603
604         return c;
605 }
606
607
608 /**
609  * Receive result of domain open request
610  *
611  * @param c composite context returned by DomainOpen_send function
612  * @param ctx initialised libnet context
613  * @param mem_ctx memory context of the call
614  * @param io results and arguments of the call
615  */
616
617 NTSTATUS libnet_DomainOpen_recv(struct composite_context *c, struct libnet_context *ctx,
618                                 TALLOC_CTX *mem_ctx, struct libnet_DomainOpen *io)
619 {
620         NTSTATUS status;
621
622         switch (io->in.type) {
623         case DOMAIN_LSA:
624                 status = libnet_DomainOpenLsa_recv(c, ctx, mem_ctx, io);
625                 break;
626
627         case DOMAIN_SAMR:
628         default:
629                 status = libnet_DomainOpenSamr_recv(c, ctx, mem_ctx, io);
630                 break;
631         }
632         
633         return status;
634 }
635
636
637 /**
638  * Synchronous version of DomainOpen call
639  *
640  * @param ctx initialised libnet context
641  * @param mem_ctx memory context for the call
642  * @param io arguments and results of the call
643  * @return nt status code of execution
644  */
645
646 NTSTATUS libnet_DomainOpen(struct libnet_context *ctx,
647                            TALLOC_CTX *mem_ctx,
648                            struct libnet_DomainOpen *io)
649 {
650         struct composite_context *c = libnet_DomainOpen_send(ctx, io, NULL);
651         return libnet_DomainOpen_recv(c, ctx, mem_ctx, io);
652 }
653
654
655 struct domain_close_lsa_state {
656         struct dcerpc_pipe *pipe;
657         struct lsa_Close close;
658         struct policy_handle handle;
659
660         void (*monitor_fn)(struct monitor_msg*);
661 };
662
663
664 static void continue_lsa_close(struct rpc_request *req);
665
666
667 struct composite_context* libnet_DomainCloseLsa_send(struct libnet_context *ctx,
668                                                      struct libnet_DomainClose *io,
669                                                      void (*monitor)(struct monitor_msg*))
670 {
671         struct composite_context *c;
672         struct domain_close_lsa_state *s;
673         struct rpc_request *close_req;
674
675         /* composite context and state structure allocation */
676         c = composite_create(ctx, ctx->event_ctx);
677         if (c == NULL) return c;
678
679         s = talloc_zero(c, struct domain_close_lsa_state);
680         if (composite_nomem(s, c)) return c;
681
682         c->private_data = s;
683         s->monitor_fn   = monitor;
684
685         /* TODO: check if lsa pipe pointer is non-null */
686
687         if (!strequal(ctx->lsa.name, io->in.domain_name)) {
688                 composite_error(c, NT_STATUS_INVALID_PARAMETER);
689                 return c;
690         }
691
692         /* get opened lsarpc pipe pointer */
693         s->pipe = ctx->lsa.pipe;
694         
695         /* prepare close handle call arguments */
696         s->close.in.handle  = &ctx->lsa.handle;
697         s->close.out.handle = &s->handle;
698
699         /* send the request */
700         close_req = dcerpc_lsa_Close_send(s->pipe, c, &s->close);
701         if (composite_nomem(close_req, c)) return c;
702
703         composite_continue_rpc(c, close_req, continue_lsa_close, c);
704         return c;
705 }
706
707
708 /*
709   Stage 1: Receive result of lsa close call
710 */
711 static void continue_lsa_close(struct rpc_request *req)
712 {
713         struct composite_context *c;
714         struct domain_close_lsa_state *s;
715         
716         c = talloc_get_type(req->async.private_data, struct composite_context);
717         s = talloc_get_type(c->private_data, struct domain_close_lsa_state);
718
719         c->status = dcerpc_ndr_request_recv(req);
720         if (!composite_is_ok(c)) return;
721
722         if (s->monitor_fn) {
723                 struct monitor_msg msg;
724
725                 msg.type      = mon_LsaClose;
726                 msg.data      = NULL;
727                 msg.data_size = 0;
728                 s->monitor_fn(&msg);
729         }
730
731         composite_done(c);
732 }
733
734
735 NTSTATUS libnet_DomainCloseLsa_recv(struct composite_context *c, struct libnet_context *ctx,
736                                     TALLOC_CTX *mem_ctx, struct libnet_DomainClose *io)
737 {
738         NTSTATUS status;
739
740         status = composite_wait(c);
741
742         if (NT_STATUS_IS_OK(status) && io) {
743                 /* policy handle closed successfully */
744
745                 ctx->lsa.name = NULL;
746                 ZERO_STRUCT(ctx->lsa.handle);
747
748                 io->out.error_string = talloc_asprintf(mem_ctx, "Success");
749
750         } else if (!NT_STATUS_IS_OK(status)) {
751                 /* there was an error, so return description of the status code */
752                 io->out.error_string = talloc_asprintf(mem_ctx, "Error: %s", nt_errstr(status));
753         }
754
755         talloc_free(c);
756         return status;
757 }
758
759
760 struct domain_close_samr_state {
761         struct samr_Close close;
762         struct policy_handle handle;
763         
764         void (*monitor_fn)(struct monitor_msg*);
765 };
766
767
768 static void continue_samr_close(struct rpc_request *req);
769
770
771 struct composite_context* libnet_DomainCloseSamr_send(struct libnet_context *ctx,
772                                                       struct libnet_DomainClose *io,
773                                                       void (*monitor)(struct monitor_msg*))
774 {
775         struct composite_context *c;
776         struct domain_close_samr_state *s;
777         struct rpc_request *close_req;
778
779         /* composite context and state structure allocation */
780         c = composite_create(ctx, ctx->event_ctx);
781         if (c == NULL) return c;
782
783         s = talloc_zero(c, struct domain_close_samr_state);
784         if (composite_nomem(s, c)) return c;
785
786         c->private_data = s;
787         s->monitor_fn   = monitor;
788
789         /* TODO: check if samr pipe pointer is non-null */
790
791         if (!strequal(ctx->samr.name, io->in.domain_name)) {
792                 composite_error(c, NT_STATUS_INVALID_PARAMETER);
793                 return c;
794         }
795
796         /* prepare close domain handle call arguments */
797         ZERO_STRUCT(s->close);
798         s->close.in.handle  = &ctx->samr.handle;
799         s->close.out.handle = &s->handle;
800
801         /* send the request */
802         close_req = dcerpc_samr_Close_send(ctx->samr.pipe, ctx, &s->close);
803         if (composite_nomem(close_req, c)) return c;
804
805         composite_continue_rpc(c, close_req, continue_samr_close, c);
806         return c;
807 }
808
809
810 /*
811   Stage 1: Receive result of samr close call
812 */
813 static void continue_samr_close(struct rpc_request *req)
814 {
815         struct composite_context *c;
816         struct domain_close_samr_state *s;
817
818         c = talloc_get_type(req->async.private_data, struct composite_context);
819         s = talloc_get_type(c->private_data, struct domain_close_samr_state);
820         
821         c->status = dcerpc_ndr_request_recv(req);
822         if (!composite_is_ok(c)) return;
823
824         if (s->monitor_fn) {
825                 struct monitor_msg msg;
826                 
827                 msg.type      = mon_SamrClose;
828                 msg.data      = NULL;
829                 msg.data_size = 0;
830                 s->monitor_fn(&msg);
831         }
832         
833         composite_done(c);
834 }
835
836
837 NTSTATUS libnet_DomainCloseSamr_recv(struct composite_context *c, struct libnet_context *ctx,
838                                      TALLOC_CTX *mem_ctx, struct libnet_DomainClose *io)
839 {
840         NTSTATUS status;
841
842         status = composite_wait(c);
843
844         if (NT_STATUS_IS_OK(status) && io) {
845                 /* domain policy handle closed successfully */
846
847                 ZERO_STRUCT(ctx->samr.handle);
848                 talloc_free(ctx->samr.name);
849                 talloc_free(ctx->samr.sid);
850                 ctx->samr.name = NULL;
851                 ctx->samr.sid = NULL;
852
853                 io->out.error_string = talloc_asprintf(mem_ctx, "Success");
854
855         } else if (!NT_STATUS_IS_OK(status)) {
856                 /* there was an error, so return description of the status code */
857                 io->out.error_string = talloc_asprintf(mem_ctx, "Error: %s", nt_errstr(status));
858         }
859
860         talloc_free(c);
861         return status;
862 }
863
864
865 struct composite_context* libnet_DomainClose_send(struct libnet_context *ctx,
866                                                   struct libnet_DomainClose *io,
867                                                   void (*monitor)(struct monitor_msg*))
868 {
869         struct composite_context *c;
870
871         switch (io->in.type) {
872         case DOMAIN_LSA:
873                 /* request to close policy handle on \pipe\lsarpc */
874                 c = libnet_DomainCloseLsa_send(ctx, io, monitor);
875                 break;
876
877         case DOMAIN_SAMR:
878         default:
879                 /* request to close domain policy handle on \pipe\samr */
880                 c = libnet_DomainCloseSamr_send(ctx, io, monitor);
881                 break;
882         }
883         
884         return c;
885 }
886
887
888 NTSTATUS libnet_DomainClose_recv(struct composite_context *c, struct libnet_context *ctx,
889                                  TALLOC_CTX *mem_ctx, struct libnet_DomainClose *io)
890 {
891         NTSTATUS status;
892
893         switch (io->in.type) {
894         case DOMAIN_LSA:
895                 /* receive result of closing lsa policy handle */
896                 status = libnet_DomainCloseLsa_recv(c, ctx, mem_ctx, io);
897                 break;
898
899         case DOMAIN_SAMR:
900         default:
901                 /* receive result of closing samr domain policy handle */
902                 status = libnet_DomainCloseSamr_recv(c, ctx, mem_ctx, io);
903                 break;
904         }
905         
906         return status;
907 }
908
909
910 NTSTATUS libnet_DomainClose(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
911                             struct libnet_DomainClose *io)
912 {
913         struct composite_context *c;
914         
915         c = libnet_DomainClose_send(ctx, io, NULL);
916         return libnet_DomainClose_recv(c, ctx, mem_ctx, io);
917 }
918
919
920 struct domain_list_state {      
921         struct libnet_context *ctx;
922         struct libnet_RpcConnect rpcconn;
923         struct samr_Connect samrconn;
924         struct samr_EnumDomains enumdom;
925         struct samr_Close samrclose;
926         const char *hostname;
927         struct policy_handle connect_handle;
928         int buf_size;
929         struct domainlist *domains;
930         uint32_t resume_handle;
931         uint32_t count;
932
933         void (*monitor_fn)(struct monitor_msg*);
934 };
935
936
937 static void continue_rpc_connect(struct composite_context *c);
938 static void continue_samr_connect(struct rpc_request *c);
939 static void continue_samr_enum_domains(struct rpc_request *req);
940 static void continue_samr_close_handle(struct rpc_request *req);
941
942 static struct domainlist* get_domain_list(TALLOC_CTX *mem_ctx, struct domain_list_state *s);
943
944
945 /*
946   Stage 1: Receive connected rpc pipe and send connection
947   request to SAMR service
948 */
949 static void continue_rpc_connect(struct composite_context *ctx)
950 {
951         struct composite_context *c;
952         struct domain_list_state *s;
953         struct rpc_request *samrconn_req;
954
955         c = talloc_get_type(ctx->async.private_data, struct composite_context);
956         s = talloc_get_type(c->private_data, struct domain_list_state);
957         
958         c->status = libnet_RpcConnect_recv(ctx, s->ctx, c, &s->rpcconn);
959         if (!composite_is_ok(c)) return;
960
961         s->samrconn.in.system_name     = 0;
962         s->samrconn.in.access_mask     = SEC_GENERIC_READ;     /* should be enough */
963         s->samrconn.out.connect_handle = &s->connect_handle;
964
965         samrconn_req = dcerpc_samr_Connect_send(s->ctx->samr.pipe, c, &s->samrconn);
966         if (composite_nomem(samrconn_req, c)) return;
967
968         composite_continue_rpc(c, samrconn_req, continue_samr_connect, c);
969 }
970
971
972 /*
973   Stage 2: Receive policy handle to the connected SAMR service and issue
974   a request to enumerate domain databases available
975 */
976 static void continue_samr_connect(struct rpc_request *req)
977 {
978         struct composite_context *c;
979         struct domain_list_state *s;
980         struct rpc_request *enumdom_req;
981
982         c = talloc_get_type(req->async.private_data, struct composite_context);
983         s = talloc_get_type(c->private_data, struct domain_list_state);
984         
985         c->status = dcerpc_ndr_request_recv(req);
986         if (!composite_is_ok(c)) return;
987
988         if (s->monitor_fn) {
989                 struct monitor_msg msg;
990                 
991                 msg.type      = mon_SamrConnect;
992                 msg.data      = NULL;
993                 msg.data_size = 0;
994                 s->monitor_fn(&msg);
995         }
996
997         s->enumdom.in.connect_handle = &s->connect_handle;
998         s->enumdom.in.resume_handle  = &s->resume_handle;
999         s->enumdom.in.buf_size       = s->buf_size;
1000         s->enumdom.out.resume_handle = &s->resume_handle;
1001
1002         enumdom_req = dcerpc_samr_EnumDomains_send(s->ctx->samr.pipe, c, &s->enumdom);
1003         if (composite_nomem(enumdom_req, c)) return;
1004
1005         composite_continue_rpc(c, enumdom_req, continue_samr_enum_domains, c);
1006 }
1007
1008
1009 /*
1010   Stage 3: Receive domain names available and repeat the request
1011   enumeration is not complete yet. Close samr connection handle
1012   upon completion.
1013 */
1014 static void continue_samr_enum_domains(struct rpc_request *req)
1015 {
1016         struct composite_context *c;
1017         struct domain_list_state *s;
1018         struct rpc_request *enumdom_req;
1019         struct rpc_request *samrclose_req;
1020
1021         c = talloc_get_type(req->async.private_data, struct composite_context);
1022         s = talloc_get_type(c->private_data, struct domain_list_state);
1023         
1024         c->status = dcerpc_ndr_request_recv(req);
1025         if (!composite_is_ok(c)) return;
1026
1027         if (s->monitor_fn) {
1028                 struct monitor_msg msg;
1029                 
1030                 msg.type      = mon_SamrEnumDomains;
1031                 msg.data      = NULL;
1032                 msg.data_size = 0;
1033                 s->monitor_fn(&msg);
1034         }
1035
1036         if (NT_STATUS_IS_OK(s->enumdom.out.result)) {
1037
1038                 s->domains = get_domain_list(c, s);
1039
1040         } else if (NT_STATUS_EQUAL(s->enumdom.out.result, STATUS_MORE_ENTRIES)) {
1041                 
1042                 s->domains = get_domain_list(c, s);
1043                 
1044                 /* prepare next round of enumeration */
1045                 s->enumdom.in.connect_handle = &s->connect_handle;
1046                 s->enumdom.in.resume_handle  = &s->resume_handle;
1047                 s->enumdom.in.buf_size       = s->ctx->samr.buf_size;
1048                 s->enumdom.out.resume_handle = &s->resume_handle;
1049
1050                 /* send the request */
1051                 enumdom_req = dcerpc_samr_EnumDomains_send(s->ctx->samr.pipe, c, &s->enumdom);
1052                 if (composite_nomem(enumdom_req, c)) return;
1053
1054                 composite_continue_rpc(c, enumdom_req, continue_samr_enum_domains, c);
1055
1056         } else {
1057                 composite_error(c, s->enumdom.out.result);
1058                 return;
1059         }
1060
1061         /* close samr connection handle */
1062         s->samrclose.in.handle  = &s->connect_handle;
1063         s->samrclose.out.handle = &s->connect_handle;
1064         
1065         /* send the request */
1066         samrclose_req = dcerpc_samr_Close_send(s->ctx->samr.pipe, c, &s->samrclose);
1067         if (composite_nomem(samrclose_req, c)) return;
1068
1069         composite_continue_rpc(c, samrclose_req, continue_samr_close_handle, c);
1070 }
1071
1072
1073 /*
1074   Stage 4: Receive result of closing samr connection handle.
1075 */
1076 static void continue_samr_close_handle(struct rpc_request *req)
1077 {
1078         struct composite_context *c;
1079         struct domain_list_state *s;
1080
1081         c = talloc_get_type(req->async.private_data, struct composite_context);
1082         s = talloc_get_type(c->private_data, struct domain_list_state);
1083
1084         c->status = dcerpc_ndr_request_recv(req);
1085         if (!composite_is_ok(c)) return;
1086
1087         if (s->monitor_fn) {
1088                 struct monitor_msg msg;
1089                 
1090                 msg.type      = mon_SamrClose;
1091                 msg.data      = NULL;
1092                 msg.data_size = 0;
1093                 s->monitor_fn(&msg);
1094         }
1095
1096         /* did everything go fine ? */
1097         if (!NT_STATUS_IS_OK(s->samrclose.out.result)) {
1098                 composite_error(c, s->samrclose.out.result);
1099         }
1100
1101         composite_done(c);
1102 }
1103
1104
1105 /*
1106   Utility function to copy domain names from result of samr_EnumDomains call
1107 */
1108 static struct domainlist* get_domain_list(TALLOC_CTX *mem_ctx, struct domain_list_state *s)
1109 {
1110         int i;
1111         if (mem_ctx == NULL || s == NULL) return NULL;
1112
1113         /* prepare domains array */
1114         if (s->domains == NULL) {
1115                 s->domains = talloc_array(mem_ctx, struct domainlist,
1116                                           s->enumdom.out.num_entries);
1117         } else {
1118                 s->domains = talloc_realloc(mem_ctx, s->domains, struct domainlist,
1119                                             s->count + s->enumdom.out.num_entries);
1120         }
1121
1122         /* copy domain names returned from samr_EnumDomains call */
1123         for (i = s->count; i < s->count + s->enumdom.out.num_entries; i++)
1124         {
1125                 struct lsa_String *domain_name = &s->enumdom.out.sam->entries[i - s->count].name;
1126
1127                 /* strdup name as a child of allocated array to make it follow the array
1128                    in case of talloc_steal or talloc_free */
1129                 s->domains[i].name = talloc_strdup(s->domains, domain_name->string);
1130                 s->domains[i].sid  = NULL;  /* this is to be filled out later */
1131         }
1132
1133         /* number of entries returned (domains enumerated) */
1134         s->count += s->enumdom.out.num_entries;
1135         
1136         return s->domains;
1137 }
1138
1139
1140 /**
1141  * Sends a request to list domains on given host
1142  *
1143  * @param ctx initalised libnet context
1144  * @param mem_ctx memory context
1145  * @param io arguments and results of the call
1146  * @param monitor pointer to monitor function that is passed monitor messages
1147  */
1148
1149 struct composite_context* libnet_DomainList_send(struct libnet_context *ctx,
1150                                                  TALLOC_CTX *mem_ctx,
1151                                                  struct libnet_DomainList *io,
1152                                                  void (*monitor)(struct monitor_msg*))
1153 {
1154         struct composite_context *c;
1155         struct domain_list_state *s;
1156         struct composite_context *rpcconn_req;
1157         struct rpc_request *samrconn_req;
1158
1159         /* composite context and state structure allocation */
1160         c = composite_create(ctx, ctx->event_ctx);
1161         if (c == NULL) return c;
1162
1163         s = talloc_zero(c, struct domain_list_state);
1164         if (composite_nomem(s, c)) return c;
1165
1166         c->private_data = s;
1167         s->monitor_fn   = monitor;
1168
1169         s->ctx      = ctx;
1170         s->hostname = talloc_strdup(c, io->in.hostname);
1171         if (composite_nomem(s->hostname, c)) return c;
1172
1173         /* check whether samr pipe has already been opened */
1174         if (ctx->samr.pipe == NULL) {
1175                 /* prepare rpc connect call */
1176                 s->rpcconn.level           = LIBNET_RPC_CONNECT_SERVER;
1177                 s->rpcconn.in.name         = s->hostname;
1178                 s->rpcconn.in.dcerpc_iface = &ndr_table_samr;
1179
1180                 rpcconn_req = libnet_RpcConnect_send(ctx, c, &s->rpcconn, s->monitor_fn);
1181                 if (composite_nomem(rpcconn_req, c)) return c;
1182                 
1183                 composite_continue(c, rpcconn_req, continue_rpc_connect, c);
1184
1185         } else {
1186                 /* prepare samr_Connect call */
1187                 s->samrconn.in.system_name     = 0;
1188                 s->samrconn.in.access_mask     = SEC_GENERIC_READ;
1189                 s->samrconn.out.connect_handle = &s->connect_handle;
1190                 
1191                 samrconn_req = dcerpc_samr_Connect_send(s->ctx->samr.pipe, c, &s->samrconn);
1192                 if (composite_nomem(samrconn_req, c)) return c;
1193
1194                 composite_continue_rpc(c, samrconn_req, continue_samr_connect, c);
1195         }
1196
1197         return c;
1198 }
1199
1200
1201 /**
1202  * Receive result of domain list request
1203  *
1204  * @param c composite context returned by DomainList_send function
1205  * @param ctx initialised libnet context
1206  * @param mem_ctx memory context of the call
1207  * @param io results and arguments of the call
1208  */
1209
1210 NTSTATUS libnet_DomainList_recv(struct composite_context *c, struct libnet_context *ctx,
1211                                 TALLOC_CTX *mem_ctx, struct libnet_DomainList *io)
1212 {
1213         NTSTATUS status;
1214         struct domain_list_state *s;
1215
1216         status = composite_wait(c);
1217
1218         s = talloc_get_type(c->private_data, struct domain_list_state);
1219
1220         if (NT_STATUS_IS_OK(status) && ctx && mem_ctx && io) {
1221                 /* fetch the results to be returned by io structure */
1222                 io->out.count        = s->count;
1223                 io->out.domains      = talloc_steal(mem_ctx, s->domains);
1224                 io->out.error_string = talloc_asprintf(mem_ctx, "Success");
1225
1226         } else if (!NT_STATUS_IS_OK(status)) {
1227                 /* there was an error, so return description of the status code */
1228                 io->out.error_string = talloc_asprintf(mem_ctx, "Error: %s", nt_errstr(status));
1229         }
1230
1231         talloc_free(c);
1232         return status;
1233 }
1234
1235
1236 /**
1237  * Synchronous version of DomainList call
1238  *
1239  * @param ctx initialised libnet context
1240  * @param mem_ctx memory context for the call
1241  * @param io arguments and results of the call
1242  * @return nt status code of execution
1243  */
1244
1245 NTSTATUS libnet_DomainList(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
1246                            struct libnet_DomainList *io)
1247 {
1248         struct composite_context *c;
1249
1250         c = libnet_DomainList_send(ctx, mem_ctx, io, NULL);
1251         return libnet_DomainList_recv(c, ctx, mem_ctx, io);
1252 }