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