2 Unix SMB/CIFS implementation.
4 Copyright (C) Rafal Szczesniak 2005
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.
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.
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/>.
22 #include "libnet/libnet.h"
23 #include "libcli/composite/composite.h"
24 #include "auth/credentials/credentials.h"
25 #include "librpc/ndr/libndr.h"
26 #include "librpc/gen_ndr/samr.h"
27 #include "librpc/gen_ndr/ndr_samr_c.h"
28 #include "librpc/gen_ndr/lsa.h"
29 #include "librpc/gen_ndr/ndr_lsa_c.h"
30 #include "libcli/security/security.h"
33 struct create_user_state {
34 struct libnet_CreateUser r;
35 struct libnet_DomainOpen domain_open;
36 struct libnet_rpc_useradd user_add;
37 struct libnet_context *ctx;
39 /* information about the progress */
40 void (*monitor_fn)(struct monitor_msg *);
44 static void continue_rpc_useradd(struct composite_context *ctx);
45 static void continue_domain_open_create(struct composite_context *ctx);
49 * Sends request to create user account
51 * @param ctx initialised libnet context
52 * @param mem_ctx memory context of this call
53 * @param r pointer to a structure containing arguments and results of this call
54 * @param monitor function pointer for receiving monitor messages
55 * @return compostite context of this request
57 struct composite_context* libnet_CreateUser_send(struct libnet_context *ctx,
59 struct libnet_CreateUser *r,
60 void (*monitor)(struct monitor_msg*))
62 struct composite_context *c;
63 struct create_user_state *s;
64 struct composite_context *create_req;
65 bool prereq_met = false;
67 /* composite context allocation and setup */
68 c = composite_create(mem_ctx, ctx->event_ctx);
69 if (c == NULL) return NULL;
71 s = talloc_zero(c, struct create_user_state);
72 if (composite_nomem(s, c)) return c;
76 /* store arguments in the state structure */
79 ZERO_STRUCT(s->r.out);
81 /* prerequisite: make sure the domain is opened */
82 prereq_met = samr_domain_opened(ctx, s->r.in.domain_name, &c, &s->domain_open,
83 continue_domain_open_create, monitor);
84 if (!prereq_met) return c;
86 /* prepare arguments for useradd call */
87 s->user_add.in.username = r->in.user_name;
88 s->user_add.in.domain_handle = ctx->samr.handle;
90 /* send the request */
91 create_req = libnet_rpc_useradd_send(ctx->samr.pipe, &s->user_add, monitor);
92 if (composite_nomem(create_req, c)) return c;
94 /* set the next stage */
95 composite_continue(c, create_req, continue_rpc_useradd, c);
101 * Stage 0.5 (optional): receive result of domain open request
102 * and send useradd request
104 static void continue_domain_open_create(struct composite_context *ctx)
106 struct composite_context *c;
107 struct create_user_state *s;
108 struct composite_context *create_req;
109 struct monitor_msg msg;
111 c = talloc_get_type(ctx->async.private_data, struct composite_context);
112 s = talloc_get_type(c->private_data, struct create_user_state);
114 /* receive result of DomainOpen call */
115 c->status = libnet_DomainOpen_recv(ctx, s->ctx, c, &s->domain_open);
116 if (!composite_is_ok(c)) return;
118 /* send monitor message */
119 if (s->monitor_fn) s->monitor_fn(&msg);
121 /* prepare arguments for useradd call */
122 s->user_add.in.username = s->r.in.user_name;
123 s->user_add.in.domain_handle = s->ctx->samr.handle;
125 /* send the request */
126 create_req = libnet_rpc_useradd_send(s->ctx->samr.pipe, &s->user_add, s->monitor_fn);
127 if (composite_nomem(create_req, c)) return;
129 /* set the next stage */
130 composite_continue(c, create_req, continue_rpc_useradd, c);
135 * Stage 1: receive result of useradd call
137 static void continue_rpc_useradd(struct composite_context *ctx)
139 struct composite_context *c;
140 struct create_user_state *s;
141 struct monitor_msg msg;
143 c = talloc_get_type(ctx->async.private_data, struct composite_context);
144 s = talloc_get_type(c->private_data, struct create_user_state);
146 /* receive result of the call */
147 c->status = libnet_rpc_useradd_recv(ctx, c, &s->user_add);
148 if (!composite_is_ok(c)) return;
150 /* send monitor message */
151 if (s->monitor_fn) s->monitor_fn(&msg);
159 * Receive result of CreateUser call
161 * @param c composite context returned by send request routine
162 * @param mem_ctx memory context of this call
163 * @param r pointer to a structure containing arguments and result of this call
166 NTSTATUS libnet_CreateUser_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
167 struct libnet_CreateUser *r)
170 struct create_user_state *s;
172 r->out.error_string = NULL;
174 /* wait for result of async request and check status code */
175 status = composite_wait(c);
176 if (!NT_STATUS_IS_OK(status)) {
177 s = talloc_get_type(c->private_data, struct create_user_state);
178 r->out.error_string = talloc_strdup(mem_ctx, nt_errstr(status));
186 * Synchronous version of CreateUser call
188 * @param ctx initialised libnet context
189 * @param mem_ctx memory context of this call
190 * @param r pointer to a structure containing arguments and result of this call
193 NTSTATUS libnet_CreateUser(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
194 struct libnet_CreateUser *r)
196 struct composite_context *c;
198 c = libnet_CreateUser_send(ctx, mem_ctx, r, NULL);
199 return libnet_CreateUser_recv(c, mem_ctx, r);
203 struct delete_user_state {
204 struct libnet_DeleteUser r;
205 struct libnet_context *ctx;
206 struct libnet_DomainOpen domain_open;
207 struct libnet_rpc_userdel user_del;
209 /* information about the progress */
210 void (*monitor_fn)(struct monitor_msg *);
214 static void continue_rpc_userdel(struct composite_context *ctx);
215 static void continue_domain_open_delete(struct composite_context *ctx);
219 * Sends request to delete user account
221 * @param ctx initialised libnet context
222 * @param mem_ctx memory context of this call
223 * @param r pointer to structure containing arguments and result of this call
224 * @param monitor function pointer for receiving monitor messages
226 struct composite_context *libnet_DeleteUser_send(struct libnet_context *ctx,
228 struct libnet_DeleteUser *r,
229 void (*monitor)(struct monitor_msg*))
231 struct composite_context *c;
232 struct delete_user_state *s;
233 struct composite_context *delete_req;
234 bool prereq_met = false;
236 /* composite context allocation and setup */
237 c = composite_create(mem_ctx, ctx->event_ctx);
238 if (c == NULL) return NULL;
240 s = talloc_zero(c, struct delete_user_state);
241 if (composite_nomem(s, c)) return c;
245 /* store arguments in state structure */
248 ZERO_STRUCT(s->r.out);
250 /* prerequisite: make sure the domain is opened before proceeding */
251 prereq_met = samr_domain_opened(ctx, s->r.in.domain_name, &c, &s->domain_open,
252 continue_domain_open_delete, monitor);
253 if (!prereq_met) return c;
255 /* prepare arguments for userdel call */
256 s->user_del.in.username = r->in.user_name;
257 s->user_del.in.domain_handle = ctx->samr.handle;
260 delete_req = libnet_rpc_userdel_send(ctx->samr.pipe, &s->user_del, monitor);
261 if (composite_nomem(delete_req, c)) return c;
263 /* set the next stage */
264 composite_continue(c, delete_req, continue_rpc_userdel, c);
270 * Stage 0.5 (optional): receive result of domain open request
271 * and send useradd request
273 static void continue_domain_open_delete(struct composite_context *ctx)
275 struct composite_context *c;
276 struct delete_user_state *s;
277 struct composite_context *delete_req;
278 struct monitor_msg msg;
280 c = talloc_get_type(ctx->async.private_data, struct composite_context);
281 s = talloc_get_type(c->private_data, struct delete_user_state);
283 /* receive result of DomainOpen call */
284 c->status = libnet_DomainOpen_recv(ctx, s->ctx, c, &s->domain_open);
285 if (!composite_is_ok(c)) return;
287 /* send monitor message */
288 if (s->monitor_fn) s->monitor_fn(&msg);
290 /* prepare arguments for userdel call */
291 s->user_del.in.username = s->r.in.user_name;
292 s->user_del.in.domain_handle = s->ctx->samr.handle;
295 delete_req = libnet_rpc_userdel_send(s->ctx->samr.pipe, &s->user_del, s->monitor_fn);
296 if (composite_nomem(delete_req, c)) return;
298 /* set the next stage */
299 composite_continue(c, delete_req, continue_rpc_userdel, c);
304 * Stage 1: receive result of userdel call and finish the composite function
306 static void continue_rpc_userdel(struct composite_context *ctx)
308 struct composite_context *c;
309 struct delete_user_state *s;
310 struct monitor_msg msg;
312 c = talloc_get_type(ctx->async.private_data, struct composite_context);
313 s = talloc_get_type(c->private_data, struct delete_user_state);
315 /* receive result of userdel call */
316 c->status = libnet_rpc_userdel_recv(ctx, c, &s->user_del);
317 if (!composite_is_ok(c)) return;
319 /* send monitor message */
320 if (s->monitor_fn) s->monitor_fn(&msg);
328 * Receives result of asynchronous DeleteUser call
330 * @param c composite context returned by async DeleteUser call
331 * @param mem_ctx memory context of this call
332 * @param r pointer to structure containing arguments and result
334 NTSTATUS libnet_DeleteUser_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
335 struct libnet_DeleteUser *r)
338 struct delete_user_state *s;
340 r->out.error_string = NULL;
342 /* wait for result of async request and check status code */
343 status = composite_wait(c);
344 if (!NT_STATUS_IS_OK(status)) {
345 s = talloc_get_type(c->private_data, struct delete_user_state);
346 r->out.error_string = talloc_steal(mem_ctx, s->r.out.error_string);
354 * Synchronous version of DeleteUser call
356 * @param ctx initialised libnet context
357 * @param mem_ctx memory context of this call
358 * @param r pointer to structure containing arguments and result
360 NTSTATUS libnet_DeleteUser(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
361 struct libnet_DeleteUser *r)
363 struct composite_context *c;
365 c = libnet_DeleteUser_send(ctx, mem_ctx, r, NULL);
366 return libnet_DeleteUser_recv(c, mem_ctx, r);
370 struct modify_user_state {
371 struct libnet_ModifyUser r;
372 struct libnet_context *ctx;
373 struct libnet_DomainOpen domain_open;
374 struct libnet_rpc_userinfo user_info;
375 struct libnet_rpc_usermod user_mod;
377 void (*monitor_fn)(struct monitor_msg *);
381 static void continue_rpc_usermod(struct composite_context *ctx);
382 static void continue_domain_open_modify(struct composite_context *ctx);
383 static NTSTATUS set_user_changes(TALLOC_CTX *mem_ctx, struct usermod_change *mod,
384 struct libnet_rpc_userinfo *info, struct libnet_ModifyUser *r);
385 static void continue_rpc_userinfo(struct composite_context *ctx);
389 * Sends request to modify user account
391 * @param ctx initialised libnet context
392 * @param mem_ctx memory context of this call
393 * @param r pointer to structure containing arguments and result of this call
394 * @param monitor function pointer for receiving monitor messages
396 struct composite_context *libnet_ModifyUser_send(struct libnet_context *ctx,
398 struct libnet_ModifyUser *r,
399 void (*monitor)(struct monitor_msg*))
401 const uint16_t level = 21;
402 struct composite_context *c;
403 struct modify_user_state *s;
404 struct composite_context *userinfo_req;
405 bool prereq_met = false;
407 c = composite_create(mem_ctx, ctx->event_ctx);
408 if (c == NULL) return NULL;
410 s = talloc_zero(c, struct modify_user_state);
411 if (composite_nomem(s, c)) return c;
418 prereq_met = samr_domain_opened(ctx, s->r.in.domain_name, &c, &s->domain_open,
419 continue_domain_open_modify, monitor);
420 if (!prereq_met) return c;
422 s->user_info.in.username = r->in.user_name;
423 s->user_info.in.domain_handle = ctx->samr.handle;
424 s->user_info.in.level = level;
426 userinfo_req = libnet_rpc_userinfo_send(ctx->samr.pipe, &s->user_info, monitor);
427 if (composite_nomem(userinfo_req, c)) return c;
429 composite_continue(c, userinfo_req, continue_rpc_userinfo, c);
435 * Stage 0.5 (optional): receive result of domain open request
436 * and send userinfo request
438 static void continue_domain_open_modify(struct composite_context *ctx)
440 const uint16_t level = 21;
441 struct composite_context *c;
442 struct modify_user_state *s;
443 struct composite_context *userinfo_req;
444 struct monitor_msg msg;
446 c = talloc_get_type(ctx->async.private_data, struct composite_context);
447 s = talloc_get_type(c->private_data, struct modify_user_state);
449 c->status = libnet_DomainOpen_recv(ctx, s->ctx, c, &s->domain_open);
450 if (!composite_is_ok(c)) return;
452 if (s->monitor_fn) s->monitor_fn(&msg);
454 s->user_info.in.domain_handle = s->ctx->samr.handle;
455 s->user_info.in.username = s->r.in.user_name;
456 s->user_info.in.level = level;
458 userinfo_req = libnet_rpc_userinfo_send(s->ctx->samr.pipe, &s->user_info, s->monitor_fn);
459 if (composite_nomem(userinfo_req, c)) return;
461 composite_continue(c, userinfo_req, continue_rpc_userinfo, c);
466 * Stage 1: receive result of userinfo call, prepare user changes
467 * (set the fields a caller required to change) and send usermod request
469 static void continue_rpc_userinfo(struct composite_context *ctx)
471 struct composite_context *c;
472 struct modify_user_state *s;
473 struct composite_context *usermod_req;
475 c = talloc_get_type(ctx->async.private_data, struct composite_context);
476 s = talloc_get_type(c->private_data, struct modify_user_state);
478 c->status = libnet_rpc_userinfo_recv(ctx, c, &s->user_info);
479 if (!composite_is_ok(c)) return;
481 s->user_mod.in.domain_handle = s->ctx->samr.handle;
482 s->user_mod.in.username = s->r.in.user_name;
484 c->status = set_user_changes(c, &s->user_mod.in.change, &s->user_info, &s->r);
486 usermod_req = libnet_rpc_usermod_send(s->ctx->samr.pipe, &s->user_mod, s->monitor_fn);
487 if (composite_nomem(usermod_req, c)) return;
489 composite_continue(c, usermod_req, continue_rpc_usermod, c);
494 * Prepare user changes: compare userinfo result to requested changes and
495 * set the field values and flags accordingly for user modify call
497 static NTSTATUS set_user_changes(TALLOC_CTX *mem_ctx, struct usermod_change *mod,
498 struct libnet_rpc_userinfo *info, struct libnet_ModifyUser *r)
500 struct samr_UserInfo21 *user;
502 if (mod == NULL || info == NULL || r == NULL || info->in.level != 21) {
503 return NT_STATUS_INVALID_PARAMETER;
506 user = &info->out.info.info21;
507 mod->fields = 0; /* reset flag field before setting individual flags */
509 /* account name change */
510 SET_FIELD_LSA_STRING(r->in, user, mod, account_name, USERMOD_FIELD_ACCOUNT_NAME);
512 /* full name change */
513 SET_FIELD_LSA_STRING(r->in, user, mod, full_name, USERMOD_FIELD_FULL_NAME);
515 /* description change */
516 SET_FIELD_LSA_STRING(r->in, user, mod, description, USERMOD_FIELD_DESCRIPTION);
519 SET_FIELD_LSA_STRING(r->in, user, mod, comment, USERMOD_FIELD_COMMENT);
521 /* home directory change */
522 SET_FIELD_LSA_STRING(r->in, user, mod, home_directory, USERMOD_FIELD_HOME_DIRECTORY);
524 /* home drive change */
525 SET_FIELD_LSA_STRING(r->in, user, mod, home_drive, USERMOD_FIELD_HOME_DRIVE);
527 /* logon script change */
528 SET_FIELD_LSA_STRING(r->in, user, mod, logon_script, USERMOD_FIELD_LOGON_SCRIPT);
530 /* profile path change */
531 SET_FIELD_LSA_STRING(r->in, user, mod, profile_path, USERMOD_FIELD_PROFILE_PATH);
533 /* account expiry change */
534 SET_FIELD_NTTIME(r->in, user, mod, acct_expiry, USERMOD_FIELD_ACCT_EXPIRY);
536 /* account flags change */
537 SET_FIELD_UINT32(r->in, user, mod, acct_flags, USERMOD_FIELD_ACCT_FLAGS);
544 * Stage 2: receive result of usermod request and finish the composite function
546 static void continue_rpc_usermod(struct composite_context *ctx)
548 struct composite_context *c;
549 struct modify_user_state *s;
550 struct monitor_msg msg;
552 c = talloc_get_type(ctx->async.private_data, struct composite_context);
553 s = talloc_get_type(c->private_data, struct modify_user_state);
555 c->status = libnet_rpc_usermod_recv(ctx, c, &s->user_mod);
556 if (!composite_is_ok(c)) return;
558 if (s->monitor_fn) s->monitor_fn(&msg);
564 * Receive result of ModifyUser call
566 * @param c composite context returned by send request routine
567 * @param mem_ctx memory context of this call
568 * @param r pointer to a structure containing arguments and result of this call
571 NTSTATUS libnet_ModifyUser_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
572 struct libnet_ModifyUser *r)
574 NTSTATUS status = composite_wait(c);
580 * Synchronous version of ModifyUser call
582 * @param ctx initialised libnet context
583 * @param mem_ctx memory context of this call
584 * @param r pointer to a structure containing arguments and result of this call
587 NTSTATUS libnet_ModifyUser(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
588 struct libnet_ModifyUser *r)
590 struct composite_context *c;
592 c = libnet_ModifyUser_send(ctx, mem_ctx, r, NULL);
593 return libnet_ModifyUser_recv(c, mem_ctx, r);
597 struct user_info_state {
598 struct libnet_context *ctx;
599 const char *domain_name;
600 const char *user_name;
601 struct libnet_LookupName lookup;
602 struct libnet_DomainOpen domopen;
603 struct libnet_rpc_userinfo userinfo;
605 /* information about the progress */
606 void (*monitor_fn)(struct monitor_msg *);
610 static void continue_name_found(struct composite_context *ctx);
611 static void continue_domain_open_info(struct composite_context *ctx);
612 static void continue_info_received(struct composite_context *ctx);
616 * Sends request to get user account information
618 * @param ctx initialised libnet context
619 * @param mem_ctx memory context of this call
620 * @param r pointer to a structure containing arguments and results of this call
621 * @param monitor function pointer for receiving monitor messages
622 * @return compostite context of this request
624 struct composite_context* libnet_UserInfo_send(struct libnet_context *ctx,
626 struct libnet_UserInfo *r,
627 void (*monitor)(struct monitor_msg*))
629 struct composite_context *c;
630 struct user_info_state *s;
631 struct composite_context *lookup_req;
632 bool prereq_met = false;
634 /* composite context allocation and setup */
635 c = composite_create(mem_ctx, ctx->event_ctx);
636 if (c == NULL) return NULL;
638 s = talloc_zero(c, struct user_info_state);
639 if (composite_nomem(s, c)) return c;
643 /* store arguments in the state structure */
644 s->monitor_fn = monitor;
646 s->domain_name = talloc_strdup(c, r->in.domain_name);
647 s->user_name = talloc_strdup(c, r->in.user_name);
649 /* prerequisite: make sure the domain is opened */
650 prereq_met = samr_domain_opened(ctx, s->domain_name, &c, &s->domopen,
651 continue_domain_open_info, monitor);
652 if (!prereq_met) return c;
654 /* prepare arguments for LookupName call */
655 s->lookup.in.domain_name = s->domain_name;
656 s->lookup.in.name = s->user_name;
658 /* send the request */
659 lookup_req = libnet_LookupName_send(ctx, c, &s->lookup, s->monitor_fn);
660 if (composite_nomem(lookup_req, c)) return c;
662 /* set the next stage */
663 composite_continue(c, lookup_req, continue_name_found, c);
669 * Stage 0.5 (optional): receive result of domain open request
670 * and send LookupName request
672 static void continue_domain_open_info(struct composite_context *ctx)
674 struct composite_context *c;
675 struct user_info_state *s;
676 struct composite_context *lookup_req;
677 struct monitor_msg msg;
679 c = talloc_get_type(ctx->async.private_data, struct composite_context);
680 s = talloc_get_type(c->private_data, struct user_info_state);
682 /* receive result of DomainOpen call */
683 c->status = libnet_DomainOpen_recv(ctx, s->ctx, c, &s->domopen);
684 if (!composite_is_ok(c)) return;
686 /* send monitor message */
687 if (s->monitor_fn) s->monitor_fn(&msg);
689 /* prepare arguments for LookupName call */
690 s->lookup.in.domain_name = s->domain_name;
691 s->lookup.in.name = s->user_name;
693 /* send the request */
694 lookup_req = libnet_LookupName_send(s->ctx, c, &s->lookup, s->monitor_fn);
695 if (composite_nomem(lookup_req, c)) return;
697 /* set the next stage */
698 composite_continue(c, lookup_req, continue_name_found, c);
703 * Stage 1: receive the name (if found) and send userinfo request
705 static void continue_name_found(struct composite_context *ctx)
707 struct composite_context *c;
708 struct user_info_state *s;
709 struct composite_context *info_req;
711 c = talloc_get_type(ctx->async.private_data, struct composite_context);
712 s = talloc_get_type(c->private_data, struct user_info_state);
714 /* receive result of LookupName call */
715 c->status = libnet_LookupName_recv(ctx, c, &s->lookup);
716 if (!composite_is_ok(c)) return;
718 /* we're only interested in user accounts this time */
719 if (s->lookup.out.sid_type != SID_NAME_USER) {
720 composite_error(c, NT_STATUS_NO_SUCH_USER);
724 /* prepare arguments for UserInfo call */
725 s->userinfo.in.domain_handle = s->ctx->samr.handle;
726 s->userinfo.in.sid = s->lookup.out.sidstr;
727 s->userinfo.in.level = 21;
729 /* send the request */
730 info_req = libnet_rpc_userinfo_send(s->ctx->samr.pipe, &s->userinfo, s->monitor_fn);
731 if (composite_nomem(info_req, c)) return;
733 /* set the next stage */
734 composite_continue(c, info_req, continue_info_received, c);
739 * Stage 2: receive user account information and finish the composite function
741 static void continue_info_received(struct composite_context *ctx)
743 struct composite_context *c;
744 struct user_info_state *s;
746 c = talloc_get_type(ctx->async.private_data, struct composite_context);
747 s = talloc_get_type(c->private_data, struct user_info_state);
749 /* receive result of userinfo call */
750 c->status = libnet_rpc_userinfo_recv(ctx, c, &s->userinfo);
751 if (!composite_is_ok(c)) return;
758 * Receive result of UserInfo call
760 * @param c composite context returned by send request routine
761 * @param mem_ctx memory context of this call
762 * @param r pointer to a structure containing arguments and result of this call
765 NTSTATUS libnet_UserInfo_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
766 struct libnet_UserInfo *r)
769 struct user_info_state *s;
771 status = composite_wait(c);
773 if (NT_STATUS_IS_OK(status) && r != NULL) {
774 struct samr_UserInfo21 *info;
776 s = talloc_get_type(c->private_data, struct user_info_state);
777 info = &s->userinfo.out.info.info21;
779 r->out.user_sid = dom_sid_add_rid(mem_ctx, s->ctx->samr.sid, info->rid);
780 r->out.primary_group_sid = dom_sid_add_rid(mem_ctx, s->ctx->samr.sid, info->primary_gid);
783 r->out.account_name = talloc_steal(mem_ctx, info->account_name.string);
784 r->out.full_name = talloc_steal(mem_ctx, info->full_name.string);
785 r->out.description = talloc_steal(mem_ctx, info->description.string);
786 r->out.home_directory = talloc_steal(mem_ctx, info->home_directory.string);
787 r->out.home_drive = talloc_steal(mem_ctx, info->home_drive.string);
788 r->out.comment = talloc_steal(mem_ctx, info->comment.string);
789 r->out.logon_script = talloc_steal(mem_ctx, info->logon_script.string);
790 r->out.profile_path = talloc_steal(mem_ctx, info->profile_path.string);
792 /* time fields (allocation) */
793 r->out.acct_expiry = talloc(mem_ctx, struct timeval);
794 r->out.allow_password_change = talloc(mem_ctx, struct timeval);
795 r->out.force_password_change = talloc(mem_ctx, struct timeval);
796 r->out.last_logon = talloc(mem_ctx, struct timeval);
797 r->out.last_logoff = talloc(mem_ctx, struct timeval);
798 r->out.last_password_change = talloc(mem_ctx, struct timeval);
800 /* time fields (converting) */
801 nttime_to_timeval(r->out.acct_expiry, info->acct_expiry);
802 nttime_to_timeval(r->out.allow_password_change, info->allow_password_change);
803 nttime_to_timeval(r->out.force_password_change, info->force_password_change);
804 nttime_to_timeval(r->out.last_logon, info->last_logon);
805 nttime_to_timeval(r->out.last_logoff, info->last_logoff);
806 nttime_to_timeval(r->out.last_password_change, info->last_password_change);
808 /* flag and number fields */
809 r->out.acct_flags = info->acct_flags;
811 r->out.error_string = talloc_strdup(mem_ctx, "Success");
814 r->out.error_string = talloc_asprintf(mem_ctx, "Error: %s", nt_errstr(status));
824 * Synchronous version of UserInfo call
826 * @param ctx initialised libnet context
827 * @param mem_ctx memory context of this call
828 * @param r pointer to a structure containing arguments and result of this call
831 NTSTATUS libnet_UserInfo(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
832 struct libnet_UserInfo *r)
834 struct composite_context *c;
836 c = libnet_UserInfo_send(ctx, mem_ctx, r, NULL);
837 return libnet_UserInfo_recv(c, mem_ctx, r);
841 struct userlist_state {
842 struct libnet_context *ctx;
843 const char *domain_name;
844 struct lsa_DomainInfo dominfo;
846 uint32_t resume_index;
847 struct userlist *users;
850 struct libnet_DomainOpen domain_open;
851 struct lsa_QueryInfoPolicy query_domain;
852 struct samr_EnumDomainUsers user_list;
854 void (*monitor_fn)(struct monitor_msg*);
858 static void continue_lsa_domain_opened(struct composite_context *ctx);
859 static void continue_domain_queried(struct rpc_request *req);
860 static void continue_samr_domain_opened(struct composite_context *ctx);
861 static void continue_users_enumerated(struct rpc_request *req);
865 * Sends request to list (enumerate) user accounts
867 * @param ctx initialised libnet context
868 * @param mem_ctx memory context of this call
869 * @param r pointer to a structure containing arguments and results of this call
870 * @param monitor function pointer for receiving monitor messages
871 * @return compostite context of this request
873 struct composite_context* libnet_UserList_send(struct libnet_context *ctx,
875 struct libnet_UserList *r,
876 void (*monitor)(struct monitor_msg*))
878 struct composite_context *c;
879 struct userlist_state *s;
880 struct rpc_request *query_req;
881 bool prereq_met = false;
883 /* composite context allocation and setup */
884 c = composite_create(mem_ctx, ctx->event_ctx);
885 if (c == NULL) return NULL;
887 s = talloc_zero(c, struct userlist_state);
888 if (composite_nomem(s, c)) return c;
892 /* store the arguments in the state structure */
894 s->page_size = r->in.page_size;
895 s->resume_index = (uint32_t)r->in.resume_index;
896 s->domain_name = talloc_strdup(c, r->in.domain_name);
897 s->monitor_fn = monitor;
899 /* make sure we have lsa domain handle before doing anything */
900 prereq_met = lsa_domain_opened(ctx, s->domain_name, &c, &s->domain_open,
901 continue_lsa_domain_opened, monitor);
902 if (!prereq_met) return c;
904 /* prepare arguments of QueryDomainInfo call */
905 s->query_domain.in.handle = &ctx->lsa.handle;
906 s->query_domain.in.level = LSA_POLICY_INFO_DOMAIN;
908 /* send the request */
909 query_req = dcerpc_lsa_QueryInfoPolicy_send(ctx->lsa.pipe, c, &s->query_domain);
910 if (composite_nomem(query_req, c)) return c;
912 composite_continue_rpc(c, query_req, continue_domain_queried, c);
918 * Stage 0.5 (optional): receive lsa domain handle and send
919 * request to query domain info
921 static void continue_lsa_domain_opened(struct composite_context *ctx)
923 struct composite_context *c;
924 struct userlist_state *s;
925 struct rpc_request *query_req;
927 c = talloc_get_type(ctx->async.private_data, struct composite_context);
928 s = talloc_get_type(c->private_data, struct userlist_state);
930 /* receive lsa domain handle */
931 c->status = libnet_DomainOpen_recv(ctx, s->ctx, c, &s->domain_open);
932 if (!composite_is_ok(c)) return;
934 /* prepare arguments of QueryDomainInfo call */
935 s->query_domain.in.handle = &s->ctx->lsa.handle;
936 s->query_domain.in.level = LSA_POLICY_INFO_DOMAIN;
938 /* send the request */
939 query_req = dcerpc_lsa_QueryInfoPolicy_send(s->ctx->lsa.pipe, c, &s->query_domain);
940 if (composite_nomem(query_req, c)) return;
942 composite_continue_rpc(c, query_req, continue_domain_queried, c);
947 * Stage 1: receive domain info and request to enum users,
948 * provided a valid samr handle is opened
950 static void continue_domain_queried(struct rpc_request *req)
952 struct composite_context *c;
953 struct userlist_state *s;
954 struct rpc_request *enum_req;
955 bool prereq_met = false;
957 c = talloc_get_type(req->async.private_data, struct composite_context);
958 s = talloc_get_type(c->private_data, struct userlist_state);
960 /* receive result of rpc request */
961 c->status = dcerpc_ndr_request_recv(req);
962 if (!composite_is_ok(c)) return;
964 /* get the returned domain info */
965 s->dominfo = s->query_domain.out.info->domain;
967 /* make sure we have samr domain handle before continuing */
968 prereq_met = samr_domain_opened(s->ctx, s->domain_name, &c, &s->domain_open,
969 continue_samr_domain_opened, s->monitor_fn);
970 if (!prereq_met) return;
972 /* prepare arguments od EnumDomainUsers call */
973 s->user_list.in.domain_handle = &s->ctx->samr.handle;
974 s->user_list.in.max_size = s->page_size;
975 s->user_list.in.resume_handle = &s->resume_index;
976 s->user_list.in.acct_flags = ACB_NORMAL;
977 s->user_list.out.resume_handle = &s->resume_index;
979 /* send the request */
980 enum_req = dcerpc_samr_EnumDomainUsers_send(s->ctx->samr.pipe, c, &s->user_list);
981 if (composite_nomem(enum_req, c)) return;
983 composite_continue_rpc(c, enum_req, continue_users_enumerated, c);
988 * Stage 1.5 (optional): receive samr domain handle
989 * and request to enumerate accounts
991 static void continue_samr_domain_opened(struct composite_context *ctx)
993 struct composite_context *c;
994 struct userlist_state *s;
995 struct rpc_request *enum_req;
997 c = talloc_get_type(ctx->async.private_data, struct composite_context);
998 s = talloc_get_type(c->private_data, struct userlist_state);
1000 /* receive samr domain handle */
1001 c->status = libnet_DomainOpen_recv(ctx, s->ctx, c, &s->domain_open);
1002 if (!composite_is_ok(c)) return;
1004 /* prepare arguments od EnumDomainUsers call */
1005 s->user_list.in.domain_handle = &s->ctx->samr.handle;
1006 s->user_list.in.max_size = s->page_size;
1007 s->user_list.in.resume_handle = &s->resume_index;
1008 s->user_list.in.acct_flags = ACB_NORMAL;
1009 s->user_list.out.resume_handle = &s->resume_index;
1011 /* send the request */
1012 enum_req = dcerpc_samr_EnumDomainUsers_send(s->ctx->samr.pipe, c, &s->user_list);
1013 if (composite_nomem(enum_req, c)) return;
1015 composite_continue_rpc(c, enum_req, continue_users_enumerated, c);
1020 * Stage 2: receive enumerated users and their rids
1022 static void continue_users_enumerated(struct rpc_request *req)
1024 struct composite_context *c;
1025 struct userlist_state *s;
1028 c = talloc_get_type(req->async.private_data, struct composite_context);
1029 s = talloc_get_type(c->private_data, struct userlist_state);
1031 /* receive result of rpc request */
1032 c->status = dcerpc_ndr_request_recv(req);
1033 if (!composite_is_ok(c)) return;
1035 /* get the actual status of the rpc call result (instead of rpc layer status) */
1036 c->status = s->user_list.out.result;
1038 /* we're interested in status "ok" as well as two enum-specific status codes */
1039 if (NT_STATUS_IS_OK(c->status) ||
1040 NT_STATUS_EQUAL(c->status, STATUS_MORE_ENTRIES) ||
1041 NT_STATUS_EQUAL(c->status, NT_STATUS_NO_MORE_ENTRIES)) {
1043 /* get enumerated accounts counter and resume handle (the latter allows
1044 making subsequent call to continue enumeration) */
1045 s->resume_index = *s->user_list.out.resume_handle;
1046 s->count = s->user_list.out.num_entries;
1048 /* prepare returned user accounts array */
1049 s->users = talloc_array(c, struct userlist, s->user_list.out.sam->count);
1050 if (composite_nomem(s->users, c)) return;
1052 for (i = 0; i < s->user_list.out.sam->count; i++) {
1053 struct dom_sid *user_sid;
1054 struct samr_SamEntry *entry = &s->user_list.out.sam->entries[i];
1055 struct dom_sid *domain_sid = s->query_domain.out.info->domain.sid;
1057 /* construct user sid from returned rid and queried domain sid */
1058 user_sid = dom_sid_add_rid(c, domain_sid, entry->idx);
1059 if (composite_nomem(user_sid, c)) return;
1062 s->users[i].username = talloc_strdup(c, entry->name.string);
1063 if (composite_nomem(s->users[i].username, c)) return;
1066 s->users[i].sid = dom_sid_string(c, user_sid);
1067 if (composite_nomem(s->users[i].sid, c)) return;
1074 /* something went wrong */
1075 composite_error(c, c->status);
1081 * Receive result of UserList call
1083 * @param c composite context returned by send request routine
1084 * @param mem_ctx memory context of this call
1085 * @param r pointer to a structure containing arguments and result of this call
1088 NTSTATUS libnet_UserList_recv(struct composite_context* c, TALLOC_CTX *mem_ctx,
1089 struct libnet_UserList *r)
1092 struct userlist_state *s;
1094 if (c == NULL || mem_ctx == NULL || r == NULL) {
1095 return NT_STATUS_INVALID_PARAMETER;
1098 status = composite_wait(c);
1099 if (NT_STATUS_IS_OK(status) ||
1100 NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES) ||
1101 NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES)) {
1103 s = talloc_get_type(c->private_data, struct userlist_state);
1105 /* get results from composite context */
1106 r->out.count = s->count;
1107 r->out.resume_index = s->resume_index;
1108 r->out.users = talloc_steal(mem_ctx, s->users);
1110 if (NT_STATUS_IS_OK(status)) {
1111 r->out.error_string = talloc_strdup(mem_ctx, "Success");
1113 /* success, but we're not done yet */
1114 r->out.error_string = talloc_asprintf(mem_ctx, "Success (status: %s)",
1119 r->out.error_string = talloc_asprintf(mem_ctx, "Error: %s", nt_errstr(status));
1127 * Synchronous version of UserList call
1129 * @param ctx initialised libnet context
1130 * @param mem_ctx memory context of this call
1131 * @param r pointer to a structure containing arguments and result of this call
1134 NTSTATUS libnet_UserList(struct libnet_context *ctx,
1135 TALLOC_CTX *mem_ctx,
1136 struct libnet_UserList *r)
1138 struct composite_context *c;
1140 c = libnet_UserList_send(ctx, mem_ctx, r, NULL);
1141 return libnet_UserList_recv(c, mem_ctx, r);