source4/libnet/libnet_user.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 #include "includes.h"
  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"
  31
  32
  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;
  38
  39         /* information about the progress */
  40         void (*monitor_fn)(struct monitor_msg *);
  41 };
  42
  43
  44 static void continue_rpc_useradd(struct composite_context *ctx);
  45 static void continue_domain_open_create(struct composite_context *ctx);
  46
  47
  48 /**
  49  * Sends request to create user account
  50  *
  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
  56  */
  57 struct composite_context* libnet_CreateUser_send(struct libnet_context *ctx,
  58                                                  TALLOC_CTX *mem_ctx,
  59                                                  struct libnet_CreateUser *r,
  60                                                  void (*monitor)(struct monitor_msg*))
  61 {
  62         struct composite_context *c;
  63         struct create_user_state *s;
  64         struct composite_context *create_req;
  65         bool prereq_met = false;
  66
  67         /* composite context allocation and setup */
  68         c = composite_create(mem_ctx, ctx->event_ctx);
  69         if (c == NULL) return NULL;
  70
  71         s = talloc_zero(c, struct create_user_state);
  72         if (composite_nomem(s, c)) return c;
  73
  74         c->private_data = s;
  75
  76         /* store arguments in the state structure */
  77         s->ctx = ctx;
  78         s->r   = *r;
  79         ZERO_STRUCT(s->r.out);
  80
  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;
  85
  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;
  89
  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;
  93
  94         /* set the next stage */
  95         composite_continue(c, create_req, continue_rpc_useradd, c);
  96         return c;
  97 }
  98
  99
 100 /*
 101  * Stage 0.5 (optional): receive result of domain open request
 102  * and send useradd request
 103  */
 104 static void continue_domain_open_create(struct composite_context *ctx)
 105 {
 106         struct composite_context *c;
 107         struct create_user_state *s;
 108         struct composite_context *create_req;
 109         struct monitor_msg msg;
 110
 111         c = talloc_get_type_abort(ctx->async.private_data, struct composite_context);
 112         s = talloc_get_type_abort(c->private_data, struct create_user_state);
 113
 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;
 117
 118         /* send monitor message */
 119         if (s->monitor_fn) s->monitor_fn(&msg);
 120
 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;
 124
 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;
 128
 129         /* set the next stage */
 130         composite_continue(c, create_req, continue_rpc_useradd, c);
 131 }
 132
 133
 134 /*
 135  * Stage 1: receive result of useradd call
 136  */
 137 static void continue_rpc_useradd(struct composite_context *ctx)
 138 {
 139         struct composite_context *c;
 140         struct create_user_state *s;
 141         struct monitor_msg msg;
 142
 143         c = talloc_get_type_abort(ctx->async.private_data, struct composite_context);
 144         s = talloc_get_type_abort(c->private_data, struct create_user_state);
 145
 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;
 149
 150         /* send monitor message */
 151         if (s->monitor_fn) s->monitor_fn(&msg);
 152
 153         /* we're done */
 154         composite_done(c);
 155 }
 156
 157
 158 /**
 159  * Receive result of CreateUser call
 160  *
 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
 164  * @return nt status
 165  */
 166 NTSTATUS libnet_CreateUser_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
 167                                 struct libnet_CreateUser *r)
 168 {
 169         NTSTATUS status;
 170
 171         r->out.error_string = NULL;
 172
 173         /* wait for result of async request and check status code */
 174         status = composite_wait(c);
 175         if (!NT_STATUS_IS_OK(status)) {
 176                 r->out.error_string = talloc_strdup(mem_ctx, nt_errstr(status));
 177         }
 178
 179         talloc_free(c);
 180         return status;
 181 }
 182
 183
 184 /**
 185  * Synchronous version of CreateUser call
 186  *
 187  * @param ctx initialised libnet context
 188  * @param mem_ctx memory context of this call
 189  * @param r pointer to a structure containing arguments and result of this call
 190  * @return nt status
 191  */
 192 NTSTATUS libnet_CreateUser(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
 193                            struct libnet_CreateUser *r)
 194 {
 195         struct composite_context *c;
 196
 197         c = libnet_CreateUser_send(ctx, mem_ctx, r, NULL);
 198         return libnet_CreateUser_recv(c, mem_ctx, r);
 199 }
 200
 201
 202 struct delete_user_state {
 203         struct libnet_DeleteUser r;
 204         struct libnet_context *ctx;
 205         struct libnet_DomainOpen domain_open;
 206         struct libnet_rpc_userdel user_del;
 207
 208         /* information about the progress */
 209         void (*monitor_fn)(struct monitor_msg *);
 210 };
 211
 212
 213 static void continue_rpc_userdel(struct composite_context *ctx);
 214 static void continue_domain_open_delete(struct composite_context *ctx);
 215
 216
 217 /**
 218  * Sends request to delete user account
 219  *
 220  * @param ctx initialised libnet context
 221  * @param mem_ctx memory context of this call
 222  * @param r pointer to structure containing arguments and result of this call
 223  * @param monitor function pointer for receiving monitor messages
 224  */
 225 struct composite_context *libnet_DeleteUser_send(struct libnet_context *ctx,
 226                                                  TALLOC_CTX *mem_ctx,
 227                                                  struct libnet_DeleteUser *r,
 228                                                  void (*monitor)(struct monitor_msg*))
 229 {
 230         struct composite_context *c;
 231         struct delete_user_state *s;
 232         struct composite_context *delete_req;
 233         bool prereq_met = false;
 234
 235         /* composite context allocation and setup */
 236         c = composite_create(mem_ctx, ctx->event_ctx);
 237         if (c == NULL) return NULL;
 238
 239         s = talloc_zero(c, struct delete_user_state);
 240         if (composite_nomem(s, c)) return c;
 241
 242         c->private_data = s;
 243
 244         /* store arguments in state structure */
 245         s->ctx = ctx;
 246         s->r   = *r;
 247         ZERO_STRUCT(s->r.out);
 248
 249         /* prerequisite: make sure the domain is opened before proceeding */
 250         prereq_met = samr_domain_opened(ctx, s->r.in.domain_name, &c, &s->domain_open,
 251                                         continue_domain_open_delete, monitor);
 252         if (!prereq_met) return c;
 253
 254         /* prepare arguments for userdel call */
 255         s->user_del.in.username       = r->in.user_name;
 256         s->user_del.in.domain_handle  = ctx->samr.handle;
 257
 258         /* send request */
 259         delete_req = libnet_rpc_userdel_send(ctx->samr.pipe, &s->user_del, monitor);
 260         if (composite_nomem(delete_req, c)) return c;
 261
 262         /* set the next stage */
 263         composite_continue(c, delete_req, continue_rpc_userdel, c);
 264         return c;
 265 }
 266
 267
 268 /*
 269  * Stage 0.5 (optional): receive result of domain open request
 270  * and send useradd request
 271  */
 272 static void continue_domain_open_delete(struct composite_context *ctx)
 273 {
 274         struct composite_context *c;
 275         struct delete_user_state *s;
 276         struct composite_context *delete_req;
 277         struct monitor_msg msg;
 278
 279         c = talloc_get_type_abort(ctx->async.private_data, struct composite_context);
 280         s = talloc_get_type_abort(c->private_data, struct delete_user_state);
 281
 282         /* receive result of DomainOpen call */
 283         c->status = libnet_DomainOpen_recv(ctx, s->ctx, c, &s->domain_open);
 284         if (!composite_is_ok(c)) return;
 285
 286         /* send monitor message */
 287         if (s->monitor_fn) s->monitor_fn(&msg);
 288
 289         /* prepare arguments for userdel call */
 290         s->user_del.in.username       = s->r.in.user_name;
 291         s->user_del.in.domain_handle  = s->ctx->samr.handle;
 292
 293         /* send request */
 294         delete_req = libnet_rpc_userdel_send(s->ctx->samr.pipe, &s->user_del, s->monitor_fn);
 295         if (composite_nomem(delete_req, c)) return;
 296
 297         /* set the next stage */
 298         composite_continue(c, delete_req, continue_rpc_userdel, c);
 299 }
 300
 301
 302 /*
 303  * Stage 1: receive result of userdel call and finish the composite function
 304  */
 305 static void continue_rpc_userdel(struct composite_context *ctx)
 306 {
 307         struct composite_context *c;
 308         struct delete_user_state *s;
 309         struct monitor_msg msg;
 310
 311         c = talloc_get_type_abort(ctx->async.private_data, struct composite_context);
 312         s = talloc_get_type_abort(c->private_data, struct delete_user_state);
 313
 314         /* receive result of userdel call */
 315         c->status = libnet_rpc_userdel_recv(ctx, c, &s->user_del);
 316         if (!composite_is_ok(c)) return;
 317
 318         /* send monitor message */
 319         if (s->monitor_fn) s->monitor_fn(&msg);
 320
 321         /* we're done */
 322         composite_done(c);
 323 }
 324
 325
 326 /**
 327  * Receives result of asynchronous DeleteUser call
 328  *
 329  * @param c composite context returned by async DeleteUser call
 330  * @param mem_ctx memory context of this call
 331  * @param r pointer to structure containing arguments and result
 332  */
 333 NTSTATUS libnet_DeleteUser_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
 334                                 struct libnet_DeleteUser *r)
 335 {
 336         NTSTATUS status;
 337         struct delete_user_state *s;
 338
 339         r->out.error_string = NULL;
 340
 341         /* wait for result of async request and check status code */
 342         status = composite_wait(c);
 343         if (!NT_STATUS_IS_OK(status)) {
 344                 s = talloc_get_type_abort(c->private_data, struct delete_user_state);
 345                 r->out.error_string = talloc_steal(mem_ctx, s->r.out.error_string);
 346         }
 347
 348         talloc_free(c);
 349         return status;
 350 }
 351
 352
 353 /**
 354  * Synchronous version of DeleteUser call
 355  *
 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
 359  */
 360 NTSTATUS libnet_DeleteUser(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
 361                            struct libnet_DeleteUser *r)
 362 {
 363         struct composite_context *c;
 364
 365         c = libnet_DeleteUser_send(ctx, mem_ctx, r, NULL);
 366         return libnet_DeleteUser_recv(c, mem_ctx, r);
 367 }
 368
 369
 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;
 376
 377         void (*monitor_fn)(struct monitor_msg *);
 378 };
 379
 380
 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);
 386
 387
 388 /**
 389  * Sends request to modify user account
 390  *
 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
 395  */
 396 struct composite_context *libnet_ModifyUser_send(struct libnet_context *ctx,
 397                                                  TALLOC_CTX *mem_ctx,
 398                                                  struct libnet_ModifyUser *r,
 399                                                  void (*monitor)(struct monitor_msg*))
 400 {
 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;
 406
 407         c = composite_create(mem_ctx, ctx->event_ctx);
 408         if (c == NULL) return NULL;
 409
 410         s = talloc_zero(c, struct modify_user_state);
 411         if (composite_nomem(s, c)) return c;
 412
 413         c->private_data = s;
 414
 415         s->ctx = ctx;
 416         s->r = *r;
 417
 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;
 421
 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;
 425
 426         userinfo_req = libnet_rpc_userinfo_send(ctx->samr.pipe, &s->user_info, monitor);
 427         if (composite_nomem(userinfo_req, c)) return c;
 428
 429         composite_continue(c, userinfo_req, continue_rpc_userinfo, c);
 430         return c;
 431 }
 432
 433
 434 /*
 435  * Stage 0.5 (optional): receive result of domain open request
 436  * and send userinfo request
 437  */
 438 static void continue_domain_open_modify(struct composite_context *ctx)
 439 {
 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;
 445
 446         c = talloc_get_type_abort(ctx->async.private_data, struct composite_context);
 447         s = talloc_get_type_abort(c->private_data, struct modify_user_state);
 448
 449         c->status = libnet_DomainOpen_recv(ctx, s->ctx, c, &s->domain_open);
 450         if (!composite_is_ok(c)) return;
 451
 452         if (s->monitor_fn) s->monitor_fn(&msg);
 453
 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;
 457
 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;
 460
 461         composite_continue(c, userinfo_req, continue_rpc_userinfo, c);
 462 }
 463
 464
 465 /*
 466  * Stage 1: receive result of userinfo call, prepare user changes
 467  * (set the fields a caller required to change) and send usermod request
 468  */
 469 static void continue_rpc_userinfo(struct composite_context *ctx)
 470 {
 471         struct composite_context *c;
 472         struct modify_user_state *s;
 473         struct composite_context *usermod_req;
 474
 475         c = talloc_get_type_abort(ctx->async.private_data, struct composite_context);
 476         s = talloc_get_type_abort(c->private_data, struct modify_user_state);
 477
 478         c->status = libnet_rpc_userinfo_recv(ctx, c, &s->user_info);
 479         if (!composite_is_ok(c)) return;
 480
 481         s->user_mod.in.domain_handle = s->ctx->samr.handle;
 482         s->user_mod.in.username      = s->r.in.user_name;
 483
 484         c->status = set_user_changes(c, &s->user_mod.in.change, &s->user_info, &s->r);
 485
 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;
 488
 489         composite_continue(c, usermod_req, continue_rpc_usermod, c);
 490 }
 491
 492
 493 /*
 494  * Prepare user changes: compare userinfo result to requested changes and
 495  * set the field values and flags accordingly for user modify call
 496  */
 497 static NTSTATUS set_user_changes(TALLOC_CTX *mem_ctx, struct usermod_change *mod,
 498                                  struct libnet_rpc_userinfo *info, struct libnet_ModifyUser *r)
 499 {
 500         struct samr_UserInfo21 *user;
 501
 502         if (mod == NULL || info == NULL || r == NULL || info->in.level != 21) {
 503                 return NT_STATUS_INVALID_PARAMETER;
 504         }
 505
 506         user = &info->out.info.info21;
 507         mod->fields = 0;        /* reset flag field before setting individual flags */
 508
 509         /* account name change */
 510         SET_FIELD_LSA_STRING(r->in, user, mod, account_name, USERMOD_FIELD_ACCOUNT_NAME);
 511
 512         /* full name change */
 513         SET_FIELD_LSA_STRING(r->in, user, mod, full_name, USERMOD_FIELD_FULL_NAME);
 514
 515         /* description change */
 516         SET_FIELD_LSA_STRING(r->in, user, mod, description, USERMOD_FIELD_DESCRIPTION);
 517
 518         /* comment change */
 519         SET_FIELD_LSA_STRING(r->in, user, mod, comment, USERMOD_FIELD_COMMENT);
 520
 521         /* home directory change */
 522         SET_FIELD_LSA_STRING(r->in, user, mod, home_directory, USERMOD_FIELD_HOME_DIRECTORY);
 523
 524         /* home drive change */
 525         SET_FIELD_LSA_STRING(r->in, user, mod, home_drive, USERMOD_FIELD_HOME_DRIVE);
 526
 527         /* logon script change */
 528         SET_FIELD_LSA_STRING(r->in, user, mod, logon_script, USERMOD_FIELD_LOGON_SCRIPT);
 529
 530         /* profile path change */
 531         SET_FIELD_LSA_STRING(r->in, user, mod, profile_path, USERMOD_FIELD_PROFILE_PATH);
 532
 533         /* account expiry change */
 534         SET_FIELD_NTTIME(r->in, user, mod, acct_expiry, USERMOD_FIELD_ACCT_EXPIRY);
 535
 536         /* account flags change */
 537         SET_FIELD_ACCT_FLAGS(r->in, user, mod, acct_flags, USERMOD_FIELD_ACCT_FLAGS);
 538
 539         return NT_STATUS_OK;
 540 }
 541
 542
 543 /*
 544  * Stage 2: receive result of usermod request and finish the composite function
 545  */
 546 static void continue_rpc_usermod(struct composite_context *ctx)
 547 {
 548         struct composite_context *c;
 549         struct modify_user_state *s;
 550         struct monitor_msg msg;
 551
 552         c = talloc_get_type_abort(ctx->async.private_data, struct composite_context);
 553         s = talloc_get_type_abort(c->private_data, struct modify_user_state);
 554
 555         c->status = libnet_rpc_usermod_recv(ctx, c, &s->user_mod);
 556         if (!composite_is_ok(c)) return;
 557
 558         if (s->monitor_fn) s->monitor_fn(&msg);
 559         composite_done(c);
 560 }
 561
 562
 563 /**
 564  * Receive result of ModifyUser call
 565  *
 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
 569  * @return nt status
 570  */
 571 NTSTATUS libnet_ModifyUser_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
 572                                 struct libnet_ModifyUser *r)
 573 {
 574         NTSTATUS status = composite_wait(c);
 575
 576         talloc_free(c);
 577         return status;
 578 }
 579
 580
 581 /**
 582  * Synchronous version of ModifyUser call
 583  *
 584  * @param ctx initialised libnet context
 585  * @param mem_ctx memory context of this call
 586  * @param r pointer to a structure containing arguments and result of this call
 587  * @return nt status
 588  */
 589 NTSTATUS libnet_ModifyUser(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
 590                            struct libnet_ModifyUser *r)
 591 {
 592         struct composite_context *c;
 593
 594         c = libnet_ModifyUser_send(ctx, mem_ctx, r, NULL);
 595         return libnet_ModifyUser_recv(c, mem_ctx, r);
 596 }
 597
 598
 599 struct user_info_state {
 600         struct libnet_context *ctx;
 601         const char *domain_name;
 602         enum libnet_UserInfo_level level;
 603         const char *user_name;
 604         const char *sid_string;
 605         struct libnet_LookupName lookup;
 606         struct libnet_DomainOpen domopen;
 607         struct libnet_rpc_userinfo userinfo;
 608
 609         /* information about the progress */
 610         void (*monitor_fn)(struct monitor_msg *);
 611 };
 612
 613
 614 static void continue_name_found(struct composite_context *ctx);
 615 static void continue_domain_open_info(struct composite_context *ctx);
 616 static void continue_info_received(struct composite_context *ctx);
 617
 618
 619 /**
 620  * Sends request to get user account information
 621  *
 622  * @param ctx initialised libnet context
 623  * @param mem_ctx memory context of this call
 624  * @param r pointer to a structure containing arguments and results of this call
 625  * @param monitor function pointer for receiving monitor messages
 626  * @return compostite context of this request
 627  */
 628 struct composite_context* libnet_UserInfo_send(struct libnet_context *ctx,
 629                                                TALLOC_CTX *mem_ctx,
 630                                                struct libnet_UserInfo *r,
 631                                                void (*monitor)(struct monitor_msg*))
 632 {
 633         struct composite_context *c;
 634         struct user_info_state *s;
 635         struct composite_context *lookup_req, *info_req;
 636         bool prereq_met = false;
 637
 638         /* composite context allocation and setup */
 639         c = composite_create(mem_ctx, ctx->event_ctx);
 640         if (c == NULL) return NULL;
 641
 642         s = talloc_zero(c, struct user_info_state);
 643         if (composite_nomem(s, c)) return c;
 644
 645         c->private_data = s;
 646
 647         /* store arguments in the state structure */
 648         s->monitor_fn = monitor;
 649         s->ctx = ctx;
 650         s->domain_name = talloc_strdup(c, r->in.domain_name);
 651         s->level = r->in.level;
 652         switch (s->level) {
 653         case USER_INFO_BY_NAME:
 654                 s->user_name = talloc_strdup(c, r->in.data.user_name);
 655                 s->sid_string = NULL;
 656                 break;
 657         case USER_INFO_BY_SID:
 658                 s->user_name = NULL;
 659                 s->sid_string = dom_sid_string(c, r->in.data.user_sid);
 660                 break;
 661         }
 662
 663         /* prerequisite: make sure the domain is opened */
 664         prereq_met = samr_domain_opened(ctx, s->domain_name, &c, &s->domopen,
 665                                         continue_domain_open_info, monitor);
 666         if (!prereq_met) return c;
 667
 668         switch (s->level) {
 669         case USER_INFO_BY_NAME:
 670                 /* prepare arguments for LookupName call */
 671                 s->lookup.in.domain_name = s->domain_name;
 672                 s->lookup.in.name        = s->user_name;
 673
 674                 /* send the request */
 675                 lookup_req = libnet_LookupName_send(ctx, c, &s->lookup,
 676                                                     s->monitor_fn);
 677                 if (composite_nomem(lookup_req, c)) return c;
 678
 679                 /* set the next stage */
 680                 composite_continue(c, lookup_req, continue_name_found, c);
 681                 break;
 682         case USER_INFO_BY_SID:
 683                 /* prepare arguments for UserInfo call */
 684                 s->userinfo.in.domain_handle = s->ctx->samr.handle;
 685                 s->userinfo.in.sid = s->sid_string;
 686                 s->userinfo.in.level = 21;
 687
 688                 /* send the request */
 689                 info_req = libnet_rpc_userinfo_send(s->ctx->samr.pipe,
 690                                                     &s->userinfo,
 691                                                     s->monitor_fn);
 692                 if (composite_nomem(info_req, c)) return c;
 693
 694                 /* set the next stage */
 695                 composite_continue(c, info_req, continue_info_received, c);
 696                 break;
 697         }
 698
 699         return c;
 700 }
 701
 702
 703 /*
 704  * Stage 0.5 (optional): receive result of domain open request
 705  * and send LookupName request
 706  */
 707 static void continue_domain_open_info(struct composite_context *ctx)
 708 {
 709         struct composite_context *c;
 710         struct user_info_state *s;
 711         struct composite_context *lookup_req, *info_req;
 712         struct monitor_msg msg;
 713
 714         c = talloc_get_type_abort(ctx->async.private_data, struct composite_context);
 715         s = talloc_get_type_abort(c->private_data, struct user_info_state);
 716
 717         /* receive result of DomainOpen call */
 718         c->status = libnet_DomainOpen_recv(ctx, s->ctx, c, &s->domopen);
 719         if (!composite_is_ok(c)) return;
 720
 721         /* send monitor message */
 722         if (s->monitor_fn) s->monitor_fn(&msg);
 723
 724         switch (s->level) {
 725         case USER_INFO_BY_NAME:
 726                 /* prepare arguments for LookupName call */
 727                 s->lookup.in.domain_name = s->domain_name;
 728                 s->lookup.in.name        = s->user_name;
 729
 730                 /* send the request */
 731                 lookup_req = libnet_LookupName_send(s->ctx, c, &s->lookup, s->monitor_fn);
 732                 if (composite_nomem(lookup_req, c)) return;
 733
 734                 /* set the next stage */
 735                 composite_continue(c, lookup_req, continue_name_found, c);
 736                 break;
 737
 738         case USER_INFO_BY_SID:
 739                 /* prepare arguments for UserInfo call */
 740                 s->userinfo.in.domain_handle = s->ctx->samr.handle;
 741                 s->userinfo.in.sid = s->sid_string;
 742                 s->userinfo.in.level = 21;
 743
 744                 /* send the request */
 745                 info_req = libnet_rpc_userinfo_send(s->ctx->samr.pipe,
 746                                                     &s->userinfo,
 747                                                     s->monitor_fn);
 748                 if (composite_nomem(info_req, c)) return;
 749
 750                 /* set the next stage */
 751                 composite_continue(c, info_req, continue_info_received, c);
 752                 break;
 753         }
 754 }
 755
 756
 757 /*
 758  * Stage 1: receive the name (if found) and send userinfo request
 759  */
 760 static void continue_name_found(struct composite_context *ctx)
 761 {
 762         struct composite_context *c;
 763         struct user_info_state *s;
 764         struct composite_context *info_req;
 765
 766         c = talloc_get_type_abort(ctx->async.private_data, struct composite_context);
 767         s = talloc_get_type_abort(c->private_data, struct user_info_state);
 768
 769         /* receive result of LookupName call */
 770         c->status = libnet_LookupName_recv(ctx, c, &s->lookup);
 771         if (!composite_is_ok(c)) return;
 772
 773         /* we're only interested in user accounts this time */
 774         if (s->lookup.out.sid_type != SID_NAME_USER) {
 775                 composite_error(c, NT_STATUS_NO_SUCH_USER);
 776                 return;
 777         }
 778
 779         /* prepare arguments for UserInfo call */
 780         s->userinfo.in.domain_handle = s->ctx->samr.handle;
 781         s->userinfo.in.sid = s->lookup.out.sidstr;
 782         s->userinfo.in.level = 21;
 783
 784         /* send the request */
 785         info_req = libnet_rpc_userinfo_send(s->ctx->samr.pipe, &s->userinfo, s->monitor_fn);
 786         if (composite_nomem(info_req, c)) return;
 787
 788         /* set the next stage */
 789         composite_continue(c, info_req, continue_info_received, c);
 790 }
 791
 792
 793 /*
 794  * Stage 2: receive user account information and finish the composite function
 795  */
 796 static void continue_info_received(struct composite_context *ctx)
 797 {
 798         struct composite_context *c;
 799         struct user_info_state *s;
 800
 801         c = talloc_get_type_abort(ctx->async.private_data, struct composite_context);
 802         s = talloc_get_type_abort(c->private_data, struct user_info_state);
 803
 804         /* receive result of userinfo call */
 805         c->status = libnet_rpc_userinfo_recv(ctx, c, &s->userinfo);
 806         if (!composite_is_ok(c)) return;
 807
 808         composite_done(c);
 809 }
 810
 811
 812 /**
 813  * Receive result of UserInfo call
 814  *
 815  * @param c composite context returned by send request routine
 816  * @param mem_ctx memory context of this call
 817  * @param r pointer to a structure containing arguments and result of this call
 818  * @return nt status
 819  */
 820 NTSTATUS libnet_UserInfo_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
 821                               struct libnet_UserInfo *r)
 822 {
 823         NTSTATUS status;
 824         struct user_info_state *s;
 825
 826         status = composite_wait(c);
 827
 828         if (NT_STATUS_IS_OK(status) && r != NULL) {
 829                 struct samr_UserInfo21 *info;
 830
 831                 s = talloc_get_type_abort(c->private_data, struct user_info_state);
 832                 info = &s->userinfo.out.info.info21;
 833
 834                 r->out.user_sid = dom_sid_add_rid(mem_ctx, s->ctx->samr.sid, info->rid);
 835                 r->out.primary_group_sid = dom_sid_add_rid(mem_ctx, s->ctx->samr.sid, info->primary_gid);
 836
 837                 /* string fields */
 838                 r->out.account_name   = talloc_steal(mem_ctx, info->account_name.string);
 839                 r->out.full_name      = talloc_steal(mem_ctx, info->full_name.string);
 840                 r->out.description    = talloc_steal(mem_ctx, info->description.string);
 841                 r->out.home_directory = talloc_steal(mem_ctx, info->home_directory.string);
 842                 r->out.home_drive     = talloc_steal(mem_ctx, info->home_drive.string);
 843                 r->out.comment        = talloc_steal(mem_ctx, info->comment.string);
 844                 r->out.logon_script   = talloc_steal(mem_ctx, info->logon_script.string);
 845                 r->out.profile_path   = talloc_steal(mem_ctx, info->profile_path.string);
 846
 847                 /* time fields (allocation) */
 848                 r->out.acct_expiry           = talloc(mem_ctx, struct timeval);
 849                 r->out.allow_password_change = talloc(mem_ctx, struct timeval);
 850                 r->out.force_password_change = talloc(mem_ctx, struct timeval);
 851                 r->out.last_logon            = talloc(mem_ctx, struct timeval);
 852                 r->out.last_logoff           = talloc(mem_ctx, struct timeval);
 853                 r->out.last_password_change  = talloc(mem_ctx, struct timeval);
 854
 855                 /* time fields (converting) */
 856                 nttime_to_timeval(r->out.acct_expiry, info->acct_expiry);
 857                 nttime_to_timeval(r->out.allow_password_change, info->allow_password_change);
 858                 nttime_to_timeval(r->out.force_password_change, info->force_password_change);
 859                 nttime_to_timeval(r->out.last_logon, info->last_logon);
 860                 nttime_to_timeval(r->out.last_logoff, info->last_logoff);
 861                 nttime_to_timeval(r->out.last_password_change, info->last_password_change);
 862
 863                 /* flag and number fields */
 864                 r->out.acct_flags = info->acct_flags;
 865
 866                 r->out.error_string = talloc_strdup(mem_ctx, "Success");
 867
 868         } else {
 869                 r->out.error_string = talloc_asprintf(mem_ctx, "Error: %s", nt_errstr(status));
 870         }
 871
 872         talloc_free(c);
 873         return status;
 874 }
 875
 876
 877 /**
 878  * Synchronous version of UserInfo call
 879  *
 880  * @param ctx initialised libnet context
 881  * @param mem_ctx memory context of this call
 882  * @param r pointer to a structure containing arguments and result of this call
 883  * @return nt status
 884  */
 885 NTSTATUS libnet_UserInfo(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
 886                          struct libnet_UserInfo *r)
 887 {
 888         struct composite_context *c;
 889
 890         c = libnet_UserInfo_send(ctx, mem_ctx, r, NULL);
 891         return libnet_UserInfo_recv(c, mem_ctx, r);
 892 }
 893
 894
 895 struct userlist_state {
 896         struct libnet_context *ctx;
 897         const char *domain_name;
 898         struct lsa_DomainInfo dominfo;
 899         int page_size;
 900         uint32_t resume_index;
 901         struct userlist *users;
 902         uint32_t count;
 903
 904         struct libnet_DomainOpen domain_open;
 905         struct lsa_QueryInfoPolicy query_domain;
 906         struct samr_EnumDomainUsers user_list;
 907
 908         void (*monitor_fn)(struct monitor_msg*);
 909 };
 910
 911
 912 static void continue_lsa_domain_opened(struct composite_context *ctx);
 913 static void continue_domain_queried(struct tevent_req *subreq);
 914 static void continue_samr_domain_opened(struct composite_context *ctx);
 915 static void continue_users_enumerated(struct tevent_req *subreq);
 916
 917
 918 /**
 919  * Sends request to list (enumerate) user accounts
 920  *
 921  * @param ctx initialised libnet context
 922  * @param mem_ctx memory context of this call
 923  * @param r pointer to structure containing arguments and results of this call
 924  * @param monitor function pointer for receiving monitor messages
 925  * @return compostite context of this request
 926  */
 927 struct composite_context* libnet_UserList_send(struct libnet_context *ctx,
 928                                                TALLOC_CTX *mem_ctx,
 929                                                struct libnet_UserList *r,
 930                                                void (*monitor)(struct monitor_msg*))
 931 {
 932         struct composite_context *c;
 933         struct userlist_state *s;
 934         struct tevent_req *subreq;
 935         bool prereq_met = false;
 936
 937         /* composite context allocation and setup */
 938         c = composite_create(mem_ctx, ctx->event_ctx);
 939         if (c == NULL) return NULL;
 940
 941         s = talloc_zero(c, struct userlist_state);
 942         if (composite_nomem(s, c)) return c;
 943
 944         c->private_data = s;
 945
 946         /* store the arguments in the state structure */
 947         s->ctx          = ctx;
 948         s->page_size    = r->in.page_size;
 949         s->resume_index = r->in.resume_index;
 950         s->domain_name  = talloc_strdup(c, r->in.domain_name);
 951         s->monitor_fn   = monitor;
 952
 953         /* make sure we have lsa domain handle before doing anything */
 954         prereq_met = lsa_domain_opened(ctx, s->domain_name, &c, &s->domain_open,
 955                                        continue_lsa_domain_opened, monitor);
 956         if (!prereq_met) return c;
 957
 958         /* prepare arguments of QueryDomainInfo call */
 959         s->query_domain.in.handle = &ctx->lsa.handle;
 960         s->query_domain.in.level  = LSA_POLICY_INFO_DOMAIN;
 961         s->query_domain.out.info  = talloc_zero(c, union lsa_PolicyInformation *);
 962         if (composite_nomem(s->query_domain.out.info, c)) return c;
 963
 964         /* send the request */
 965         subreq = dcerpc_lsa_QueryInfoPolicy_r_send(s, c->event_ctx,
 966                                                    ctx->lsa.pipe->binding_handle,
 967                                                    &s->query_domain);
 968         if (composite_nomem(subreq, c)) return c;
 969
 970         tevent_req_set_callback(subreq, continue_domain_queried, c);
 971         return c;
 972 }
 973
 974
 975 /*
 976  * Stage 0.5 (optional): receive lsa domain handle and send
 977  * request to query domain info
 978  */
 979 static void continue_lsa_domain_opened(struct composite_context *ctx)
 980 {
 981         struct composite_context *c;
 982         struct userlist_state *s;
 983         struct tevent_req *subreq;
 984
 985         c = talloc_get_type_abort(ctx->async.private_data, struct composite_context);
 986         s = talloc_get_type_abort(c->private_data, struct userlist_state);
 987
 988         /* receive lsa domain handle */
 989         c->status = libnet_DomainOpen_recv(ctx, s->ctx, c, &s->domain_open);
 990         if (!composite_is_ok(c)) return;
 991
 992         /* prepare arguments of QueryDomainInfo call */
 993         s->query_domain.in.handle = &s->ctx->lsa.handle;
 994         s->query_domain.in.level  = LSA_POLICY_INFO_DOMAIN;
 995         s->query_domain.out.info  = talloc_zero(c, union lsa_PolicyInformation *);
 996         if (composite_nomem(s->query_domain.out.info, c)) return;
 997
 998         /* send the request */
 999         subreq = dcerpc_lsa_QueryInfoPolicy_r_send(s, c->event_ctx,
1000                                                    s->ctx->lsa.pipe->binding_handle,
1001                                                    &s->query_domain);
1002         if (composite_nomem(subreq, c)) return;
1003
1004         tevent_req_set_callback(subreq, continue_domain_queried, c);
1005 }
1006
1007
1008 /*
1009  * Stage 1: receive domain info and request to enum users,
1010  * provided a valid samr handle is opened
1011  */
1012 static void continue_domain_queried(struct tevent_req *subreq)
1013 {
1014         struct composite_context *c;
1015         struct userlist_state *s;
1016         bool prereq_met = false;
1017
1018         c = tevent_req_callback_data(subreq, struct composite_context);
1019         s = talloc_get_type_abort(c->private_data, struct userlist_state);
1020
1021         /* receive result of rpc request */
1022         c->status = dcerpc_lsa_QueryInfoPolicy_r_recv(subreq, s);
1023         TALLOC_FREE(subreq);
1024         if (!composite_is_ok(c)) return;
1025
1026         /* get the returned domain info */
1027         s->dominfo = (*s->query_domain.out.info)->domain;
1028
1029         /* make sure we have samr domain handle before continuing */
1030         prereq_met = samr_domain_opened(s->ctx, s->domain_name, &c, &s->domain_open,
1031                                         continue_samr_domain_opened, s->monitor_fn);
1032         if (!prereq_met) return;
1033
1034         /* prepare arguments of EnumDomainUsers call */
1035         s->user_list.in.domain_handle = &s->ctx->samr.handle;
1036         s->user_list.in.max_size = s->page_size;
1037         s->user_list.in.resume_handle = &s->resume_index;
1038         s->user_list.in.acct_flags = ACB_NORMAL;
1039         s->user_list.out.resume_handle = &s->resume_index;
1040         s->user_list.out.num_entries = talloc(s, uint32_t);
1041         if (composite_nomem(s->user_list.out.num_entries, c)) return;
1042         s->user_list.out.sam = talloc(s, struct samr_SamArray *);
1043         if (composite_nomem(s->user_list.out.sam, c)) return;
1044
1045         /* send the request */
1046         subreq = dcerpc_samr_EnumDomainUsers_r_send(s, c->event_ctx,
1047                                                     s->ctx->samr.pipe->binding_handle,
1048                                                     &s->user_list);
1049         if (composite_nomem(subreq, c)) return;
1050
1051         tevent_req_set_callback(subreq, continue_users_enumerated, c);
1052 }
1053
1054
1055 /*
1056  * Stage 1.5 (optional): receive samr domain handle
1057  * and request to enumerate accounts
1058  */
1059 static void continue_samr_domain_opened(struct composite_context *ctx)
1060 {
1061         struct composite_context *c;
1062         struct userlist_state *s;
1063         struct tevent_req *subreq;
1064
1065         c = talloc_get_type_abort(ctx->async.private_data, struct composite_context);
1066         s = talloc_get_type_abort(c->private_data, struct userlist_state);
1067
1068         /* receive samr domain handle */
1069         c->status = libnet_DomainOpen_recv(ctx, s->ctx, c, &s->domain_open);
1070         if (!composite_is_ok(c)) return;
1071
1072         /* prepare arguments of EnumDomainUsers call */
1073         s->user_list.in.domain_handle = &s->ctx->samr.handle;
1074         s->user_list.in.max_size = s->page_size;
1075         s->user_list.in.resume_handle = &s->resume_index;
1076         s->user_list.in.acct_flags = ACB_NORMAL;
1077         s->user_list.out.resume_handle = &s->resume_index;
1078         s->user_list.out.sam = talloc(s, struct samr_SamArray *);
1079         if (composite_nomem(s->user_list.out.sam, c)) return;
1080         s->user_list.out.num_entries = talloc(s, uint32_t);
1081         if (composite_nomem(s->user_list.out.num_entries, c)) return;
1082
1083         /* send the request */
1084         subreq = dcerpc_samr_EnumDomainUsers_r_send(s, c->event_ctx,
1085                                                     s->ctx->samr.pipe->binding_handle,
1086                                                     &s->user_list);
1087         if (composite_nomem(subreq, c)) return;
1088
1089         tevent_req_set_callback(subreq, continue_users_enumerated, c);
1090 }
1091
1092
1093 /*
1094  * Stage 2: receive enumerated users and their rids
1095  */
1096 static void continue_users_enumerated(struct tevent_req *subreq)
1097 {
1098         struct composite_context *c;
1099         struct userlist_state *s;
1100         uint32_t i;
1101
1102         c = tevent_req_callback_data(subreq, struct composite_context);
1103         s = talloc_get_type_abort(c->private_data, struct userlist_state);
1104
1105         /* receive result of rpc request */
1106         c->status = dcerpc_samr_EnumDomainUsers_r_recv(subreq, s);
1107         TALLOC_FREE(subreq);
1108         if (!composite_is_ok(c)) return;
1109
1110         /* get the actual status of the rpc call result
1111            (instead of rpc layer status) */
1112         c->status = s->user_list.out.result;
1113
1114         /* we're interested in status "ok" as well as two
1115            enum-specific status codes */
1116         if (NT_STATUS_IS_OK(c->status) ||
1117             NT_STATUS_EQUAL(c->status, STATUS_MORE_ENTRIES) ||
1118             NT_STATUS_EQUAL(c->status, NT_STATUS_NO_MORE_ENTRIES)) {
1119
1120                 /* get enumerated accounts counter and resume handle (the latter allows
1121                    making subsequent call to continue enumeration) */
1122                 s->resume_index = *s->user_list.out.resume_handle;
1123                 s->count        = *s->user_list.out.num_entries;
1124
1125                 /* prepare returned user accounts array */
1126                 s->users        = talloc_array(c, struct userlist, (*s->user_list.out.sam)->count);
1127                 if (composite_nomem(s->users, c)) return;
1128
1129                 for (i = 0; i < (*s->user_list.out.sam)->count; i++) {
1130                         struct dom_sid *user_sid;
1131                         struct samr_SamEntry *entry = &(*s->user_list.out.sam)->entries[i];
1132                         struct dom_sid *domain_sid = (*s->query_domain.out.info)->domain.sid;
1133
1134                         /* construct user sid from returned rid and queried domain sid */
1135                         user_sid = dom_sid_add_rid(c, domain_sid, entry->idx);
1136                         if (composite_nomem(user_sid, c)) return;
1137
1138                         /* username */
1139                         s->users[i].username = talloc_strdup(s->users, entry->name.string);
1140                         if (composite_nomem(s->users[i].username, c)) return;
1141
1142                         /* sid string */
1143                         s->users[i].sid = dom_sid_string(s->users, user_sid);
1144                         if (composite_nomem(s->users[i].sid, c)) return;
1145                 }
1146
1147                 /* that's it */
1148                 composite_done(c);
1149
1150         } else {
1151                 /* something went wrong */
1152                 composite_error(c, c->status);
1153         }
1154 }
1155
1156
1157 /**
1158  * Receive result of UserList call
1159  *
1160  * @param c composite context returned by send request routine
1161  * @param mem_ctx memory context of this call
1162  * @param r pointer to structure containing arguments and result of this call
1163  * @return nt status
1164  */
1165 NTSTATUS libnet_UserList_recv(struct composite_context* c, TALLOC_CTX *mem_ctx,
1166                               struct libnet_UserList *r)
1167 {
1168         NTSTATUS status;
1169         struct userlist_state *s;
1170
1171         if (c == NULL || mem_ctx == NULL || r == NULL) {
1172                 talloc_free(c);
1173                 return NT_STATUS_INVALID_PARAMETER;
1174         }
1175
1176         status = composite_wait(c);
1177         if (NT_STATUS_IS_OK(status) ||
1178             NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES) ||
1179             NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES)) {
1180
1181                 s = talloc_get_type_abort(c->private_data, struct userlist_state);
1182
1183                 /* get results from composite context */
1184                 r->out.count = s->count;
1185                 r->out.resume_index = s->resume_index;
1186                 r->out.users = talloc_steal(mem_ctx, s->users);
1187
1188                 if (NT_STATUS_IS_OK(status)) {
1189                         r->out.error_string = talloc_strdup(mem_ctx, "Success");
1190                 } else {
1191                         /* success, but we're not done yet */
1192                         r->out.error_string = talloc_asprintf(mem_ctx, "Success (status: %s)",
1193                                                               nt_errstr(status));
1194                 }
1195
1196         } else {
1197                 r->out.error_string = talloc_asprintf(mem_ctx, "Error: %s", nt_errstr(status));
1198         }
1199
1200         talloc_free(c);
1201         return status;
1202 }
1203
1204
1205 /**
1206  * Synchronous version of UserList call
1207  *
1208  * @param ctx initialised libnet context
1209  * @param mem_ctx memory context of this call
1210  * @param r pointer to structure containing arguments and result of this call
1211  * @return nt status
1212  */
1213 NTSTATUS libnet_UserList(struct libnet_context *ctx,
1214                          TALLOC_CTX *mem_ctx,
1215                          struct libnet_UserList *r)
1216 {
1217         struct composite_context *c;
1218
1219         c = libnet_UserList_send(ctx, mem_ctx, r, NULL);
1220         return libnet_UserList_recv(c, mem_ctx, r);
1221 }