source3/libsmb/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) Luke Kenneth Casson Leighton 1996-1997,2000,
   7    Copyright (C) Paul Ashton                       1997,2000,
   8    Copyright (C) Elrond                                 2000.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 */
  24
  25 #include "includes.h"
  26
  27 /* Connect to SAMR database */
  28
  29 NTSTATUS cli_samr_connect(struct cli_state *cli, TALLOC_CTX *mem_ctx,
  30                           uint32 access_mask, POLICY_HND *connect_pol)
  31 {
  32         prs_struct qbuf, rbuf;
  33         SAMR_Q_CONNECT q;
  34         SAMR_R_CONNECT r;
  35         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
  36
  37         ZERO_STRUCT(q);
  38         ZERO_STRUCT(r);
  39
  40         /* Initialise parse structures */
  41
  42         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
  43         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
  44
  45         /* Marshall data and send request */
  46
  47         init_samr_q_connect(&q, cli->desthost, access_mask);
  48
  49         if (!samr_io_q_connect("", &q, &qbuf, 0) ||
  50             !rpc_api_pipe_req(cli, SAMR_CONNECT, &qbuf, &rbuf))
  51                 goto done;
  52
  53         /* Unmarshall response */
  54
  55         if (!samr_io_r_connect("", &r, &rbuf, 0))
  56                 goto done;
  57
  58         /* Return output parameters */
  59
  60         if (NT_STATUS_IS_OK(result = r.status)) {
  61                 *connect_pol = r.connect_pol;
  62 #ifdef __INSURE__
  63                 connect_pol->marker = malloc(1);
  64 #endif
  65         }
  66
  67  done:
  68         prs_mem_free(&qbuf);
  69         prs_mem_free(&rbuf);
  70
  71         return result;
  72 }
  73
  74 /* Close SAMR handle */
  75
  76 NTSTATUS cli_samr_close(struct cli_state *cli, TALLOC_CTX *mem_ctx,
  77                         POLICY_HND *connect_pol)
  78 {
  79         prs_struct qbuf, rbuf;
  80         SAMR_Q_CLOSE_HND q;
  81         SAMR_R_CLOSE_HND r;
  82         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
  83
  84         ZERO_STRUCT(q);
  85         ZERO_STRUCT(r);
  86
  87         /* Initialise parse structures */
  88
  89         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
  90         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
  91
  92         /* Marshall data and send request */
  93
  94         init_samr_q_close_hnd(&q, connect_pol);
  95
  96         if (!samr_io_q_close_hnd("", &q, &qbuf, 0) ||
  97             !rpc_api_pipe_req(cli, SAMR_CLOSE_HND, &qbuf, &rbuf))
  98                 goto done;
  99
 100         /* Unmarshall response */
 101
 102         if (!samr_io_r_close_hnd("", &r, &rbuf, 0))
 103                 goto done;
 104
 105         /* Return output parameters */
 106
 107         if (NT_STATUS_IS_OK(result = r.status)) {
 108 #ifdef __INSURE__
 109                 SAFE_FREE(connect_pol->marker);
 110 #endif
 111                 *connect_pol = r.pol;
 112         }
 113
 114  done:
 115         prs_mem_free(&qbuf);
 116         prs_mem_free(&rbuf);
 117
 118         return result;
 119 }
 120
 121 /* Open handle on a domain */
 122
 123 NTSTATUS cli_samr_open_domain(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 124                               POLICY_HND *connect_pol, uint32 access_mask,
 125                               const DOM_SID *domain_sid, POLICY_HND *domain_pol)
 126 {
 127         prs_struct qbuf, rbuf;
 128         SAMR_Q_OPEN_DOMAIN q;
 129         SAMR_R_OPEN_DOMAIN r;
 130         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 131
 132         ZERO_STRUCT(q);
 133         ZERO_STRUCT(r);
 134
 135         /* Initialise parse structures */
 136
 137         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 138         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 139
 140         /* Marshall data and send request */
 141
 142         init_samr_q_open_domain(&q, connect_pol, access_mask, domain_sid);
 143
 144         if (!samr_io_q_open_domain("", &q, &qbuf, 0) ||
 145             !rpc_api_pipe_req(cli, SAMR_OPEN_DOMAIN, &qbuf, &rbuf))
 146                 goto done;
 147
 148         /* Unmarshall response */
 149
 150         if (!samr_io_r_open_domain("", &r, &rbuf, 0))
 151                 goto done;
 152
 153         /* Return output parameters */
 154
 155         if (NT_STATUS_IS_OK(result = r.status)) {
 156                 *domain_pol = r.domain_pol;
 157 #ifdef __INSURE__
 158                 domain_pol->marker = malloc(1);
 159 #endif
 160         }
 161
 162  done:
 163         prs_mem_free(&qbuf);
 164         prs_mem_free(&rbuf);
 165
 166         return result;
 167 }
 168
 169 /* Open handle on a user */
 170
 171 NTSTATUS cli_samr_open_user(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 172                             POLICY_HND *domain_pol, uint32 access_mask,
 173                             uint32 user_rid, POLICY_HND *user_pol)
 174 {
 175         prs_struct qbuf, rbuf;
 176         SAMR_Q_OPEN_USER q;
 177         SAMR_R_OPEN_USER r;
 178         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 179
 180         ZERO_STRUCT(q);
 181         ZERO_STRUCT(r);
 182
 183         /* Initialise parse structures */
 184
 185         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 186         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 187
 188         /* Marshall data and send request */
 189
 190         init_samr_q_open_user(&q, domain_pol, access_mask, user_rid);
 191
 192         if (!samr_io_q_open_user("", &q, &qbuf, 0) ||
 193             !rpc_api_pipe_req(cli, SAMR_OPEN_USER, &qbuf, &rbuf))
 194                 goto done;
 195
 196         /* Unmarshall response */
 197
 198         if (!samr_io_r_open_user("", &r, &rbuf, 0))
 199                 goto done;
 200
 201         /* Return output parameters */
 202
 203         if (NT_STATUS_IS_OK(result = r.status)) {
 204                 *user_pol = r.user_pol;
 205 #ifdef __INSURE__
 206                 user_pol->marker = malloc(1);
 207 #endif
 208         }
 209
 210  done:
 211         prs_mem_free(&qbuf);
 212         prs_mem_free(&rbuf);
 213
 214         return result;
 215 }
 216
 217 /* Open handle on a group */
 218
 219 NTSTATUS cli_samr_open_group(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 220                              POLICY_HND *domain_pol, uint32 access_mask,
 221                              uint32 group_rid, POLICY_HND *group_pol)
 222 {
 223         prs_struct qbuf, rbuf;
 224         SAMR_Q_OPEN_GROUP q;
 225         SAMR_R_OPEN_GROUP r;
 226         NTSTATUS result =  NT_STATUS_UNSUCCESSFUL;
 227
 228         ZERO_STRUCT(q);
 229         ZERO_STRUCT(r);
 230
 231         /* Initialise parse structures */
 232
 233         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 234         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 235
 236         /* Marshall data and send request */
 237
 238         init_samr_q_open_group(&q, domain_pol, access_mask, group_rid);
 239
 240         if (!samr_io_q_open_group("", &q, &qbuf, 0) ||
 241             !rpc_api_pipe_req(cli, SAMR_OPEN_GROUP, &qbuf, &rbuf))
 242                 goto done;
 243
 244         /* Unmarshall response */
 245
 246         if (!samr_io_r_open_group("", &r, &rbuf, 0))
 247                 goto done;
 248
 249         /* Return output parameters */
 250
 251         if (NT_STATUS_IS_OK(result = r.status)) {
 252                 *group_pol = r.pol;
 253 #ifdef __INSURE__
 254                 group_pol->marker = malloc(1);
 255 #endif
 256         }
 257
 258  done:
 259         prs_mem_free(&qbuf);
 260         prs_mem_free(&rbuf);
 261
 262         return result;
 263 }
 264
 265 /* Query user info */
 266
 267 NTSTATUS cli_samr_query_userinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 268                                  POLICY_HND *user_pol, uint16 switch_value,
 269                                  SAM_USERINFO_CTR **ctr)
 270 {
 271         prs_struct qbuf, rbuf;
 272         SAMR_Q_QUERY_USERINFO q;
 273         SAMR_R_QUERY_USERINFO r;
 274         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 275
 276         ZERO_STRUCT(q);
 277         ZERO_STRUCT(r);
 278
 279         /* Initialise parse structures */
 280
 281         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 282         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 283
 284         /* Marshall data and send request */
 285
 286         init_samr_q_query_userinfo(&q, user_pol, switch_value);
 287
 288         if (!samr_io_q_query_userinfo("", &q, &qbuf, 0) ||
 289             !rpc_api_pipe_req(cli, SAMR_QUERY_USERINFO, &qbuf, &rbuf))
 290                 goto done;
 291
 292         /* Unmarshall response */
 293
 294         if (!samr_io_r_query_userinfo("", &r, &rbuf, 0))
 295                 goto done;
 296
 297         /* Return output parameters */
 298
 299         result = r.status;
 300         *ctr = r.ctr;
 301
 302  done:
 303         prs_mem_free(&qbuf);
 304         prs_mem_free(&rbuf);
 305
 306         return result;
 307 }
 308
 309 /* Query group info */
 310
 311 NTSTATUS cli_samr_query_groupinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 312                                   POLICY_HND *group_pol, uint32 info_level,
 313                                   GROUP_INFO_CTR *ctr)
 314 {
 315         prs_struct qbuf, rbuf;
 316         SAMR_Q_QUERY_GROUPINFO q;
 317         SAMR_R_QUERY_GROUPINFO r;
 318         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 319
 320         ZERO_STRUCT(q);
 321         ZERO_STRUCT(r);
 322
 323         /* Initialise parse structures */
 324
 325         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 326         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 327
 328         /* Marshall data and send request */
 329
 330         init_samr_q_query_groupinfo(&q, group_pol, info_level);
 331
 332         if (!samr_io_q_query_groupinfo("", &q, &qbuf, 0) ||
 333             !rpc_api_pipe_req(cli, SAMR_QUERY_GROUPINFO, &qbuf, &rbuf))
 334                 goto done;
 335
 336         /* Unmarshall response */
 337
 338         r.ctr = ctr;
 339
 340         if (!samr_io_r_query_groupinfo("", &r, &rbuf, 0))
 341                 goto done;
 342
 343         /* Return output parameters */
 344
 345         result = r.status;
 346
 347  done:
 348         prs_mem_free(&qbuf);
 349         prs_mem_free(&rbuf);
 350
 351         return result;
 352 }
 353
 354 /* Query user groups */
 355
 356 NTSTATUS cli_samr_query_usergroups(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 357                                    POLICY_HND *user_pol, uint32 *num_groups,
 358                                    DOM_GID **gid)
 359 {
 360         prs_struct qbuf, rbuf;
 361         SAMR_Q_QUERY_USERGROUPS q;
 362         SAMR_R_QUERY_USERGROUPS r;
 363         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 364
 365         ZERO_STRUCT(q);
 366         ZERO_STRUCT(r);
 367
 368         /* Initialise parse structures */
 369
 370         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 371         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 372
 373         /* Marshall data and send request */
 374
 375         init_samr_q_query_usergroups(&q, user_pol);
 376
 377         if (!samr_io_q_query_usergroups("", &q, &qbuf, 0) ||
 378             !rpc_api_pipe_req(cli, SAMR_QUERY_USERGROUPS, &qbuf, &rbuf))
 379                 goto done;
 380
 381         /* Unmarshall response */
 382
 383         if (!samr_io_r_query_usergroups("", &r, &rbuf, 0))
 384                 goto done;
 385
 386         /* Return output parameters */
 387
 388         if (NT_STATUS_IS_OK(result = r.status)) {
 389                 *num_groups = r.num_entries;
 390                 *gid = r.gid;
 391         }
 392
 393  done:
 394         prs_mem_free(&qbuf);
 395         prs_mem_free(&rbuf);
 396
 397         return result;
 398 }
 399
 400 /* Query user aliases */
 401
 402 NTSTATUS cli_samr_query_useraliases(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 403                                    POLICY_HND *user_pol, uint32 num_sids, DOM_SID2 *sid,
 404                                    uint32 *num_aliases, uint32 **als_rids)
 405 {
 406         prs_struct qbuf, rbuf;
 407         SAMR_Q_QUERY_USERALIASES q;
 408         SAMR_R_QUERY_USERALIASES r;
 409         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 410         unsigned int ptr=1;
 411
 412         ZERO_STRUCT(q);
 413         ZERO_STRUCT(r);
 414
 415         /* Initialise parse structures */
 416
 417         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 418         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 419
 420         /* Marshall data and send request */
 421
 422         init_samr_q_query_useraliases(&q, user_pol, num_sids, &ptr, sid);
 423
 424         if (!samr_io_q_query_useraliases("", &q, &qbuf, 0) ||
 425             !rpc_api_pipe_req(cli, SAMR_QUERY_USERALIASES, &qbuf, &rbuf))
 426                 goto done;
 427
 428         /* Unmarshall response */
 429
 430         if (!samr_io_r_query_useraliases("", &r, &rbuf, 0))
 431                 goto done;
 432
 433         /* Return output parameters */
 434
 435         if (NT_STATUS_IS_OK(result = r.status)) {
 436                 *num_aliases = r.num_entries;
 437                 *als_rids = r.rid;
 438         }
 439
 440  done:
 441         prs_mem_free(&qbuf);
 442         prs_mem_free(&rbuf);
 443
 444         return result;
 445 }
 446
 447 /* Query user groups */
 448
 449 NTSTATUS cli_samr_query_groupmem(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 450                                  POLICY_HND *group_pol, uint32 *num_mem,
 451                                  uint32 **rid, uint32 **attr)
 452 {
 453         prs_struct qbuf, rbuf;
 454         SAMR_Q_QUERY_GROUPMEM q;
 455         SAMR_R_QUERY_GROUPMEM r;
 456         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 457
 458         ZERO_STRUCT(q);
 459         ZERO_STRUCT(r);
 460
 461         /* Initialise parse structures */
 462
 463         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 464         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 465
 466         /* Marshall data and send request */
 467
 468         init_samr_q_query_groupmem(&q, group_pol);
 469
 470         if (!samr_io_q_query_groupmem("", &q, &qbuf, 0) ||
 471             !rpc_api_pipe_req(cli, SAMR_QUERY_GROUPMEM, &qbuf, &rbuf))
 472                 goto done;
 473
 474         /* Unmarshall response */
 475
 476         if (!samr_io_r_query_groupmem("", &r, &rbuf, 0))
 477                 goto done;
 478
 479         /* Return output parameters */
 480
 481         if (NT_STATUS_IS_OK(result = r.status)) {
 482                 *num_mem = r.num_entries;
 483                 *rid = r.rid;
 484                 *attr = r.attr;
 485         }
 486
 487  done:
 488         prs_mem_free(&qbuf);
 489         prs_mem_free(&rbuf);
 490
 491         return result;
 492 }
 493
 494 /* Enumerate domain groups */
 495
 496 NTSTATUS cli_samr_enum_dom_groups(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 497                                   POLICY_HND *pol, uint32 *start_idx,
 498                                   uint32 size, struct acct_info **dom_groups,
 499                                   uint32 *num_dom_groups)
 500 {
 501         prs_struct qbuf, rbuf;
 502         SAMR_Q_ENUM_DOM_GROUPS q;
 503         SAMR_R_ENUM_DOM_GROUPS r;
 504         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 505         uint32 name_idx, i;
 506
 507         ZERO_STRUCT(q);
 508         ZERO_STRUCT(r);
 509
 510         /* Initialise parse structures */
 511
 512         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 513         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 514
 515         /* Marshall data and send request */
 516
 517         init_samr_q_enum_dom_groups(&q, pol, *start_idx, size);
 518
 519         if (!samr_io_q_enum_dom_groups("", &q, &qbuf, 0) ||
 520             !rpc_api_pipe_req(cli, SAMR_ENUM_DOM_GROUPS, &qbuf, &rbuf))
 521                 goto done;
 522
 523         /* Unmarshall response */
 524
 525         if (!samr_io_r_enum_dom_groups("", &r, &rbuf, 0))
 526                 goto done;
 527
 528         /* Return output parameters */
 529
 530         result = r.status;
 531
 532         if (!NT_STATUS_IS_OK(result) &&
 533             NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES))
 534                 goto done;
 535
 536         *num_dom_groups = r.num_entries2;
 537
 538         if (!((*dom_groups) = (struct acct_info *)
 539               talloc(mem_ctx, sizeof(struct acct_info) * *num_dom_groups))) {
 540                 result = NT_STATUS_UNSUCCESSFUL;
 541                 goto done;
 542         }
 543
 544         memset(*dom_groups, 0, sizeof(struct acct_info) * *num_dom_groups);
 545
 546         name_idx = 0;
 547
 548         for (i = 0; i < *num_dom_groups; i++) {
 549
 550                 (*dom_groups)[i].rid = r.sam[i].rid;
 551
 552                 if (r.sam[i].hdr_name.buffer) {
 553                         unistr2_to_ascii((*dom_groups)[i].acct_name,
 554                                          &r.uni_grp_name[name_idx],
 555                                          sizeof(fstring) - 1);
 556                         name_idx++;
 557                 }
 558
 559                 *start_idx = r.next_idx;
 560         }
 561
 562  done:
 563         prs_mem_free(&qbuf);
 564         prs_mem_free(&rbuf);
 565
 566         return result;
 567 }
 568
 569 /* Enumerate domain groups */
 570
 571 NTSTATUS cli_samr_enum_als_groups(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 572                                   POLICY_HND *pol, uint32 *start_idx,
 573                                   uint32 size, struct acct_info **dom_groups,
 574                                   uint32 *num_dom_groups)
 575 {
 576         prs_struct qbuf, rbuf;
 577         SAMR_Q_ENUM_DOM_ALIASES q;
 578         SAMR_R_ENUM_DOM_ALIASES r;
 579         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 580         uint32 name_idx, i;
 581
 582         ZERO_STRUCT(q);
 583         ZERO_STRUCT(r);
 584
 585         /* Initialise parse structures */
 586
 587         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 588         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 589
 590         /* Marshall data and send request */
 591
 592         init_samr_q_enum_dom_aliases(&q, pol, *start_idx, size);
 593
 594         if (!samr_io_q_enum_dom_aliases("", &q, &qbuf, 0) ||
 595             !rpc_api_pipe_req(cli, SAMR_ENUM_DOM_ALIASES, &qbuf, &rbuf)) {
 596                 goto done;
 597         }
 598
 599         /* Unmarshall response */
 600
 601         if (!samr_io_r_enum_dom_aliases("", &r, &rbuf, 0)) {
 602                 goto done;
 603         }
 604
 605         /* Return output parameters */
 606
 607         result = r.status;
 608
 609         if (!NT_STATUS_IS_OK(result) &&
 610             NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) {
 611                 goto done;
 612         }
 613
 614         *num_dom_groups = r.num_entries2;
 615
 616         if (!((*dom_groups) = (struct acct_info *)
 617               talloc(mem_ctx, sizeof(struct acct_info) * *num_dom_groups))) {
 618                 result = NT_STATUS_UNSUCCESSFUL;
 619                 goto done;
 620         }
 621
 622         memset(*dom_groups, 0, sizeof(struct acct_info) * *num_dom_groups);
 623
 624         name_idx = 0;
 625
 626         for (i = 0; i < *num_dom_groups; i++) {
 627
 628                 (*dom_groups)[i].rid = r.sam[i].rid;
 629
 630                 if (r.sam[i].hdr_name.buffer) {
 631                         unistr2_to_ascii((*dom_groups)[i].acct_name,
 632                                          &r.uni_grp_name[name_idx],
 633                                          sizeof(fstring) - 1);
 634                         name_idx++;
 635                 }
 636
 637                 *start_idx = r.next_idx;
 638         }
 639
 640  done:
 641         prs_mem_free(&qbuf);
 642         prs_mem_free(&rbuf);
 643
 644         return result;
 645 }
 646
 647 /* Query alias members */
 648
 649 NTSTATUS cli_samr_query_aliasmem(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 650                                  POLICY_HND *alias_pol, uint32 *num_mem,
 651                                  DOM_SID **sids)
 652 {
 653         prs_struct qbuf, rbuf;
 654         SAMR_Q_QUERY_ALIASMEM q;
 655         SAMR_R_QUERY_ALIASMEM r;
 656         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 657         uint32 i;
 658
 659         ZERO_STRUCT(q);
 660         ZERO_STRUCT(r);
 661
 662         /* Initialise parse structures */
 663
 664         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 665         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 666
 667         /* Marshall data and send request */
 668
 669         init_samr_q_query_aliasmem(&q, alias_pol);
 670
 671         if (!samr_io_q_query_aliasmem("", &q, &qbuf, 0) ||
 672             !rpc_api_pipe_req(cli, SAMR_QUERY_ALIASMEM, &qbuf, &rbuf)) {
 673                 goto done;
 674         }
 675
 676         /* Unmarshall response */
 677
 678         if (!samr_io_r_query_aliasmem("", &r, &rbuf, 0)) {
 679                 goto done;
 680         }
 681
 682         /* Return output parameters */
 683
 684         if (!NT_STATUS_IS_OK(result = r.status)) {
 685                 goto done;
 686         }
 687
 688         *num_mem = r.num_sids;
 689
 690         if (!(*sids = talloc(mem_ctx, sizeof(DOM_SID) * *num_mem))) {
 691                 result = NT_STATUS_UNSUCCESSFUL;
 692                 goto done;
 693         }
 694
 695         for (i = 0; i < *num_mem; i++) {
 696                 (*sids)[i] = r.sid[i].sid;
 697         }
 698
 699  done:
 700         prs_mem_free(&qbuf);
 701         prs_mem_free(&rbuf);
 702
 703         return result;
 704 }
 705
 706 /* Open handle on an alias */
 707
 708 NTSTATUS cli_samr_open_alias(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 709                              POLICY_HND *domain_pol, uint32 access_mask,
 710                              uint32 alias_rid, POLICY_HND *alias_pol)
 711 {
 712         prs_struct qbuf, rbuf;
 713         SAMR_Q_OPEN_ALIAS q;
 714         SAMR_R_OPEN_ALIAS r;
 715         NTSTATUS result;
 716
 717         ZERO_STRUCT(q);
 718         ZERO_STRUCT(r);
 719
 720         /* Initialise parse structures */
 721
 722         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 723         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 724
 725         /* Marshall data and send request */
 726
 727         init_samr_q_open_alias(&q, domain_pol, access_mask, alias_rid);
 728
 729         if (!samr_io_q_open_alias("", &q, &qbuf, 0) ||
 730             !rpc_api_pipe_req(cli, SAMR_OPEN_ALIAS, &qbuf, &rbuf)) {
 731                 result = NT_STATUS_UNSUCCESSFUL;
 732                 goto done;
 733         }
 734
 735         /* Unmarshall response */
 736
 737         if (!samr_io_r_open_alias("", &r, &rbuf, 0)) {
 738                 result = NT_STATUS_UNSUCCESSFUL;
 739                 goto done;
 740         }
 741
 742         /* Return output parameters */
 743
 744         if (NT_STATUS_IS_OK(result = r.status)) {
 745                 *alias_pol = r.pol;
 746 #ifdef __INSURE__
 747                 alias_pol->marker = malloc(1);
 748 #endif
 749         }
 750
 751  done:
 752         prs_mem_free(&qbuf);
 753         prs_mem_free(&rbuf);
 754
 755         return result;
 756 }
 757
 758 /* Query domain info */
 759
 760 NTSTATUS cli_samr_query_dom_info(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 761                                  POLICY_HND *domain_pol, uint16 switch_value,
 762                                  SAM_UNK_CTR *ctr)
 763 {
 764         prs_struct qbuf, rbuf;
 765         SAMR_Q_QUERY_DOMAIN_INFO q;
 766         SAMR_R_QUERY_DOMAIN_INFO r;
 767         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 768
 769         ZERO_STRUCT(q);
 770         ZERO_STRUCT(r);
 771
 772         /* Initialise parse structures */
 773
 774         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 775         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 776
 777         /* Marshall data and send request */
 778
 779         init_samr_q_query_dom_info(&q, domain_pol, switch_value);
 780
 781         if (!samr_io_q_query_dom_info("", &q, &qbuf, 0) ||
 782             !rpc_api_pipe_req(cli, SAMR_QUERY_DOMAIN_INFO, &qbuf, &rbuf)) {
 783                 goto done;
 784         }
 785
 786         /* Unmarshall response */
 787
 788         r.ctr = ctr;
 789
 790         if (!samr_io_r_query_dom_info("", &r, &rbuf, 0)) {
 791                 goto done;
 792         }
 793
 794         /* Return output parameters */
 795
 796         if (!NT_STATUS_IS_OK(result = r.status)) {
 797                 goto done;
 798         }
 799
 800  done:
 801         prs_mem_free(&qbuf);
 802         prs_mem_free(&rbuf);
 803
 804         return result;
 805 }
 806
 807 /* Query display info */
 808
 809 NTSTATUS cli_samr_query_dispinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 810                                  POLICY_HND *domain_pol, uint32 *start_idx,
 811                                  uint16 switch_value, uint32 *num_entries,
 812                                  uint32 max_entries, SAM_DISPINFO_CTR *ctr)
 813 {
 814         prs_struct qbuf, rbuf;
 815         SAMR_Q_QUERY_DISPINFO q;
 816         SAMR_R_QUERY_DISPINFO r;
 817         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 818
 819         ZERO_STRUCT(q);
 820         ZERO_STRUCT(r);
 821
 822         /* Initialise parse structures */
 823
 824         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 825         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 826
 827         /* Marshall data and send request */
 828
 829         init_samr_q_query_dispinfo(&q, domain_pol, switch_value,
 830                                    *start_idx, max_entries);
 831
 832         if (!samr_io_q_query_dispinfo("", &q, &qbuf, 0) ||
 833             !rpc_api_pipe_req(cli, SAMR_QUERY_DISPINFO, &qbuf, &rbuf)) {
 834                 goto done;
 835         }
 836
 837         /* Unmarshall response */
 838
 839         r.ctr = ctr;
 840
 841         if (!samr_io_r_query_dispinfo("", &r, &rbuf, 0)) {
 842                 goto done;
 843         }
 844
 845         /* Return output parameters */
 846
 847         result = r.status;
 848
 849         if (!NT_STATUS_IS_OK(result) &&
 850             NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) {
 851                 goto done;
 852         }
 853
 854         *num_entries = r.num_entries;
 855         *start_idx += r.num_entries;  /* No next_idx in this structure! */
 856
 857  done:
 858         prs_mem_free(&qbuf);
 859         prs_mem_free(&rbuf);
 860
 861         return result;
 862 }
 863
 864 /* Lookup rids.  Note that NT4 seems to crash if more than ~1000 rids are
 865    looked up in one packet. */
 866
 867 NTSTATUS cli_samr_lookup_rids(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 868                               POLICY_HND *domain_pol, uint32 flags,
 869                               uint32 num_rids, uint32 *rids,
 870                               uint32 *num_names, char ***names,
 871                               uint32 **name_types)
 872 {
 873         prs_struct qbuf, rbuf;
 874         SAMR_Q_LOOKUP_RIDS q;
 875         SAMR_R_LOOKUP_RIDS r;
 876         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 877         uint32 i;
 878
 879         if (num_rids > 1000) {
 880                 DEBUG(2, ("cli_samr_lookup_rids: warning: NT4 can crash if "
 881                           "more than ~1000 rids are looked up at once.\n"));
 882         }
 883
 884         ZERO_STRUCT(q);
 885         ZERO_STRUCT(r);
 886
 887         /* Initialise parse structures */
 888
 889         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 890         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 891
 892         /* Marshall data and send request */
 893
 894         init_samr_q_lookup_rids(mem_ctx, &q, domain_pol, flags,
 895                                 num_rids, rids);
 896
 897         if (!samr_io_q_lookup_rids("", &q, &qbuf, 0) ||
 898             !rpc_api_pipe_req(cli, SAMR_LOOKUP_RIDS, &qbuf, &rbuf)) {
 899                 goto done;
 900         }
 901
 902         /* Unmarshall response */
 903
 904         if (!samr_io_r_lookup_rids("", &r, &rbuf, 0)) {
 905                 goto done;
 906         }
 907
 908         /* Return output parameters */
 909
 910         if (!NT_STATUS_IS_OK(result = r.status)) {
 911                 goto done;
 912         }
 913
 914         if (r.num_names1 == 0) {
 915                 *num_names = 0;
 916                 *names = NULL;
 917                 goto done;
 918         }
 919
 920         *num_names = r.num_names1;
 921         *names = talloc(mem_ctx, sizeof(char *) * r.num_names1);
 922         *name_types = talloc(mem_ctx, sizeof(uint32) * r.num_names1);
 923
 924         for (i = 0; i < r.num_names1; i++) {
 925                 fstring tmp;
 926
 927                 unistr2_to_ascii(tmp, &r.uni_name[i], sizeof(tmp) - 1);
 928                 (*names)[i] = talloc_strdup(mem_ctx, tmp);
 929                 (*name_types)[i] = r.type[i];
 930         }
 931
 932  done:
 933         prs_mem_free(&qbuf);
 934         prs_mem_free(&rbuf);
 935
 936         return result;
 937 }
 938
 939 /* Lookup names */
 940
 941 NTSTATUS cli_samr_lookup_names(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 942                                POLICY_HND *domain_pol, uint32 flags,
 943                                uint32 num_names, const char **names,
 944                                uint32 *num_rids, uint32 **rids,
 945                                uint32 **rid_types)
 946 {
 947         prs_struct qbuf, rbuf;
 948         SAMR_Q_LOOKUP_NAMES q;
 949         SAMR_R_LOOKUP_NAMES r;
 950         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 951         uint32 i;
 952
 953         ZERO_STRUCT(q);
 954         ZERO_STRUCT(r);
 955
 956         /* Initialise parse structures */
 957
 958         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
 959         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 960
 961         /* Marshall data and send request */
 962
 963         init_samr_q_lookup_names(mem_ctx, &q, domain_pol, flags,
 964                                  num_names, names);
 965
 966         if (!samr_io_q_lookup_names("", &q, &qbuf, 0) ||
 967             !rpc_api_pipe_req(cli, SAMR_LOOKUP_NAMES, &qbuf, &rbuf)) {
 968                 goto done;
 969         }
 970
 971         /* Unmarshall response */
 972
 973         if (!samr_io_r_lookup_names("", &r, &rbuf, 0)) {
 974                 goto done;
 975         }
 976
 977         /* Return output parameters */
 978
 979         if (!NT_STATUS_IS_OK(result = r.status)) {
 980                 goto done;
 981         }
 982
 983         if (r.num_rids1 == 0) {
 984                 *num_rids = 0;
 985                 goto done;
 986         }
 987
 988         *num_rids = r.num_rids1;
 989         *rids = talloc(mem_ctx, sizeof(uint32) * r.num_rids1);
 990         *rid_types = talloc(mem_ctx, sizeof(uint32) * r.num_rids1);
 991
 992         for (i = 0; i < r.num_rids1; i++) {
 993                 (*rids)[i] = r.rids[i];
 994                 (*rid_types)[i] = r.types[i];
 995         }
 996
 997  done:
 998         prs_mem_free(&qbuf);
 999         prs_mem_free(&rbuf);
1000
1001         return result;
1002 }
1003
1004 /* Create a domain user */
1005
1006 NTSTATUS cli_samr_create_dom_user(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1007                                   POLICY_HND *domain_pol, const char *acct_name,
1008                                   uint32 acb_info, uint32 unknown,
1009                                   POLICY_HND *user_pol, uint32 *rid)
1010 {
1011         prs_struct qbuf, rbuf;
1012         SAMR_Q_CREATE_USER q;
1013         SAMR_R_CREATE_USER r;
1014         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1015
1016         ZERO_STRUCT(q);
1017         ZERO_STRUCT(r);
1018
1019         /* Initialise parse structures */
1020
1021         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1022         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1023
1024         /* Marshall data and send request */
1025
1026         init_samr_q_create_user(&q, domain_pol, acct_name, acb_info, unknown);
1027
1028         if (!samr_io_q_create_user("", &q, &qbuf, 0) ||
1029             !rpc_api_pipe_req(cli, SAMR_CREATE_USER, &qbuf, &rbuf)) {
1030                 goto done;
1031         }
1032
1033         /* Unmarshall response */
1034
1035         if (!samr_io_r_create_user("", &r, &rbuf, 0)) {
1036                 goto done;
1037         }
1038
1039         /* Return output parameters */
1040
1041         if (!NT_STATUS_IS_OK(result = r.status)) {
1042                 goto done;
1043         }
1044
1045         if (user_pol)
1046                 *user_pol = r.user_pol;
1047
1048         if (rid)
1049                 *rid = r.user_rid;
1050
1051  done:
1052         prs_mem_free(&qbuf);
1053         prs_mem_free(&rbuf);
1054
1055         return result;
1056 }
1057
1058 /* Set userinfo */
1059
1060 NTSTATUS cli_samr_set_userinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1061                                POLICY_HND *user_pol, uint16 switch_value,
1062                                uchar sess_key[16], SAM_USERINFO_CTR *ctr)
1063 {
1064         prs_struct qbuf, rbuf;
1065         SAMR_Q_SET_USERINFO q;
1066         SAMR_R_SET_USERINFO r;
1067         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1068
1069         ZERO_STRUCT(q);
1070         ZERO_STRUCT(r);
1071
1072         /* Initialise parse structures */
1073
1074         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1075         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1076
1077         /* Marshall data and send request */
1078
1079         q.ctr = ctr;
1080
1081         init_samr_q_set_userinfo(&q, user_pol, sess_key, switch_value,
1082                                  ctr->info.id);
1083
1084         if (!samr_io_q_set_userinfo("", &q, &qbuf, 0) ||
1085             !rpc_api_pipe_req(cli, SAMR_SET_USERINFO, &qbuf, &rbuf)) {
1086                 goto done;
1087         }
1088
1089         /* Unmarshall response */
1090
1091         if (!samr_io_r_set_userinfo("", &r, &rbuf, 0)) {
1092                 goto done;
1093         }
1094
1095         /* Return output parameters */
1096
1097         if (!NT_STATUS_IS_OK(result = r.status)) {
1098                 goto done;
1099         }
1100
1101  done:
1102         prs_mem_free(&qbuf);
1103         prs_mem_free(&rbuf);
1104
1105         return result;
1106 }
1107
1108 /* Set userinfo2 */
1109
1110 NTSTATUS cli_samr_set_userinfo2(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1111                                 POLICY_HND *user_pol, uint16 switch_value,
1112                                 uchar sess_key[16], SAM_USERINFO_CTR *ctr)
1113 {
1114         prs_struct qbuf, rbuf;
1115         SAMR_Q_SET_USERINFO2 q;
1116         SAMR_R_SET_USERINFO2 r;
1117         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1118
1119         ZERO_STRUCT(q);
1120         ZERO_STRUCT(r);
1121
1122         /* Initialise parse structures */
1123
1124         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1125         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1126
1127         /* Marshall data and send request */
1128
1129         init_samr_q_set_userinfo2(&q, user_pol, sess_key, switch_value, ctr);
1130
1131         if (!samr_io_q_set_userinfo2("", &q, &qbuf, 0) ||
1132             !rpc_api_pipe_req(cli, SAMR_SET_USERINFO2, &qbuf, &rbuf)) {
1133                 goto done;
1134         }
1135
1136         /* Unmarshall response */
1137
1138         if (!samr_io_r_set_userinfo2("", &r, &rbuf, 0)) {
1139                 goto done;
1140         }
1141
1142         /* Return output parameters */
1143
1144         if (!NT_STATUS_IS_OK(result = r.status)) {
1145                 goto done;
1146         }
1147
1148  done:
1149         prs_mem_free(&qbuf);
1150         prs_mem_free(&rbuf);
1151
1152         return result;
1153 }
1154
1155 /* Delete domain user */
1156
1157 NTSTATUS cli_samr_delete_dom_user(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1158                                   POLICY_HND *user_pol)
1159 {
1160         prs_struct qbuf, rbuf;
1161         SAMR_Q_DELETE_DOM_USER q;
1162         SAMR_R_DELETE_DOM_USER r;
1163         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1164
1165         ZERO_STRUCT(q);
1166         ZERO_STRUCT(r);
1167
1168         /* Initialise parse structures */
1169
1170         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1171         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1172
1173         /* Marshall data and send request */
1174
1175         init_samr_q_delete_dom_user(&q, user_pol);
1176
1177         if (!samr_io_q_delete_dom_user("", &q, &qbuf, 0) ||
1178             !rpc_api_pipe_req(cli, SAMR_DELETE_DOM_USER, &qbuf, &rbuf)) {
1179                 goto done;
1180         }
1181
1182         /* Unmarshall response */
1183
1184         if (!samr_io_r_delete_dom_user("", &r, &rbuf, 0)) {
1185                 goto done;
1186         }
1187
1188         /* Return output parameters */
1189
1190         result = r.status;
1191
1192  done:
1193         prs_mem_free(&qbuf);
1194         prs_mem_free(&rbuf);
1195
1196         return result;
1197 }
1198
1199 /* Query user security object */
1200
1201 NTSTATUS cli_samr_query_sec_obj(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1202                                  POLICY_HND *user_pol, uint16 switch_value,
1203                                  TALLOC_CTX *ctx, SEC_DESC_BUF **sec_desc_buf)
1204 {
1205         prs_struct qbuf, rbuf;
1206         SAMR_Q_QUERY_SEC_OBJ q;
1207         SAMR_R_QUERY_SEC_OBJ r;
1208         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1209
1210         ZERO_STRUCT(q);
1211         ZERO_STRUCT(r);
1212
1213         /* Initialise parse structures */
1214
1215         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1216         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1217
1218         /* Marshall data and send request */
1219
1220         init_samr_q_query_sec_obj(&q, user_pol, switch_value);
1221
1222         if (!samr_io_q_query_sec_obj("", &q, &qbuf, 0) ||
1223             !rpc_api_pipe_req(cli, SAMR_QUERY_SEC_OBJECT, &qbuf, &rbuf)) {
1224                 goto done;
1225         }
1226
1227         /* Unmarshall response */
1228
1229         if (!samr_io_r_query_sec_obj("", &r, &rbuf, 0)) {
1230                 goto done;
1231         }
1232
1233         /* Return output parameters */
1234
1235         result = r.status;
1236         *sec_desc_buf=dup_sec_desc_buf(ctx, r.buf);
1237
1238  done:
1239         prs_mem_free(&qbuf);
1240         prs_mem_free(&rbuf);
1241
1242         return result;
1243 }
1244
1245 /* Get domain password info */
1246
1247 NTSTATUS cli_samr_get_dom_pwinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1248                                  uint16 *unk_0, uint16 *unk_1, uint16 *unk_2)
1249 {
1250         prs_struct qbuf, rbuf;
1251         SAMR_Q_GET_DOM_PWINFO q;
1252         SAMR_R_GET_DOM_PWINFO r;
1253         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1254
1255         ZERO_STRUCT(q);
1256         ZERO_STRUCT(r);
1257
1258         /* Initialise parse structures */
1259
1260         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1261         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1262
1263         /* Marshall data and send request */
1264
1265         init_samr_q_get_dom_pwinfo(&q, cli->desthost);
1266
1267         if (!samr_io_q_get_dom_pwinfo("", &q, &qbuf, 0) ||
1268             !rpc_api_pipe_req(cli, SAMR_GET_DOM_PWINFO, &qbuf, &rbuf))
1269                 goto done;
1270
1271         /* Unmarshall response */
1272
1273         if (!samr_io_r_get_dom_pwinfo("", &r, &rbuf, 0))
1274                 goto done;
1275
1276         /* Return output parameters */
1277
1278         result = r.status;
1279
1280         if (NT_STATUS_IS_OK(result)) {
1281                 if (unk_0)
1282                         *unk_0 = r.unk_0;
1283                 if (unk_1)
1284                         *unk_1 = r.unk_1;
1285                 if (unk_2)
1286                         *unk_2 = r.unk_2;
1287         }
1288
1289  done:
1290         prs_mem_free(&qbuf);
1291         prs_mem_free(&rbuf);
1292
1293         return result;
1294 }