source3/lib/netapi/user.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  NetApi User Support
   4  *  Copyright (C) Guenther Deschner 2008
   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 #include "includes.h"
  21
  22 #include "librpc/gen_ndr/libnetapi.h"
  23 #include "lib/netapi/netapi.h"
  24 #include "lib/netapi/netapi_private.h"
  25 #include "lib/netapi/libnetapi.h"
  26
  27 /****************************************************************
  28 ****************************************************************/
  29
  30 static void convert_USER_INFO_X_to_samr_user_info21(struct USER_INFO_X *infoX,
  31                                                     struct samr_UserInfo21 *info21)
  32 {
  33         uint32_t fields_present = SAMR_FIELD_ACCT_FLAGS;
  34         struct samr_LogonHours zero_logon_hours;
  35         struct lsa_BinaryString zero_parameters;
  36         uint32_t acct_flags = 0;
  37         NTTIME password_age;
  38
  39         ZERO_STRUCTP(info21);
  40         ZERO_STRUCT(zero_logon_hours);
  41         ZERO_STRUCT(zero_parameters);
  42
  43         if (infoX->usriX_name) {
  44                 fields_present |= SAMR_FIELD_FULL_NAME;
  45         }
  46         if (infoX->usriX_password) {
  47                 fields_present |= SAMR_FIELD_PASSWORD;
  48         }
  49         if (infoX->usriX_flags) {
  50                 fields_present |= SAMR_FIELD_ACCT_FLAGS;
  51         }
  52         if (infoX->usriX_name) {
  53                 fields_present |= SAMR_FIELD_FULL_NAME;
  54         }
  55         if (infoX->usriX_home_dir) {
  56                 fields_present |= SAMR_FIELD_HOME_DIRECTORY;
  57         }
  58         if (infoX->usriX_script_path) {
  59                 fields_present |= SAMR_FIELD_LOGON_SCRIPT;
  60         }
  61         if (infoX->usriX_comment) {
  62                 fields_present |= SAMR_FIELD_DESCRIPTION;
  63         }
  64         if (infoX->usriX_password_age) {
  65                 fields_present |= SAMR_FIELD_FORCE_PWD_CHANGE;
  66         }
  67
  68         acct_flags |= infoX->usriX_flags | ACB_NORMAL;
  69
  70         unix_to_nt_time_abs(&password_age, infoX->usriX_password_age);
  71
  72         /* TODO: infoX->usriX_priv */
  73         init_samr_user_info21(info21,
  74                               0,
  75                               0,
  76                               0,
  77                               0,
  78                               0,
  79                               password_age,
  80                               NULL,
  81                               infoX->usriX_name,
  82                               infoX->usriX_home_dir,
  83                               NULL,
  84                               infoX->usriX_script_path,
  85                               NULL,
  86                               infoX->usriX_comment,
  87                               NULL,
  88                               NULL,
  89                               &zero_parameters,
  90                               0,
  91                               0,
  92                               acct_flags,
  93                               fields_present,
  94                               zero_logon_hours,
  95                               0,
  96                               0,
  97                               0,
  98                               0,
  99                               0,
 100                               0,
 101                               0);
 102 }
 103
 104 /****************************************************************
 105 ****************************************************************/
 106
 107 static NTSTATUS construct_USER_INFO_X(uint32_t level,
 108                                       uint8_t *buffer,
 109                                       struct USER_INFO_X *uX)
 110 {
 111         struct USER_INFO_0 *u0 = NULL;
 112         struct USER_INFO_1 *u1 = NULL;
 113         struct USER_INFO_2 *u2 = NULL;
 114         struct USER_INFO_1003 *u1003 = NULL;
 115         struct USER_INFO_1007 *u1007 = NULL;
 116
 117         if (!buffer || !uX) {
 118                 return NT_STATUS_INVALID_PARAMETER;
 119         }
 120
 121         ZERO_STRUCTP(uX);
 122
 123         switch (level) {
 124                 case 0:
 125                         u0 = (struct USER_INFO_0 *)buffer;
 126                         uX->usriX_name          = u0->usri0_name;
 127                         break;
 128                 case 1:
 129                         u1 = (struct USER_INFO_1 *)buffer;
 130                         uX->usriX_name          = u1->usri1_name;
 131                         uX->usriX_password      = u1->usri1_password;
 132                         uX->usriX_password_age  = u1->usri1_password_age;
 133                         uX->usriX_priv          = u1->usri1_priv;
 134                         uX->usriX_home_dir      = u1->usri1_home_dir;
 135                         uX->usriX_comment       = u1->usri1_comment;
 136                         uX->usriX_flags         = u1->usri1_flags;
 137                         uX->usriX_script_path   = u1->usri1_script_path;
 138                         break;
 139                 case 2:
 140                         u2 = (struct USER_INFO_2 *)buffer;
 141                         uX->usriX_name          = u2->usri2_name;
 142                         uX->usriX_password      = u2->usri2_password;
 143                         uX->usriX_password_age  = u2->usri2_password_age;
 144                         uX->usriX_priv          = u2->usri2_priv;
 145                         uX->usriX_home_dir      = u2->usri2_home_dir;
 146                         uX->usriX_comment       = u2->usri2_comment;
 147                         uX->usriX_flags         = u2->usri2_flags;
 148                         uX->usriX_script_path   = u2->usri2_script_path;
 149                         uX->usriX_auth_flags    = u2->usri2_auth_flags;
 150                         uX->usriX_full_name     = u2->usri2_full_name;
 151                         uX->usriX_usr_comment   = u2->usri2_usr_comment;
 152                         uX->usriX_parms         = u2->usri2_parms;
 153                         uX->usriX_workstations  = u2->usri2_workstations;
 154                         uX->usriX_last_logon    = u2->usri2_last_logon;
 155                         uX->usriX_last_logoff   = u2->usri2_last_logoff;
 156                         uX->usriX_acct_expires  = u2->usri2_acct_expires;
 157                         uX->usriX_max_storage   = u2->usri2_max_storage;
 158                         uX->usriX_units_per_week= u2->usri2_units_per_week;
 159                         uX->usriX_logon_hours   = u2->usri2_logon_hours;
 160                         uX->usriX_bad_pw_count  = u2->usri2_bad_pw_count;
 161                         uX->usriX_num_logons    = u2->usri2_num_logons;
 162                         uX->usriX_logon_server  = u2->usri2_logon_server;
 163                         uX->usriX_country_code  = u2->usri2_country_code;
 164                         uX->usriX_code_page     = u2->usri2_code_page;
 165                         break;
 166                 case 1003:
 167                         u1003 = (struct USER_INFO_1003 *)buffer;
 168                         uX->usriX_password      = u1003->usri1003_password;
 169                         break;
 170                 case 1007:
 171                         u1007 = (struct USER_INFO_1007 *)buffer;
 172                         uX->usriX_comment       = u1007->usri1007_comment;
 173                         break;
 174                 case 3:
 175                 case 4:
 176                 default:
 177                         return NT_STATUS_INVALID_INFO_CLASS;
 178         }
 179
 180         return NT_STATUS_OK;
 181 }
 182
 183 /****************************************************************
 184 ****************************************************************/
 185
 186 static NTSTATUS set_user_info_USER_INFO_X(TALLOC_CTX *ctx,
 187                                           struct rpc_pipe_client *pipe_cli,
 188                                           DATA_BLOB *session_key,
 189                                           struct policy_handle *user_handle,
 190                                           struct USER_INFO_X *uX)
 191 {
 192         union samr_UserInfo user_info;
 193         struct samr_UserInfo21 info21;
 194         NTSTATUS status;
 195
 196         if (!uX) {
 197                 return NT_STATUS_INVALID_PARAMETER;
 198         }
 199
 200         convert_USER_INFO_X_to_samr_user_info21(uX, &info21);
 201
 202         ZERO_STRUCT(user_info);
 203
 204         if (uX->usriX_password) {
 205
 206                 user_info.info25.info = info21;
 207
 208                 init_samr_CryptPasswordEx(uX->usriX_password,
 209                                           session_key,
 210                                           &user_info.info25.password);
 211
 212                 status = rpccli_samr_SetUserInfo2(pipe_cli, ctx,
 213                                                   user_handle,
 214                                                   25,
 215                                                   &user_info);
 216
 217                 if (NT_STATUS_EQUAL(status, NT_STATUS(DCERPC_FAULT_INVALID_TAG))) {
 218
 219                         user_info.info23.info = info21;
 220
 221                         init_samr_CryptPassword(uX->usriX_password,
 222                                                 session_key,
 223                                                 &user_info.info23.password);
 224
 225                         status = rpccli_samr_SetUserInfo2(pipe_cli, ctx,
 226                                                           user_handle,
 227                                                           23,
 228                                                           &user_info);
 229                 }
 230         } else {
 231
 232                 user_info.info21 = info21;
 233
 234                 status = rpccli_samr_SetUserInfo(pipe_cli, ctx,
 235                                                  user_handle,
 236                                                  21,
 237                                                  &user_info);
 238         }
 239
 240         return status;
 241 }
 242
 243 /****************************************************************
 244 ****************************************************************/
 245
 246 WERROR NetUserAdd_r(struct libnetapi_ctx *ctx,
 247                     struct NetUserAdd *r)
 248 {
 249         struct cli_state *cli = NULL;
 250         struct rpc_pipe_client *pipe_cli = NULL;
 251         NTSTATUS status;
 252         WERROR werr;
 253         POLICY_HND connect_handle, domain_handle, user_handle;
 254         struct lsa_String lsa_account_name;
 255         struct dom_sid2 *domain_sid = NULL;
 256         union samr_UserInfo *user_info = NULL;
 257         struct samr_PwInfo pw_info;
 258         uint32_t access_granted = 0;
 259         uint32_t rid = 0;
 260         struct USER_INFO_X uX;
 261
 262         ZERO_STRUCT(connect_handle);
 263         ZERO_STRUCT(domain_handle);
 264         ZERO_STRUCT(user_handle);
 265
 266         if (!r->in.buffer) {
 267                 return WERR_INVALID_PARAM;
 268         }
 269
 270         switch (r->in.level) {
 271                 case 1:
 272                         break;
 273                 case 2:
 274                 case 3:
 275                 case 4:
 276                 default:
 277                         werr = WERR_NOT_SUPPORTED;
 278                         goto done;
 279         }
 280
 281         werr = libnetapi_open_pipe(ctx, r->in.server_name,
 282                                    &ndr_table_samr.syntax_id,
 283                                    &cli,
 284                                    &pipe_cli);
 285         if (!W_ERROR_IS_OK(werr)) {
 286                 goto done;
 287         }
 288
 289         status = construct_USER_INFO_X(r->in.level, r->in.buffer, &uX);
 290         if (!NT_STATUS_IS_OK(status)) {
 291                 werr = ntstatus_to_werror(status);
 292                 goto done;
 293         }
 294
 295         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 296                                           SAMR_ACCESS_ENUM_DOMAINS |
 297                                           SAMR_ACCESS_OPEN_DOMAIN,
 298                                           SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
 299                                           SAMR_DOMAIN_ACCESS_CREATE_USER |
 300                                           SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
 301                                           &connect_handle,
 302                                           &domain_handle,
 303                                           &domain_sid);
 304         if (!W_ERROR_IS_OK(werr)) {
 305                 goto done;
 306         }
 307
 308         init_lsa_String(&lsa_account_name, uX.usriX_name);
 309
 310         status = rpccli_samr_CreateUser2(pipe_cli, ctx,
 311                                          &domain_handle,
 312                                          &lsa_account_name,
 313                                          ACB_NORMAL,
 314                                          SEC_STD_WRITE_DAC |
 315                                          SEC_STD_DELETE |
 316                                          SAMR_USER_ACCESS_SET_PASSWORD |
 317                                          SAMR_USER_ACCESS_SET_ATTRIBUTES |
 318                                          SAMR_USER_ACCESS_GET_ATTRIBUTES,
 319                                          &user_handle,
 320                                          &access_granted,
 321                                          &rid);
 322         if (!NT_STATUS_IS_OK(status)) {
 323                 werr = ntstatus_to_werror(status);
 324                 goto done;
 325         }
 326
 327         status = rpccli_samr_QueryUserInfo(pipe_cli, ctx,
 328                                            &user_handle,
 329                                            16,
 330                                            &user_info);
 331         if (!NT_STATUS_IS_OK(status)) {
 332                 werr = ntstatus_to_werror(status);
 333                 goto done;
 334         }
 335
 336         if (!(user_info->info16.acct_flags & ACB_NORMAL)) {
 337                 werr = WERR_INVALID_PARAM;
 338                 goto done;
 339         }
 340
 341         status = rpccli_samr_GetUserPwInfo(pipe_cli, ctx,
 342                                            &user_handle,
 343                                            &pw_info);
 344         if (!NT_STATUS_IS_OK(status)) {
 345                 werr = ntstatus_to_werror(status);
 346                 goto done;
 347         }
 348
 349         status = set_user_info_USER_INFO_X(ctx, pipe_cli,
 350                                            &cli->user_session_key,
 351                                            &user_handle,
 352                                            &uX);
 353         if (!NT_STATUS_IS_OK(status)) {
 354                 werr = ntstatus_to_werror(status);
 355                 goto failed;
 356         }
 357
 358         werr = WERR_OK;
 359         goto done;
 360
 361  failed:
 362         rpccli_samr_DeleteUser(pipe_cli, ctx,
 363                                &user_handle);
 364
 365  done:
 366         if (!cli) {
 367                 return werr;
 368         }
 369
 370         if (is_valid_policy_hnd(&user_handle)) {
 371                 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
 372         }
 373
 374         if (ctx->disable_policy_handle_cache) {
 375                 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
 376                 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
 377         }
 378
 379         return werr;
 380 }
 381
 382 /****************************************************************
 383 ****************************************************************/
 384
 385 WERROR NetUserAdd_l(struct libnetapi_ctx *ctx,
 386                     struct NetUserAdd *r)
 387 {
 388         LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserAdd);
 389 }
 390
 391 /****************************************************************
 392 ****************************************************************/
 393
 394 WERROR NetUserDel_r(struct libnetapi_ctx *ctx,
 395                     struct NetUserDel *r)
 396 {
 397         struct cli_state *cli = NULL;
 398         struct rpc_pipe_client *pipe_cli = NULL;
 399         NTSTATUS status;
 400         WERROR werr;
 401         POLICY_HND connect_handle, builtin_handle, domain_handle, user_handle;
 402         struct lsa_String lsa_account_name;
 403         struct samr_Ids user_rids, name_types;
 404         struct dom_sid2 *domain_sid = NULL;
 405         struct dom_sid2 user_sid;
 406
 407         ZERO_STRUCT(connect_handle);
 408         ZERO_STRUCT(builtin_handle);
 409         ZERO_STRUCT(domain_handle);
 410         ZERO_STRUCT(user_handle);
 411
 412         werr = libnetapi_open_pipe(ctx, r->in.server_name,
 413                                    &ndr_table_samr.syntax_id,
 414                                    &cli,
 415                                    &pipe_cli);
 416
 417         if (!W_ERROR_IS_OK(werr)) {
 418                 goto done;
 419         }
 420
 421         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 422                                           SAMR_ACCESS_ENUM_DOMAINS |
 423                                           SAMR_ACCESS_OPEN_DOMAIN,
 424                                           SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
 425                                           &connect_handle,
 426                                           &domain_handle,
 427                                           &domain_sid);
 428         if (!W_ERROR_IS_OK(werr)) {
 429                 goto done;
 430         }
 431
 432         status = rpccli_samr_OpenDomain(pipe_cli, ctx,
 433                                         &connect_handle,
 434                                         SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
 435                                         CONST_DISCARD(DOM_SID *, &global_sid_Builtin),
 436                                         &builtin_handle);
 437         if (!NT_STATUS_IS_OK(status)) {
 438                 werr = ntstatus_to_werror(status);
 439                 goto done;
 440         }
 441
 442         init_lsa_String(&lsa_account_name, r->in.user_name);
 443
 444         status = rpccli_samr_LookupNames(pipe_cli, ctx,
 445                                          &domain_handle,
 446                                          1,
 447                                          &lsa_account_name,
 448                                          &user_rids,
 449                                          &name_types);
 450         if (!NT_STATUS_IS_OK(status)) {
 451                 werr = ntstatus_to_werror(status);
 452                 goto done;
 453         }
 454
 455         status = rpccli_samr_OpenUser(pipe_cli, ctx,
 456                                       &domain_handle,
 457                                       STD_RIGHT_DELETE_ACCESS,
 458                                       user_rids.ids[0],
 459                                       &user_handle);
 460         if (!NT_STATUS_IS_OK(status)) {
 461                 werr = ntstatus_to_werror(status);
 462                 goto done;
 463         }
 464
 465         sid_compose(&user_sid, domain_sid, user_rids.ids[0]);
 466
 467         status = rpccli_samr_RemoveMemberFromForeignDomain(pipe_cli, ctx,
 468                                                            &builtin_handle,
 469                                                            &user_sid);
 470         if (!NT_STATUS_IS_OK(status)) {
 471                 werr = ntstatus_to_werror(status);
 472                 goto done;
 473         }
 474
 475         status = rpccli_samr_DeleteUser(pipe_cli, ctx,
 476                                         &user_handle);
 477         if (!NT_STATUS_IS_OK(status)) {
 478                 werr = ntstatus_to_werror(status);
 479                 goto done;
 480         }
 481
 482         werr = WERR_OK;
 483
 484  done:
 485         if (!cli) {
 486                 return werr;
 487         }
 488
 489         if (is_valid_policy_hnd(&user_handle)) {
 490                 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
 491         }
 492
 493         if (ctx->disable_policy_handle_cache) {
 494                 libnetapi_samr_close_builtin_handle(ctx, &builtin_handle);
 495                 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
 496                 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
 497         }
 498
 499         return werr;
 500 }
 501
 502 /****************************************************************
 503 ****************************************************************/
 504
 505 WERROR NetUserDel_l(struct libnetapi_ctx *ctx,
 506                     struct NetUserDel *r)
 507 {
 508         LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserDel);
 509 }
 510
 511 /****************************************************************
 512 ****************************************************************/
 513
 514 static NTSTATUS libnetapi_samr_lookup_user(TALLOC_CTX *mem_ctx,
 515                                            struct rpc_pipe_client *pipe_cli,
 516                                            struct policy_handle *domain_handle,
 517                                            struct policy_handle *builtin_handle,
 518                                            const char *user_name,
 519                                            uint32_t rid,
 520                                            uint32_t level,
 521                                            struct samr_UserInfo21 **info21,
 522                                            struct sec_desc_buf **sec_desc)
 523 {
 524         NTSTATUS status;
 525
 526         struct policy_handle user_handle;
 527         union samr_UserInfo *user_info = NULL;
 528         struct samr_RidWithAttributeArray *rid_array = NULL;
 529         uint32_t access_mask = SEC_STD_READ_CONTROL |
 530                                SAMR_USER_ACCESS_GET_ATTRIBUTES |
 531                                SAMR_USER_ACCESS_GET_NAME_ETC;
 532
 533         ZERO_STRUCT(user_handle);
 534
 535         switch (level) {
 536                 case 0:
 537                 case 1:
 538                 case 2:
 539                 case 3:
 540                 case 10:
 541                 case 11:
 542                 case 20:
 543                 case 23:
 544                         break;
 545                 default:
 546                         return NT_STATUS_INVALID_LEVEL;
 547         }
 548
 549         if (level == 0) {
 550                 return NT_STATUS_OK;
 551         }
 552
 553         status = rpccli_samr_OpenUser(pipe_cli, mem_ctx,
 554                                       domain_handle,
 555                                       access_mask,
 556                                       rid,
 557                                       &user_handle);
 558         if (!NT_STATUS_IS_OK(status)) {
 559                 goto done;
 560         }
 561
 562         status = rpccli_samr_QueryUserInfo(pipe_cli, mem_ctx,
 563                                            &user_handle,
 564                                            21,
 565                                            &user_info);
 566         if (!NT_STATUS_IS_OK(status)) {
 567                 goto done;
 568         }
 569
 570         status = rpccli_samr_QuerySecurity(pipe_cli, mem_ctx,
 571                                            &user_handle,
 572                                            SECINFO_DACL,
 573                                            sec_desc);
 574         if (!NT_STATUS_IS_OK(status)) {
 575                 goto done;
 576         }
 577
 578         if (level == 1) {
 579                 status = rpccli_samr_GetGroupsForUser(pipe_cli, mem_ctx,
 580                                                       &user_handle,
 581                                                       &rid_array);
 582                 if (!NT_STATUS_IS_OK(status)) {
 583                         goto done;
 584                 }
 585
 586 #if 0
 587                 status = rpccli_samr_GetAliasMembership(pipe_cli, ctx,
 588                                                         &builtin_handle,
 589                                                         &sids,
 590                                                         &rids);
 591                 if (!NT_STATUS_IS_OK(status)) {
 592                         goto done;
 593                 }
 594 #endif
 595         }
 596
 597         *info21 = &user_info->info21;
 598
 599  done:
 600         if (is_valid_policy_hnd(&user_handle)) {
 601                 rpccli_samr_Close(pipe_cli, mem_ctx, &user_handle);
 602         }
 603
 604         return status;
 605 }
 606
 607 /****************************************************************
 608 ****************************************************************/
 609
 610 static NTSTATUS libnetapi_samr_lookup_user_map_USER_INFO(TALLOC_CTX *mem_ctx,
 611                                                          struct rpc_pipe_client *pipe_cli,
 612                                                          struct dom_sid *domain_sid,
 613                                                          struct policy_handle *domain_handle,
 614                                                          struct policy_handle *builtin_handle,
 615                                                          const char *user_name,
 616                                                          uint32_t rid,
 617                                                          uint32_t level,
 618                                                          uint8_t **buffer,
 619                                                          uint32_t *num_entries)
 620 {
 621         NTSTATUS status;
 622
 623         struct samr_UserInfo21 *info21 = NULL;
 624         struct sec_desc_buf *sec_desc = NULL;
 625         struct dom_sid sid;
 626
 627         struct USER_INFO_0 info0;
 628         struct USER_INFO_10 info10;
 629         struct USER_INFO_20 info20;
 630         struct USER_INFO_23 info23;
 631
 632         switch (level) {
 633                 case 0:
 634                 case 1:
 635                 case 2:
 636                 case 3:
 637                 case 10:
 638                 case 11:
 639                 case 20:
 640                 case 23:
 641                         break;
 642                 default:
 643                         return NT_STATUS_INVALID_LEVEL;
 644         }
 645
 646         if (level == 0) {
 647                 info0.usri0_name = talloc_strdup(mem_ctx, user_name);
 648                 NT_STATUS_HAVE_NO_MEMORY(info0.usri0_name);
 649
 650                 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_0, info0,
 651                              (struct USER_INFO_0 **)buffer, num_entries);
 652
 653                 return NT_STATUS_OK;
 654         }
 655
 656         status = libnetapi_samr_lookup_user(mem_ctx, pipe_cli,
 657                                             domain_handle,
 658                                             builtin_handle,
 659                                             user_name,
 660                                             rid,
 661                                             level,
 662                                             &info21,
 663                                             &sec_desc);
 664
 665         if (!NT_STATUS_IS_OK(status)) {
 666                 goto done;
 667         }
 668
 669         switch (level) {
 670                 case 10:
 671                         info10.usri10_name = talloc_strdup(mem_ctx, user_name);
 672                         NT_STATUS_HAVE_NO_MEMORY(info10.usri10_name);
 673
 674                         info10.usri10_comment = talloc_strdup(mem_ctx,
 675                                 info21->description.string);
 676
 677                         info10.usri10_full_name = talloc_strdup(mem_ctx,
 678                                 info21->full_name.string);
 679
 680                         info10.usri10_usr_comment = talloc_strdup(mem_ctx,
 681                                 info21->comment.string);
 682
 683                         ADD_TO_ARRAY(mem_ctx, struct USER_INFO_10, info10,
 684                                      (struct USER_INFO_10 **)buffer, num_entries);
 685
 686                         break;
 687
 688                 case 20:
 689                         info20.usri20_name = talloc_strdup(mem_ctx, user_name);
 690                         NT_STATUS_HAVE_NO_MEMORY(info20.usri20_name);
 691
 692                         info20.usri20_comment = talloc_strdup(mem_ctx,
 693                                 info21->description.string);
 694
 695                         info20.usri20_full_name = talloc_strdup(mem_ctx,
 696                                 info21->full_name.string);
 697
 698                         info20.usri20_flags = info21->acct_flags;
 699                         info20.usri20_user_id = rid;
 700
 701                         ADD_TO_ARRAY(mem_ctx, struct USER_INFO_20, info20,
 702                                      (struct USER_INFO_20 **)buffer, num_entries);
 703
 704                         break;
 705                 case 23:
 706                         info23.usri23_name = talloc_strdup(mem_ctx, user_name);
 707                         NT_STATUS_HAVE_NO_MEMORY(info23.usri23_name);
 708
 709                         info23.usri23_comment = talloc_strdup(mem_ctx,
 710                                 info21->description.string);
 711
 712                         info23.usri23_full_name = talloc_strdup(mem_ctx,
 713                                 info21->full_name.string);
 714
 715                         info23.usri23_flags = info21->acct_flags;
 716
 717                         if (!sid_compose(&sid, domain_sid, rid)) {
 718                                 return NT_STATUS_NO_MEMORY;
 719                         }
 720
 721                         info23.usri23_user_sid =
 722                                 (struct domsid *)sid_dup_talloc(mem_ctx, &sid);
 723
 724                         ADD_TO_ARRAY(mem_ctx, struct USER_INFO_23, info23,
 725                                      (struct USER_INFO_23 **)buffer, num_entries);
 726                         break;
 727         }
 728
 729  done:
 730         return status;
 731 }
 732
 733 /****************************************************************
 734 ****************************************************************/
 735
 736 WERROR NetUserEnum_r(struct libnetapi_ctx *ctx,
 737                      struct NetUserEnum *r)
 738 {
 739         struct cli_state *cli = NULL;
 740         struct rpc_pipe_client *pipe_cli = NULL;
 741         struct policy_handle connect_handle;
 742         struct dom_sid2 *domain_sid = NULL;
 743         struct policy_handle domain_handle;
 744         struct samr_SamArray *sam = NULL;
 745         uint32_t filter = ACB_NORMAL;
 746         int i;
 747         uint32_t entries_read = 0;
 748
 749         NTSTATUS status = NT_STATUS_OK;
 750         WERROR werr;
 751
 752         ZERO_STRUCT(connect_handle);
 753         ZERO_STRUCT(domain_handle);
 754
 755         if (!r->out.buffer) {
 756                 return WERR_INVALID_PARAM;
 757         }
 758
 759         *r->out.buffer = NULL;
 760         *r->out.entries_read = 0;
 761
 762         switch (r->in.level) {
 763                 case 0:
 764                 case 10:
 765                 case 20:
 766                 case 23:
 767                         break;
 768                 case 1:
 769                 case 2:
 770                 case 3:
 771                 case 11:
 772                 default:
 773                         return WERR_NOT_SUPPORTED;
 774         }
 775
 776         werr = libnetapi_open_pipe(ctx, r->in.server_name,
 777                                    &ndr_table_samr.syntax_id,
 778                                    &cli,
 779                                    &pipe_cli);
 780         if (!W_ERROR_IS_OK(werr)) {
 781                 goto done;
 782         }
 783
 784         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 785                                           SAMR_ACCESS_ENUM_DOMAINS |
 786                                           SAMR_ACCESS_OPEN_DOMAIN,
 787                                           SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
 788                                           SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS |
 789                                           SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
 790                                           &connect_handle,
 791                                           &domain_handle,
 792                                           &domain_sid);
 793         if (!W_ERROR_IS_OK(werr)) {
 794                 goto done;
 795         }
 796
 797         switch (r->in.filter) {
 798                 case FILTER_NORMAL_ACCOUNT:
 799                         filter = ACB_NORMAL;
 800                         break;
 801                 case FILTER_TEMP_DUPLICATE_ACCOUNT:
 802                         filter = ACB_TEMPDUP;
 803                         break;
 804                 case FILTER_INTERDOMAIN_TRUST_ACCOUNT:
 805                         filter = ACB_DOMTRUST;
 806                         break;
 807                 case FILTER_WORKSTATION_TRUST_ACCOUNT:
 808                         filter = ACB_WSTRUST;
 809                         break;
 810                 case FILTER_SERVER_TRUST_ACCOUNT:
 811                         filter = ACB_SVRTRUST;
 812                         break;
 813                 default:
 814                         break;
 815         }
 816
 817         status = rpccli_samr_EnumDomainUsers(pipe_cli,
 818                                              ctx,
 819                                              &domain_handle,
 820                                              r->in.resume_handle,
 821                                              filter,
 822                                              &sam,
 823                                              r->in.prefmaxlen,
 824                                              &entries_read);
 825         werr = ntstatus_to_werror(status);
 826         if (NT_STATUS_IS_ERR(status)) {
 827                 goto done;
 828         }
 829
 830         for (i=0; i < sam->count; i++) {
 831
 832                 status = libnetapi_samr_lookup_user_map_USER_INFO(ctx, pipe_cli,
 833                                                                   domain_sid,
 834                                                                   &domain_handle,
 835                                                                   NULL, /*&builtin_handle, */
 836                                                                   sam->entries[i].name.string,
 837                                                                   sam->entries[i].idx,
 838                                                                   r->in.level,
 839                                                                   r->out.buffer,
 840                                                                   r->out.entries_read);
 841                 if (!NT_STATUS_IS_OK(status)) {
 842                         werr = ntstatus_to_werror(status);
 843                         goto done;
 844                 }
 845         }
 846
 847  done:
 848         if (!cli) {
 849                 return werr;
 850         }
 851
 852         /* if last query */
 853         if (NT_STATUS_IS_OK(status) ||
 854             NT_STATUS_IS_ERR(status)) {
 855
 856                 if (ctx->disable_policy_handle_cache) {
 857                         libnetapi_samr_close_domain_handle(ctx, &domain_handle);
 858                         libnetapi_samr_close_connect_handle(ctx, &connect_handle);
 859                 }
 860         }
 861
 862         return werr;
 863 }
 864
 865 /****************************************************************
 866 ****************************************************************/
 867
 868 WERROR NetUserEnum_l(struct libnetapi_ctx *ctx,
 869                      struct NetUserEnum *r)
 870 {
 871         LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserEnum);
 872 }
 873
 874 /****************************************************************
 875 ****************************************************************/
 876
 877 static WERROR convert_samr_dispinfo_to_NET_DISPLAY_USER(TALLOC_CTX *mem_ctx,
 878                                                         struct samr_DispInfoGeneral *info,
 879                                                         uint32_t *entries_read,
 880                                                         void **buffer)
 881 {
 882         struct NET_DISPLAY_USER *user = NULL;
 883         int i;
 884
 885         user = TALLOC_ZERO_ARRAY(mem_ctx,
 886                                  struct NET_DISPLAY_USER,
 887                                  info->count);
 888         W_ERROR_HAVE_NO_MEMORY(user);
 889
 890         for (i = 0; i < info->count; i++) {
 891                 user[i].usri1_name = talloc_strdup(mem_ctx,
 892                         info->entries[i].account_name.string);
 893                 user[i].usri1_comment = talloc_strdup(mem_ctx,
 894                         info->entries[i].description.string);
 895                 user[i].usri1_flags =
 896                         info->entries[i].acct_flags;
 897                 user[i].usri1_full_name = talloc_strdup(mem_ctx,
 898                         info->entries[i].full_name.string);
 899                 user[i].usri1_user_id =
 900                         info->entries[i].rid;
 901                 user[i].usri1_next_index =
 902                         info->entries[i].idx;
 903
 904                 if (!user[i].usri1_name) {
 905                         return WERR_NOMEM;
 906                 }
 907         }
 908
 909         *buffer = talloc_memdup(mem_ctx, user,
 910                 sizeof(struct NET_DISPLAY_USER) * info->count);
 911         W_ERROR_HAVE_NO_MEMORY(*buffer);
 912
 913         *entries_read = info->count;
 914
 915         return WERR_OK;
 916 }
 917
 918 /****************************************************************
 919 ****************************************************************/
 920
 921 static WERROR convert_samr_dispinfo_to_NET_DISPLAY_MACHINE(TALLOC_CTX *mem_ctx,
 922                                                            struct samr_DispInfoFull *info,
 923                                                            uint32_t *entries_read,
 924                                                            void **buffer)
 925 {
 926         struct NET_DISPLAY_MACHINE *machine = NULL;
 927         int i;
 928
 929         machine = TALLOC_ZERO_ARRAY(mem_ctx,
 930                                     struct NET_DISPLAY_MACHINE,
 931                                     info->count);
 932         W_ERROR_HAVE_NO_MEMORY(machine);
 933
 934         for (i = 0; i < info->count; i++) {
 935                 machine[i].usri2_name = talloc_strdup(mem_ctx,
 936                         info->entries[i].account_name.string);
 937                 machine[i].usri2_comment = talloc_strdup(mem_ctx,
 938                         info->entries[i].description.string);
 939                 machine[i].usri2_flags =
 940                         info->entries[i].acct_flags;
 941                 machine[i].usri2_user_id =
 942                         info->entries[i].rid;
 943                 machine[i].usri2_next_index =
 944                         info->entries[i].idx;
 945
 946                 if (!machine[i].usri2_name) {
 947                         return WERR_NOMEM;
 948                 }
 949         }
 950
 951         *buffer = talloc_memdup(mem_ctx, machine,
 952                 sizeof(struct NET_DISPLAY_MACHINE) * info->count);
 953         W_ERROR_HAVE_NO_MEMORY(*buffer);
 954
 955         *entries_read = info->count;
 956
 957         return WERR_OK;
 958 }
 959
 960 /****************************************************************
 961 ****************************************************************/
 962
 963 static WERROR convert_samr_dispinfo_to_NET_DISPLAY_GROUP(TALLOC_CTX *mem_ctx,
 964                                                          struct samr_DispInfoFullGroups *info,
 965                                                          uint32_t *entries_read,
 966                                                          void **buffer)
 967 {
 968         struct NET_DISPLAY_GROUP *group = NULL;
 969         int i;
 970
 971         group = TALLOC_ZERO_ARRAY(mem_ctx,
 972                                   struct NET_DISPLAY_GROUP,
 973                                   info->count);
 974         W_ERROR_HAVE_NO_MEMORY(group);
 975
 976         for (i = 0; i < info->count; i++) {
 977                 group[i].grpi3_name = talloc_strdup(mem_ctx,
 978                         info->entries[i].account_name.string);
 979                 group[i].grpi3_comment = talloc_strdup(mem_ctx,
 980                         info->entries[i].description.string);
 981                 group[i].grpi3_group_id =
 982                         info->entries[i].rid;
 983                 group[i].grpi3_attributes =
 984                         info->entries[i].acct_flags;
 985                 group[i].grpi3_next_index =
 986                         info->entries[i].idx;
 987
 988                 if (!group[i].grpi3_name) {
 989                         return WERR_NOMEM;
 990                 }
 991         }
 992
 993         *buffer = talloc_memdup(mem_ctx, group,
 994                 sizeof(struct NET_DISPLAY_GROUP) * info->count);
 995         W_ERROR_HAVE_NO_MEMORY(*buffer);
 996
 997         *entries_read = info->count;
 998
 999         return WERR_OK;
1000
1001 }
1002
1003 /****************************************************************
1004 ****************************************************************/
1005
1006 static WERROR convert_samr_dispinfo_to_NET_DISPLAY(TALLOC_CTX *mem_ctx,
1007                                                    union samr_DispInfo *info,
1008                                                    uint32_t level,
1009                                                    uint32_t *entries_read,
1010                                                    void **buffer)
1011 {
1012         switch (level) {
1013                 case 1:
1014                         return convert_samr_dispinfo_to_NET_DISPLAY_USER(mem_ctx,
1015                                                                          &info->info1,
1016                                                                          entries_read,
1017                                                                          buffer);
1018                 case 2:
1019                         return convert_samr_dispinfo_to_NET_DISPLAY_MACHINE(mem_ctx,
1020                                                                             &info->info2,
1021                                                                             entries_read,
1022                                                                             buffer);
1023                 case 3:
1024                         return convert_samr_dispinfo_to_NET_DISPLAY_GROUP(mem_ctx,
1025                                                                           &info->info3,
1026                                                                           entries_read,
1027                                                                           buffer);
1028                 default:
1029                         return WERR_UNKNOWN_LEVEL;
1030         }
1031
1032         return WERR_OK;
1033 }
1034
1035 /****************************************************************
1036 ****************************************************************/
1037
1038 WERROR NetQueryDisplayInformation_r(struct libnetapi_ctx *ctx,
1039                                     struct NetQueryDisplayInformation *r)
1040 {
1041         struct cli_state *cli = NULL;
1042         struct rpc_pipe_client *pipe_cli = NULL;
1043         struct policy_handle connect_handle;
1044         struct dom_sid2 *domain_sid = NULL;
1045         struct policy_handle domain_handle;
1046         union samr_DispInfo info;
1047
1048         uint32_t total_size = 0;
1049         uint32_t returned_size = 0;
1050
1051         NTSTATUS status = NT_STATUS_OK;
1052         WERROR werr;
1053
1054         ZERO_STRUCT(connect_handle);
1055         ZERO_STRUCT(domain_handle);
1056
1057         switch (r->in.level) {
1058                 case 1:
1059                 case 2:
1060                 case 3:
1061                         break;
1062                 default:
1063                         return WERR_UNKNOWN_LEVEL;
1064         }
1065
1066         werr = libnetapi_open_pipe(ctx, r->in.server_name,
1067                                    &ndr_table_samr.syntax_id,
1068                                    &cli,
1069                                    &pipe_cli);
1070         if (!W_ERROR_IS_OK(werr)) {
1071                 goto done;
1072         }
1073
1074         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1075                                           SAMR_ACCESS_ENUM_DOMAINS |
1076                                           SAMR_ACCESS_OPEN_DOMAIN,
1077                                           SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
1078                                           SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS |
1079                                           SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1080                                           &connect_handle,
1081                                           &domain_handle,
1082                                           &domain_sid);
1083         if (!W_ERROR_IS_OK(werr)) {
1084                 goto done;
1085         }
1086
1087         status = rpccli_samr_QueryDisplayInfo2(pipe_cli,
1088                                                ctx,
1089                                                &domain_handle,
1090                                                r->in.level,
1091                                                r->in.idx,
1092                                                r->in.entries_requested,
1093                                                r->in.prefmaxlen,
1094                                                &total_size,
1095                                                &returned_size,
1096                                                &info);
1097         if (!NT_STATUS_IS_OK(status)) {
1098                 werr = ntstatus_to_werror(status);
1099                 goto done;
1100         }
1101
1102         werr = convert_samr_dispinfo_to_NET_DISPLAY(ctx, &info,
1103                                                     r->in.level,
1104                                                     r->out.entries_read,
1105                                                     r->out.buffer);
1106  done:
1107         if (!cli) {
1108                 return werr;
1109         }
1110
1111         /* if last query */
1112         if (NT_STATUS_IS_OK(status) ||
1113             NT_STATUS_IS_ERR(status)) {
1114
1115                 if (ctx->disable_policy_handle_cache) {
1116                         libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1117                         libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1118                 }
1119         }
1120
1121         return werr;
1122
1123 }
1124
1125 /****************************************************************
1126 ****************************************************************/
1127
1128
1129 WERROR NetQueryDisplayInformation_l(struct libnetapi_ctx *ctx,
1130                                     struct NetQueryDisplayInformation *r)
1131 {
1132         LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetQueryDisplayInformation);
1133 }
1134
1135 /****************************************************************
1136 ****************************************************************/
1137
1138 WERROR NetUserChangePassword_r(struct libnetapi_ctx *ctx,
1139                                struct NetUserChangePassword *r)
1140 {
1141         return WERR_NOT_SUPPORTED;
1142 }
1143
1144 /****************************************************************
1145 ****************************************************************/
1146
1147 WERROR NetUserChangePassword_l(struct libnetapi_ctx *ctx,
1148                                struct NetUserChangePassword *r)
1149 {
1150         return WERR_NOT_SUPPORTED;
1151 }
1152
1153 /****************************************************************
1154 ****************************************************************/
1155
1156 WERROR NetUserGetInfo_r(struct libnetapi_ctx *ctx,
1157                         struct NetUserGetInfo *r)
1158 {
1159         struct cli_state *cli = NULL;
1160         struct rpc_pipe_client *pipe_cli = NULL;
1161         NTSTATUS status;
1162         WERROR werr;
1163
1164         struct policy_handle connect_handle, domain_handle, builtin_handle, user_handle;
1165         struct lsa_String lsa_account_name;
1166         struct dom_sid2 *domain_sid = NULL;
1167         struct samr_Ids user_rids, name_types;
1168         uint32_t num_entries = 0;
1169
1170         ZERO_STRUCT(connect_handle);
1171         ZERO_STRUCT(domain_handle);
1172         ZERO_STRUCT(builtin_handle);
1173         ZERO_STRUCT(user_handle);
1174
1175         if (!r->out.buffer) {
1176                 return WERR_INVALID_PARAM;
1177         }
1178
1179         switch (r->in.level) {
1180                 case 0:
1181                 /* case 1: */
1182                 case 10:
1183                 case 20:
1184                 case 23:
1185                         break;
1186                 default:
1187                         werr = WERR_NOT_SUPPORTED;
1188                         goto done;
1189         }
1190
1191         werr = libnetapi_open_pipe(ctx, r->in.server_name,
1192                                    &ndr_table_samr.syntax_id,
1193                                    &cli,
1194                                    &pipe_cli);
1195         if (!W_ERROR_IS_OK(werr)) {
1196                 goto done;
1197         }
1198
1199         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1200                                           SAMR_ACCESS_ENUM_DOMAINS |
1201                                           SAMR_ACCESS_OPEN_DOMAIN,
1202                                           SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1203                                           &connect_handle,
1204                                           &domain_handle,
1205                                           &domain_sid);
1206         if (!W_ERROR_IS_OK(werr)) {
1207                 goto done;
1208         }
1209
1210         werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
1211                                                   SAMR_ACCESS_ENUM_DOMAINS |
1212                                                   SAMR_ACCESS_OPEN_DOMAIN,
1213                                                   SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
1214                                                   SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
1215                                                   &connect_handle,
1216                                                   &builtin_handle);
1217         if (!W_ERROR_IS_OK(werr)) {
1218                 goto done;
1219         }
1220
1221         init_lsa_String(&lsa_account_name, r->in.user_name);
1222
1223         status = rpccli_samr_LookupNames(pipe_cli, ctx,
1224                                          &domain_handle,
1225                                          1,
1226                                          &lsa_account_name,
1227                                          &user_rids,
1228                                          &name_types);
1229         if (!NT_STATUS_IS_OK(status)) {
1230                 werr = ntstatus_to_werror(status);
1231                 goto done;
1232         }
1233
1234         status = libnetapi_samr_lookup_user_map_USER_INFO(ctx, pipe_cli,
1235                                                           domain_sid,
1236                                                           &domain_handle,
1237                                                           &builtin_handle,
1238                                                           r->in.user_name,
1239                                                           user_rids.ids[0],
1240                                                           r->in.level,
1241                                                           r->out.buffer,
1242                                                           &num_entries);
1243         if (!NT_STATUS_IS_OK(status)) {
1244                 werr = ntstatus_to_werror(status);
1245                 goto done;
1246         }
1247
1248  done:
1249         if (!cli) {
1250                 return werr;
1251         }
1252
1253         if (is_valid_policy_hnd(&user_handle)) {
1254                 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
1255         }
1256
1257         if (ctx->disable_policy_handle_cache) {
1258                 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1259                 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1260         }
1261
1262         return werr;
1263 }
1264
1265 /****************************************************************
1266 ****************************************************************/
1267
1268 WERROR NetUserGetInfo_l(struct libnetapi_ctx *ctx,
1269                         struct NetUserGetInfo *r)
1270 {
1271         LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserGetInfo);
1272 }
1273
1274 /****************************************************************
1275 ****************************************************************/
1276
1277 WERROR NetUserSetInfo_r(struct libnetapi_ctx *ctx,
1278                         struct NetUserSetInfo *r)
1279 {
1280         struct cli_state *cli = NULL;
1281         struct rpc_pipe_client *pipe_cli = NULL;
1282         NTSTATUS status;
1283         WERROR werr;
1284
1285         struct policy_handle connect_handle, domain_handle, builtin_handle, user_handle;
1286         struct lsa_String lsa_account_name;
1287         struct dom_sid2 *domain_sid = NULL;
1288         struct samr_Ids user_rids, name_types;
1289         union samr_UserInfo user_info;
1290
1291         struct USER_INFO_X uX;
1292
1293         ZERO_STRUCT(connect_handle);
1294         ZERO_STRUCT(domain_handle);
1295         ZERO_STRUCT(builtin_handle);
1296         ZERO_STRUCT(user_handle);
1297
1298         if (!r->in.buffer) {
1299                 return WERR_INVALID_PARAM;
1300         }
1301
1302         switch (r->in.level) {
1303                 case 0:
1304                 case 1007:
1305                         break;
1306                 default:
1307                         werr = WERR_NOT_SUPPORTED;
1308                         goto done;
1309         }
1310
1311         werr = libnetapi_open_pipe(ctx, r->in.server_name,
1312                                    &ndr_table_samr.syntax_id,
1313                                    &cli,
1314                                    &pipe_cli);
1315         if (!W_ERROR_IS_OK(werr)) {
1316                 goto done;
1317         }
1318
1319         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1320                                           SAMR_ACCESS_ENUM_DOMAINS |
1321                                           SAMR_ACCESS_OPEN_DOMAIN,
1322                                           SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
1323                                           SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1324                                           &connect_handle,
1325                                           &domain_handle,
1326                                           &domain_sid);
1327         if (!W_ERROR_IS_OK(werr)) {
1328                 goto done;
1329         }
1330
1331         werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
1332                                                   SAMR_ACCESS_ENUM_DOMAINS |
1333                                                   SAMR_ACCESS_OPEN_DOMAIN,
1334                                                   SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
1335                                                   SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
1336                                                   &connect_handle,
1337                                                   &builtin_handle);
1338         if (!W_ERROR_IS_OK(werr)) {
1339                 goto done;
1340         }
1341
1342         init_lsa_String(&lsa_account_name, r->in.user_name);
1343
1344         status = rpccli_samr_LookupNames(pipe_cli, ctx,
1345                                          &domain_handle,
1346                                          1,
1347                                          &lsa_account_name,
1348                                          &user_rids,
1349                                          &name_types);
1350         if (!NT_STATUS_IS_OK(status)) {
1351                 werr = ntstatus_to_werror(status);
1352                 goto done;
1353         }
1354
1355         status = rpccli_samr_OpenUser(pipe_cli, ctx,
1356                                       &domain_handle,
1357                                       SAMR_USER_ACCESS_SET_ATTRIBUTES,
1358                                       user_rids.ids[0],
1359                                       &user_handle);
1360         if (!NT_STATUS_IS_OK(status)) {
1361                 werr = ntstatus_to_werror(status);
1362                 goto done;
1363         }
1364
1365         status = construct_USER_INFO_X(r->in.level, r->in.buffer, &uX);
1366         if (!NT_STATUS_IS_OK(status)) {
1367                 werr = ntstatus_to_werror(status);
1368                 goto done;
1369         }
1370
1371         convert_USER_INFO_X_to_samr_user_info21(&uX, &user_info.info21);
1372
1373         status = rpccli_samr_SetUserInfo(pipe_cli, ctx,
1374                                          &user_handle,
1375                                          21,
1376                                          &user_info);
1377         if (!NT_STATUS_IS_OK(status)) {
1378                 werr = ntstatus_to_werror(status);
1379                 goto done;
1380         }
1381
1382         werr = WERR_OK;
1383
1384  done:
1385         if (!cli) {
1386                 return werr;
1387         }
1388
1389         if (is_valid_policy_hnd(&user_handle)) {
1390                 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
1391         }
1392
1393         if (ctx->disable_policy_handle_cache) {
1394                 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1395                 libnetapi_samr_close_builtin_handle(ctx, &builtin_handle);
1396                 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1397         }
1398
1399         return werr;
1400 }
1401
1402 /****************************************************************
1403 ****************************************************************/
1404
1405 WERROR NetUserSetInfo_l(struct libnetapi_ctx *ctx,
1406                         struct NetUserSetInfo *r)
1407 {
1408         LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserSetInfo);
1409 }
1410
1411 /****************************************************************
1412 ****************************************************************/
1413
1414 static NTSTATUS query_USER_MODALS_INFO_rpc(TALLOC_CTX *mem_ctx,
1415                                            struct rpc_pipe_client *pipe_cli,
1416                                            struct policy_handle *domain_handle,
1417                                            struct samr_DomInfo1 *info1,
1418                                            struct samr_DomInfo3 *info3,
1419                                            struct samr_DomInfo5 *info5,
1420                                            struct samr_DomInfo6 *info6,
1421                                            struct samr_DomInfo7 *info7,
1422                                            struct samr_DomInfo12 *info12)
1423 {
1424         NTSTATUS status;
1425         union samr_DomainInfo *dom_info = NULL;
1426
1427         if (info1) {
1428                 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1429                                                      domain_handle,
1430                                                      1,
1431                                                      &dom_info);
1432                 NT_STATUS_NOT_OK_RETURN(status);
1433
1434                 *info1 = dom_info->info1;
1435         }
1436
1437         if (info3) {
1438                 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1439                                                      domain_handle,
1440                                                      3,
1441                                                      &dom_info);
1442                 NT_STATUS_NOT_OK_RETURN(status);
1443
1444                 *info3 = dom_info->info3;
1445         }
1446
1447         if (info5) {
1448                 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1449                                                      domain_handle,
1450                                                      5,
1451                                                      &dom_info);
1452                 NT_STATUS_NOT_OK_RETURN(status);
1453
1454                 *info5 = dom_info->info5;
1455         }
1456
1457         if (info6) {
1458                 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1459                                                      domain_handle,
1460                                                      6,
1461                                                      &dom_info);
1462                 NT_STATUS_NOT_OK_RETURN(status);
1463
1464                 *info6 = dom_info->info6;
1465         }
1466
1467         if (info7) {
1468                 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1469                                                      domain_handle,
1470                                                      7,
1471                                                      &dom_info);
1472                 NT_STATUS_NOT_OK_RETURN(status);
1473
1474                 *info7 = dom_info->info7;
1475         }
1476
1477         if (info12) {
1478                 status = rpccli_samr_QueryDomainInfo2(pipe_cli, mem_ctx,
1479                                                       domain_handle,
1480                                                       12,
1481                                                       &dom_info);
1482                 NT_STATUS_NOT_OK_RETURN(status);
1483
1484                 *info12 = dom_info->info12;
1485         }
1486
1487         return NT_STATUS_OK;
1488 }
1489
1490 /****************************************************************
1491 ****************************************************************/
1492
1493 static NTSTATUS query_USER_MODALS_INFO_0(TALLOC_CTX *mem_ctx,
1494                                          struct rpc_pipe_client *pipe_cli,
1495                                          struct policy_handle *domain_handle,
1496                                          struct USER_MODALS_INFO_0 *info0)
1497 {
1498         NTSTATUS status;
1499         struct samr_DomInfo1 dom_info1;
1500         struct samr_DomInfo3 dom_info3;
1501
1502         ZERO_STRUCTP(info0);
1503
1504         status = query_USER_MODALS_INFO_rpc(mem_ctx,
1505                                             pipe_cli,
1506                                             domain_handle,
1507                                             &dom_info1,
1508                                             &dom_info3,
1509                                             NULL,
1510                                             NULL,
1511                                             NULL,
1512                                             NULL);
1513         NT_STATUS_NOT_OK_RETURN(status);
1514
1515         info0->usrmod0_min_passwd_len =
1516                 dom_info1.min_password_length;
1517         info0->usrmod0_max_passwd_age =
1518                 nt_time_to_unix_abs((NTTIME *)&dom_info1.max_password_age);
1519         info0->usrmod0_min_passwd_age =
1520                 nt_time_to_unix_abs((NTTIME *)&dom_info1.min_password_age);
1521         info0->usrmod0_password_hist_len =
1522                 dom_info1.password_history_length;
1523
1524         info0->usrmod0_force_logoff =
1525                 nt_time_to_unix_abs(&dom_info3.force_logoff_time);
1526
1527         return NT_STATUS_OK;
1528 }
1529
1530 /****************************************************************
1531 ****************************************************************/
1532
1533 static NTSTATUS query_USER_MODALS_INFO_1(TALLOC_CTX *mem_ctx,
1534                                          struct rpc_pipe_client *pipe_cli,
1535                                          struct policy_handle *domain_handle,
1536                                          struct USER_MODALS_INFO_1 *info1)
1537 {
1538         NTSTATUS status;
1539         struct samr_DomInfo6 dom_info6;
1540         struct samr_DomInfo7 dom_info7;
1541
1542         status = query_USER_MODALS_INFO_rpc(mem_ctx,
1543                                             pipe_cli,
1544                                             domain_handle,
1545                                             NULL,
1546                                             NULL,
1547                                             NULL,
1548                                             &dom_info6,
1549                                             &dom_info7,
1550                                             NULL);
1551         NT_STATUS_NOT_OK_RETURN(status);
1552
1553         info1->usrmod1_primary =
1554                 talloc_strdup(mem_ctx, dom_info6.primary.string);
1555
1556         info1->usrmod1_role = dom_info7.role;
1557
1558         return NT_STATUS_OK;
1559 }
1560
1561 /****************************************************************
1562 ****************************************************************/
1563
1564 static NTSTATUS query_USER_MODALS_INFO_2(TALLOC_CTX *mem_ctx,
1565                                          struct rpc_pipe_client *pipe_cli,
1566                                          struct policy_handle *domain_handle,
1567                                          struct dom_sid *domain_sid,
1568                                          struct USER_MODALS_INFO_2 *info2)
1569 {
1570         NTSTATUS status;
1571         struct samr_DomInfo5 dom_info5;
1572
1573         status = query_USER_MODALS_INFO_rpc(mem_ctx,
1574                                             pipe_cli,
1575                                             domain_handle,
1576                                             NULL,
1577                                             NULL,
1578                                             &dom_info5,
1579                                             NULL,
1580                                             NULL,
1581                                             NULL);
1582         NT_STATUS_NOT_OK_RETURN(status);
1583
1584         info2->usrmod2_domain_name =
1585                 talloc_strdup(mem_ctx, dom_info5.domain_name.string);
1586         info2->usrmod2_domain_id =
1587                 (struct domsid *)sid_dup_talloc(mem_ctx, domain_sid);
1588
1589         NT_STATUS_HAVE_NO_MEMORY(info2->usrmod2_domain_name);
1590         NT_STATUS_HAVE_NO_MEMORY(info2->usrmod2_domain_id);
1591
1592         return NT_STATUS_OK;
1593 }
1594
1595 /****************************************************************
1596 ****************************************************************/
1597
1598 static NTSTATUS query_USER_MODALS_INFO_3(TALLOC_CTX *mem_ctx,
1599                                          struct rpc_pipe_client *pipe_cli,
1600                                          struct policy_handle *domain_handle,
1601                                          struct USER_MODALS_INFO_3 *info3)
1602 {
1603         NTSTATUS status;
1604         struct samr_DomInfo12 dom_info12;
1605
1606         status = query_USER_MODALS_INFO_rpc(mem_ctx,
1607                                             pipe_cli,
1608                                             domain_handle,
1609                                             NULL,
1610                                             NULL,
1611                                             NULL,
1612                                             NULL,
1613                                             NULL,
1614                                             &dom_info12);
1615         NT_STATUS_NOT_OK_RETURN(status);
1616
1617         info3->usrmod3_lockout_duration =
1618                 nt_time_to_unix_abs(&dom_info12.lockout_duration);
1619         info3->usrmod3_lockout_observation_window =
1620                 nt_time_to_unix_abs(&dom_info12.lockout_window);
1621         info3->usrmod3_lockout_threshold =
1622                 dom_info12.lockout_threshold;
1623
1624         return NT_STATUS_OK;
1625 }
1626
1627 /****************************************************************
1628 ****************************************************************/
1629
1630 static NTSTATUS query_USER_MODALS_INFO_to_buffer(TALLOC_CTX *mem_ctx,
1631                                                  struct rpc_pipe_client *pipe_cli,
1632                                                  uint32_t level,
1633                                                  struct policy_handle *domain_handle,
1634                                                  struct dom_sid *domain_sid,
1635                                                  uint8_t **buffer)
1636 {
1637         NTSTATUS status;
1638
1639         struct USER_MODALS_INFO_0 info0;
1640         struct USER_MODALS_INFO_1 info1;
1641         struct USER_MODALS_INFO_2 info2;
1642         struct USER_MODALS_INFO_3 info3;
1643
1644         if (!buffer) {
1645                 return ERROR_INSUFFICIENT_BUFFER;
1646         }
1647
1648         switch (level) {
1649                 case 0:
1650                         status = query_USER_MODALS_INFO_0(mem_ctx,
1651                                                           pipe_cli,
1652                                                           domain_handle,
1653                                                           &info0);
1654                         NT_STATUS_NOT_OK_RETURN(status);
1655
1656                         *buffer = (uint8_t *)talloc_memdup(mem_ctx, &info0,
1657                                                            sizeof(info0));
1658                         break;
1659
1660                 case 1:
1661                         status = query_USER_MODALS_INFO_1(mem_ctx,
1662                                                           pipe_cli,
1663                                                           domain_handle,
1664                                                           &info1);
1665                         NT_STATUS_NOT_OK_RETURN(status);
1666
1667                         *buffer = (uint8_t *)talloc_memdup(mem_ctx, &info1,
1668                                                            sizeof(info1));
1669                         break;
1670                 case 2:
1671                         status = query_USER_MODALS_INFO_2(mem_ctx,
1672                                                           pipe_cli,
1673                                                           domain_handle,
1674                                                           domain_sid,
1675                                                           &info2);
1676                         NT_STATUS_NOT_OK_RETURN(status);
1677
1678                         *buffer = (uint8_t *)talloc_memdup(mem_ctx, &info2,
1679                                                            sizeof(info2));
1680                         break;
1681                 case 3:
1682                         status = query_USER_MODALS_INFO_3(mem_ctx,
1683                                                           pipe_cli,
1684                                                           domain_handle,
1685                                                           &info3);
1686                         NT_STATUS_NOT_OK_RETURN(status);
1687
1688                         *buffer = (uint8_t *)talloc_memdup(mem_ctx, &info3,
1689                                                            sizeof(info3));
1690                         break;
1691                 default:
1692                         break;
1693         }
1694
1695         NT_STATUS_HAVE_NO_MEMORY(*buffer);
1696
1697         return NT_STATUS_OK;
1698 }
1699
1700 /****************************************************************
1701 ****************************************************************/
1702
1703 WERROR NetUserModalsGet_r(struct libnetapi_ctx *ctx,
1704                           struct NetUserModalsGet *r)
1705 {
1706         struct cli_state *cli = NULL;
1707         struct rpc_pipe_client *pipe_cli = NULL;
1708         NTSTATUS status;
1709         WERROR werr;
1710
1711         struct policy_handle connect_handle, domain_handle;
1712         struct dom_sid2 *domain_sid = NULL;
1713         uint32_t access_mask = SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT;
1714
1715         ZERO_STRUCT(connect_handle);
1716         ZERO_STRUCT(domain_handle);
1717
1718         if (!r->out.buffer) {
1719                 return WERR_INVALID_PARAM;
1720         }
1721
1722         switch (r->in.level) {
1723                 case 0:
1724                         access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
1725                                        SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2;
1726                         break;
1727                 case 1:
1728                 case 2:
1729                         access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2;
1730                         break;
1731                 case 3:
1732                         access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1;
1733                         break;
1734                 default:
1735                         werr = WERR_UNKNOWN_LEVEL;
1736                         goto done;
1737         }
1738
1739         werr = libnetapi_open_pipe(ctx, r->in.server_name,
1740                                    &ndr_table_samr.syntax_id,
1741                                    &cli,
1742                                    &pipe_cli);
1743         if (!W_ERROR_IS_OK(werr)) {
1744                 goto done;
1745         }
1746
1747         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1748                                           SAMR_ACCESS_ENUM_DOMAINS |
1749                                           SAMR_ACCESS_OPEN_DOMAIN,
1750                                           access_mask,
1751                                           &connect_handle,
1752                                           &domain_handle,
1753                                           &domain_sid);
1754         if (!W_ERROR_IS_OK(werr)) {
1755                 goto done;
1756         }
1757
1758         /* 0:  1 + 3 */
1759         /* 1:  6 + 7 */
1760         /* 2:  5 */
1761         /* 3: 12 (DomainInfo2) */
1762
1763         status = query_USER_MODALS_INFO_to_buffer(ctx,
1764                                                   pipe_cli,
1765                                                   r->in.level,
1766                                                   &domain_handle,
1767                                                   domain_sid,
1768                                                   r->out.buffer);
1769         if (!NT_STATUS_IS_OK(status)) {
1770                 werr = ntstatus_to_werror(status);
1771                 goto done;
1772         }
1773
1774  done:
1775         if (!cli) {
1776                 return werr;
1777         }
1778
1779         if (ctx->disable_policy_handle_cache) {
1780                 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1781                 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1782         }
1783
1784         return werr;
1785 }
1786
1787 /****************************************************************
1788 ****************************************************************/
1789
1790 WERROR NetUserModalsGet_l(struct libnetapi_ctx *ctx,
1791                           struct NetUserModalsGet *r)
1792 {
1793         LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserModalsGet);
1794 }
1795
1796 /****************************************************************
1797 ****************************************************************/
1798
1799 static NTSTATUS set_USER_MODALS_INFO_rpc(TALLOC_CTX *mem_ctx,
1800                                          struct rpc_pipe_client *pipe_cli,
1801                                          struct policy_handle *domain_handle,
1802                                          struct samr_DomInfo1 *info1,
1803                                          struct samr_DomInfo3 *info3,
1804                                          struct samr_DomInfo12 *info12)
1805 {
1806         NTSTATUS status;
1807         union samr_DomainInfo dom_info;
1808
1809         if (info1) {
1810
1811                 ZERO_STRUCT(dom_info);
1812
1813                 dom_info.info1 = *info1;
1814
1815                 status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
1816                                                    domain_handle,
1817                                                    1,
1818                                                    &dom_info);
1819                 NT_STATUS_NOT_OK_RETURN(status);
1820         }
1821
1822         if (info3) {
1823
1824                 ZERO_STRUCT(dom_info);
1825
1826                 dom_info.info3 = *info3;
1827
1828                 status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
1829                                                    domain_handle,
1830                                                    3,
1831                                                    &dom_info);
1832
1833                 NT_STATUS_NOT_OK_RETURN(status);
1834         }
1835
1836         if (info12) {
1837
1838                 ZERO_STRUCT(dom_info);
1839
1840                 dom_info.info12 = *info12;
1841
1842                 status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
1843                                                    domain_handle,
1844                                                    12,
1845                                                    &dom_info);
1846
1847                 NT_STATUS_NOT_OK_RETURN(status);
1848         }
1849
1850         return NT_STATUS_OK;
1851 }
1852
1853 /****************************************************************
1854 ****************************************************************/
1855
1856 static NTSTATUS set_USER_MODALS_INFO_0_buffer(TALLOC_CTX *mem_ctx,
1857                                               struct rpc_pipe_client *pipe_cli,
1858                                               struct policy_handle *domain_handle,
1859                                               struct USER_MODALS_INFO_0 *info0)
1860 {
1861         NTSTATUS status;
1862         struct samr_DomInfo1 dom_info_1;
1863         struct samr_DomInfo3 dom_info_3;
1864
1865         status = query_USER_MODALS_INFO_rpc(mem_ctx,
1866                                             pipe_cli,
1867                                             domain_handle,
1868                                             &dom_info_1,
1869                                             &dom_info_3,
1870                                             NULL,
1871                                             NULL,
1872                                             NULL,
1873                                             NULL);
1874         NT_STATUS_NOT_OK_RETURN(status);
1875
1876         dom_info_1.min_password_length =
1877                 info0->usrmod0_min_passwd_len;
1878         dom_info_1.password_history_length =
1879                 info0->usrmod0_password_hist_len;
1880
1881         unix_to_nt_time_abs((NTTIME *)&dom_info_1.max_password_age,
1882                 info0->usrmod0_max_passwd_age);
1883         unix_to_nt_time_abs((NTTIME *)&dom_info_1.min_password_age,
1884                 info0->usrmod0_min_passwd_age);
1885
1886         unix_to_nt_time_abs(&dom_info_3.force_logoff_time,
1887                 info0->usrmod0_force_logoff);
1888
1889         return set_USER_MODALS_INFO_rpc(mem_ctx,
1890                                         pipe_cli,
1891                                         domain_handle,
1892                                         &dom_info_1,
1893                                         &dom_info_3,
1894                                         NULL);
1895 }
1896
1897 /****************************************************************
1898 ****************************************************************/
1899
1900 static NTSTATUS set_USER_MODALS_INFO_3_buffer(TALLOC_CTX *mem_ctx,
1901                                               struct rpc_pipe_client *pipe_cli,
1902                                               struct policy_handle *domain_handle,
1903                                               struct USER_MODALS_INFO_3 *info3)
1904 {
1905         NTSTATUS status;
1906         struct samr_DomInfo12 dom_info_12;
1907
1908         status = query_USER_MODALS_INFO_rpc(mem_ctx,
1909                                             pipe_cli,
1910                                             domain_handle,
1911                                             NULL,
1912                                             NULL,
1913                                             NULL,
1914                                             NULL,
1915                                             NULL,
1916                                             &dom_info_12);
1917         NT_STATUS_NOT_OK_RETURN(status);
1918
1919         unix_to_nt_time_abs((NTTIME *)&dom_info_12.lockout_duration,
1920                 info3->usrmod3_lockout_duration);
1921         unix_to_nt_time_abs((NTTIME *)&dom_info_12.lockout_window,
1922                 info3->usrmod3_lockout_observation_window);
1923         dom_info_12.lockout_threshold = info3->usrmod3_lockout_threshold;
1924
1925         return set_USER_MODALS_INFO_rpc(mem_ctx,
1926                                         pipe_cli,
1927                                         domain_handle,
1928                                         NULL,
1929                                         NULL,
1930                                         &dom_info_12);
1931 }
1932
1933 /****************************************************************
1934 ****************************************************************/
1935
1936 static NTSTATUS set_USER_MODALS_INFO_1001_buffer(TALLOC_CTX *mem_ctx,
1937                                                  struct rpc_pipe_client *pipe_cli,
1938                                                  struct policy_handle *domain_handle,
1939                                                  struct USER_MODALS_INFO_1001 *info1001)
1940 {
1941         NTSTATUS status;
1942         struct samr_DomInfo1 dom_info_1;
1943
1944         status = query_USER_MODALS_INFO_rpc(mem_ctx,
1945                                             pipe_cli,
1946                                             domain_handle,
1947                                             &dom_info_1,
1948                                             NULL,
1949                                             NULL,
1950                                             NULL,
1951                                             NULL,
1952                                             NULL);
1953         NT_STATUS_NOT_OK_RETURN(status);
1954
1955         dom_info_1.min_password_length =
1956                 info1001->usrmod1001_min_passwd_len;
1957
1958         return set_USER_MODALS_INFO_rpc(mem_ctx,
1959                                         pipe_cli,
1960                                         domain_handle,
1961                                         &dom_info_1,
1962                                         NULL,
1963                                         NULL);
1964 }
1965
1966 /****************************************************************
1967 ****************************************************************/
1968
1969 static NTSTATUS set_USER_MODALS_INFO_1002_buffer(TALLOC_CTX *mem_ctx,
1970                                                  struct rpc_pipe_client *pipe_cli,
1971                                                  struct policy_handle *domain_handle,
1972                                                  struct USER_MODALS_INFO_1002 *info1002)
1973 {
1974         NTSTATUS status;
1975         struct samr_DomInfo1 dom_info_1;
1976
1977         status = query_USER_MODALS_INFO_rpc(mem_ctx,
1978                                             pipe_cli,
1979                                             domain_handle,
1980                                             &dom_info_1,
1981                                             NULL,
1982                                             NULL,
1983                                             NULL,
1984                                             NULL,
1985                                             NULL);
1986         NT_STATUS_NOT_OK_RETURN(status);
1987
1988         unix_to_nt_time_abs((NTTIME *)&dom_info_1.max_password_age,
1989                 info1002->usrmod1002_max_passwd_age);
1990
1991         return set_USER_MODALS_INFO_rpc(mem_ctx,
1992                                         pipe_cli,
1993                                         domain_handle,
1994                                         &dom_info_1,
1995                                         NULL,
1996                                         NULL);
1997 }
1998
1999 /****************************************************************
2000 ****************************************************************/
2001
2002 static NTSTATUS set_USER_MODALS_INFO_1003_buffer(TALLOC_CTX *mem_ctx,
2003                                                  struct rpc_pipe_client *pipe_cli,
2004                                                  struct policy_handle *domain_handle,
2005                                                  struct USER_MODALS_INFO_1003 *info1003)
2006 {
2007         NTSTATUS status;
2008         struct samr_DomInfo1 dom_info_1;
2009
2010         status = query_USER_MODALS_INFO_rpc(mem_ctx,
2011                                             pipe_cli,
2012                                             domain_handle,
2013                                             &dom_info_1,
2014                                             NULL,
2015                                             NULL,
2016                                             NULL,
2017                                             NULL,
2018                                             NULL);
2019         NT_STATUS_NOT_OK_RETURN(status);
2020
2021         unix_to_nt_time_abs((NTTIME *)&dom_info_1.min_password_age,
2022                 info1003->usrmod1003_min_passwd_age);
2023
2024         return set_USER_MODALS_INFO_rpc(mem_ctx,
2025                                         pipe_cli,
2026                                         domain_handle,
2027                                         &dom_info_1,
2028                                         NULL,
2029                                         NULL);
2030 }
2031
2032 /****************************************************************
2033 ****************************************************************/
2034
2035 static NTSTATUS set_USER_MODALS_INFO_1004_buffer(TALLOC_CTX *mem_ctx,
2036                                                  struct rpc_pipe_client *pipe_cli,
2037                                                  struct policy_handle *domain_handle,
2038                                                  struct USER_MODALS_INFO_1004 *info1004)
2039 {
2040         NTSTATUS status;
2041         struct samr_DomInfo3 dom_info_3;
2042
2043         status = query_USER_MODALS_INFO_rpc(mem_ctx,
2044                                             pipe_cli,
2045                                             domain_handle,
2046                                             NULL,
2047                                             &dom_info_3,
2048                                             NULL,
2049                                             NULL,
2050                                             NULL,
2051                                             NULL);
2052         NT_STATUS_NOT_OK_RETURN(status);
2053
2054         unix_to_nt_time_abs(&dom_info_3.force_logoff_time,
2055                 info1004->usrmod1004_force_logoff);
2056
2057         return set_USER_MODALS_INFO_rpc(mem_ctx,
2058                                         pipe_cli,
2059                                         domain_handle,
2060                                         NULL,
2061                                         &dom_info_3,
2062                                         NULL);
2063 }
2064
2065 /****************************************************************
2066 ****************************************************************/
2067
2068 static NTSTATUS set_USER_MODALS_INFO_1005_buffer(TALLOC_CTX *mem_ctx,
2069                                                  struct rpc_pipe_client *pipe_cli,
2070                                                  struct policy_handle *domain_handle,
2071                                                  struct USER_MODALS_INFO_1005 *info1005)
2072 {
2073         NTSTATUS status;
2074         struct samr_DomInfo1 dom_info_1;
2075
2076         status = query_USER_MODALS_INFO_rpc(mem_ctx,
2077                                             pipe_cli,
2078                                             domain_handle,
2079                                             &dom_info_1,
2080                                             NULL,
2081                                             NULL,
2082                                             NULL,
2083                                             NULL,
2084                                             NULL);
2085         NT_STATUS_NOT_OK_RETURN(status);
2086
2087         dom_info_1.password_history_length =
2088                 info1005->usrmod1005_password_hist_len;
2089
2090         return set_USER_MODALS_INFO_rpc(mem_ctx,
2091                                         pipe_cli,
2092                                         domain_handle,
2093                                         &dom_info_1,
2094                                         NULL,
2095                                         NULL);
2096 }
2097
2098 /****************************************************************
2099 ****************************************************************/
2100
2101 static NTSTATUS set_USER_MODALS_INFO_buffer(TALLOC_CTX *mem_ctx,
2102                                             struct rpc_pipe_client *pipe_cli,
2103                                             uint32_t level,
2104                                             struct policy_handle *domain_handle,
2105                                             struct dom_sid *domain_sid,
2106                                             uint8_t *buffer)
2107 {
2108         struct USER_MODALS_INFO_0 *info0;
2109         struct USER_MODALS_INFO_3 *info3;
2110         struct USER_MODALS_INFO_1001 *info1001;
2111         struct USER_MODALS_INFO_1002 *info1002;
2112         struct USER_MODALS_INFO_1003 *info1003;
2113         struct USER_MODALS_INFO_1004 *info1004;
2114         struct USER_MODALS_INFO_1005 *info1005;
2115
2116         if (!buffer) {
2117                 return ERROR_INSUFFICIENT_BUFFER;
2118         }
2119
2120         switch (level) {
2121                 case 0:
2122                         info0 = (struct USER_MODALS_INFO_0 *)buffer;
2123                         return set_USER_MODALS_INFO_0_buffer(mem_ctx,
2124                                                              pipe_cli,
2125                                                              domain_handle,
2126                                                              info0);
2127                 case 3:
2128                         info3 = (struct USER_MODALS_INFO_3 *)buffer;
2129                         return set_USER_MODALS_INFO_3_buffer(mem_ctx,
2130                                                              pipe_cli,
2131                                                              domain_handle,
2132                                                              info3);
2133                 case 1001:
2134                         info1001 = (struct USER_MODALS_INFO_1001 *)buffer;
2135                         return set_USER_MODALS_INFO_1001_buffer(mem_ctx,
2136                                                                 pipe_cli,
2137                                                                 domain_handle,
2138                                                                 info1001);
2139                 case 1002:
2140                         info1002 = (struct USER_MODALS_INFO_1002 *)buffer;
2141                         return set_USER_MODALS_INFO_1002_buffer(mem_ctx,
2142                                                                 pipe_cli,
2143                                                                 domain_handle,
2144                                                                 info1002);
2145                 case 1003:
2146                         info1003 = (struct USER_MODALS_INFO_1003 *)buffer;
2147                         return set_USER_MODALS_INFO_1003_buffer(mem_ctx,
2148                                                                 pipe_cli,
2149                                                                 domain_handle,
2150                                                                 info1003);
2151                 case 1004:
2152                         info1004 = (struct USER_MODALS_INFO_1004 *)buffer;
2153                         return set_USER_MODALS_INFO_1004_buffer(mem_ctx,
2154                                                                 pipe_cli,
2155                                                                 domain_handle,
2156                                                                 info1004);
2157                 case 1005:
2158                         info1005 = (struct USER_MODALS_INFO_1005 *)buffer;
2159                         return set_USER_MODALS_INFO_1005_buffer(mem_ctx,
2160                                                                 pipe_cli,
2161                                                                 domain_handle,
2162                                                                 info1005);
2163
2164                 default:
2165                         break;
2166         }
2167
2168         return NT_STATUS_OK;
2169 }
2170
2171 /****************************************************************
2172 ****************************************************************/
2173
2174 WERROR NetUserModalsSet_r(struct libnetapi_ctx *ctx,
2175                           struct NetUserModalsSet *r)
2176 {
2177         struct cli_state *cli = NULL;
2178         struct rpc_pipe_client *pipe_cli = NULL;
2179         NTSTATUS status;
2180         WERROR werr;
2181
2182         struct policy_handle connect_handle, domain_handle;
2183         struct dom_sid2 *domain_sid = NULL;
2184         uint32_t access_mask = SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT;
2185
2186         ZERO_STRUCT(connect_handle);
2187         ZERO_STRUCT(domain_handle);
2188
2189         if (!r->in.buffer) {
2190                 return WERR_INVALID_PARAM;
2191         }
2192
2193         switch (r->in.level) {
2194                 case 0:
2195                         access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
2196                                        SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
2197                                        SAMR_DOMAIN_ACCESS_SET_INFO_1 |
2198                                        SAMR_DOMAIN_ACCESS_SET_INFO_2;
2199                         break;
2200                 case 3:
2201                 case 1001:
2202                 case 1002:
2203                 case 1003:
2204                 case 1005:
2205                         access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
2206                                        SAMR_DOMAIN_ACCESS_SET_INFO_1;
2207                         break;
2208                 case 1004:
2209                         access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
2210                                        SAMR_DOMAIN_ACCESS_SET_INFO_2;
2211                         break;
2212                 case 1:
2213                 case 2:
2214                 case 1006:
2215                 case 1007:
2216                         werr = WERR_NOT_SUPPORTED;
2217                         break;
2218                 default:
2219                         werr = WERR_UNKNOWN_LEVEL;
2220                         goto done;
2221         }
2222
2223         werr = libnetapi_open_pipe(ctx, r->in.server_name,
2224                                    &ndr_table_samr.syntax_id,
2225                                    &cli,
2226                                    &pipe_cli);
2227         if (!W_ERROR_IS_OK(werr)) {
2228                 goto done;
2229         }
2230
2231         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
2232                                           SAMR_ACCESS_ENUM_DOMAINS |
2233                                           SAMR_ACCESS_OPEN_DOMAIN,
2234                                           access_mask,
2235                                           &connect_handle,
2236                                           &domain_handle,
2237                                           &domain_sid);
2238         if (!W_ERROR_IS_OK(werr)) {
2239                 goto done;
2240         }
2241
2242         status = set_USER_MODALS_INFO_buffer(ctx,
2243                                              pipe_cli,
2244                                              r->in.level,
2245                                              &domain_handle,
2246                                              domain_sid,
2247                                              r->in.buffer);
2248         if (!NT_STATUS_IS_OK(status)) {
2249                 werr = ntstatus_to_werror(status);
2250                 goto done;
2251         }
2252
2253  done:
2254         if (!cli) {
2255                 return werr;
2256         }
2257
2258         if (ctx->disable_policy_handle_cache) {
2259                 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
2260                 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
2261         }
2262
2263         return werr;
2264 }
2265
2266 /****************************************************************
2267 ****************************************************************/
2268
2269 WERROR NetUserModalsSet_l(struct libnetapi_ctx *ctx,
2270                           struct NetUserModalsSet *r)
2271 {
2272         LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserModalsSet);
2273 }