source3/rpc_server/lsa/srv_lsa_nt.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-1997,
   5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   6  *  Copyright (C) Paul Ashton                       1997,
   7  *  Copyright (C) Jeremy Allison                    2001, 2006.
   8  *  Copyright (C) Rafal Szczesniak                  2002,
   9  *  Copyright (C) Jim McDonough <jmcd@us.ibm.com>   2002,
  10  *  Copyright (C) Simo Sorce                        2003.
  11  *  Copyright (C) Gerald (Jerry) Carter             2005.
  12  *  Copyright (C) Volker Lendecke                   2005.
  13  *  Copyright (C) Guenther Deschner                 2008.
  14  *  Copyright (C) Andrew Bartlett                   2010.
  15  *
  16  *  This program is free software; you can redistribute it and/or modify
  17  *  it under the terms of the GNU General Public License as published by
  18  *  the Free Software Foundation; either version 3 of the License, or
  19  *  (at your option) any later version.
  20  *
  21  *  This program is distributed in the hope that it will be useful,
  22  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  *  GNU General Public License for more details.
  25  *
  26  *  You should have received a copy of the GNU General Public License
  27  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  28  */
  29
  30 /* This is the implementation of the lsa server code. */
  31
  32 #include "includes.h"
  33 #include "../librpc/gen_ndr/srv_lsa.h"
  34 #include "secrets.h"
  35 #include "../librpc/gen_ndr/netlogon.h"
  36 #include "rpc_client/init_lsa.h"
  37 #include "../libcli/security/security.h"
  38
  39 #undef DBGC_CLASS
  40 #define DBGC_CLASS DBGC_RPC_SRV
  41
  42 #define MAX_LOOKUP_SIDS 0x5000 /* 20480 */
  43
  44 enum lsa_handle_type { LSA_HANDLE_POLICY_TYPE = 1, LSA_HANDLE_ACCOUNT_TYPE };
  45
  46 struct lsa_info {
  47         struct dom_sid sid;
  48         const char *name;
  49         uint32 access;
  50         enum lsa_handle_type type;
  51         struct security_descriptor *sd;
  52 };
  53
  54 const struct generic_mapping lsa_account_mapping = {
  55         LSA_ACCOUNT_READ,
  56         LSA_ACCOUNT_WRITE,
  57         LSA_ACCOUNT_EXECUTE,
  58         LSA_ACCOUNT_ALL_ACCESS
  59 };
  60
  61 const struct generic_mapping lsa_policy_mapping = {
  62         LSA_POLICY_READ,
  63         LSA_POLICY_WRITE,
  64         LSA_POLICY_EXECUTE,
  65         LSA_POLICY_ALL_ACCESS
  66 };
  67
  68 const struct generic_mapping lsa_secret_mapping = {
  69         LSA_SECRET_READ,
  70         LSA_SECRET_WRITE,
  71         LSA_SECRET_EXECUTE,
  72         LSA_SECRET_ALL_ACCESS
  73 };
  74
  75 const struct generic_mapping lsa_trusted_domain_mapping = {
  76         LSA_TRUSTED_DOMAIN_READ,
  77         LSA_TRUSTED_DOMAIN_WRITE,
  78         LSA_TRUSTED_DOMAIN_EXECUTE,
  79         LSA_TRUSTED_DOMAIN_ALL_ACCESS
  80 };
  81
  82 /***************************************************************************
  83  init_lsa_ref_domain_list - adds a domain if it's not already in, returns the index.
  84 ***************************************************************************/
  85
  86 static int init_lsa_ref_domain_list(TALLOC_CTX *mem_ctx,
  87                                     struct lsa_RefDomainList *ref,
  88                                     const char *dom_name,
  89                                     struct dom_sid *dom_sid)
  90 {
  91         int num = 0;
  92
  93         if (dom_name != NULL) {
  94                 for (num = 0; num < ref->count; num++) {
  95                         if (dom_sid_equal(dom_sid, ref->domains[num].sid)) {
  96                                 return num;
  97                         }
  98                 }
  99         } else {
 100                 num = ref->count;
 101         }
 102
 103         if (num >= LSA_REF_DOMAIN_LIST_MULTIPLIER) {
 104                 /* index not found, already at maximum domain limit */
 105                 return -1;
 106         }
 107
 108         ref->count = num + 1;
 109         ref->max_size = LSA_REF_DOMAIN_LIST_MULTIPLIER;
 110
 111         ref->domains = TALLOC_REALLOC_ARRAY(mem_ctx, ref->domains,
 112                                             struct lsa_DomainInfo, ref->count);
 113         if (!ref->domains) {
 114                 return -1;
 115         }
 116
 117         ZERO_STRUCT(ref->domains[num]);
 118
 119         init_lsa_StringLarge(&ref->domains[num].name, dom_name);
 120         ref->domains[num].sid = dom_sid_dup(mem_ctx, dom_sid);
 121         if (!ref->domains[num].sid) {
 122                 return -1;
 123         }
 124
 125         return num;
 126 }
 127
 128
 129 /***************************************************************************
 130  initialize a lsa_DomainInfo structure.
 131  ***************************************************************************/
 132
 133 static void init_dom_query_3(struct lsa_DomainInfo *r,
 134                              const char *name,
 135                              struct dom_sid *sid)
 136 {
 137         init_lsa_StringLarge(&r->name, name);
 138         r->sid = sid;
 139 }
 140
 141 /***************************************************************************
 142  initialize a lsa_DomainInfo structure.
 143  ***************************************************************************/
 144
 145 static void init_dom_query_5(struct lsa_DomainInfo *r,
 146                              const char *name,
 147                              struct dom_sid *sid)
 148 {
 149         init_lsa_StringLarge(&r->name, name);
 150         r->sid = sid;
 151 }
 152
 153 /***************************************************************************
 154  lookup_lsa_rids. Must be called as root for lookup_name to work.
 155  ***************************************************************************/
 156
 157 static NTSTATUS lookup_lsa_rids(TALLOC_CTX *mem_ctx,
 158                                 struct lsa_RefDomainList *ref,
 159                                 struct lsa_TranslatedSid *prid,
 160                                 uint32_t num_entries,
 161                                 struct lsa_String *name,
 162                                 int flags,
 163                                 uint32_t *pmapped_count)
 164 {
 165         uint32 mapped_count, i;
 166
 167         SMB_ASSERT(num_entries <= MAX_LOOKUP_SIDS);
 168
 169         mapped_count = 0;
 170         *pmapped_count = 0;
 171
 172         for (i = 0; i < num_entries; i++) {
 173                 struct dom_sid sid;
 174                 uint32 rid;
 175                 int dom_idx;
 176                 const char *full_name;
 177                 const char *domain;
 178                 enum lsa_SidType type = SID_NAME_UNKNOWN;
 179
 180                 /* Split name into domain and user component */
 181
 182                 /* follow w2k8 behavior and return the builtin domain when no
 183                  * input has been passed in */
 184
 185                 if (name[i].string) {
 186                         full_name = name[i].string;
 187                 } else {
 188                         full_name = "BUILTIN";
 189                 }
 190
 191                 DEBUG(5, ("lookup_lsa_rids: looking up name %s\n", full_name));
 192
 193                 /* We can ignore the result of lookup_name, it will not touch
 194                    "type" if it's not successful */
 195
 196                 lookup_name(mem_ctx, full_name, flags, &domain, NULL,
 197                             &sid, &type);
 198
 199                 switch (type) {
 200                 case SID_NAME_USER:
 201                 case SID_NAME_DOM_GRP:
 202                 case SID_NAME_DOMAIN:
 203                 case SID_NAME_ALIAS:
 204                 case SID_NAME_WKN_GRP:
 205                         DEBUG(5, ("init_lsa_rids: %s found\n", full_name));
 206                         /* Leave these unchanged */
 207                         break;
 208                 default:
 209                         /* Don't hand out anything but the list above */
 210                         DEBUG(5, ("init_lsa_rids: %s not found\n", full_name));
 211                         type = SID_NAME_UNKNOWN;
 212                         break;
 213                 }
 214
 215                 rid = 0;
 216                 dom_idx = -1;
 217
 218                 if (type != SID_NAME_UNKNOWN) {
 219                         if (type == SID_NAME_DOMAIN) {
 220                                 rid = (uint32_t)-1;
 221                         } else {
 222                                 sid_split_rid(&sid, &rid);
 223                         }
 224                         dom_idx = init_lsa_ref_domain_list(mem_ctx, ref, domain, &sid);
 225                         mapped_count++;
 226                 }
 227
 228                 prid[i].sid_type        = type;
 229                 prid[i].rid             = rid;
 230                 prid[i].sid_index       = dom_idx;
 231         }
 232
 233         *pmapped_count = mapped_count;
 234         return NT_STATUS_OK;
 235 }
 236
 237 /***************************************************************************
 238  lookup_lsa_sids. Must be called as root for lookup_name to work.
 239  ***************************************************************************/
 240
 241 static NTSTATUS lookup_lsa_sids(TALLOC_CTX *mem_ctx,
 242                                 struct lsa_RefDomainList *ref,
 243                                 struct lsa_TranslatedSid3 *trans_sids,
 244                                 uint32_t num_entries,
 245                                 struct lsa_String *name,
 246                                 int flags,
 247                                 uint32 *pmapped_count)
 248 {
 249         uint32 mapped_count, i;
 250
 251         SMB_ASSERT(num_entries <= MAX_LOOKUP_SIDS);
 252
 253         mapped_count = 0;
 254         *pmapped_count = 0;
 255
 256         for (i = 0; i < num_entries; i++) {
 257                 struct dom_sid sid;
 258                 uint32 rid;
 259                 int dom_idx;
 260                 const char *full_name;
 261                 const char *domain;
 262                 enum lsa_SidType type = SID_NAME_UNKNOWN;
 263
 264                 ZERO_STRUCT(sid);
 265
 266                 /* Split name into domain and user component */
 267
 268                 full_name = name[i].string;
 269                 if (full_name == NULL) {
 270                         return NT_STATUS_NO_MEMORY;
 271                 }
 272
 273                 DEBUG(5, ("init_lsa_sids: looking up name %s\n", full_name));
 274
 275                 /* We can ignore the result of lookup_name, it will not touch
 276                    "type" if it's not successful */
 277
 278                 lookup_name(mem_ctx, full_name, flags, &domain, NULL,
 279                             &sid, &type);
 280
 281                 switch (type) {
 282                 case SID_NAME_USER:
 283                 case SID_NAME_DOM_GRP:
 284                 case SID_NAME_DOMAIN:
 285                 case SID_NAME_ALIAS:
 286                 case SID_NAME_WKN_GRP:
 287                         DEBUG(5, ("init_lsa_sids: %s found\n", full_name));
 288                         /* Leave these unchanged */
 289                         break;
 290                 default:
 291                         /* Don't hand out anything but the list above */
 292                         DEBUG(5, ("init_lsa_sids: %s not found\n", full_name));
 293                         type = SID_NAME_UNKNOWN;
 294                         break;
 295                 }
 296
 297                 rid = 0;
 298                 dom_idx = -1;
 299
 300                 if (type != SID_NAME_UNKNOWN) {
 301                         struct dom_sid domain_sid;
 302                         sid_copy(&domain_sid, &sid);
 303                         sid_split_rid(&domain_sid, &rid);
 304                         dom_idx = init_lsa_ref_domain_list(mem_ctx, ref, domain, &domain_sid);
 305                         mapped_count++;
 306                 }
 307
 308                 /* Initialize the lsa_TranslatedSid3 return. */
 309                 trans_sids[i].sid_type = type;
 310                 trans_sids[i].sid = dom_sid_dup(mem_ctx, &sid);
 311                 trans_sids[i].sid_index = dom_idx;
 312         }
 313
 314         *pmapped_count = mapped_count;
 315         return NT_STATUS_OK;
 316 }
 317
 318 static NTSTATUS make_lsa_object_sd(TALLOC_CTX *mem_ctx, struct security_descriptor **sd, size_t *sd_size,
 319                                         const struct generic_mapping *map,
 320                                         struct dom_sid *sid, uint32_t sid_access)
 321 {
 322         struct dom_sid adm_sid;
 323         struct security_ace ace[5];
 324         size_t i = 0;
 325
 326         struct security_acl *psa = NULL;
 327
 328         /* READ|EXECUTE access for Everyone */
 329
 330         init_sec_ace(&ace[i++], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED,
 331                         map->generic_execute | map->generic_read, 0);
 332
 333         /* Add Full Access 'BUILTIN\Administrators' and 'BUILTIN\Account Operators */
 334
 335         init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
 336                         SEC_ACE_TYPE_ACCESS_ALLOWED, map->generic_all, 0);
 337         init_sec_ace(&ace[i++], &global_sid_Builtin_Account_Operators,
 338                         SEC_ACE_TYPE_ACCESS_ALLOWED, map->generic_all, 0);
 339
 340         /* Add Full Access for Domain Admins */
 341         sid_compose(&adm_sid, get_global_sam_sid(), DOMAIN_RID_ADMINS);
 342         init_sec_ace(&ace[i++], &adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
 343                         map->generic_all, 0);
 344
 345         /* If we have a sid, give it some special access */
 346
 347         if (sid) {
 348                 init_sec_ace(&ace[i++], sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
 349                         sid_access, 0);
 350         }
 351
 352         if((psa = make_sec_acl(mem_ctx, NT4_ACL_REVISION, i, ace)) == NULL)
 353                 return NT_STATUS_NO_MEMORY;
 354
 355         if((*sd = make_sec_desc(mem_ctx, SECURITY_DESCRIPTOR_REVISION_1,
 356                                 SEC_DESC_SELF_RELATIVE, &adm_sid, NULL, NULL,
 357                                 psa, sd_size)) == NULL)
 358                 return NT_STATUS_NO_MEMORY;
 359
 360         return NT_STATUS_OK;
 361 }
 362
 363 /***************************************************************************
 364  ***************************************************************************/
 365
 366 static NTSTATUS create_lsa_policy_handle(TALLOC_CTX *mem_ctx,
 367                                          struct pipes_struct *p,
 368                                          enum lsa_handle_type type,
 369                                          uint32_t acc_granted,
 370                                          struct dom_sid *sid,
 371                                          const char *name,
 372                                          const struct security_descriptor *sd,
 373                                          struct policy_handle *handle)
 374 {
 375         struct lsa_info *info;
 376
 377         ZERO_STRUCTP(handle);
 378
 379         info = talloc_zero(mem_ctx, struct lsa_info);
 380         if (!info) {
 381                 return NT_STATUS_NO_MEMORY;
 382         }
 383
 384         info->type = type;
 385         info->access = acc_granted;
 386
 387         if (sid) {
 388                 sid_copy(&info->sid, sid);
 389         }
 390
 391         info->name = talloc_strdup(info, name);
 392
 393         if (sd) {
 394                 info->sd = dup_sec_desc(info, sd);
 395                 if (!info->sd) {
 396                         talloc_free(info);
 397                         return NT_STATUS_NO_MEMORY;
 398                 }
 399         }
 400
 401         if (!create_policy_hnd(p, handle, info)) {
 402                 talloc_free(info);
 403                 ZERO_STRUCTP(handle);
 404                 return NT_STATUS_NO_MEMORY;
 405         }
 406
 407         return NT_STATUS_OK;
 408 }
 409
 410 /***************************************************************************
 411  _lsa_OpenPolicy2
 412  ***************************************************************************/
 413
 414 NTSTATUS _lsa_OpenPolicy2(struct pipes_struct *p,
 415                           struct lsa_OpenPolicy2 *r)
 416 {
 417         struct security_descriptor *psd = NULL;
 418         size_t sd_size;
 419         uint32 des_access = r->in.access_mask;
 420         uint32 acc_granted;
 421         NTSTATUS status;
 422
 423         /* Work out max allowed. */
 424         map_max_allowed_access(p->server_info->security_token,
 425                                &p->server_info->utok,
 426                                &des_access);
 427
 428         /* map the generic bits to the lsa policy ones */
 429         se_map_generic(&des_access, &lsa_policy_mapping);
 430
 431         /* get the generic lsa policy SD until we store it */
 432         status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size, &lsa_policy_mapping,
 433                         NULL, 0);
 434         if (!NT_STATUS_IS_OK(status)) {
 435                 return status;
 436         }
 437
 438         status = access_check_object(psd, p->server_info->security_token,
 439                                      SEC_PRIV_INVALID, SEC_PRIV_INVALID, 0, des_access,
 440                                      &acc_granted, "_lsa_OpenPolicy2" );
 441         if (!NT_STATUS_IS_OK(status)) {
 442                 return status;
 443         }
 444
 445         status = create_lsa_policy_handle(p->mem_ctx, p,
 446                                           LSA_HANDLE_POLICY_TYPE,
 447                                           acc_granted,
 448                                           get_global_sam_sid(),
 449                                           NULL,
 450                                           psd,
 451                                           r->out.handle);
 452         if (!NT_STATUS_IS_OK(status)) {
 453                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 454         }
 455
 456         return NT_STATUS_OK;
 457 }
 458
 459 /***************************************************************************
 460  _lsa_OpenPolicy
 461  ***************************************************************************/
 462
 463 NTSTATUS _lsa_OpenPolicy(struct pipes_struct *p,
 464                          struct lsa_OpenPolicy *r)
 465 {
 466         struct lsa_OpenPolicy2 o;
 467
 468         o.in.system_name        = NULL; /* should be ignored */
 469         o.in.attr               = r->in.attr;
 470         o.in.access_mask        = r->in.access_mask;
 471
 472         o.out.handle            = r->out.handle;
 473
 474         return _lsa_OpenPolicy2(p, &o);
 475 }
 476
 477 /***************************************************************************
 478  _lsa_EnumTrustDom - this needs fixing to do more than return NULL ! JRA.
 479  ufff, done :)  mimir
 480  ***************************************************************************/
 481
 482 NTSTATUS _lsa_EnumTrustDom(struct pipes_struct *p,
 483                            struct lsa_EnumTrustDom *r)
 484 {
 485         struct lsa_info *info;
 486         uint32_t count;
 487         struct trustdom_info **domains;
 488         struct lsa_DomainInfo *entries;
 489         int i;
 490         NTSTATUS nt_status;
 491
 492         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
 493                 return NT_STATUS_INVALID_HANDLE;
 494
 495         if (info->type != LSA_HANDLE_POLICY_TYPE) {
 496                 return NT_STATUS_INVALID_HANDLE;
 497         }
 498
 499         /* check if the user has enough rights */
 500         if (!(info->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
 501                 return NT_STATUS_ACCESS_DENIED;
 502
 503         become_root();
 504         nt_status = pdb_enum_trusteddoms(p->mem_ctx, &count, &domains);
 505         unbecome_root();
 506
 507         if (!NT_STATUS_IS_OK(nt_status)) {
 508                 return nt_status;
 509         }
 510
 511         entries = TALLOC_ZERO_ARRAY(p->mem_ctx, struct lsa_DomainInfo, count);
 512         if (!entries) {
 513                 return NT_STATUS_NO_MEMORY;
 514         }
 515
 516         for (i=0; i<count; i++) {
 517                 init_lsa_StringLarge(&entries[i].name, domains[i]->name);
 518                 entries[i].sid = &domains[i]->sid;
 519         }
 520
 521         if (*r->in.resume_handle >= count) {
 522                 *r->out.resume_handle = -1;
 523                 TALLOC_FREE(entries);
 524                 return NT_STATUS_NO_MORE_ENTRIES;
 525         }
 526
 527         /* return the rest, limit by max_size. Note that we
 528            use the w2k3 element size value of 60 */
 529         r->out.domains->count = count - *r->in.resume_handle;
 530         r->out.domains->count = MIN(r->out.domains->count,
 531                                  1+(r->in.max_size/LSA_ENUM_TRUST_DOMAIN_MULTIPLIER));
 532
 533         r->out.domains->domains = entries + *r->in.resume_handle;
 534
 535         if (r->out.domains->count < count - *r->in.resume_handle) {
 536                 *r->out.resume_handle = *r->in.resume_handle + r->out.domains->count;
 537                 return STATUS_MORE_ENTRIES;
 538         }
 539
 540         /* according to MS-LSAD 3.1.4.7.8 output resume handle MUST
 541          * always be larger than the previous input resume handle, in
 542          * particular when hitting the last query it is vital to set the
 543          * resume handle correctly to avoid infinite client loops, as
 544          * seen e.g. with Windows XP SP3 when resume handle is 0 and
 545          * status is NT_STATUS_OK - gd */
 546
 547         *r->out.resume_handle = (uint32_t)-1;
 548
 549         return NT_STATUS_OK;
 550 }
 551
 552 #define LSA_AUDIT_NUM_CATEGORIES_NT4    7
 553 #define LSA_AUDIT_NUM_CATEGORIES_WIN2K  9
 554 #define LSA_AUDIT_NUM_CATEGORIES LSA_AUDIT_NUM_CATEGORIES_NT4
 555
 556 /***************************************************************************
 557  _lsa_QueryInfoPolicy
 558  ***************************************************************************/
 559
 560 NTSTATUS _lsa_QueryInfoPolicy(struct pipes_struct *p,
 561                               struct lsa_QueryInfoPolicy *r)
 562 {
 563         NTSTATUS status = NT_STATUS_OK;
 564         struct lsa_info *handle;
 565         struct dom_sid domain_sid;
 566         const char *name;
 567         struct dom_sid *sid = NULL;
 568         union lsa_PolicyInformation *info = NULL;
 569         uint32_t acc_required = 0;
 570
 571         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
 572                 return NT_STATUS_INVALID_HANDLE;
 573
 574         if (handle->type != LSA_HANDLE_POLICY_TYPE) {
 575                 return NT_STATUS_INVALID_HANDLE;
 576         }
 577
 578         switch (r->in.level) {
 579         case LSA_POLICY_INFO_AUDIT_LOG:
 580         case LSA_POLICY_INFO_AUDIT_EVENTS:
 581                 acc_required = LSA_POLICY_VIEW_AUDIT_INFORMATION;
 582                 break;
 583         case LSA_POLICY_INFO_DOMAIN:
 584                 acc_required = LSA_POLICY_VIEW_LOCAL_INFORMATION;
 585                 break;
 586         case LSA_POLICY_INFO_PD:
 587                 acc_required = LSA_POLICY_GET_PRIVATE_INFORMATION;
 588                 break;
 589         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
 590                 acc_required = LSA_POLICY_VIEW_LOCAL_INFORMATION;
 591                 break;
 592         case LSA_POLICY_INFO_ROLE:
 593         case LSA_POLICY_INFO_REPLICA:
 594                 acc_required = LSA_POLICY_VIEW_LOCAL_INFORMATION;
 595                 break;
 596         case LSA_POLICY_INFO_QUOTA:
 597                 acc_required = LSA_POLICY_VIEW_LOCAL_INFORMATION;
 598                 break;
 599         case LSA_POLICY_INFO_MOD:
 600         case LSA_POLICY_INFO_AUDIT_FULL_SET:
 601                 /* according to MS-LSAD 3.1.4.4.3 */
 602                 return NT_STATUS_INVALID_PARAMETER;
 603         case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
 604                 acc_required = LSA_POLICY_VIEW_AUDIT_INFORMATION;
 605                 break;
 606         case LSA_POLICY_INFO_DNS:
 607         case LSA_POLICY_INFO_DNS_INT:
 608         case LSA_POLICY_INFO_L_ACCOUNT_DOMAIN:
 609                 acc_required = LSA_POLICY_VIEW_LOCAL_INFORMATION;
 610                 break;
 611         default:
 612                 break;
 613         }
 614
 615         if (!(handle->access & acc_required)) {
 616                 /* return NT_STATUS_ACCESS_DENIED; */
 617         }
 618
 619         info = TALLOC_ZERO_P(p->mem_ctx, union lsa_PolicyInformation);
 620         if (!info) {
 621                 return NT_STATUS_NO_MEMORY;
 622         }
 623
 624         switch (r->in.level) {
 625         /* according to MS-LSAD 3.1.4.4.3 */
 626         case LSA_POLICY_INFO_MOD:
 627         case LSA_POLICY_INFO_AUDIT_FULL_SET:
 628         case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
 629                 return NT_STATUS_INVALID_PARAMETER;
 630         case LSA_POLICY_INFO_AUDIT_LOG:
 631                 info->audit_log.percent_full            = 0;
 632                 info->audit_log.maximum_log_size        = 0;
 633                 info->audit_log.retention_time          = 0;
 634                 info->audit_log.shutdown_in_progress    = 0;
 635                 info->audit_log.time_to_shutdown        = 0;
 636                 info->audit_log.next_audit_record       = 0;
 637                 status = NT_STATUS_OK;
 638                 break;
 639         case LSA_POLICY_INFO_PD:
 640                 info->pd.name.string                    = NULL;
 641                 status = NT_STATUS_OK;
 642                 break;
 643         case LSA_POLICY_INFO_REPLICA:
 644                 info->replica.source.string             = NULL;
 645                 info->replica.account.string            = NULL;
 646                 status = NT_STATUS_OK;
 647                 break;
 648         case LSA_POLICY_INFO_QUOTA:
 649                 info->quota.paged_pool                  = 0;
 650                 info->quota.non_paged_pool              = 0;
 651                 info->quota.min_wss                     = 0;
 652                 info->quota.max_wss                     = 0;
 653                 info->quota.pagefile                    = 0;
 654                 info->quota.unknown                     = 0;
 655                 status = NT_STATUS_OK;
 656                 break;
 657         case LSA_POLICY_INFO_AUDIT_EVENTS:
 658                 {
 659
 660                 uint32 policy_def = LSA_AUDIT_POLICY_ALL;
 661
 662                 /* check if the user has enough rights */
 663                 if (!(handle->access & LSA_POLICY_VIEW_AUDIT_INFORMATION)) {
 664                         DEBUG(10,("_lsa_QueryInfoPolicy: insufficient access rights\n"));
 665                         return NT_STATUS_ACCESS_DENIED;
 666                 }
 667
 668                 /* fake info: We audit everything. ;) */
 669
 670                 info->audit_events.auditing_mode = true;
 671                 info->audit_events.count = LSA_AUDIT_NUM_CATEGORIES;
 672                 info->audit_events.settings = TALLOC_ZERO_ARRAY(p->mem_ctx,
 673                                                                 enum lsa_PolicyAuditPolicy,
 674                                                                 info->audit_events.count);
 675                 if (!info->audit_events.settings) {
 676                         return NT_STATUS_NO_MEMORY;
 677                 }
 678
 679                 info->audit_events.settings[LSA_AUDIT_CATEGORY_ACCOUNT_MANAGEMENT] = policy_def;
 680                 info->audit_events.settings[LSA_AUDIT_CATEGORY_FILE_AND_OBJECT_ACCESS] = policy_def;
 681                 info->audit_events.settings[LSA_AUDIT_CATEGORY_LOGON] = policy_def;
 682                 info->audit_events.settings[LSA_AUDIT_CATEGORY_PROCCESS_TRACKING] = policy_def;
 683                 info->audit_events.settings[LSA_AUDIT_CATEGORY_SECURITY_POLICY_CHANGES] = policy_def;
 684                 info->audit_events.settings[LSA_AUDIT_CATEGORY_SYSTEM] = policy_def;
 685                 info->audit_events.settings[LSA_AUDIT_CATEGORY_USE_OF_USER_RIGHTS] = policy_def;
 686
 687                 break;
 688                 }
 689         case LSA_POLICY_INFO_DOMAIN:
 690                 /* check if the user has enough rights */
 691                 if (!(handle->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
 692                         return NT_STATUS_ACCESS_DENIED;
 693
 694                 /* Request PolicyPrimaryDomainInformation. */
 695                 switch (lp_server_role()) {
 696                         case ROLE_DOMAIN_PDC:
 697                         case ROLE_DOMAIN_BDC:
 698                                 name = get_global_sam_name();
 699                                 sid = dom_sid_dup(p->mem_ctx, get_global_sam_sid());
 700                                 if (!sid) {
 701                                         return NT_STATUS_NO_MEMORY;
 702                                 }
 703                                 break;
 704                         case ROLE_DOMAIN_MEMBER:
 705                                 name = lp_workgroup();
 706                                 /* We need to return the Domain SID here. */
 707                                 if (secrets_fetch_domain_sid(lp_workgroup(), &domain_sid)) {
 708                                         sid = dom_sid_dup(p->mem_ctx, &domain_sid);
 709                                         if (!sid) {
 710                                                 return NT_STATUS_NO_MEMORY;
 711                                         }
 712                                 } else {
 713                                         return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
 714                                 }
 715                                 break;
 716                         case ROLE_STANDALONE:
 717                                 name = lp_workgroup();
 718                                 sid = NULL;
 719                                 break;
 720                         default:
 721                                 return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
 722                 }
 723                 init_dom_query_3(&info->domain, name, sid);
 724                 break;
 725         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
 726                 /* check if the user has enough rights */
 727                 if (!(handle->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
 728                         return NT_STATUS_ACCESS_DENIED;
 729
 730                 /* Request PolicyAccountDomainInformation. */
 731                 name = get_global_sam_name();
 732                 sid = get_global_sam_sid();
 733
 734                 init_dom_query_5(&info->account_domain, name, sid);
 735                 break;
 736         case LSA_POLICY_INFO_ROLE:
 737                 /* check if the user has enough rights */
 738                 if (!(handle->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
 739                         return NT_STATUS_ACCESS_DENIED;
 740
 741                 switch (lp_server_role()) {
 742                         case ROLE_DOMAIN_BDC:
 743                                 /*
 744                                  * only a BDC is a backup controller
 745                                  * of the domain, it controls.
 746                                  */
 747                                 info->role.role = LSA_ROLE_BACKUP;
 748                                 break;
 749                         default:
 750                                 /*
 751                                  * any other role is a primary
 752                                  * of the domain, it controls.
 753                                  */
 754                                 info->role.role = LSA_ROLE_PRIMARY;
 755                                 break;
 756                 }
 757                 break;
 758         case LSA_POLICY_INFO_DNS:
 759         case LSA_POLICY_INFO_DNS_INT: {
 760                 struct pdb_domain_info *dominfo;
 761
 762                 if ((pdb_capabilities() & PDB_CAP_ADS) == 0) {
 763                         DEBUG(10, ("Not replying to LSA_POLICY_INFO_DNS "
 764                                    "without ADS passdb backend\n"));
 765                         status = NT_STATUS_INVALID_INFO_CLASS;
 766                         break;
 767                 }
 768
 769                 dominfo = pdb_get_domain_info(info);
 770                 if (dominfo == NULL) {
 771                         status = NT_STATUS_NO_MEMORY;
 772                         break;
 773                 }
 774
 775                 init_lsa_StringLarge(&info->dns.name,
 776                                      dominfo->name);
 777                 init_lsa_StringLarge(&info->dns.dns_domain,
 778                                      dominfo->dns_domain);
 779                 init_lsa_StringLarge(&info->dns.dns_forest,
 780                                      dominfo->dns_forest);
 781                 info->dns.domain_guid = dominfo->guid;
 782                 info->dns.sid = &dominfo->sid;
 783                 break;
 784         }
 785         default:
 786                 DEBUG(0,("_lsa_QueryInfoPolicy: unknown info level in Lsa Query: %d\n",
 787                         r->in.level));
 788                 status = NT_STATUS_INVALID_INFO_CLASS;
 789                 break;
 790         }
 791
 792         *r->out.info = info;
 793
 794         return status;
 795 }
 796
 797 /***************************************************************************
 798  _lsa_QueryInfoPolicy2
 799  ***************************************************************************/
 800
 801 NTSTATUS _lsa_QueryInfoPolicy2(struct pipes_struct *p,
 802                                struct lsa_QueryInfoPolicy2 *r2)
 803 {
 804         struct lsa_QueryInfoPolicy r;
 805
 806         if ((pdb_capabilities() & PDB_CAP_ADS) == 0) {
 807                 p->rng_fault_state = True;
 808                 return NT_STATUS_NOT_IMPLEMENTED;
 809         }
 810
 811         ZERO_STRUCT(r);
 812         r.in.handle = r2->in.handle;
 813         r.in.level = r2->in.level;
 814         r.out.info = r2->out.info;
 815
 816         return _lsa_QueryInfoPolicy(p, &r);
 817 }
 818
 819 /***************************************************************************
 820  _lsa_lookup_sids_internal
 821  ***************************************************************************/
 822
 823 static NTSTATUS _lsa_lookup_sids_internal(struct pipes_struct *p,
 824                                           TALLOC_CTX *mem_ctx,
 825                                           uint16_t level,                       /* input */
 826                                           int num_sids,                         /* input */
 827                                           struct lsa_SidPtr *sid,               /* input */
 828                                           struct lsa_RefDomainList **pp_ref,    /* input/output */
 829                                           struct lsa_TranslatedName2 **pp_names,/* input/output */
 830                                           uint32_t *pp_mapped_count)            /* input/output */
 831 {
 832         NTSTATUS status;
 833         int i;
 834         const struct dom_sid **sids = NULL;
 835         struct lsa_RefDomainList *ref = NULL;
 836         uint32 mapped_count = 0;
 837         struct lsa_dom_info *dom_infos = NULL;
 838         struct lsa_name_info *name_infos = NULL;
 839         struct lsa_TranslatedName2 *names = NULL;
 840
 841         *pp_mapped_count = 0;
 842         *pp_names = NULL;
 843         *pp_ref = NULL;
 844
 845         if (num_sids == 0) {
 846                 return NT_STATUS_OK;
 847         }
 848
 849         sids = TALLOC_ARRAY(p->mem_ctx, const struct dom_sid *, num_sids);
 850         ref = TALLOC_ZERO_P(p->mem_ctx, struct lsa_RefDomainList);
 851
 852         if (sids == NULL || ref == NULL) {
 853                 return NT_STATUS_NO_MEMORY;
 854         }
 855
 856         for (i=0; i<num_sids; i++) {
 857                 sids[i] = sid[i].sid;
 858         }
 859
 860         status = lookup_sids(p->mem_ctx, num_sids, sids, level,
 861                                   &dom_infos, &name_infos);
 862
 863         if (!NT_STATUS_IS_OK(status)) {
 864                 return status;
 865         }
 866
 867         names = TALLOC_ARRAY(p->mem_ctx, struct lsa_TranslatedName2, num_sids);
 868         if (names == NULL) {
 869                 return NT_STATUS_NO_MEMORY;
 870         }
 871
 872         for (i=0; i<LSA_REF_DOMAIN_LIST_MULTIPLIER; i++) {
 873
 874                 if (!dom_infos[i].valid) {
 875                         break;
 876                 }
 877
 878                 if (init_lsa_ref_domain_list(mem_ctx, ref,
 879                                              dom_infos[i].name,
 880                                              &dom_infos[i].sid) != i) {
 881                         DEBUG(0, ("Domain %s mentioned twice??\n",
 882                                   dom_infos[i].name));
 883                         return NT_STATUS_INTERNAL_ERROR;
 884                 }
 885         }
 886
 887         for (i=0; i<num_sids; i++) {
 888                 struct lsa_name_info *name = &name_infos[i];
 889
 890                 if (name->type == SID_NAME_UNKNOWN) {
 891                         fstring tmp;
 892                         name->dom_idx = -1;
 893                         /* Unknown sids should return the string
 894                          * representation of the SID. Windows 2003 behaves
 895                          * rather erratic here, in many cases it returns the
 896                          * RID as 8 bytes hex, in others it returns the full
 897                          * SID. We (Jerry/VL) could not figure out which the
 898                          * hard cases are, so leave it with the SID.  */
 899                         name->name = talloc_asprintf(p->mem_ctx, "%s",
 900                                                      sid_to_fstring(tmp,
 901                                                                     sids[i]));
 902                         if (name->name == NULL) {
 903                                 return NT_STATUS_NO_MEMORY;
 904                         }
 905                 } else {
 906                         mapped_count += 1;
 907                 }
 908
 909                 names[i].sid_type       = name->type;
 910                 names[i].name.string    = name->name;
 911                 names[i].sid_index      = name->dom_idx;
 912                 names[i].unknown        = 0;
 913         }
 914
 915         status = NT_STATUS_NONE_MAPPED;
 916         if (mapped_count > 0) {
 917                 status = (mapped_count < num_sids) ?
 918                         STATUS_SOME_UNMAPPED : NT_STATUS_OK;
 919         }
 920
 921         DEBUG(10, ("num_sids %d, mapped_count %d, status %s\n",
 922                    num_sids, mapped_count, nt_errstr(status)));
 923
 924         *pp_mapped_count = mapped_count;
 925         *pp_names = names;
 926         *pp_ref = ref;
 927
 928         return status;
 929 }
 930
 931 /***************************************************************************
 932  _lsa_LookupSids
 933  ***************************************************************************/
 934
 935 NTSTATUS _lsa_LookupSids(struct pipes_struct *p,
 936                          struct lsa_LookupSids *r)
 937 {
 938         NTSTATUS status;
 939         struct lsa_info *handle;
 940         int num_sids = r->in.sids->num_sids;
 941         uint32 mapped_count = 0;
 942         struct lsa_RefDomainList *domains = NULL;
 943         struct lsa_TranslatedName *names_out = NULL;
 944         struct lsa_TranslatedName2 *names = NULL;
 945         int i;
 946
 947         if ((r->in.level < 1) || (r->in.level > 6)) {
 948                 return NT_STATUS_INVALID_PARAMETER;
 949         }
 950
 951         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle)) {
 952                 return NT_STATUS_INVALID_HANDLE;
 953         }
 954
 955         if (handle->type != LSA_HANDLE_POLICY_TYPE) {
 956                 return NT_STATUS_INVALID_HANDLE;
 957         }
 958
 959         /* check if the user has enough rights */
 960         if (!(handle->access & LSA_POLICY_LOOKUP_NAMES)) {
 961                 return NT_STATUS_ACCESS_DENIED;
 962         }
 963
 964         if (num_sids >  MAX_LOOKUP_SIDS) {
 965                 DEBUG(5,("_lsa_LookupSids: limit of %d exceeded, requested %d\n",
 966                          MAX_LOOKUP_SIDS, num_sids));
 967                 return NT_STATUS_NONE_MAPPED;
 968         }
 969
 970         status = _lsa_lookup_sids_internal(p,
 971                                            p->mem_ctx,
 972                                            r->in.level,
 973                                            num_sids,
 974                                            r->in.sids->sids,
 975                                            &domains,
 976                                            &names,
 977                                            &mapped_count);
 978
 979         /* Only return here when there is a real error.
 980            NT_STATUS_NONE_MAPPED is a special case as it indicates that none of
 981            the requested sids could be resolved. Older versions of XP (pre SP3)
 982            rely that we return with the string representations of those SIDs in
 983            that case. If we don't, XP crashes - Guenther
 984            */
 985
 986         if (NT_STATUS_IS_ERR(status) &&
 987             !NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED)) {
 988                 return status;
 989         }
 990
 991         /* Convert from lsa_TranslatedName2 to lsa_TranslatedName */
 992         names_out = TALLOC_ARRAY(p->mem_ctx, struct lsa_TranslatedName,
 993                                  num_sids);
 994         if (!names_out) {
 995                 return NT_STATUS_NO_MEMORY;
 996         }
 997
 998         for (i=0; i<num_sids; i++) {
 999                 names_out[i].sid_type = names[i].sid_type;
1000                 names_out[i].name = names[i].name;
1001                 names_out[i].sid_index = names[i].sid_index;
1002         }
1003
1004         *r->out.domains = domains;
1005         r->out.names->count = num_sids;
1006         r->out.names->names = names_out;
1007         *r->out.count = mapped_count;
1008
1009         return status;
1010 }
1011
1012 /***************************************************************************
1013  _lsa_LookupSids2
1014  ***************************************************************************/
1015
1016 NTSTATUS _lsa_LookupSids2(struct pipes_struct *p,
1017                           struct lsa_LookupSids2 *r)
1018 {
1019         NTSTATUS status;
1020         struct lsa_info *handle;
1021         int num_sids = r->in.sids->num_sids;
1022         uint32 mapped_count = 0;
1023         struct lsa_RefDomainList *domains = NULL;
1024         struct lsa_TranslatedName2 *names = NULL;
1025         bool check_policy = true;
1026
1027         switch (p->opnum) {
1028                 case NDR_LSA_LOOKUPSIDS3:
1029                         check_policy = false;
1030                         break;
1031                 case NDR_LSA_LOOKUPSIDS2:
1032                 default:
1033                         check_policy = true;
1034         }
1035
1036         if ((r->in.level < 1) || (r->in.level > 6)) {
1037                 return NT_STATUS_INVALID_PARAMETER;
1038         }
1039
1040         if (check_policy) {
1041                 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle)) {
1042                         return NT_STATUS_INVALID_HANDLE;
1043                 }
1044
1045                 if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1046                         return NT_STATUS_INVALID_HANDLE;
1047                 }
1048
1049                 /* check if the user has enough rights */
1050                 if (!(handle->access & LSA_POLICY_LOOKUP_NAMES)) {
1051                         return NT_STATUS_ACCESS_DENIED;
1052                 }
1053         }
1054
1055         if (num_sids >  MAX_LOOKUP_SIDS) {
1056                 DEBUG(5,("_lsa_LookupSids2: limit of %d exceeded, requested %d\n",
1057                          MAX_LOOKUP_SIDS, num_sids));
1058                 return NT_STATUS_NONE_MAPPED;
1059         }
1060
1061         status = _lsa_lookup_sids_internal(p,
1062                                            p->mem_ctx,
1063                                            r->in.level,
1064                                            num_sids,
1065                                            r->in.sids->sids,
1066                                            &domains,
1067                                            &names,
1068                                            &mapped_count);
1069
1070         *r->out.domains = domains;
1071         r->out.names->count = num_sids;
1072         r->out.names->names = names;
1073         *r->out.count = mapped_count;
1074
1075         return status;
1076 }
1077
1078 /***************************************************************************
1079  _lsa_LookupSids3
1080  ***************************************************************************/
1081
1082 NTSTATUS _lsa_LookupSids3(struct pipes_struct *p,
1083                           struct lsa_LookupSids3 *r)
1084 {
1085         struct lsa_LookupSids2 q;
1086
1087         /* No policy handle on this call. Restrict to crypto connections. */
1088         if (p->auth.auth_type != DCERPC_AUTH_TYPE_SCHANNEL) {
1089                 DEBUG(0,("_lsa_LookupSids3: client %s not using schannel for netlogon\n",
1090                         get_remote_machine_name() ));
1091                 return NT_STATUS_INVALID_PARAMETER;
1092         }
1093
1094         q.in.handle             = NULL;
1095         q.in.sids               = r->in.sids;
1096         q.in.level              = r->in.level;
1097         q.in.lookup_options     = r->in.lookup_options;
1098         q.in.client_revision    = r->in.client_revision;
1099         q.in.names              = r->in.names;
1100         q.in.count              = r->in.count;
1101
1102         q.out.domains           = r->out.domains;
1103         q.out.names             = r->out.names;
1104         q.out.count             = r->out.count;
1105
1106         return _lsa_LookupSids2(p, &q);
1107 }
1108
1109 /***************************************************************************
1110  ***************************************************************************/
1111
1112 static int lsa_lookup_level_to_flags(enum lsa_LookupNamesLevel level)
1113 {
1114         int flags;
1115
1116         switch (level) {
1117                 case LSA_LOOKUP_NAMES_ALL: /* 1 */
1118                         flags = LOOKUP_NAME_ALL;
1119                         break;
1120                 case LSA_LOOKUP_NAMES_DOMAINS_ONLY: /* 2 */
1121                         flags = LOOKUP_NAME_DOMAIN|LOOKUP_NAME_REMOTE|LOOKUP_NAME_ISOLATED;
1122                         break;
1123                 case LSA_LOOKUP_NAMES_PRIMARY_DOMAIN_ONLY: /* 3 */
1124                         flags = LOOKUP_NAME_DOMAIN|LOOKUP_NAME_ISOLATED;
1125                         break;
1126                 case LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY: /* 4 */
1127                 case LSA_LOOKUP_NAMES_FOREST_TRUSTS_ONLY: /* 5 */
1128                 case LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY2: /* 6 */
1129                 case LSA_LOOKUP_NAMES_RODC_REFERRAL_TO_FULL_DC: /* 7 */
1130                 default:
1131                         flags = LOOKUP_NAME_NONE;
1132                         break;
1133         }
1134
1135         return flags;
1136 }
1137
1138 /***************************************************************************
1139  _lsa_LookupNames
1140  ***************************************************************************/
1141
1142 NTSTATUS _lsa_LookupNames(struct pipes_struct *p,
1143                           struct lsa_LookupNames *r)
1144 {
1145         NTSTATUS status = NT_STATUS_NONE_MAPPED;
1146         struct lsa_info *handle;
1147         struct lsa_String *names = r->in.names;
1148         uint32 num_entries = r->in.num_names;
1149         struct lsa_RefDomainList *domains = NULL;
1150         struct lsa_TranslatedSid *rids = NULL;
1151         uint32 mapped_count = 0;
1152         int flags = 0;
1153
1154         if (num_entries >  MAX_LOOKUP_SIDS) {
1155                 num_entries = MAX_LOOKUP_SIDS;
1156                 DEBUG(5,("_lsa_LookupNames: truncating name lookup list to %d\n",
1157                         num_entries));
1158         }
1159
1160         flags = lsa_lookup_level_to_flags(r->in.level);
1161
1162         domains = TALLOC_ZERO_P(p->mem_ctx, struct lsa_RefDomainList);
1163         if (!domains) {
1164                 return NT_STATUS_NO_MEMORY;
1165         }
1166
1167         if (num_entries) {
1168                 rids = TALLOC_ZERO_ARRAY(p->mem_ctx, struct lsa_TranslatedSid,
1169                                          num_entries);
1170                 if (!rids) {
1171                         return NT_STATUS_NO_MEMORY;
1172                 }
1173         } else {
1174                 rids = NULL;
1175         }
1176
1177         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle)) {
1178                 status = NT_STATUS_INVALID_HANDLE;
1179                 goto done;
1180         }
1181
1182         if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1183                 return NT_STATUS_INVALID_HANDLE;
1184         }
1185
1186         /* check if the user has enough rights */
1187         if (!(handle->access & LSA_POLICY_LOOKUP_NAMES)) {
1188                 status = NT_STATUS_ACCESS_DENIED;
1189                 goto done;
1190         }
1191
1192         /* set up the LSA Lookup RIDs response */
1193         become_root(); /* lookup_name can require root privs */
1194         status = lookup_lsa_rids(p->mem_ctx, domains, rids, num_entries,
1195                                  names, flags, &mapped_count);
1196         unbecome_root();
1197
1198 done:
1199
1200         if (NT_STATUS_IS_OK(status) && (num_entries != 0) ) {
1201                 if (mapped_count == 0) {
1202                         status = NT_STATUS_NONE_MAPPED;
1203                 } else if (mapped_count != num_entries) {
1204                         status = STATUS_SOME_UNMAPPED;
1205                 }
1206         }
1207
1208         *r->out.count = mapped_count;
1209         *r->out.domains = domains;
1210         r->out.sids->sids = rids;
1211         r->out.sids->count = num_entries;
1212
1213         return status;
1214 }
1215
1216 /***************************************************************************
1217  _lsa_LookupNames2
1218  ***************************************************************************/
1219
1220 NTSTATUS _lsa_LookupNames2(struct pipes_struct *p,
1221                            struct lsa_LookupNames2 *r)
1222 {
1223         NTSTATUS status;
1224         struct lsa_LookupNames q;
1225         struct lsa_TransSidArray2 *sid_array2 = r->in.sids;
1226         struct lsa_TransSidArray *sid_array = NULL;
1227         uint32_t i;
1228
1229         sid_array = TALLOC_ZERO_P(p->mem_ctx, struct lsa_TransSidArray);
1230         if (!sid_array) {
1231                 return NT_STATUS_NO_MEMORY;
1232         }
1233
1234         q.in.handle             = r->in.handle;
1235         q.in.num_names          = r->in.num_names;
1236         q.in.names              = r->in.names;
1237         q.in.level              = r->in.level;
1238         q.in.sids               = sid_array;
1239         q.in.count              = r->in.count;
1240         /* we do not know what this is for */
1241         /*                      = r->in.unknown1; */
1242         /*                      = r->in.unknown2; */
1243
1244         q.out.domains           = r->out.domains;
1245         q.out.sids              = sid_array;
1246         q.out.count             = r->out.count;
1247
1248         status = _lsa_LookupNames(p, &q);
1249
1250         sid_array2->count = sid_array->count;
1251         sid_array2->sids = TALLOC_ARRAY(p->mem_ctx, struct lsa_TranslatedSid2, sid_array->count);
1252         if (!sid_array2->sids) {
1253                 return NT_STATUS_NO_MEMORY;
1254         }
1255
1256         for (i=0; i<sid_array->count; i++) {
1257                 sid_array2->sids[i].sid_type  = sid_array->sids[i].sid_type;
1258                 sid_array2->sids[i].rid       = sid_array->sids[i].rid;
1259                 sid_array2->sids[i].sid_index = sid_array->sids[i].sid_index;
1260                 sid_array2->sids[i].unknown   = 0;
1261         }
1262
1263         r->out.sids = sid_array2;
1264
1265         return status;
1266 }
1267
1268 /***************************************************************************
1269  _lsa_LookupNames3
1270  ***************************************************************************/
1271
1272 NTSTATUS _lsa_LookupNames3(struct pipes_struct *p,
1273                            struct lsa_LookupNames3 *r)
1274 {
1275         NTSTATUS status;
1276         struct lsa_info *handle;
1277         struct lsa_String *names = r->in.names;
1278         uint32 num_entries = r->in.num_names;
1279         struct lsa_RefDomainList *domains = NULL;
1280         struct lsa_TranslatedSid3 *trans_sids = NULL;
1281         uint32 mapped_count = 0;
1282         int flags = 0;
1283         bool check_policy = true;
1284
1285         switch (p->opnum) {
1286                 case NDR_LSA_LOOKUPNAMES4:
1287                         check_policy = false;
1288                         break;
1289                 case NDR_LSA_LOOKUPNAMES3:
1290                 default:
1291                         check_policy = true;
1292         }
1293
1294         if (num_entries >  MAX_LOOKUP_SIDS) {
1295                 num_entries = MAX_LOOKUP_SIDS;
1296                 DEBUG(5,("_lsa_LookupNames3: truncating name lookup list to %d\n", num_entries));
1297         }
1298
1299         /* Probably the lookup_level is some sort of bitmask. */
1300         if (r->in.level == 1) {
1301                 flags = LOOKUP_NAME_ALL;
1302         }
1303
1304         domains = TALLOC_ZERO_P(p->mem_ctx, struct lsa_RefDomainList);
1305         if (!domains) {
1306                 return NT_STATUS_NO_MEMORY;
1307         }
1308
1309         if (num_entries) {
1310                 trans_sids = TALLOC_ZERO_ARRAY(p->mem_ctx, struct lsa_TranslatedSid3,
1311                                                num_entries);
1312                 if (!trans_sids) {
1313                         return NT_STATUS_NO_MEMORY;
1314                 }
1315         } else {
1316                 trans_sids = NULL;
1317         }
1318
1319         if (check_policy) {
1320
1321                 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle)) {
1322                         status = NT_STATUS_INVALID_HANDLE;
1323                         goto done;
1324                 }
1325
1326                 if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1327                         return NT_STATUS_INVALID_HANDLE;
1328                 }
1329
1330                 /* check if the user has enough rights */
1331                 if (!(handle->access & LSA_POLICY_LOOKUP_NAMES)) {
1332                         status = NT_STATUS_ACCESS_DENIED;
1333                         goto done;
1334                 }
1335         }
1336
1337         /* set up the LSA Lookup SIDs response */
1338         become_root(); /* lookup_name can require root privs */
1339         status = lookup_lsa_sids(p->mem_ctx, domains, trans_sids, num_entries,
1340                                  names, flags, &mapped_count);
1341         unbecome_root();
1342
1343 done:
1344
1345         if (NT_STATUS_IS_OK(status)) {
1346                 if (mapped_count == 0) {
1347                         status = NT_STATUS_NONE_MAPPED;
1348                 } else if (mapped_count != num_entries) {
1349                         status = STATUS_SOME_UNMAPPED;
1350                 }
1351         }
1352
1353         *r->out.count = mapped_count;
1354         *r->out.domains = domains;
1355         r->out.sids->sids = trans_sids;
1356         r->out.sids->count = num_entries;
1357
1358         return status;
1359 }
1360
1361 /***************************************************************************
1362  _lsa_LookupNames4
1363  ***************************************************************************/
1364
1365 NTSTATUS _lsa_LookupNames4(struct pipes_struct *p,
1366                            struct lsa_LookupNames4 *r)
1367 {
1368         struct lsa_LookupNames3 q;
1369
1370         /* No policy handle on this call. Restrict to crypto connections. */
1371         if (p->auth.auth_type != DCERPC_AUTH_TYPE_SCHANNEL) {
1372                 DEBUG(0,("_lsa_lookup_names4: client %s not using schannel for netlogon\n",
1373                         get_remote_machine_name() ));
1374                 return NT_STATUS_INVALID_PARAMETER;
1375         }
1376
1377         q.in.handle             = NULL;
1378         q.in.num_names          = r->in.num_names;
1379         q.in.names              = r->in.names;
1380         q.in.level              = r->in.level;
1381         q.in.lookup_options     = r->in.lookup_options;
1382         q.in.client_revision    = r->in.client_revision;
1383         q.in.sids               = r->in.sids;
1384         q.in.count              = r->in.count;
1385
1386         q.out.domains           = r->out.domains;
1387         q.out.sids              = r->out.sids;
1388         q.out.count             = r->out.count;
1389
1390         return _lsa_LookupNames3(p, &q);
1391 }
1392
1393 /***************************************************************************
1394  _lsa_close. Also weird - needs to check if lsa handle is correct. JRA.
1395  ***************************************************************************/
1396
1397 NTSTATUS _lsa_Close(struct pipes_struct *p, struct lsa_Close *r)
1398 {
1399         if (!find_policy_by_hnd(p, r->in.handle, NULL)) {
1400                 return NT_STATUS_INVALID_HANDLE;
1401         }
1402
1403         close_policy_hnd(p, r->in.handle);
1404         ZERO_STRUCTP(r->out.handle);
1405         return NT_STATUS_OK;
1406 }
1407
1408 /***************************************************************************
1409  ***************************************************************************/
1410
1411 NTSTATUS _lsa_OpenSecret(struct pipes_struct *p, struct lsa_OpenSecret *r)
1412 {
1413         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1414 }
1415
1416 /***************************************************************************
1417  ***************************************************************************/
1418
1419 NTSTATUS _lsa_OpenTrustedDomain(struct pipes_struct *p,
1420                                 struct lsa_OpenTrustedDomain *r)
1421 {
1422         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1423 }
1424
1425 /***************************************************************************
1426  ***************************************************************************/
1427
1428 NTSTATUS _lsa_CreateTrustedDomain(struct pipes_struct *p,
1429                                   struct lsa_CreateTrustedDomain *r)
1430 {
1431         return NT_STATUS_ACCESS_DENIED;
1432 }
1433
1434 /***************************************************************************
1435  ***************************************************************************/
1436
1437 NTSTATUS _lsa_CreateSecret(struct pipes_struct *p, struct lsa_CreateSecret *r)
1438 {
1439         return NT_STATUS_ACCESS_DENIED;
1440 }
1441
1442 /***************************************************************************
1443  ***************************************************************************/
1444
1445 NTSTATUS _lsa_SetSecret(struct pipes_struct *p, struct lsa_SetSecret *r)
1446 {
1447         return NT_STATUS_ACCESS_DENIED;
1448 }
1449
1450 /***************************************************************************
1451  _lsa_DeleteObject
1452  ***************************************************************************/
1453
1454 NTSTATUS _lsa_DeleteObject(struct pipes_struct *p,
1455                            struct lsa_DeleteObject *r)
1456 {
1457         NTSTATUS status;
1458         struct lsa_info *info = NULL;
1459
1460         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info)) {
1461                 return NT_STATUS_INVALID_HANDLE;
1462         }
1463
1464         if (!(info->access & SEC_STD_DELETE)) {
1465                 return NT_STATUS_ACCESS_DENIED;
1466         }
1467
1468         switch (info->type) {
1469         case LSA_HANDLE_ACCOUNT_TYPE:
1470                 status = privilege_delete_account(&info->sid);
1471                 if (!NT_STATUS_IS_OK(status)) {
1472                         DEBUG(10,("_lsa_DeleteObject: privilege_delete_account gave: %s\n",
1473                                 nt_errstr(status)));
1474                         return status;
1475                 }
1476                 break;
1477         default:
1478                 return NT_STATUS_INVALID_HANDLE;
1479         }
1480
1481         close_policy_hnd(p, r->in.handle);
1482         ZERO_STRUCTP(r->out.handle);
1483
1484         return status;
1485 }
1486
1487 /***************************************************************************
1488  _lsa_EnumPrivs
1489  ***************************************************************************/
1490
1491 NTSTATUS _lsa_EnumPrivs(struct pipes_struct *p,
1492                         struct lsa_EnumPrivs *r)
1493 {
1494         struct lsa_info *handle;
1495         uint32 i;
1496         uint32 enum_context = *r->in.resume_handle;
1497         int num_privs = num_privileges_in_short_list();
1498         struct lsa_PrivEntry *entries = NULL;
1499
1500         /* remember that the enum_context starts at 0 and not 1 */
1501
1502         if ( enum_context >= num_privs )
1503                 return NT_STATUS_NO_MORE_ENTRIES;
1504
1505         DEBUG(10,("_lsa_EnumPrivs: enum_context:%d total entries:%d\n",
1506                 enum_context, num_privs));
1507
1508         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
1509                 return NT_STATUS_INVALID_HANDLE;
1510
1511         if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1512                 return NT_STATUS_INVALID_HANDLE;
1513         }
1514
1515         /* check if the user has enough rights
1516            I don't know if it's the right one. not documented.  */
1517
1518         if (!(handle->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
1519                 return NT_STATUS_ACCESS_DENIED;
1520
1521         if (num_privs) {
1522                 entries = TALLOC_ZERO_ARRAY(p->mem_ctx, struct lsa_PrivEntry, num_privs);
1523                 if (!entries) {
1524                         return NT_STATUS_NO_MEMORY;
1525                 }
1526         } else {
1527                 entries = NULL;
1528         }
1529
1530         for (i = 0; i < num_privs; i++) {
1531                 if( i < enum_context) {
1532
1533                         init_lsa_StringLarge(&entries[i].name, NULL);
1534
1535                         entries[i].luid.low = 0;
1536                         entries[i].luid.high = 0;
1537                 } else {
1538
1539                         init_lsa_StringLarge(&entries[i].name, sec_privilege_name_from_index(i));
1540
1541                         entries[i].luid.low = sec_privilege_from_index(i);
1542                         entries[i].luid.high = 0;
1543                 }
1544         }
1545
1546         enum_context = num_privs;
1547
1548         *r->out.resume_handle = enum_context;
1549         r->out.privs->count = num_privs;
1550         r->out.privs->privs = entries;
1551
1552         return NT_STATUS_OK;
1553 }
1554
1555 /***************************************************************************
1556  _lsa_LookupPrivDisplayName
1557  ***************************************************************************/
1558
1559 NTSTATUS _lsa_LookupPrivDisplayName(struct pipes_struct *p,
1560                                     struct lsa_LookupPrivDisplayName *r)
1561 {
1562         struct lsa_info *handle;
1563         const char *description;
1564         struct lsa_StringLarge *lsa_name;
1565
1566         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
1567                 return NT_STATUS_INVALID_HANDLE;
1568
1569         if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1570                 return NT_STATUS_INVALID_HANDLE;
1571         }
1572
1573         /* check if the user has enough rights */
1574
1575         /*
1576          * I don't know if it's the right one. not documented.
1577          */
1578         if (!(handle->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
1579                 return NT_STATUS_ACCESS_DENIED;
1580
1581         DEBUG(10,("_lsa_LookupPrivDisplayName: name = %s\n", r->in.name->string));
1582
1583         description = get_privilege_dispname(r->in.name->string);
1584         if (!description) {
1585                 DEBUG(10,("_lsa_LookupPrivDisplayName: doesn't exist\n"));
1586                 return NT_STATUS_NO_SUCH_PRIVILEGE;
1587         }
1588
1589         DEBUG(10,("_lsa_LookupPrivDisplayName: display name = %s\n", description));
1590
1591         lsa_name = TALLOC_ZERO_P(p->mem_ctx, struct lsa_StringLarge);
1592         if (!lsa_name) {
1593                 return NT_STATUS_NO_MEMORY;
1594         }
1595
1596         init_lsa_StringLarge(lsa_name, description);
1597
1598         *r->out.returned_language_id = r->in.language_id;
1599         *r->out.disp_name = lsa_name;
1600
1601         return NT_STATUS_OK;
1602 }
1603
1604 /***************************************************************************
1605  _lsa_EnumAccounts
1606  ***************************************************************************/
1607
1608 NTSTATUS _lsa_EnumAccounts(struct pipes_struct *p,
1609                            struct lsa_EnumAccounts *r)
1610 {
1611         struct lsa_info *handle;
1612         struct dom_sid *sid_list;
1613         int i, j, num_entries;
1614         NTSTATUS status;
1615         struct lsa_SidPtr *sids = NULL;
1616
1617         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
1618                 return NT_STATUS_INVALID_HANDLE;
1619
1620         if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1621                 return NT_STATUS_INVALID_HANDLE;
1622         }
1623
1624         if (!(handle->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
1625                 return NT_STATUS_ACCESS_DENIED;
1626
1627         sid_list = NULL;
1628         num_entries = 0;
1629
1630         /* The only way we can currently find out all the SIDs that have been
1631            privileged is to scan all privileges */
1632
1633         status = privilege_enumerate_accounts(&sid_list, &num_entries);
1634         if (!NT_STATUS_IS_OK(status)) {
1635                 return status;
1636         }
1637
1638         if (*r->in.resume_handle >= num_entries) {
1639                 return NT_STATUS_NO_MORE_ENTRIES;
1640         }
1641
1642         if (num_entries - *r->in.resume_handle) {
1643                 sids = TALLOC_ZERO_ARRAY(p->mem_ctx, struct lsa_SidPtr,
1644                                          num_entries - *r->in.resume_handle);
1645                 if (!sids) {
1646                         talloc_free(sid_list);
1647                         return NT_STATUS_NO_MEMORY;
1648                 }
1649
1650                 for (i = *r->in.resume_handle, j = 0; i < num_entries; i++, j++) {
1651                         sids[j].sid = dom_sid_dup(p->mem_ctx, &sid_list[i]);
1652                         if (!sids[j].sid) {
1653                                 talloc_free(sid_list);
1654                                 return NT_STATUS_NO_MEMORY;
1655                         }
1656                 }
1657         }
1658
1659         talloc_free(sid_list);
1660
1661         *r->out.resume_handle = num_entries;
1662         r->out.sids->num_sids = num_entries;
1663         r->out.sids->sids = sids;
1664
1665         return NT_STATUS_OK;
1666 }
1667
1668 /***************************************************************************
1669  _lsa_GetUserName
1670  ***************************************************************************/
1671
1672 NTSTATUS _lsa_GetUserName(struct pipes_struct *p,
1673                           struct lsa_GetUserName *r)
1674 {
1675         const char *username, *domname;
1676         struct lsa_String *account_name = NULL;
1677         struct lsa_String *authority_name = NULL;
1678
1679         if (r->in.account_name &&
1680            *r->in.account_name) {
1681                 return NT_STATUS_INVALID_PARAMETER;
1682         }
1683
1684         if (r->in.authority_name &&
1685            *r->in.authority_name) {
1686                 return NT_STATUS_INVALID_PARAMETER;
1687         }
1688
1689         if (p->server_info->guest) {
1690                 /*
1691                  * I'm 99% sure this is not the right place to do this,
1692                  * global_sid_Anonymous should probably be put into the token
1693                  * instead of the guest id -- vl
1694                  */
1695                 if (!lookup_sid(p->mem_ctx, &global_sid_Anonymous,
1696                                 &domname, &username, NULL)) {
1697                         return NT_STATUS_NO_MEMORY;
1698                 }
1699         } else {
1700                 username = p->server_info->sanitized_username;
1701                 domname = p->server_info->info3->base.domain.string;
1702         }
1703
1704         account_name = TALLOC_P(p->mem_ctx, struct lsa_String);
1705         if (!account_name) {
1706                 return NT_STATUS_NO_MEMORY;
1707         }
1708         init_lsa_String(account_name, username);
1709
1710         if (r->out.authority_name) {
1711                 authority_name = TALLOC_P(p->mem_ctx, struct lsa_String);
1712                 if (!authority_name) {
1713                         return NT_STATUS_NO_MEMORY;
1714                 }
1715                 init_lsa_String(authority_name, domname);
1716         }
1717
1718         *r->out.account_name = account_name;
1719         if (r->out.authority_name) {
1720                 *r->out.authority_name = authority_name;
1721         }
1722
1723         return NT_STATUS_OK;
1724 }
1725
1726 /***************************************************************************
1727  _lsa_CreateAccount
1728  ***************************************************************************/
1729
1730 NTSTATUS _lsa_CreateAccount(struct pipes_struct *p,
1731                             struct lsa_CreateAccount *r)
1732 {
1733         NTSTATUS status;
1734         struct lsa_info *handle;
1735         uint32_t acc_granted;
1736         struct security_descriptor *psd;
1737         size_t sd_size;
1738
1739         /* find the connection policy handle. */
1740         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
1741                 return NT_STATUS_INVALID_HANDLE;
1742
1743         if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1744                 return NT_STATUS_INVALID_HANDLE;
1745         }
1746
1747         /* check if the user has enough rights */
1748
1749         if (!(handle->access & LSA_POLICY_CREATE_ACCOUNT)) {
1750                 return NT_STATUS_ACCESS_DENIED;
1751         }
1752
1753         /* Work out max allowed. */
1754         map_max_allowed_access(p->server_info->security_token,
1755                                &p->server_info->utok,
1756                                &r->in.access_mask);
1757
1758         /* map the generic bits to the lsa policy ones */
1759         se_map_generic(&r->in.access_mask, &lsa_account_mapping);
1760
1761         status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size,
1762                                     &lsa_account_mapping,
1763                                     r->in.sid, LSA_POLICY_ALL_ACCESS);
1764         if (!NT_STATUS_IS_OK(status)) {
1765                 return status;
1766         }
1767
1768         status = access_check_object(psd, p->server_info->security_token,
1769                                      SEC_PRIV_INVALID, SEC_PRIV_INVALID, 0, r->in.access_mask,
1770                                      &acc_granted, "_lsa_CreateAccount");
1771         if (!NT_STATUS_IS_OK(status)) {
1772                 return status;
1773         }
1774
1775         if ( is_privileged_sid( r->in.sid ) )
1776                 return NT_STATUS_OBJECT_NAME_COLLISION;
1777
1778         status = create_lsa_policy_handle(p->mem_ctx, p,
1779                                           LSA_HANDLE_ACCOUNT_TYPE,
1780                                           acc_granted,
1781                                           r->in.sid,
1782                                           NULL,
1783                                           psd,
1784                                           r->out.acct_handle);
1785         if (!NT_STATUS_IS_OK(status)) {
1786                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1787         }
1788
1789         return privilege_create_account(r->in.sid);
1790 }
1791
1792 /***************************************************************************
1793  _lsa_OpenAccount
1794  ***************************************************************************/
1795
1796 NTSTATUS _lsa_OpenAccount(struct pipes_struct *p,
1797                           struct lsa_OpenAccount *r)
1798 {
1799         struct lsa_info *handle;
1800         struct security_descriptor *psd = NULL;
1801         size_t sd_size;
1802         uint32_t des_access = r->in.access_mask;
1803         uint32_t acc_granted;
1804         NTSTATUS status;
1805
1806         /* find the connection policy handle. */
1807         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
1808                 return NT_STATUS_INVALID_HANDLE;
1809
1810         if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1811                 return NT_STATUS_INVALID_HANDLE;
1812         }
1813
1814         /* des_access is for the account here, not the policy
1815          * handle - so don't check against policy handle. */
1816
1817         /* Work out max allowed. */
1818         map_max_allowed_access(p->server_info->security_token,
1819                                &p->server_info->utok,
1820                                &des_access);
1821
1822         /* map the generic bits to the lsa account ones */
1823         se_map_generic(&des_access, &lsa_account_mapping);
1824
1825         /* get the generic lsa account SD until we store it */
1826         status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size,
1827                                 &lsa_account_mapping,
1828                                 r->in.sid, LSA_ACCOUNT_ALL_ACCESS);
1829         if (!NT_STATUS_IS_OK(status)) {
1830                 return status;
1831         }
1832
1833         status = access_check_object(psd, p->server_info->security_token,
1834                                      SEC_PRIV_INVALID, SEC_PRIV_INVALID, 0, des_access,
1835                                      &acc_granted, "_lsa_OpenAccount" );
1836         if (!NT_STATUS_IS_OK(status)) {
1837                 return status;
1838         }
1839
1840         /* TODO: Fis the parsing routine before reenabling this check! */
1841         #if 0
1842         if (!lookup_sid(&handle->sid, dom_name, name, &type))
1843                 return NT_STATUS_ACCESS_DENIED;
1844         #endif
1845
1846         status = create_lsa_policy_handle(p->mem_ctx, p,
1847                                           LSA_HANDLE_ACCOUNT_TYPE,
1848                                           acc_granted,
1849                                           r->in.sid,
1850                                           NULL,
1851                                           psd,
1852                                           r->out.acct_handle);
1853         if (!NT_STATUS_IS_OK(status)) {
1854                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1855         }
1856
1857         return NT_STATUS_OK;
1858 }
1859
1860 /***************************************************************************
1861  _lsa_EnumPrivsAccount
1862  For a given SID, enumerate all the privilege this account has.
1863  ***************************************************************************/
1864
1865 NTSTATUS _lsa_EnumPrivsAccount(struct pipes_struct *p,
1866                                struct lsa_EnumPrivsAccount *r)
1867 {
1868         NTSTATUS status = NT_STATUS_OK;
1869         struct lsa_info *info=NULL;
1870         PRIVILEGE_SET *privileges;
1871         struct lsa_PrivilegeSet *priv_set = NULL;
1872
1873         /* find the connection policy handle. */
1874         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
1875                 return NT_STATUS_INVALID_HANDLE;
1876
1877         if (info->type != LSA_HANDLE_ACCOUNT_TYPE) {
1878                 return NT_STATUS_INVALID_HANDLE;
1879         }
1880
1881         if (!(info->access & LSA_ACCOUNT_VIEW))
1882                 return NT_STATUS_ACCESS_DENIED;
1883
1884         status = get_privileges_for_sid_as_set(p->mem_ctx, &privileges, &info->sid);
1885         if (!NT_STATUS_IS_OK(status)) {
1886                 return status;
1887         }
1888
1889         *r->out.privs = priv_set = TALLOC_ZERO_P(p->mem_ctx, struct lsa_PrivilegeSet);
1890         if (!priv_set) {
1891                 return NT_STATUS_NO_MEMORY;
1892         }
1893
1894         DEBUG(10,("_lsa_EnumPrivsAccount: %s has %d privileges\n",
1895                   sid_string_dbg(&info->sid),
1896                   privileges->count));
1897
1898         priv_set->count = privileges->count;
1899         priv_set->unknown = 0;
1900         priv_set->set = talloc_move(priv_set, &privileges->set);
1901
1902         return status;
1903 }
1904
1905 /***************************************************************************
1906  _lsa_GetSystemAccessAccount
1907  ***************************************************************************/
1908
1909 NTSTATUS _lsa_GetSystemAccessAccount(struct pipes_struct *p,
1910                                      struct lsa_GetSystemAccessAccount *r)
1911 {
1912         NTSTATUS status;
1913         struct lsa_info *info = NULL;
1914         struct lsa_EnumPrivsAccount e;
1915         struct lsa_PrivilegeSet *privset;
1916
1917         /* find the connection policy handle. */
1918
1919         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
1920                 return NT_STATUS_INVALID_HANDLE;
1921
1922         if (info->type != LSA_HANDLE_ACCOUNT_TYPE) {
1923                 return NT_STATUS_INVALID_HANDLE;
1924         }
1925
1926         if (!(info->access & LSA_ACCOUNT_VIEW))
1927                 return NT_STATUS_ACCESS_DENIED;
1928
1929         privset = talloc_zero(p->mem_ctx, struct lsa_PrivilegeSet);
1930         if (!privset) {
1931                 return NT_STATUS_NO_MEMORY;
1932         }
1933
1934         e.in.handle = r->in.handle;
1935         e.out.privs = &privset;
1936
1937         status = _lsa_EnumPrivsAccount(p, &e);
1938         if (!NT_STATUS_IS_OK(status)) {
1939                 DEBUG(10,("_lsa_GetSystemAccessAccount: "
1940                         "failed to call _lsa_EnumPrivsAccount(): %s\n",
1941                         nt_errstr(status)));
1942                 return status;
1943         }
1944
1945         /* Samba4 would iterate over the privset to merge the policy mode bits,
1946          * not sure samba3 can do the same here, so just return what we did in
1947          * the past - gd */
1948
1949         /*
1950           0x01 -> Log on locally
1951           0x02 -> Access this computer from network
1952           0x04 -> Log on as a batch job
1953           0x10 -> Log on as a service
1954
1955           they can be ORed together
1956         */
1957
1958         *r->out.access_mask = LSA_POLICY_MODE_INTERACTIVE |
1959                               LSA_POLICY_MODE_NETWORK;
1960
1961         return NT_STATUS_OK;
1962 }
1963
1964 /***************************************************************************
1965   update the systemaccount information
1966  ***************************************************************************/
1967
1968 NTSTATUS _lsa_SetSystemAccessAccount(struct pipes_struct *p,
1969                                      struct lsa_SetSystemAccessAccount *r)
1970 {
1971         struct lsa_info *info=NULL;
1972         GROUP_MAP map;
1973
1974         /* find the connection policy handle. */
1975         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
1976                 return NT_STATUS_INVALID_HANDLE;
1977
1978         if (info->type != LSA_HANDLE_ACCOUNT_TYPE) {
1979                 return NT_STATUS_INVALID_HANDLE;
1980         }
1981
1982         if (!(info->access & LSA_ACCOUNT_ADJUST_SYSTEM_ACCESS)) {
1983                 return NT_STATUS_ACCESS_DENIED;
1984         }
1985
1986         if (!pdb_getgrsid(&map, info->sid))
1987                 return NT_STATUS_NO_SUCH_GROUP;
1988
1989         return pdb_update_group_mapping_entry(&map);
1990 }
1991
1992 /***************************************************************************
1993  _lsa_AddPrivilegesToAccount
1994  For a given SID, add some privileges.
1995  ***************************************************************************/
1996
1997 NTSTATUS _lsa_AddPrivilegesToAccount(struct pipes_struct *p,
1998                                      struct lsa_AddPrivilegesToAccount *r)
1999 {
2000         struct lsa_info *info = NULL;
2001         struct lsa_PrivilegeSet *set = NULL;
2002
2003         /* find the connection policy handle. */
2004         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
2005                 return NT_STATUS_INVALID_HANDLE;
2006
2007         if (info->type != LSA_HANDLE_ACCOUNT_TYPE) {
2008                 return NT_STATUS_INVALID_HANDLE;
2009         }
2010
2011         if (!(info->access & LSA_ACCOUNT_ADJUST_PRIVILEGES)) {
2012                 return NT_STATUS_ACCESS_DENIED;
2013         }
2014
2015         set = r->in.privs;
2016
2017         if ( !grant_privilege_set( &info->sid, set ) ) {
2018                 DEBUG(3,("_lsa_AddPrivilegesToAccount: grant_privilege_set(%s) failed!\n",
2019                          sid_string_dbg(&info->sid) ));
2020                 return NT_STATUS_NO_SUCH_PRIVILEGE;
2021         }
2022
2023         return NT_STATUS_OK;
2024 }
2025
2026 /***************************************************************************
2027  _lsa_RemovePrivilegesFromAccount
2028  For a given SID, remove some privileges.
2029  ***************************************************************************/
2030
2031 NTSTATUS _lsa_RemovePrivilegesFromAccount(struct pipes_struct *p,
2032                                           struct lsa_RemovePrivilegesFromAccount *r)
2033 {
2034         struct lsa_info *info = NULL;
2035         struct lsa_PrivilegeSet *set = NULL;
2036
2037         /* find the connection policy handle. */
2038         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
2039                 return NT_STATUS_INVALID_HANDLE;
2040
2041         if (info->type != LSA_HANDLE_ACCOUNT_TYPE) {
2042                 return NT_STATUS_INVALID_HANDLE;
2043         }
2044
2045         if (!(info->access & LSA_ACCOUNT_ADJUST_PRIVILEGES)) {
2046                 return NT_STATUS_ACCESS_DENIED;
2047         }
2048
2049         set = r->in.privs;
2050
2051         if ( !revoke_privilege_set( &info->sid, set) ) {
2052                 DEBUG(3,("_lsa_RemovePrivilegesFromAccount: revoke_privilege(%s) failed!\n",
2053                          sid_string_dbg(&info->sid) ));
2054                 return NT_STATUS_NO_SUCH_PRIVILEGE;
2055         }
2056
2057         return NT_STATUS_OK;
2058 }
2059
2060 /***************************************************************************
2061  _lsa_LookupPrivName
2062  ***************************************************************************/
2063
2064 NTSTATUS _lsa_LookupPrivName(struct pipes_struct *p,
2065                              struct lsa_LookupPrivName *r)
2066 {
2067         struct lsa_info *info = NULL;
2068         const char *name;
2069         struct lsa_StringLarge *lsa_name;
2070
2071         /* find the connection policy handle. */
2072         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info)) {
2073                 return NT_STATUS_INVALID_HANDLE;
2074         }
2075
2076         if (info->type != LSA_HANDLE_POLICY_TYPE) {
2077                 return NT_STATUS_INVALID_HANDLE;
2078         }
2079
2080         if (!(info->access & LSA_POLICY_VIEW_LOCAL_INFORMATION)) {
2081                 return NT_STATUS_ACCESS_DENIED;
2082         }
2083
2084         if (r->in.luid->high != 0) {
2085                 return NT_STATUS_NO_SUCH_PRIVILEGE;
2086         }
2087
2088         name = sec_privilege_name(r->in.luid->low);
2089         if (!name) {
2090                 return NT_STATUS_NO_SUCH_PRIVILEGE;
2091         }
2092
2093         lsa_name = TALLOC_ZERO_P(p->mem_ctx, struct lsa_StringLarge);
2094         if (!lsa_name) {
2095                 return NT_STATUS_NO_MEMORY;
2096         }
2097
2098         lsa_name->string = talloc_strdup(lsa_name, name);
2099         if (!lsa_name->string) {
2100                 TALLOC_FREE(lsa_name);
2101                 return NT_STATUS_NO_MEMORY;
2102         }
2103
2104         *r->out.name = lsa_name;
2105
2106         return NT_STATUS_OK;
2107 }
2108
2109 /***************************************************************************
2110  _lsa_QuerySecurity
2111  ***************************************************************************/
2112
2113 NTSTATUS _lsa_QuerySecurity(struct pipes_struct *p,
2114                             struct lsa_QuerySecurity *r)
2115 {
2116         struct lsa_info *handle=NULL;
2117         struct security_descriptor *psd = NULL;
2118         size_t sd_size;
2119         NTSTATUS status;
2120
2121         /* find the connection policy handle. */
2122         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
2123                 return NT_STATUS_INVALID_HANDLE;
2124
2125         switch (handle->type) {
2126         case LSA_HANDLE_POLICY_TYPE:
2127                 status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size,
2128                                 &lsa_policy_mapping, NULL, 0);
2129                 break;
2130         case LSA_HANDLE_ACCOUNT_TYPE:
2131                 status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size,
2132                                 &lsa_account_mapping,
2133                                 &handle->sid, LSA_ACCOUNT_ALL_ACCESS);
2134                 break;
2135         default:
2136                 status = NT_STATUS_INVALID_HANDLE;
2137                 break;
2138         }
2139
2140         if (!NT_STATUS_IS_OK(status)) {
2141                 return status;
2142         }
2143
2144         *r->out.sdbuf = make_sec_desc_buf(p->mem_ctx, sd_size, psd);
2145         if (!*r->out.sdbuf) {
2146                 return NT_STATUS_NO_MEMORY;
2147         }
2148
2149         return status;
2150 }
2151
2152 /***************************************************************************
2153  _lsa_AddAccountRights
2154  ***************************************************************************/
2155
2156 NTSTATUS _lsa_AddAccountRights(struct pipes_struct *p,
2157                                struct lsa_AddAccountRights *r)
2158 {
2159         struct lsa_info *info = NULL;
2160         int i = 0;
2161         uint32_t acc_granted = 0;
2162         struct security_descriptor *psd = NULL;
2163         size_t sd_size;
2164         struct dom_sid sid;
2165         NTSTATUS status;
2166
2167         /* find the connection policy handle. */
2168         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
2169                 return NT_STATUS_INVALID_HANDLE;
2170
2171         if (info->type != LSA_HANDLE_POLICY_TYPE) {
2172                 return NT_STATUS_INVALID_HANDLE;
2173         }
2174
2175         /* get the generic lsa account SD for this SID until we store it */
2176         status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size,
2177                                 &lsa_account_mapping,
2178                                 r->in.sid, LSA_ACCOUNT_ALL_ACCESS);
2179         if (!NT_STATUS_IS_OK(status)) {
2180                 return status;
2181         }
2182
2183         /*
2184          * From the MS DOCs. If the sid doesn't exist, ask for LSA_POLICY_CREATE_ACCOUNT
2185          * on the policy handle. If it does, ask for
2186          * LSA_ACCOUNT_ADJUST_PRIVILEGES|LSA_ACCOUNT_ADJUST_SYSTEM_ACCESS|LSA_ACCOUNT_VIEW,
2187          * on the account sid. We don't check here so just use the latter. JRA.
2188          */
2189
2190         status = access_check_object(psd, p->server_info->security_token,
2191                                      SEC_PRIV_INVALID, SEC_PRIV_INVALID, 0,
2192                                      LSA_ACCOUNT_ADJUST_PRIVILEGES|LSA_ACCOUNT_ADJUST_SYSTEM_ACCESS|LSA_ACCOUNT_VIEW,
2193                                      &acc_granted, "_lsa_AddAccountRights" );
2194         if (!NT_STATUS_IS_OK(status)) {
2195                 return status;
2196         }
2197
2198         /* according to an NT4 PDC, you can add privileges to SIDs even without
2199            call_lsa_create_account() first.  And you can use any arbitrary SID. */
2200
2201         sid_copy( &sid, r->in.sid );
2202
2203         for ( i=0; i < r->in.rights->count; i++ ) {
2204
2205                 const char *privname = r->in.rights->names[i].string;
2206
2207                 /* only try to add non-null strings */
2208
2209                 if ( !privname )
2210                         continue;
2211
2212                 if ( !grant_privilege_by_name( &sid, privname ) ) {
2213                         DEBUG(2,("_lsa_AddAccountRights: Failed to add privilege [%s]\n",
2214                                 privname ));
2215                         return NT_STATUS_NO_SUCH_PRIVILEGE;
2216                 }
2217         }
2218
2219         return NT_STATUS_OK;
2220 }
2221
2222 /***************************************************************************
2223  _lsa_RemoveAccountRights
2224  ***************************************************************************/
2225
2226 NTSTATUS _lsa_RemoveAccountRights(struct pipes_struct *p,
2227                                   struct lsa_RemoveAccountRights *r)
2228 {
2229         struct lsa_info *info = NULL;
2230         int i = 0;
2231         struct security_descriptor *psd = NULL;
2232         size_t sd_size;
2233         struct dom_sid sid;
2234         const char *privname = NULL;
2235         uint32_t acc_granted = 0;
2236         NTSTATUS status;
2237
2238         /* find the connection policy handle. */
2239         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
2240                 return NT_STATUS_INVALID_HANDLE;
2241
2242         if (info->type != LSA_HANDLE_POLICY_TYPE) {
2243                 return NT_STATUS_INVALID_HANDLE;
2244         }
2245
2246         /* get the generic lsa account SD for this SID until we store it */
2247         status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size,
2248                                 &lsa_account_mapping,
2249                                 r->in.sid, LSA_ACCOUNT_ALL_ACCESS);
2250         if (!NT_STATUS_IS_OK(status)) {
2251                 return status;
2252         }
2253
2254         /*
2255          * From the MS DOCs. We need
2256          * LSA_ACCOUNT_ADJUST_PRIVILEGES|LSA_ACCOUNT_ADJUST_SYSTEM_ACCESS|LSA_ACCOUNT_VIEW
2257          * and DELETE on the account sid.
2258          */
2259
2260         status = access_check_object(psd, p->server_info->security_token,
2261                                      SEC_PRIV_INVALID, SEC_PRIV_INVALID, 0,
2262                                      LSA_ACCOUNT_ADJUST_PRIVILEGES|LSA_ACCOUNT_ADJUST_SYSTEM_ACCESS|
2263                                      LSA_ACCOUNT_VIEW|SEC_STD_DELETE,
2264                                      &acc_granted, "_lsa_RemoveAccountRights");
2265         if (!NT_STATUS_IS_OK(status)) {
2266                 return status;
2267         }
2268
2269         sid_copy( &sid, r->in.sid );
2270
2271         if ( r->in.remove_all ) {
2272                 if ( !revoke_all_privileges( &sid ) )
2273                         return NT_STATUS_ACCESS_DENIED;
2274
2275                 return NT_STATUS_OK;
2276         }
2277
2278         for ( i=0; i < r->in.rights->count; i++ ) {
2279
2280                 privname = r->in.rights->names[i].string;
2281
2282                 /* only try to add non-null strings */
2283
2284                 if ( !privname )
2285                         continue;
2286
2287                 if ( !revoke_privilege_by_name( &sid, privname ) ) {
2288                         DEBUG(2,("_lsa_RemoveAccountRights: Failed to revoke privilege [%s]\n",
2289                                 privname ));
2290                         return NT_STATUS_NO_SUCH_PRIVILEGE;
2291                 }
2292         }
2293
2294         return NT_STATUS_OK;
2295 }
2296
2297 /*******************************************************************
2298 ********************************************************************/
2299
2300 static NTSTATUS init_lsa_right_set(TALLOC_CTX *mem_ctx,
2301                                    struct lsa_RightSet *r,
2302                                    PRIVILEGE_SET *privileges)
2303 {
2304         uint32 i;
2305         const char *privname;
2306         const char **privname_array = NULL;
2307         int num_priv = 0;
2308
2309         for (i=0; i<privileges->count; i++) {
2310                 if (privileges->set[i].luid.high) {
2311                         continue;
2312                 }
2313                 privname = sec_privilege_name(privileges->set[i].luid.low);
2314                 if (privname) {
2315                         if (!add_string_to_array(mem_ctx, privname,
2316                                                  &privname_array, &num_priv)) {
2317                                 return NT_STATUS_NO_MEMORY;
2318                         }
2319                 }
2320         }
2321
2322         if (num_priv) {
2323
2324                 r->names = TALLOC_ZERO_ARRAY(mem_ctx, struct lsa_StringLarge,
2325                                              num_priv);
2326                 if (!r->names) {
2327                         return NT_STATUS_NO_MEMORY;
2328                 }
2329
2330                 for (i=0; i<num_priv; i++) {
2331                         init_lsa_StringLarge(&r->names[i], privname_array[i]);
2332                 }
2333
2334                 r->count = num_priv;
2335         }
2336
2337         return NT_STATUS_OK;
2338 }
2339
2340 /***************************************************************************
2341  _lsa_EnumAccountRights
2342  ***************************************************************************/
2343
2344 NTSTATUS _lsa_EnumAccountRights(struct pipes_struct *p,
2345                                 struct lsa_EnumAccountRights *r)
2346 {
2347         NTSTATUS status;
2348         struct lsa_info *info = NULL;
2349         PRIVILEGE_SET *privileges;
2350
2351         /* find the connection policy handle. */
2352
2353         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
2354                 return NT_STATUS_INVALID_HANDLE;
2355
2356         if (info->type != LSA_HANDLE_POLICY_TYPE) {
2357                 return NT_STATUS_INVALID_HANDLE;
2358         }
2359
2360         if (!(info->access & LSA_ACCOUNT_VIEW)) {
2361                 return NT_STATUS_ACCESS_DENIED;
2362         }
2363
2364         /* according to an NT4 PDC, you can add privileges to SIDs even without
2365            call_lsa_create_account() first.  And you can use any arbitrary SID. */
2366
2367         /* according to MS-LSAD 3.1.4.5.10 it is required to return
2368          * NT_STATUS_OBJECT_NAME_NOT_FOUND if the account sid was not found in
2369          * the lsa database */
2370
2371         status = get_privileges_for_sid_as_set(p->mem_ctx, &privileges, r->in.sid);
2372         if (!NT_STATUS_IS_OK(status)) {
2373                 return status;
2374         }
2375
2376         DEBUG(10,("_lsa_EnumAccountRights: %s has %d privileges\n",
2377                   sid_string_dbg(r->in.sid), privileges->count));
2378
2379         status = init_lsa_right_set(p->mem_ctx, r->out.rights, privileges);
2380
2381         return status;
2382 }
2383
2384 /***************************************************************************
2385  _lsa_LookupPrivValue
2386  ***************************************************************************/
2387
2388 NTSTATUS _lsa_LookupPrivValue(struct pipes_struct *p,
2389                               struct lsa_LookupPrivValue *r)
2390 {
2391         struct lsa_info *info = NULL;
2392         const char *name = NULL;
2393
2394         /* find the connection policy handle. */
2395
2396         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
2397                 return NT_STATUS_INVALID_HANDLE;
2398
2399         if (info->type != LSA_HANDLE_POLICY_TYPE) {
2400                 return NT_STATUS_INVALID_HANDLE;
2401         }
2402
2403         if (!(info->access & LSA_POLICY_LOOKUP_NAMES))
2404                 return NT_STATUS_ACCESS_DENIED;
2405
2406         name = r->in.name->string;
2407
2408         DEBUG(10,("_lsa_lookup_priv_value: name = %s\n", name));
2409
2410         r->out.luid->low = sec_privilege_id(name);
2411         r->out.luid->high = 0;
2412         if (r->out.luid->low == SEC_PRIV_INVALID) {
2413                 return NT_STATUS_NO_SUCH_PRIVILEGE;
2414         }
2415         return NT_STATUS_OK;
2416 }
2417
2418 /***************************************************************************
2419  _lsa_EnumAccountsWithUserRight
2420  ***************************************************************************/
2421
2422 NTSTATUS _lsa_EnumAccountsWithUserRight(struct pipes_struct *p,
2423                                         struct lsa_EnumAccountsWithUserRight *r)
2424 {
2425         NTSTATUS status;
2426         struct lsa_info *info = NULL;
2427         struct dom_sid *sids = NULL;
2428         int num_sids = 0;
2429         uint32_t i;
2430         enum sec_privilege privilege;
2431
2432         if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info)) {
2433                 return NT_STATUS_INVALID_HANDLE;
2434         }
2435
2436         if (info->type != LSA_HANDLE_POLICY_TYPE) {
2437                 return NT_STATUS_INVALID_HANDLE;
2438         }
2439
2440         if (!(info->access & LSA_POLICY_LOOKUP_NAMES)) {
2441                 return NT_STATUS_ACCESS_DENIED;
2442         }
2443
2444         if (!r->in.name || !r->in.name->string) {
2445                 return NT_STATUS_NO_SUCH_PRIVILEGE;
2446         }
2447
2448         privilege = sec_privilege_id(r->in.name->string);
2449         if (privilege == SEC_PRIV_INVALID) {
2450                 return NT_STATUS_NO_SUCH_PRIVILEGE;
2451         }
2452
2453         status = privilege_enum_sids(privilege, p->mem_ctx,
2454                                      &sids, &num_sids);
2455         if (!NT_STATUS_IS_OK(status)) {
2456                 return status;
2457         }
2458
2459         r->out.sids->num_sids = num_sids;
2460         r->out.sids->sids = talloc_array(p->mem_ctx, struct lsa_SidPtr,
2461                                          r->out.sids->num_sids);
2462
2463         for (i=0; i < r->out.sids->num_sids; i++) {
2464                 r->out.sids->sids[i].sid = dom_sid_dup(r->out.sids->sids,
2465                                                           &sids[i]);
2466                 if (!r->out.sids->sids[i].sid) {
2467                         TALLOC_FREE(r->out.sids->sids);
2468                         r->out.sids->num_sids = 0;
2469                         return NT_STATUS_NO_MEMORY;
2470                 }
2471         }
2472
2473         return NT_STATUS_OK;
2474 }
2475
2476 /***************************************************************************
2477  _lsa_Delete
2478  ***************************************************************************/
2479
2480 NTSTATUS _lsa_Delete(struct pipes_struct *p,
2481                      struct lsa_Delete *r)
2482 {
2483         return NT_STATUS_NOT_SUPPORTED;
2484 }
2485
2486 /*
2487  * From here on the server routines are just dummy ones to make smbd link with
2488  * librpc/gen_ndr/srv_lsa.c. These routines are actually never called, we are
2489  * pulling the server stubs across one by one.
2490  */
2491
2492 NTSTATUS _lsa_SetSecObj(struct pipes_struct *p, struct lsa_SetSecObj *r)
2493 {
2494         p->rng_fault_state = True;
2495         return NT_STATUS_NOT_IMPLEMENTED;
2496 }
2497
2498 NTSTATUS _lsa_ChangePassword(struct pipes_struct *p,
2499                              struct lsa_ChangePassword *r)
2500 {
2501         p->rng_fault_state = True;
2502         return NT_STATUS_NOT_IMPLEMENTED;
2503 }
2504
2505 NTSTATUS _lsa_SetInfoPolicy(struct pipes_struct *p, struct lsa_SetInfoPolicy *r)
2506 {
2507         p->rng_fault_state = True;
2508         return NT_STATUS_NOT_IMPLEMENTED;
2509 }
2510
2511 NTSTATUS _lsa_ClearAuditLog(struct pipes_struct *p, struct lsa_ClearAuditLog *r)
2512 {
2513         p->rng_fault_state = True;
2514         return NT_STATUS_NOT_IMPLEMENTED;
2515 }
2516
2517 NTSTATUS _lsa_GetQuotasForAccount(struct pipes_struct *p,
2518                                   struct lsa_GetQuotasForAccount *r)
2519 {
2520         p->rng_fault_state = True;
2521         return NT_STATUS_NOT_IMPLEMENTED;
2522 }
2523
2524 NTSTATUS _lsa_SetQuotasForAccount(struct pipes_struct *p,
2525                                   struct lsa_SetQuotasForAccount *r)
2526 {
2527         p->rng_fault_state = True;
2528         return NT_STATUS_NOT_IMPLEMENTED;
2529 }
2530
2531 NTSTATUS _lsa_QueryTrustedDomainInfo(struct pipes_struct *p,
2532                                      struct lsa_QueryTrustedDomainInfo *r)
2533 {
2534         p->rng_fault_state = True;
2535         return NT_STATUS_NOT_IMPLEMENTED;
2536 }
2537
2538 NTSTATUS _lsa_SetInformationTrustedDomain(struct pipes_struct *p,
2539                                           struct lsa_SetInformationTrustedDomain *r)
2540 {
2541         p->rng_fault_state = True;
2542         return NT_STATUS_NOT_IMPLEMENTED;
2543 }
2544
2545 NTSTATUS _lsa_QuerySecret(struct pipes_struct *p, struct lsa_QuerySecret *r)
2546 {
2547         p->rng_fault_state = True;
2548         return NT_STATUS_NOT_IMPLEMENTED;
2549 }
2550
2551 NTSTATUS _lsa_QueryTrustedDomainInfoBySid(struct pipes_struct *p,
2552                                           struct lsa_QueryTrustedDomainInfoBySid *r)
2553 {
2554         p->rng_fault_state = True;
2555         return NT_STATUS_NOT_IMPLEMENTED;
2556 }
2557
2558 NTSTATUS _lsa_SetTrustedDomainInfo(struct pipes_struct *p,
2559                                    struct lsa_SetTrustedDomainInfo *r)
2560 {
2561         p->rng_fault_state = True;
2562         return NT_STATUS_NOT_IMPLEMENTED;
2563 }
2564
2565 NTSTATUS _lsa_DeleteTrustedDomain(struct pipes_struct *p,
2566                                   struct lsa_DeleteTrustedDomain *r)
2567 {
2568         p->rng_fault_state = True;
2569         return NT_STATUS_NOT_IMPLEMENTED;
2570 }
2571
2572 NTSTATUS _lsa_StorePrivateData(struct pipes_struct *p,
2573                                struct lsa_StorePrivateData *r)
2574 {
2575         p->rng_fault_state = True;
2576         return NT_STATUS_NOT_IMPLEMENTED;
2577 }
2578
2579 NTSTATUS _lsa_RetrievePrivateData(struct pipes_struct *p,
2580                                   struct lsa_RetrievePrivateData *r)
2581 {
2582         p->rng_fault_state = True;
2583         return NT_STATUS_NOT_IMPLEMENTED;
2584 }
2585
2586 NTSTATUS _lsa_SetInfoPolicy2(struct pipes_struct *p,
2587                              struct lsa_SetInfoPolicy2 *r)
2588 {
2589         p->rng_fault_state = True;
2590         return NT_STATUS_NOT_IMPLEMENTED;
2591 }
2592
2593 NTSTATUS _lsa_QueryTrustedDomainInfoByName(struct pipes_struct *p,
2594                                            struct lsa_QueryTrustedDomainInfoByName *r)
2595 {
2596         p->rng_fault_state = True;
2597         return NT_STATUS_NOT_IMPLEMENTED;
2598 }
2599
2600 NTSTATUS _lsa_SetTrustedDomainInfoByName(struct pipes_struct *p,
2601                                          struct lsa_SetTrustedDomainInfoByName *r)
2602 {
2603         p->rng_fault_state = True;
2604         return NT_STATUS_NOT_IMPLEMENTED;
2605 }
2606
2607 NTSTATUS _lsa_EnumTrustedDomainsEx(struct pipes_struct *p,
2608                                    struct lsa_EnumTrustedDomainsEx *r)
2609 {
2610         p->rng_fault_state = True;
2611         return NT_STATUS_NOT_IMPLEMENTED;
2612 }
2613
2614 NTSTATUS _lsa_CreateTrustedDomainEx(struct pipes_struct *p,
2615                                     struct lsa_CreateTrustedDomainEx *r)
2616 {
2617         p->rng_fault_state = True;
2618         return NT_STATUS_NOT_IMPLEMENTED;
2619 }
2620
2621 NTSTATUS _lsa_CloseTrustedDomainEx(struct pipes_struct *p,
2622                                    struct lsa_CloseTrustedDomainEx *r)
2623 {
2624         p->rng_fault_state = True;
2625         return NT_STATUS_NOT_IMPLEMENTED;
2626 }
2627
2628 NTSTATUS _lsa_QueryDomainInformationPolicy(struct pipes_struct *p,
2629                                            struct lsa_QueryDomainInformationPolicy *r)
2630 {
2631         p->rng_fault_state = True;
2632         return NT_STATUS_NOT_IMPLEMENTED;
2633 }
2634
2635 NTSTATUS _lsa_SetDomainInformationPolicy(struct pipes_struct *p,
2636                                          struct lsa_SetDomainInformationPolicy *r)
2637 {
2638         p->rng_fault_state = True;
2639         return NT_STATUS_NOT_IMPLEMENTED;
2640 }
2641
2642 NTSTATUS _lsa_OpenTrustedDomainByName(struct pipes_struct *p,
2643                                       struct lsa_OpenTrustedDomainByName *r)
2644 {
2645         p->rng_fault_state = True;
2646         return NT_STATUS_NOT_IMPLEMENTED;
2647 }
2648
2649 NTSTATUS _lsa_TestCall(struct pipes_struct *p, struct lsa_TestCall *r)
2650 {
2651         p->rng_fault_state = True;
2652         return NT_STATUS_NOT_IMPLEMENTED;
2653 }
2654
2655 NTSTATUS _lsa_CreateTrustedDomainEx2(struct pipes_struct *p,
2656                                      struct lsa_CreateTrustedDomainEx2 *r)
2657 {
2658         p->rng_fault_state = True;
2659         return NT_STATUS_NOT_IMPLEMENTED;
2660 }
2661
2662 NTSTATUS _lsa_CREDRWRITE(struct pipes_struct *p, struct lsa_CREDRWRITE *r)
2663 {
2664         p->rng_fault_state = True;
2665         return NT_STATUS_NOT_IMPLEMENTED;
2666 }
2667
2668 NTSTATUS _lsa_CREDRREAD(struct pipes_struct *p, struct lsa_CREDRREAD *r)
2669 {
2670         p->rng_fault_state = True;
2671         return NT_STATUS_NOT_IMPLEMENTED;
2672 }
2673
2674 NTSTATUS _lsa_CREDRENUMERATE(struct pipes_struct *p, struct lsa_CREDRENUMERATE *r)
2675 {
2676         p->rng_fault_state = True;
2677         return NT_STATUS_NOT_IMPLEMENTED;
2678 }
2679
2680 NTSTATUS _lsa_CREDRWRITEDOMAINCREDENTIALS(struct pipes_struct *p,
2681                                           struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
2682 {
2683         p->rng_fault_state = True;
2684         return NT_STATUS_NOT_IMPLEMENTED;
2685 }
2686
2687 NTSTATUS _lsa_CREDRREADDOMAINCREDENTIALS(struct pipes_struct *p,
2688                                          struct lsa_CREDRREADDOMAINCREDENTIALS *r)
2689 {
2690         p->rng_fault_state = True;
2691         return NT_STATUS_NOT_IMPLEMENTED;
2692 }
2693
2694 NTSTATUS _lsa_CREDRDELETE(struct pipes_struct *p, struct lsa_CREDRDELETE *r)
2695 {
2696         p->rng_fault_state = True;
2697         return NT_STATUS_NOT_IMPLEMENTED;
2698 }
2699
2700 NTSTATUS _lsa_CREDRGETTARGETINFO(struct pipes_struct *p,
2701                                  struct lsa_CREDRGETTARGETINFO *r)
2702 {
2703         p->rng_fault_state = True;
2704         return NT_STATUS_NOT_IMPLEMENTED;
2705 }
2706
2707 NTSTATUS _lsa_CREDRPROFILELOADED(struct pipes_struct *p,
2708                                  struct lsa_CREDRPROFILELOADED *r)
2709 {
2710         p->rng_fault_state = True;
2711         return NT_STATUS_NOT_IMPLEMENTED;
2712 }
2713
2714 NTSTATUS _lsa_CREDRGETSESSIONTYPES(struct pipes_struct *p,
2715                                    struct lsa_CREDRGETSESSIONTYPES *r)
2716 {
2717         p->rng_fault_state = True;
2718         return NT_STATUS_NOT_IMPLEMENTED;
2719 }
2720
2721 NTSTATUS _lsa_LSARREGISTERAUDITEVENT(struct pipes_struct *p,
2722                                      struct lsa_LSARREGISTERAUDITEVENT *r)
2723 {
2724         p->rng_fault_state = True;
2725         return NT_STATUS_NOT_IMPLEMENTED;
2726 }
2727
2728 NTSTATUS _lsa_LSARGENAUDITEVENT(struct pipes_struct *p,
2729                                 struct lsa_LSARGENAUDITEVENT *r)
2730 {
2731         p->rng_fault_state = True;
2732         return NT_STATUS_NOT_IMPLEMENTED;
2733 }
2734
2735 NTSTATUS _lsa_LSARUNREGISTERAUDITEVENT(struct pipes_struct *p,
2736                                        struct lsa_LSARUNREGISTERAUDITEVENT *r)
2737 {
2738         p->rng_fault_state = True;
2739         return NT_STATUS_NOT_IMPLEMENTED;
2740 }
2741
2742 NTSTATUS _lsa_lsaRQueryForestTrustInformation(struct pipes_struct *p,
2743                                               struct lsa_lsaRQueryForestTrustInformation *r)
2744 {
2745         p->rng_fault_state = True;
2746         return NT_STATUS_NOT_IMPLEMENTED;
2747 }
2748
2749 NTSTATUS _lsa_lsaRSetForestTrustInformation(struct pipes_struct *p,
2750                                             struct lsa_lsaRSetForestTrustInformation *r)
2751 {
2752         p->rng_fault_state = True;
2753         return NT_STATUS_NOT_IMPLEMENTED;
2754 }
2755
2756 NTSTATUS _lsa_CREDRRENAME(struct pipes_struct *p,
2757                           struct lsa_CREDRRENAME *r)
2758 {
2759         p->rng_fault_state = True;
2760         return NT_STATUS_NOT_IMPLEMENTED;
2761 }
2762
2763 NTSTATUS _lsa_LSAROPENPOLICYSCE(struct pipes_struct *p,
2764                                 struct lsa_LSAROPENPOLICYSCE *r)
2765 {
2766         p->rng_fault_state = True;
2767         return NT_STATUS_NOT_IMPLEMENTED;
2768 }
2769
2770 NTSTATUS _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct pipes_struct *p,
2771                                                  struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
2772 {
2773         p->rng_fault_state = True;
2774         return NT_STATUS_NOT_IMPLEMENTED;
2775 }
2776
2777 NTSTATUS _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct pipes_struct *p,
2778                                                    struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
2779 {
2780         p->rng_fault_state = True;
2781         return NT_STATUS_NOT_IMPLEMENTED;
2782 }
2783
2784 NTSTATUS _lsa_LSARADTREPORTSECURITYEVENT(struct pipes_struct *p,
2785                                          struct lsa_LSARADTREPORTSECURITYEVENT *r)
2786 {
2787         p->rng_fault_state = True;
2788         return NT_STATUS_NOT_IMPLEMENTED;
2789 }