source/rpc_parse/parse_lsa.c

   1 /*
   2  *  Unix SMB/Netbios implementation.
   3  *  Version 1.9.
   4  *  RPC Pipe client / server routines
   5  *  Copyright (C) Andrew Tridgell              1992-1999,
   6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1999,
   7  *  Copyright (C) Paul Ashton                  1997-1999.
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include "includes.h"
  25 #include "rpc_parse.h"
  26 #include "nterr.h"
  27
  28 extern int DEBUGLEVEL;
  29
  30 /*******************************************************************
  31 creates a LSA_TRANS_NAME structure.
  32 ********************************************************************/
  33 BOOL make_lsa_trans_name(LSA_TRANS_NAME * trn, UNISTR2 * uni_name,
  34                          uint32 sid_name_use, char *name, uint32 idx)
  35 {
  36         int len_name = strlen(name);
  37
  38         trn->sid_name_use = sid_name_use;
  39         make_uni_hdr(&(trn->hdr_name), len_name);
  40         make_unistr2(uni_name, name, len_name);
  41         trn->domain_idx = idx;
  42
  43         return True;
  44 }
  45
  46 /*******************************************************************
  47 reads or writes a LSA_TRANS_NAME structure.
  48 ********************************************************************/
  49 static BOOL lsa_io_trans_name(char *desc, LSA_TRANS_NAME * trn,
  50                               prs_struct * ps, int depth)
  51 {
  52         if (trn == NULL)
  53                 return False;
  54
  55         prs_debug(ps, depth, desc, "lsa_io_trans_name");
  56         depth++;
  57
  58         prs_align(ps);
  59
  60         prs_uint32("sid_name_use", ps, depth, &(trn->sid_name_use));
  61         smb_io_unihdr("hdr_name", &(trn->hdr_name), ps, depth);
  62         prs_uint32("domain_idx  ", ps, depth, &(trn->domain_idx));
  63
  64         return True;
  65 }
  66
  67 /***************************************************************************
  68 make_dom_ref - adds a domain if it's not already in, returns the index
  69  ***************************************************************************/
  70 int make_dom_ref_uni(DOM_R_REF * ref, const UNISTR2 * uni_domname,
  71                      const DOM_SID * dom_sid)
  72 {
  73         int num = 0;
  74         UNISTR2 uni_tmp;
  75
  76         if (ref == NULL)
  77         {
  78                 return -1;
  79         }
  80
  81         if (uni_domname == NULL)
  82         {
  83                 uni_domname = &uni_tmp;
  84                 make_unistr2(&uni_tmp, NULL, 0);
  85         }
  86
  87         for (num = 0; num < ref->num_ref_doms_1; num++)
  88         {
  89                 if (unistr2equal(uni_domname,
  90                                  &ref->ref_dom[num].uni_dom_name))
  91                 {
  92                         return num;
  93                 }
  94         }
  95
  96         if (num >= MAX_REF_DOMAINS)
  97         {
  98                 /* index not found, already at maximum domain limit */
  99                 return -1;
 100         }
 101
 102         ref->num_ref_doms_1 = num + 1;
 103         ref->ptr_ref_dom = 1;
 104         ref->max_entries = MAX_REF_DOMAINS;
 105         ref->num_ref_doms_2 = num + 1;
 106
 107         make_unihdr_from_unistr2(&(ref->hdr_ref_dom[num].hdr_dom_name),
 108                                  uni_domname);
 109         copy_unistr2(&(ref->ref_dom[num].uni_dom_name), uni_domname);
 110
 111         ref->hdr_ref_dom[num].ptr_dom_sid = dom_sid != NULL ? 1 : 0;
 112         make_dom_sid2(&(ref->ref_dom[num].ref_dom), dom_sid);
 113
 114         return num;
 115 }
 116
 117 int make_dom_ref(DOM_R_REF * ref, const char *domname,
 118                  const DOM_SID * dom_sid)
 119 {
 120         UNISTR2 *uni_domname;
 121         int ret;
 122
 123         uni_domname = unistr2_new(domname);
 124         ret = make_dom_ref_uni(ref, uni_domname, dom_sid);
 125         unistr2_free(uni_domname);
 126         return ret;
 127 }
 128
 129 /*******************************************************************
 130 reads or writes a DOM_R_REF structure.
 131 ********************************************************************/
 132 static BOOL lsa_io_dom_r_ref(char *desc, DOM_R_REF * r_r, prs_struct * ps,
 133                              int depth)
 134 {
 135         uint32 i, s, n;
 136
 137         prs_debug(ps, depth, desc, "smb_io_dom_r_ref");
 138         depth++;
 139
 140         if (r_r == NULL)
 141                 return False;
 142
 143         prs_align(ps);
 144
 145         prs_uint32("num_ref_doms_1", ps, depth, &(r_r->num_ref_doms_1));        /* num referenced domains? */
 146         prs_uint32("ptr_ref_dom   ", ps, depth, &(r_r->ptr_ref_dom));   /* undocumented buffer pointer. */
 147         prs_uint32("max_entries   ", ps, depth, &(r_r->max_entries));   /* 32 - max number of entries */
 148
 149         SMB_ASSERT_ARRAY(r_r->hdr_ref_dom, r_r->num_ref_doms_1);
 150
 151         if (r_r->ptr_ref_dom != 0)
 152         {
 153                 prs_uint32("num_ref_doms_2", ps, depth, &(r_r->num_ref_doms_2));        /* 4 - num referenced domains? */
 154                 SMB_ASSERT_ARRAY(r_r->ref_dom, r_r->num_ref_doms_2);
 155
 156                 for (i = 0; i < r_r->num_ref_doms_1; i++)
 157                 {
 158                         fstring t;
 159
 160                         slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
 161                         smb_io_unihdr(t, &(r_r->hdr_ref_dom[i].hdr_dom_name),
 162                                       ps, depth);
 163
 164                         slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
 165                         prs_uint32(t, ps, depth,
 166                                    &(r_r->hdr_ref_dom[i].ptr_dom_sid));
 167                 }
 168
 169                 for (i = 0, n = 0, s = 0; i < r_r->num_ref_doms_2; i++)
 170                 {
 171                         fstring t;
 172
 173                         if (r_r->hdr_ref_dom[i].hdr_dom_name.buffer != 0)
 174                         {
 175                                 slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
 176                                 smb_io_unistr2(t,
 177                                                &(r_r->ref_dom[n].
 178                                                  uni_dom_name), True, ps, depth);       /* domain name unicode string */
 179                                 prs_align(ps);
 180                                 n++;
 181                         }
 182
 183                         if (r_r->hdr_ref_dom[i].ptr_dom_sid != 0)
 184                         {
 185                                 slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
 186                                 smb_io_dom_sid2("",
 187                                                 &(r_r->ref_dom[s].ref_dom),
 188                                                 ps, depth);     /* referenced domain SIDs */
 189                                 s++;
 190                         }
 191                 }
 192         }
 193
 194         return True;
 195 }
 196
 197
 198 /*******************************************************************
 199 makes an LSA_SEC_QOS structure.
 200 ********************************************************************/
 201 BOOL make_lsa_sec_qos(LSA_SEC_QOS * qos, uint16 imp_lev, uint8 ctxt,
 202                       uint8 eff, uint32 unknown)
 203 {
 204         if (qos == NULL)
 205                 return False;
 206
 207         DEBUG(5, ("make_lsa_sec_qos\n"));
 208
 209         qos->len = 0x0c;        /* length of quality of service block, in bytes */
 210         qos->sec_imp_level = imp_lev;
 211         qos->sec_ctxt_mode = ctxt;
 212         qos->effective_only = eff;
 213         qos->unknown = unknown;
 214
 215         return True;
 216 }
 217
 218 /*******************************************************************
 219 reads or writes an LSA_SEC_QOS structure.
 220 ********************************************************************/
 221 static BOOL lsa_io_sec_qos(char *desc, LSA_SEC_QOS * qos, prs_struct * ps,
 222                            int depth)
 223 {
 224         int start;
 225
 226         if (qos == NULL)
 227                 return False;
 228
 229         prs_debug(ps, depth, desc, "lsa_io_obj_qos");
 230         depth++;
 231
 232         prs_align(ps);
 233
 234         start = ps->offset;
 235
 236         /* these pointers had _better_ be zero, because we don't know
 237            what they point to!
 238          */
 239         prs_uint32("len           ", ps, depth, &(qos->len));   /* 0x18 - length (in bytes) inc. the length field. */
 240         prs_uint16("sec_imp_level ", ps, depth, &(qos->sec_imp_level));
 241         prs_uint8("sec_ctxt_mode ", ps, depth, &(qos->sec_ctxt_mode));
 242         prs_uint8("effective_only", ps, depth, &(qos->effective_only));
 243         prs_uint32("unknown       ", ps, depth, &(qos->unknown));
 244
 245         if (qos->len != ps->offset - start)
 246         {
 247                 DEBUG(3,
 248                       ("lsa_io_sec_qos: length %x does not match size %x\n",
 249                        qos->len, ps->offset - start));
 250         }
 251
 252         return True;
 253 }
 254
 255
 256 /*******************************************************************
 257 makes an LSA_OBJ_ATTR structure.
 258 ********************************************************************/
 259 BOOL make_lsa_obj_attr(LSA_OBJ_ATTR * attr, uint32 attributes,
 260                        LSA_SEC_QOS * qos)
 261 {
 262         if (attr == NULL)
 263                 return False;
 264
 265         DEBUG(5, ("make_lsa_obj_attr\n"));
 266
 267         attr->len = 0x18;       /* length of object attribute block, in bytes */
 268         attr->ptr_root_dir = 0;
 269         attr->ptr_obj_name = 0;
 270         attr->attributes = attributes;
 271         attr->ptr_sec_desc = 0;
 272
 273         if (qos != NULL)
 274         {
 275                 attr->ptr_sec_qos = 1;
 276                 attr->sec_qos = qos;
 277         }
 278         else
 279         {
 280                 attr->ptr_sec_qos = 0;
 281                 attr->sec_qos = NULL;
 282         }
 283
 284         return True;
 285 }
 286
 287 /*******************************************************************
 288 reads or writes an LSA_OBJ_ATTR structure.
 289 ********************************************************************/
 290 static BOOL lsa_io_obj_attr(char *desc, LSA_OBJ_ATTR * attr, prs_struct * ps,
 291                             int depth)
 292 {
 293         int start;
 294
 295         if (attr == NULL)
 296                 return False;
 297
 298         prs_debug(ps, depth, desc, "lsa_io_obj_attr");
 299         depth++;
 300
 301         prs_align(ps);
 302
 303         start = ps->offset;
 304
 305         /* these pointers had _better_ be zero, because we don't know
 306            what they point to!
 307          */
 308         prs_uint32("len         ", ps, depth, &(attr->len));    /* 0x18 - length (in bytes) inc. the length field. */
 309         prs_uint32("ptr_root_dir", ps, depth, &(attr->ptr_root_dir));   /* 0 - root directory (pointer) */
 310         prs_uint32("ptr_obj_name", ps, depth, &(attr->ptr_obj_name));   /* 0 - object name (pointer) */
 311         prs_uint32("attributes  ", ps, depth, &(attr->attributes));     /* 0 - attributes (undocumented) */
 312         prs_uint32("ptr_sec_desc", ps, depth, &(attr->ptr_sec_desc));   /* 0 - security descriptior (pointer) */
 313         prs_uint32("ptr_sec_qos ", ps, depth, &(attr->ptr_sec_qos));    /* security quality of service (pointer) */
 314
 315         if (attr->len != ps->offset - start)
 316         {
 317                 DEBUG(3,
 318                       ("lsa_io_obj_attr: length %x does not match size %x\n",
 319                        attr->len, ps->offset - start));
 320         }
 321
 322         if (attr->ptr_sec_qos != 0 && attr->sec_qos != NULL)
 323         {
 324                 lsa_io_sec_qos("sec_qos", attr->sec_qos, ps, depth);
 325         }
 326
 327         return True;
 328 }
 329
 330
 331 /*******************************************************************
 332 makes an LSA_Q_OPEN_POL structure.
 333 ********************************************************************/
 334 BOOL make_q_open_pol(LSA_Q_OPEN_POL * r_q, uint16 system_name,
 335                      uint32 attributes,
 336                      uint32 desired_access, LSA_SEC_QOS * qos)
 337 {
 338         if (r_q == NULL)
 339                 return False;
 340
 341         DEBUG(5,
 342               ("make_open_pol: attr:%d da:%d\n", attributes, desired_access));
 343
 344         r_q->ptr = 1;           /* undocumented pointer */
 345
 346         if (qos == NULL)
 347         {
 348                 r_q->des_access = desired_access;
 349         }
 350
 351         r_q->system_name = system_name;
 352         make_lsa_obj_attr(&(r_q->attr), attributes, qos);
 353
 354         return True;
 355 }
 356
 357 /*******************************************************************
 358 reads or writes an LSA_Q_OPEN_POL structure.
 359 ********************************************************************/
 360 BOOL lsa_io_q_open_pol(char *desc, LSA_Q_OPEN_POL * r_q, prs_struct * ps,
 361                        int depth)
 362 {
 363         if (r_q == NULL)
 364                 return False;
 365
 366         prs_debug(ps, depth, desc, "lsa_io_q_open_pol");
 367         depth++;
 368
 369         prs_uint32("ptr       ", ps, depth, &(r_q->ptr));
 370         prs_uint16("system_name", ps, depth, &(r_q->system_name));
 371         prs_align(ps);
 372
 373         lsa_io_obj_attr("", &(r_q->attr), ps, depth);
 374
 375         if (r_q->attr.ptr_sec_qos == 0)
 376         {
 377                 prs_uint32("des_access", ps, depth, &(r_q->des_access));
 378         }
 379
 380         return True;
 381 }
 382
 383 /*******************************************************************
 384 reads or writes an LSA_R_OPEN_POL structure.
 385 ********************************************************************/
 386 BOOL lsa_io_r_open_pol(char *desc, LSA_R_OPEN_POL * r_p, prs_struct * ps,
 387                        int depth)
 388 {
 389         if (r_p == NULL)
 390                 return False;
 391
 392         prs_debug(ps, depth, desc, "lsa_io_r_open_pol");
 393         depth++;
 394
 395         smb_io_pol_hnd("", &(r_p->pol), ps, depth);
 396
 397         prs_uint32("status", ps, depth, &(r_p->status));
 398
 399         return True;
 400 }
 401
 402 /*******************************************************************
 403 makes an LSA_Q_OPEN_POL2 structure.
 404 ********************************************************************/
 405 BOOL make_q_open_pol2(LSA_Q_OPEN_POL2 * r_q, const char *server_name,
 406                       uint32 attributes,
 407                       uint32 desired_access, LSA_SEC_QOS * qos)
 408 {
 409         if (r_q == NULL)
 410                 return False;
 411
 412         DEBUG(5,
 413               ("make_open_pol2: attr:%d da:%d\n", attributes,
 414                desired_access));
 415
 416         r_q->ptr = 1;           /* undocumented pointer */
 417
 418         if (qos == NULL)
 419         {
 420                 r_q->des_access = desired_access;
 421         }
 422
 423         make_unistr2(&(r_q->uni_server_name), server_name,
 424                      strlen(server_name));
 425         make_lsa_obj_attr(&(r_q->attr), attributes, qos);
 426
 427         return True;
 428 }
 429
 430 /*******************************************************************
 431 reads or writes an LSA_Q_OPEN_POL2 structure.
 432 ********************************************************************/
 433 BOOL lsa_io_q_open_pol2(char *desc, LSA_Q_OPEN_POL2 * r_q, prs_struct * ps,
 434                         int depth)
 435 {
 436         if (r_q == NULL)
 437                 return False;
 438
 439         prs_debug(ps, depth, desc, "lsa_io_q_open_pol2");
 440         depth++;
 441
 442         prs_uint32("ptr       ", ps, depth, &(r_q->ptr));
 443
 444         smb_io_unistr2("", &(r_q->uni_server_name), r_q->ptr, ps, depth);
 445         prs_align(ps);
 446
 447         lsa_io_obj_attr("", &(r_q->attr), ps, depth);
 448
 449         if (r_q->attr.ptr_sec_qos == 0)
 450         {
 451                 prs_uint32("des_access", ps, depth, &(r_q->des_access));
 452         }
 453
 454         return True;
 455 }
 456
 457 /*******************************************************************
 458 reads or writes an LSA_R_OPEN_POL2 structure.
 459 ********************************************************************/
 460 BOOL lsa_io_r_open_pol2(char *desc, LSA_R_OPEN_POL2 * r_p, prs_struct * ps,
 461                         int depth)
 462 {
 463         if (r_p == NULL)
 464                 return False;
 465
 466         prs_debug(ps, depth, desc, "lsa_io_r_open_pol2");
 467         depth++;
 468
 469         smb_io_pol_hnd("", &(r_p->pol), ps, depth);
 470
 471         prs_uint32("status", ps, depth, &(r_p->status));
 472
 473         return True;
 474
 475         return True;
 476 }
 477
 478 /*******************************************************************
 479 makes an LSA_Q_QUERY_SEC_OBJ structure.
 480 ********************************************************************/
 481 BOOL make_q_query_sec_obj(LSA_Q_QUERY_SEC_OBJ * q_q, const POLICY_HND *hnd,
 482                                 uint32 sec_info)
 483 {
 484         if (q_q == NULL || hnd == NULL)
 485                 return False;
 486
 487         DEBUG(5, ("make_q_query_sec_obj\n"));
 488
 489         q_q->pol = *hnd;
 490         q_q->sec_info = sec_info;
 491
 492         return True;
 493 }
 494
 495 /*******************************************************************
 496 reads or writes an LSA_Q_QUERY_SEC_OBJ structure.
 497 ********************************************************************/
 498 BOOL lsa_io_q_query_sec_obj(char *desc, LSA_Q_QUERY_SEC_OBJ * q_q, prs_struct * ps,
 499                     int depth)
 500 {
 501         if (q_q == NULL)
 502                 return False;
 503
 504         prs_debug(ps, depth, desc, "lsa_io_q_query_sec_obj");
 505         depth++;
 506
 507         smb_io_pol_hnd("", &(q_q->pol), ps, depth);
 508         prs_uint32("sec_info", ps, depth, &(q_q->sec_info));
 509
 510         return True;
 511 }
 512
 513 /*******************************************************************
 514 reads or writes a LSA_R_QUERY_SEC_OBJ structure.
 515 ********************************************************************/
 516 BOOL lsa_io_r_query_sec_obj(char *desc,  LSA_R_QUERY_SEC_OBJ *r_u, prs_struct *ps, int depth)
 517 {
 518         if (r_u == NULL) return False;
 519
 520         prs_debug(ps, depth, desc, "lsa_io_r_query_sec_obj");
 521         depth++;
 522
 523         prs_align(ps);
 524
 525         prs_uint32("ptr", ps, depth, &(r_u->ptr));
 526         if (r_u->ptr != 0x0)
 527         {
 528                 sec_io_desc_buf("sec", &r_u->buf, ps, depth);
 529         }
 530         prs_uint32("status", ps, depth, &(r_u->status));
 531
 532         return True;
 533 }
 534 /*******************************************************************
 535 makes an LSA_Q_QUERY_INFO structure.
 536 ********************************************************************/
 537 BOOL make_q_query(LSA_Q_QUERY_INFO * q_q, POLICY_HND *hnd, uint16 info_class)
 538 {
 539         if (q_q == NULL || hnd == NULL)
 540                 return False;
 541
 542         DEBUG(5, ("make_q_query\n"));
 543
 544         memcpy(&(q_q->pol), hnd, sizeof(q_q->pol));
 545
 546         q_q->info_class = info_class;
 547
 548         return True;
 549 }
 550
 551 /*******************************************************************
 552 reads or writes an LSA_Q_QUERY_INFO structure.
 553 ********************************************************************/
 554 BOOL lsa_io_q_query(char *desc, LSA_Q_QUERY_INFO * q_q, prs_struct * ps,
 555                     int depth)
 556 {
 557         if (q_q == NULL)
 558                 return False;
 559
 560         prs_debug(ps, depth, desc, "lsa_io_q_query");
 561         depth++;
 562
 563         smb_io_pol_hnd("", &(q_q->pol), ps, depth);
 564
 565         prs_uint16("info_class", ps, depth, &(q_q->info_class));
 566
 567         return True;
 568 }
 569
 570 /*******************************************************************
 571 makes an LSA_Q_CREATE_SECRET structure.
 572 ********************************************************************/
 573 BOOL make_q_create_secret(LSA_Q_CREATE_SECRET * q_o,
 574                           const POLICY_HND *pol_hnd, const char *secret_name,
 575                           uint32 desired_access)
 576 {
 577         int len = strlen(secret_name);
 578
 579         if (q_o == NULL)
 580                 return False;
 581
 582         DEBUG(5, ("make_q_create_secret"));
 583
 584         memcpy(&(q_o->pol), pol_hnd, sizeof(q_o->pol));
 585
 586         make_uni_hdr(&(q_o->hdr_secret), len);
 587         make_unistr2(&(q_o->uni_secret), secret_name, len);
 588
 589         q_o->des_access = desired_access;
 590
 591         return True;
 592 }
 593
 594 /*******************************************************************
 595 reads or writes an LSA_Q_CREATE_SECRET structure.
 596 ********************************************************************/
 597 BOOL lsa_io_q_create_secret(char *desc, LSA_Q_CREATE_SECRET * q_o,
 598                             prs_struct * ps, int depth)
 599 {
 600         if (q_o == NULL)
 601                 return False;
 602
 603         prs_debug(ps, depth, desc, "lsa_io_q_create_secret");
 604         depth++;
 605
 606         smb_io_pol_hnd("", &(q_o->pol), ps, depth);
 607
 608         prs_align(ps);
 609         smb_io_unihdr("", &(q_o->hdr_secret), ps, depth);
 610         smb_io_unistr2("", &(q_o->uni_secret), 1, ps, depth);
 611
 612         prs_align(ps);
 613         prs_uint32("des_access", ps, depth, &(q_o->des_access));
 614
 615         return True;
 616 }
 617
 618 /*******************************************************************
 619 reads or writes an LSA_R_CREATE_SECRET structure.
 620 ********************************************************************/
 621 BOOL lsa_io_r_create_secret(char *desc, LSA_R_CREATE_SECRET * r_o,
 622                             prs_struct * ps, int depth)
 623 {
 624         if (r_o == NULL)
 625                 return False;
 626
 627         prs_debug(ps, depth, desc, "lsa_io_r_create_secret");
 628         depth++;
 629
 630         smb_io_pol_hnd("", &(r_o->pol), ps, depth);
 631
 632         prs_uint32("status", ps, depth, &(r_o->status));
 633
 634         return True;
 635 }
 636
 637 /*******************************************************************
 638 makes an LSA_Q_OPEN_SECRET structure.
 639 ********************************************************************/
 640 BOOL make_q_open_secret(LSA_Q_OPEN_SECRET * q_o, const POLICY_HND *pol_hnd,
 641                         const char *secret_name, uint32 desired_access)
 642 {
 643         int len = strlen(secret_name);
 644
 645         if (q_o == NULL)
 646                 return False;
 647
 648         DEBUG(5, ("make_q_open_secret"));
 649
 650         memcpy(&(q_o->pol), pol_hnd, sizeof(q_o->pol));
 651
 652         make_uni_hdr(&(q_o->hdr_secret), len);
 653         make_unistr2(&(q_o->uni_secret), secret_name, len);
 654
 655         q_o->des_access = desired_access;
 656
 657         return True;
 658 }
 659
 660 /*******************************************************************
 661 reads or writes an LSA_Q_OPEN_SECRET structure.
 662 ********************************************************************/
 663 BOOL lsa_io_q_open_secret(char *desc, LSA_Q_OPEN_SECRET * q_o,
 664                           prs_struct * ps, int depth)
 665 {
 666         if (q_o == NULL)
 667                 return False;
 668
 669         prs_debug(ps, depth, desc, "lsa_io_q_open_secret");
 670         depth++;
 671
 672         smb_io_pol_hnd("", &(q_o->pol), ps, depth);
 673
 674         prs_align(ps);
 675         smb_io_unihdr("", &(q_o->hdr_secret), ps, depth);
 676         smb_io_unistr2("", &(q_o->uni_secret), 1, ps, depth);
 677
 678         prs_align(ps);
 679         prs_uint32("des_access", ps, depth, &(q_o->des_access));
 680
 681         return True;
 682 }
 683
 684 /*******************************************************************
 685 reads or writes an LSA_R_OPEN_SECRET structure.
 686 ********************************************************************/
 687 BOOL lsa_io_r_open_secret(char *desc, LSA_R_OPEN_SECRET * r_o,
 688                           prs_struct * ps, int depth)
 689 {
 690         if (r_o == NULL)
 691                 return False;
 692
 693         prs_debug(ps, depth, desc, "lsa_io_r_open_secret");
 694         depth++;
 695
 696         smb_io_pol_hnd("", &(r_o->pol), ps, depth);
 697
 698         prs_uint32("status", ps, depth, &(r_o->status));
 699
 700         return True;
 701 }
 702
 703 /*******************************************************************
 704 reads or writes an LSA_SECRET_VALUE structure.
 705 ********************************************************************/
 706 BOOL lsa_io_secret_value(char *desc, LSA_SECRET_VALUE * value,
 707                          prs_struct * ps, int depth)
 708 {
 709         if (value == NULL)
 710                 return False;
 711
 712         prs_debug(ps, depth, desc, "lsa_io_secret_value");
 713         depth++;
 714
 715         prs_align(ps);
 716         prs_uint32("ptr_secret", ps, depth, &(value->ptr_secret));
 717
 718         if (value->ptr_secret != 0)
 719         {
 720                 smb_io_strhdr2("hdr_secret", &(value->hdr_secret), ps, depth);
 721                 smb_io_string2("secret", &(value->enc_secret),
 722                                value->hdr_secret.buffer, ps, depth);
 723         }
 724
 725         prs_align(ps);
 726
 727         return True;
 728 }
 729
 730 /*******************************************************************
 731 reads or writes an LSA_SECRET_INFO structure.
 732 ********************************************************************/
 733 BOOL lsa_io_secret_info(char *desc, LSA_SECRET_INFO * info, prs_struct * ps,
 734                         int depth)
 735 {
 736         if (info == NULL)
 737                 return False;
 738
 739         prs_debug(ps, depth, desc, "lsa_io_secret_info");
 740         depth++;
 741
 742         prs_align(ps);
 743         prs_uint32("ptr_value ", ps, depth, &(info->ptr_value));
 744
 745         if (info->ptr_value != 0)
 746         {
 747                 lsa_io_secret_value("", &(info->value), ps, depth);
 748         }
 749
 750         prs_align(ps);
 751         prs_uint32("ptr_update", ps, depth, &(info->ptr_update));
 752
 753         if (info->ptr_update != 0)
 754         {
 755                 ps->align = 8;
 756                 prs_align(ps);
 757                 ps->align = 4;
 758
 759                 smb_io_time("last_update", &(info->last_update), ps, depth);
 760         }
 761
 762         prs_align(ps);
 763
 764         return True;
 765 }
 766
 767 /*******************************************************************
 768 reads or writes an LSA_SECRET structure.
 769 ********************************************************************/
 770 BOOL lsa_io_secret(char *desc, LSA_SECRET * q_q, prs_struct * ps, int depth)
 771 {
 772         if (q_q == NULL)
 773                 return False;
 774
 775         prs_debug(ps, depth, desc, "lsa_io_secret");
 776         depth++;
 777
 778         lsa_io_secret_info("", &(q_q->curinfo), ps, depth);
 779         lsa_io_secret_info("", &(q_q->oldinfo), ps, depth);
 780
 781         return True;
 782 }
 783
 784 /*******************************************************************
 785 makes an LSA_Q_QUERY_SECRET structure.
 786 ********************************************************************/
 787 BOOL make_q_query_secret(LSA_Q_QUERY_SECRET * q_q, POLICY_HND *pol,
 788                          const STRING2 *secret, const NTTIME * update)
 789 {
 790         if (q_q == NULL)
 791                 return False;
 792
 793         DEBUG(5, ("make_q_query_secret\n"));
 794
 795         memcpy(&(q_q->pol), pol, sizeof(q_q->pol));
 796
 797         /* Want secret */
 798         q_q->sec.curinfo.ptr_value = secret != NULL ? 1 : 0;
 799         q_q->sec.curinfo.value.ptr_secret = 0;
 800
 801         /* Want last change time */
 802         q_q->sec.curinfo.ptr_update = update != NULL ? 1 : 0;
 803
 804         /* Don't care about old info */
 805         q_q->sec.oldinfo.ptr_value = 0;
 806         q_q->sec.oldinfo.ptr_update = 0;
 807
 808         return True;
 809 }
 810
 811 /*******************************************************************
 812 reads or writes an LSA_Q_QUERY_SECRET structure.
 813 ********************************************************************/
 814 BOOL lsa_io_q_query_secret(char *desc, LSA_Q_QUERY_SECRET * q_q,
 815                            prs_struct * ps, int depth)
 816 {
 817         if (q_q == NULL)
 818                 return False;
 819
 820         prs_debug(ps, depth, desc, "lsa_io_q_query_secret");
 821         depth++;
 822
 823         smb_io_pol_hnd("", &(q_q->pol), ps, depth);
 824         lsa_io_secret("", &(q_q->sec), ps, depth);
 825
 826         return True;
 827 }
 828
 829 /*******************************************************************
 830 reads or writes an LSA_Q_QUERY_SECRET structure.
 831 ********************************************************************/
 832 BOOL lsa_io_r_query_secret(char *desc, LSA_R_QUERY_SECRET * r_q,
 833                            prs_struct * ps, int depth)
 834 {
 835         if (r_q == NULL)
 836                 return False;
 837
 838         prs_debug(ps, depth, desc, "lsa_io_r_query_secret");
 839         depth++;
 840
 841         lsa_io_secret("", &(r_q->sec), ps, depth);
 842         prs_align(ps);
 843         prs_uint32("status", ps, depth, &(r_q->status));
 844
 845         return True;
 846 }
 847
 848 /*******************************************************************
 849 reads or writes an LSA_Q_SET_SECRET structure.
 850 ********************************************************************/
 851 BOOL lsa_io_q_set_secret(char *desc, LSA_Q_SET_SECRET * q_q, prs_struct * ps,
 852                          int depth)
 853 {
 854         if (q_q == NULL)
 855                 return False;
 856
 857         prs_debug(ps, depth, desc, "lsa_io_q_set_secret");
 858         depth++;
 859
 860         smb_io_pol_hnd("", &(q_q->pol), ps, depth);
 861
 862         lsa_io_secret_value("", &(q_q->value), ps, depth);
 863         prs_uint32("unknown", ps, depth, &(q_q->unknown));
 864
 865         return True;
 866 }
 867
 868 /*******************************************************************
 869 reads or writes an LSA_Q_SET_SECRET structure.
 870 ********************************************************************/
 871 BOOL lsa_io_r_set_secret(char *desc, LSA_R_SET_SECRET * r_q, prs_struct * ps,
 872                          int depth)
 873 {
 874         if (r_q == NULL)
 875                 return False;
 876
 877         prs_debug(ps, depth, desc, "lsa_io_r_set_secret");
 878         depth++;
 879
 880         prs_align(ps);
 881         prs_uint32("status", ps, depth, &(r_q->status));
 882
 883         return True;
 884 }
 885
 886 /*******************************************************************
 887 makes an LSA_Q_ENUM_TRUST_DOM structure.
 888 ********************************************************************/
 889 BOOL make_q_enum_trust_dom(LSA_Q_ENUM_TRUST_DOM * q_e,
 890                            POLICY_HND *pol,
 891                            uint32 enum_context, uint32 preferred_len)
 892 {
 893         if (q_e == NULL)
 894                 return False;
 895
 896         DEBUG(5, ("make_q_enum_trust_dom\n"));
 897
 898         memcpy(&(q_e->pol), pol, sizeof(q_e->pol));
 899         q_e->enum_context = enum_context;
 900         q_e->preferred_len = preferred_len;
 901
 902         return True;
 903 }
 904
 905 /*******************************************************************
 906 reads or writes an LSA_Q_ENUM_TRUST_DOM structure.
 907 ********************************************************************/
 908 BOOL lsa_io_q_enum_trust_dom(char *desc, LSA_Q_ENUM_TRUST_DOM * q_e,
 909                              prs_struct * ps, int depth)
 910 {
 911         if (q_e == NULL)
 912                 return False;
 913
 914         prs_debug(ps, depth, desc, "lsa_io_q_enum_trust_dom");
 915         depth++;
 916
 917
 918         smb_io_pol_hnd("", &(q_e->pol), ps, depth);
 919
 920         prs_uint32("enum_context ", ps, depth, &(q_e->enum_context));
 921         prs_uint32("preferred_len", ps, depth, &(q_e->preferred_len));
 922
 923         return True;
 924 }
 925
 926 /*******************************************************************
 927 makes an LSA_R_ENUM_TRUST_DOM structure.
 928 ********************************************************************/
 929 BOOL make_r_enum_trust_dom(LSA_R_ENUM_TRUST_DOM * r_e, int32 enum_context,
 930                            uint32 num_domains,
 931                            UNISTR2 * domain_names, DOM_SID ** domain_sids,
 932                            uint32 status)
 933 {
 934         if (r_e == NULL)
 935                 return False;
 936
 937         DEBUG(5, ("make_r_enum_trust_dom\n"));
 938
 939         r_e->enum_context = enum_context;
 940
 941         if ((domain_names == NULL) || (domain_sids == NULL))
 942         {
 943                 num_domains = 0;
 944         }
 945
 946         if ((status == 0) && (num_domains != 0))
 947         {
 948                 uint32 i;
 949
 950                 r_e->num_domains = num_domains;
 951                 r_e->ptr_enum_domains = 1;
 952                 r_e->num_domains2 = num_domains;
 953
 954                 r_e->hdr_domain_name = g_new(UNIHDR2, num_domains);
 955                 r_e->domain_sid = g_new(DOM_SID2, num_domains);
 956                 if ((r_e->hdr_domain_name == NULL)
 957                     || (r_e->domain_sid == NULL))
 958                 {
 959                         r_e->uni_domain_name = NULL;
 960                         lsa_free_r_enum_trust_dom(r_e);
 961                         r_e->status = status;
 962                         return False;
 963                 }
 964                 r_e->uni_domain_name = domain_names;
 965                 for (i = 0; i < num_domains; i++)
 966                 {
 967                         make_unihdr2_from_unistr2(&(r_e->hdr_domain_name[i]),
 968                                                   &(domain_names[i]));
 969                         make_dom_sid2(&(r_e->domain_sid[i]), domain_sids[i]);
 970                 }
 971         }
 972         else
 973         {
 974                 r_e->num_domains = 0;
 975                 r_e->ptr_enum_domains = 0;
 976         }
 977
 978         r_e->status = status;
 979
 980         return True;
 981 }
 982
 983 /*******************************************************************
 984 reads or writes an LSA_R_ENUM_TRUST_DOM structure.
 985 ********************************************************************/
 986 BOOL lsa_io_r_enum_trust_dom(char *desc, LSA_R_ENUM_TRUST_DOM * r_e,
 987                              prs_struct * ps, int depth)
 988 {
 989         if (r_e == NULL)
 990                 return False;
 991
 992         prs_debug(ps, depth, desc, "lsa_io_r_enum_trust_dom");
 993         depth++;
 994
 995         prs_uint32("enum_context    ", ps, depth, &(r_e->enum_context));
 996         prs_uint32("num_domains     ", ps, depth, &(r_e->num_domains));
 997         prs_uint32("ptr_enum_domains", ps, depth, &(r_e->ptr_enum_domains));
 998
 999         if (r_e->ptr_enum_domains != 0)
1000         {
1001                 uint32 i, num_domains;
1002                 prs_uint32("num_domains2", ps, depth, &(r_e->num_domains2));
1003                 num_domains = r_e->num_domains2;
1004
1005                 if (ps->io)
1006                 {
1007                         r_e->uni_domain_name = g_new(UNISTR2, num_domains);
1008                         r_e->hdr_domain_name = g_new(UNIHDR2, num_domains);
1009                         r_e->domain_sid = g_new(DOM_SID2, num_domains);
1010                         if ((r_e->uni_domain_name == NULL)
1011                             || (r_e->hdr_domain_name == NULL)
1012                             || (r_e->domain_sid == NULL))
1013                         {
1014                                 lsa_free_r_enum_trust_dom(r_e);
1015                                 return False;
1016                         }
1017                 }
1018
1019                 for (i = 0; i < num_domains; i++)
1020                 {
1021                         smb_io_unihdr2("", &(r_e->hdr_domain_name[i]), ps,
1022                                        depth);
1023                 }
1024
1025                 for (i = 0; i < num_domains; i++)
1026                 {
1027                         smb_io_unistr2("", &(r_e->uni_domain_name[i]),
1028                                        r_e->hdr_domain_name[i].buffer, ps,
1029                                        depth);
1030                         prs_align(ps);
1031                         smb_io_dom_sid2("", &(r_e->domain_sid[i]), ps, depth);
1032                 }
1033         }
1034
1035         prs_uint32("status", ps, depth, &(r_e->status));
1036
1037         if (!ps->io)
1038         {
1039                 r_e->uni_domain_name = NULL;
1040                 lsa_free_r_enum_trust_dom(r_e);
1041         }
1042
1043         return True;
1044 }
1045
1046 void lsa_free_r_enum_trust_dom(LSA_R_ENUM_TRUST_DOM * r_e)
1047 {
1048         if (r_e == NULL)
1049         {
1050                 return;
1051         }
1052         safe_free(r_e->uni_domain_name);
1053         safe_free(r_e->hdr_domain_name);
1054         safe_free(r_e->domain_sid);
1055         r_e->uni_domain_name = NULL;
1056         r_e->hdr_domain_name = NULL;
1057         r_e->domain_sid = NULL;
1058
1059         r_e->num_domains = 0;
1060         r_e->ptr_enum_domains = 0;
1061 }
1062
1063 /*******************************************************************
1064 reads or writes an LSA_R_QUERY_INFO structure.
1065 ********************************************************************/
1066 BOOL lsa_io_r_query(char *desc, LSA_R_QUERY_INFO * r_q, prs_struct * ps,
1067                     int depth)
1068 {
1069         if (r_q == NULL)
1070                 return False;
1071
1072         prs_debug(ps, depth, desc, "lsa_io_r_query");
1073         depth++;
1074
1075         prs_uint32("undoc_buffer", ps, depth, &(r_q->undoc_buffer));
1076
1077         if (r_q->undoc_buffer != 0)
1078         {
1079                 prs_uint16("info_class", ps, depth, &(r_q->info_class));
1080                 prs_align(ps);
1081
1082                 switch (r_q->info_class)
1083                 {
1084                         case 3:
1085                         {
1086                                 smb_io_dom_query_3("", &(r_q->dom.id3), ps,
1087                                                    depth);
1088                                 break;
1089                         }
1090                         case 5:
1091                         {
1092                                 smb_io_dom_query_5("", &(r_q->dom.id3), ps,
1093                                                    depth);
1094                                 break;
1095                         }
1096                         default:
1097                         {
1098                                 /* PANIC! */
1099                                 break;
1100                         }
1101                 }
1102         }
1103
1104         prs_uint32("status", ps, depth, &(r_q->status));
1105
1106         return True;
1107 }
1108
1109 /*******************************************************************
1110 makes a LSA_SID_ENUM structure.
1111 ********************************************************************/
1112 BOOL make_lsa_sid_enum(LSA_SID_ENUM * sen, uint32 num_entries,
1113                        DOM_SID ** sids)
1114 {
1115         uint32 i, i2;
1116         if (sen == NULL || sids == NULL)
1117                 return False;
1118
1119         DEBUG(5, ("make_lsa_sid_enum\n"));
1120
1121         sen->num_entries = num_entries;
1122         sen->ptr_sid_enum = num_entries != 0 ? 1 : 0;
1123         sen->num_entries2 = num_entries;
1124
1125         SMB_ASSERT_ARRAY(sen->sid, sen->num_entries);
1126
1127         for (i = 0, i2 = 0; i < num_entries; i++)
1128         {
1129                 if (sids[i] != NULL)
1130                 {
1131                         sen->ptr_sid[i] = 1;
1132                         make_dom_sid2(&(sen->sid[i2]), sids[i]);
1133                         i2++;
1134                 }
1135                 else
1136                 {
1137                         sen->ptr_sid[i] = 0;
1138                 }
1139         }
1140
1141         return True;
1142 }
1143
1144 /*******************************************************************
1145 reads or writes a LSA_SID_ENUM structure.
1146 ********************************************************************/
1147 static BOOL lsa_io_sid_enum(char *desc, LSA_SID_ENUM * sen,
1148                             prs_struct * ps, int depth)
1149 {
1150         uint32 i;
1151
1152         if (sen == NULL)
1153                 return False;
1154
1155         prs_debug(ps, depth, desc, "lsa_io_sid_enum");
1156         depth++;
1157
1158         prs_align(ps);
1159
1160         prs_uint32("num_entries ", ps, depth, &(sen->num_entries));
1161         prs_uint32("ptr_sid_enum", ps, depth, &(sen->ptr_sid_enum));
1162         prs_uint32("num_entries2", ps, depth, &(sen->num_entries2));
1163
1164         SMB_ASSERT_ARRAY(sen->ptr_sid, sen->num_entries);
1165
1166         for (i = 0; i < sen->num_entries; i++)
1167         {
1168                 fstring temp;
1169                 slprintf(temp, sizeof(temp) - 1, "ptr_sid[%d]", i);
1170                 prs_uint32(temp, ps, depth, &(sen->ptr_sid[i]));        /* domain SID pointers to be looked up. */
1171         }
1172
1173         SMB_ASSERT_ARRAY(sen->sid, sen->num_entries);
1174
1175         for (i = 0; i < sen->num_entries; i++)
1176         {
1177                 fstring temp;
1178                 slprintf(temp, sizeof(temp) - 1, "sid[%d]", i);
1179                 smb_io_dom_sid2(temp, &(sen->sid[i]), ps, depth);       /* domain SIDs to be looked up. */
1180         }
1181
1182         return True;
1183 }
1184
1185 /*******************************************************************
1186 reads or writes a structure.
1187 ********************************************************************/
1188 static BOOL lsa_io_trans_names(char *desc, LSA_TRANS_NAME_ENUM * trn,
1189                                prs_struct * ps, int depth)
1190 {
1191         uint32 i;
1192
1193         if (trn == NULL)
1194                 return False;
1195
1196         prs_debug(ps, depth, desc, "lsa_io_trans_names");
1197         depth++;
1198
1199         prs_align(ps);
1200
1201         prs_uint32("num_entries    ", ps, depth, &(trn->num_entries));
1202         prs_uint32("ptr_trans_names", ps, depth, &(trn->ptr_trans_names));
1203
1204         if (trn->ptr_trans_names != 0)
1205         {
1206                 prs_uint32("num_entries2   ", ps, depth,
1207                            &(trn->num_entries2));
1208                 SMB_ASSERT_ARRAY(trn->name, trn->num_entries);
1209
1210                 for (i = 0; i < trn->num_entries2; i++)
1211                 {
1212                         fstring t;
1213                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1214
1215                         lsa_io_trans_name(t, &(trn->name[i]), ps, depth);       /* translated name */
1216
1217                 }
1218                 for (i = 0; i < trn->num_entries2; i++)
1219                 {
1220                         fstring t;
1221                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1222
1223                         smb_io_unistr2(t, &(trn->uni_name[i]),
1224                                        trn->name[i].hdr_name.buffer, ps,
1225                                        depth);
1226                         prs_align(ps);
1227                 }
1228         }
1229
1230         return True;
1231 }
1232
1233 /*******************************************************************
1234 makes a structure.
1235 ********************************************************************/
1236 BOOL make_q_lookup_sids(LSA_Q_LOOKUP_SIDS * q_l, POLICY_HND *hnd,
1237                         int num_sids, DOM_SID ** sids, uint16 level)
1238 {
1239         if (q_l == NULL)
1240                 return False;
1241
1242         DEBUG(5, ("make_q_lookup_sids\n"));
1243
1244         memcpy(&(q_l->pol), hnd, sizeof(q_l->pol));
1245         make_lsa_sid_enum(&(q_l->sids), num_sids, sids);
1246
1247         q_l->names.ptr_trans_names = 0;
1248         q_l->names.num_entries = 0;
1249
1250         q_l->level.value = level;
1251
1252         return True;
1253 }
1254
1255 /*******************************************************************
1256 reads or writes a LSA_Q_LOOKUP_SIDS structure.
1257 ********************************************************************/
1258 BOOL lsa_io_q_lookup_sids(char *desc, LSA_Q_LOOKUP_SIDS * q_s,
1259                           prs_struct * ps, int depth)
1260 {
1261         if (q_s == NULL)
1262                 return False;
1263
1264         prs_debug(ps, depth, desc, "lsa_io_q_lookup_sids");
1265         depth++;
1266
1267         prs_align(ps);
1268
1269         smb_io_pol_hnd("pol_hnd", &(q_s->pol), ps, depth);      /* policy handle */
1270         lsa_io_sid_enum("sids   ", &(q_s->sids), ps, depth);    /* sids to be looked up */
1271         lsa_io_trans_names("names  ", &(q_s->names), ps, depth);        /* translated names */
1272         smb_io_lookup_level("switch ", &(q_s->level), ps, depth);       /* lookup level */
1273
1274         prs_uint32("mapped_count", ps, depth, &(q_s->mapped_count));
1275
1276         return True;
1277 }
1278
1279 /*******************************************************************
1280 reads or writes a structure.
1281 ********************************************************************/
1282 BOOL lsa_io_r_lookup_sids(char *desc, LSA_R_LOOKUP_SIDS * r_s,
1283                           prs_struct * ps, int depth)
1284 {
1285         if (r_s == NULL)
1286                 return False;
1287
1288         prs_debug(ps, depth, desc, "lsa_io_r_lookup_sids");
1289         depth++;
1290
1291         prs_align(ps);
1292
1293         prs_uint32("ptr_dom_ref", ps, depth, &(r_s->ptr_dom_ref));
1294         if (r_s->ptr_dom_ref != 0)
1295         {
1296                 lsa_io_dom_r_ref("dom_ref", r_s->dom_ref, ps, depth);   /* domain reference info */
1297         }
1298         lsa_io_trans_names("names  ", r_s->names, ps, depth);   /* translated names */
1299
1300         prs_align(ps);
1301
1302         prs_uint32("mapped_count", ps, depth, &(r_s->mapped_count));
1303
1304         prs_uint32("status      ", ps, depth, &(r_s->status));
1305
1306         return True;
1307 }
1308
1309 /*******************************************************************
1310 makes a structure.
1311 ********************************************************************/
1312 BOOL make_q_lookup_names(LSA_Q_LOOKUP_NAMES * q_l, POLICY_HND *hnd,
1313                          uint32 num_names, char **names)
1314 {
1315         uint32 i;
1316         if (q_l == NULL)
1317                 return False;
1318
1319         DEBUG(5, ("make_q_lookup_names\n"));
1320
1321         memcpy(&(q_l->pol), hnd, sizeof(q_l->pol));
1322
1323         q_l->num_entries = num_names;
1324         q_l->num_entries2 = num_names;
1325
1326         SMB_ASSERT_ARRAY(q_l->uni_name, q_l->num_entries);
1327
1328         for (i = 0; i < num_names; i++)
1329         {
1330                 const char *name = names[i];
1331                 int len = strlen(name);
1332                 make_uni_hdr(&q_l->hdr_name[i], len);
1333                 make_unistr2(&q_l->uni_name[i], name, len);
1334         }
1335
1336         q_l->num_trans_entries = 0;
1337         q_l->ptr_trans_sids = 0;
1338         q_l->lookup_level = 1;
1339         q_l->mapped_count = 0;
1340
1341         return True;
1342 }
1343
1344 /*******************************************************************
1345 reads or writes a structure.
1346 ********************************************************************/
1347 BOOL lsa_io_q_lookup_names(char *desc, LSA_Q_LOOKUP_NAMES * q_r,
1348                            prs_struct * ps, int depth)
1349 {
1350         uint32 i;
1351
1352         if (q_r == NULL)
1353                 return False;
1354
1355         prs_debug(ps, depth, desc, "lsa_io_q_lookup_names");
1356         depth++;
1357
1358         prs_align(ps);
1359
1360         smb_io_pol_hnd("", &(q_r->pol), ps, depth);     /* policy handle */
1361
1362         prs_uint32("num_entries    ", ps, depth, &(q_r->num_entries));
1363         prs_uint32("num_entries2   ", ps, depth, &(q_r->num_entries2));
1364
1365         SMB_ASSERT_ARRAY(q_r->uni_name, q_r->num_entries);
1366
1367         for (i = 0; i < q_r->num_entries; i++)
1368         {
1369                 smb_io_unihdr("hdr_name", &(q_r->hdr_name[i]), ps, depth);      /* pointer names */
1370         }
1371
1372         for (i = 0; i < q_r->num_entries; i++)
1373         {
1374                 smb_io_unistr2("dom_name", &(q_r->uni_name[i]),
1375                                q_r->hdr_name[i].buffer, ps, depth);     /* names to be looked up */
1376                 prs_align(ps);
1377         }
1378
1379         prs_uint32("num_trans_entries ", ps, depth,
1380                    &(q_r->num_trans_entries));
1381         prs_uint32("ptr_trans_sids ", ps, depth, &(q_r->ptr_trans_sids));
1382         prs_uint32("lookup_level   ", ps, depth, &(q_r->lookup_level));
1383         prs_uint32("mapped_count   ", ps, depth, &(q_r->mapped_count));
1384
1385         return True;
1386 }
1387
1388 /*******************************************************************
1389 reads or writes a structure.
1390 ********************************************************************/
1391 BOOL lsa_io_r_lookup_names(char *desc, LSA_R_LOOKUP_NAMES * r_r,
1392                            prs_struct * ps, int depth)
1393 {
1394         uint32 i;
1395
1396         if (r_r == NULL)
1397                 return False;
1398
1399         prs_debug(ps, depth, desc, "lsa_io_r_lookup_names");
1400         depth++;
1401
1402         prs_align(ps);
1403
1404         prs_uint32("ptr_dom_ref", ps, depth, &(r_r->ptr_dom_ref));
1405         if (r_r->ptr_dom_ref != 0)
1406         {
1407                 lsa_io_dom_r_ref("", r_r->dom_ref, ps, depth);
1408         }
1409
1410         prs_uint32("num_entries", ps, depth, &(r_r->num_entries));
1411         prs_uint32("ptr_entries", ps, depth, &(r_r->ptr_entries));
1412
1413         if (r_r->ptr_entries != 0)
1414         {
1415                 prs_uint32("num_entries2", ps, depth, &(r_r->num_entries2));
1416
1417                 if (r_r->num_entries2 != r_r->num_entries)
1418                 {
1419                         /* RPC fault */
1420                         return False;
1421                 }
1422
1423                 for (i = 0; i < r_r->num_entries2; i++)
1424                 {
1425                         smb_io_dom_rid2("", &(r_r->dom_rid[i]), ps, depth);     /* domain RIDs being looked up */
1426                 }
1427         }
1428
1429         prs_uint32("mapped_count", ps, depth, &(r_r->mapped_count));
1430
1431         prs_uint32("status      ", ps, depth, &(r_r->status));
1432
1433         return True;
1434 }
1435
1436
1437 /*******************************************************************
1438 makes an LSA_Q_CLOSE structure.
1439 ********************************************************************/
1440 BOOL make_lsa_q_close(LSA_Q_CLOSE * q_c, POLICY_HND *hnd)
1441 {
1442         if (q_c == NULL || hnd == NULL)
1443                 return False;
1444
1445         DEBUG(5, ("make_lsa_q_close\n"));
1446
1447         memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
1448
1449         return True;
1450 }
1451
1452 /*******************************************************************
1453 reads or writes an LSA_Q_CLOSE structure.
1454 ********************************************************************/
1455 BOOL lsa_io_q_close(char *desc, LSA_Q_CLOSE * q_c, prs_struct * ps, int depth)
1456 {
1457         if (q_c == NULL)
1458                 return False;
1459
1460         prs_debug(ps, depth, desc, "lsa_io_q_close");
1461         depth++;
1462
1463         smb_io_pol_hnd("", &(q_c->pol), ps, depth);
1464
1465         return True;
1466 }
1467
1468 /*******************************************************************
1469 reads or writes an LSA_R_CLOSE structure.
1470 ********************************************************************/
1471 BOOL lsa_io_r_close(char *desc, LSA_R_CLOSE * r_c, prs_struct * ps, int depth)
1472 {
1473         if (r_c == NULL)
1474                 return False;
1475
1476         prs_debug(ps, depth, desc, "lsa_io_r_close");
1477         depth++;
1478
1479         smb_io_pol_hnd("", &(r_c->pol), ps, depth);
1480
1481         prs_uint32("status", ps, depth, &(r_c->status));
1482
1483         return True;
1484 }