source4/libnet/userman.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Copyright (C) Rafal Szczesniak 2005
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 /*
  21   a composite functions for user management operations (add/del/chg)
  22 */
  23
  24 #include "includes.h"
  25 #include "libcli/composite/composite.h"
  26 #include "libnet/libnet.h"
  27 #include "librpc/gen_ndr/ndr_samr_c.h"
  28
  29 /*
  30  * Composite USER ADD functionality
  31  */
  32
  33 struct useradd_state {
  34         struct dcerpc_pipe       *pipe;
  35         struct policy_handle     domain_handle;
  36         struct samr_CreateUser   createuser;
  37         struct policy_handle     user_handle;
  38         uint32_t                 user_rid;
  39
  40         /* information about the progress */
  41         void (*monitor_fn)(struct monitor_msg *);
  42 };
  43
  44
  45 static void continue_useradd_create(struct tevent_req *subreq);
  46
  47
  48 /**
  49  * Stage 1 (and the only one for now): Create user account.
  50  */
  51 static void continue_useradd_create(struct tevent_req *subreq)
  52 {
  53         struct composite_context *c;
  54         struct useradd_state *s;
  55
  56         c = tevent_req_callback_data(subreq, struct composite_context);
  57         s = talloc_get_type(c->private_data, struct useradd_state);
  58
  59         /* check rpc layer status code */
  60         c->status = dcerpc_samr_CreateUser_r_recv(subreq, s);
  61         TALLOC_FREE(subreq);
  62         if (!composite_is_ok(c)) return;
  63
  64         /* check create user call status code */
  65         c->status = s->createuser.out.result;
  66
  67         /* get created user account data */
  68         s->user_handle = *s->createuser.out.user_handle;
  69         s->user_rid    = *s->createuser.out.rid;
  70
  71         /* issue a monitor message */
  72         if (s->monitor_fn) {
  73                 struct monitor_msg msg;
  74                 struct msg_rpc_create_user rpc_create;
  75
  76                 rpc_create.rid = *s->createuser.out.rid;
  77
  78                 msg.type      = mon_SamrCreateUser;
  79                 msg.data      = (void*)&rpc_create;
  80                 msg.data_size = sizeof(rpc_create);
  81
  82                 s->monitor_fn(&msg);
  83         }
  84
  85         composite_done(c);
  86 }
  87
  88
  89 /**
  90  * Sends asynchronous useradd request
  91  *
  92  * @param p dce/rpc call pipe
  93  * @param io arguments and results of the call
  94  * @param monitor monitor function for providing information about the progress
  95  */
  96
  97 struct composite_context *libnet_rpc_useradd_send(struct dcerpc_pipe *p,
  98                                                   TALLOC_CTX *mem_ctx,
  99                                                   struct libnet_rpc_useradd *io,
 100                                                   void (*monitor)(struct monitor_msg*))
 101 {
 102         struct composite_context *c;
 103         struct useradd_state *s;
 104         struct tevent_req *subreq;
 105
 106         if (!p || !io) return NULL;
 107
 108         /* composite allocation and setup */
 109         c = composite_create(mem_ctx, dcerpc_event_context(p));
 110         if (c == NULL) return NULL;
 111
 112         s = talloc_zero(c, struct useradd_state);
 113         if (composite_nomem(s, c)) return c;
 114
 115         c->private_data = s;
 116
 117         /* put passed arguments to the state structure */
 118         s->domain_handle = io->in.domain_handle;
 119         s->pipe          = p;
 120         s->monitor_fn    = monitor;
 121
 122         /* preparing parameters to send rpc request */
 123         s->createuser.in.domain_handle         = &io->in.domain_handle;
 124
 125         s->createuser.in.account_name          = talloc_zero(c, struct lsa_String);
 126         if (composite_nomem(s->createuser.in.account_name, c)) return c;
 127
 128         s->createuser.in.account_name->string  = talloc_strdup(c, io->in.username);
 129         if (composite_nomem(s->createuser.in.account_name->string, c)) return c;
 130
 131         s->createuser.out.user_handle          = &s->user_handle;
 132         s->createuser.out.rid                  = &s->user_rid;
 133
 134         /* send the request */
 135         subreq = dcerpc_samr_CreateUser_r_send(s, c->event_ctx,
 136                                                p->binding_handle,
 137                                                &s->createuser);
 138         if (composite_nomem(subreq, c)) return c;
 139
 140         tevent_req_set_callback(subreq, continue_useradd_create, c);
 141         return c;
 142 }
 143
 144
 145 /**
 146  * Waits for and receives result of asynchronous useradd call
 147  *
 148  * @param c composite context returned by asynchronous useradd call
 149  * @param mem_ctx memory context of the call
 150  * @param io pointer to results (and arguments) of the call
 151  * @return nt status code of execution
 152  */
 153
 154 NTSTATUS libnet_rpc_useradd_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
 155                                  struct libnet_rpc_useradd *io)
 156 {
 157         NTSTATUS status;
 158         struct useradd_state *s;
 159
 160         status = composite_wait(c);
 161
 162         if (NT_STATUS_IS_OK(status) && io) {
 163                 /* get and return result of the call */
 164                 s = talloc_get_type(c->private_data, struct useradd_state);
 165                 io->out.user_handle = s->user_handle;
 166         }
 167
 168         talloc_free(c);
 169         return status;
 170 }
 171
 172
 173 /**
 174  * Synchronous version of useradd call
 175  *
 176  * @param pipe dce/rpc call pipe
 177  * @param mem_ctx memory context for the call
 178  * @param io arguments and results of the call
 179  * @return nt status code of execution
 180  */
 181
 182 NTSTATUS libnet_rpc_useradd(struct dcerpc_pipe *p,
 183                             TALLOC_CTX *mem_ctx,
 184                             struct libnet_rpc_useradd *io)
 185 {
 186         struct composite_context *c = libnet_rpc_useradd_send(p, mem_ctx, io, NULL);
 187         return libnet_rpc_useradd_recv(c, mem_ctx, io);
 188 }
 189
 190
 191
 192 /*
 193  * Composite USER DELETE functionality
 194  */
 195
 196
 197 struct userdel_state {
 198         struct dcerpc_pipe        *pipe;
 199         struct policy_handle      domain_handle;
 200         struct policy_handle      user_handle;
 201         struct samr_LookupNames   lookupname;
 202         struct samr_OpenUser      openuser;
 203         struct samr_DeleteUser    deleteuser;
 204
 205         /* information about the progress */
 206         void (*monitor_fn)(struct monitor_msg *);
 207 };
 208
 209
 210 static void continue_userdel_name_found(struct tevent_req *subreq);
 211 static void continue_userdel_user_opened(struct tevent_req *subreq);
 212 static void continue_userdel_deleted(struct tevent_req *subreq);
 213
 214
 215 /**
 216  * Stage 1: Lookup the user name and resolve it to rid
 217  */
 218 static void continue_userdel_name_found(struct tevent_req *subreq)
 219 {
 220         struct composite_context *c;
 221         struct userdel_state *s;
 222         struct monitor_msg msg;
 223
 224         c = tevent_req_callback_data(subreq, struct composite_context);
 225         s = talloc_get_type(c->private_data, struct userdel_state);
 226
 227         /* receive samr_LookupNames result */
 228         c->status = dcerpc_samr_LookupNames_r_recv(subreq, s);
 229         TALLOC_FREE(subreq);
 230         if (!composite_is_ok(c)) return;
 231
 232         c->status = s->lookupname.out.result;
 233         if (!NT_STATUS_IS_OK(c->status)) {
 234                 composite_error(c, c->status);
 235                 return;
 236         }
 237
 238         /* what to do when there's no user account to delete
 239            and what if there's more than one rid resolved */
 240         if (s->lookupname.out.rids->count != s->lookupname.in.num_names) {
 241                 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
 242                 return;
 243         }
 244         if (s->lookupname.out.types->count != s->lookupname.in.num_names) {
 245                 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
 246                 return;
 247         }
 248
 249         /* issue a monitor message */
 250         if (s->monitor_fn) {
 251                 struct msg_rpc_lookup_name msg_lookup;
 252
 253                 msg_lookup.rid   = s->lookupname.out.rids->ids;
 254                 msg_lookup.count = s->lookupname.out.rids->count;
 255
 256                 msg.type      = mon_SamrLookupName;
 257                 msg.data      = (void*)&msg_lookup;
 258                 msg.data_size = sizeof(msg_lookup);
 259                 s->monitor_fn(&msg);
 260         }
 261
 262         /* prepare the arguments for rpc call */
 263         s->openuser.in.domain_handle = &s->domain_handle;
 264         s->openuser.in.rid           = s->lookupname.out.rids->ids[0];
 265         s->openuser.in.access_mask   = SEC_FLAG_MAXIMUM_ALLOWED;
 266         s->openuser.out.user_handle  = &s->user_handle;
 267
 268         /* send rpc request */
 269         subreq = dcerpc_samr_OpenUser_r_send(s, c->event_ctx,
 270                                              s->pipe->binding_handle,
 271                                              &s->openuser);
 272         if (composite_nomem(subreq, c)) return;
 273
 274         tevent_req_set_callback(subreq, continue_userdel_user_opened, c);
 275 }
 276
 277
 278 /**
 279  * Stage 2: Open user account.
 280  */
 281 static void continue_userdel_user_opened(struct tevent_req *subreq)
 282 {
 283         struct composite_context *c;
 284         struct userdel_state *s;
 285         struct monitor_msg msg;
 286
 287         c = tevent_req_callback_data(subreq, struct composite_context);
 288         s = talloc_get_type(c->private_data, struct userdel_state);
 289
 290         /* receive samr_OpenUser result */
 291         c->status = dcerpc_samr_OpenUser_r_recv(subreq, s);
 292         TALLOC_FREE(subreq);
 293         if (!composite_is_ok(c)) return;
 294
 295         c->status = s->openuser.out.result;
 296         if (!NT_STATUS_IS_OK(c->status)) {
 297                 composite_error(c, c->status);
 298                 return;
 299         }
 300
 301         /* issue a monitor message */
 302         if (s->monitor_fn) {
 303                 struct msg_rpc_open_user msg_open;
 304
 305                 msg_open.rid         = s->openuser.in.rid;
 306                 msg_open.access_mask = s->openuser.in.access_mask;
 307
 308                 msg.type      = mon_SamrOpenUser;
 309                 msg.data      = (void*)&msg_open;
 310                 msg.data_size = sizeof(msg_open);
 311                 s->monitor_fn(&msg);
 312         }
 313
 314         /* prepare the final rpc call arguments */
 315         s->deleteuser.in.user_handle   = &s->user_handle;
 316         s->deleteuser.out.user_handle  = &s->user_handle;
 317
 318         /* send rpc request */
 319         subreq = dcerpc_samr_DeleteUser_r_send(s, c->event_ctx,
 320                                                s->pipe->binding_handle,
 321                                                &s->deleteuser);
 322         if (composite_nomem(subreq, c)) return;
 323
 324         /* callback handler setup */
 325         tevent_req_set_callback(subreq, continue_userdel_deleted, c);
 326 }
 327
 328
 329 /**
 330  * Stage 3: Delete user account
 331  */
 332 static void continue_userdel_deleted(struct tevent_req *subreq)
 333 {
 334         struct composite_context *c;
 335         struct userdel_state *s;
 336         struct monitor_msg msg;
 337
 338         c = tevent_req_callback_data(subreq, struct composite_context);
 339         s = talloc_get_type(c->private_data, struct userdel_state);
 340
 341         /* receive samr_DeleteUser result */
 342         c->status = dcerpc_samr_DeleteUser_r_recv(subreq, s);
 343         TALLOC_FREE(subreq);
 344         if (!composite_is_ok(c)) return;
 345
 346         /* return the actual function call status */
 347         c->status = s->deleteuser.out.result;
 348         if (!NT_STATUS_IS_OK(c->status)) {
 349                 composite_error(c, c->status);
 350                 return;
 351         }
 352
 353         /* issue a monitor message */
 354         if (s->monitor_fn) {
 355                 msg.type      = mon_SamrDeleteUser;
 356                 msg.data      = NULL;
 357                 msg.data_size = 0;
 358                 s->monitor_fn(&msg);
 359         }
 360
 361         composite_done(c);
 362 }
 363
 364
 365 /**
 366  * Sends asynchronous userdel request
 367  *
 368  * @param p dce/rpc call pipe
 369  * @param io arguments and results of the call
 370  * @param monitor monitor function for providing information about the progress
 371  */
 372
 373 struct composite_context *libnet_rpc_userdel_send(struct dcerpc_pipe *p,
 374                                                   TALLOC_CTX *mem_ctx,
 375                                                   struct libnet_rpc_userdel *io,
 376                                                   void (*monitor)(struct monitor_msg*))
 377 {
 378         struct composite_context *c;
 379         struct userdel_state *s;
 380         struct tevent_req *subreq;
 381
 382         /* composite context allocation and setup */
 383         c = composite_create(mem_ctx, dcerpc_event_context(p));
 384         if (c == NULL) return NULL;
 385
 386         s = talloc_zero(c, struct userdel_state);
 387         if (composite_nomem(s, c)) return c;
 388
 389         c->private_data  = s;
 390
 391         /* store function parameters in the state structure */
 392         s->pipe          = p;
 393         s->domain_handle = io->in.domain_handle;
 394         s->monitor_fn    = monitor;
 395
 396         /* preparing parameters to send rpc request */
 397         s->lookupname.in.domain_handle = &io->in.domain_handle;
 398         s->lookupname.in.num_names     = 1;
 399         s->lookupname.in.names         = talloc_zero(s, struct lsa_String);
 400         s->lookupname.in.names->string = io->in.username;
 401         s->lookupname.out.rids         = talloc_zero(s, struct samr_Ids);
 402         s->lookupname.out.types        = talloc_zero(s, struct samr_Ids);
 403         if (composite_nomem(s->lookupname.out.rids, c)) return c;
 404         if (composite_nomem(s->lookupname.out.types, c)) return c;
 405
 406         /* send the request */
 407         subreq = dcerpc_samr_LookupNames_r_send(s, c->event_ctx,
 408                                                 p->binding_handle,
 409                                                 &s->lookupname);
 410         if (composite_nomem(subreq, c)) return c;
 411
 412         /* set the next stage */
 413         tevent_req_set_callback(subreq, continue_userdel_name_found, c);
 414         return c;
 415 }
 416
 417
 418 /**
 419  * Waits for and receives results of asynchronous userdel call
 420  *
 421  * @param c composite context returned by asynchronous userdel call
 422  * @param mem_ctx memory context of the call
 423  * @param io pointer to results (and arguments) of the call
 424  * @return nt status code of execution
 425  */
 426
 427 NTSTATUS libnet_rpc_userdel_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
 428                                  struct libnet_rpc_userdel *io)
 429 {
 430         NTSTATUS status;
 431         struct userdel_state *s;
 432
 433         status = composite_wait(c);
 434
 435         if (NT_STATUS_IS_OK(status) && io) {
 436                 s  = talloc_get_type(c->private_data, struct userdel_state);
 437                 io->out.user_handle = s->user_handle;
 438         }
 439
 440         talloc_free(c);
 441         return status;
 442 }
 443
 444
 445 /**
 446  * Synchronous version of userdel call
 447  *
 448  * @param pipe dce/rpc call pipe
 449  * @param mem_ctx memory context for the call
 450  * @param io arguments and results of the call
 451  * @return nt status code of execution
 452  */
 453
 454 NTSTATUS libnet_rpc_userdel(struct dcerpc_pipe *p,
 455                             TALLOC_CTX *mem_ctx,
 456                             struct libnet_rpc_userdel *io)
 457 {
 458         struct composite_context *c = libnet_rpc_userdel_send(p, mem_ctx, io, NULL);
 459         return libnet_rpc_userdel_recv(c, mem_ctx, io);
 460 }
 461
 462
 463 /*
 464  * USER MODIFY functionality
 465  */
 466
 467 static void continue_usermod_name_found(struct tevent_req *subreq);
 468 static void continue_usermod_user_opened(struct tevent_req *subreq);
 469 static void continue_usermod_user_queried(struct tevent_req *subreq);
 470 static void continue_usermod_user_changed(struct tevent_req *subreq);
 471
 472
 473 struct usermod_state {
 474         struct dcerpc_pipe         *pipe;
 475         struct policy_handle       domain_handle;
 476         struct policy_handle       user_handle;
 477         struct usermod_change      change;
 478         union  samr_UserInfo       info;
 479         struct samr_LookupNames    lookupname;
 480         struct samr_OpenUser       openuser;
 481         struct samr_SetUserInfo    setuser;
 482         struct samr_QueryUserInfo  queryuser;
 483
 484         /* information about the progress */
 485         void (*monitor_fn)(struct monitor_msg *);
 486 };
 487
 488
 489 /**
 490  * Step 1: Lookup user name
 491  */
 492 static void continue_usermod_name_found(struct tevent_req *subreq)
 493 {
 494         struct composite_context *c;
 495         struct usermod_state *s;
 496         struct monitor_msg msg;
 497
 498         c = tevent_req_callback_data(subreq, struct composite_context);
 499         s = talloc_get_type(c->private_data, struct usermod_state);
 500
 501         /* receive samr_LookupNames result */
 502         c->status = dcerpc_samr_LookupNames_r_recv(subreq, s);
 503         TALLOC_FREE(subreq);
 504         if (!composite_is_ok(c)) return;
 505
 506         c->status = s->lookupname.out.result;
 507         if (!NT_STATUS_IS_OK(c->status)) {
 508                 composite_error(c, c->status);
 509                 return;
 510         }
 511
 512         /* what to do when there's no user account to delete
 513            and what if there's more than one rid resolved */
 514         if (s->lookupname.out.rids->count != s->lookupname.in.num_names) {
 515                 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
 516                 return;
 517         }
 518         if (s->lookupname.out.types->count != s->lookupname.in.num_names) {
 519                 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
 520                 return;
 521         }
 522
 523         /* issue a monitor message */
 524         if (s->monitor_fn) {
 525                 struct msg_rpc_lookup_name msg_lookup;
 526
 527                 msg_lookup.rid   = s->lookupname.out.rids->ids;
 528                 msg_lookup.count = s->lookupname.out.rids->count;
 529
 530                 msg.type      = mon_SamrLookupName;
 531                 msg.data      = (void*)&msg_lookup;
 532                 msg.data_size = sizeof(msg_lookup);
 533                 s->monitor_fn(&msg);
 534         }
 535
 536         /* prepare the next rpc call */
 537         s->openuser.in.domain_handle = &s->domain_handle;
 538         s->openuser.in.rid           = s->lookupname.out.rids->ids[0];
 539         s->openuser.in.access_mask   = SEC_FLAG_MAXIMUM_ALLOWED;
 540         s->openuser.out.user_handle  = &s->user_handle;
 541
 542         /* send the rpc request */
 543         subreq = dcerpc_samr_OpenUser_r_send(s, c->event_ctx,
 544                                              s->pipe->binding_handle,
 545                                              &s->openuser);
 546         if (composite_nomem(subreq, c)) return;
 547
 548         tevent_req_set_callback(subreq, continue_usermod_user_opened, c);
 549 }
 550
 551
 552 /**
 553  * Choose a proper level of samr_UserInfo structure depending on required
 554  * change specified by means of flags field. Subsequent calls of this
 555  * function are made until there's no flags set meaning that all of the
 556  * changes have been made.
 557  */
 558 static bool usermod_setfields(struct usermod_state *s, uint16_t *level,
 559                               union samr_UserInfo *i, bool queried)
 560 {
 561         if (s->change.fields == 0) return s->change.fields;
 562
 563         *level = 0;
 564
 565         if ((s->change.fields & USERMOD_FIELD_ACCOUNT_NAME) &&
 566             (*level == 0 || *level == 7)) {
 567                 *level = 7;
 568                 i->info7.account_name.string = s->change.account_name;
 569
 570                 s->change.fields ^= USERMOD_FIELD_ACCOUNT_NAME;
 571         }
 572
 573         if ((s->change.fields & USERMOD_FIELD_FULL_NAME) &&
 574             (*level == 0 || *level == 8)) {
 575                 *level = 8;
 576                 i->info8.full_name.string = s->change.full_name;
 577
 578                 s->change.fields ^= USERMOD_FIELD_FULL_NAME;
 579         }
 580
 581         if ((s->change.fields & USERMOD_FIELD_DESCRIPTION) &&
 582             (*level == 0 || *level == 13)) {
 583                 *level = 13;
 584                 i->info13.description.string = s->change.description;
 585
 586                 s->change.fields ^= USERMOD_FIELD_DESCRIPTION;
 587         }
 588
 589         if ((s->change.fields & USERMOD_FIELD_COMMENT) &&
 590             (*level == 0 || *level == 2)) {
 591                 *level = 2;
 592
 593                 if (queried) {
 594                         /* the user info is obtained, so now set the required field */
 595                         i->info2.comment.string = s->change.comment;
 596                         s->change.fields ^= USERMOD_FIELD_COMMENT;
 597
 598                 } else {
 599                         /* we need to query the user info before setting one field in it */
 600                         return false;
 601                 }
 602         }
 603
 604         if ((s->change.fields & USERMOD_FIELD_LOGON_SCRIPT) &&
 605             (*level == 0 || *level == 11)) {
 606                 *level = 11;
 607                 i->info11.logon_script.string = s->change.logon_script;
 608
 609                 s->change.fields ^= USERMOD_FIELD_LOGON_SCRIPT;
 610         }
 611
 612         if ((s->change.fields & USERMOD_FIELD_PROFILE_PATH) &&
 613             (*level == 0 || *level == 12)) {
 614                 *level = 12;
 615                 i->info12.profile_path.string = s->change.profile_path;
 616
 617                 s->change.fields ^= USERMOD_FIELD_PROFILE_PATH;
 618         }
 619
 620         if ((s->change.fields & USERMOD_FIELD_HOME_DIRECTORY) &&
 621             (*level == 0 || *level == 10)) {
 622                 *level = 10;
 623
 624                 if (queried) {
 625                         i->info10.home_directory.string = s->change.home_directory;
 626                         s->change.fields ^= USERMOD_FIELD_HOME_DIRECTORY;
 627                 } else {
 628                         return false;
 629                 }
 630         }
 631
 632         if ((s->change.fields & USERMOD_FIELD_HOME_DRIVE) &&
 633             (*level == 0 || *level == 10)) {
 634                 *level = 10;
 635
 636                 if (queried) {
 637                         i->info10.home_drive.string = s->change.home_drive;
 638                         s->change.fields ^= USERMOD_FIELD_HOME_DRIVE;
 639                 } else {
 640                         return false;
 641                 }
 642         }
 643
 644         if ((s->change.fields & USERMOD_FIELD_ACCT_EXPIRY) &&
 645             (*level == 0 || *level == 17)) {
 646                 *level = 17;
 647                 i->info17.acct_expiry = timeval_to_nttime(s->change.acct_expiry);
 648
 649                 s->change.fields ^= USERMOD_FIELD_ACCT_EXPIRY;
 650         }
 651
 652         if ((s->change.fields & USERMOD_FIELD_ACCT_FLAGS) &&
 653             (*level == 0 || *level == 16)) {
 654                 *level = 16;
 655                 i->info16.acct_flags = s->change.acct_flags;
 656
 657                 s->change.fields ^= USERMOD_FIELD_ACCT_FLAGS;
 658         }
 659
 660         /* We're going to be here back again soon unless all fields have been set */
 661         return true;
 662 }
 663
 664
 665 static NTSTATUS usermod_change(struct composite_context *c,
 666                                struct usermod_state *s)
 667 {
 668         bool do_set;
 669         union samr_UserInfo *i = &s->info;
 670         struct tevent_req *subreq;
 671
 672         /* set the level to invalid value, so that unless setfields routine
 673            gives it a valid value we report the error correctly */
 674         uint16_t level = 27;
 675
 676         /* prepare UserInfo level and data based on bitmask field */
 677         do_set = usermod_setfields(s, &level, i, false);
 678
 679         if (level < 1 || level > 26) {
 680                 /* apparently there's a field that the setfields routine
 681                    does not know how to set */
 682                 return NT_STATUS_INVALID_PARAMETER;
 683         }
 684
 685         /* If some specific level is used to set user account data and the change
 686            itself does not cover all fields then we need to query the user info
 687            first, right before changing the data. Otherwise we could set required
 688            fields and accidentally reset the others.
 689         */
 690         if (!do_set) {
 691                 s->queryuser.in.user_handle = &s->user_handle;
 692                 s->queryuser.in.level       = level;
 693                 s->queryuser.out.info       = talloc(s, union samr_UserInfo *);
 694                 if (composite_nomem(s->queryuser.out.info, c)) return NT_STATUS_NO_MEMORY;
 695
 696
 697                 /* send query user info request to retrieve complete data of
 698                    a particular info level */
 699                 subreq = dcerpc_samr_QueryUserInfo_r_send(s, c->event_ctx,
 700                                                           s->pipe->binding_handle,
 701                                                           &s->queryuser);
 702                 if (composite_nomem(subreq, c)) return NT_STATUS_NO_MEMORY;
 703                 tevent_req_set_callback(subreq, continue_usermod_user_queried, c);
 704
 705         } else {
 706                 s->setuser.in.user_handle  = &s->user_handle;
 707                 s->setuser.in.level        = level;
 708                 s->setuser.in.info         = i;
 709
 710                 /* send set user info request after making required change */
 711                 subreq = dcerpc_samr_SetUserInfo_r_send(s, c->event_ctx,
 712                                                         s->pipe->binding_handle,
 713                                                         &s->setuser);
 714                 if (composite_nomem(subreq, c)) return NT_STATUS_NO_MEMORY;
 715                 tevent_req_set_callback(subreq, continue_usermod_user_changed, c);
 716         }
 717
 718         return NT_STATUS_OK;
 719 }
 720
 721
 722 /**
 723  * Stage 2: Open user account
 724  */
 725 static void continue_usermod_user_opened(struct tevent_req *subreq)
 726 {
 727         struct composite_context *c;
 728         struct usermod_state *s;
 729
 730         c = tevent_req_callback_data(subreq, struct composite_context);
 731         s = talloc_get_type(c->private_data, struct usermod_state);
 732
 733         c->status = dcerpc_samr_OpenUser_r_recv(subreq, s);
 734         TALLOC_FREE(subreq);
 735         if (!composite_is_ok(c)) return;
 736
 737         c->status = s->openuser.out.result;
 738         if (!NT_STATUS_IS_OK(c->status)) {
 739                 composite_error(c, c->status);
 740                 return;
 741         }
 742
 743         c->status = usermod_change(c, s);
 744 }
 745
 746
 747 /**
 748  * Stage 2a (optional): Query the user information
 749  */
 750 static void continue_usermod_user_queried(struct tevent_req *subreq)
 751 {
 752         struct composite_context *c;
 753         struct usermod_state *s;
 754         union samr_UserInfo *i;
 755         uint16_t level;
 756
 757         c = tevent_req_callback_data(subreq, struct composite_context);
 758         s = talloc_get_type(c->private_data, struct usermod_state);
 759
 760         i = &s->info;
 761
 762         /* receive samr_QueryUserInfo result */
 763         c->status = dcerpc_samr_QueryUserInfo_r_recv(subreq, s);
 764         TALLOC_FREE(subreq);
 765         if (!composite_is_ok(c)) return;
 766
 767         c->status = s->queryuser.out.result;
 768         if (!NT_STATUS_IS_OK(c->status)) {
 769                 composite_error(c, c->status);
 770                 return;
 771         }
 772
 773         /* get returned user data and make a change (potentially one
 774            of many) */
 775         s->info = *(*s->queryuser.out.info);
 776
 777         usermod_setfields(s, &level, i, true);
 778
 779         /* prepare rpc call arguments */
 780         s->setuser.in.user_handle  = &s->user_handle;
 781         s->setuser.in.level        = level;
 782         s->setuser.in.info         = i;
 783
 784         /* send the rpc request */
 785         subreq = dcerpc_samr_SetUserInfo_r_send(s, c->event_ctx,
 786                                                 s->pipe->binding_handle,
 787                                                 &s->setuser);
 788         if (composite_nomem(subreq, c)) return;
 789         tevent_req_set_callback(subreq, continue_usermod_user_changed, c);
 790 }
 791
 792
 793 /**
 794  * Stage 3: Set new user account data
 795  */
 796 static void continue_usermod_user_changed(struct tevent_req *subreq)
 797 {
 798         struct composite_context *c;
 799         struct usermod_state *s;
 800
 801         c = tevent_req_callback_data(subreq, struct composite_context);
 802         s = talloc_get_type(c->private_data, struct usermod_state);
 803
 804         /* receive samr_SetUserInfo result */
 805         c->status = dcerpc_samr_SetUserInfo_r_recv(subreq, s);
 806         TALLOC_FREE(subreq);
 807         if (!composite_is_ok(c)) return;
 808
 809         /* return the actual function call status */
 810         c->status = s->setuser.out.result;
 811         if (!NT_STATUS_IS_OK(c->status)) {
 812                 composite_error(c, c->status);
 813                 return;
 814         }
 815
 816         if (s->change.fields == 0) {
 817                 /* all fields have been set - we're done */
 818                 composite_done(c);
 819
 820         } else {
 821                 /* something's still not changed - repeat the procedure */
 822                 c->status = usermod_change(c, s);
 823         }
 824 }
 825
 826
 827 /**
 828  * Sends asynchronous usermod request
 829  *
 830  * @param p dce/rpc call pipe
 831  * @param io arguments and results of the call
 832  * @param monitor monitor function for providing information about the progress
 833  */
 834
 835 struct composite_context *libnet_rpc_usermod_send(struct dcerpc_pipe *p,
 836                                                   TALLOC_CTX *mem_ctx,
 837                                                   struct libnet_rpc_usermod *io,
 838                                                   void (*monitor)(struct monitor_msg*))
 839 {
 840         struct composite_context *c;
 841         struct usermod_state *s;
 842         struct tevent_req *subreq;
 843
 844         /* composite context allocation and setup */
 845         c = composite_create(mem_ctx, dcerpc_event_context(p));
 846         if (c == NULL) return NULL;
 847         s = talloc_zero(c, struct usermod_state);
 848         if (composite_nomem(s, c)) return c;
 849
 850         c->private_data = s;
 851
 852         /* store parameters in the call structure */
 853         s->pipe          = p;
 854         s->domain_handle = io->in.domain_handle;
 855         s->change        = io->in.change;
 856         s->monitor_fn    = monitor;
 857
 858         /* prepare rpc call arguments */
 859         s->lookupname.in.domain_handle = &io->in.domain_handle;
 860         s->lookupname.in.num_names     = 1;
 861         s->lookupname.in.names         = talloc_zero(s, struct lsa_String);
 862         s->lookupname.in.names->string = io->in.username;
 863         s->lookupname.out.rids         = talloc_zero(s, struct samr_Ids);
 864         s->lookupname.out.types        = talloc_zero(s, struct samr_Ids);
 865         if (composite_nomem(s->lookupname.out.rids, c)) return c;
 866         if (composite_nomem(s->lookupname.out.types, c)) return c;
 867
 868         /* send the rpc request */
 869         subreq = dcerpc_samr_LookupNames_r_send(s, c->event_ctx,
 870                                                 p->binding_handle,
 871                                                 &s->lookupname);
 872         if (composite_nomem(subreq, c)) return c;
 873
 874         /* callback handler setup */
 875         tevent_req_set_callback(subreq, continue_usermod_name_found, c);
 876         return c;
 877 }
 878
 879
 880 /**
 881  * Waits for and receives results of asynchronous usermod call
 882  *
 883  * @param c composite context returned by asynchronous usermod call
 884  * @param mem_ctx memory context of the call
 885  * @param io pointer to results (and arguments) of the call
 886  * @return nt status code of execution
 887  */
 888
 889 NTSTATUS libnet_rpc_usermod_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
 890                                  struct libnet_rpc_usermod *io)
 891 {
 892         NTSTATUS status;
 893
 894         status = composite_wait(c);
 895
 896         talloc_free(c);
 897         return status;
 898 }
 899
 900
 901 /**
 902  * Synchronous version of usermod call
 903  *
 904  * @param pipe dce/rpc call pipe
 905  * @param mem_ctx memory context for the call
 906  * @param io arguments and results of the call
 907  * @return nt status code of execution
 908  */
 909
 910 NTSTATUS libnet_rpc_usermod(struct dcerpc_pipe *p,
 911                             TALLOC_CTX *mem_ctx,
 912                             struct libnet_rpc_usermod *io)
 913 {
 914         struct composite_context *c = libnet_rpc_usermod_send(p, mem_ctx, io, NULL);
 915         return libnet_rpc_usermod_recv(c, mem_ctx, io);
 916 }