source/rpc_client/cli_samr.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    RPC pipe client
   4    Copyright (C) Tim Potter                        2000-2001,
   5    Copyright (C) Andrew Tridgell              1992-1997,2000,
   6    Copyright (C) Rafal Szczesniak                       2002.
   7    Copyright (C) Jeremy Allison                         2005.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25
  26 /* Connect to SAMR database */
  27
  28 NTSTATUS rpccli_samr_connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
  29                              uint32 access_mask, POLICY_HND *connect_pol)
  30 {
  31         prs_struct qbuf, rbuf;
  32         SAMR_Q_CONNECT q;
  33         SAMR_R_CONNECT r;
  34         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
  35
  36         DEBUG(10,("cli_samr_connect to %s\n", cli->cli->desthost));
  37
  38         ZERO_STRUCT(q);
  39         ZERO_STRUCT(r);
  40
  41         /* Marshall data and send request */
  42
  43         init_samr_q_connect(&q, cli->cli->desthost, access_mask);
  44
  45         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CONNECT,
  46                 q, r,
  47                 qbuf, rbuf,
  48                 samr_io_q_connect,
  49                 samr_io_r_connect,
  50                 NT_STATUS_UNSUCCESSFUL);
  51         /* Return output parameters */
  52
  53         if (NT_STATUS_IS_OK(result = r.status)) {
  54                 *connect_pol = r.connect_pol;
  55         }
  56
  57         return result;
  58 }
  59
  60 /* Connect to SAMR database */
  61
  62 NTSTATUS rpccli_samr_connect4(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
  63                            uint32 access_mask, POLICY_HND *connect_pol)
  64 {
  65         prs_struct qbuf, rbuf;
  66         SAMR_Q_CONNECT4 q;
  67         SAMR_R_CONNECT4 r;
  68         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
  69
  70         ZERO_STRUCT(q);
  71         ZERO_STRUCT(r);
  72
  73         /* Marshall data and send request */
  74
  75         init_samr_q_connect4(&q, cli->cli->desthost, access_mask);
  76
  77         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CONNECT4,
  78                 q, r,
  79                 qbuf, rbuf,
  80                 samr_io_q_connect4,
  81                 samr_io_r_connect4,
  82                 NT_STATUS_UNSUCCESSFUL);
  83
  84         /* Return output parameters */
  85
  86         if (NT_STATUS_IS_OK(result = r.status)) {
  87                 *connect_pol = r.connect_pol;
  88         }
  89
  90         return result;
  91 }
  92
  93 /* Close SAMR handle */
  94
  95 NTSTATUS rpccli_samr_close(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
  96                            POLICY_HND *connect_pol)
  97 {
  98         prs_struct qbuf, rbuf;
  99         SAMR_Q_CLOSE_HND q;
 100         SAMR_R_CLOSE_HND r;
 101         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 102
 103         DEBUG(10,("cli_samr_close\n"));
 104
 105         ZERO_STRUCT(q);
 106         ZERO_STRUCT(r);
 107
 108         /* Marshall data and send request */
 109
 110         init_samr_q_close_hnd(&q, connect_pol);
 111
 112         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CLOSE_HND,
 113                 q, r,
 114                 qbuf, rbuf,
 115                 samr_io_q_close_hnd,
 116                 samr_io_r_close_hnd,
 117                 NT_STATUS_UNSUCCESSFUL);
 118
 119         /* Return output parameters */
 120
 121         if (NT_STATUS_IS_OK(result = r.status)) {
 122                 *connect_pol = r.pol;
 123         }
 124
 125         return result;
 126 }
 127
 128 /* Open handle on a domain */
 129
 130 NTSTATUS rpccli_samr_open_domain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 131                                  POLICY_HND *connect_pol, uint32 access_mask,
 132                                  const DOM_SID *domain_sid,
 133                                  POLICY_HND *domain_pol)
 134 {
 135         prs_struct qbuf, rbuf;
 136         SAMR_Q_OPEN_DOMAIN q;
 137         SAMR_R_OPEN_DOMAIN r;
 138         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 139
 140         DEBUG(10,("cli_samr_open_domain with sid %s\n", sid_string_static(domain_sid) ));
 141
 142         ZERO_STRUCT(q);
 143         ZERO_STRUCT(r);
 144
 145         /* Marshall data and send request */
 146
 147         init_samr_q_open_domain(&q, connect_pol, access_mask, domain_sid);
 148
 149         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_DOMAIN,
 150                 q, r,
 151                 qbuf, rbuf,
 152                 samr_io_q_open_domain,
 153                 samr_io_r_open_domain,
 154                 NT_STATUS_UNSUCCESSFUL);
 155
 156         /* Return output parameters */
 157
 158         if (NT_STATUS_IS_OK(result = r.status)) {
 159                 *domain_pol = r.domain_pol;
 160         }
 161
 162         return result;
 163 }
 164
 165 NTSTATUS rpccli_samr_open_user(struct rpc_pipe_client *cli,
 166                                TALLOC_CTX *mem_ctx,
 167                                POLICY_HND *domain_pol, uint32 access_mask,
 168                                uint32 user_rid, POLICY_HND *user_pol)
 169 {
 170         prs_struct qbuf, rbuf;
 171         SAMR_Q_OPEN_USER q;
 172         SAMR_R_OPEN_USER r;
 173         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 174
 175         DEBUG(10,("cli_samr_open_user with rid 0x%x\n", user_rid ));
 176
 177         ZERO_STRUCT(q);
 178         ZERO_STRUCT(r);
 179
 180         /* Marshall data and send request */
 181
 182         init_samr_q_open_user(&q, domain_pol, access_mask, user_rid);
 183
 184         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_USER,
 185                 q, r,
 186                 qbuf, rbuf,
 187                 samr_io_q_open_user,
 188                 samr_io_r_open_user,
 189                 NT_STATUS_UNSUCCESSFUL);
 190
 191         /* Return output parameters */
 192
 193         if (NT_STATUS_IS_OK(result = r.status)) {
 194                 *user_pol = r.user_pol;
 195         }
 196
 197         return result;
 198 }
 199
 200 /* Open handle on a group */
 201
 202 NTSTATUS rpccli_samr_open_group(struct rpc_pipe_client *cli,
 203                                 TALLOC_CTX *mem_ctx,
 204                                 POLICY_HND *domain_pol, uint32 access_mask,
 205                                 uint32 group_rid, POLICY_HND *group_pol)
 206 {
 207         prs_struct qbuf, rbuf;
 208         SAMR_Q_OPEN_GROUP q;
 209         SAMR_R_OPEN_GROUP r;
 210         NTSTATUS result =  NT_STATUS_UNSUCCESSFUL;
 211
 212         DEBUG(10,("cli_samr_open_group with rid 0x%x\n", group_rid ));
 213
 214         ZERO_STRUCT(q);
 215         ZERO_STRUCT(r);
 216
 217         /* Marshall data and send request */
 218
 219         init_samr_q_open_group(&q, domain_pol, access_mask, group_rid);
 220
 221         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_GROUP,
 222                 q, r,
 223                 qbuf, rbuf,
 224                 samr_io_q_open_group,
 225                 samr_io_r_open_group,
 226                 NT_STATUS_UNSUCCESSFUL);
 227
 228         /* Return output parameters */
 229
 230         if (NT_STATUS_IS_OK(result = r.status)) {
 231                 *group_pol = r.pol;
 232         }
 233
 234         return result;
 235 }
 236
 237 /* Create domain group */
 238
 239 NTSTATUS rpccli_samr_create_dom_group(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 240                                    POLICY_HND *domain_pol,
 241                                    const char *group_name,
 242                                    uint32 access_mask, POLICY_HND *group_pol)
 243 {
 244         prs_struct qbuf, rbuf;
 245         SAMR_Q_CREATE_DOM_GROUP q;
 246         SAMR_R_CREATE_DOM_GROUP r;
 247         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 248
 249         DEBUG(10,("cli_samr_create_dom_group\n"));
 250
 251         ZERO_STRUCT(q);
 252         ZERO_STRUCT(r);
 253
 254         /* Marshall data and send request */
 255
 256         init_samr_q_create_dom_group(&q, domain_pol, group_name, access_mask);
 257
 258         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CREATE_DOM_GROUP,
 259                 q, r,
 260                 qbuf, rbuf,
 261                 samr_io_q_create_dom_group,
 262                 samr_io_r_create_dom_group,
 263                 NT_STATUS_UNSUCCESSFUL);
 264
 265         /* Return output parameters */
 266
 267         result = r.status;
 268
 269         if (NT_STATUS_IS_OK(result))
 270                 *group_pol = r.pol;
 271
 272         return result;
 273 }
 274
 275 /* Add a domain group member */
 276
 277 NTSTATUS rpccli_samr_add_groupmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 278                                POLICY_HND *group_pol, uint32 rid)
 279 {
 280         prs_struct qbuf, rbuf;
 281         SAMR_Q_ADD_GROUPMEM q;
 282         SAMR_R_ADD_GROUPMEM r;
 283         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 284
 285         DEBUG(10,("cli_samr_add_groupmem\n"));
 286
 287         ZERO_STRUCT(q);
 288         ZERO_STRUCT(r);
 289
 290         /* Marshall data and send request */
 291
 292         init_samr_q_add_groupmem(&q, group_pol, rid);
 293
 294         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ADD_GROUPMEM,
 295                 q, r,
 296                 qbuf, rbuf,
 297                 samr_io_q_add_groupmem,
 298                 samr_io_r_add_groupmem,
 299                 NT_STATUS_UNSUCCESSFUL);
 300
 301         /* Return output parameters */
 302
 303         result = r.status;
 304
 305         return result;
 306 }
 307
 308 /* Delete a domain group member */
 309
 310 NTSTATUS rpccli_samr_del_groupmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 311                                POLICY_HND *group_pol, uint32 rid)
 312 {
 313         prs_struct qbuf, rbuf;
 314         SAMR_Q_DEL_GROUPMEM q;
 315         SAMR_R_DEL_GROUPMEM r;
 316         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 317
 318         DEBUG(10,("cli_samr_del_groupmem\n"));
 319
 320         ZERO_STRUCT(q);
 321         ZERO_STRUCT(r);
 322
 323         /* Marshall data and send request */
 324
 325         init_samr_q_del_groupmem(&q, group_pol, rid);
 326
 327         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DEL_GROUPMEM,
 328                 q, r,
 329                 qbuf, rbuf,
 330                 samr_io_q_del_groupmem,
 331                 samr_io_r_del_groupmem,
 332                 NT_STATUS_UNSUCCESSFUL);
 333
 334         /* Return output parameters */
 335
 336         result = r.status;
 337
 338         return result;
 339 }
 340
 341 /* Query user info */
 342
 343 NTSTATUS rpccli_samr_query_userinfo(struct rpc_pipe_client *cli,
 344                                     TALLOC_CTX *mem_ctx,
 345                                     const POLICY_HND *user_pol,
 346                                     uint16 switch_value,
 347                                     SAM_USERINFO_CTR **ctr)
 348 {
 349         prs_struct qbuf, rbuf;
 350         SAMR_Q_QUERY_USERINFO q;
 351         SAMR_R_QUERY_USERINFO r;
 352         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 353
 354         DEBUG(10,("cli_samr_query_userinfo\n"));
 355
 356         ZERO_STRUCT(q);
 357         ZERO_STRUCT(r);
 358
 359         /* Marshall data and send request */
 360
 361         init_samr_q_query_userinfo(&q, user_pol, switch_value);
 362
 363         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_USERINFO,
 364                 q, r,
 365                 qbuf, rbuf,
 366                 samr_io_q_query_userinfo,
 367                 samr_io_r_query_userinfo,
 368                 NT_STATUS_UNSUCCESSFUL);
 369
 370         /* Return output parameters */
 371
 372         result = r.status;
 373         *ctr = r.ctr;
 374
 375         return result;
 376 }
 377
 378 /* Set group info */
 379
 380 NTSTATUS rpccli_samr_set_groupinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 381                                 POLICY_HND *group_pol, GROUP_INFO_CTR *ctr)
 382 {
 383         prs_struct qbuf, rbuf;
 384         SAMR_Q_SET_GROUPINFO q;
 385         SAMR_R_SET_GROUPINFO r;
 386         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 387
 388         DEBUG(10,("cli_samr_set_groupinfo\n"));
 389
 390         ZERO_STRUCT(q);
 391         ZERO_STRUCT(r);
 392
 393         /* Marshall data and send request */
 394
 395         init_samr_q_set_groupinfo(&q, group_pol, ctr);
 396
 397         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_GROUPINFO,
 398                 q, r,
 399                 qbuf, rbuf,
 400                 samr_io_q_set_groupinfo,
 401                 samr_io_r_set_groupinfo,
 402                 NT_STATUS_UNSUCCESSFUL);
 403
 404         /* Return output parameters */
 405
 406         result = r.status;
 407
 408         return result;
 409 }
 410
 411 /* Query group info */
 412
 413 NTSTATUS rpccli_samr_query_groupinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 414                                   POLICY_HND *group_pol, uint32 info_level,
 415                                   GROUP_INFO_CTR **ctr)
 416 {
 417         prs_struct qbuf, rbuf;
 418         SAMR_Q_QUERY_GROUPINFO q;
 419         SAMR_R_QUERY_GROUPINFO r;
 420         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 421
 422         DEBUG(10,("cli_samr_query_groupinfo\n"));
 423
 424         ZERO_STRUCT(q);
 425         ZERO_STRUCT(r);
 426
 427         /* Marshall data and send request */
 428
 429         init_samr_q_query_groupinfo(&q, group_pol, info_level);
 430
 431         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_GROUPINFO,
 432                 q, r,
 433                 qbuf, rbuf,
 434                 samr_io_q_query_groupinfo,
 435                 samr_io_r_query_groupinfo,
 436                 NT_STATUS_UNSUCCESSFUL);
 437
 438         *ctr = r.ctr;
 439
 440         /* Return output parameters */
 441
 442         result = r.status;
 443
 444         return result;
 445 }
 446
 447 /* Query user groups */
 448
 449 NTSTATUS rpccli_samr_query_usergroups(struct rpc_pipe_client *cli,
 450                                       TALLOC_CTX *mem_ctx,
 451                                       POLICY_HND *user_pol,
 452                                       uint32 *num_groups,
 453                                       DOM_GID **gid)
 454 {
 455         prs_struct qbuf, rbuf;
 456         SAMR_Q_QUERY_USERGROUPS q;
 457         SAMR_R_QUERY_USERGROUPS r;
 458         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 459
 460         DEBUG(10,("cli_samr_query_usergroups\n"));
 461
 462         ZERO_STRUCT(q);
 463         ZERO_STRUCT(r);
 464
 465         /* Marshall data and send request */
 466
 467         init_samr_q_query_usergroups(&q, user_pol);
 468
 469         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_USERGROUPS,
 470                 q, r,
 471                 qbuf, rbuf,
 472                 samr_io_q_query_usergroups,
 473                 samr_io_r_query_usergroups,
 474                 NT_STATUS_UNSUCCESSFUL);
 475
 476         /* Return output parameters */
 477
 478         if (NT_STATUS_IS_OK(result = r.status)) {
 479                 *num_groups = r.num_entries;
 480                 *gid = r.gid;
 481         }
 482
 483         return result;
 484 }
 485
 486 /* Set alias info */
 487
 488 NTSTATUS rpccli_samr_set_aliasinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 489                                 POLICY_HND *alias_pol, ALIAS_INFO_CTR *ctr)
 490 {
 491         prs_struct qbuf, rbuf;
 492         SAMR_Q_SET_ALIASINFO q;
 493         SAMR_R_SET_ALIASINFO r;
 494         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 495
 496         DEBUG(10,("cli_samr_set_aliasinfo\n"));
 497
 498         ZERO_STRUCT(q);
 499         ZERO_STRUCT(r);
 500
 501         /* Marshall data and send request */
 502
 503         init_samr_q_set_aliasinfo(&q, alias_pol, ctr);
 504
 505         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_ALIASINFO,
 506                 q, r,
 507                 qbuf, rbuf,
 508                 samr_io_q_set_aliasinfo,
 509                 samr_io_r_set_aliasinfo,
 510                 NT_STATUS_UNSUCCESSFUL);
 511
 512         /* Return output parameters */
 513
 514         result = r.status;
 515
 516         return result;
 517 }
 518
 519 /* Query user aliases */
 520
 521 NTSTATUS rpccli_samr_query_useraliases(struct rpc_pipe_client *cli,
 522                                        TALLOC_CTX *mem_ctx,
 523                                        POLICY_HND *dom_pol, uint32 num_sids,
 524                                        DOM_SID2 *sid,
 525                                        uint32 *num_aliases, uint32 **als_rids)
 526 {
 527         prs_struct qbuf, rbuf;
 528         SAMR_Q_QUERY_USERALIASES q;
 529         SAMR_R_QUERY_USERALIASES r;
 530         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 531         int i;
 532         uint32 *sid_ptrs;
 533
 534         DEBUG(10,("cli_samr_query_useraliases\n"));
 535
 536         ZERO_STRUCT(q);
 537         ZERO_STRUCT(r);
 538
 539         sid_ptrs = TALLOC_ARRAY(mem_ctx, uint32, num_sids);
 540         if (sid_ptrs == NULL)
 541                 return NT_STATUS_NO_MEMORY;
 542
 543         for (i=0; i<num_sids; i++)
 544                 sid_ptrs[i] = 1;
 545
 546         /* Marshall data and send request */
 547
 548         init_samr_q_query_useraliases(&q, dom_pol, num_sids, sid_ptrs, sid);
 549
 550         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_USERALIASES,
 551                 q, r,
 552                 qbuf, rbuf,
 553                 samr_io_q_query_useraliases,
 554                 samr_io_r_query_useraliases,
 555                 NT_STATUS_UNSUCCESSFUL);
 556
 557         /* Return output parameters */
 558
 559         if (NT_STATUS_IS_OK(result = r.status)) {
 560                 *num_aliases = r.num_entries;
 561                 *als_rids = r.rid;
 562         }
 563
 564         return result;
 565 }
 566
 567 /* Query user groups */
 568
 569 NTSTATUS rpccli_samr_query_groupmem(struct rpc_pipe_client *cli,
 570                                     TALLOC_CTX *mem_ctx,
 571                                     POLICY_HND *group_pol, uint32 *num_mem,
 572                                     uint32 **rid, uint32 **attr)
 573 {
 574         prs_struct qbuf, rbuf;
 575         SAMR_Q_QUERY_GROUPMEM q;
 576         SAMR_R_QUERY_GROUPMEM r;
 577         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 578
 579         DEBUG(10,("cli_samr_query_groupmem\n"));
 580
 581         ZERO_STRUCT(q);
 582         ZERO_STRUCT(r);
 583
 584         /* Marshall data and send request */
 585
 586         init_samr_q_query_groupmem(&q, group_pol);
 587
 588         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_GROUPMEM,
 589                 q, r,
 590                 qbuf, rbuf,
 591                 samr_io_q_query_groupmem,
 592                 samr_io_r_query_groupmem,
 593                 NT_STATUS_UNSUCCESSFUL);
 594
 595         /* Return output parameters */
 596
 597         if (NT_STATUS_IS_OK(result = r.status)) {
 598                 *num_mem = r.num_entries;
 599                 *rid = r.rid;
 600                 *attr = r.attr;
 601         }
 602
 603         return result;
 604 }
 605
 606 /**
 607  * Enumerate domain users
 608  *
 609  * @param cli client state structure
 610  * @param mem_ctx talloc context
 611  * @param pol opened domain policy handle
 612  * @param start_idx starting index of enumeration, returns context for
 613                     next enumeration
 614  * @param acb_mask account control bit mask (to enumerate some particular
 615  *                 kind of accounts)
 616  * @param size max acceptable size of response
 617  * @param dom_users returned array of domain user names
 618  * @param rids returned array of domain user RIDs
 619  * @param num_dom_users numer returned entries
 620  *
 621  * @return NTSTATUS returned in rpc response
 622  **/
 623
 624 NTSTATUS rpccli_samr_enum_dom_users(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 625                                  POLICY_HND *pol, uint32 *start_idx, uint32 acb_mask,
 626                                  uint32 size, char ***dom_users, uint32 **rids,
 627                                  uint32 *num_dom_users)
 628 {
 629         prs_struct qbuf;
 630         prs_struct rbuf;
 631         SAMR_Q_ENUM_DOM_USERS q;
 632         SAMR_R_ENUM_DOM_USERS r;
 633         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 634         int i;
 635
 636         DEBUG(10,("cli_samr_enum_dom_users starting at index %u\n", (unsigned int)*start_idx));
 637
 638         ZERO_STRUCT(q);
 639         ZERO_STRUCT(r);
 640
 641         /* always init this */
 642         *num_dom_users = 0;
 643
 644         /* Fill query structure with parameters */
 645
 646         init_samr_q_enum_dom_users(&q, pol, *start_idx, acb_mask, size);
 647
 648         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ENUM_DOM_USERS,
 649                 q, r,
 650                 qbuf, rbuf,
 651                 samr_io_q_enum_dom_users,
 652                 samr_io_r_enum_dom_users,
 653                 NT_STATUS_UNSUCCESSFUL);
 654
 655         result = r.status;
 656
 657         if (!NT_STATUS_IS_OK(result) &&
 658             NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES))
 659                 goto done;
 660
 661         *start_idx = r.next_idx;
 662         *num_dom_users = r.num_entries2;
 663
 664         if (r.num_entries2) {
 665                 /* allocate memory needed to return received data */
 666                 *rids = TALLOC_ARRAY(mem_ctx, uint32, r.num_entries2);
 667                 if (!*rids) {
 668                         DEBUG(0, ("Error in cli_samr_enum_dom_users(): out of memory\n"));
 669                         return NT_STATUS_NO_MEMORY;
 670                 }
 671
 672                 *dom_users = TALLOC_ARRAY(mem_ctx, char*, r.num_entries2);
 673                 if (!*dom_users) {
 674                         DEBUG(0, ("Error in cli_samr_enum_dom_users(): out of memory\n"));
 675                         return NT_STATUS_NO_MEMORY;
 676                 }
 677
 678                 /* fill output buffers with rpc response */
 679                 for (i = 0; i < r.num_entries2; i++) {
 680                         fstring conv_buf;
 681
 682                         (*rids)[i] = r.sam[i].rid;
 683                         unistr2_to_ascii(conv_buf, &(r.uni_acct_name[i]), sizeof(conv_buf) - 1);
 684                         (*dom_users)[i] = talloc_strdup(mem_ctx, conv_buf);
 685                 }
 686         }
 687
 688 done:
 689         return result;
 690 }
 691
 692 /* Enumerate domain groups */
 693
 694 NTSTATUS rpccli_samr_enum_dom_groups(struct rpc_pipe_client *cli,
 695                                      TALLOC_CTX *mem_ctx,
 696                                      POLICY_HND *pol, uint32 *start_idx,
 697                                      uint32 size, struct acct_info **dom_groups,
 698                                      uint32 *num_dom_groups)
 699 {
 700         prs_struct qbuf, rbuf;
 701         SAMR_Q_ENUM_DOM_GROUPS q;
 702         SAMR_R_ENUM_DOM_GROUPS r;
 703         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 704         uint32 name_idx, i;
 705
 706         DEBUG(10,("cli_samr_enum_dom_groups starting at index %u\n", (unsigned int)*start_idx));
 707
 708         ZERO_STRUCT(q);
 709         ZERO_STRUCT(r);
 710
 711         /* Marshall data and send request */
 712
 713         init_samr_q_enum_dom_groups(&q, pol, *start_idx, size);
 714
 715         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ENUM_DOM_GROUPS,
 716                 q, r,
 717                 qbuf, rbuf,
 718                 samr_io_q_enum_dom_groups,
 719                 samr_io_r_enum_dom_groups,
 720                 NT_STATUS_UNSUCCESSFUL);
 721
 722         /* Return output parameters */
 723
 724         result = r.status;
 725
 726         if (!NT_STATUS_IS_OK(result) &&
 727             NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES))
 728                 goto done;
 729
 730         *num_dom_groups = r.num_entries2;
 731
 732         if (*num_dom_groups == 0)
 733                 goto done;
 734
 735         if (!((*dom_groups) = TALLOC_ARRAY(mem_ctx, struct acct_info, *num_dom_groups))) {
 736                 result = NT_STATUS_NO_MEMORY;
 737                 goto done;
 738         }
 739
 740         memset(*dom_groups, 0, sizeof(struct acct_info) * (*num_dom_groups));
 741
 742         name_idx = 0;
 743
 744         for (i = 0; i < *num_dom_groups; i++) {
 745
 746                 (*dom_groups)[i].rid = r.sam[i].rid;
 747
 748                 if (r.sam[i].hdr_name.buffer) {
 749                         unistr2_to_ascii((*dom_groups)[i].acct_name,
 750                                          &r.uni_grp_name[name_idx],
 751                                          sizeof(fstring) - 1);
 752                         name_idx++;
 753                 }
 754
 755                 *start_idx = r.next_idx;
 756         }
 757
 758  done:
 759         return result;
 760 }
 761
 762 /* Enumerate domain groups */
 763
 764 NTSTATUS rpccli_samr_enum_als_groups(struct rpc_pipe_client *cli,
 765                                      TALLOC_CTX *mem_ctx,
 766                                      POLICY_HND *pol, uint32 *start_idx,
 767                                      uint32 size, struct acct_info **dom_aliases,
 768                                      uint32 *num_dom_aliases)
 769 {
 770         prs_struct qbuf, rbuf;
 771         SAMR_Q_ENUM_DOM_ALIASES q;
 772         SAMR_R_ENUM_DOM_ALIASES r;
 773         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 774         uint32 name_idx, i;
 775
 776         DEBUG(10,("cli_samr_enum_als_groups starting at index %u\n", (unsigned int)*start_idx));
 777
 778         ZERO_STRUCT(q);
 779         ZERO_STRUCT(r);
 780
 781         /* Marshall data and send request */
 782
 783         init_samr_q_enum_dom_aliases(&q, pol, *start_idx, size);
 784
 785         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ENUM_DOM_ALIASES,
 786                 q, r,
 787                 qbuf, rbuf,
 788                 samr_io_q_enum_dom_aliases,
 789                 samr_io_r_enum_dom_aliases,
 790                 NT_STATUS_UNSUCCESSFUL);
 791
 792         /* Return output parameters */
 793
 794         result = r.status;
 795
 796         if (!NT_STATUS_IS_OK(result) &&
 797             NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) {
 798                 goto done;
 799         }
 800
 801         *num_dom_aliases = r.num_entries2;
 802
 803         if (*num_dom_aliases == 0)
 804                 goto done;
 805
 806         if (!((*dom_aliases) = TALLOC_ARRAY(mem_ctx, struct acct_info, *num_dom_aliases))) {
 807                 result = NT_STATUS_NO_MEMORY;
 808                 goto done;
 809         }
 810
 811         memset(*dom_aliases, 0, sizeof(struct acct_info) * *num_dom_aliases);
 812
 813         name_idx = 0;
 814
 815         for (i = 0; i < *num_dom_aliases; i++) {
 816
 817                 (*dom_aliases)[i].rid = r.sam[i].rid;
 818
 819                 if (r.sam[i].hdr_name.buffer) {
 820                         unistr2_to_ascii((*dom_aliases)[i].acct_name,
 821                                          &r.uni_grp_name[name_idx],
 822                                          sizeof(fstring) - 1);
 823                         name_idx++;
 824                 }
 825
 826                 *start_idx = r.next_idx;
 827         }
 828
 829  done:
 830         return result;
 831 }
 832
 833 /* Query alias members */
 834
 835 NTSTATUS rpccli_samr_query_aliasmem(struct rpc_pipe_client *cli,
 836                                     TALLOC_CTX *mem_ctx,
 837                                     POLICY_HND *alias_pol, uint32 *num_mem,
 838                                     DOM_SID **sids)
 839 {
 840         prs_struct qbuf, rbuf;
 841         SAMR_Q_QUERY_ALIASMEM q;
 842         SAMR_R_QUERY_ALIASMEM r;
 843         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 844         uint32 i;
 845
 846         DEBUG(10,("cli_samr_query_aliasmem\n"));
 847
 848         ZERO_STRUCT(q);
 849         ZERO_STRUCT(r);
 850
 851         /* Marshall data and send request */
 852
 853         init_samr_q_query_aliasmem(&q, alias_pol);
 854
 855         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_ALIASMEM,
 856                 q, r,
 857                 qbuf, rbuf,
 858                 samr_io_q_query_aliasmem,
 859                 samr_io_r_query_aliasmem,
 860                 NT_STATUS_UNSUCCESSFUL);
 861
 862         /* Return output parameters */
 863
 864         if (!NT_STATUS_IS_OK(result = r.status)) {
 865                 goto done;
 866         }
 867
 868         *num_mem = r.num_sids;
 869
 870         if (*num_mem == 0) {
 871                 *sids = NULL;
 872                 result = NT_STATUS_OK;
 873                 goto done;
 874         }
 875
 876         if (!(*sids = TALLOC_ARRAY(mem_ctx, DOM_SID, *num_mem))) {
 877                 result = NT_STATUS_UNSUCCESSFUL;
 878                 goto done;
 879         }
 880
 881         for (i = 0; i < *num_mem; i++) {
 882                 (*sids)[i] = r.sid[i].sid;
 883         }
 884
 885  done:
 886         return result;
 887 }
 888
 889 /* Open handle on an alias */
 890
 891 NTSTATUS rpccli_samr_open_alias(struct rpc_pipe_client *cli,
 892                                 TALLOC_CTX *mem_ctx,
 893                                 POLICY_HND *domain_pol, uint32 access_mask,
 894                                 uint32 alias_rid, POLICY_HND *alias_pol)
 895 {
 896         prs_struct qbuf, rbuf;
 897         SAMR_Q_OPEN_ALIAS q;
 898         SAMR_R_OPEN_ALIAS r;
 899         NTSTATUS result;
 900
 901         DEBUG(10,("cli_samr_open_alias with rid 0x%x\n", alias_rid));
 902
 903         ZERO_STRUCT(q);
 904         ZERO_STRUCT(r);
 905
 906         /* Marshall data and send request */
 907
 908         init_samr_q_open_alias(&q, domain_pol, access_mask, alias_rid);
 909
 910         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_ALIAS,
 911                 q, r,
 912                 qbuf, rbuf,
 913                 samr_io_q_open_alias,
 914                 samr_io_r_open_alias,
 915                 NT_STATUS_UNSUCCESSFUL);
 916
 917         /* Return output parameters */
 918
 919         if (NT_STATUS_IS_OK(result = r.status)) {
 920                 *alias_pol = r.pol;
 921         }
 922
 923         return result;
 924 }
 925
 926 /* Create an alias */
 927
 928 NTSTATUS rpccli_samr_create_dom_alias(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 929                                    POLICY_HND *domain_pol, const char *name,
 930                                    POLICY_HND *alias_pol)
 931 {
 932         prs_struct qbuf, rbuf;
 933         SAMR_Q_CREATE_DOM_ALIAS q;
 934         SAMR_R_CREATE_DOM_ALIAS r;
 935         NTSTATUS result;
 936
 937         DEBUG(10,("cli_samr_create_dom_alias named %s\n", name));
 938
 939         ZERO_STRUCT(q);
 940         ZERO_STRUCT(r);
 941
 942         /* Marshall data and send request */
 943
 944         init_samr_q_create_dom_alias(&q, domain_pol, name);
 945
 946         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CREATE_DOM_ALIAS,
 947                 q, r,
 948                 qbuf, rbuf,
 949                 samr_io_q_create_dom_alias,
 950                 samr_io_r_create_dom_alias,
 951                 NT_STATUS_UNSUCCESSFUL);
 952
 953         /* Return output parameters */
 954
 955         if (NT_STATUS_IS_OK(result = r.status)) {
 956                 *alias_pol = r.alias_pol;
 957         }
 958
 959         return result;
 960 }
 961
 962 /* Add an alias member */
 963
 964 NTSTATUS rpccli_samr_add_aliasmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 965                                POLICY_HND *alias_pol, DOM_SID *member)
 966 {
 967         prs_struct qbuf, rbuf;
 968         SAMR_Q_ADD_ALIASMEM q;
 969         SAMR_R_ADD_ALIASMEM r;
 970         NTSTATUS result;
 971
 972         DEBUG(10,("cli_samr_add_aliasmem"));
 973
 974         ZERO_STRUCT(q);
 975         ZERO_STRUCT(r);
 976
 977         /* Marshall data and send request */
 978
 979         init_samr_q_add_aliasmem(&q, alias_pol, member);
 980
 981         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ADD_ALIASMEM,
 982                 q, r,
 983                 qbuf, rbuf,
 984                 samr_io_q_add_aliasmem,
 985                 samr_io_r_add_aliasmem,
 986                 NT_STATUS_UNSUCCESSFUL);
 987
 988         result = r.status;
 989
 990         return result;
 991 }
 992
 993 /* Delete an alias member */
 994
 995 NTSTATUS rpccli_samr_del_aliasmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 996                                POLICY_HND *alias_pol, DOM_SID *member)
 997 {
 998         prs_struct qbuf, rbuf;
 999         SAMR_Q_DEL_ALIASMEM q;
1000         SAMR_R_DEL_ALIASMEM r;
1001         NTSTATUS result;
1002
1003         DEBUG(10,("cli_samr_del_aliasmem"));
1004
1005         ZERO_STRUCT(q);
1006         ZERO_STRUCT(r);
1007
1008         /* Marshall data and send request */
1009
1010         init_samr_q_del_aliasmem(&q, alias_pol, member);
1011
1012         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DEL_ALIASMEM,
1013                 q, r,
1014                 qbuf, rbuf,
1015                 samr_io_q_del_aliasmem,
1016                 samr_io_r_del_aliasmem,
1017                 NT_STATUS_UNSUCCESSFUL);
1018
1019         result = r.status;
1020
1021         return result;
1022 }
1023
1024 /* Query alias info */
1025
1026 NTSTATUS rpccli_samr_query_alias_info(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1027                                    POLICY_HND *alias_pol, uint16 switch_value,
1028                                    ALIAS_INFO_CTR *ctr)
1029 {
1030         prs_struct qbuf, rbuf;
1031         SAMR_Q_QUERY_ALIASINFO q;
1032         SAMR_R_QUERY_ALIASINFO r;
1033         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1034
1035         DEBUG(10,("cli_samr_query_alias_info\n"));
1036
1037         ZERO_STRUCT(q);
1038         ZERO_STRUCT(r);
1039
1040         /* Marshall data and send request */
1041
1042         init_samr_q_query_aliasinfo(&q, alias_pol, switch_value);
1043
1044         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_ALIASINFO,
1045                 q, r,
1046                 qbuf, rbuf,
1047                 samr_io_q_query_aliasinfo,
1048                 samr_io_r_query_aliasinfo,
1049                 NT_STATUS_UNSUCCESSFUL);
1050
1051         /* Return output parameters */
1052
1053         if (!NT_STATUS_IS_OK(result = r.status)) {
1054                 goto done;
1055         }
1056
1057         *ctr = *r.ctr;
1058
1059   done:
1060
1061         return result;
1062 }
1063
1064 /* Query domain info */
1065
1066 NTSTATUS rpccli_samr_query_dom_info(struct rpc_pipe_client *cli,
1067                                     TALLOC_CTX *mem_ctx,
1068                                     POLICY_HND *domain_pol,
1069                                     uint16 switch_value,
1070                                     SAM_UNK_CTR *ctr)
1071 {
1072         prs_struct qbuf, rbuf;
1073         SAMR_Q_QUERY_DOMAIN_INFO q;
1074         SAMR_R_QUERY_DOMAIN_INFO r;
1075         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1076
1077         DEBUG(10,("cli_samr_query_dom_info\n"));
1078
1079         ZERO_STRUCT(q);
1080         ZERO_STRUCT(r);
1081
1082         /* Marshall data and send request */
1083
1084         init_samr_q_query_domain_info(&q, domain_pol, switch_value);
1085
1086         r.ctr = ctr;
1087
1088         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DOMAIN_INFO,
1089                 q, r,
1090                 qbuf, rbuf,
1091                 samr_io_q_query_domain_info,
1092                 samr_io_r_query_domain_info,
1093                 NT_STATUS_UNSUCCESSFUL);
1094
1095         /* Return output parameters */
1096
1097         if (!NT_STATUS_IS_OK(result = r.status)) {
1098                 goto done;
1099         }
1100
1101  done:
1102
1103         return result;
1104 }
1105
1106 /* Query domain info2 */
1107
1108 NTSTATUS rpccli_samr_query_dom_info2(struct rpc_pipe_client *cli,
1109                                      TALLOC_CTX *mem_ctx,
1110                                      POLICY_HND *domain_pol,
1111                                      uint16 switch_value,
1112                                      SAM_UNK_CTR *ctr)
1113 {
1114         prs_struct qbuf, rbuf;
1115         SAMR_Q_QUERY_DOMAIN_INFO2 q;
1116         SAMR_R_QUERY_DOMAIN_INFO2 r;
1117         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1118
1119         DEBUG(10,("cli_samr_query_dom_info2\n"));
1120
1121         ZERO_STRUCT(q);
1122         ZERO_STRUCT(r);
1123
1124         /* Marshall data and send request */
1125
1126         init_samr_q_query_domain_info2(&q, domain_pol, switch_value);
1127
1128         r.ctr = ctr;
1129
1130         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DOMAIN_INFO2,
1131                 q, r,
1132                 qbuf, rbuf,
1133                 samr_io_q_query_domain_info2,
1134                 samr_io_r_query_domain_info2,
1135                 NT_STATUS_UNSUCCESSFUL);
1136
1137         /* Return output parameters */
1138
1139         if (!NT_STATUS_IS_OK(result = r.status)) {
1140                 goto done;
1141         }
1142
1143  done:
1144
1145         return result;
1146 }
1147
1148 /* Set domain info */
1149
1150 NTSTATUS rpccli_samr_set_domain_info(struct rpc_pipe_client *cli,
1151                                      TALLOC_CTX *mem_ctx,
1152                                      POLICY_HND *domain_pol,
1153                                      uint16 switch_value,
1154                                      SAM_UNK_CTR *ctr)
1155 {
1156         prs_struct qbuf, rbuf;
1157         SAMR_Q_SET_DOMAIN_INFO q;
1158         SAMR_R_SET_DOMAIN_INFO r;
1159         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1160
1161         DEBUG(10,("cli_samr_set_domain_info\n"));
1162
1163         ZERO_STRUCT(q);
1164         ZERO_STRUCT(r);
1165
1166         /* Marshall data and send request */
1167
1168         init_samr_q_set_domain_info(&q, domain_pol, switch_value, ctr);
1169
1170         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_DOMAIN_INFO,
1171                 q, r,
1172                 qbuf, rbuf,
1173                 samr_io_q_set_domain_info,
1174                 samr_io_r_set_domain_info,
1175                 NT_STATUS_UNSUCCESSFUL);
1176
1177         /* Return output parameters */
1178
1179         if (!NT_STATUS_IS_OK(result = r.status)) {
1180                 goto done;
1181         }
1182
1183  done:
1184
1185         return result;
1186 }
1187
1188 /* User change password */
1189
1190 NTSTATUS rpccli_samr_chgpasswd_user(struct rpc_pipe_client *cli,
1191                                     TALLOC_CTX *mem_ctx,
1192                                     const char *username,
1193                                     const char *newpassword,
1194                                     const char *oldpassword )
1195 {
1196         uchar new_nt_password[516];
1197         uchar new_lm_password[516];
1198         uchar old_nt_hash[16];
1199         uchar old_lanman_hash[16];
1200         uchar old_nt_hash_enc[16];
1201         uchar old_lanman_hash_enc[16];
1202
1203         uchar new_nt_hash[16];
1204         uchar new_lanman_hash[16];
1205
1206         DEBUG(10,("rpccli_samr_chgpasswd_user\n"));
1207
1208         /* Calculate the MD4 hash (NT compatible) of the password */
1209         E_md4hash(oldpassword, old_nt_hash);
1210         E_md4hash(newpassword, new_nt_hash);
1211
1212         if (lp_client_lanman_auth()
1213             && E_deshash(newpassword, new_lanman_hash)
1214             && E_deshash(oldpassword, old_lanman_hash)) {
1215                 /* E_deshash returns false for 'long' passwords (> 14
1216                    DOS chars).  This allows us to match Win2k, which
1217                    does not store a LM hash for these passwords (which
1218                    would reduce the effective password length to 14) */
1219
1220                 encode_pw_buffer(new_lm_password, newpassword, STR_UNICODE);
1221
1222                 SamOEMhash( new_lm_password, old_nt_hash, 516);
1223                 E_old_pw_hash( new_nt_hash, old_lanman_hash, old_lanman_hash_enc);
1224         } else {
1225                 ZERO_STRUCT(new_lm_password);
1226                 ZERO_STRUCT(old_lanman_hash_enc);
1227         }
1228
1229         encode_pw_buffer(new_nt_password, newpassword, STR_UNICODE);
1230
1231         SamOEMhash( new_nt_password, old_nt_hash, 516);
1232         E_old_pw_hash( new_nt_hash, old_nt_hash, old_nt_hash_enc);
1233
1234         return rpccli_samr_chng_pswd_auth_crap(cli, mem_ctx, username,
1235                                                data_blob_const(new_nt_password,sizeof(new_nt_password)),
1236                                                data_blob_const(old_nt_hash_enc,sizeof(old_nt_hash_enc)),
1237                                                data_blob_const(new_lm_password,sizeof(new_lm_password)),
1238                                                data_blob_const(old_lanman_hash_enc,sizeof(old_lanman_hash_enc)));
1239 }
1240
1241 /* User change passwd with auth crap */
1242
1243 NTSTATUS rpccli_samr_chng_pswd_auth_crap(struct rpc_pipe_client *cli,
1244                                          TALLOC_CTX *mem_ctx,
1245                                          const char *username,
1246                                          DATA_BLOB new_nt_password,
1247                                          DATA_BLOB old_nt_hash_enc,
1248                                          DATA_BLOB new_lm_password,
1249                                          DATA_BLOB old_lm_hash_enc)
1250 {
1251         prs_struct qbuf, rbuf;
1252         SAMR_Q_CHGPASSWD_USER q;
1253         SAMR_R_CHGPASSWD_USER r;
1254         char *srv_name_slash;
1255
1256         if (!(srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s",
1257                                                cli->cli->desthost))) {
1258                 return NT_STATUS_NO_MEMORY;
1259         }
1260
1261         DEBUG(5,("rpccli_samr_chng_pswd_auth_crap on server: %s\n",
1262                  srv_name_slash));
1263
1264         ZERO_STRUCT(q);
1265         ZERO_STRUCT(r);
1266
1267         /* Marshall data and send request */
1268
1269         init_samr_q_chgpasswd_user(&q, srv_name_slash, username,
1270                                    new_nt_password.data,
1271                                    old_nt_hash_enc.data,
1272                                    new_lm_password.data,
1273                                    old_lm_hash_enc.data);
1274
1275         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CHGPASSWD_USER,
1276                    q, r,
1277                    qbuf, rbuf,
1278                    samr_io_q_chgpasswd_user,
1279                    samr_io_r_chgpasswd_user,
1280                    NT_STATUS_UNSUCCESSFUL);
1281
1282         return r.status;
1283 }
1284
1285 /* change password 3 */
1286
1287 NTSTATUS rpccli_samr_chgpasswd3(struct rpc_pipe_client *cli,
1288                                 TALLOC_CTX *mem_ctx,
1289                                 const char *username,
1290                                 const char *newpassword,
1291                                 const char *oldpassword,
1292                                 SAM_UNK_INFO_1 *info,
1293                                 SAMR_CHANGE_REJECT *reject)
1294 {
1295         prs_struct qbuf, rbuf;
1296         SAMR_Q_CHGPASSWD_USER3 q;
1297         SAMR_R_CHGPASSWD_USER3 r;
1298
1299         uchar new_nt_password[516];
1300         uchar new_lm_password[516];
1301         uchar old_nt_hash[16];
1302         uchar old_lanman_hash[16];
1303         uchar old_nt_hash_enc[16];
1304         uchar old_lanman_hash_enc[16];
1305
1306         uchar new_nt_hash[16];
1307         uchar new_lanman_hash[16];
1308
1309         char *srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", cli->cli->desthost);
1310
1311         DEBUG(10,("rpccli_samr_chgpasswd_user3\n"));
1312
1313         ZERO_STRUCT(q);
1314         ZERO_STRUCT(r);
1315
1316         /* Calculate the MD4 hash (NT compatible) of the password */
1317         E_md4hash(oldpassword, old_nt_hash);
1318         E_md4hash(newpassword, new_nt_hash);
1319
1320         if (lp_client_lanman_auth()
1321             && E_deshash(newpassword, new_lanman_hash)
1322             && E_deshash(oldpassword, old_lanman_hash)) {
1323                 /* E_deshash returns false for 'long' passwords (> 14
1324                    DOS chars).  This allows us to match Win2k, which
1325                    does not store a LM hash for these passwords (which
1326                    would reduce the effective password length to 14) */
1327
1328                 encode_pw_buffer(new_lm_password, newpassword, STR_UNICODE);
1329
1330                 SamOEMhash( new_lm_password, old_nt_hash, 516);
1331                 E_old_pw_hash( new_nt_hash, old_lanman_hash, old_lanman_hash_enc);
1332         } else {
1333                 ZERO_STRUCT(new_lm_password);
1334                 ZERO_STRUCT(old_lanman_hash_enc);
1335         }
1336
1337         encode_pw_buffer(new_nt_password, newpassword, STR_UNICODE);
1338
1339         SamOEMhash( new_nt_password, old_nt_hash, 516);
1340         E_old_pw_hash( new_nt_hash, old_nt_hash, old_nt_hash_enc);
1341
1342         /* Marshall data and send request */
1343
1344         init_samr_q_chgpasswd_user3(&q, srv_name_slash, username,
1345                                     new_nt_password,
1346                                     old_nt_hash_enc,
1347                                     new_lm_password,
1348                                     old_lanman_hash_enc);
1349         r.info = info;
1350         r.reject = reject;
1351
1352         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CHGPASSWD_USER3,
1353                 q, r,
1354                 qbuf, rbuf,
1355                 samr_io_q_chgpasswd_user3,
1356                 samr_io_r_chgpasswd_user3,
1357                 NT_STATUS_UNSUCCESSFUL);
1358
1359         /* Return output parameters */
1360
1361         return r.status;
1362 }
1363
1364 /* This function returns the bizzare set of (max_entries, max_size) required
1365    for the QueryDisplayInfo RPC to actually work against a domain controller
1366    with large (10k and higher) numbers of users.  These values were
1367    obtained by inspection using ethereal and NT4 running User Manager. */
1368
1369 void get_query_dispinfo_params(int loop_count, uint32 *max_entries,
1370                                uint32 *max_size)
1371 {
1372         switch(loop_count) {
1373         case 0:
1374                 *max_entries = 512;
1375                 *max_size = 16383;
1376                 break;
1377         case 1:
1378                 *max_entries = 1024;
1379                 *max_size = 32766;
1380                 break;
1381         case 2:
1382                 *max_entries = 2048;
1383                 *max_size = 65532;
1384                 break;
1385         case 3:
1386                 *max_entries = 4096;
1387                 *max_size = 131064;
1388                 break;
1389         default:              /* loop_count >= 4 */
1390                 *max_entries = 4096;
1391                 *max_size = 131071;
1392                 break;
1393         }
1394 }
1395
1396 /* Query display info */
1397
1398 NTSTATUS rpccli_samr_query_dispinfo(struct rpc_pipe_client *cli,
1399                                     TALLOC_CTX *mem_ctx,
1400                                     POLICY_HND *domain_pol, uint32 *start_idx,
1401                                     uint16 switch_value, uint32 *num_entries,
1402                                     uint32 max_entries, uint32 max_size,
1403                                     SAM_DISPINFO_CTR *ctr)
1404 {
1405         prs_struct qbuf, rbuf;
1406         SAMR_Q_QUERY_DISPINFO q;
1407         SAMR_R_QUERY_DISPINFO r;
1408         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1409
1410         DEBUG(10,("cli_samr_query_dispinfo for start_idx = %u\n", *start_idx));
1411
1412         ZERO_STRUCT(q);
1413         ZERO_STRUCT(r);
1414
1415         *num_entries = 0;
1416
1417         /* Marshall data and send request */
1418
1419         init_samr_q_query_dispinfo(&q, domain_pol, switch_value,
1420                                    *start_idx, max_entries, max_size);
1421
1422         r.ctr = ctr;
1423
1424         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DISPINFO,
1425                 q, r,
1426                 qbuf, rbuf,
1427                 samr_io_q_query_dispinfo,
1428                 samr_io_r_query_dispinfo,
1429                 NT_STATUS_UNSUCCESSFUL);
1430
1431         /* Return output parameters */
1432
1433         result = r.status;
1434
1435         if (!NT_STATUS_IS_OK(result) &&
1436             NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) {
1437                 goto done;
1438         }
1439
1440         *num_entries = r.num_entries;
1441         *start_idx += r.num_entries;  /* No next_idx in this structure! */
1442
1443  done:
1444         return result;
1445 }
1446
1447
1448 /* Query display info2 */
1449
1450 NTSTATUS rpccli_samr_query_dispinfo2(struct rpc_pipe_client *cli,
1451                                      TALLOC_CTX *mem_ctx,
1452                                      POLICY_HND *domain_pol, uint32 *start_idx,
1453                                      uint16 switch_value, uint32 *num_entries,
1454                                      uint32 max_entries, uint32 max_size,
1455                                      SAM_DISPINFO_CTR *ctr)
1456 {
1457         prs_struct qbuf, rbuf;
1458         SAMR_Q_QUERY_DISPINFO q;
1459         SAMR_R_QUERY_DISPINFO r;
1460         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1461
1462         DEBUG(10,("cli_samr_query_dispinfo2 for start_idx = %u\n", *start_idx));
1463
1464         ZERO_STRUCT(q);
1465         ZERO_STRUCT(r);
1466
1467         *num_entries = 0;
1468
1469         /* Marshall data and send request */
1470
1471         init_samr_q_query_dispinfo(&q, domain_pol, switch_value,
1472                                    *start_idx, max_entries, max_size);
1473
1474         r.ctr = ctr;
1475
1476         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DISPINFO2,
1477                 q, r,
1478                 qbuf, rbuf,
1479                 samr_io_q_query_dispinfo,
1480                 samr_io_r_query_dispinfo,
1481                 NT_STATUS_UNSUCCESSFUL);
1482
1483         /* Return output parameters */
1484
1485         result = r.status;
1486
1487         if (!NT_STATUS_IS_OK(result) &&
1488             NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) {
1489                 goto done;
1490         }
1491
1492         *num_entries = r.num_entries;
1493         *start_idx += r.num_entries;  /* No next_idx in this structure! */
1494
1495  done:
1496         return result;
1497 }
1498
1499 /* Query display info */
1500
1501 NTSTATUS rpccli_samr_query_dispinfo3(struct rpc_pipe_client *cli,
1502                                      TALLOC_CTX *mem_ctx,
1503                                      POLICY_HND *domain_pol, uint32 *start_idx,
1504                                      uint16 switch_value, uint32 *num_entries,
1505                                      uint32 max_entries, uint32 max_size,
1506                                      SAM_DISPINFO_CTR *ctr)
1507 {
1508         prs_struct qbuf, rbuf;
1509         SAMR_Q_QUERY_DISPINFO q;
1510         SAMR_R_QUERY_DISPINFO r;
1511         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1512
1513         DEBUG(10,("cli_samr_query_dispinfo3 for start_idx = %u\n", *start_idx));
1514
1515         ZERO_STRUCT(q);
1516         ZERO_STRUCT(r);
1517
1518         *num_entries = 0;
1519
1520         /* Marshall data and send request */
1521
1522         init_samr_q_query_dispinfo(&q, domain_pol, switch_value,
1523                                    *start_idx, max_entries, max_size);
1524
1525         r.ctr = ctr;
1526
1527         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DISPINFO3,
1528                 q, r,
1529                 qbuf, rbuf,
1530                 samr_io_q_query_dispinfo,
1531                 samr_io_r_query_dispinfo,
1532                 NT_STATUS_UNSUCCESSFUL);
1533
1534         /* Return output parameters */
1535
1536         result = r.status;
1537
1538         if (!NT_STATUS_IS_OK(result) &&
1539             NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) {
1540                 goto done;
1541         }
1542
1543         *num_entries = r.num_entries;
1544         *start_idx += r.num_entries;  /* No next_idx in this structure! */
1545
1546  done:
1547         return result;
1548 }
1549
1550 /* Query display info index */
1551
1552 NTSTATUS rpccli_samr_get_dispenum_index(struct rpc_pipe_client *cli,
1553                                         TALLOC_CTX *mem_ctx,
1554                                         POLICY_HND *domain_pol,
1555                                         uint16 switch_value,
1556                                         const char *name,
1557                                         uint32 *idx)
1558 {
1559         prs_struct qbuf, rbuf;
1560         SAMR_Q_GET_DISPENUM_INDEX q;
1561         SAMR_R_GET_DISPENUM_INDEX r;
1562         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1563
1564         DEBUG(10,("cli_samr_get_dispenum_index for name = %s\n", name));
1565
1566         ZERO_STRUCT(q);
1567         ZERO_STRUCT(r);
1568
1569         /* Marshall data and send request */
1570
1571         init_samr_q_get_dispenum_index(&q, domain_pol, switch_value, name);
1572
1573         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_GET_DISPENUM_INDEX,
1574                 q, r,
1575                 qbuf, rbuf,
1576                 samr_io_q_get_dispenum_index,
1577                 samr_io_r_get_dispenum_index,
1578                 NT_STATUS_UNSUCCESSFUL);
1579
1580         /* Return output parameters */
1581
1582         *idx = 0;
1583
1584         result = r.status;
1585
1586         if (!NT_STATUS_IS_ERR(result)) {
1587                 *idx = r.idx;
1588         }
1589
1590         return result;
1591 }
1592
1593 NTSTATUS rpccli_samr_get_dispenum_index2(struct rpc_pipe_client *cli,
1594                                          TALLOC_CTX *mem_ctx,
1595                                          POLICY_HND *domain_pol,
1596                                          uint16 switch_value,
1597                                          const char *name,
1598                                          uint32 *idx)
1599 {
1600         prs_struct qbuf, rbuf;
1601         SAMR_Q_GET_DISPENUM_INDEX q;
1602         SAMR_R_GET_DISPENUM_INDEX r;
1603         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1604
1605         DEBUG(10,("cli_samr_get_dispenum_index2 for name = %s\n", name));
1606
1607         ZERO_STRUCT(q);
1608         ZERO_STRUCT(r);
1609
1610         /* Marshall data and send request */
1611
1612         init_samr_q_get_dispenum_index(&q, domain_pol, switch_value, name);
1613
1614         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_GET_DISPENUM_INDEX2,
1615                 q, r,
1616                 qbuf, rbuf,
1617                 samr_io_q_get_dispenum_index,
1618                 samr_io_r_get_dispenum_index,
1619                 NT_STATUS_UNSUCCESSFUL);
1620
1621         /* Return output parameters */
1622
1623         *idx = 0;
1624
1625         result = r.status;
1626
1627         if (!NT_STATUS_IS_ERR(result)) {
1628                 *idx = r.idx;
1629         }
1630
1631         return result;
1632 }
1633
1634
1635 /* Lookup rids.  Note that NT4 seems to crash if more than ~1000 rids are
1636    looked up in one packet. */
1637
1638 NTSTATUS rpccli_samr_lookup_rids(struct rpc_pipe_client *cli,
1639                                  TALLOC_CTX *mem_ctx,
1640                                  POLICY_HND *domain_pol,
1641                                  uint32 num_rids, uint32 *rids,
1642                                  uint32 *num_names, char ***names,
1643                                  uint32 **name_types)
1644 {
1645         prs_struct qbuf, rbuf;
1646         SAMR_Q_LOOKUP_RIDS q;
1647         SAMR_R_LOOKUP_RIDS r;
1648         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1649         uint32 i;
1650
1651         DEBUG(10,("cli_samr_lookup_rids\n"));
1652
1653         if (num_rids > 1000) {
1654                 DEBUG(2, ("cli_samr_lookup_rids: warning: NT4 can crash if "
1655                           "more than ~1000 rids are looked up at once.\n"));
1656         }
1657
1658         ZERO_STRUCT(q);
1659         ZERO_STRUCT(r);
1660
1661         /* Marshall data and send request */
1662
1663         init_samr_q_lookup_rids(mem_ctx, &q, domain_pol, 1000, num_rids, rids);
1664
1665         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_LOOKUP_RIDS,
1666                 q, r,
1667                 qbuf, rbuf,
1668                 samr_io_q_lookup_rids,
1669                 samr_io_r_lookup_rids,
1670                 NT_STATUS_UNSUCCESSFUL);
1671
1672         /* Return output parameters */
1673
1674         result = r.status;
1675
1676         if (!NT_STATUS_IS_OK(result) &&
1677             !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED))
1678                 goto done;
1679
1680         if (r.num_names1 == 0) {
1681                 *num_names = 0;
1682                 *names = NULL;
1683                 goto done;
1684         }
1685
1686         *num_names = r.num_names1;
1687         *names = TALLOC_ARRAY(mem_ctx, char *, r.num_names1);
1688         *name_types = TALLOC_ARRAY(mem_ctx, uint32, r.num_names1);
1689
1690         if ((*names == NULL) || (*name_types == NULL)) {
1691                 TALLOC_FREE(*names);
1692                 TALLOC_FREE(*name_types);
1693                 return NT_STATUS_NO_MEMORY;
1694         }
1695
1696         for (i = 0; i < r.num_names1; i++) {
1697                 fstring tmp;
1698
1699                 unistr2_to_ascii(tmp, &r.uni_name[i], sizeof(tmp) - 1);
1700                 (*names)[i] = talloc_strdup(mem_ctx, tmp);
1701                 (*name_types)[i] = r.type[i];
1702         }
1703
1704  done:
1705
1706         return result;
1707 }
1708
1709 /* Lookup names */
1710
1711 NTSTATUS rpccli_samr_lookup_names(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1712                                POLICY_HND *domain_pol, uint32 flags,
1713                                uint32 num_names, const char **names,
1714                                uint32 *num_rids, uint32 **rids,
1715                                uint32 **rid_types)
1716 {
1717         prs_struct qbuf, rbuf;
1718         SAMR_Q_LOOKUP_NAMES q;
1719         SAMR_R_LOOKUP_NAMES r;
1720         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1721         uint32 i;
1722
1723         DEBUG(10,("cli_samr_lookup_names\n"));
1724
1725         ZERO_STRUCT(q);
1726         ZERO_STRUCT(r);
1727
1728         /* Marshall data and send request */
1729
1730         init_samr_q_lookup_names(mem_ctx, &q, domain_pol, flags,
1731                                  num_names, names);
1732
1733         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_LOOKUP_NAMES,
1734                 q, r,
1735                 qbuf, rbuf,
1736                 samr_io_q_lookup_names,
1737                 samr_io_r_lookup_names,
1738                 NT_STATUS_UNSUCCESSFUL);
1739
1740         /* Return output parameters */
1741
1742         if (!NT_STATUS_IS_OK(result = r.status)) {
1743                 goto done;
1744         }
1745
1746         if (r.num_rids1 == 0) {
1747                 *num_rids = 0;
1748                 goto done;
1749         }
1750
1751         *num_rids = r.num_rids1;
1752         *rids = TALLOC_ARRAY(mem_ctx, uint32, r.num_rids1);
1753         *rid_types = TALLOC_ARRAY(mem_ctx, uint32, r.num_rids1);
1754
1755         if ((*rids == NULL) || (*rid_types == NULL)) {
1756                 TALLOC_FREE(*rids);
1757                 TALLOC_FREE(*rid_types);
1758                 return NT_STATUS_NO_MEMORY;
1759         }
1760
1761         for (i = 0; i < r.num_rids1; i++) {
1762                 (*rids)[i] = r.rids[i];
1763                 (*rid_types)[i] = r.types[i];
1764         }
1765
1766  done:
1767
1768         return result;
1769 }
1770
1771 /* Create a domain user */
1772
1773 NTSTATUS rpccli_samr_create_dom_user(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1774                                   POLICY_HND *domain_pol, const char *acct_name,
1775                                   uint32 acb_info, uint32 unknown,
1776                                   POLICY_HND *user_pol, uint32 *rid)
1777 {
1778         prs_struct qbuf, rbuf;
1779         SAMR_Q_CREATE_USER q;
1780         SAMR_R_CREATE_USER r;
1781         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1782
1783         DEBUG(10,("cli_samr_create_dom_user %s\n", acct_name));
1784
1785         ZERO_STRUCT(q);
1786         ZERO_STRUCT(r);
1787
1788         /* Marshall data and send request */
1789
1790         init_samr_q_create_user(&q, domain_pol, acct_name, acb_info, unknown);
1791
1792         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CREATE_USER,
1793                 q, r,
1794                 qbuf, rbuf,
1795                 samr_io_q_create_user,
1796                 samr_io_r_create_user,
1797                 NT_STATUS_UNSUCCESSFUL);
1798
1799         /* Return output parameters */
1800
1801         if (!NT_STATUS_IS_OK(result = r.status)) {
1802                 goto done;
1803         }
1804
1805         if (user_pol)
1806                 *user_pol = r.user_pol;
1807
1808         if (rid)
1809                 *rid = r.user_rid;
1810
1811  done:
1812
1813         return result;
1814 }
1815
1816 /* Set userinfo */
1817
1818 NTSTATUS rpccli_samr_set_userinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1819                                const POLICY_HND *user_pol, uint16 switch_value,
1820                                DATA_BLOB *sess_key, SAM_USERINFO_CTR *ctr)
1821 {
1822         prs_struct qbuf, rbuf;
1823         SAMR_Q_SET_USERINFO q;
1824         SAMR_R_SET_USERINFO r;
1825         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1826
1827         DEBUG(10,("cli_samr_set_userinfo\n"));
1828
1829         ZERO_STRUCT(q);
1830         ZERO_STRUCT(r);
1831
1832         if (!sess_key->length) {
1833                 DEBUG(1, ("No user session key\n"));
1834                 return NT_STATUS_NO_USER_SESSION_KEY;
1835         }
1836
1837         /* Initialise parse structures */
1838
1839         prs_init(&qbuf, RPC_MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1840         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1841
1842         /* Marshall data and send request */
1843
1844         q.ctr = ctr;
1845
1846         init_samr_q_set_userinfo(&q, user_pol, sess_key, switch_value,
1847                                  ctr->info.id);
1848
1849         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_USERINFO,
1850                 q, r,
1851                 qbuf, rbuf,
1852                 samr_io_q_set_userinfo,
1853                 samr_io_r_set_userinfo,
1854                 NT_STATUS_UNSUCCESSFUL);
1855
1856         /* Return output parameters */
1857
1858         if (!NT_STATUS_IS_OK(result = r.status)) {
1859                 goto done;
1860         }
1861
1862  done:
1863
1864         return result;
1865 }
1866
1867 /* Set userinfo2 */
1868
1869 NTSTATUS rpccli_samr_set_userinfo2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1870                                    const POLICY_HND *user_pol, uint16 switch_value,
1871                                 DATA_BLOB *sess_key, SAM_USERINFO_CTR *ctr)
1872 {
1873         prs_struct qbuf, rbuf;
1874         SAMR_Q_SET_USERINFO2 q;
1875         SAMR_R_SET_USERINFO2 r;
1876         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1877
1878         DEBUG(10,("cli_samr_set_userinfo2\n"));
1879
1880         if (!sess_key->length) {
1881                 DEBUG(1, ("No user session key\n"));
1882                 return NT_STATUS_NO_USER_SESSION_KEY;
1883         }
1884
1885         ZERO_STRUCT(q);
1886         ZERO_STRUCT(r);
1887
1888         /* Marshall data and send request */
1889
1890         init_samr_q_set_userinfo2(&q, user_pol, sess_key, switch_value, ctr);
1891
1892         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_USERINFO2,
1893                 q, r,
1894                 qbuf, rbuf,
1895                 samr_io_q_set_userinfo2,
1896                 samr_io_r_set_userinfo2,
1897                 NT_STATUS_UNSUCCESSFUL);
1898
1899         /* Return output parameters */
1900
1901         if (!NT_STATUS_IS_OK(result = r.status)) {
1902                 goto done;
1903         }
1904
1905  done:
1906
1907         return result;
1908 }
1909
1910 /* Delete domain group */
1911
1912 NTSTATUS rpccli_samr_delete_dom_group(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1913                                   POLICY_HND *group_pol)
1914 {
1915         prs_struct qbuf, rbuf;
1916         SAMR_Q_DELETE_DOM_GROUP q;
1917         SAMR_R_DELETE_DOM_GROUP r;
1918         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1919
1920         DEBUG(10,("cli_samr_delete_dom_group\n"));
1921
1922         ZERO_STRUCT(q);
1923         ZERO_STRUCT(r);
1924
1925         /* Marshall data and send request */
1926
1927         init_samr_q_delete_dom_group(&q, group_pol);
1928
1929         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DELETE_DOM_GROUP,
1930                 q, r,
1931                 qbuf, rbuf,
1932                 samr_io_q_delete_dom_group,
1933                 samr_io_r_delete_dom_group,
1934                 NT_STATUS_UNSUCCESSFUL);
1935
1936         /* Return output parameters */
1937
1938         result = r.status;
1939
1940         return result;
1941 }
1942
1943 /* Delete domain alias */
1944
1945 NTSTATUS rpccli_samr_delete_dom_alias(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1946                                   POLICY_HND *alias_pol)
1947 {
1948         prs_struct qbuf, rbuf;
1949         SAMR_Q_DELETE_DOM_ALIAS q;
1950         SAMR_R_DELETE_DOM_ALIAS r;
1951         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1952
1953         DEBUG(10,("cli_samr_delete_dom_alias\n"));
1954
1955         ZERO_STRUCT(q);
1956         ZERO_STRUCT(r);
1957
1958         /* Marshall data and send request */
1959
1960         init_samr_q_delete_dom_alias(&q, alias_pol);
1961
1962         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DELETE_DOM_ALIAS,
1963                 q, r,
1964                 qbuf, rbuf,
1965                 samr_io_q_delete_dom_alias,
1966                 samr_io_r_delete_dom_alias,
1967                 NT_STATUS_UNSUCCESSFUL);
1968
1969         /* Return output parameters */
1970
1971         result = r.status;
1972
1973         return result;
1974 }
1975
1976 /* Delete domain user */
1977
1978 NTSTATUS rpccli_samr_delete_dom_user(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1979                                   POLICY_HND *user_pol)
1980 {
1981         prs_struct qbuf, rbuf;
1982         SAMR_Q_DELETE_DOM_USER q;
1983         SAMR_R_DELETE_DOM_USER r;
1984         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1985
1986         DEBUG(10,("cli_samr_delete_dom_user\n"));
1987
1988         ZERO_STRUCT(q);
1989         ZERO_STRUCT(r);
1990
1991         /* Marshall data and send request */
1992
1993         init_samr_q_delete_dom_user(&q, user_pol);
1994
1995         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DELETE_DOM_USER,
1996                 q, r,
1997                 qbuf, rbuf,
1998                 samr_io_q_delete_dom_user,
1999                 samr_io_r_delete_dom_user,
2000                 NT_STATUS_UNSUCCESSFUL);
2001
2002         /* Return output parameters */
2003
2004         result = r.status;
2005
2006         return result;
2007 }
2008
2009 /* Remove foreign SID */
2010
2011 NTSTATUS rpccli_samr_remove_sid_foreign_domain(struct rpc_pipe_client *cli,
2012                                             TALLOC_CTX *mem_ctx,
2013                                             POLICY_HND *user_pol,
2014                                             DOM_SID *sid)
2015 {
2016         prs_struct qbuf, rbuf;
2017         SAMR_Q_REMOVE_SID_FOREIGN_DOMAIN q;
2018         SAMR_R_REMOVE_SID_FOREIGN_DOMAIN r;
2019         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2020
2021         DEBUG(10,("cli_samr_remove_sid_foreign_domain\n"));
2022
2023         ZERO_STRUCT(q);
2024         ZERO_STRUCT(r);
2025
2026         /* Marshall data and send request */
2027
2028         init_samr_q_remove_sid_foreign_domain(&q, user_pol, sid);
2029
2030         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_REMOVE_SID_FOREIGN_DOMAIN,
2031                 q, r,
2032                 qbuf, rbuf,
2033                 samr_io_q_remove_sid_foreign_domain,
2034                 samr_io_r_remove_sid_foreign_domain,
2035                 NT_STATUS_UNSUCCESSFUL);
2036
2037         /* Return output parameters */
2038
2039         result = r.status;
2040
2041         return result;
2042 }
2043
2044 /* Query user security object */
2045
2046 NTSTATUS rpccli_samr_query_sec_obj(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
2047                                  POLICY_HND *user_pol, uint32 sec_info,
2048                                  TALLOC_CTX *ctx, SEC_DESC_BUF **sec_desc_buf)
2049 {
2050         prs_struct qbuf, rbuf;
2051         SAMR_Q_QUERY_SEC_OBJ q;
2052         SAMR_R_QUERY_SEC_OBJ r;
2053         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2054
2055         DEBUG(10,("cli_samr_query_sec_obj\n"));
2056
2057         ZERO_STRUCT(q);
2058         ZERO_STRUCT(r);
2059
2060         /* Marshall data and send request */
2061
2062         init_samr_q_query_sec_obj(&q, user_pol, sec_info);
2063
2064         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_SEC_OBJECT,
2065                 q, r,
2066                 qbuf, rbuf,
2067                 samr_io_q_query_sec_obj,
2068                 samr_io_r_query_sec_obj,
2069                 NT_STATUS_UNSUCCESSFUL);
2070
2071         /* Return output parameters */
2072
2073         result = r.status;
2074         *sec_desc_buf=dup_sec_desc_buf(ctx, r.buf);
2075
2076         return result;
2077 }
2078
2079 /* Set user security object */
2080
2081 NTSTATUS rpccli_samr_set_sec_obj(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
2082                                  POLICY_HND *user_pol, uint32 sec_info,
2083                                  SEC_DESC_BUF *sec_desc_buf)
2084 {
2085         prs_struct qbuf, rbuf;
2086         SAMR_Q_SET_SEC_OBJ q;
2087         SAMR_R_SET_SEC_OBJ r;
2088         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2089
2090         DEBUG(10,("cli_samr_set_sec_obj\n"));
2091
2092         ZERO_STRUCT(q);
2093         ZERO_STRUCT(r);
2094
2095         /* Marshall data and send request */
2096
2097         init_samr_q_set_sec_obj(&q, user_pol, sec_info, sec_desc_buf);
2098
2099         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_SEC_OBJECT,
2100                 q, r,
2101                 qbuf, rbuf,
2102                 samr_io_q_set_sec_obj,
2103                 samr_io_r_set_sec_obj,
2104                 NT_STATUS_UNSUCCESSFUL);
2105
2106         /* Return output parameters */
2107
2108         result = r.status;
2109
2110         return result;
2111 }
2112
2113
2114 /* Get domain password info */
2115
2116 NTSTATUS rpccli_samr_get_dom_pwinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
2117                                  uint16 *min_pwd_length, uint32 *password_properties)
2118 {
2119         prs_struct qbuf, rbuf;
2120         SAMR_Q_GET_DOM_PWINFO q;
2121         SAMR_R_GET_DOM_PWINFO r;
2122         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2123
2124         DEBUG(10,("cli_samr_get_dom_pwinfo\n"));
2125
2126         ZERO_STRUCT(q);
2127         ZERO_STRUCT(r);
2128
2129         /* Marshall data and send request */
2130
2131         init_samr_q_get_dom_pwinfo(&q, cli->cli->desthost);
2132
2133         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_GET_DOM_PWINFO,
2134                 q, r,
2135                 qbuf, rbuf,
2136                 samr_io_q_get_dom_pwinfo,
2137                 samr_io_r_get_dom_pwinfo,
2138                 NT_STATUS_UNSUCCESSFUL);
2139
2140         /* Return output parameters */
2141
2142         result = r.status;
2143
2144         if (NT_STATUS_IS_OK(result)) {
2145                 if (min_pwd_length)
2146                         *min_pwd_length = r.min_pwd_length;
2147                 if (password_properties)
2148                         *password_properties = r.password_properties;
2149         }
2150
2151         return result;
2152 }
2153
2154 /* Get domain password info */
2155
2156 NTSTATUS rpccli_samr_get_usrdom_pwinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
2157                                        POLICY_HND *pol, uint16 *min_pwd_length,
2158                                        uint32 *password_properties, uint32 *unknown1)
2159 {
2160         prs_struct qbuf, rbuf;
2161         SAMR_Q_GET_USRDOM_PWINFO q;
2162         SAMR_R_GET_USRDOM_PWINFO r;
2163         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2164
2165         DEBUG(10,("cli_samr_get_usrdom_pwinfo\n"));
2166
2167         ZERO_STRUCT(q);
2168         ZERO_STRUCT(r);
2169
2170         /* Marshall data and send request */
2171
2172         init_samr_q_get_usrdom_pwinfo(&q, pol);
2173
2174         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_GET_USRDOM_PWINFO,
2175                    q, r,
2176                    qbuf, rbuf,
2177                    samr_io_q_get_usrdom_pwinfo,
2178                    samr_io_r_get_usrdom_pwinfo,
2179                    NT_STATUS_UNSUCCESSFUL);
2180
2181         /* Return output parameters */
2182
2183         result = r.status;
2184
2185         if (NT_STATUS_IS_OK(result)) {
2186                 if (min_pwd_length)
2187                         *min_pwd_length = r.min_pwd_length;
2188                 if (password_properties)
2189                         *password_properties = r.password_properties;
2190                 if (unknown1)
2191                         *unknown1 = r.unknown_1;
2192         }
2193
2194         return result;
2195 }
2196
2197
2198 /* Lookup Domain Name */
2199
2200 NTSTATUS rpccli_samr_lookup_domain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
2201                                 POLICY_HND *user_pol, char *domain_name,
2202                                 DOM_SID *sid)
2203 {
2204         prs_struct qbuf, rbuf;
2205         SAMR_Q_LOOKUP_DOMAIN q;
2206         SAMR_R_LOOKUP_DOMAIN r;
2207         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2208
2209         DEBUG(10,("cli_samr_lookup_domain\n"));
2210
2211         ZERO_STRUCT(q);
2212         ZERO_STRUCT(r);
2213
2214         /* Marshall data and send request */
2215
2216         init_samr_q_lookup_domain(&q, user_pol, domain_name);
2217
2218         CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_LOOKUP_DOMAIN,
2219                 q, r,
2220                 qbuf, rbuf,
2221                 samr_io_q_lookup_domain,
2222                 samr_io_r_lookup_domain,
2223                 NT_STATUS_UNSUCCESSFUL);
2224
2225         /* Return output parameters */
2226
2227         result = r.status;
2228
2229         if (NT_STATUS_IS_OK(result))
2230                 sid_copy(sid, &r.dom_sid.sid);
2231
2232         return result;
2233 }