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