source/libnet/libnet_user.c

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