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