source3/rpc_client/cli_lsarpc.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    Copyright (C) Michael Adam                           2007.
   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 3 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, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25
  26 /** @defgroup lsa LSA - Local Security Architecture
  27  *  @ingroup rpc_client
  28  *
  29  * @{
  30  **/
  31
  32 /**
  33  * @file cli_lsarpc.c
  34  *
  35  * RPC client routines for the LSA RPC pipe.  LSA means "local
  36  * security authority", which is half of a password database.
  37  **/
  38
  39 /** Open a LSA policy handle
  40  *
  41  * @param cli Handle on an initialised SMB connection */
  42
  43 NTSTATUS rpccli_lsa_open_policy(struct rpc_pipe_client *cli,
  44                                 TALLOC_CTX *mem_ctx,
  45                                 bool sec_qos, uint32 des_access,
  46                                 POLICY_HND *pol)
  47 {
  48         prs_struct qbuf, rbuf;
  49         LSA_Q_OPEN_POL q;
  50         LSA_R_OPEN_POL r;
  51         LSA_SEC_QOS qos;
  52         NTSTATUS result;
  53
  54         ZERO_STRUCT(q);
  55         ZERO_STRUCT(r);
  56
  57         /* Initialise input parameters */
  58
  59         if (sec_qos) {
  60                 init_lsa_sec_qos(&qos, 2, 1, 0);
  61                 init_q_open_pol(&q, '\\', 0, des_access, &qos);
  62         } else {
  63                 init_q_open_pol(&q, '\\', 0, des_access, NULL);
  64         }
  65
  66         /* Marshall data and send request */
  67
  68         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_OPENPOLICY,
  69                         q, r,
  70                         qbuf, rbuf,
  71                         lsa_io_q_open_pol,
  72                         lsa_io_r_open_pol,
  73                         NT_STATUS_UNSUCCESSFUL );
  74
  75         /* Return output parameters */
  76
  77         result = r.status;
  78
  79         if (NT_STATUS_IS_OK(result)) {
  80                 *pol = r.pol;
  81         }
  82
  83         return result;
  84 }
  85
  86 /** Open a LSA policy handle
  87   *
  88   * @param cli Handle on an initialised SMB connection
  89   */
  90
  91 NTSTATUS rpccli_lsa_open_policy2(struct rpc_pipe_client *cli,
  92                                  TALLOC_CTX *mem_ctx, bool sec_qos,
  93                                  uint32 des_access, POLICY_HND *pol)
  94 {
  95         prs_struct qbuf, rbuf;
  96         LSA_Q_OPEN_POL2 q;
  97         LSA_R_OPEN_POL2 r;
  98         LSA_SEC_QOS qos;
  99         NTSTATUS result;
 100         char *srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", cli->cli->desthost);
 101
 102         ZERO_STRUCT(q);
 103         ZERO_STRUCT(r);
 104
 105         if (sec_qos) {
 106                 init_lsa_sec_qos(&qos, 2, 1, 0);
 107                 init_q_open_pol2(&q, srv_name_slash, 0, des_access, &qos);
 108         } else {
 109                 init_q_open_pol2(&q, srv_name_slash, 0, des_access, NULL);
 110         }
 111
 112         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_OPENPOLICY2,
 113                         q, r,
 114                         qbuf, rbuf,
 115                         lsa_io_q_open_pol2,
 116                         lsa_io_r_open_pol2,
 117                         NT_STATUS_UNSUCCESSFUL );
 118
 119         /* Return output parameters */
 120
 121         result = r.status;
 122
 123         if (NT_STATUS_IS_OK(result)) {
 124                 *pol = r.pol;
 125         }
 126
 127         return result;
 128 }
 129
 130 /* Lookup a list of sids
 131  *
 132  * internal version withOUT memory allocation of the target arrays.
 133  * this assumes suffciently sized arrays to store domains, names and types. */
 134
 135 static NTSTATUS rpccli_lsa_lookup_sids_noalloc(struct rpc_pipe_client *cli,
 136                                                TALLOC_CTX *mem_ctx,
 137                                                POLICY_HND *pol,
 138                                                int num_sids,
 139                                                const DOM_SID *sids,
 140                                                char **domains,
 141                                                char **names,
 142                                                enum lsa_SidType *types)
 143 {
 144         prs_struct qbuf, rbuf;
 145         LSA_Q_LOOKUP_SIDS q;
 146         LSA_R_LOOKUP_SIDS r;
 147         DOM_R_REF ref;
 148         NTSTATUS result = NT_STATUS_OK;
 149         TALLOC_CTX *tmp_ctx = NULL;
 150         int i;
 151
 152         tmp_ctx = talloc_new(mem_ctx);
 153         if (!tmp_ctx) {
 154                 DEBUG(0, ("rpccli_lsa_lookup_sids_noalloc: out of memory!\n"));
 155                 result = NT_STATUS_UNSUCCESSFUL;
 156                 goto done;
 157         }
 158
 159         ZERO_STRUCT(q);
 160         ZERO_STRUCT(r);
 161
 162         init_q_lookup_sids(tmp_ctx, &q, pol, num_sids, sids, 1);
 163
 164         ZERO_STRUCT(ref);
 165
 166         r.dom_ref = &ref;
 167
 168         CLI_DO_RPC( cli, tmp_ctx, PI_LSARPC, LSA_LOOKUPSIDS,
 169                         q, r,
 170                         qbuf, rbuf,
 171                         lsa_io_q_lookup_sids,
 172                         lsa_io_r_lookup_sids,
 173                         NT_STATUS_UNSUCCESSFUL );
 174
 175         DEBUG(10, ("LSA_LOOKUPSIDS returned '%s', mapped count = %d'\n",
 176                    nt_errstr(r.status), r.mapped_count));
 177
 178         if (!NT_STATUS_IS_OK(r.status) &&
 179             !NT_STATUS_EQUAL(r.status, NT_STATUS_NONE_MAPPED) &&
 180             !NT_STATUS_EQUAL(r.status, STATUS_SOME_UNMAPPED))
 181         {
 182                 /* An actual error occured */
 183                 result = r.status;
 184                 goto done;
 185         }
 186
 187         /* Return output parameters */
 188
 189         if (NT_STATUS_EQUAL(r.status, NT_STATUS_NONE_MAPPED) ||
 190             (r.mapped_count == 0))
 191         {
 192                 for (i = 0; i < num_sids; i++) {
 193                         (names)[i] = NULL;
 194                         (domains)[i] = NULL;
 195                         (types)[i] = SID_NAME_UNKNOWN;
 196                 }
 197                 result = NT_STATUS_NONE_MAPPED;
 198                 goto done;
 199         }
 200
 201         for (i = 0; i < num_sids; i++) {
 202                 fstring name, dom_name;
 203                 uint32 dom_idx = r.names.name[i].domain_idx;
 204
 205                 /* Translate optimised name through domain index array */
 206
 207                 if (dom_idx != 0xffffffff) {
 208
 209                         rpcstr_pull_unistr2_fstring(
 210                                 dom_name, &ref.ref_dom[dom_idx].uni_dom_name);
 211                         rpcstr_pull_unistr2_fstring(
 212                                 name, &r.names.uni_name[i]);
 213
 214                         (names)[i] = talloc_strdup(mem_ctx, name);
 215                         (domains)[i] = talloc_strdup(mem_ctx, dom_name);
 216                         (types)[i] = r.names.name[i].sid_name_use;
 217
 218                         if (((names)[i] == NULL) || ((domains)[i] == NULL)) {
 219                                 DEBUG(0, ("cli_lsa_lookup_sids_noalloc(): out of memory\n"));
 220                                 result = NT_STATUS_UNSUCCESSFUL;
 221                                 goto done;
 222                         }
 223
 224                 } else {
 225                         (names)[i] = NULL;
 226                         (domains)[i] = NULL;
 227                         (types)[i] = SID_NAME_UNKNOWN;
 228                 }
 229         }
 230
 231 done:
 232         TALLOC_FREE(tmp_ctx);
 233         return result;
 234 }
 235
 236 /* Lookup a list of sids
 237  *
 238  * do it the right way: there is a limit (of 20480 for w2k3) entries
 239  * returned by this call. when the sids list contains more entries,
 240  * empty lists are returned. This version of lsa_lookup_sids passes
 241  * the list of sids in hunks of LOOKUP_SIDS_HUNK_SIZE to the lsa call. */
 242
 243 /* This constant defines the limit of how many sids to look up
 244  * in one call (maximum). the limit from the server side is
 245  * at 20480 for win2k3, but we keep it at a save 1000 for now. */
 246 #define LOOKUP_SIDS_HUNK_SIZE 1000
 247
 248 NTSTATUS rpccli_lsa_lookup_sids(struct rpc_pipe_client *cli,
 249                                 TALLOC_CTX *mem_ctx,
 250                                 POLICY_HND *pol,
 251                                 int num_sids,
 252                                 const DOM_SID *sids,
 253                                 char ***domains,
 254                                 char ***names,
 255                                 enum lsa_SidType **types)
 256 {
 257         NTSTATUS result = NT_STATUS_OK;
 258         int sids_left = 0;
 259         int sids_processed = 0;
 260         const DOM_SID *hunk_sids = sids;
 261         char **hunk_domains = NULL;
 262         char **hunk_names = NULL;
 263         enum lsa_SidType *hunk_types = NULL;
 264
 265         if (num_sids) {
 266                 if (!((*domains) = TALLOC_ARRAY(mem_ctx, char *, num_sids))) {
 267                         DEBUG(0, ("rpccli_lsa_lookup_sids(): out of memory\n"));
 268                         result = NT_STATUS_NO_MEMORY;
 269                         goto fail;
 270                 }
 271
 272                 if (!((*names) = TALLOC_ARRAY(mem_ctx, char *, num_sids))) {
 273                         DEBUG(0, ("rpccli_lsa_lookup_sids(): out of memory\n"));
 274                         result = NT_STATUS_NO_MEMORY;
 275                         goto fail;
 276                 }
 277
 278                 if (!((*types) = TALLOC_ARRAY(mem_ctx, enum lsa_SidType, num_sids))) {
 279                         DEBUG(0, ("rpccli_lsa_lookup_sids(): out of memory\n"));
 280                         result = NT_STATUS_NO_MEMORY;
 281                         goto fail;
 282                 }
 283         } else {
 284                 (*domains) = NULL;
 285                 (*names) = NULL;
 286                 (*types) = NULL;
 287         }
 288
 289         sids_left = num_sids;
 290         hunk_domains = *domains;
 291         hunk_names = *names;
 292         hunk_types = *types;
 293
 294         while (sids_left > 0) {
 295                 int hunk_num_sids;
 296                 NTSTATUS hunk_result = NT_STATUS_OK;
 297
 298                 hunk_num_sids = ((sids_left > LOOKUP_SIDS_HUNK_SIZE)
 299                                 ? LOOKUP_SIDS_HUNK_SIZE
 300                                 : sids_left);
 301
 302                 DEBUG(10, ("rpccli_lsa_lookup_sids: processing items "
 303                            "%d -- %d of %d.\n",
 304                            sids_processed,
 305                            sids_processed + hunk_num_sids - 1,
 306                            num_sids));
 307
 308                 hunk_result = rpccli_lsa_lookup_sids_noalloc(cli,
 309                                                              mem_ctx,
 310                                                              pol,
 311                                                              hunk_num_sids,
 312                                                              hunk_sids,
 313                                                              hunk_domains,
 314                                                              hunk_names,
 315                                                              hunk_types);
 316
 317                 if (!NT_STATUS_IS_OK(hunk_result) &&
 318                     !NT_STATUS_EQUAL(hunk_result, STATUS_SOME_UNMAPPED) &&
 319                     !NT_STATUS_EQUAL(hunk_result, NT_STATUS_NONE_MAPPED))
 320                 {
 321                         /* An actual error occured */
 322                         result = hunk_result;
 323                         goto fail;
 324                 }
 325
 326                 /* adapt overall result */
 327                 if (( NT_STATUS_IS_OK(result) &&
 328                      !NT_STATUS_IS_OK(hunk_result))
 329                     ||
 330                     ( NT_STATUS_EQUAL(result, NT_STATUS_NONE_MAPPED) &&
 331                      !NT_STATUS_EQUAL(hunk_result, NT_STATUS_NONE_MAPPED)))
 332                 {
 333                         result = STATUS_SOME_UNMAPPED;
 334                 }
 335
 336                 sids_left -= hunk_num_sids;
 337                 sids_processed += hunk_num_sids; /* only used in DEBUG */
 338                 hunk_sids += hunk_num_sids;
 339                 hunk_domains += hunk_num_sids;
 340                 hunk_names += hunk_num_sids;
 341                 hunk_types += hunk_num_sids;
 342         }
 343
 344         return result;
 345
 346 fail:
 347         TALLOC_FREE(*domains);
 348         TALLOC_FREE(*names);
 349         TALLOC_FREE(*types);
 350         return result;
 351 }
 352
 353 /** Lookup a list of names */
 354
 355 NTSTATUS rpccli_lsa_lookup_names(struct rpc_pipe_client *cli,
 356                                  TALLOC_CTX *mem_ctx,
 357                                  POLICY_HND *pol, int num_names,
 358                                  const char **names,
 359                                  const char ***dom_names,
 360                                  int level,
 361                                  DOM_SID **sids,
 362                                  enum lsa_SidType **types)
 363 {
 364         prs_struct qbuf, rbuf;
 365         LSA_Q_LOOKUP_NAMES q;
 366         LSA_R_LOOKUP_NAMES r;
 367         DOM_R_REF ref;
 368         NTSTATUS result;
 369         int i;
 370
 371         ZERO_STRUCT(q);
 372         ZERO_STRUCT(r);
 373
 374         ZERO_STRUCT(ref);
 375         r.dom_ref = &ref;
 376
 377         init_q_lookup_names(mem_ctx, &q, pol, num_names, names, level);
 378
 379         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_LOOKUPNAMES,
 380                         q, r,
 381                         qbuf, rbuf,
 382                         lsa_io_q_lookup_names,
 383                         lsa_io_r_lookup_names,
 384                         NT_STATUS_UNSUCCESSFUL);
 385
 386         result = r.status;
 387
 388         if (!NT_STATUS_IS_OK(result) && NT_STATUS_V(result) !=
 389             NT_STATUS_V(STATUS_SOME_UNMAPPED)) {
 390
 391                 /* An actual error occured */
 392
 393                 goto done;
 394         }
 395
 396         /* Return output parameters */
 397
 398         if (r.mapped_count == 0) {
 399                 result = NT_STATUS_NONE_MAPPED;
 400                 goto done;
 401         }
 402
 403         if (num_names) {
 404                 if (!((*sids = TALLOC_ARRAY(mem_ctx, DOM_SID, num_names)))) {
 405                         DEBUG(0, ("cli_lsa_lookup_sids(): out of memory\n"));
 406                         result = NT_STATUS_NO_MEMORY;
 407                         goto done;
 408                 }
 409
 410                 if (!((*types = TALLOC_ARRAY(mem_ctx, enum lsa_SidType, num_names)))) {
 411                         DEBUG(0, ("cli_lsa_lookup_sids(): out of memory\n"));
 412                         result = NT_STATUS_NO_MEMORY;
 413                         goto done;
 414                 }
 415
 416                 if (dom_names != NULL) {
 417                         *dom_names = TALLOC_ARRAY(mem_ctx, const char *, num_names);
 418                         if (*dom_names == NULL) {
 419                                 DEBUG(0, ("cli_lsa_lookup_sids(): out of memory\n"));
 420                                 result = NT_STATUS_NO_MEMORY;
 421                                 goto done;
 422                         }
 423                 }
 424         } else {
 425                 *sids = NULL;
 426                 *types = NULL;
 427                 if (dom_names != NULL) {
 428                         *dom_names = NULL;
 429                 }
 430         }
 431
 432         for (i = 0; i < num_names; i++) {
 433                 DOM_RID *t_rids = r.dom_rid;
 434                 uint32 dom_idx = t_rids[i].rid_idx;
 435                 uint32 dom_rid = t_rids[i].rid;
 436                 DOM_SID *sid = &(*sids)[i];
 437
 438                 /* Translate optimised sid through domain index array */
 439
 440                 if (dom_idx == 0xffffffff) {
 441                         /* Nothing to do, this is unknown */
 442                         ZERO_STRUCTP(sid);
 443                         (*types)[i] = SID_NAME_UNKNOWN;
 444                         continue;
 445                 }
 446
 447                 sid_copy(sid, &ref.ref_dom[dom_idx].ref_dom.sid);
 448
 449                 if (dom_rid != 0xffffffff) {
 450                         sid_append_rid(sid, dom_rid);
 451                 }
 452
 453                 (*types)[i] = t_rids[i].type;
 454
 455                 if (dom_names == NULL) {
 456                         continue;
 457                 }
 458
 459                 (*dom_names)[i] = rpcstr_pull_unistr2_talloc(
 460                         *dom_names, &ref.ref_dom[dom_idx].uni_dom_name);
 461         }
 462
 463  done:
 464
 465         return result;
 466 }
 467
 468 /**
 469  * Enumerate list of trusted domains
 470  *
 471  * @param cli client state (cli_state) structure of the connection
 472  * @param mem_ctx memory context
 473  * @param pol opened lsa policy handle
 474  * @param enum_ctx enumeration context ie. index of first returned domain entry
 475  * @param pref_num_domains preferred max number of entries returned in one response
 476  * @param num_domains total number of trusted domains returned by response
 477  * @param domain_names returned trusted domain names
 478  * @param domain_sids returned trusted domain sids
 479  *
 480  * @return nt status code of response
 481  **/
 482
 483 NTSTATUS rpccli_lsa_enum_trust_dom(struct rpc_pipe_client *cli,
 484                                    TALLOC_CTX *mem_ctx,
 485                                    POLICY_HND *pol, uint32 *enum_ctx,
 486                                    uint32 *num_domains,
 487                                    char ***domain_names, DOM_SID **domain_sids)
 488 {
 489         prs_struct qbuf, rbuf;
 490         LSA_Q_ENUM_TRUST_DOM in;
 491         LSA_R_ENUM_TRUST_DOM out;
 492         int i;
 493         fstring tmp;
 494
 495         ZERO_STRUCT(in);
 496         ZERO_STRUCT(out);
 497
 498         /* 64k is enough for about 2000 trusted domains */
 499
 500         init_q_enum_trust_dom(&in, pol, *enum_ctx, 0x10000);
 501
 502         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_ENUMTRUSTDOM,
 503                     in, out,
 504                     qbuf, rbuf,
 505                     lsa_io_q_enum_trust_dom,
 506                     lsa_io_r_enum_trust_dom,
 507                     NT_STATUS_UNSUCCESSFUL );
 508
 509
 510         /* check for an actual error */
 511
 512         if ( !NT_STATUS_IS_OK(out.status)
 513                 && !NT_STATUS_EQUAL(out.status, NT_STATUS_NO_MORE_ENTRIES)
 514                 && !NT_STATUS_EQUAL(out.status, STATUS_MORE_ENTRIES) )
 515         {
 516                 return out.status;
 517         }
 518
 519         /* Return output parameters */
 520
 521         *num_domains  = out.count;
 522         *enum_ctx     = out.enum_context;
 523
 524         if ( out.count ) {
 525
 526                 /* Allocate memory for trusted domain names and sids */
 527
 528                 if ( !(*domain_names = TALLOC_ARRAY(mem_ctx, char *, out.count)) ) {
 529                         DEBUG(0, ("cli_lsa_enum_trust_dom(): out of memory\n"));
 530                         return NT_STATUS_NO_MEMORY;
 531                 }
 532
 533                 if ( !(*domain_sids = TALLOC_ARRAY(mem_ctx, DOM_SID, out.count)) ) {
 534                         DEBUG(0, ("cli_lsa_enum_trust_dom(): out of memory\n"));
 535                         return NT_STATUS_NO_MEMORY;
 536                 }
 537
 538                 /* Copy across names and sids */
 539
 540                 for (i = 0; i < out.count; i++) {
 541
 542                         rpcstr_pull( tmp, out.domlist->domains[i].name.string->buffer,
 543                                 sizeof(tmp), out.domlist->domains[i].name.length, 0);
 544                         (*domain_names)[i] = talloc_strdup(mem_ctx, tmp);
 545
 546                         sid_copy(&(*domain_sids)[i], &out.domlist->domains[i].sid->sid );
 547                 }
 548         }
 549
 550         return out.status;
 551 }
 552
 553 /** Enumerate privileges*/
 554
 555 NTSTATUS rpccli_lsa_enum_privilege(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 556                                 POLICY_HND *pol, uint32 *enum_context, uint32 pref_max_length,
 557                                 uint32 *count, char ***privs_name, uint32 **privs_high, uint32 **privs_low)
 558 {
 559         prs_struct qbuf, rbuf;
 560         LSA_Q_ENUM_PRIVS q;
 561         LSA_R_ENUM_PRIVS r;
 562         NTSTATUS result;
 563         int i;
 564
 565         ZERO_STRUCT(q);
 566         ZERO_STRUCT(r);
 567
 568         init_q_enum_privs(&q, pol, *enum_context, pref_max_length);
 569
 570         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_ENUM_PRIVS,
 571                 q, r,
 572                 qbuf, rbuf,
 573                 lsa_io_q_enum_privs,
 574                 lsa_io_r_enum_privs,
 575                 NT_STATUS_UNSUCCESSFUL);
 576
 577         result = r.status;
 578
 579         if (!NT_STATUS_IS_OK(result)) {
 580                 goto done;
 581         }
 582
 583         /* Return output parameters */
 584
 585         *enum_context = r.enum_context;
 586         *count = r.count;
 587
 588         if (r.count) {
 589                 if (!((*privs_name = TALLOC_ARRAY(mem_ctx, char *, r.count)))) {
 590                         DEBUG(0, ("(cli_lsa_enum_privilege): out of memory\n"));
 591                         result = NT_STATUS_UNSUCCESSFUL;
 592                         goto done;
 593                 }
 594
 595                 if (!((*privs_high = TALLOC_ARRAY(mem_ctx, uint32, r.count)))) {
 596                         DEBUG(0, ("(cli_lsa_enum_privilege): out of memory\n"));
 597                         result = NT_STATUS_UNSUCCESSFUL;
 598                         goto done;
 599                 }
 600
 601                 if (!((*privs_low = TALLOC_ARRAY(mem_ctx, uint32, r.count)))) {
 602                         DEBUG(0, ("(cli_lsa_enum_privilege): out of memory\n"));
 603                         result = NT_STATUS_UNSUCCESSFUL;
 604                         goto done;
 605                 }
 606         } else {
 607                 *privs_name = NULL;
 608                 *privs_high = NULL;
 609                 *privs_low = NULL;
 610         }
 611
 612         for (i = 0; i < r.count; i++) {
 613                 fstring name;
 614
 615                 rpcstr_pull_unistr2_fstring( name, &r.privs[i].name);
 616
 617                 (*privs_name)[i] = talloc_strdup(mem_ctx, name);
 618
 619                 (*privs_high)[i] = r.privs[i].luid_high;
 620                 (*privs_low)[i] = r.privs[i].luid_low;
 621         }
 622
 623  done:
 624
 625         return result;
 626 }
 627
 628 /** Get privilege name */
 629
 630 NTSTATUS rpccli_lsa_get_dispname(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 631                               POLICY_HND *pol, const char *name,
 632                               uint16 lang_id, uint16 lang_id_sys,
 633                               fstring description, uint16 *lang_id_desc)
 634 {
 635         prs_struct qbuf, rbuf;
 636         LSA_Q_PRIV_GET_DISPNAME q;
 637         LSA_R_PRIV_GET_DISPNAME r;
 638         NTSTATUS result;
 639
 640         ZERO_STRUCT(q);
 641         ZERO_STRUCT(r);
 642
 643         init_lsa_priv_get_dispname(&q, pol, name, lang_id, lang_id_sys);
 644
 645         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_PRIV_GET_DISPNAME,
 646                 q, r,
 647                 qbuf, rbuf,
 648                 lsa_io_q_priv_get_dispname,
 649                 lsa_io_r_priv_get_dispname,
 650                 NT_STATUS_UNSUCCESSFUL);
 651
 652         result = r.status;
 653
 654         if (!NT_STATUS_IS_OK(result)) {
 655                 goto done;
 656         }
 657
 658         /* Return output parameters */
 659
 660         rpcstr_pull_unistr2_fstring(description , &r.desc);
 661         *lang_id_desc = r.lang_id;
 662
 663  done:
 664
 665         return result;
 666 }
 667
 668 /** Enumerate list of SIDs  */
 669
 670 NTSTATUS rpccli_lsa_enum_sids(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 671                                 POLICY_HND *pol, uint32 *enum_ctx, uint32 pref_max_length,
 672                                 uint32 *num_sids, DOM_SID **sids)
 673 {
 674         prs_struct qbuf, rbuf;
 675         LSA_Q_ENUM_ACCOUNTS q;
 676         LSA_R_ENUM_ACCOUNTS r;
 677         NTSTATUS result;
 678         int i;
 679
 680         ZERO_STRUCT(q);
 681         ZERO_STRUCT(r);
 682
 683         init_lsa_q_enum_accounts(&q, pol, *enum_ctx, pref_max_length);
 684
 685         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_ENUM_ACCOUNTS,
 686                 q, r,
 687                 qbuf, rbuf,
 688                 lsa_io_q_enum_accounts,
 689                 lsa_io_r_enum_accounts,
 690                 NT_STATUS_UNSUCCESSFUL);
 691
 692         result = r.status;
 693
 694         if (!NT_STATUS_IS_OK(result)) {
 695                 goto done;
 696         }
 697
 698         if (r.sids.num_entries==0)
 699                 goto done;
 700
 701         /* Return output parameters */
 702
 703         *sids = TALLOC_ARRAY(mem_ctx, DOM_SID, r.sids.num_entries);
 704         if (!*sids) {
 705                 DEBUG(0, ("(cli_lsa_enum_sids): out of memory\n"));
 706                 result = NT_STATUS_UNSUCCESSFUL;
 707                 goto done;
 708         }
 709
 710         /* Copy across names and sids */
 711
 712         for (i = 0; i < r.sids.num_entries; i++) {
 713                 sid_copy(&(*sids)[i], &r.sids.sid[i].sid);
 714         }
 715
 716         *num_sids= r.sids.num_entries;
 717         *enum_ctx = r.enum_context;
 718
 719  done:
 720
 721         return result;
 722 }
 723
 724 /** Create a LSA user handle
 725  *
 726  * @param cli Handle on an initialised SMB connection
 727  *
 728  * FIXME: The code is actually identical to open account
 729  * TODO: Check and code what the function should exactly do
 730  *
 731  * */
 732
 733 NTSTATUS rpccli_lsa_create_account(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 734                              POLICY_HND *dom_pol, DOM_SID *sid, uint32 desired_access,
 735                              POLICY_HND *user_pol)
 736 {
 737         prs_struct qbuf, rbuf;
 738         LSA_Q_CREATEACCOUNT q;
 739         LSA_R_CREATEACCOUNT r;
 740         NTSTATUS result;
 741
 742         ZERO_STRUCT(q);
 743         ZERO_STRUCT(r);
 744
 745         /* Initialise input parameters */
 746
 747         init_lsa_q_create_account(&q, dom_pol, sid, desired_access);
 748
 749         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_CREATEACCOUNT,
 750                 q, r,
 751                 qbuf, rbuf,
 752                 lsa_io_q_create_account,
 753                 lsa_io_r_create_account,
 754                 NT_STATUS_UNSUCCESSFUL);
 755
 756         /* Return output parameters */
 757
 758         result = r.status;
 759
 760         if (NT_STATUS_IS_OK(result)) {
 761                 *user_pol = r.pol;
 762         }
 763
 764         return result;
 765 }
 766
 767 /** Open a LSA user handle
 768  *
 769  * @param cli Handle on an initialised SMB connection */
 770
 771 NTSTATUS rpccli_lsa_open_account(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 772                              POLICY_HND *dom_pol, DOM_SID *sid, uint32 des_access,
 773                              POLICY_HND *user_pol)
 774 {
 775         prs_struct qbuf, rbuf;
 776         LSA_Q_OPENACCOUNT q;
 777         LSA_R_OPENACCOUNT r;
 778         NTSTATUS result;
 779
 780         ZERO_STRUCT(q);
 781         ZERO_STRUCT(r);
 782
 783         /* Initialise input parameters */
 784
 785         init_lsa_q_open_account(&q, dom_pol, sid, des_access);
 786
 787         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_OPENACCOUNT,
 788                 q, r,
 789                 qbuf, rbuf,
 790                 lsa_io_q_open_account,
 791                 lsa_io_r_open_account,
 792                 NT_STATUS_UNSUCCESSFUL);
 793
 794         /* Return output parameters */
 795
 796         result = r.status;
 797
 798         if (NT_STATUS_IS_OK(result)) {
 799                 *user_pol = r.pol;
 800         }
 801
 802         return result;
 803 }
 804
 805 /** Enumerate user privileges
 806  *
 807  * @param cli Handle on an initialised SMB connection */
 808
 809 NTSTATUS rpccli_lsa_enum_privsaccount(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 810                              POLICY_HND *pol, uint32 *count, LUID_ATTR **set)
 811 {
 812         prs_struct qbuf, rbuf;
 813         LSA_Q_ENUMPRIVSACCOUNT q;
 814         LSA_R_ENUMPRIVSACCOUNT r;
 815         NTSTATUS result;
 816         int i;
 817
 818         ZERO_STRUCT(q);
 819         ZERO_STRUCT(r);
 820
 821         /* Initialise input parameters */
 822
 823         init_lsa_q_enum_privsaccount(&q, pol);
 824
 825         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_ENUMPRIVSACCOUNT,
 826                 q, r,
 827                 qbuf, rbuf,
 828                 lsa_io_q_enum_privsaccount,
 829                 lsa_io_r_enum_privsaccount,
 830                 NT_STATUS_UNSUCCESSFUL);
 831
 832         /* Return output parameters */
 833
 834         result = r.status;
 835
 836         if (!NT_STATUS_IS_OK(result)) {
 837                 goto done;
 838         }
 839
 840         if (r.count == 0)
 841                 goto done;
 842
 843         if (!((*set = TALLOC_ARRAY(mem_ctx, LUID_ATTR, r.count)))) {
 844                 DEBUG(0, ("(cli_lsa_enum_privsaccount): out of memory\n"));
 845                 result = NT_STATUS_UNSUCCESSFUL;
 846                 goto done;
 847         }
 848
 849         for (i=0; i<r.count; i++) {
 850                 (*set)[i].luid.low = r.set.set[i].luid.low;
 851                 (*set)[i].luid.high = r.set.set[i].luid.high;
 852                 (*set)[i].attr = r.set.set[i].attr;
 853         }
 854
 855         *count=r.count;
 856  done:
 857
 858         return result;
 859 }
 860
 861 /** Get a privilege value given its name */
 862
 863 NTSTATUS rpccli_lsa_lookup_priv_value(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 864                                  POLICY_HND *pol, const char *name, LUID *luid)
 865 {
 866         prs_struct qbuf, rbuf;
 867         LSA_Q_LOOKUP_PRIV_VALUE q;
 868         LSA_R_LOOKUP_PRIV_VALUE r;
 869         NTSTATUS result;
 870
 871         ZERO_STRUCT(q);
 872         ZERO_STRUCT(r);
 873
 874         /* Marshall data and send request */
 875
 876         init_lsa_q_lookup_priv_value(&q, pol, name);
 877
 878         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_LOOKUPPRIVVALUE,
 879                 q, r,
 880                 qbuf, rbuf,
 881                 lsa_io_q_lookup_priv_value,
 882                 lsa_io_r_lookup_priv_value,
 883                 NT_STATUS_UNSUCCESSFUL);
 884
 885         result = r.status;
 886
 887         if (!NT_STATUS_IS_OK(result)) {
 888                 goto done;
 889         }
 890
 891         /* Return output parameters */
 892
 893         (*luid).low=r.luid.low;
 894         (*luid).high=r.luid.high;
 895
 896  done:
 897
 898         return result;
 899 }
 900
 901 /* Enumerate account rights This is similar to enum_privileges but
 902    takes a SID directly, avoiding the open_account call.
 903 */
 904
 905 NTSTATUS rpccli_lsa_enum_account_rights(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 906                                      POLICY_HND *pol, DOM_SID *sid,
 907                                      uint32 *count, char ***priv_names)
 908 {
 909         prs_struct qbuf, rbuf;
 910         LSA_Q_ENUM_ACCT_RIGHTS q;
 911         LSA_R_ENUM_ACCT_RIGHTS r;
 912         NTSTATUS result;
 913         int i;
 914         fstring *privileges;
 915         char **names;
 916
 917         ZERO_STRUCT(q);
 918         ZERO_STRUCT(r);
 919
 920         /* Marshall data and send request */
 921         init_q_enum_acct_rights(&q, pol, 2, sid);
 922
 923         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_ENUMACCTRIGHTS,
 924                 q, r,
 925                 qbuf, rbuf,
 926                 lsa_io_q_enum_acct_rights,
 927                 lsa_io_r_enum_acct_rights,
 928                 NT_STATUS_UNSUCCESSFUL);
 929
 930         result = r.status;
 931
 932         if (!NT_STATUS_IS_OK(result)) {
 933                 goto done;
 934         }
 935
 936         *count = r.count;
 937         if (! *count) {
 938                 goto done;
 939         }
 940
 941
 942         privileges = TALLOC_ARRAY( mem_ctx, fstring, *count );
 943         names      = TALLOC_ARRAY( mem_ctx, char *, *count );
 944
 945         if ((privileges == NULL) || (names == NULL)) {
 946                 TALLOC_FREE(privileges);
 947                 TALLOC_FREE(names);
 948                 return NT_STATUS_NO_MEMORY;
 949         }
 950
 951         for ( i=0; i<*count; i++ ) {
 952                 UNISTR4 *uni_string = &r.rights->strings[i];
 953
 954                 if ( !uni_string->string )
 955                         continue;
 956
 957                 rpcstr_pull( privileges[i], uni_string->string->buffer, sizeof(privileges[i]), -1, STR_TERMINATE );
 958
 959                 /* now copy to the return array */
 960                 names[i] = talloc_strdup( mem_ctx, privileges[i] );
 961         }
 962
 963         *priv_names = names;
 964
 965 done:
 966
 967         return result;
 968 }
 969
 970
 971
 972 /* add account rights to an account. */
 973
 974 NTSTATUS rpccli_lsa_add_account_rights(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 975                                     POLICY_HND *pol, DOM_SID sid,
 976                                         uint32 count, const char **privs_name)
 977 {
 978         prs_struct qbuf, rbuf;
 979         LSA_Q_ADD_ACCT_RIGHTS q;
 980         LSA_R_ADD_ACCT_RIGHTS r;
 981         NTSTATUS result;
 982
 983         ZERO_STRUCT(q);
 984         ZERO_STRUCT(r);
 985
 986         /* Marshall data and send request */
 987         init_q_add_acct_rights(&q, pol, &sid, count, privs_name);
 988
 989         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_ADDACCTRIGHTS,
 990                 q, r,
 991                 qbuf, rbuf,
 992                 lsa_io_q_add_acct_rights,
 993                 lsa_io_r_add_acct_rights,
 994                 NT_STATUS_UNSUCCESSFUL);
 995
 996         result = r.status;
 997
 998         if (!NT_STATUS_IS_OK(result)) {
 999                 goto done;
1000         }
1001 done:
1002
1003         return result;
1004 }
1005
1006
1007 /* remove account rights for an account. */
1008
1009 NTSTATUS rpccli_lsa_remove_account_rights(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1010                                        POLICY_HND *pol, DOM_SID sid, bool removeall,
1011                                        uint32 count, const char **privs_name)
1012 {
1013         prs_struct qbuf, rbuf;
1014         LSA_Q_REMOVE_ACCT_RIGHTS q;
1015         LSA_R_REMOVE_ACCT_RIGHTS r;
1016         NTSTATUS result;
1017
1018         ZERO_STRUCT(q);
1019         ZERO_STRUCT(r);
1020
1021         /* Marshall data and send request */
1022         init_q_remove_acct_rights(&q, pol, &sid, removeall?1:0, count, privs_name);
1023
1024         CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_REMOVEACCTRIGHTS,
1025                 q, r,
1026                 qbuf, rbuf,
1027                 lsa_io_q_remove_acct_rights,
1028                 lsa_io_r_remove_acct_rights,
1029                 NT_STATUS_UNSUCCESSFUL);
1030
1031         result = r.status;
1032
1033         if (!NT_STATUS_IS_OK(result)) {
1034                 goto done;
1035         }
1036 done:
1037
1038         return result;
1039 }
1040
1041
1042 #if 0
1043
1044 /** An example of how to use the routines in this file.  Fetch a DOMAIN
1045     sid. Does complete cli setup / teardown anonymously. */
1046
1047 bool fetch_domain_sid( char *domain, char *remote_machine, DOM_SID *psid)
1048 {
1049         struct cli_state cli;
1050         NTSTATUS result;
1051         POLICY_HND lsa_pol;
1052         bool ret = False;
1053
1054         ZERO_STRUCT(cli);
1055         if(cli_initialise(&cli) == False) {
1056                 DEBUG(0,("fetch_domain_sid: unable to initialize client connection.\n"));
1057                 return False;
1058         }
1059
1060         if(!resolve_name( remote_machine, &cli.dest_ip, 0x20)) {
1061                 DEBUG(0,("fetch_domain_sid: Can't resolve address for %s\n", remote_machine));
1062                 goto done;
1063         }
1064
1065         if (!cli_connect(&cli, remote_machine, &cli.dest_ip)) {
1066                 DEBUG(0,("fetch_domain_sid: unable to connect to SMB server on \
1067 machine %s. Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
1068                 goto done;
1069         }
1070
1071         if (!attempt_netbios_session_request(&cli, global_myname(), remote_machine, &cli.dest_ip)) {
1072                 DEBUG(0,("fetch_domain_sid: machine %s rejected the NetBIOS session request.\n",
1073                         remote_machine));
1074                 goto done;
1075         }
1076
1077         cli.protocol = PROTOCOL_NT1;
1078
1079         if (!cli_negprot(&cli)) {
1080                 DEBUG(0,("fetch_domain_sid: machine %s rejected the negotiate protocol. \
1081 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
1082                 goto done;
1083         }
1084
1085         if (cli.protocol != PROTOCOL_NT1) {
1086                 DEBUG(0,("fetch_domain_sid: machine %s didn't negotiate NT protocol.\n",
1087                         remote_machine));
1088                 goto done;
1089         }
1090
1091         /*
1092          * Do an anonymous session setup.
1093          */
1094
1095         if (!cli_session_setup(&cli, "", "", 0, "", 0, "")) {
1096                 DEBUG(0,("fetch_domain_sid: machine %s rejected the session setup. \
1097 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
1098                 goto done;
1099         }
1100
1101         if (!(cli.sec_mode & NEGOTIATE_SECURITY_USER_LEVEL)) {
1102                 DEBUG(0,("fetch_domain_sid: machine %s isn't in user level security mode\n",
1103                         remote_machine));
1104                 goto done;
1105         }
1106
1107         if (!cli_send_tconX(&cli, "IPC$", "IPC", "", 1)) {
1108                 DEBUG(0,("fetch_domain_sid: machine %s rejected the tconX on the IPC$ share. \
1109 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
1110                 goto done;
1111         }
1112
1113         /* Fetch domain sid */
1114
1115         if (!cli_nt_session_open(&cli, PI_LSARPC)) {
1116                 DEBUG(0, ("fetch_domain_sid: Error connecting to SAM pipe\n"));
1117                 goto done;
1118         }
1119
1120         result = cli_lsa_open_policy(&cli, cli.mem_ctx, True, SEC_RIGHTS_QUERY_VALUE, &lsa_pol);
1121         if (!NT_STATUS_IS_OK(result)) {
1122                 DEBUG(0, ("fetch_domain_sid: Error opening lsa policy handle. %s\n",
1123                         nt_errstr(result) ));
1124                 goto done;
1125         }
1126
1127         result = cli_lsa_query_info_policy(&cli, cli.mem_ctx, &lsa_pol, 5, domain, psid);
1128         if (!NT_STATUS_IS_OK(result)) {
1129                 DEBUG(0, ("fetch_domain_sid: Error querying lsa policy handle. %s\n",
1130                         nt_errstr(result) ));
1131                 goto done;
1132         }
1133
1134         ret = True;
1135
1136   done:
1137
1138         cli_shutdown(&cli);
1139         return ret;
1140 }
1141
1142 #endif