source3/rpc_server/srv_lsa.c

   1 #define OLD_NTDOMAIN 1
   2 /*
   3  *  Unix SMB/Netbios implementation.
   4  *  Version 1.9.
   5  *  RPC Pipe client / server routines
   6  *  Copyright (C) Andrew Tridgell              1992-1997,
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   8  *  Copyright (C) Paul Ashton                       1997.
   9  *  Copyright (C) Jeremy Allison                    1998.
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 #include "includes.h"
  27
  28 extern int DEBUGLEVEL;
  29 extern DOM_SID global_sam_sid;
  30 extern fstring global_myworkgroup;
  31 extern pstring global_myname;
  32
  33 /***************************************************************************
  34  lsa_reply_open_policy2
  35  ***************************************************************************/
  36
  37 static BOOL lsa_reply_open_policy2(prs_struct *rdata)
  38 {
  39         int i;
  40         LSA_R_OPEN_POL2 r_o;
  41
  42         ZERO_STRUCT(r_o);
  43
  44         /* set up the LSA QUERY INFO response */
  45
  46         for (i = 4; i < POL_HND_SIZE; i++)
  47                 r_o.pol.data[i] = i;
  48         r_o.status = 0x0;
  49
  50         /* store the response in the SMB stream */
  51         if(!lsa_io_r_open_pol2("", &r_o, rdata, 0)) {
  52                 DEBUG(0,("lsa_reply_open_policy2: unable to marshall LSA_R_OPEN_POL2.\n"));
  53                 return False;
  54         }
  55
  56         return True;
  57 }
  58
  59 /***************************************************************************
  60 lsa_reply_open_policy
  61  ***************************************************************************/
  62
  63 static BOOL lsa_reply_open_policy(prs_struct *rdata)
  64 {
  65         int i;
  66         LSA_R_OPEN_POL r_o;
  67
  68         ZERO_STRUCT(r_o);
  69
  70         /* set up the LSA QUERY INFO response */
  71
  72         for (i = 4; i < POL_HND_SIZE; i++)
  73                 r_o.pol.data[i] = i;
  74         r_o.status = 0x0;
  75
  76         /* store the response in the SMB stream */
  77         if(!lsa_io_r_open_pol("", &r_o, rdata, 0)) {
  78                 DEBUG(0,("lsa_reply_open_policy: unable to marshall LSA_R_OPEN_POL.\n"));
  79                 return False;
  80         }
  81
  82         return True;
  83 }
  84
  85 /***************************************************************************
  86 Init dom_query
  87  ***************************************************************************/
  88
  89 static void init_dom_query(DOM_QUERY *d_q, char *dom_name, DOM_SID *dom_sid)
  90 {
  91         int domlen = (dom_name != NULL) ? strlen(dom_name) : 0;
  92
  93         d_q->uni_dom_max_len = domlen * 2;
  94         d_q->uni_dom_str_len = domlen * 2;
  95
  96         d_q->buffer_dom_name = (dom_name != 0)   ? 1 : 0;
  97         d_q->buffer_dom_sid  = (dom_sid != NULL) ? 1 : 0;
  98
  99         /* this string is supposed to be character short */
 100         init_unistr2(&d_q->uni_domain_name, dom_name, domlen);
 101         if (dom_sid != NULL)
 102                 init_dom_sid2(&d_q->dom_sid, dom_sid);
 103 }
 104
 105 /***************************************************************************
 106  lsa_reply_enum_trust_dom
 107  ***************************************************************************/
 108
 109 static void lsa_reply_enum_trust_dom(LSA_Q_ENUM_TRUST_DOM *q_e,
 110                                 prs_struct *rdata,
 111                                 uint32 enum_context, char *dom_name, DOM_SID *dom_sid)
 112 {
 113         LSA_R_ENUM_TRUST_DOM r_e;
 114
 115         ZERO_STRUCT(r_e);
 116
 117         /* set up the LSA QUERY INFO response */
 118         init_r_enum_trust_dom(&r_e, enum_context, dom_name, dom_sid,
 119               dom_name != NULL ? 0x0 : 0x80000000 | NT_STATUS_UNABLE_TO_FREE_VM);
 120
 121         /* store the response in the SMB stream */
 122         lsa_io_r_enum_trust_dom("", &r_e, rdata, 0);
 123 }
 124
 125 /***************************************************************************
 126 lsa_reply_query_info
 127  ***************************************************************************/
 128
 129 static BOOL lsa_reply_query_info(LSA_Q_QUERY_INFO *q_q, prs_struct *rdata,
 130                                 char *dom_name, DOM_SID *dom_sid, uint32 status_code)
 131 {
 132         LSA_R_QUERY_INFO r_q;
 133
 134         ZERO_STRUCT(r_q);
 135
 136         /* set up the LSA QUERY INFO response */
 137
 138         if(status_code == 0) {
 139                 r_q.undoc_buffer = 0x22000000; /* bizarre */
 140                 r_q.info_class = q_q->info_class;
 141
 142                 init_dom_query(&r_q.dom.id5, dom_name, dom_sid);
 143         }
 144
 145         r_q.status = status_code;
 146
 147         /* store the response in the SMB stream */
 148         if(!lsa_io_r_query("", &r_q, rdata, 0)) {
 149                 DEBUG(0,("lsa_reply_query_info: failed to marshall LSA_R_QUERY_INFO.\n"));
 150                 return False;
 151         }
 152
 153         return True;
 154 }
 155
 156 /***************************************************************************
 157  init_dom_ref - adds a domain if it's not already in, returns the index.
 158 ***************************************************************************/
 159
 160 static int init_dom_ref(DOM_R_REF *ref, char *dom_name, DOM_SID *dom_sid)
 161 {
 162         int num = 0;
 163         int len;
 164
 165         if (dom_name != NULL) {
 166                 for (num = 0; num < ref->num_ref_doms_1; num++) {
 167                         fstring domname;
 168                         fstrcpy(domname, dos_unistr2_to_str(&ref->ref_dom[num].uni_dom_name));
 169                         if (strequal(domname, dom_name))
 170                                 return num;
 171                 }
 172         } else {
 173                 num = ref->num_ref_doms_1;
 174         }
 175
 176         if (num >= MAX_REF_DOMAINS) {
 177                 /* index not found, already at maximum domain limit */
 178                 return -1;
 179         }
 180
 181         ref->num_ref_doms_1 = num+1;
 182         ref->ptr_ref_dom  = 1;
 183         ref->max_entries = MAX_REF_DOMAINS;
 184         ref->num_ref_doms_2 = num+1;
 185
 186         len = (dom_name != NULL) ? strlen(dom_name) : 0;
 187         if(dom_name != NULL && len == 0)
 188                 len = 1;
 189
 190         init_uni_hdr(&ref->hdr_ref_dom[num].hdr_dom_name, len);
 191         ref->hdr_ref_dom[num].ptr_dom_sid = dom_sid != NULL ? 1 : 0;
 192
 193         init_unistr2(&ref->ref_dom[num].uni_dom_name, dom_name, len);
 194         init_dom_sid2(&ref->ref_dom[num].ref_dom, dom_sid );
 195
 196         return num;
 197 }
 198
 199 /***************************************************************************
 200  init_lsa_rid2s
 201  ***************************************************************************/
 202
 203 static void init_lsa_rid2s(DOM_R_REF *ref, DOM_RID2 *rid2,
 204                                 int num_entries, UNISTR2 name[MAX_LOOKUP_SIDS],
 205                                 uint32 *mapped_count)
 206 {
 207         int i;
 208         int total = 0;
 209         *mapped_count = 0;
 210
 211         SMB_ASSERT(num_entries <= MAX_LOOKUP_SIDS);
 212
 213         for (i = 0; i < num_entries; i++) {
 214                 BOOL status = False;
 215                 DOM_SID dom_sid;
 216                 DOM_SID sid;
 217                 uint32 rid = 0xffffffff;
 218                 int dom_idx = -1;
 219                 pstring full_name;
 220                 fstring dom_name;
 221                 fstring user;
 222                 uint8 sid_name_use = SID_NAME_UNKNOWN;
 223
 224                 pstrcpy(full_name, dos_unistr2_to_str(&name[i]));
 225
 226                 /*
 227                  * Try and split the name into a DOMAIN and
 228                  * user component.
 229                  */
 230
 231                 split_domain_name(full_name, dom_name, user);
 232
 233                 /*
 234                  * We only do anything with this name if we
 235                  * can map the Domain into a SID we know.
 236                  */
 237
 238                 if (map_domain_name_to_sid(&dom_sid, dom_name)) {
 239                         dom_idx = init_dom_ref(ref, dom_name, &dom_sid);
 240
 241                         if (lookup_local_name(dom_name, user, &sid, &sid_name_use) && sid_split_rid(&sid, &rid))
 242                                 status = True;
 243                 }
 244
 245                 if (status)
 246                         (*mapped_count)++;
 247                 else {
 248                         dom_idx = -1;
 249                         rid = 0xffffffff;
 250                         sid_name_use = SID_NAME_UNKNOWN;
 251                 }
 252
 253                 init_dom_rid2(&rid2[total], rid, sid_name_use, dom_idx);
 254                 total++;
 255         }
 256 }
 257
 258 /***************************************************************************
 259  init_reply_lookup_names
 260  ***************************************************************************/
 261
 262 static void init_reply_lookup_names(LSA_R_LOOKUP_NAMES *r_l,
 263                 DOM_R_REF *ref, uint32 num_entries,
 264                 DOM_RID2 *rid2, uint32 mapped_count)
 265 {
 266         r_l->ptr_dom_ref  = 1;
 267         r_l->dom_ref      = ref;
 268
 269         r_l->num_entries  = num_entries;
 270         r_l->ptr_entries  = 1;
 271         r_l->num_entries2 = num_entries;
 272         r_l->dom_rid      = rid2;
 273
 274         r_l->mapped_count = mapped_count;
 275
 276         if (mapped_count == 0)
 277                 r_l->status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
 278         else
 279                 r_l->status = 0x0;
 280 }
 281
 282 /* Call winbindd to convert sid to name */
 283
 284 BOOL winbind_lookup_sid(DOM_SID *sid, fstring dom_name, fstring name,
 285                         uint8 *name_type)
 286 {
 287         struct winbindd_request request;
 288         struct winbindd_response response;
 289         enum winbindd_result result;
 290         DOM_SID tmp_sid;
 291         uint32 rid;
 292         fstring sid_str;
 293
 294         if (!name_type) return False;
 295
 296         /* Check if this is our own sid.  This should perhaps be done by
 297            winbind?  For the moment handle it here. */
 298
 299         if (sid->num_auths == 5) {
 300                 sid_copy(&tmp_sid, sid);
 301                 sid_split_rid(&tmp_sid, &rid);
 302
 303                 if (sid_equal(&global_sam_sid, &tmp_sid)) {
 304
 305                 return map_domain_sid_to_name(&tmp_sid, dom_name) &&
 306                         lookup_local_rid(rid, name, name_type);
 307                 }
 308         }
 309
 310         /* Initialise request */
 311
 312         ZERO_STRUCT(request);
 313         ZERO_STRUCT(response);
 314
 315         sid_to_string(sid_str, sid);
 316         fstrcpy(request.data.sid, sid_str);
 317
 318         /* Make request */
 319
 320         result = generic_request(WINBINDD_LOOKUPSID, &request, &response);
 321
 322         /* Copy out result */
 323
 324         if (result == WINBINDD_OK) {
 325                 parse_domain_user(response.data.name.name, dom_name, name);
 326                 *name_type = response.data.name.type;
 327         }
 328
 329         return (result == WINBINDD_OK);
 330 }
 331
 332 /***************************************************************************
 333  Init lsa_trans_names.
 334  ***************************************************************************/
 335
 336 static void init_lsa_trans_names(DOM_R_REF *ref, LSA_TRANS_NAME_ENUM *trn,
 337                                 int num_entries, DOM_SID2 sid[MAX_LOOKUP_SIDS], uint32 *mapped_count)
 338 {
 339         int i;
 340         int total = 0;
 341         *mapped_count = 0;
 342
 343         SMB_ASSERT(num_entries <= MAX_LOOKUP_SIDS);
 344
 345         for (i = 0; i < num_entries; i++) {
 346                 BOOL status = False;
 347                 DOM_SID find_sid = sid[i].sid;
 348                 uint32 rid = 0xffffffff;
 349                 int dom_idx = -1;
 350                 fstring name, dom_name;
 351                 uint8 sid_name_use = 0;
 352
 353                 /* Lookup sid from winbindd */
 354
 355                 memset(dom_name, '\0', sizeof(dom_name));
 356                 memset(name, '\0', sizeof(name));
 357
 358                 status = winbind_lookup_sid(&find_sid, dom_name, name,
 359                                             &sid_name_use);
 360
 361                 if (!status) {
 362                         sid_name_use = SID_NAME_UNKNOWN;
 363                 }
 364
 365                 /* Store domain sid in ref array */
 366
 367                 if (find_sid.num_auths == 5) {
 368                         sid_split_rid(&find_sid, &rid);
 369                 }
 370
 371                 dom_idx = init_dom_ref(ref, dom_name, &find_sid);
 372
 373                 DEBUG(10,("init_lsa_trans_names: added user '%s\\%s' to referenced list.\n", dom_name, name ));
 374
 375                 (*mapped_count)++;
 376
 377                 init_lsa_trans_name(&trn->name[total], &trn->uni_name[total],
 378                                         sid_name_use, name, dom_idx);
 379                 total++;
 380         }
 381
 382         trn->num_entries = total;
 383         trn->ptr_trans_names = 1;
 384         trn->num_entries2 = total;
 385 }
 386
 387 /***************************************************************************
 388  Init_reply_lookup_sids.
 389  ***************************************************************************/
 390
 391 static void init_reply_lookup_sids(LSA_R_LOOKUP_SIDS *r_l,
 392                 DOM_R_REF *ref, LSA_TRANS_NAME_ENUM *names,
 393                 uint32 mapped_count)
 394 {
 395         r_l->ptr_dom_ref  = 1;
 396         r_l->dom_ref      = ref;
 397         r_l->names        = names;
 398         r_l->mapped_count = mapped_count;
 399
 400         if (mapped_count == 0)
 401                 r_l->status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
 402         else
 403                 r_l->status = 0x0;
 404 }
 405
 406 /***************************************************************************
 407 lsa_reply_lookup_sids
 408  ***************************************************************************/
 409
 410 static BOOL lsa_reply_lookup_sids(prs_struct *rdata, DOM_SID2 *sid, int num_entries)
 411 {
 412         LSA_R_LOOKUP_SIDS r_l;
 413         DOM_R_REF ref;
 414         LSA_TRANS_NAME_ENUM names;
 415         uint32 mapped_count = 0;
 416
 417         ZERO_STRUCT(r_l);
 418         ZERO_STRUCT(ref);
 419         ZERO_STRUCT(names);
 420
 421         /* set up the LSA Lookup SIDs response */
 422         init_lsa_trans_names(&ref, &names, num_entries, sid, &mapped_count);
 423         init_reply_lookup_sids(&r_l, &ref, &names, mapped_count);
 424
 425         /* store the response in the SMB stream */
 426         if(!lsa_io_r_lookup_sids("", &r_l, rdata, 0)) {
 427                 DEBUG(0,("lsa_reply_lookup_sids: Failed to marshall LSA_R_LOOKUP_SIDS.\n"));
 428                 return False;
 429         }
 430
 431         return True;
 432 }
 433
 434 /***************************************************************************
 435 lsa_reply_lookup_names
 436  ***************************************************************************/
 437
 438 static BOOL lsa_reply_lookup_names(prs_struct *rdata,
 439                 UNISTR2 names[MAX_LOOKUP_SIDS], int num_entries)
 440 {
 441         LSA_R_LOOKUP_NAMES r_l;
 442         DOM_R_REF ref;
 443         DOM_RID2 rids[MAX_LOOKUP_SIDS];
 444         uint32 mapped_count = 0;
 445
 446         ZERO_STRUCT(r_l);
 447         ZERO_STRUCT(ref);
 448         ZERO_ARRAY(rids);
 449
 450         /* set up the LSA Lookup RIDs response */
 451         init_lsa_rid2s(&ref, rids, num_entries, names, &mapped_count);
 452         init_reply_lookup_names(&r_l, &ref, num_entries, rids, mapped_count);
 453
 454         /* store the response in the SMB stream */
 455         if(!lsa_io_r_lookup_names("", &r_l, rdata, 0)) {
 456                 DEBUG(0,("lsa_reply_lookup_names: Failed to marshall LSA_R_LOOKUP_NAMES.\n"));
 457                 return False;
 458         }
 459
 460         return True;
 461 }
 462
 463 /***************************************************************************
 464  api_lsa_open_policy2
 465  ***************************************************************************/
 466
 467 static BOOL api_lsa_open_policy2(pipes_struct *p)
 468 {
 469         prs_struct *data = &p->in_data.data;
 470         prs_struct *rdata = &p->out_data.rdata;
 471
 472         LSA_Q_OPEN_POL2 q_o;
 473
 474         ZERO_STRUCT(q_o);
 475
 476         /* grab the server, object attributes and desired access flag...*/
 477         if(!lsa_io_q_open_pol2("", &q_o, data, 0)) {
 478                 DEBUG(0,("api_lsa_open_policy2: unable to unmarshall LSA_Q_OPEN_POL2.\n"));
 479                 return False;
 480         }
 481
 482         /* lkclXXXX having decoded it, ignore all fields in the open policy! */
 483
 484         /* return a 20 byte policy handle */
 485         if(!lsa_reply_open_policy2(rdata))
 486                 return False;
 487
 488         return True;
 489 }
 490
 491 /***************************************************************************
 492 api_lsa_open_policy
 493  ***************************************************************************/
 494 static BOOL api_lsa_open_policy(pipes_struct *p)
 495 {
 496         prs_struct *data = &p->in_data.data;
 497         prs_struct *rdata = &p->out_data.rdata;
 498
 499         LSA_Q_OPEN_POL q_o;
 500
 501         ZERO_STRUCT(q_o);
 502
 503         /* grab the server, object attributes and desired access flag...*/
 504         if(!lsa_io_q_open_pol("", &q_o, data, 0)) {
 505                 DEBUG(0,("api_lsa_open_policy: unable to unmarshall LSA_Q_OPEN_POL.\n"));
 506                 return False;
 507         }
 508
 509         /* lkclXXXX having decoded it, ignore all fields in the open policy! */
 510
 511         /* return a 20 byte policy handle */
 512         if(!lsa_reply_open_policy(rdata))
 513                 return False;
 514
 515         return True;
 516 }
 517
 518 /***************************************************************************
 519 api_lsa_enum_trust_dom
 520  ***************************************************************************/
 521 static BOOL api_lsa_enum_trust_dom(pipes_struct *p)
 522 {
 523         LSA_Q_ENUM_TRUST_DOM q_e;
 524         prs_struct *data = &p->in_data.data;
 525         prs_struct *rdata = &p->out_data.rdata;
 526
 527         ZERO_STRUCT(q_e);
 528
 529         /* grab the enum trust domain context etc. */
 530         if(!lsa_io_q_enum_trust_dom("", &q_e, data, 0))
 531                 return False;
 532
 533         /* construct reply.  return status is always 0x0 */
 534         lsa_reply_enum_trust_dom(&q_e, rdata, 0, NULL, NULL);
 535
 536         return True;
 537 }
 538
 539 /***************************************************************************
 540 api_lsa_query_info
 541  ***************************************************************************/
 542 static BOOL api_lsa_query_info(pipes_struct *p)
 543 {
 544         LSA_Q_QUERY_INFO q_i;
 545         DOM_SID domain_sid;
 546         char *name = NULL;
 547         DOM_SID *sid = NULL;
 548         uint32 status_code = 0;
 549         prs_struct *data = &p->in_data.data;
 550         prs_struct *rdata = &p->out_data.rdata;
 551
 552         ZERO_STRUCT(q_i);
 553
 554         /* grab the info class and policy handle */
 555         if(!lsa_io_q_query("", &q_i, data, 0)) {
 556                 DEBUG(0,("api_lsa_query_info: failed to unmarshall LSA_Q_QUERY_INFO.\n"));
 557                 return False;
 558         }
 559
 560         switch (q_i.info_class) {
 561         case 0x03:
 562                 switch (lp_server_role())
 563                 {
 564                         case ROLE_DOMAIN_PDC:
 565                         case ROLE_DOMAIN_BDC:
 566                                 name = global_myworkgroup;
 567                                 sid = &global_sam_sid;
 568                                 break;
 569                         case ROLE_DOMAIN_MEMBER:
 570                                 if (secrets_fetch_domain_sid(global_myworkgroup,
 571                                         &domain_sid))
 572                                 {
 573                                         name = global_myworkgroup;
 574                                         sid = &domain_sid;
 575                                 }
 576                         default:
 577                                 break;
 578                 }
 579                 break;
 580         case 0x05:
 581                 name = global_myname;
 582                 sid = &global_sam_sid;
 583                 break;
 584         default:
 585                 DEBUG(0,("api_lsa_query_info: unknown info level in Lsa Query: %d\n", q_i.info_class));
 586                 status_code = (NT_STATUS_INVALID_INFO_CLASS | 0xC0000000);
 587                 break;
 588         }
 589
 590         /* construct reply.  return status is always 0x0 */
 591         if(!lsa_reply_query_info(&q_i, rdata, name, sid, status_code))
 592                 return False;
 593
 594         return True;
 595 }
 596
 597 /***************************************************************************
 598  api_lsa_lookup_sids
 599  ***************************************************************************/
 600
 601 static BOOL api_lsa_lookup_sids(pipes_struct *p)
 602 {
 603         LSA_Q_LOOKUP_SIDS q_l;
 604         prs_struct *data = &p->in_data.data;
 605         prs_struct *rdata = &p->out_data.rdata;
 606
 607         ZERO_STRUCT(q_l);
 608
 609         /* grab the info class and policy handle */
 610         if(!lsa_io_q_lookup_sids("", &q_l, data, 0)) {
 611                 DEBUG(0,("api_lsa_lookup_sids: failed to unmarshall LSA_Q_LOOKUP_SIDS.\n"));
 612                 return False;
 613         }
 614
 615         /* construct reply.  return status is always 0x0 */
 616         if(!lsa_reply_lookup_sids(rdata, q_l.sids.sid, q_l.sids.num_entries))
 617                 return False;
 618
 619         return True;
 620 }
 621
 622 /***************************************************************************
 623  api_lsa_lookup_names
 624  ***************************************************************************/
 625
 626 static BOOL api_lsa_lookup_names(pipes_struct *p)
 627 {
 628         LSA_Q_LOOKUP_NAMES q_l;
 629         prs_struct *data = &p->in_data.data;
 630         prs_struct *rdata = &p->out_data.rdata;
 631
 632         ZERO_STRUCT(q_l);
 633
 634         /* grab the info class and policy handle */
 635         if(!lsa_io_q_lookup_names("", &q_l, data, 0)) {
 636                 DEBUG(0,("api_lsa_lookup_names: failed to unmarshall LSA_Q_LOOKUP_NAMES.\n"));
 637                 return False;
 638         }
 639
 640         SMB_ASSERT_ARRAY(q_l.uni_name, q_l.num_entries);
 641
 642         return lsa_reply_lookup_names(rdata, q_l.uni_name, q_l.num_entries);
 643 }
 644
 645 /***************************************************************************
 646  api_lsa_close
 647  ***************************************************************************/
 648 static BOOL api_lsa_close(pipes_struct *p)
 649 {
 650         LSA_R_CLOSE r_c;
 651         prs_struct *data = &p->in_data.data;
 652         prs_struct *rdata = &p->out_data.rdata;
 653
 654         ZERO_STRUCT(r_c);
 655
 656         /* store the response in the SMB stream */
 657         if (!lsa_io_r_close("", &r_c, rdata, 0)) {
 658                 DEBUG(0,("api_lsa_close: lsa_io_r_close failed.\n"));
 659                 return False;
 660         }
 661
 662         return True;
 663 }
 664
 665 /***************************************************************************
 666  api_lsa_open_secret
 667  ***************************************************************************/
 668 static BOOL api_lsa_open_secret(pipes_struct *p)
 669 {
 670         /* XXXX this is NOT good */
 671         size_t i;
 672         uint32 dummy = 0;
 673         prs_struct *data = &p->in_data.data;
 674         prs_struct *rdata = &p->out_data.rdata;
 675
 676         for(i =0; i < 4; i++) {
 677                 if(!prs_uint32("api_lsa_close", rdata, 1, &dummy)) {
 678                         DEBUG(0,("api_lsa_open_secret: prs_uint32 %d failed.\n",
 679                                 (int)i ));
 680                         return False;
 681                 }
 682         }
 683
 684         dummy = 0xC0000000 | NT_STATUS_OBJECT_NAME_NOT_FOUND;
 685         if(!prs_uint32("api_lsa_close", rdata, 1, &dummy)) {
 686                 DEBUG(0,("api_lsa_open_secret: prs_uint32 status failed.\n"));
 687                 return False;
 688         }
 689
 690         return True;
 691 }
 692
 693 /***************************************************************************
 694  \PIPE\ntlsa commands
 695  ***************************************************************************/
 696 static struct api_struct api_lsa_cmds[] =
 697 {
 698         { "LSA_OPENPOLICY2"     , LSA_OPENPOLICY2     , api_lsa_open_policy2   },
 699         { "LSA_OPENPOLICY"      , LSA_OPENPOLICY      , api_lsa_open_policy    },
 700         { "LSA_QUERYINFOPOLICY" , LSA_QUERYINFOPOLICY , api_lsa_query_info     },
 701         { "LSA_ENUMTRUSTDOM"    , LSA_ENUMTRUSTDOM    , api_lsa_enum_trust_dom },
 702         { "LSA_CLOSE"           , LSA_CLOSE           , api_lsa_close          },
 703         { "LSA_OPENSECRET"      , LSA_OPENSECRET      , api_lsa_open_secret    },
 704         { "LSA_LOOKUPSIDS"      , LSA_LOOKUPSIDS      , api_lsa_lookup_sids    },
 705         { "LSA_LOOKUPNAMES"     , LSA_LOOKUPNAMES     , api_lsa_lookup_names   },
 706         { NULL                  , 0                   , NULL                   }
 707 };
 708
 709 /***************************************************************************
 710  api_ntLsarpcTNP
 711  ***************************************************************************/
 712 BOOL api_ntlsa_rpc(pipes_struct *p)
 713 {
 714         return api_rpcTNP(p, "api_ntlsa_rpc", api_lsa_cmds);
 715 }
 716
 717 #undef OLD_NTDOMAIN