source3/rpc_parse/parse_lsa.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) Andrew Bartlett                   2002,
   8  *  Copyright (C) Jim McDonough <jmcd@us.ibm.com>   2002.
   9  *  Copyright (C) Gerald )Jerry) Carter             2005
  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 #undef DBGC_CLASS
  29 #define DBGC_CLASS DBGC_RPC_PARSE
  30
  31 static BOOL lsa_io_trans_names(const char *desc, LSA_TRANS_NAME_ENUM *trn, prs_struct *ps, int depth);
  32 static BOOL lsa_io_trans_names2(const char *desc, LSA_TRANS_NAME_ENUM2 *trn, prs_struct *ps, int depth);
  33
  34 /*******************************************************************
  35  Inits a LSA_TRANS_NAME structure.
  36 ********************************************************************/
  37
  38 void init_lsa_trans_name(LSA_TRANS_NAME *trn, UNISTR2 *uni_name,
  39                          uint16 sid_name_use, const char *name, uint32 idx)
  40 {
  41         trn->sid_name_use = sid_name_use;
  42         init_unistr2(uni_name, name, UNI_FLAGS_NONE);
  43         init_uni_hdr(&trn->hdr_name, uni_name);
  44         trn->domain_idx = idx;
  45 }
  46
  47 /*******************************************************************
  48  Reads or writes a LSA_TRANS_NAME structure.
  49 ********************************************************************/
  50
  51 static BOOL lsa_io_trans_name(const char *desc, LSA_TRANS_NAME *trn, prs_struct *ps,
  52                               int depth)
  53 {
  54         prs_debug(ps, depth, desc, "lsa_io_trans_name");
  55         depth++;
  56
  57         if(!prs_align(ps))
  58                 return False;
  59
  60         if(!prs_uint16("sid_name_use", ps, depth, &trn->sid_name_use))
  61                 return False;
  62         if(!prs_align(ps))
  63                 return False;
  64
  65         if(!smb_io_unihdr ("hdr_name", &trn->hdr_name, ps, depth))
  66                 return False;
  67         if(!prs_uint32("domain_idx  ", ps, depth, &trn->domain_idx))
  68                 return False;
  69
  70         return True;
  71 }
  72
  73 /*******************************************************************
  74  Inits a LSA_TRANS_NAME2 structure.
  75 ********************************************************************/
  76
  77 void init_lsa_trans_name2(LSA_TRANS_NAME2 *trn, UNISTR2 *uni_name,
  78                          uint16 sid_name_use, const char *name, uint32 idx)
  79 {
  80         trn->sid_name_use = sid_name_use;
  81         init_unistr2(uni_name, name, UNI_FLAGS_NONE);
  82         init_uni_hdr(&trn->hdr_name, uni_name);
  83         trn->domain_idx = idx;
  84         trn->unknown = 0;
  85 }
  86
  87 /*******************************************************************
  88  Reads or writes a LSA_TRANS_NAME2 structure.
  89 ********************************************************************/
  90
  91 static BOOL lsa_io_trans_name2(const char *desc, LSA_TRANS_NAME2 *trn, prs_struct *ps,
  92                               int depth)
  93 {
  94         prs_debug(ps, depth, desc, "lsa_io_trans_name2");
  95         depth++;
  96
  97         if(!prs_align(ps))
  98                 return False;
  99
 100         if(!prs_uint16("sid_name_use", ps, depth, &trn->sid_name_use))
 101                 return False;
 102         if(!prs_align(ps))
 103                 return False;
 104
 105         if(!smb_io_unihdr ("hdr_name", &trn->hdr_name, ps, depth))
 106                 return False;
 107         if(!prs_uint32("domain_idx  ", ps, depth, &trn->domain_idx))
 108                 return False;
 109         if(!prs_uint32("unknown  ", ps, depth, &trn->unknown))
 110                 return False;
 111
 112         return True;
 113 }
 114
 115 /*******************************************************************
 116  Reads or writes a DOM_R_REF structure.
 117 ********************************************************************/
 118
 119 static BOOL lsa_io_dom_r_ref(const char *desc, DOM_R_REF *dom, prs_struct *ps, int depth)
 120 {
 121         unsigned int i;
 122
 123         prs_debug(ps, depth, desc, "lsa_io_dom_r_ref");
 124         depth++;
 125
 126         if(!prs_align(ps))
 127                 return False;
 128
 129         if(!prs_uint32("num_ref_doms_1", ps, depth, &dom->num_ref_doms_1)) /* num referenced domains? */
 130                 return False;
 131         if(!prs_uint32("ptr_ref_dom   ", ps, depth, &dom->ptr_ref_dom)) /* undocumented buffer pointer. */
 132                 return False;
 133         if(!prs_uint32("max_entries   ", ps, depth, &dom->max_entries)) /* 32 - max number of entries */
 134                 return False;
 135
 136         SMB_ASSERT_ARRAY(dom->hdr_ref_dom, dom->num_ref_doms_1);
 137
 138         if (dom->ptr_ref_dom != 0) {
 139
 140                 if(!prs_uint32("num_ref_doms_2", ps, depth, &dom->num_ref_doms_2)) /* 4 - num referenced domains? */
 141                         return False;
 142
 143                 SMB_ASSERT_ARRAY(dom->ref_dom, dom->num_ref_doms_2);
 144
 145                 for (i = 0; i < dom->num_ref_doms_1; i++) {
 146                         fstring t;
 147
 148                         slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
 149                         if(!smb_io_unihdr(t, &dom->hdr_ref_dom[i].hdr_dom_name, ps, depth))
 150                                 return False;
 151
 152                         slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
 153                         if(!prs_uint32(t, ps, depth, &dom->hdr_ref_dom[i].ptr_dom_sid))
 154                                 return False;
 155                 }
 156
 157                 for (i = 0; i < dom->num_ref_doms_2; i++) {
 158                         fstring t;
 159
 160                         if (dom->hdr_ref_dom[i].hdr_dom_name.buffer != 0) {
 161                                 slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
 162                                 if(!smb_io_unistr2(t, &dom->ref_dom[i].uni_dom_name, True, ps, depth)) /* domain name unicode string */
 163                                         return False;
 164                                 if(!prs_align(ps))
 165                                         return False;
 166                         }
 167
 168                         if (dom->hdr_ref_dom[i].ptr_dom_sid != 0) {
 169                                 slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
 170                                 if(!smb_io_dom_sid2(t, &dom->ref_dom[i].ref_dom, ps, depth)) /* referenced domain SIDs */
 171                                         return False;
 172                         }
 173                 }
 174         }
 175
 176         return True;
 177 }
 178
 179 /*******************************************************************
 180  Inits an LSA_SEC_QOS structure.
 181 ********************************************************************/
 182
 183 void init_lsa_sec_qos(LSA_SEC_QOS *qos, uint16 imp_lev, uint8 ctxt, uint8 eff)
 184 {
 185         DEBUG(5, ("init_lsa_sec_qos\n"));
 186
 187         qos->len = 0x0c; /* length of quality of service block, in bytes */
 188         qos->sec_imp_level = imp_lev;
 189         qos->sec_ctxt_mode = ctxt;
 190         qos->effective_only = eff;
 191 }
 192
 193 /*******************************************************************
 194  Reads or writes an LSA_SEC_QOS structure.
 195 ********************************************************************/
 196
 197 static BOOL lsa_io_sec_qos(const char *desc,  LSA_SEC_QOS *qos, prs_struct *ps,
 198                            int depth)
 199 {
 200         uint32 start;
 201
 202         prs_debug(ps, depth, desc, "lsa_io_obj_qos");
 203         depth++;
 204
 205         if(!prs_align(ps))
 206                 return False;
 207
 208         start = prs_offset(ps);
 209
 210         /* these pointers had _better_ be zero, because we don't know
 211            what they point to!
 212          */
 213         if(!prs_uint32("len           ", ps, depth, &qos->len)) /* 0x18 - length (in bytes) inc. the length field. */
 214                 return False;
 215         if(!prs_uint16("sec_imp_level ", ps, depth, &qos->sec_imp_level ))
 216                 return False;
 217         if(!prs_uint8 ("sec_ctxt_mode ", ps, depth, &qos->sec_ctxt_mode ))
 218                 return False;
 219         if(!prs_uint8 ("effective_only", ps, depth, &qos->effective_only))
 220                 return False;
 221
 222         if (qos->len != prs_offset(ps) - start) {
 223                 DEBUG(3,("lsa_io_sec_qos: length %x does not match size %x\n",
 224                          qos->len, prs_offset(ps) - start));
 225         }
 226
 227         return True;
 228 }
 229
 230 /*******************************************************************
 231  Inits an LSA_OBJ_ATTR structure.
 232 ********************************************************************/
 233
 234 static void init_lsa_obj_attr(LSA_OBJ_ATTR *attr, uint32 attributes, LSA_SEC_QOS *qos)
 235 {
 236         DEBUG(5, ("init_lsa_obj_attr\n"));
 237
 238         attr->len = 0x18; /* length of object attribute block, in bytes */
 239         attr->ptr_root_dir = 0;
 240         attr->ptr_obj_name = 0;
 241         attr->attributes = attributes;
 242         attr->ptr_sec_desc = 0;
 243
 244         if (qos != NULL) {
 245                 attr->ptr_sec_qos = 1;
 246                 attr->sec_qos = qos;
 247         } else {
 248                 attr->ptr_sec_qos = 0;
 249                 attr->sec_qos = NULL;
 250         }
 251 }
 252
 253 /*******************************************************************
 254  Reads or writes an LSA_OBJ_ATTR structure.
 255 ********************************************************************/
 256
 257 static BOOL lsa_io_obj_attr(const char *desc, LSA_OBJ_ATTR *attr, prs_struct *ps,
 258                             int depth)
 259 {
 260         prs_debug(ps, depth, desc, "lsa_io_obj_attr");
 261         depth++;
 262
 263         if(!prs_align(ps))
 264                 return False;
 265
 266         /* these pointers had _better_ be zero, because we don't know
 267            what they point to!
 268          */
 269         if(!prs_uint32("len         ", ps, depth, &attr->len)) /* 0x18 - length (in bytes) inc. the length field. */
 270                 return False;
 271         if(!prs_uint32("ptr_root_dir", ps, depth, &attr->ptr_root_dir)) /* 0 - root directory (pointer) */
 272                 return False;
 273         if(!prs_uint32("ptr_obj_name", ps, depth, &attr->ptr_obj_name)) /* 0 - object name (pointer) */
 274                 return False;
 275         if(!prs_uint32("attributes  ", ps, depth, &attr->attributes)) /* 0 - attributes (undocumented) */
 276                 return False;
 277         if(!prs_uint32("ptr_sec_desc", ps, depth, &attr->ptr_sec_desc)) /* 0 - security descriptior (pointer) */
 278                 return False;
 279         if(!prs_uint32("ptr_sec_qos ", ps, depth, &attr->ptr_sec_qos )) /* security quality of service (pointer) */
 280                 return False;
 281
 282         if (attr->ptr_sec_qos != 0) {
 283                 if (UNMARSHALLING(ps))
 284                         if (!(attr->sec_qos = PRS_ALLOC_MEM(ps,LSA_SEC_QOS,1)))
 285                                 return False;
 286
 287                 if(!lsa_io_sec_qos("sec_qos", attr->sec_qos, ps, depth))
 288                         return False;
 289         }
 290
 291         return True;
 292 }
 293
 294
 295 /*******************************************************************
 296  Inits an LSA_Q_OPEN_POL structure.
 297 ********************************************************************/
 298
 299 void init_q_open_pol(LSA_Q_OPEN_POL *in, uint16 system_name,
 300                      uint32 attributes, uint32 desired_access,
 301                      LSA_SEC_QOS *qos)
 302 {
 303         DEBUG(5, ("init_open_pol: attr:%d da:%d\n", attributes,
 304                   desired_access));
 305
 306         in->ptr = 1; /* undocumented pointer */
 307
 308         in->des_access = desired_access;
 309
 310         in->system_name = system_name;
 311         init_lsa_obj_attr(&in->attr, attributes, qos);
 312 }
 313
 314 /*******************************************************************
 315  Reads or writes an LSA_Q_OPEN_POL structure.
 316 ********************************************************************/
 317
 318 BOOL lsa_io_q_open_pol(const char *desc, LSA_Q_OPEN_POL *in, prs_struct *ps,
 319                        int depth)
 320 {
 321         prs_debug(ps, depth, desc, "lsa_io_q_open_pol");
 322         depth++;
 323
 324         if(!prs_uint32("ptr       ", ps, depth, &in->ptr))
 325                 return False;
 326         if(!prs_uint16("system_name", ps, depth, &in->system_name))
 327                 return False;
 328         if(!prs_align( ps ))
 329                 return False;
 330
 331         if(!lsa_io_obj_attr("", &in->attr, ps, depth))
 332                 return False;
 333
 334         if(!prs_uint32("des_access", ps, depth, &in->des_access))
 335                 return False;
 336
 337         return True;
 338 }
 339
 340 /*******************************************************************
 341  Reads or writes an LSA_R_OPEN_POL structure.
 342 ********************************************************************/
 343
 344 BOOL lsa_io_r_open_pol(const char *desc, LSA_R_OPEN_POL *out, prs_struct *ps,
 345                        int depth)
 346 {
 347         prs_debug(ps, depth, desc, "lsa_io_r_open_pol");
 348         depth++;
 349
 350         if(!smb_io_pol_hnd("", &out->pol, ps, depth))
 351                 return False;
 352
 353         if(!prs_ntstatus("status", ps, depth, &out->status))
 354                 return False;
 355
 356         return True;
 357 }
 358
 359 /*******************************************************************
 360  Inits an LSA_Q_OPEN_POL2 structure.
 361 ********************************************************************/
 362
 363 void init_q_open_pol2(LSA_Q_OPEN_POL2 *in, const char *server_name,
 364                         uint32 attributes, uint32 desired_access,
 365                         LSA_SEC_QOS *qos)
 366 {
 367         DEBUG(5, ("init_q_open_pol2: attr:%d da:%d\n", attributes,
 368                   desired_access));
 369
 370         in->ptr = 1; /* undocumented pointer */
 371
 372         in->des_access = desired_access;
 373
 374         init_unistr2(&in->uni_server_name, server_name, UNI_STR_TERMINATE);
 375
 376         init_lsa_obj_attr(&in->attr, attributes, qos);
 377 }
 378
 379 /*******************************************************************
 380  Reads or writes an LSA_Q_OPEN_POL2 structure.
 381 ********************************************************************/
 382
 383 BOOL lsa_io_q_open_pol2(const char *desc, LSA_Q_OPEN_POL2 *in, prs_struct *ps,
 384                         int depth)
 385 {
 386         prs_debug(ps, depth, desc, "lsa_io_q_open_pol2");
 387         depth++;
 388
 389         if(!prs_uint32("ptr       ", ps, depth, &in->ptr))
 390                 return False;
 391
 392         if(!smb_io_unistr2 ("", &in->uni_server_name, in->ptr, ps, depth))
 393                 return False;
 394         if(!lsa_io_obj_attr("", &in->attr, ps, depth))
 395                 return False;
 396
 397         if(!prs_uint32("des_access", ps, depth, &in->des_access))
 398                 return False;
 399
 400         return True;
 401 }
 402
 403 /*******************************************************************
 404  Reads or writes an LSA_R_OPEN_POL2 structure.
 405 ********************************************************************/
 406
 407 BOOL lsa_io_r_open_pol2(const char *desc, LSA_R_OPEN_POL2 *out, prs_struct *ps,
 408                         int depth)
 409 {
 410         prs_debug(ps, depth, desc, "lsa_io_r_open_pol2");
 411         depth++;
 412
 413         if(!smb_io_pol_hnd("", &out->pol, ps, depth))
 414                 return False;
 415
 416         if(!prs_ntstatus("status", ps, depth, &out->status))
 417                 return False;
 418
 419         return True;
 420 }
 421
 422 /*******************************************************************
 423 makes an LSA_Q_QUERY_SEC_OBJ structure.
 424 ********************************************************************/
 425
 426 void init_q_query_sec_obj(LSA_Q_QUERY_SEC_OBJ *in, const POLICY_HND *hnd,
 427                           uint32 sec_info)
 428 {
 429         DEBUG(5, ("init_q_query_sec_obj\n"));
 430
 431         in->pol = *hnd;
 432         in->sec_info = sec_info;
 433
 434         return;
 435 }
 436
 437 /*******************************************************************
 438  Reads or writes an LSA_Q_QUERY_SEC_OBJ structure.
 439 ********************************************************************/
 440
 441 BOOL lsa_io_q_query_sec_obj(const char *desc, LSA_Q_QUERY_SEC_OBJ *in,
 442                             prs_struct *ps, int depth)
 443 {
 444         prs_debug(ps, depth, desc, "lsa_io_q_query_sec_obj");
 445         depth++;
 446
 447         if (!smb_io_pol_hnd("", &in->pol, ps, depth))
 448                 return False;
 449
 450         if (!prs_uint32("sec_info", ps, depth, &in->sec_info))
 451                 return False;
 452
 453         return True;
 454 }
 455
 456 /*******************************************************************
 457  Reads or writes a LSA_R_QUERY_SEC_OBJ structure.
 458 ********************************************************************/
 459
 460 BOOL lsa_io_r_query_sec_obj(const char *desc, LSA_R_QUERY_SEC_OBJ *out, prs_struct *ps, int depth)
 461 {
 462         prs_debug(ps, depth, desc, "lsa_io_r_query_sec_obj");
 463         depth++;
 464
 465         if (!prs_align(ps))
 466                 return False;
 467
 468         if (!prs_uint32("ptr", ps, depth, &out->ptr))
 469                 return False;
 470
 471         if (out->ptr != 0) {
 472                 if (!sec_io_desc_buf("sec", &out->buf, ps, depth))
 473                         return False;
 474         }
 475
 476         if (!prs_ntstatus("status", ps, depth, &out->status))
 477                 return False;
 478
 479         return True;
 480 }
 481
 482 /*******************************************************************
 483  Inits an LSA_Q_QUERY_INFO structure.
 484 ********************************************************************/
 485
 486 void init_q_query(LSA_Q_QUERY_INFO *in, POLICY_HND *hnd, uint16 info_class)
 487 {
 488         DEBUG(5, ("init_q_query\n"));
 489
 490         memcpy(&in->pol, hnd, sizeof(in->pol));
 491
 492         in->info_class = info_class;
 493 }
 494
 495 /*******************************************************************
 496  Reads or writes an LSA_Q_QUERY_INFO structure.
 497 ********************************************************************/
 498
 499 BOOL lsa_io_q_query(const char *desc, LSA_Q_QUERY_INFO *in, prs_struct *ps,
 500                     int depth)
 501 {
 502         prs_debug(ps, depth, desc, "lsa_io_q_query");
 503         depth++;
 504
 505         if(!smb_io_pol_hnd("", &in->pol, ps, depth))
 506                 return False;
 507
 508         if(!prs_uint16("info_class", ps, depth, &in->info_class))
 509                 return False;
 510
 511         return True;
 512 }
 513
 514 /*******************************************************************
 515 makes an LSA_Q_ENUM_TRUST_DOM structure.
 516 ********************************************************************/
 517 BOOL init_q_enum_trust_dom(LSA_Q_ENUM_TRUST_DOM * q_e, POLICY_HND *pol,
 518                            uint32 enum_context, uint32 preferred_len)
 519 {
 520         DEBUG(5, ("init_q_enum_trust_dom\n"));
 521
 522         q_e->pol = *pol;
 523         q_e->enum_context = enum_context;
 524         q_e->preferred_len = preferred_len;
 525
 526         return True;
 527 }
 528
 529 /*******************************************************************
 530  Reads or writes an LSA_Q_ENUM_TRUST_DOM structure.
 531 ********************************************************************/
 532
 533 BOOL lsa_io_q_enum_trust_dom(const char *desc, LSA_Q_ENUM_TRUST_DOM *q_e,
 534                              prs_struct *ps, int depth)
 535 {
 536         prs_debug(ps, depth, desc, "lsa_io_q_enum_trust_dom");
 537         depth++;
 538
 539         if(!smb_io_pol_hnd("", &q_e->pol, ps, depth))
 540                 return False;
 541
 542         if(!prs_uint32("enum_context ", ps, depth, &q_e->enum_context))
 543                 return False;
 544         if(!prs_uint32("preferred_len", ps, depth, &q_e->preferred_len))
 545                 return False;
 546
 547         return True;
 548 }
 549
 550 /*******************************************************************
 551  Inits an LSA_R_ENUM_TRUST_DOM structure.
 552 ********************************************************************/
 553
 554 void init_r_enum_trust_dom(TALLOC_CTX *ctx, LSA_R_ENUM_TRUST_DOM *out,
 555                            uint32 enum_context, uint32 num_domains,
 556                            struct trustdom_info **td)
 557 {
 558         unsigned int i;
 559
 560         DEBUG(5, ("init_r_enum_trust_dom\n"));
 561
 562         out->enum_context  = enum_context;
 563         out->count         = num_domains;
 564
 565         if ( num_domains != 0 ) {
 566
 567                 /* allocate container memory */
 568
 569                 out->domlist = TALLOC_P( ctx, DOMAIN_LIST );
 570
 571                 if ( !out->domlist ) {
 572                         out->status = NT_STATUS_NO_MEMORY;
 573                         return;
 574                 }
 575
 576                 out->domlist->domains = TALLOC_ARRAY( ctx, DOMAIN_INFO,
 577                                                       out->count );
 578
 579                 if ( !out->domlist->domains ) {
 580                         out->status = NT_STATUS_NO_MEMORY;
 581                         return;
 582                 }
 583
 584                 out->domlist->count = out->count;
 585
 586                 /* initialize the list of domains and their sid */
 587
 588                 for (i = 0; i < num_domains; i++) {
 589                         smb_ucs2_t *name;
 590                         if ( !(out->domlist->domains[i].sid =
 591                                TALLOC_P(ctx, DOM_SID2)) ) {
 592                                 out->status = NT_STATUS_NO_MEMORY;
 593                                 return;
 594                         }
 595
 596                         init_dom_sid2(out->domlist->domains[i].sid,
 597                                       &(td[i])->sid);
 598                         if (push_ucs2_talloc(ctx, &name, (td[i])->name) == (size_t)-1){
 599                                 out->status = NT_STATUS_NO_MEMORY;
 600                                 return;
 601                         }
 602                         init_unistr4_w(ctx, &out->domlist->domains[i].name,
 603                                        name);
 604                 }
 605         }
 606
 607 }
 608
 609 /*******************************************************************
 610 ********************************************************************/
 611
 612 BOOL lsa_io_domain_list( const char *desc, prs_struct *ps, int depth, DOMAIN_LIST *domlist )
 613 {
 614         int i;
 615
 616         prs_debug(ps, depth, desc, "lsa_io_domain_list");
 617         depth++;
 618
 619         if(!prs_uint32("count", ps, depth, &domlist->count))
 620                 return False;
 621
 622         if ( domlist->count == 0 )
 623                 return True;
 624
 625         if ( UNMARSHALLING(ps) ) {
 626                 if ( !(domlist->domains = PRS_ALLOC_MEM( ps, DOMAIN_INFO, domlist->count )) )
 627                         return False;
 628         }
 629
 630         /* headers */
 631
 632         for ( i=0; i<domlist->count; i++ ) {
 633                 if ( !prs_unistr4_hdr("name_header", ps, depth, &domlist->domains[i].name) )
 634                         return False;
 635                 if ( !smb_io_dom_sid2_p("sid_header", ps, depth, &domlist->domains[i].sid) )
 636                         return False;
 637         }
 638
 639         /* data */
 640
 641         for ( i=0; i<domlist->count; i++ ) {
 642                 if ( !prs_unistr4_str("name", ps, depth, &domlist->domains[i].name) )
 643                         return False;
 644                 if( !smb_io_dom_sid2("sid", domlist->domains[i].sid, ps, depth) )
 645                         return False;
 646         }
 647
 648         return True;
 649 }
 650
 651 /*******************************************************************
 652  Reads or writes an LSA_R_ENUM_TRUST_DOM structure.
 653 ********************************************************************/
 654
 655 BOOL lsa_io_r_enum_trust_dom(const char *desc, LSA_R_ENUM_TRUST_DOM *out,
 656                              prs_struct *ps, int depth)
 657 {
 658         prs_debug(ps, depth, desc, "lsa_io_r_enum_trust_dom");
 659         depth++;
 660
 661         if(!prs_uint32("enum_context", ps, depth, &out->enum_context))
 662                 return False;
 663
 664         if(!prs_uint32("count", ps, depth, &out->count))
 665                 return False;
 666
 667         if ( !prs_pointer("trusted_domains", ps, depth, (void**)&out->domlist, sizeof(DOMAIN_LIST), (PRS_POINTER_CAST)lsa_io_domain_list))
 668                 return False;
 669
 670         if(!prs_ntstatus("status", ps, depth, &out->status))
 671                 return False;
 672
 673         return True;
 674 }
 675
 676 /*******************************************************************
 677 reads or writes a structure.
 678 ********************************************************************/
 679
 680 static BOOL lsa_io_dom_query_1(const char *desc, DOM_QUERY_1 *d_q, prs_struct *ps, int depth)
 681 {
 682         if (d_q == NULL)
 683                 return False;
 684
 685         prs_debug(ps, depth, desc, "lsa_io_dom_query_1");
 686         depth++;
 687
 688         if (!prs_align(ps))
 689                 return False;
 690
 691         if (!prs_uint32("percent_full", ps, depth, &d_q->percent_full))
 692                 return False;
 693         if (!prs_uint32("log_size", ps, depth, &d_q->log_size))
 694                 return False;
 695         if (!smb_io_nttime("retention_time", ps, depth, &d_q->retention_time))
 696                 return False;
 697         if (!prs_uint8("shutdown_in_progress", ps, depth, &d_q->shutdown_in_progress))
 698                 return False;
 699         if (!smb_io_nttime("time_to_shutdown", ps, depth, &d_q->time_to_shutdown))
 700                 return False;
 701         if (!prs_uint32("next_audit_record", ps, depth, &d_q->next_audit_record))
 702                 return False;
 703         if (!prs_uint32("unknown", ps, depth, &d_q->unknown))
 704                 return False;
 705
 706         return True;
 707 }
 708
 709 /*******************************************************************
 710 reads or writes a structure.
 711 ********************************************************************/
 712
 713 static BOOL lsa_io_dom_query_2(const char *desc, DOM_QUERY_2 *d_q, prs_struct *ps, int depth)
 714 {
 715         if (d_q == NULL)
 716                 return False;
 717
 718         prs_debug(ps, depth, desc, "lsa_io_dom_query_2");
 719         depth++;
 720
 721         if (!prs_align(ps))
 722                 return False;
 723
 724         if (!prs_uint32("auditing_enabled", ps, depth, &d_q->auditing_enabled))
 725                 return False;
 726         if (!prs_uint32("ptr   ", ps, depth, &d_q->ptr))
 727                 return False;
 728         if (!prs_uint32("count1", ps, depth, &d_q->count1))
 729                 return False;
 730
 731         if (d_q->ptr) {
 732
 733                 if (!prs_uint32("count2", ps, depth, &d_q->count2))
 734                         return False;
 735
 736                 if (d_q->count1 != d_q->count2)
 737                         return False;
 738
 739                 if (UNMARSHALLING(ps)) {
 740                         d_q->auditsettings = TALLOC_ZERO_ARRAY(ps->mem_ctx, uint32, d_q->count2);
 741                 }
 742
 743                 if (!prs_uint32s(False, "auditsettings", ps, depth, d_q->auditsettings, d_q->count2))
 744                         return False;
 745         }
 746
 747         return True;
 748 }
 749
 750 /*******************************************************************
 751 reads or writes a dom query structure.
 752 ********************************************************************/
 753
 754 static BOOL lsa_io_dom_query_3(const char *desc, DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
 755 {
 756         if (d_q == NULL)
 757                 return False;
 758
 759         prs_debug(ps, depth, desc, "lsa_io_dom_query_3");
 760         depth++;
 761
 762         if(!prs_align(ps))
 763                 return False;
 764
 765         if(!prs_uint16("uni_dom_max_len", ps, depth, &d_q->uni_dom_max_len)) /* domain name string length * 2 */
 766                 return False;
 767         if(!prs_uint16("uni_dom_str_len", ps, depth, &d_q->uni_dom_str_len)) /* domain name string length * 2 */
 768                 return False;
 769
 770         if(!prs_uint32("buffer_dom_name", ps, depth, &d_q->buffer_dom_name)) /* undocumented domain name string buffer pointer */
 771                 return False;
 772         if(!prs_uint32("buffer_dom_sid ", ps, depth, &d_q->buffer_dom_sid)) /* undocumented domain SID string buffer pointer */
 773                 return False;
 774
 775         if(!smb_io_unistr2("unistr2", &d_q->uni_domain_name, d_q->buffer_dom_name, ps, depth)) /* domain name (unicode string) */
 776                 return False;
 777
 778         if(!prs_align(ps))
 779                 return False;
 780
 781         if (d_q->buffer_dom_sid != 0) {
 782                 if(!smb_io_dom_sid2("", &d_q->dom_sid, ps, depth)) /* domain SID */
 783                         return False;
 784         } else {
 785                 memset((char *)&d_q->dom_sid, '\0', sizeof(d_q->dom_sid));
 786         }
 787
 788         return True;
 789 }
 790
 791 /*******************************************************************
 792  Reads or writes a dom query structure.
 793 ********************************************************************/
 794
 795 static BOOL lsa_io_dom_query_5(const char *desc, DOM_QUERY_5 *d_q, prs_struct *ps, int depth)
 796 {
 797         return lsa_io_dom_query_3("", d_q, ps, depth);
 798 }
 799
 800 /*******************************************************************
 801  Reads or writes a dom query structure.
 802 ********************************************************************/
 803
 804 static BOOL lsa_io_dom_query_6(const char *desc, DOM_QUERY_6 *d_q, prs_struct *ps, int depth)
 805 {
 806         if (d_q == NULL)
 807                 return False;
 808
 809         prs_debug(ps, depth, desc, "lsa_io_dom_query_6");
 810         depth++;
 811
 812         if (!prs_uint16("server_role", ps, depth, &d_q->server_role))
 813                 return False;
 814
 815         return True;
 816 }
 817
 818 /*******************************************************************
 819  Reads or writes a dom query structure.
 820 ********************************************************************/
 821
 822 static BOOL lsa_io_dom_query_10(const char *desc, DOM_QUERY_10 *d_q, prs_struct *ps, int depth)
 823 {
 824         if (d_q == NULL)
 825                 return False;
 826
 827         prs_debug(ps, depth, desc, "lsa_io_dom_query_10");
 828         depth++;
 829
 830         if (!prs_uint8("shutdown_on_full", ps, depth, &d_q->shutdown_on_full))
 831                 return False;
 832
 833         return True;
 834 }
 835
 836 /*******************************************************************
 837  Reads or writes a dom query structure.
 838 ********************************************************************/
 839
 840 static BOOL lsa_io_dom_query_11(const char *desc, DOM_QUERY_11 *d_q, prs_struct *ps, int depth)
 841 {
 842         if (d_q == NULL)
 843                 return False;
 844
 845         prs_debug(ps, depth, desc, "lsa_io_dom_query_11");
 846         depth++;
 847
 848         if (!prs_uint16("unknown", ps, depth, &d_q->unknown))
 849                 return False;
 850         if (!prs_uint8("shutdown_on_full", ps, depth, &d_q->shutdown_on_full))
 851                 return False;
 852         if (!prs_uint8("log_is_full", ps, depth, &d_q->log_is_full))
 853                 return False;
 854
 855         return True;
 856 }
 857
 858 /*******************************************************************
 859  Reads or writes an LSA_DNS_DOM_INFO structure.
 860 ********************************************************************/
 861
 862 BOOL lsa_io_dom_query_12(const char *desc, DOM_QUERY_12 *info, prs_struct *ps, int depth)
 863 {
 864         prs_debug(ps, depth, desc, "lsa_io_dom_query_12");
 865         depth++;
 866
 867         if(!prs_align(ps))
 868                 return False;
 869         if(!smb_io_unihdr("nb_name", &info->hdr_nb_dom_name, ps, depth))
 870                 return False;
 871         if(!smb_io_unihdr("dns_name", &info->hdr_dns_dom_name, ps, depth))
 872                 return False;
 873         if(!smb_io_unihdr("forest", &info->hdr_forest_name, ps, depth))
 874                 return False;
 875
 876         if(!prs_align(ps))
 877                 return False;
 878         if ( !smb_io_uuid("dom_guid", &info->dom_guid, ps, depth) )
 879                 return False;
 880
 881         if(!prs_align(ps))
 882                 return False;
 883         if(!prs_uint32("dom_sid", ps, depth, &info->ptr_dom_sid))
 884                 return False;
 885
 886         if(!smb_io_unistr2("nb_name", &info->uni_nb_dom_name,
 887                            info->hdr_nb_dom_name.buffer, ps, depth))
 888                 return False;
 889         if(!smb_io_unistr2("dns_name", &info->uni_dns_dom_name,
 890                            info->hdr_dns_dom_name.buffer, ps, depth))
 891                 return False;
 892         if(!smb_io_unistr2("forest", &info->uni_forest_name,
 893                            info->hdr_forest_name.buffer, ps, depth))
 894                 return False;
 895
 896         if(!smb_io_dom_sid2("dom_sid", &info->dom_sid, ps, depth))
 897                 return False;
 898
 899         return True;
 900
 901 }
 902
 903 /*******************************************************************
 904  Inits an LSA_Q_QUERY_INFO structure.
 905 ********************************************************************/
 906
 907 void init_q_set(LSA_Q_SET_INFO *in, POLICY_HND *hnd, uint16 info_class, LSA_INFO_CTR ctr)
 908 {
 909         DEBUG(5,("init_q_set\n"));
 910
 911         in->info_class = info_class;
 912
 913         in->pol = *hnd;
 914
 915         in->ctr = ctr;
 916         in->ctr.info_class = info_class;
 917 }
 918
 919 /*******************************************************************
 920 reads or writes a structure.
 921 ********************************************************************/
 922
 923 static BOOL lsa_io_query_info_ctr2(const char *desc, prs_struct *ps, int depth, LSA_INFO_CTR2 *ctr)
 924 {
 925         prs_debug(ps, depth, desc, "lsa_io_query_info_ctr2");
 926         depth++;
 927
 928         if(!prs_uint16("info_class", ps, depth, &ctr->info_class))
 929                 return False;
 930
 931         switch (ctr->info_class) {
 932         case 1:
 933                 if(!lsa_io_dom_query_1("", &ctr->info.id1, ps, depth))
 934                         return False;
 935                 break;
 936         case 2:
 937                 if(!lsa_io_dom_query_2("", &ctr->info.id2, ps, depth))
 938                         return False;
 939                 break;
 940         case 3:
 941                 if(!lsa_io_dom_query_3("", &ctr->info.id3, ps, depth))
 942                         return False;
 943                 break;
 944         case 5:
 945                 if(!lsa_io_dom_query_5("", &ctr->info.id5, ps, depth))
 946                         return False;
 947                 break;
 948         case 6:
 949                 if(!lsa_io_dom_query_6("", &ctr->info.id6, ps, depth))
 950                         return False;
 951                 break;
 952         case 10:
 953                 if(!lsa_io_dom_query_10("", &ctr->info.id10, ps, depth))
 954                         return False;
 955                 break;
 956         case 11:
 957                 if(!lsa_io_dom_query_11("", &ctr->info.id11, ps, depth))
 958                         return False;
 959                 break;
 960         case 12:
 961                 if(!lsa_io_dom_query_12("", &ctr->info.id12, ps, depth))
 962                         return False;
 963                 break;
 964         default:
 965                 DEBUG(0,("invalid info_class: %d\n", ctr->info_class));
 966                 return False;
 967                 break;
 968         }
 969
 970         return True;
 971 }
 972
 973
 974 /*******************************************************************
 975 reads or writes a structure.
 976 ********************************************************************/
 977
 978 static BOOL lsa_io_query_info_ctr(const char *desc, prs_struct *ps, int depth, LSA_INFO_CTR *ctr)
 979 {
 980         prs_debug(ps, depth, desc, "lsa_io_query_info_ctr");
 981         depth++;
 982
 983         if(!prs_uint16("info_class", ps, depth, &ctr->info_class))
 984                 return False;
 985
 986         switch (ctr->info_class) {
 987         case 1:
 988                 if(!lsa_io_dom_query_1("", &ctr->info.id1, ps, depth))
 989                         return False;
 990                 break;
 991         case 2:
 992                 if(!lsa_io_dom_query_2("", &ctr->info.id2, ps, depth))
 993                         return False;
 994                 break;
 995         case 3:
 996                 if(!lsa_io_dom_query_3("", &ctr->info.id3, ps, depth))
 997                         return False;
 998                 break;
 999         case 5:
1000                 if(!lsa_io_dom_query_5("", &ctr->info.id5, ps, depth))
1001                         return False;
1002                 break;
1003         case 6:
1004                 if(!lsa_io_dom_query_6("", &ctr->info.id6, ps, depth))
1005                         return False;
1006                 break;
1007         case 10:
1008                 if(!lsa_io_dom_query_10("", &ctr->info.id10, ps, depth))
1009                         return False;
1010                 break;
1011         case 11:
1012                 if(!lsa_io_dom_query_11("", &ctr->info.id11, ps, depth))
1013                         return False;
1014                 break;
1015         default:
1016                 DEBUG(0,("invalid info_class: %d\n", ctr->info_class));
1017                 return False;
1018                 break;
1019         }
1020
1021         return True;
1022 }
1023
1024 /*******************************************************************
1025  Reads or writes an LSA_R_QUERY_INFO structure.
1026 ********************************************************************/
1027
1028 BOOL lsa_io_r_query(const char *desc, LSA_R_QUERY_INFO *out, prs_struct *ps, int depth)
1029 {
1030
1031         prs_debug(ps, depth, desc, "lsa_io_r_query");
1032         depth++;
1033
1034         if(!prs_align(ps))
1035                 return False;
1036
1037         if(!prs_uint32("dom_ptr", ps, depth, &out->dom_ptr))
1038                 return False;
1039
1040         if (out->dom_ptr) {
1041
1042                 if(!lsa_io_query_info_ctr("", ps, depth, &out->ctr))
1043                         return False;
1044         }
1045
1046         if(!prs_align(ps))
1047                 return False;
1048
1049         if(!prs_ntstatus("status", ps, depth, &out->status))
1050                 return False;
1051
1052         return True;
1053 }
1054
1055 /*******************************************************************
1056  Reads or writes an LSA_Q_SET_INFO structure.
1057 ********************************************************************/
1058
1059 BOOL lsa_io_q_set(const char *desc, LSA_Q_SET_INFO *in, prs_struct *ps,
1060                   int depth)
1061 {
1062         prs_debug(ps, depth, desc, "lsa_io_q_set");
1063         depth++;
1064
1065         if(!prs_align(ps))
1066                 return False;
1067
1068         if(!smb_io_pol_hnd("", &in->pol, ps, depth))
1069                 return False;
1070
1071         if(!prs_uint16("info_class", ps, depth, &in->info_class))
1072                 return False;
1073
1074         if(!lsa_io_query_info_ctr("", ps, depth, &in->ctr))
1075                 return False;
1076
1077         return True;
1078 }
1079
1080 /*******************************************************************
1081  Reads or writes an LSA_R_SET_INFO structure.
1082 ********************************************************************/
1083
1084 BOOL lsa_io_r_set(const char *desc, LSA_R_SET_INFO *out, prs_struct *ps, int depth)
1085 {
1086         prs_debug(ps, depth, desc, "lsa_io_r_set");
1087         depth++;
1088
1089         if(!prs_align(ps))
1090                 return False;
1091
1092         if(!prs_ntstatus("status", ps, depth, &out->status))
1093                 return False;
1094
1095         return True;
1096 }
1097
1098 /*******************************************************************
1099  Inits a LSA_SID_ENUM structure.
1100 ********************************************************************/
1101
1102 static void init_lsa_sid_enum(TALLOC_CTX *mem_ctx, LSA_SID_ENUM *sen,
1103                        int num_entries, const DOM_SID *sids)
1104 {
1105         int i;
1106
1107         DEBUG(5, ("init_lsa_sid_enum\n"));
1108
1109         sen->num_entries  = num_entries;
1110         sen->ptr_sid_enum = (num_entries != 0);
1111         sen->num_entries2 = num_entries;
1112
1113         /* Allocate memory for sids and sid pointers */
1114
1115         if (num_entries == 0) return;
1116
1117         if ((sen->ptr_sid = TALLOC_ZERO_ARRAY(mem_ctx, uint32, num_entries )) == NULL) {
1118                 DEBUG(3, ("init_lsa_sid_enum(): out of memory for ptr_sid\n"));
1119                 return;
1120         }
1121
1122         if ((sen->sid = TALLOC_ZERO_ARRAY(mem_ctx, DOM_SID2, num_entries)) == NULL) {
1123                 DEBUG(3, ("init_lsa_sid_enum(): out of memory for sids\n"));
1124                 return;
1125         }
1126
1127         /* Copy across SIDs and SID pointers */
1128
1129         for (i = 0; i < num_entries; i++) {
1130                 sen->ptr_sid[i] = 1;
1131                 init_dom_sid2(&sen->sid[i], &sids[i]);
1132         }
1133 }
1134
1135 /*******************************************************************
1136  Reads or writes a LSA_SID_ENUM structure.
1137 ********************************************************************/
1138
1139 static BOOL lsa_io_sid_enum(const char *desc, LSA_SID_ENUM *sen, prs_struct *ps,
1140                             int depth)
1141 {
1142         unsigned int i;
1143
1144         prs_debug(ps, depth, desc, "lsa_io_sid_enum");
1145         depth++;
1146
1147         if(!prs_align(ps))
1148                 return False;
1149
1150         if(!prs_uint32("num_entries ", ps, depth, &sen->num_entries))
1151                 return False;
1152         if(!prs_uint32("ptr_sid_enum", ps, depth, &sen->ptr_sid_enum))
1153                 return False;
1154
1155         /*
1156            if the ptr is NULL, leave here. checked from a real w2k trace.
1157            JFM, 11/23/2001
1158          */
1159
1160         if (sen->ptr_sid_enum==0)
1161                 return True;
1162
1163         if(!prs_uint32("num_entries2", ps, depth, &sen->num_entries2))
1164                 return False;
1165
1166         /* Mallocate memory if we're unpacking from the wire */
1167
1168         if (UNMARSHALLING(ps)) {
1169                 if ((sen->ptr_sid = PRS_ALLOC_MEM( ps, uint32, sen->num_entries)) == NULL) {
1170                         DEBUG(3, ("init_lsa_sid_enum(): out of memory for "
1171                                   "ptr_sid\n"));
1172                         return False;
1173                 }
1174
1175                 if ((sen->sid = PRS_ALLOC_MEM( ps, DOM_SID2, sen->num_entries)) == NULL) {
1176                         DEBUG(3, ("init_lsa_sid_enum(): out of memory for "
1177                                   "sids\n"));
1178                         return False;
1179                 }
1180         }
1181
1182         for (i = 0; i < sen->num_entries; i++) {
1183                 fstring temp;
1184
1185                 slprintf(temp, sizeof(temp) - 1, "ptr_sid[%d]", i);
1186                 if(!prs_uint32(temp, ps, depth, &sen->ptr_sid[i])) {
1187                         return False;
1188                 }
1189         }
1190
1191         for (i = 0; i < sen->num_entries; i++) {
1192                 fstring temp;
1193
1194                 slprintf(temp, sizeof(temp) - 1, "sid[%d]", i);
1195                 if(!smb_io_dom_sid2(temp, &sen->sid[i], ps, depth)) {
1196                         return False;
1197                 }
1198         }
1199
1200         return True;
1201 }
1202
1203 /*******************************************************************
1204  Inits an LSA_R_ENUM_TRUST_DOM structure.
1205 ********************************************************************/
1206
1207 void init_q_lookup_sids(TALLOC_CTX *mem_ctx, LSA_Q_LOOKUP_SIDS *q_l,
1208                         POLICY_HND *hnd, int num_sids, const DOM_SID *sids,
1209                         uint16 level)
1210 {
1211         DEBUG(5, ("init_q_lookup_sids\n"));
1212
1213         ZERO_STRUCTP(q_l);
1214
1215         memcpy(&q_l->pol, hnd, sizeof(q_l->pol));
1216         init_lsa_sid_enum(mem_ctx, &q_l->sids, num_sids, sids);
1217
1218         q_l->level = level;
1219 }
1220
1221 /*******************************************************************
1222  Reads or writes a LSA_Q_LOOKUP_SIDS structure.
1223 ********************************************************************/
1224
1225 BOOL lsa_io_q_lookup_sids(const char *desc, LSA_Q_LOOKUP_SIDS *q_s, prs_struct *ps,
1226                           int depth)
1227 {
1228         prs_debug(ps, depth, desc, "lsa_io_q_lookup_sids");
1229         depth++;
1230
1231         if(!prs_align(ps))
1232                 return False;
1233
1234         if(!smb_io_pol_hnd("pol_hnd", &q_s->pol, ps, depth)) /* policy handle */
1235                 return False;
1236         if(!lsa_io_sid_enum("sids   ", &q_s->sids, ps, depth)) /* sids to be looked up */
1237                 return False;
1238         if(!lsa_io_trans_names("names  ", &q_s->names, ps, depth)) /* translated names */
1239                 return False;
1240
1241         if(!prs_uint16("level", ps, depth, &q_s->level)) /* lookup level */
1242                 return False;
1243         if(!prs_align(ps))
1244                 return False;
1245
1246         if(!prs_uint32("mapped_count", ps, depth, &q_s->mapped_count))
1247                 return False;
1248
1249         return True;
1250 }
1251
1252 /*******************************************************************
1253  Reads or writes a LSA_Q_LOOKUP_SIDS2 structure.
1254 ********************************************************************/
1255
1256 BOOL lsa_io_q_lookup_sids2(const char *desc, LSA_Q_LOOKUP_SIDS2 *q_s, prs_struct *ps,
1257                           int depth)
1258 {
1259         prs_debug(ps, depth, desc, "lsa_io_q_lookup_sids2");
1260         depth++;
1261
1262         if(!prs_align(ps))
1263                 return False;
1264
1265         if(!smb_io_pol_hnd("pol_hnd", &q_s->pol, ps, depth)) /* policy handle */
1266                 return False;
1267         if(!lsa_io_sid_enum("sids   ", &q_s->sids, ps, depth)) /* sids to be looked up */
1268                 return False;
1269         if(!lsa_io_trans_names2("names  ", &q_s->names, ps, depth)) /* translated names */
1270                 return False;
1271
1272         if(!prs_uint16("level", ps, depth, &q_s->level)) /* lookup level */
1273                 return False;
1274         if(!prs_align(ps))
1275                 return False;
1276
1277         if(!prs_uint32("mapped_count", ps, depth, &q_s->mapped_count))
1278                 return False;
1279         if(!prs_uint32("unknown1", ps, depth, &q_s->unknown1))
1280                 return False;
1281         if(!prs_uint32("unknown2", ps, depth, &q_s->unknown2))
1282                 return False;
1283
1284         return True;
1285 }
1286
1287 /*******************************************************************
1288  Reads or writes a LSA_Q_LOOKUP_SIDS3 structure.
1289 ********************************************************************/
1290
1291 BOOL lsa_io_q_lookup_sids3(const char *desc, LSA_Q_LOOKUP_SIDS3 *q_s, prs_struct *ps,
1292                           int depth)
1293 {
1294         prs_debug(ps, depth, desc, "lsa_io_q_lookup_sids3");
1295         depth++;
1296
1297         if(!prs_align(ps))
1298                 return False;
1299
1300         if(!lsa_io_sid_enum("sids   ", &q_s->sids, ps, depth)) /* sids to be looked up */
1301                 return False;
1302         if(!lsa_io_trans_names2("names  ", &q_s->names, ps, depth)) /* translated names */
1303                 return False;
1304
1305         if(!prs_uint16("level", ps, depth, &q_s->level)) /* lookup level */
1306                 return False;
1307         if(!prs_align(ps))
1308                 return False;
1309
1310         if(!prs_uint32("mapped_count", ps, depth, &q_s->mapped_count))
1311                 return False;
1312         if(!prs_uint32("unknown1", ps, depth, &q_s->unknown1))
1313                 return False;
1314         if(!prs_uint32("unknown2", ps, depth, &q_s->unknown2))
1315                 return False;
1316
1317         return True;
1318 }
1319
1320
1321 /*******************************************************************
1322  Reads or writes a structure.
1323 ********************************************************************/
1324
1325 static BOOL lsa_io_trans_names(const char *desc, LSA_TRANS_NAME_ENUM *trn,
1326                 prs_struct *ps, int depth)
1327 {
1328         unsigned int i;
1329
1330         prs_debug(ps, depth, desc, "lsa_io_trans_names");
1331         depth++;
1332
1333         if(!prs_align(ps))
1334                 return False;
1335
1336         if(!prs_uint32("num_entries    ", ps, depth, &trn->num_entries))
1337                 return False;
1338         if(!prs_uint32("ptr_trans_names", ps, depth, &trn->ptr_trans_names))
1339                 return False;
1340
1341         if (trn->ptr_trans_names != 0) {
1342                 if(!prs_uint32("num_entries2   ", ps, depth,
1343                                &trn->num_entries2))
1344                         return False;
1345
1346                 if (UNMARSHALLING(ps)) {
1347                         if ((trn->name = PRS_ALLOC_MEM(ps, LSA_TRANS_NAME, trn->num_entries)) == NULL) {
1348                                 return False;
1349                         }
1350
1351                         if ((trn->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, trn->num_entries)) == NULL) {
1352                                 return False;
1353                         }
1354                 }
1355
1356                 for (i = 0; i < trn->num_entries2; i++) {
1357                         fstring t;
1358                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1359
1360                         if(!lsa_io_trans_name(t, &trn->name[i], ps, depth)) /* translated name */
1361                                 return False;
1362                 }
1363
1364                 for (i = 0; i < trn->num_entries2; i++) {
1365                         fstring t;
1366                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1367
1368                         if(!smb_io_unistr2(t, &trn->uni_name[i], trn->name[i].hdr_name.buffer, ps, depth))
1369                                 return False;
1370                         if(!prs_align(ps))
1371                                 return False;
1372                 }
1373         }
1374
1375         return True;
1376 }
1377
1378 /*******************************************************************
1379  Reads or writes a structure.
1380 ********************************************************************/
1381
1382 static BOOL lsa_io_trans_names2(const char *desc, LSA_TRANS_NAME_ENUM2 *trn,
1383                 prs_struct *ps, int depth)
1384 {
1385         unsigned int i;
1386
1387         prs_debug(ps, depth, desc, "lsa_io_trans_names2");
1388         depth++;
1389
1390         if(!prs_align(ps))
1391                 return False;
1392
1393         if(!prs_uint32("num_entries    ", ps, depth, &trn->num_entries))
1394                 return False;
1395         if(!prs_uint32("ptr_trans_names", ps, depth, &trn->ptr_trans_names))
1396                 return False;
1397
1398         if (trn->ptr_trans_names != 0) {
1399                 if(!prs_uint32("num_entries2   ", ps, depth,
1400                                &trn->num_entries2))
1401                         return False;
1402
1403                 if (UNMARSHALLING(ps)) {
1404                         if ((trn->name = PRS_ALLOC_MEM(ps, LSA_TRANS_NAME2, trn->num_entries)) == NULL) {
1405                                 return False;
1406                         }
1407
1408                         if ((trn->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, trn->num_entries)) == NULL) {
1409                                 return False;
1410                         }
1411                 }
1412
1413                 for (i = 0; i < trn->num_entries2; i++) {
1414                         fstring t;
1415                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1416
1417                         if(!lsa_io_trans_name2(t, &trn->name[i], ps, depth)) /* translated name */
1418                                 return False;
1419                 }
1420
1421                 for (i = 0; i < trn->num_entries2; i++) {
1422                         fstring t;
1423                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1424
1425                         if(!smb_io_unistr2(t, &trn->uni_name[i], trn->name[i].hdr_name.buffer, ps, depth))
1426                                 return False;
1427                         if(!prs_align(ps))
1428                                 return False;
1429                 }
1430         }
1431
1432         return True;
1433 }
1434
1435
1436 /*******************************************************************
1437  Reads or writes a structure.
1438 ********************************************************************/
1439
1440 BOOL lsa_io_r_lookup_sids(const char *desc, LSA_R_LOOKUP_SIDS *r_s,
1441                           prs_struct *ps, int depth)
1442 {
1443         prs_debug(ps, depth, desc, "lsa_io_r_lookup_sids");
1444         depth++;
1445
1446         if(!prs_align(ps))
1447                 return False;
1448
1449         if(!prs_uint32("ptr_dom_ref", ps, depth, &r_s->ptr_dom_ref))
1450                 return False;
1451
1452         if (r_s->ptr_dom_ref != 0)
1453                 if(!lsa_io_dom_r_ref ("dom_ref", r_s->dom_ref, ps, depth)) /* domain reference info */
1454                         return False;
1455
1456         if(!lsa_io_trans_names("names  ", r_s->names, ps, depth)) /* translated names */
1457                 return False;
1458
1459         if(!prs_align(ps))
1460                 return False;
1461
1462         if(!prs_uint32("mapped_count", ps, depth, &r_s->mapped_count))
1463                 return False;
1464
1465         if(!prs_ntstatus("status      ", ps, depth, &r_s->status))
1466                 return False;
1467
1468         return True;
1469 }
1470
1471 /*******************************************************************
1472  Reads or writes a structure.
1473 ********************************************************************/
1474
1475 BOOL lsa_io_r_lookup_sids2(const char *desc, LSA_R_LOOKUP_SIDS2 *r_s,
1476                           prs_struct *ps, int depth)
1477 {
1478         prs_debug(ps, depth, desc, "lsa_io_r_lookup_sids2");
1479         depth++;
1480
1481         if(!prs_align(ps))
1482                 return False;
1483
1484         if(!prs_uint32("ptr_dom_ref", ps, depth, &r_s->ptr_dom_ref))
1485                 return False;
1486
1487         if (r_s->ptr_dom_ref != 0)
1488                 if(!lsa_io_dom_r_ref ("dom_ref", r_s->dom_ref, ps, depth)) /* domain reference info */
1489                         return False;
1490
1491         if(!lsa_io_trans_names2("names  ", r_s->names, ps, depth)) /* translated names */
1492                 return False;
1493
1494         if(!prs_align(ps))
1495                 return False;
1496
1497         if(!prs_uint32("mapped_count", ps, depth, &r_s->mapped_count))
1498                 return False;
1499
1500         if(!prs_ntstatus("status      ", ps, depth, &r_s->status))
1501                 return False;
1502
1503         return True;
1504 }
1505
1506
1507 /*******************************************************************
1508  Reads or writes a structure.
1509 ********************************************************************/
1510
1511 BOOL lsa_io_r_lookup_sids3(const char *desc, LSA_R_LOOKUP_SIDS3 *r_s,
1512                           prs_struct *ps, int depth)
1513 {
1514         prs_debug(ps, depth, desc, "lsa_io_r_lookup_sids3");
1515         depth++;
1516
1517         if(!prs_align(ps))
1518                 return False;
1519
1520         if(!prs_uint32("ptr_dom_ref", ps, depth, &r_s->ptr_dom_ref))
1521                 return False;
1522
1523         if (r_s->ptr_dom_ref != 0)
1524                 if(!lsa_io_dom_r_ref ("dom_ref", r_s->dom_ref, ps, depth)) /* domain reference info */
1525                         return False;
1526
1527         if(!lsa_io_trans_names2("names  ", r_s->names, ps, depth)) /* translated names */
1528                 return False;
1529
1530         if(!prs_align(ps))
1531                 return False;
1532
1533         if(!prs_uint32("mapped_count", ps, depth, &r_s->mapped_count))
1534                 return False;
1535
1536         if(!prs_ntstatus("status      ", ps, depth, &r_s->status))
1537                 return False;
1538
1539         return True;
1540 }
1541
1542 /*******************************************************************
1543 makes a structure.
1544 ********************************************************************/
1545
1546 void init_q_lookup_names(TALLOC_CTX *mem_ctx, LSA_Q_LOOKUP_NAMES *q_l,
1547                          POLICY_HND *hnd, int num_names, const char **names)
1548 {
1549         unsigned int i;
1550
1551         DEBUG(5, ("init_q_lookup_names\n"));
1552
1553         ZERO_STRUCTP(q_l);
1554
1555         q_l->pol = *hnd;
1556         q_l->num_entries = num_names;
1557         q_l->num_entries2 = num_names;
1558         q_l->lookup_level = 1;
1559
1560         if ((q_l->uni_name = TALLOC_ZERO_ARRAY(mem_ctx, UNISTR2, num_names)) == NULL) {
1561                 DEBUG(3, ("init_q_lookup_names(): out of memory\n"));
1562                 return;
1563         }
1564
1565         if ((q_l->hdr_name = TALLOC_ZERO_ARRAY(mem_ctx, UNIHDR, num_names)) == NULL) {
1566                 DEBUG(3, ("init_q_lookup_names(): out of memory\n"));
1567                 return;
1568         }
1569
1570         for (i = 0; i < num_names; i++) {
1571                 init_unistr2(&q_l->uni_name[i], names[i], UNI_FLAGS_NONE);
1572                 init_uni_hdr(&q_l->hdr_name[i], &q_l->uni_name[i]);
1573         }
1574 }
1575
1576 /*******************************************************************
1577 reads or writes a structure.
1578 ********************************************************************/
1579
1580 BOOL lsa_io_q_lookup_names(const char *desc, LSA_Q_LOOKUP_NAMES *q_r,
1581                            prs_struct *ps, int depth)
1582 {
1583         unsigned int i;
1584
1585         prs_debug(ps, depth, desc, "lsa_io_q_lookup_names");
1586         depth++;
1587
1588         if(!prs_align(ps))
1589                 return False;
1590
1591         if(!smb_io_pol_hnd("", &q_r->pol, ps, depth)) /* policy handle */
1592                 return False;
1593
1594         if(!prs_align(ps))
1595                 return False;
1596         if(!prs_uint32("num_entries    ", ps, depth, &q_r->num_entries))
1597                 return False;
1598         if(!prs_uint32("num_entries2   ", ps, depth, &q_r->num_entries2))
1599                 return False;
1600
1601         if (UNMARSHALLING(ps)) {
1602                 if (q_r->num_entries) {
1603                         if ((q_r->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_r->num_entries)) == NULL)
1604                                 return False;
1605                         if ((q_r->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_r->num_entries)) == NULL)
1606                                 return False;
1607                 }
1608         }
1609
1610         for (i = 0; i < q_r->num_entries; i++) {
1611                 if(!prs_align(ps))
1612                         return False;
1613                 if(!smb_io_unihdr("hdr_name", &q_r->hdr_name[i], ps, depth)) /* pointer names */
1614                         return False;
1615         }
1616
1617         for (i = 0; i < q_r->num_entries; i++) {
1618                 if(!prs_align(ps))
1619                         return False;
1620                 if(!smb_io_unistr2("dom_name", &q_r->uni_name[i], q_r->hdr_name[i].buffer, ps, depth)) /* names to be looked up */
1621                         return False;
1622         }
1623
1624         if(!prs_align(ps))
1625                 return False;
1626         if(!prs_uint32("num_trans_entries ", ps, depth, &q_r->num_trans_entries))
1627                 return False;
1628         if(!prs_uint32("ptr_trans_sids ", ps, depth, &q_r->ptr_trans_sids))
1629                 return False;
1630         if(!prs_uint16("lookup_level   ", ps, depth, &q_r->lookup_level))
1631                 return False;
1632         if(!prs_align(ps))
1633                 return False;
1634         if(!prs_uint32("mapped_count   ", ps, depth, &q_r->mapped_count))
1635                 return False;
1636
1637         return True;
1638 }
1639
1640 /*******************************************************************
1641 reads or writes a structure.
1642 ********************************************************************/
1643
1644 BOOL lsa_io_r_lookup_names(const char *desc, LSA_R_LOOKUP_NAMES *out, prs_struct *ps, int depth)
1645 {
1646         unsigned int i;
1647
1648         prs_debug(ps, depth, desc, "lsa_io_r_lookup_names");
1649         depth++;
1650
1651         if(!prs_align(ps))
1652                 return False;
1653
1654         if(!prs_uint32("ptr_dom_ref", ps, depth, &out->ptr_dom_ref))
1655                 return False;
1656
1657         if (out->ptr_dom_ref != 0)
1658                 if(!lsa_io_dom_r_ref("", out->dom_ref, ps, depth))
1659                         return False;
1660
1661         if(!prs_uint32("num_entries", ps, depth, &out->num_entries))
1662                 return False;
1663         if(!prs_uint32("ptr_entries", ps, depth, &out->ptr_entries))
1664                 return False;
1665
1666         if (out->ptr_entries != 0) {
1667                 if(!prs_uint32("num_entries2", ps, depth, &out->num_entries2))
1668                         return False;
1669
1670                 if (out->num_entries2 != out->num_entries) {
1671                         /* RPC fault */
1672                         return False;
1673                 }
1674
1675                 if (UNMARSHALLING(ps)) {
1676                         if ((out->dom_rid = PRS_ALLOC_MEM(ps, DOM_RID, out->num_entries2))
1677                             == NULL) {
1678                                 DEBUG(3, ("lsa_io_r_lookup_names(): out of memory\n"));
1679                                 return False;
1680                         }
1681                 }
1682
1683                 for (i = 0; i < out->num_entries2; i++)
1684                         if(!smb_io_dom_rid("", &out->dom_rid[i], ps, depth)) /* domain RIDs being looked up */
1685                                 return False;
1686         }
1687
1688         if(!prs_uint32("mapped_count", ps, depth, &out->mapped_count))
1689                 return False;
1690
1691         if(!prs_ntstatus("status      ", ps, depth, &out->status))
1692                 return False;
1693
1694         return True;
1695 }
1696
1697 /*******************************************************************
1698 reads or writes a structure.
1699 ********************************************************************/
1700
1701 BOOL lsa_io_q_lookup_names2(const char *desc, LSA_Q_LOOKUP_NAMES2 *q_r,
1702                            prs_struct *ps, int depth)
1703 {
1704         unsigned int i;
1705
1706         prs_debug(ps, depth, desc, "lsa_io_q_lookup_names2");
1707         depth++;
1708
1709         if(!prs_align(ps))
1710                 return False;
1711
1712         if(!smb_io_pol_hnd("", &q_r->pol, ps, depth)) /* policy handle */
1713                 return False;
1714
1715         if(!prs_align(ps))
1716                 return False;
1717         if(!prs_uint32("num_entries    ", ps, depth, &q_r->num_entries))
1718                 return False;
1719         if(!prs_uint32("num_entries2   ", ps, depth, &q_r->num_entries2))
1720                 return False;
1721
1722         if (UNMARSHALLING(ps)) {
1723                 if (q_r->num_entries) {
1724                         if ((q_r->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_r->num_entries)) == NULL)
1725                                 return False;
1726                         if ((q_r->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_r->num_entries)) == NULL)
1727                                 return False;
1728                 }
1729         }
1730
1731         for (i = 0; i < q_r->num_entries; i++) {
1732                 if(!prs_align(ps))
1733                         return False;
1734                 if(!smb_io_unihdr("hdr_name", &q_r->hdr_name[i], ps, depth)) /* pointer names */
1735                         return False;
1736         }
1737
1738         for (i = 0; i < q_r->num_entries; i++) {
1739                 if(!prs_align(ps))
1740                         return False;
1741                 if(!smb_io_unistr2("dom_name", &q_r->uni_name[i], q_r->hdr_name[i].buffer, ps, depth)) /* names to be looked up */
1742                         return False;
1743         }
1744
1745         if(!prs_align(ps))
1746                 return False;
1747         if(!prs_uint32("num_trans_entries ", ps, depth, &q_r->num_trans_entries))
1748                 return False;
1749         if(!prs_uint32("ptr_trans_sids ", ps, depth, &q_r->ptr_trans_sids))
1750                 return False;
1751         if(!prs_uint16("lookup_level   ", ps, depth, &q_r->lookup_level))
1752                 return False;
1753         if(!prs_align(ps))
1754                 return False;
1755         if(!prs_uint32("mapped_count   ", ps, depth, &q_r->mapped_count))
1756                 return False;
1757         if(!prs_uint32("unknown1   ", ps, depth, &q_r->unknown1))
1758                 return False;
1759         if(!prs_uint32("unknown2   ", ps, depth, &q_r->unknown2))
1760                 return False;
1761
1762         return True;
1763 }
1764
1765 /*******************************************************************
1766 reads or writes a structure.
1767 ********************************************************************/
1768
1769 BOOL lsa_io_r_lookup_names2(const char *desc, LSA_R_LOOKUP_NAMES2 *out, prs_struct *ps, int depth)
1770 {
1771         unsigned int i;
1772
1773         prs_debug(ps, depth, desc, "lsa_io_r_lookup_names2");
1774         depth++;
1775
1776         if(!prs_align(ps))
1777                 return False;
1778
1779         if(!prs_uint32("ptr_dom_ref", ps, depth, &out->ptr_dom_ref))
1780                 return False;
1781
1782         if (out->ptr_dom_ref != 0)
1783                 if(!lsa_io_dom_r_ref("", out->dom_ref, ps, depth))
1784                         return False;
1785
1786         if(!prs_uint32("num_entries", ps, depth, &out->num_entries))
1787                 return False;
1788         if(!prs_uint32("ptr_entries", ps, depth, &out->ptr_entries))
1789                 return False;
1790
1791         if (out->ptr_entries != 0) {
1792                 if(!prs_uint32("num_entries2", ps, depth, &out->num_entries2))
1793                         return False;
1794
1795                 if (out->num_entries2 != out->num_entries) {
1796                         /* RPC fault */
1797                         return False;
1798                 }
1799
1800                 if (UNMARSHALLING(ps)) {
1801                         if ((out->dom_rid = PRS_ALLOC_MEM(ps, DOM_RID2, out->num_entries2))
1802                             == NULL) {
1803                                 DEBUG(3, ("lsa_io_r_lookup_names2(): out of memory\n"));
1804                                 return False;
1805                         }
1806                 }
1807
1808                 for (i = 0; i < out->num_entries2; i++)
1809                         if(!smb_io_dom_rid2("", &out->dom_rid[i], ps, depth)) /* domain RIDs being looked up */
1810                                 return False;
1811         }
1812
1813         if(!prs_uint32("mapped_count", ps, depth, &out->mapped_count))
1814                 return False;
1815
1816         if(!prs_ntstatus("status      ", ps, depth, &out->status))
1817                 return False;
1818
1819         return True;
1820 }
1821
1822 /*******************************************************************
1823  Internal lsa data type io.
1824  Following pass must read DOM_SID2 types.
1825 ********************************************************************/
1826
1827 BOOL smb_io_lsa_translated_sids3(const char *desc, LSA_TRANSLATED_SID3 *q_r,
1828                            prs_struct *ps, int depth)
1829 {
1830         prs_debug(ps, depth, desc, "smb_io_lsa_translated_sids3");
1831         depth++;
1832
1833         if(!prs_align(ps))
1834                 return False;
1835         if(!prs_uint8 ("sid_type ", ps, depth, &q_r->sid_type ))
1836                 return False;
1837         if(!prs_align(ps))
1838                 return False;
1839         /* Second pass will read/write these. */
1840         if (!smb_io_dom_sid2_p("sid_header", ps, depth, &q_r->sid2))
1841                 return False;
1842         if(!prs_uint32("sid_idx ", ps, depth, &q_r->sid_idx ))
1843                 return False;
1844         if(!prs_uint32("unknown ", ps, depth, &q_r->unknown ))
1845                 return False;
1846
1847         return True;
1848 }
1849
1850 /*******************************************************************
1851  Identical to lsa_io_q_lookup_names2.
1852 ********************************************************************/
1853
1854 BOOL lsa_io_q_lookup_names3(const char *desc, LSA_Q_LOOKUP_NAMES3 *q_r,
1855                            prs_struct *ps, int depth)
1856 {
1857         unsigned int i;
1858
1859         prs_debug(ps, depth, desc, "lsa_io_q_lookup_names3");
1860         depth++;
1861
1862         if(!prs_align(ps))
1863                 return False;
1864
1865         if(!smb_io_pol_hnd("", &q_r->pol, ps, depth)) /* policy handle */
1866                 return False;
1867
1868         if(!prs_align(ps))
1869                 return False;
1870         if(!prs_uint32("num_entries    ", ps, depth, &q_r->num_entries))
1871                 return False;
1872         if(!prs_uint32("num_entries2   ", ps, depth, &q_r->num_entries2))
1873                 return False;
1874
1875         if (UNMARSHALLING(ps)) {
1876                 if (q_r->num_entries) {
1877                         if ((q_r->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_r->num_entries)) == NULL)
1878                                 return False;
1879                         if ((q_r->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_r->num_entries)) == NULL)
1880                                 return False;
1881                 }
1882         }
1883
1884         for (i = 0; i < q_r->num_entries; i++) {
1885                 if(!prs_align(ps))
1886                         return False;
1887                 if(!smb_io_unihdr("hdr_name", &q_r->hdr_name[i], ps, depth)) /* pointer names */
1888                         return False;
1889         }
1890
1891         for (i = 0; i < q_r->num_entries; i++) {
1892                 if(!prs_align(ps))
1893                         return False;
1894                 if(!smb_io_unistr2("dom_name", &q_r->uni_name[i], q_r->hdr_name[i].buffer, ps, depth)) /* names to be looked up */
1895                         return False;
1896         }
1897
1898         if(!prs_align(ps))
1899                 return False;
1900         if(!prs_uint32("num_trans_entries ", ps, depth, &q_r->num_trans_entries))
1901                 return False;
1902         if(!prs_uint32("ptr_trans_sids ", ps, depth, &q_r->ptr_trans_sids))
1903                 return False;
1904         if(!prs_uint16("lookup_level   ", ps, depth, &q_r->lookup_level))
1905                 return False;
1906         if(!prs_align(ps))
1907                 return False;
1908         if(!prs_uint32("mapped_count   ", ps, depth, &q_r->mapped_count))
1909                 return False;
1910         if(!prs_uint32("unknown1   ", ps, depth, &q_r->unknown1))
1911                 return False;
1912         if(!prs_uint32("unknown2   ", ps, depth, &q_r->unknown2))
1913                 return False;
1914
1915         return True;
1916 }
1917
1918 /*******************************************************************
1919 reads or writes a structure.
1920 ********************************************************************/
1921
1922 BOOL lsa_io_r_lookup_names3(const char *desc, LSA_R_LOOKUP_NAMES3 *out, prs_struct *ps, int depth)
1923 {
1924         unsigned int i;
1925
1926         prs_debug(ps, depth, desc, "lsa_io_r_lookup_names3");
1927         depth++;
1928
1929         if(!prs_align(ps))
1930                 return False;
1931
1932         if(!prs_uint32("ptr_dom_ref", ps, depth, &out->ptr_dom_ref))
1933                 return False;
1934
1935         if (out->ptr_dom_ref != 0)
1936                 if(!lsa_io_dom_r_ref("", out->dom_ref, ps, depth))
1937                         return False;
1938
1939         if(!prs_uint32("num_entries", ps, depth, &out->num_entries))
1940                 return False;
1941         if(!prs_uint32("ptr_entries", ps, depth, &out->ptr_entries))
1942                 return False;
1943
1944         if (out->ptr_entries != 0) {
1945                 if(!prs_uint32("num_entries2", ps, depth, &out->num_entries2))
1946                         return False;
1947
1948                 if (out->num_entries2 != out->num_entries) {
1949                         /* RPC fault */
1950                         return False;
1951                 }
1952
1953                 if (UNMARSHALLING(ps)) {
1954                         if ((out->trans_sids = PRS_ALLOC_MEM(ps, LSA_TRANSLATED_SID3, out->num_entries2))
1955                             == NULL) {
1956                                 DEBUG(3, ("lsa_io_r_lookup_names3(): out of memory\n"));
1957                                 return False;
1958                         }
1959                 }
1960
1961                 for (i = 0; i < out->num_entries2; i++) {
1962                         if(!smb_io_lsa_translated_sids3("", &out->trans_sids[i], ps, depth)) {
1963                                 return False;
1964                         }
1965                 }
1966                 /* Now process the DOM_SID2 entries. */
1967                 for (i = 0; i < out->num_entries2; i++) {
1968                         if (out->trans_sids[i].sid2) {
1969                                 if( !smb_io_dom_sid2("sid2", out->trans_sids[i].sid2, ps, depth) ) {
1970                                         return False;
1971                                 }
1972                         }
1973                 }
1974         }
1975
1976         if(!prs_uint32("mapped_count", ps, depth, &out->mapped_count))
1977                 return False;
1978
1979         if(!prs_ntstatus("status      ", ps, depth, &out->status))
1980                 return False;
1981
1982         return True;
1983 }
1984
1985 /*******************************************************************
1986 ********************************************************************/
1987
1988 BOOL lsa_io_q_lookup_names4(const char *desc, LSA_Q_LOOKUP_NAMES4 *q_r,
1989                            prs_struct *ps, int depth)
1990 {
1991         unsigned int i;
1992
1993         prs_debug(ps, depth, desc, "lsa_io_q_lookup_names4");
1994         depth++;
1995
1996         if(!prs_align(ps))
1997                 return False;
1998
1999         if(!prs_uint32("num_entries    ", ps, depth, &q_r->num_entries))
2000                 return False;
2001         if(!prs_uint32("num_entries2   ", ps, depth, &q_r->num_entries2))
2002                 return False;
2003
2004         if (UNMARSHALLING(ps)) {
2005                 if (q_r->num_entries) {
2006                         if ((q_r->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_r->num_entries)) == NULL)
2007                                 return False;
2008                         if ((q_r->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_r->num_entries)) == NULL)
2009                                 return False;
2010                 }
2011         }
2012
2013         for (i = 0; i < q_r->num_entries; i++) {
2014                 if(!prs_align(ps))
2015                         return False;
2016                 if(!smb_io_unihdr("hdr_name", &q_r->hdr_name[i], ps, depth)) /* pointer names */
2017                         return False;
2018         }
2019
2020         for (i = 0; i < q_r->num_entries; i++) {
2021                 if(!prs_align(ps))
2022                         return False;
2023                 if(!smb_io_unistr2("dom_name", &q_r->uni_name[i], q_r->hdr_name[i].buffer, ps, depth)) /* names to be looked up */
2024                         return False;
2025         }
2026
2027         if(!prs_align(ps))
2028                 return False;
2029         if(!prs_uint32("num_trans_entries ", ps, depth, &q_r->num_trans_entries))
2030                 return False;
2031         if(!prs_uint32("ptr_trans_sids ", ps, depth, &q_r->ptr_trans_sids))
2032                 return False;
2033         if(!prs_uint16("lookup_level   ", ps, depth, &q_r->lookup_level))
2034                 return False;
2035         if(!prs_align(ps))
2036                 return False;
2037         if(!prs_uint32("mapped_count   ", ps, depth, &q_r->mapped_count))
2038                 return False;
2039         if(!prs_uint32("unknown1   ", ps, depth, &q_r->unknown1))
2040                 return False;
2041         if(!prs_uint32("unknown2   ", ps, depth, &q_r->unknown2))
2042                 return False;
2043
2044         return True;
2045 }
2046
2047 /*******************************************************************
2048  Identical to lsa_io_r_lookup_names3.
2049 ********************************************************************/
2050
2051 BOOL lsa_io_r_lookup_names4(const char *desc, LSA_R_LOOKUP_NAMES4 *out, prs_struct *ps, int depth)
2052 {
2053         unsigned int i;
2054
2055         prs_debug(ps, depth, desc, "lsa_io_r_lookup_names4");
2056         depth++;
2057
2058         if(!prs_align(ps))
2059                 return False;
2060
2061         if(!prs_uint32("ptr_dom_ref", ps, depth, &out->ptr_dom_ref))
2062                 return False;
2063
2064         if (out->ptr_dom_ref != 0)
2065                 if(!lsa_io_dom_r_ref("", out->dom_ref, ps, depth))
2066                         return False;
2067
2068         if(!prs_uint32("num_entries", ps, depth, &out->num_entries))
2069                 return False;
2070         if(!prs_uint32("ptr_entries", ps, depth, &out->ptr_entries))
2071                 return False;
2072
2073         if (out->ptr_entries != 0) {
2074                 if(!prs_uint32("num_entries2", ps, depth, &out->num_entries2))
2075                         return False;
2076
2077                 if (out->num_entries2 != out->num_entries) {
2078                         /* RPC fault */
2079                         return False;
2080                 }
2081
2082                 if (UNMARSHALLING(ps)) {
2083                         if ((out->trans_sids = PRS_ALLOC_MEM(ps, LSA_TRANSLATED_SID3, out->num_entries2))
2084                             == NULL) {
2085                                 DEBUG(3, ("lsa_io_r_lookup_names4(): out of memory\n"));
2086                                 return False;
2087                         }
2088                 }
2089
2090                 for (i = 0; i < out->num_entries2; i++) {
2091                         if(!smb_io_lsa_translated_sids3("", &out->trans_sids[i], ps, depth)) {
2092                                 return False;
2093                         }
2094                 }
2095                 /* Now process the DOM_SID2 entries. */
2096                 for (i = 0; i < out->num_entries2; i++) {
2097                         if (out->trans_sids[i].sid2) {
2098                                 if( !smb_io_dom_sid2("sid2", out->trans_sids[i].sid2, ps, depth) ) {
2099                                         return False;
2100                                 }
2101                         }
2102                 }
2103         }
2104
2105         if(!prs_uint32("mapped_count", ps, depth, &out->mapped_count))
2106                 return False;
2107
2108         if(!prs_ntstatus("status      ", ps, depth, &out->status))
2109                 return False;
2110
2111         return True;
2112 }
2113
2114 /*******************************************************************
2115  Inits an LSA_Q_CLOSE structure.
2116 ********************************************************************/
2117
2118 void init_lsa_q_close(LSA_Q_CLOSE *in, POLICY_HND *hnd)
2119 {
2120         DEBUG(5, ("init_lsa_q_close\n"));
2121
2122         memcpy(&in->pol, hnd, sizeof(in->pol));
2123 }
2124
2125 /*******************************************************************
2126  Reads or writes an LSA_Q_CLOSE structure.
2127 ********************************************************************/
2128
2129 BOOL lsa_io_q_close(const char *desc, LSA_Q_CLOSE *in, prs_struct *ps, int depth)
2130 {
2131         prs_debug(ps, depth, desc, "lsa_io_q_close");
2132         depth++;
2133
2134         if(!smb_io_pol_hnd("", &in->pol, ps, depth))
2135                 return False;
2136
2137         return True;
2138 }
2139
2140 /*******************************************************************
2141  Reads or writes an LSA_R_CLOSE structure.
2142 ********************************************************************/
2143
2144 BOOL lsa_io_r_close(const char *desc,  LSA_R_CLOSE *out, prs_struct *ps, int depth)
2145 {
2146         prs_debug(ps, depth, desc, "lsa_io_r_close");
2147         depth++;
2148
2149         if(!smb_io_pol_hnd("", &out->pol, ps, depth))
2150                 return False;
2151
2152         if(!prs_ntstatus("status", ps, depth, &out->status))
2153                 return False;
2154
2155         return True;
2156 }
2157
2158 /*******************************************************************
2159  Reads or writes an LSA_Q_OPEN_SECRET structure.
2160 ********************************************************************/
2161
2162 BOOL lsa_io_q_open_secret(const char *desc, LSA_Q_OPEN_SECRET *in, prs_struct *ps, int depth)
2163 {
2164         prs_debug(ps, depth, desc, "lsa_io_q_open_secret");
2165         depth++;
2166
2167         if(!prs_align(ps))
2168                 return False;
2169
2170         if(!smb_io_pol_hnd("", &in->handle, ps, depth))
2171                 return False;
2172
2173         if(!prs_unistr4 ("secretname", ps, depth, &in->secretname))
2174                 return False;
2175         if(!prs_align(ps))
2176                 return False;
2177
2178         if(!prs_uint32("access", ps, depth, &in->access))
2179                 return False;
2180
2181         return True;
2182 }
2183
2184 /*******************************************************************
2185  Reads or writes an LSA_R_OPEN_SECRET structure.
2186 ********************************************************************/
2187
2188 BOOL lsa_io_r_open_secret(const char *desc, LSA_R_OPEN_SECRET *out, prs_struct *ps, int depth)
2189 {
2190         prs_debug(ps, depth, desc, "lsa_io_r_open_secret");
2191         depth++;
2192
2193         if(!prs_align(ps))
2194                 return False;
2195
2196         if(!smb_io_pol_hnd("", &out->handle, ps, depth))
2197                 return False;
2198
2199         if(!prs_ntstatus("status", ps, depth, &out->status))
2200                 return False;
2201
2202         return True;
2203 }
2204
2205 /*******************************************************************
2206  Inits an LSA_Q_ENUM_PRIVS structure.
2207 ********************************************************************/
2208
2209 void init_q_enum_privs(LSA_Q_ENUM_PRIVS *in, POLICY_HND *hnd, uint32 enum_context, uint32 pref_max_length)
2210 {
2211         DEBUG(5, ("init_q_enum_privs\n"));
2212
2213         memcpy(&in->pol, hnd, sizeof(in->pol));
2214
2215         in->enum_context = enum_context;
2216         in->pref_max_length = pref_max_length;
2217 }
2218
2219 /*******************************************************************
2220 reads or writes a structure.
2221 ********************************************************************/
2222 BOOL lsa_io_q_enum_privs(const char *desc, LSA_Q_ENUM_PRIVS *in, prs_struct *ps, int depth)
2223 {
2224         if (in == NULL)
2225                 return False;
2226
2227         prs_debug(ps, depth, desc, "lsa_io_q_enum_privs");
2228         depth++;
2229
2230         if (!smb_io_pol_hnd("", &in->pol, ps, depth))
2231                 return False;
2232
2233         if(!prs_uint32("enum_context   ", ps, depth, &in->enum_context))
2234                 return False;
2235         if(!prs_uint32("pref_max_length", ps, depth, &in->pref_max_length))
2236                 return False;
2237
2238         return True;
2239 }
2240
2241 /*******************************************************************
2242 reads or writes a structure.
2243 ********************************************************************/
2244 static BOOL lsa_io_priv_entries(const char *desc, LSA_PRIV_ENTRY *entries, uint32 count, prs_struct *ps, int depth)
2245 {
2246         uint32 i;
2247
2248         if (entries == NULL)
2249                 return False;
2250
2251         prs_debug(ps, depth, desc, "lsa_io_priv_entries");
2252         depth++;
2253
2254         if(!prs_align(ps))
2255                 return False;
2256
2257         for (i = 0; i < count; i++) {
2258                 if (!smb_io_unihdr("", &entries[i].hdr_name, ps, depth))
2259                         return False;
2260                 if(!prs_uint32("luid_low ", ps, depth, &entries[i].luid_low))
2261                         return False;
2262                 if(!prs_uint32("luid_high", ps, depth, &entries[i].luid_high))
2263                         return False;
2264         }
2265
2266         for (i = 0; i < count; i++)
2267                 if (!smb_io_unistr2("", &entries[i].name, entries[i].hdr_name.buffer, ps, depth))
2268                         return False;
2269
2270         return True;
2271 }
2272
2273 /*******************************************************************
2274  Inits an LSA_R_ENUM_PRIVS structure.
2275 ********************************************************************/
2276
2277 void init_lsa_r_enum_privs(LSA_R_ENUM_PRIVS *out, uint32 enum_context,
2278                           uint32 count, LSA_PRIV_ENTRY *entries)
2279 {
2280         DEBUG(5, ("init_lsa_r_enum_privs\n"));
2281
2282         out->enum_context=enum_context;
2283         out->count=count;
2284
2285         if (entries!=NULL) {
2286                 out->ptr=1;
2287                 out->count1=count;
2288                 out->privs=entries;
2289         } else {
2290                 out->ptr=0;
2291                 out->count1=0;
2292                 out->privs=NULL;
2293         }
2294 }
2295
2296 /*******************************************************************
2297 reads or writes a structure.
2298 ********************************************************************/
2299 BOOL lsa_io_r_enum_privs(const char *desc, LSA_R_ENUM_PRIVS *out, prs_struct *ps, int depth)
2300 {
2301         if (out == NULL)
2302                 return False;
2303
2304         prs_debug(ps, depth, desc, "lsa_io_r_enum_privs");
2305         depth++;
2306
2307         if(!prs_align(ps))
2308                 return False;
2309
2310         if(!prs_uint32("enum_context", ps, depth, &out->enum_context))
2311                 return False;
2312         if(!prs_uint32("count", ps, depth, &out->count))
2313                 return False;
2314         if(!prs_uint32("ptr", ps, depth, &out->ptr))
2315                 return False;
2316
2317         if (out->ptr) {
2318                 if(!prs_uint32("count1", ps, depth, &out->count1))
2319                         return False;
2320
2321                 if (UNMARSHALLING(ps))
2322                         if (!(out->privs = PRS_ALLOC_MEM(ps, LSA_PRIV_ENTRY, out->count1)))
2323                                 return False;
2324
2325                 if (!lsa_io_priv_entries("", out->privs, out->count1, ps, depth))
2326                         return False;
2327         }
2328
2329         if(!prs_align(ps))
2330                 return False;
2331
2332         if(!prs_ntstatus("status", ps, depth, &out->status))
2333                 return False;
2334
2335         return True;
2336 }
2337
2338 void init_lsa_priv_get_dispname(LSA_Q_PRIV_GET_DISPNAME *trn, POLICY_HND *hnd, const char *name, uint16 lang_id, uint16 lang_id_sys)
2339 {
2340         memcpy(&trn->pol, hnd, sizeof(trn->pol));
2341
2342         init_unistr2(&trn->name, name, UNI_FLAGS_NONE);
2343         init_uni_hdr(&trn->hdr_name, &trn->name);
2344         trn->lang_id = lang_id;
2345         trn->lang_id_sys = lang_id_sys;
2346 }
2347
2348 /*******************************************************************
2349 reads or writes a structure.
2350 ********************************************************************/
2351 BOOL lsa_io_q_priv_get_dispname(const char *desc, LSA_Q_PRIV_GET_DISPNAME *in, prs_struct *ps, int depth)
2352 {
2353         if (in == NULL)
2354                 return False;
2355
2356         prs_debug(ps, depth, desc, "lsa_io_q_priv_get_dispname");
2357         depth++;
2358
2359         if(!prs_align(ps))
2360                 return False;
2361
2362         if (!smb_io_pol_hnd("", &in->pol, ps, depth))
2363                 return False;
2364
2365         if (!smb_io_unihdr("hdr_name", &in->hdr_name, ps, depth))
2366                 return False;
2367
2368         if (!smb_io_unistr2("name", &in->name, in->hdr_name.buffer, ps, depth))
2369                 return False;
2370
2371         if(!prs_uint16("lang_id    ", ps, depth, &in->lang_id))
2372                 return False;
2373         if(!prs_uint16("lang_id_sys", ps, depth, &in->lang_id_sys))
2374                 return False;
2375
2376         return True;
2377 }
2378
2379 /*******************************************************************
2380 reads or writes a structure.
2381 ********************************************************************/
2382 BOOL lsa_io_r_priv_get_dispname(const char *desc, LSA_R_PRIV_GET_DISPNAME *out, prs_struct *ps, int depth)
2383 {
2384         if (out == NULL)
2385                 return False;
2386
2387         prs_debug(ps, depth, desc, "lsa_io_r_priv_get_dispname");
2388         depth++;
2389
2390         if (!prs_align(ps))
2391                 return False;
2392
2393         if (!prs_uint32("ptr_info", ps, depth, &out->ptr_info))
2394                 return False;
2395
2396         if (out->ptr_info){
2397                 if (!smb_io_unihdr("hdr_name", &out->hdr_desc, ps, depth))
2398                         return False;
2399
2400                 if (!smb_io_unistr2("desc", &out->desc, out->hdr_desc.buffer, ps, depth))
2401                         return False;
2402         }
2403 /*
2404         if(!prs_align(ps))
2405                 return False;
2406 */
2407         if(!prs_uint16("lang_id", ps, depth, &out->lang_id))
2408                 return False;
2409
2410         if(!prs_align(ps))
2411                 return False;
2412         if(!prs_ntstatus("status", ps, depth, &out->status))
2413                 return False;
2414
2415         return True;
2416 }
2417
2418 /*
2419   initialise a LSA_Q_ENUM_ACCOUNTS structure
2420 */
2421 void init_lsa_q_enum_accounts(LSA_Q_ENUM_ACCOUNTS *trn, POLICY_HND *hnd, uint32 enum_context, uint32 pref_max_length)
2422 {
2423         memcpy(&trn->pol, hnd, sizeof(trn->pol));
2424
2425         trn->enum_context = enum_context;
2426         trn->pref_max_length = pref_max_length;
2427 }
2428
2429 /*******************************************************************
2430 reads or writes a structure.
2431 ********************************************************************/
2432 BOOL lsa_io_q_enum_accounts(const char *desc, LSA_Q_ENUM_ACCOUNTS *in, prs_struct *ps, int depth)
2433 {
2434         if (in == NULL)
2435                 return False;
2436
2437         prs_debug(ps, depth, desc, "lsa_io_q_enum_accounts");
2438         depth++;
2439
2440         if (!smb_io_pol_hnd("", &in->pol, ps, depth))
2441                 return False;
2442
2443         if(!prs_uint32("enum_context   ", ps, depth, &in->enum_context))
2444                 return False;
2445         if(!prs_uint32("pref_max_length", ps, depth, &in->pref_max_length))
2446                 return False;
2447
2448         return True;
2449 }
2450
2451
2452 /*******************************************************************
2453  Inits an LSA_R_ENUM_PRIVS structure.
2454 ********************************************************************/
2455
2456 void init_lsa_r_enum_accounts(LSA_R_ENUM_ACCOUNTS *out, uint32 enum_context)
2457 {
2458         DEBUG(5, ("init_lsa_r_enum_accounts\n"));
2459
2460         out->enum_context=enum_context;
2461         if (out->enum_context!=0) {
2462                 out->sids.num_entries=enum_context;
2463                 out->sids.ptr_sid_enum=1;
2464                 out->sids.num_entries2=enum_context;
2465         } else {
2466                 out->sids.num_entries=0;
2467                 out->sids.ptr_sid_enum=0;
2468                 out->sids.num_entries2=0;
2469         }
2470 }
2471
2472 /*******************************************************************
2473 reads or writes a structure.
2474 ********************************************************************/
2475 BOOL lsa_io_r_enum_accounts(const char *desc, LSA_R_ENUM_ACCOUNTS *out, prs_struct *ps, int depth)
2476 {
2477         if (out == NULL)
2478                 return False;
2479
2480         prs_debug(ps, depth, desc, "lsa_io_r_enum_accounts");
2481         depth++;
2482
2483         if (!prs_align(ps))
2484                 return False;
2485
2486         if(!prs_uint32("enum_context", ps, depth, &out->enum_context))
2487                 return False;
2488
2489         if (!lsa_io_sid_enum("sids", &out->sids, ps, depth))
2490                 return False;
2491
2492         if (!prs_align(ps))
2493                 return False;
2494
2495         if(!prs_ntstatus("status", ps, depth, &out->status))
2496                 return False;
2497
2498         return True;
2499 }
2500
2501
2502 /*******************************************************************
2503  Reads or writes an LSA_Q_UNK_GET_CONNUSER structure.
2504 ********************************************************************/
2505
2506 BOOL lsa_io_q_unk_get_connuser(const char *desc, LSA_Q_UNK_GET_CONNUSER *in, prs_struct *ps, int depth)
2507 {
2508         prs_debug(ps, depth, desc, "lsa_io_q_unk_get_connuser");
2509         depth++;
2510
2511         if(!prs_align(ps))
2512                 return False;
2513
2514         if(!prs_uint32("ptr_srvname", ps, depth, &in->ptr_srvname))
2515                 return False;
2516
2517         if(!smb_io_unistr2("uni2_srvname", &in->uni2_srvname, in->ptr_srvname, ps, depth)) /* server name to be looked up */
2518                 return False;
2519
2520         if (!prs_align(ps))
2521           return False;
2522
2523         if(!prs_uint32("unk1", ps, depth, &in->unk1))
2524                 return False;
2525         if(!prs_uint32("unk2", ps, depth, &in->unk2))
2526                 return False;
2527         if(!prs_uint32("unk3", ps, depth, &in->unk3))
2528                 return False;
2529
2530         /* Don't bother to read or write at present... */
2531         return True;
2532 }
2533
2534 /*******************************************************************
2535  Reads or writes an LSA_R_UNK_GET_CONNUSER structure.
2536 ********************************************************************/
2537
2538 BOOL lsa_io_r_unk_get_connuser(const char *desc, LSA_R_UNK_GET_CONNUSER *out, prs_struct *ps, int depth)
2539 {
2540         prs_debug(ps, depth, desc, "lsa_io_r_unk_get_connuser");
2541         depth++;
2542
2543         if(!prs_align(ps))
2544                 return False;
2545
2546         if(!prs_uint32("ptr_user_name", ps, depth, &out->ptr_user_name))
2547                 return False;
2548         if(!smb_io_unihdr("hdr_user_name", &out->hdr_user_name, ps, depth))
2549                 return False;
2550         if(!smb_io_unistr2("uni2_user_name", &out->uni2_user_name, out->ptr_user_name, ps, depth))
2551                 return False;
2552
2553         if (!prs_align(ps))
2554           return False;
2555
2556         if(!prs_uint32("unk1", ps, depth, &out->unk1))
2557                 return False;
2558
2559         if(!prs_uint32("ptr_dom_name", ps, depth, &out->ptr_dom_name))
2560                 return False;
2561         if(!smb_io_unihdr("hdr_dom_name", &out->hdr_dom_name, ps, depth))
2562                 return False;
2563         if(!smb_io_unistr2("uni2_dom_name", &out->uni2_dom_name, out->ptr_dom_name, ps, depth))
2564                 return False;
2565
2566         if (!prs_align(ps))
2567           return False;
2568
2569         if(!prs_ntstatus("status", ps, depth, &out->status))
2570                 return False;
2571
2572         return True;
2573 }
2574
2575 void init_lsa_q_create_account(LSA_Q_CREATEACCOUNT *trn, POLICY_HND *hnd, DOM_SID *sid, uint32 desired_access)
2576 {
2577         memcpy(&trn->pol, hnd, sizeof(trn->pol));
2578
2579         init_dom_sid2(&trn->sid, sid);
2580         trn->access = desired_access;
2581 }
2582
2583
2584 /*******************************************************************
2585  Reads or writes an LSA_Q_CREATEACCOUNT structure.
2586 ********************************************************************/
2587
2588 BOOL lsa_io_q_create_account(const char *desc, LSA_Q_CREATEACCOUNT *out, prs_struct *ps, int depth)
2589 {
2590         prs_debug(ps, depth, desc, "lsa_io_q_create_account");
2591         depth++;
2592
2593         if(!prs_align(ps))
2594                 return False;
2595
2596         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2597                 return False;
2598
2599         if(!smb_io_dom_sid2("sid", &out->sid, ps, depth)) /* domain SID */
2600                 return False;
2601
2602         if(!prs_uint32("access", ps, depth, &out->access))
2603                 return False;
2604
2605         return True;
2606 }
2607
2608 /*******************************************************************
2609  Reads or writes an LSA_R_CREATEACCOUNT structure.
2610 ********************************************************************/
2611
2612 BOOL lsa_io_r_create_account(const char *desc, LSA_R_CREATEACCOUNT  *out, prs_struct *ps, int depth)
2613 {
2614         prs_debug(ps, depth, desc, "lsa_io_r_open_account");
2615         depth++;
2616
2617         if(!prs_align(ps))
2618                 return False;
2619
2620         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2621                 return False;
2622
2623         if(!prs_ntstatus("status", ps, depth, &out->status))
2624                 return False;
2625
2626         return True;
2627 }
2628
2629
2630 void init_lsa_q_open_account(LSA_Q_OPENACCOUNT *trn, POLICY_HND *hnd, DOM_SID *sid, uint32 desired_access)
2631 {
2632         memcpy(&trn->pol, hnd, sizeof(trn->pol));
2633
2634         init_dom_sid2(&trn->sid, sid);
2635         trn->access = desired_access;
2636 }
2637
2638 /*******************************************************************
2639  Reads or writes an LSA_Q_OPENACCOUNT structure.
2640 ********************************************************************/
2641
2642 BOOL lsa_io_q_open_account(const char *desc, LSA_Q_OPENACCOUNT *out, prs_struct *ps, int depth)
2643 {
2644         prs_debug(ps, depth, desc, "lsa_io_q_open_account");
2645         depth++;
2646
2647         if(!prs_align(ps))
2648                 return False;
2649
2650         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2651                 return False;
2652
2653         if(!smb_io_dom_sid2("sid", &out->sid, ps, depth)) /* domain SID */
2654                 return False;
2655
2656         if(!prs_uint32("access", ps, depth, &out->access))
2657                 return False;
2658
2659         return True;
2660 }
2661
2662 /*******************************************************************
2663  Reads or writes an LSA_R_OPENACCOUNT structure.
2664 ********************************************************************/
2665
2666 BOOL lsa_io_r_open_account(const char *desc, LSA_R_OPENACCOUNT  *out, prs_struct *ps, int depth)
2667 {
2668         prs_debug(ps, depth, desc, "lsa_io_r_open_account");
2669         depth++;
2670
2671         if(!prs_align(ps))
2672                 return False;
2673
2674         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2675                 return False;
2676
2677         if(!prs_ntstatus("status", ps, depth, &out->status))
2678                 return False;
2679
2680         return True;
2681 }
2682
2683
2684 void init_lsa_q_enum_privsaccount(LSA_Q_ENUMPRIVSACCOUNT *trn, POLICY_HND *hnd)
2685 {
2686         memcpy(&trn->pol, hnd, sizeof(trn->pol));
2687
2688 }
2689
2690 /*******************************************************************
2691  Reads or writes an LSA_Q_ENUMPRIVSACCOUNT structure.
2692 ********************************************************************/
2693
2694 BOOL lsa_io_q_enum_privsaccount(const char *desc, LSA_Q_ENUMPRIVSACCOUNT *out, prs_struct *ps, int depth)
2695 {
2696         prs_debug(ps, depth, desc, "lsa_io_q_enum_privsaccount");
2697         depth++;
2698
2699         if(!prs_align(ps))
2700                 return False;
2701
2702         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2703                 return False;
2704
2705         return True;
2706 }
2707
2708 /*******************************************************************
2709  Reads or writes an LUID structure.
2710 ********************************************************************/
2711
2712 static BOOL lsa_io_luid(const char *desc, LUID *out, prs_struct *ps, int depth)
2713 {
2714         prs_debug(ps, depth, desc, "lsa_io_luid");
2715         depth++;
2716
2717         if(!prs_align(ps))
2718                 return False;
2719
2720         if(!prs_uint32("low", ps, depth, &out->low))
2721                 return False;
2722
2723         if(!prs_uint32("high", ps, depth, &out->high))
2724                 return False;
2725
2726         return True;
2727 }
2728
2729 /*******************************************************************
2730  Reads or writes an LUID_ATTR structure.
2731 ********************************************************************/
2732
2733 static BOOL lsa_io_luid_attr(const char *desc, LUID_ATTR *out, prs_struct *ps, int depth)
2734 {
2735         prs_debug(ps, depth, desc, "lsa_io_luid_attr");
2736         depth++;
2737
2738         if(!prs_align(ps))
2739                 return False;
2740
2741         if (!lsa_io_luid(desc, &out->luid, ps, depth))
2742                 return False;
2743
2744         if(!prs_uint32("attr", ps, depth, &out->attr))
2745                 return False;
2746
2747         return True;
2748 }
2749
2750 /*******************************************************************
2751  Reads or writes an PRIVILEGE_SET structure.
2752 ********************************************************************/
2753
2754 static BOOL lsa_io_privilege_set(const char *desc, PRIVILEGE_SET *out, prs_struct *ps, int depth)
2755 {
2756         uint32 i;
2757
2758         prs_debug(ps, depth, desc, "lsa_io_privilege_set");
2759         depth++;
2760
2761         if(!prs_align(ps))
2762                 return False;
2763
2764         if(!prs_uint32("count", ps, depth, &out->count))
2765                 return False;
2766         if(!prs_uint32("control", ps, depth, &out->control))
2767                 return False;
2768
2769         for (i=0; i<out->count; i++) {
2770                 if (!lsa_io_luid_attr(desc, &out->set[i], ps, depth))
2771                         return False;
2772         }
2773
2774         return True;
2775 }
2776
2777 NTSTATUS init_lsa_r_enum_privsaccount(TALLOC_CTX *mem_ctx, LSA_R_ENUMPRIVSACCOUNT *out, LUID_ATTR *set, uint32 count, uint32 control)
2778 {
2779         NTSTATUS ret = NT_STATUS_OK;
2780
2781         out->ptr = 1;
2782         out->count = count;
2783
2784         if ( !NT_STATUS_IS_OK(ret = privilege_set_init_by_ctx(mem_ctx, &(out->set))) )
2785                 return ret;
2786
2787         out->set.count = count;
2788
2789         if (!NT_STATUS_IS_OK(ret = dup_luid_attr(out->set.mem_ctx, &(out->set.set), set, count)))
2790                 return ret;
2791
2792         DEBUG(10,("init_lsa_r_enum_privsaccount: %d privileges\n", out->count));
2793
2794         return ret;
2795 }
2796
2797 /*******************************************************************
2798  Reads or writes an LSA_R_ENUMPRIVSACCOUNT structure.
2799 ********************************************************************/
2800
2801 BOOL lsa_io_r_enum_privsaccount(const char *desc, LSA_R_ENUMPRIVSACCOUNT *out, prs_struct *ps, int depth)
2802 {
2803         prs_debug(ps, depth, desc, "lsa_io_r_enum_privsaccount");
2804         depth++;
2805
2806         if(!prs_align(ps))
2807                 return False;
2808
2809         if(!prs_uint32("ptr", ps, depth, &out->ptr))
2810                 return False;
2811
2812         if (out->ptr!=0) {
2813                 if(!prs_uint32("count", ps, depth, &out->count))
2814                         return False;
2815
2816                 /* malloc memory if unmarshalling here */
2817
2818                 if (UNMARSHALLING(ps) && out->count != 0) {
2819                         if (!NT_STATUS_IS_OK(privilege_set_init_by_ctx(ps->mem_ctx, &(out->set))))
2820                                 return False;
2821
2822                         if (!(out->set.set = PRS_ALLOC_MEM(ps,LUID_ATTR,out->count)))
2823                                 return False;
2824
2825                 }
2826
2827                 if(!lsa_io_privilege_set(desc, &out->set, ps, depth))
2828                         return False;
2829         }
2830
2831         if(!prs_ntstatus("status", ps, depth, &out->status))
2832                 return False;
2833
2834         return True;
2835 }
2836
2837
2838
2839 /*******************************************************************
2840  Reads or writes an  LSA_Q_GETSYSTEMACCOUNTstructure.
2841 ********************************************************************/
2842
2843 BOOL lsa_io_q_getsystemaccount(const char *desc, LSA_Q_GETSYSTEMACCOUNT  *out, prs_struct *ps, int depth)
2844 {
2845         prs_debug(ps, depth, desc, "lsa_io_q_getsystemaccount");
2846         depth++;
2847
2848         if(!prs_align(ps))
2849                 return False;
2850
2851         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2852                 return False;
2853
2854         return True;
2855 }
2856
2857 /*******************************************************************
2858  Reads or writes an  LSA_R_GETSYSTEMACCOUNTstructure.
2859 ********************************************************************/
2860
2861 BOOL lsa_io_r_getsystemaccount(const char *desc, LSA_R_GETSYSTEMACCOUNT  *out, prs_struct *ps, int depth)
2862 {
2863         prs_debug(ps, depth, desc, "lsa_io_r_getsystemaccount");
2864         depth++;
2865
2866         if(!prs_align(ps))
2867                 return False;
2868
2869         if(!prs_uint32("access", ps, depth, &out->access))
2870                 return False;
2871
2872         if(!prs_ntstatus("status", ps, depth, &out->status))
2873                 return False;
2874
2875         return True;
2876 }
2877
2878
2879 /*******************************************************************
2880  Reads or writes an LSA_Q_SETSYSTEMACCOUNT structure.
2881 ********************************************************************/
2882
2883 BOOL lsa_io_q_setsystemaccount(const char *desc, LSA_Q_SETSYSTEMACCOUNT  *out, prs_struct *ps, int depth)
2884 {
2885         prs_debug(ps, depth, desc, "lsa_io_q_setsystemaccount");
2886         depth++;
2887
2888         if(!prs_align(ps))
2889                 return False;
2890
2891         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2892                 return False;
2893
2894         if(!prs_uint32("access", ps, depth, &out->access))
2895                 return False;
2896
2897         return True;
2898 }
2899
2900 /*******************************************************************
2901  Reads or writes an LSA_R_SETSYSTEMACCOUNT structure.
2902 ********************************************************************/
2903
2904 BOOL lsa_io_r_setsystemaccount(const char *desc, LSA_R_SETSYSTEMACCOUNT  *out, prs_struct *ps, int depth)
2905 {
2906         prs_debug(ps, depth, desc, "lsa_io_r_setsystemaccount");
2907         depth++;
2908
2909         if(!prs_align(ps))
2910                 return False;
2911
2912         if(!prs_ntstatus("status", ps, depth, &out->status))
2913                 return False;
2914
2915         return True;
2916 }
2917
2918
2919 static void init_lsa_string( LSA_STRING *uni, const char *string )
2920 {
2921         init_unistr2(&uni->unistring, string, UNI_FLAGS_NONE);
2922         init_uni_hdr(&uni->hdr, &uni->unistring);
2923 }
2924
2925 void init_lsa_q_lookup_priv_value(LSA_Q_LOOKUP_PRIV_VALUE *q_u, POLICY_HND *hnd, const char *name)
2926 {
2927         memcpy(&q_u->pol, hnd, sizeof(q_u->pol));
2928         init_lsa_string( &q_u->privname, name );
2929 }
2930
2931 BOOL smb_io_lsa_string( const char *desc, LSA_STRING *string, prs_struct *ps, int depth )
2932 {
2933         prs_debug(ps, depth, desc, "smb_io_lsa_string");
2934         depth++;
2935
2936         if(!smb_io_unihdr ("hdr", &string->hdr, ps, depth))
2937                 return False;
2938         if(!smb_io_unistr2("unistring", &string->unistring, string->hdr.buffer, ps, depth))
2939                 return False;
2940
2941         return True;
2942 }
2943
2944 /*******************************************************************
2945  Reads or writes an LSA_Q_LOOKUP_PRIV_VALUE  structure.
2946 ********************************************************************/
2947
2948 BOOL lsa_io_q_lookup_priv_value(const char *desc, LSA_Q_LOOKUP_PRIV_VALUE  *out, prs_struct *ps, int depth)
2949 {
2950         prs_debug(ps, depth, desc, "lsa_io_q_lookup_priv_value");
2951         depth++;
2952
2953         if(!prs_align(ps))
2954                 return False;
2955
2956         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2957                 return False;
2958         if(!smb_io_lsa_string("privname", &out->privname, ps, depth))
2959                 return False;
2960
2961         return True;
2962 }
2963
2964 /*******************************************************************
2965  Reads or writes an  LSA_R_LOOKUP_PRIV_VALUE structure.
2966 ********************************************************************/
2967
2968 BOOL lsa_io_r_lookup_priv_value(const char *desc, LSA_R_LOOKUP_PRIV_VALUE  *out, prs_struct *ps, int depth)
2969 {
2970         prs_debug(ps, depth, desc, "lsa_io_r_lookup_priv_value");
2971         depth++;
2972
2973         if(!prs_align(ps))
2974                 return False;
2975
2976         if(!lsa_io_luid("luid", &out->luid, ps, depth))
2977                 return False;
2978
2979         if(!prs_ntstatus("status", ps, depth, &out->status))
2980                 return False;
2981
2982         return True;
2983 }
2984
2985
2986 /*******************************************************************
2987  Reads or writes an LSA_Q_ADDPRIVS structure.
2988 ********************************************************************/
2989
2990 BOOL lsa_io_q_addprivs(const char *desc, LSA_Q_ADDPRIVS *out, prs_struct *ps, int depth)
2991 {
2992         prs_debug(ps, depth, desc, "lsa_io_q_addprivs");
2993         depth++;
2994
2995         if(!prs_align(ps))
2996                 return False;
2997
2998         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2999                 return False;
3000
3001         if(!prs_uint32("count", ps, depth, &out->count))
3002                 return False;
3003
3004         if (UNMARSHALLING(ps) && out->count!=0) {
3005                 if (!NT_STATUS_IS_OK(privilege_set_init_by_ctx(ps->mem_ctx, &(out->set))))
3006                         return False;
3007
3008                 if (!(out->set.set = PRS_ALLOC_MEM(ps, LUID_ATTR, out->count)))
3009                         return False;
3010         }
3011
3012         if(!lsa_io_privilege_set(desc, &out->set, ps, depth))
3013                 return False;
3014
3015         return True;
3016 }
3017
3018 /*******************************************************************
3019  Reads or writes an LSA_R_ADDPRIVS structure.
3020 ********************************************************************/
3021
3022 BOOL lsa_io_r_addprivs(const char *desc, LSA_R_ADDPRIVS *out, prs_struct *ps, int depth)
3023 {
3024         prs_debug(ps, depth, desc, "lsa_io_r_addprivs");
3025         depth++;
3026
3027         if(!prs_align(ps))
3028                 return False;
3029
3030         if(!prs_ntstatus("status", ps, depth, &out->status))
3031                 return False;
3032
3033         return True;
3034 }
3035
3036 /*******************************************************************
3037  Reads or writes an LSA_Q_REMOVEPRIVS structure.
3038 ********************************************************************/
3039
3040 BOOL lsa_io_q_removeprivs(const char *desc, LSA_Q_REMOVEPRIVS *out, prs_struct *ps, int depth)
3041 {
3042         prs_debug(ps, depth, desc, "lsa_io_q_removeprivs");
3043         depth++;
3044
3045         if(!prs_align(ps))
3046                 return False;
3047
3048         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
3049                 return False;
3050
3051         if(!prs_uint32("allrights", ps, depth, &out->allrights))
3052                 return False;
3053
3054         if(!prs_uint32("ptr", ps, depth, &out->ptr))
3055                 return False;
3056
3057         /*
3058          * JFM: I'm not sure at all if the count is inside the ptr
3059          * never seen one with ptr=0
3060          */
3061
3062         if (out->ptr!=0) {
3063                 if(!prs_uint32("count", ps, depth, &out->count))
3064                         return False;
3065
3066                 if (UNMARSHALLING(ps) && out->count!=0) {
3067                         if (!NT_STATUS_IS_OK(privilege_set_init_by_ctx(ps->mem_ctx, &(out->set))))
3068                                 return False;
3069
3070                         if (!(out->set.set = PRS_ALLOC_MEM(ps, LUID_ATTR, out->count)))
3071                                 return False;
3072                 }
3073
3074                 if(!lsa_io_privilege_set(desc, &out->set, ps, depth))
3075                         return False;
3076         }
3077
3078         return True;
3079 }
3080
3081 /*******************************************************************
3082  Reads or writes an LSA_R_REMOVEPRIVS structure.
3083 ********************************************************************/
3084
3085 BOOL lsa_io_r_removeprivs(const char *desc, LSA_R_REMOVEPRIVS *out, prs_struct *ps, int depth)
3086 {
3087         prs_debug(ps, depth, desc, "lsa_io_r_removeprivs");
3088         depth++;
3089
3090         if(!prs_align(ps))
3091                 return False;
3092
3093         if(!prs_ntstatus("status", ps, depth, &out->status))
3094                 return False;
3095
3096         return True;
3097 }
3098
3099 BOOL policy_handle_is_valid(const POLICY_HND *hnd)
3100 {
3101         POLICY_HND zero_pol;
3102
3103         ZERO_STRUCT(zero_pol);
3104         return ((memcmp(&zero_pol, hnd, sizeof(POLICY_HND)) == 0) ? False : True );
3105 }
3106
3107 /*******************************************************************
3108  Inits an LSA_Q_QUERY_INFO2 structure.
3109 ********************************************************************/
3110
3111 void init_q_query2(LSA_Q_QUERY_INFO2 *in, POLICY_HND *hnd, uint16 info_class)
3112 {
3113         DEBUG(5, ("init_q_query2\n"));
3114
3115         memcpy(&in->pol, hnd, sizeof(in->pol));
3116
3117         in->info_class = info_class;
3118 }
3119
3120 /*******************************************************************
3121  Reads or writes an LSA_Q_QUERY_DNSDOMINFO structure.
3122 ********************************************************************/
3123
3124 BOOL lsa_io_q_query_info2(const char *desc, LSA_Q_QUERY_INFO2 *in, prs_struct *ps, int depth)
3125 {
3126         prs_debug(ps, depth, desc, "lsa_io_q_query_info2");
3127         depth++;
3128
3129         if(!prs_align(ps))
3130                 return False;
3131
3132         if(!smb_io_pol_hnd("pol", &in->pol, ps, depth))
3133                 return False;
3134
3135         if(!prs_uint16("info_class", ps, depth, &in->info_class))
3136                 return False;
3137
3138         return True;
3139 }
3140
3141 /*******************************************************************
3142  Reads or writes an LSA_R_QUERY_DNSDOMINFO structure.
3143 ********************************************************************/
3144
3145 BOOL lsa_io_r_query_info2(const char *desc, LSA_R_QUERY_INFO2 *out,
3146                           prs_struct *ps, int depth)
3147 {
3148         prs_debug(ps, depth, desc, "lsa_io_r_query_info2");
3149         depth++;
3150
3151         if(!prs_align(ps))
3152                 return False;
3153
3154         if(!prs_uint32("dom_ptr", ps, depth, &out->dom_ptr))
3155                 return False;
3156
3157         if (out->dom_ptr) {
3158
3159                 if(!lsa_io_query_info_ctr2("", ps, depth, &out->ctr))
3160                         return False;
3161         }
3162
3163         if(!prs_align(ps))
3164                 return False;
3165         if(!prs_ntstatus("status", ps, depth, &out->status))
3166                 return False;
3167
3168         return True;
3169 }
3170
3171 /*******************************************************************
3172  Inits an LSA_Q_ENUM_ACCT_RIGHTS structure.
3173 ********************************************************************/
3174 void init_q_enum_acct_rights(LSA_Q_ENUM_ACCT_RIGHTS *in,
3175                              POLICY_HND *hnd,
3176                              uint32 count,
3177                              DOM_SID *sid)
3178 {
3179         DEBUG(5, ("init_q_enum_acct_rights\n"));
3180
3181         in->pol = *hnd;
3182         init_dom_sid2(&in->sid, sid);
3183 }
3184
3185 /*******************************************************************
3186 ********************************************************************/
3187 NTSTATUS init_r_enum_acct_rights( LSA_R_ENUM_ACCT_RIGHTS *out, PRIVILEGE_SET *privileges )
3188 {
3189         uint32 i;
3190         char *privname;
3191         const char **privname_array = NULL;
3192         int num_priv = 0;
3193
3194         for ( i=0; i<privileges->count; i++ ) {
3195                 privname = luid_to_privilege_name( &privileges->set[i].luid );
3196                 if ( privname ) {
3197                         if ( !add_string_to_array( get_talloc_ctx(), privname, &privname_array, &num_priv ) )
3198                                 return NT_STATUS_NO_MEMORY;
3199                 }
3200         }
3201
3202         if ( num_priv ) {
3203                 out->rights = TALLOC_P( get_talloc_ctx(), UNISTR4_ARRAY );
3204                 if (!out->rights) {
3205                         return NT_STATUS_NO_MEMORY;
3206                 }
3207
3208                 if ( !init_unistr4_array( out->rights, num_priv, privname_array ) )
3209                         return NT_STATUS_NO_MEMORY;
3210
3211                 out->count = num_priv;
3212         }
3213
3214         return NT_STATUS_OK;
3215 }
3216
3217 /*******************************************************************
3218 reads or writes a LSA_Q_ENUM_ACCT_RIGHTS structure.
3219 ********************************************************************/
3220 BOOL lsa_io_q_enum_acct_rights(const char *desc, LSA_Q_ENUM_ACCT_RIGHTS *in, prs_struct *ps, int depth)
3221 {
3222
3223         if (in == NULL)
3224                 return False;
3225
3226         prs_debug(ps, depth, desc, "lsa_io_q_enum_acct_rights");
3227         depth++;
3228
3229         if (!smb_io_pol_hnd("", &in->pol, ps, depth))
3230                 return False;
3231
3232         if(!smb_io_dom_sid2("sid", &in->sid, ps, depth))
3233                 return False;
3234
3235         return True;
3236 }
3237
3238
3239 /*******************************************************************
3240 reads or writes a LSA_R_ENUM_ACCT_RIGHTS structure.
3241 ********************************************************************/
3242 BOOL lsa_io_r_enum_acct_rights(const char *desc, LSA_R_ENUM_ACCT_RIGHTS *out, prs_struct *ps, int depth)
3243 {
3244         prs_debug(ps, depth, desc, "lsa_io_r_enum_acct_rights");
3245         depth++;
3246
3247         if(!prs_uint32("count   ", ps, depth, &out->count))
3248                 return False;
3249
3250         if ( !prs_pointer("rights", ps, depth, (void**)&out->rights, sizeof(UNISTR4_ARRAY), (PRS_POINTER_CAST)prs_unistr4_array) )
3251                 return False;
3252
3253         if(!prs_align(ps))
3254                 return False;
3255
3256         if(!prs_ntstatus("status", ps, depth, &out->status))
3257                 return False;
3258
3259         return True;
3260 }
3261
3262
3263 /*******************************************************************
3264  Inits an LSA_Q_ADD_ACCT_RIGHTS structure.
3265 ********************************************************************/
3266 void init_q_add_acct_rights( LSA_Q_ADD_ACCT_RIGHTS *in, POLICY_HND *hnd,
3267                              DOM_SID *sid, uint32 count, const char **rights )
3268 {
3269         DEBUG(5, ("init_q_add_acct_rights\n"));
3270
3271         in->pol = *hnd;
3272         init_dom_sid2(&in->sid, sid);
3273
3274         in->rights = TALLOC_P( get_talloc_ctx(), UNISTR4_ARRAY );
3275         if (!in->rights) {
3276                 smb_panic("init_q_add_acct_rights: talloc fail\n");
3277                 return;
3278         }
3279         init_unistr4_array( in->rights, count, rights );
3280
3281         in->count = count;
3282 }
3283
3284
3285 /*******************************************************************
3286 reads or writes a LSA_Q_ADD_ACCT_RIGHTS structure.
3287 ********************************************************************/
3288 BOOL lsa_io_q_add_acct_rights(const char *desc, LSA_Q_ADD_ACCT_RIGHTS *in, prs_struct *ps, int depth)
3289 {
3290         prs_debug(ps, depth, desc, "lsa_io_q_add_acct_rights");
3291         depth++;
3292
3293         if (!smb_io_pol_hnd("", &in->pol, ps, depth))
3294                 return False;
3295
3296         if(!smb_io_dom_sid2("sid", &in->sid, ps, depth))
3297                 return False;
3298
3299         if(!prs_uint32("count", ps, depth, &in->count))
3300                 return False;
3301
3302         if ( !prs_pointer("rights", ps, depth, (void**)&in->rights, sizeof(UNISTR4_ARRAY), (PRS_POINTER_CAST)prs_unistr4_array) )
3303                 return False;
3304
3305         return True;
3306 }
3307
3308 /*******************************************************************
3309 reads or writes a LSA_R_ENUM_ACCT_RIGHTS structure.
3310 ********************************************************************/
3311 BOOL lsa_io_r_add_acct_rights(const char *desc, LSA_R_ADD_ACCT_RIGHTS *out, prs_struct *ps, int depth)
3312 {
3313         prs_debug(ps, depth, desc, "lsa_io_r_add_acct_rights");
3314         depth++;
3315
3316         if(!prs_ntstatus("status", ps, depth, &out->status))
3317                 return False;
3318
3319         return True;
3320 }
3321
3322 /*******************************************************************
3323  Inits an LSA_Q_REMOVE_ACCT_RIGHTS structure.
3324 ********************************************************************/
3325
3326 void init_q_remove_acct_rights(LSA_Q_REMOVE_ACCT_RIGHTS *in,
3327                                POLICY_HND *hnd,
3328                                DOM_SID *sid,
3329                                uint32 removeall,
3330                                uint32 count,
3331                                const char **rights)
3332 {
3333         DEBUG(5, ("init_q_remove_acct_rights\n"));
3334
3335         in->pol = *hnd;
3336
3337         init_dom_sid2(&in->sid, sid);
3338
3339         in->removeall = removeall;
3340         in->count = count;
3341
3342         in->rights = TALLOC_P( get_talloc_ctx(), UNISTR4_ARRAY );
3343         if (!in->rights) {
3344                 smb_panic("init_q_remove_acct_rights: talloc fail\n");
3345                 return;
3346         }
3347         init_unistr4_array( in->rights, count, rights );
3348 }
3349
3350 /*******************************************************************
3351 reads or writes a LSA_Q_REMOVE_ACCT_RIGHTS structure.
3352 ********************************************************************/
3353
3354 BOOL lsa_io_q_remove_acct_rights(const char *desc, LSA_Q_REMOVE_ACCT_RIGHTS *in, prs_struct *ps, int depth)
3355 {
3356         prs_debug(ps, depth, desc, "lsa_io_q_remove_acct_rights");
3357         depth++;
3358
3359         if (!smb_io_pol_hnd("", &in->pol, ps, depth))
3360                 return False;
3361
3362         if(!smb_io_dom_sid2("sid", &in->sid, ps, depth))
3363                 return False;
3364
3365         if(!prs_uint32("removeall", ps, depth, &in->removeall))
3366                 return False;
3367
3368         if(!prs_uint32("count", ps, depth, &in->count))
3369                 return False;
3370
3371         if ( !prs_pointer("rights", ps, depth, (void**)&in->rights, sizeof(UNISTR4_ARRAY), (PRS_POINTER_CAST)prs_unistr4_array) )
3372                 return False;
3373
3374         return True;
3375 }
3376
3377 /*******************************************************************
3378 reads or writes a LSA_R_ENUM_ACCT_RIGHTS structure.
3379 ********************************************************************/
3380 BOOL lsa_io_r_remove_acct_rights(const char *desc, LSA_R_REMOVE_ACCT_RIGHTS *out, prs_struct *ps, int depth)
3381 {
3382         prs_debug(ps, depth, desc, "lsa_io_r_remove_acct_rights");
3383         depth++;
3384
3385         if(!prs_ntstatus("status", ps, depth, &out->status))
3386                 return False;
3387
3388         return True;
3389 }
3390
3391 /*******************************************************************
3392  Inits an LSA_Q_OPEN_TRUSTED_DOMAIN structure.
3393 ********************************************************************/
3394
3395 void init_lsa_q_open_trusted_domain(LSA_Q_OPEN_TRUSTED_DOMAIN *q, POLICY_HND *hnd, DOM_SID *sid, uint32 desired_access)
3396 {
3397         memcpy(&q->pol, hnd, sizeof(q->pol));
3398
3399         init_dom_sid2(&q->sid, sid);
3400         q->access_mask = desired_access;
3401 }
3402
3403 /*******************************************************************
3404 ********************************************************************/
3405
3406 #if 0 /* jerry, I think this not correct - gd */
3407 BOOL lsa_io_q_open_trusted_domain(const char *desc, LSA_Q_OPEN_TRUSTED_DOMAIN *in, prs_struct *ps, int depth)
3408 {
3409         prs_debug(ps, depth, desc, "lsa_io_q_open_trusted_domain");
3410         depth++;
3411
3412         if(!prs_align(ps))
3413                 return False;
3414
3415         if (!smb_io_pol_hnd("", &in->handle, ps, depth))
3416                 return False;
3417
3418         if(!prs_uint32("count", ps, depth, &in->count))
3419                 return False;
3420
3421         if(!smb_io_dom_sid("sid", &in->sid, ps, depth))
3422                 return False;
3423
3424         return True;
3425 }
3426 #endif
3427
3428
3429 /*******************************************************************
3430  Inits an LSA_Q_OPEN_TRUSTED_DOMAIN_BY_NAME structure.
3431 ********************************************************************/
3432
3433 void init_lsa_q_open_trusted_domain_by_name(LSA_Q_OPEN_TRUSTED_DOMAIN_BY_NAME *q,
3434                                             POLICY_HND *hnd,
3435                                             const char *name,
3436                                             uint32 desired_access)
3437 {
3438         memcpy(&q->pol, hnd, sizeof(q->pol));
3439
3440         init_lsa_string(&q->name, name);
3441         q->access_mask = desired_access;
3442 }
3443
3444 /*******************************************************************
3445 ********************************************************************/
3446
3447
3448 /*******************************************************************
3449  Reads or writes an LSA_Q_OPEN_TRUSTED_DOMAIN_BY_NAME structure.
3450 ********************************************************************/
3451
3452 BOOL lsa_io_q_open_trusted_domain_by_name(const char *desc, LSA_Q_OPEN_TRUSTED_DOMAIN_BY_NAME *q_o, prs_struct *ps, int depth)
3453 {
3454         prs_debug(ps, depth, desc, "lsa_io_q_open_trusted_domain_by_name");
3455         depth++;
3456
3457         if(!prs_align(ps))
3458                 return False;
3459
3460         if(!smb_io_pol_hnd("pol", &q_o->pol, ps, depth))
3461                 return False;
3462
3463         if(!prs_align(ps))
3464                 return False;
3465
3466         if(!smb_io_lsa_string("name", &q_o->name, ps, depth))
3467                 return False;
3468
3469         if(!prs_align(ps))
3470                 return False;
3471
3472         if(!prs_uint32("access", ps, depth, &q_o->access_mask))
3473                 return False;
3474
3475         return True;
3476 }
3477
3478 /*******************************************************************
3479  Reads or writes an LSA_R_OPEN_TRUSTED_DOMAIN_BY_NAME structure.
3480 ********************************************************************/
3481
3482 BOOL lsa_io_r_open_trusted_domain_by_name(const char *desc, LSA_R_OPEN_TRUSTED_DOMAIN_BY_NAME *out, prs_struct *ps, int depth)
3483 {
3484         prs_debug(ps, depth, desc, "lsa_io_r_open_trusted_domain_by_name");
3485         depth++;
3486
3487         if(!prs_align(ps))
3488                 return False;
3489
3490         if (!smb_io_pol_hnd("handle", &out->handle, ps, depth))
3491                 return False;
3492
3493         if(!prs_ntstatus("status", ps, depth, &out->status))
3494                 return False;
3495
3496         return True;
3497 }
3498
3499 /*******************************************************************
3500 ********************************************************************/
3501
3502 BOOL lsa_io_q_open_trusted_domain(const char *desc, LSA_Q_OPEN_TRUSTED_DOMAIN *q_o, prs_struct *ps, int depth)
3503 {
3504         prs_debug(ps, depth, desc, "lsa_io_q_open_trusted_domain");
3505         depth++;
3506
3507         if(!prs_align(ps))
3508                 return False;
3509
3510         if(!smb_io_pol_hnd("pol", &q_o->pol, ps, depth))
3511                 return False;
3512
3513         if(!smb_io_dom_sid2("sid", &q_o->sid, ps, depth))
3514                 return False;
3515
3516         if(!prs_uint32("access", ps, depth, &q_o->access_mask))
3517                 return False;
3518
3519         return True;
3520 }
3521
3522 /*******************************************************************
3523  Reads or writes an LSA_R_OPEN_TRUSTED_DOMAIN structure.
3524 ********************************************************************/
3525
3526 BOOL lsa_io_r_open_trusted_domain(const char *desc, LSA_R_OPEN_TRUSTED_DOMAIN *out, prs_struct *ps, int depth)
3527 {
3528         prs_debug(ps, depth, desc, "lsa_io_r_open_trusted_domain");
3529         depth++;
3530
3531         if(!prs_align(ps))
3532                 return False;
3533
3534         if (!smb_io_pol_hnd("handle", &out->handle, ps, depth))
3535                 return False;
3536
3537         if(!prs_ntstatus("status", ps, depth, &out->status))
3538                 return False;
3539
3540         return True;
3541 }
3542
3543 /*******************************************************************
3544 ********************************************************************/
3545
3546 BOOL lsa_io_q_create_trusted_domain(const char *desc, LSA_Q_CREATE_TRUSTED_DOMAIN *in, prs_struct *ps, int depth)
3547 {
3548         prs_debug(ps, depth, desc, "lsa_io_q_create_trusted_domain");
3549         depth++;
3550
3551         if(!prs_align(ps))
3552                 return False;
3553
3554         if(!smb_io_pol_hnd("", &in->handle, ps, depth))
3555                 return False;
3556
3557         if(!prs_unistr4 ("secretname", ps, depth, &in->secretname))
3558                 return False;
3559         if(!prs_align(ps))
3560                 return False;
3561
3562         if(!prs_uint32("access", ps, depth, &in->access))
3563                 return False;
3564
3565         return True;
3566 }
3567
3568 /*******************************************************************
3569 ********************************************************************/
3570
3571 BOOL lsa_io_r_create_trusted_domain(const char *desc, LSA_R_CREATE_TRUSTED_DOMAIN *out, prs_struct *ps, int depth)
3572 {
3573         prs_debug(ps, depth, desc, "lsa_io_r_create_trusted_domain");
3574         depth++;
3575
3576         if(!prs_align(ps))
3577                 return False;
3578
3579         if (!smb_io_pol_hnd("", &out->handle, ps, depth))
3580                 return False;
3581
3582         if(!prs_ntstatus("status", ps, depth, &out->status))
3583                 return False;
3584
3585         return True;
3586 }
3587
3588 /*******************************************************************
3589 ********************************************************************/
3590
3591 BOOL lsa_io_q_create_secret(const char *desc, LSA_Q_CREATE_SECRET *in, prs_struct *ps, int depth)
3592 {
3593         prs_debug(ps, depth, desc, "lsa_io_q_create_secret");
3594         depth++;
3595
3596         if(!prs_align(ps))
3597                 return False;
3598
3599         if(!smb_io_pol_hnd("", &in->handle, ps, depth))
3600                 return False;
3601
3602         if(!prs_unistr4 ("secretname", ps, depth, &in->secretname))
3603                 return False;
3604         if(!prs_align(ps))
3605                 return False;
3606
3607         if(!prs_uint32("access", ps, depth, &in->access))
3608                 return False;
3609
3610         return True;
3611 }
3612
3613 /*******************************************************************
3614 ********************************************************************/
3615
3616 BOOL lsa_io_r_create_secret(const char *desc, LSA_R_CREATE_SECRET *out, prs_struct *ps, int depth)
3617 {
3618         prs_debug(ps, depth, desc, "lsa_io_r_create_secret");
3619         depth++;
3620
3621         if(!prs_align(ps))
3622                 return False;
3623
3624         if (!smb_io_pol_hnd("", &out->handle, ps, depth))
3625                 return False;
3626
3627         if(!prs_ntstatus("status", ps, depth, &out->status))
3628                 return False;
3629
3630         return True;
3631 }
3632
3633
3634
3635 /*******************************************************************
3636 ********************************************************************/
3637
3638 static BOOL lsa_io_data_blob( const char *desc, prs_struct *ps, int depth, LSA_DATA_BLOB *blob )
3639 {
3640         prs_debug(ps, depth, desc, "lsa_io_data_blob");
3641         depth++;
3642
3643         if ( !prs_uint32("size", ps, depth, &blob->size) )
3644                 return False;
3645         if ( !prs_uint32("size", ps, depth, &blob->size) )
3646                 return False;
3647
3648         if ( !prs_io_unistr2_p(desc, ps, depth, &blob->data) )
3649                 return False;
3650
3651         return True;
3652 }
3653
3654 /*******************************************************************
3655 ********************************************************************/
3656
3657 BOOL lsa_io_q_set_secret(const char *desc, LSA_Q_SET_SECRET *in, prs_struct *ps, int depth)
3658 {
3659         prs_debug(ps, depth, desc, "lsa_io_q_set_secret");
3660         depth++;
3661
3662         if ( !prs_align(ps) )
3663                 return False;
3664
3665         if ( !smb_io_pol_hnd("", &in->handle, ps, depth) )
3666                 return False;
3667
3668         if ( !prs_pointer( "old_value", ps, depth, (void*)&in->old_value, sizeof(LSA_DATA_BLOB), (PRS_POINTER_CAST)lsa_io_data_blob ))
3669                 return False;
3670
3671         if( !prs_align(ps) )
3672                 return False;
3673         if ( !prs_pointer( "old_value", ps, depth, (void*)&in->old_value, sizeof(LSA_DATA_BLOB), (PRS_POINTER_CAST)lsa_io_data_blob ))
3674                 return False;
3675
3676
3677         return True;
3678 }
3679
3680 /*******************************************************************
3681 ********************************************************************/
3682
3683 BOOL lsa_io_r_set_secret(const char *desc, LSA_R_SET_SECRET *out, prs_struct *ps, int depth)
3684 {
3685         prs_debug(ps, depth, desc, "lsa_io_r_set_secret");
3686         depth++;
3687
3688         if(!prs_ntstatus("status", ps, depth, &out->status))
3689                 return False;
3690
3691         return True;
3692 }
3693
3694 /*******************************************************************
3695 ********************************************************************/
3696
3697 BOOL lsa_io_q_delete_object(const char *desc, LSA_Q_DELETE_OBJECT *in, prs_struct *ps, int depth)
3698 {
3699         prs_debug(ps, depth, desc, "lsa_io_q_delete_object");
3700         depth++;
3701
3702         if(!prs_align(ps))
3703                 return False;
3704
3705         if(!smb_io_pol_hnd("", &in->handle, ps, depth))
3706                 return False;
3707
3708         return True;
3709 }
3710
3711 /*******************************************************************
3712 ********************************************************************/
3713
3714 BOOL lsa_io_r_delete_object(const char *desc, LSA_R_DELETE_OBJECT *out, prs_struct *ps, int depth)
3715 {
3716         prs_debug(ps, depth, desc, "lsa_io_r_delete_object");
3717         depth++;
3718
3719         if(!prs_ntstatus("status", ps, depth, &out->status))
3720                 return False;
3721
3722         return True;
3723 }
3724
3725 /*******************************************************************
3726  Inits an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO structure.
3727 ********************************************************************/
3728
3729 void init_q_query_trusted_domain_info(LSA_Q_QUERY_TRUSTED_DOMAIN_INFO *q,
3730                                       POLICY_HND *hnd, uint16 info_class)
3731 {
3732         DEBUG(5, ("init_q_query_trusted_domain_info\n"));
3733
3734         q->pol = *hnd;
3735         q->info_class = info_class;
3736 }
3737
3738 /*******************************************************************
3739  Inits an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_NAME structure.
3740 ********************************************************************/
3741
3742 void init_q_query_trusted_domain_info_by_name(LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_NAME *q,
3743                                               POLICY_HND *hnd, uint16 info_class,
3744                                               const char *dom_name)
3745 {
3746         DEBUG(5, ("init_q_query_trusted_domain_info_by_name\n"));
3747
3748         q->pol = *hnd;
3749         init_lsa_string(&q->domain_name, dom_name );
3750         q->info_class = info_class;
3751 }
3752
3753 /*******************************************************************
3754  Inits an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_SID structure.
3755 ********************************************************************/
3756
3757 void init_q_query_trusted_domain_info_by_sid(LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_SID *q,
3758                                              POLICY_HND *hnd, uint16 info_class,
3759                                              DOM_SID *dom_sid)
3760 {
3761         DEBUG(5, ("init_q_query_trusted_domain_info_by_sid\n"));
3762
3763         q->pol = *hnd;
3764         init_dom_sid2(&q->dom_sid, dom_sid);
3765         q->info_class = info_class;
3766 }
3767
3768 /*******************************************************************
3769  Reads or writes an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO structure.
3770 ********************************************************************/
3771
3772 BOOL lsa_io_q_query_trusted_domain_info(const char *desc,
3773                                         LSA_Q_QUERY_TRUSTED_DOMAIN_INFO *q_q,
3774                                         prs_struct *ps, int depth)
3775 {
3776         prs_debug(ps, depth, desc, "lsa_io_q_query_trusted_domain_info");
3777         depth++;
3778
3779         if(!prs_align(ps))
3780                 return False;
3781
3782         if(!smb_io_pol_hnd("pol", &q_q->pol, ps, depth))
3783                 return False;
3784
3785         if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
3786                 return False;
3787
3788         return True;
3789 }
3790
3791
3792 /*******************************************************************
3793  Reads or writes an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_SID structure.
3794 ********************************************************************/
3795
3796 BOOL lsa_io_q_query_trusted_domain_info_by_sid(const char *desc,
3797                                                LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_SID *q_q,
3798                                                prs_struct *ps, int depth)
3799 {
3800         prs_debug(ps, depth, desc, "lsa_io_q_query_trusted_domain_info_by_sid");
3801         depth++;
3802
3803         if(!prs_align(ps))
3804                 return False;
3805
3806         if(!smb_io_pol_hnd("pol", &q_q->pol, ps, depth))
3807                 return False;
3808
3809         if(!prs_align(ps))
3810                 return False;
3811
3812         if(!smb_io_dom_sid2("dom_sid", &q_q->dom_sid, ps, depth))
3813                 return False;
3814
3815         if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
3816                 return False;
3817
3818         return True;
3819 }
3820
3821 /*******************************************************************
3822  Reads or writes an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_NAME structure.
3823 ********************************************************************/
3824
3825 BOOL lsa_io_q_query_trusted_domain_info_by_name(const char *desc,
3826                                                 LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_NAME *q_q,
3827                                                 prs_struct *ps, int depth)
3828 {
3829         prs_debug(ps, depth, desc, "lsa_io_q_query_trusted_domain_info_by_name");
3830         depth++;
3831
3832         if(!prs_align(ps))
3833                 return False;
3834
3835         if(!smb_io_pol_hnd("pol", &q_q->pol, ps, depth))
3836                 return False;
3837
3838         if(!prs_align(ps))
3839                 return False;
3840
3841         if(!smb_io_lsa_string("domain_name", &q_q->domain_name, ps, depth))
3842                 return False;
3843
3844         if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
3845                 return False;
3846
3847         return True;
3848 }
3849
3850 /*******************************************************************
3851 ********************************************************************/
3852
3853 static BOOL smb_io_lsa_data_buf_hdr(const char *desc, LSA_DATA_BUF_HDR *buf_hdr,
3854                                     prs_struct *ps, int depth)
3855 {
3856         prs_debug(ps, depth, desc, "smb_io_lsa_data_buf_hdr");
3857         depth++;
3858
3859         if(!prs_align(ps))
3860                 return False;
3861
3862         if(!prs_uint32("length", ps, depth, &buf_hdr->length))
3863                 return False;
3864
3865         if(!prs_uint32("size", ps, depth, &buf_hdr->size))
3866                 return False;
3867
3868         if (!prs_uint32("data_ptr", ps, depth, &buf_hdr->data_ptr))
3869                 return False;
3870
3871         return True;
3872 }
3873
3874 /*******************************************************************
3875 ********************************************************************/
3876
3877 static BOOL smb_io_lsa_data_buf(const char *desc, LSA_DATA_BUF *buf,
3878                                 prs_struct *ps, int depth, int length, int size)
3879 {
3880         prs_debug(ps, depth, desc, "smb_io_lsa_data_buf");
3881         depth++;
3882
3883         if ( UNMARSHALLING(ps) ) {
3884                 if ( !(buf->data = PRS_ALLOC_MEM( ps, uint8, length )) )
3885                         return False;
3886         }
3887
3888         if (!prs_uint32("size", ps, depth, &buf->size))
3889                 return False;
3890
3891         if (!prs_uint32("offset", ps, depth, &buf->offset))
3892                 return False;
3893
3894         if (!prs_uint32("length", ps, depth, &buf->length))
3895                 return False;
3896
3897         if(!prs_uint8s(False, "data", ps, depth, buf->data, size))
3898                 return False;
3899
3900         return True;
3901 }
3902
3903 /*******************************************************************
3904 ********************************************************************/
3905
3906 static BOOL lsa_io_trustdom_query_1(const char *desc, TRUSTED_DOMAIN_INFO_NAME *name,
3907                                     prs_struct *ps, int depth)
3908 {
3909         if (!smb_io_lsa_string("netbios_name", &name->netbios_name, ps, depth))
3910                 return False;
3911
3912         return True;
3913 }
3914
3915 /*******************************************************************
3916 ********************************************************************/
3917
3918 static BOOL lsa_io_trustdom_query_3(const char *desc, TRUSTED_DOMAIN_INFO_POSIX_OFFSET *posix,
3919                                     prs_struct *ps, int depth)
3920 {
3921         if(!prs_uint32("posix_offset", ps, depth, &posix->posix_offset))
3922                 return False;
3923
3924         return True;
3925 }
3926
3927 /*******************************************************************
3928 ********************************************************************/
3929
3930 static BOOL lsa_io_trustdom_query_4(const char *desc, TRUSTED_DOMAIN_INFO_PASSWORD *password,
3931                                     prs_struct *ps, int depth)
3932 {
3933         if(!prs_align(ps))
3934                 return False;
3935
3936         if(!prs_uint32("ptr_password", ps, depth, &password->ptr_password))
3937                 return False;
3938
3939         if(!prs_uint32("ptr_old_password", ps, depth, &password->ptr_old_password))
3940                 return False;
3941
3942         if (&password->ptr_password) {
3943
3944                 if (!smb_io_lsa_data_buf_hdr("password_hdr", &password->password_hdr, ps, depth))
3945                         return False;
3946
3947                 if (!smb_io_lsa_data_buf("password", &password->password, ps, depth,
3948                                         password->password_hdr.length, password->password_hdr.size))
3949                         return False;
3950         }
3951
3952         if (&password->ptr_old_password) {
3953
3954                 if (!smb_io_lsa_data_buf_hdr("old_password_hdr", &password->old_password_hdr, ps, depth))
3955                         return False;
3956
3957                 if (!smb_io_lsa_data_buf("old_password", &password->old_password, ps, depth,
3958                                         password->old_password_hdr.length, password->old_password_hdr.size))
3959                         return False;
3960         }
3961
3962         return True;
3963 }
3964
3965 /*******************************************************************
3966 ********************************************************************/
3967
3968 static BOOL lsa_io_trustdom_query_6(const char *desc, TRUSTED_DOMAIN_INFO_EX *info_ex,
3969                                     prs_struct *ps, int depth)
3970 {
3971         uint32 dom_sid_ptr;
3972
3973         if (!smb_io_unihdr("domain_name_hdr", &info_ex->domain_name.hdr, ps, depth))
3974                 return False;
3975
3976         if (!smb_io_unihdr("netbios_name_hdr", &info_ex->netbios_name.hdr, ps, depth))
3977                 return False;
3978
3979         if (!prs_uint32("dom_sid_ptr", ps, depth, &dom_sid_ptr))
3980                 return False;
3981
3982         if (!prs_uint32("trust_direction", ps, depth, &info_ex->trust_direction))
3983                 return False;
3984
3985         if (!prs_uint32("trust_type", ps, depth, &info_ex->trust_type))
3986                 return False;
3987
3988         if (!prs_uint32("trust_attributes", ps, depth, &info_ex->trust_attributes))
3989                 return False;
3990
3991         if (!smb_io_unistr2("domain_name_unistring", &info_ex->domain_name.unistring, info_ex->domain_name.hdr.buffer, ps, depth))
3992                 return False;
3993
3994         if (!smb_io_unistr2("netbios_name_unistring", &info_ex->netbios_name.unistring, info_ex->netbios_name.hdr.buffer, ps, depth))
3995                 return False;
3996
3997         if (!smb_io_dom_sid2("sid", &info_ex->sid, ps, depth))
3998                 return False;
3999
4000         return True;
4001 }
4002
4003 /*******************************************************************
4004 ********************************************************************/
4005
4006 static BOOL lsa_io_trustdom_query(const char *desc, prs_struct *ps, int depth, LSA_TRUSTED_DOMAIN_INFO *info)
4007 {
4008         prs_debug(ps, depth, desc, "lsa_io_trustdom_query");
4009         depth++;
4010
4011         if(!prs_uint16("info_class", ps, depth, &info->info_class))
4012                 return False;
4013
4014         if(!prs_align(ps))
4015                 return False;
4016
4017         switch (info->info_class) {
4018         case 1:
4019                 if(!lsa_io_trustdom_query_1("name", &info->name, ps, depth))
4020                         return False;
4021                 break;
4022         case 3:
4023                 if(!lsa_io_trustdom_query_3("posix_offset", &info->posix_offset, ps, depth))
4024                         return False;
4025                 break;
4026         case 4:
4027                 if(!lsa_io_trustdom_query_4("password", &info->password, ps, depth))
4028                         return False;
4029                 break;
4030         case 6:
4031                 if(!lsa_io_trustdom_query_6("info_ex", &info->info_ex, ps, depth))
4032                         return False;
4033                 break;
4034         default:
4035                 DEBUG(0,("unsupported info-level: %d\n", info->info_class));
4036                 return False;
4037         }
4038
4039         return True;
4040 }
4041
4042 /*******************************************************************
4043  Reads or writes an LSA_R_QUERY_TRUSTED_DOMAIN_INFO structure.
4044 ********************************************************************/
4045
4046 BOOL lsa_io_r_query_trusted_domain_info(const char *desc,
4047                                         LSA_R_QUERY_TRUSTED_DOMAIN_INFO *r_q,
4048                                         prs_struct *ps, int depth)
4049 {
4050         if (r_q == NULL)
4051                 return False;
4052
4053         prs_debug(ps, depth, desc, "lsa_io_r_query_trusted_domain_info");
4054         depth++;
4055
4056         if (!prs_pointer("trustdom", ps, depth, (void**)&r_q->info,
4057                          sizeof(LSA_TRUSTED_DOMAIN_INFO),
4058                          (PRS_POINTER_CAST)lsa_io_trustdom_query) )
4059                 return False;
4060
4061         if(!prs_align(ps))
4062                 return False;
4063
4064         if(!prs_ntstatus("status", ps, depth, &r_q->status))
4065                 return False;
4066
4067         return True;
4068 }
4069
4070 /*******************************************************************
4071  Inits an LSA_Q_QUERY_DOM_INFO_POLICY structure.
4072 ********************************************************************/
4073
4074 void init_q_query_dom_info(LSA_Q_QUERY_DOM_INFO_POLICY *in, POLICY_HND *hnd, uint16 info_class)
4075 {
4076         DEBUG(5, ("init_q_query_dom_info\n"));
4077
4078         memcpy(&in->pol, hnd, sizeof(in->pol));
4079
4080         in->info_class = info_class;
4081 }
4082
4083 /*******************************************************************
4084  Reads or writes an LSA_Q_QUERY_DOM_INFO_POLICY structure.
4085 ********************************************************************/
4086
4087 BOOL lsa_io_q_query_dom_info(const char *desc, LSA_Q_QUERY_DOM_INFO_POLICY *in, prs_struct *ps, int depth)
4088 {
4089         prs_debug(ps, depth, desc, "lsa_io_q_query_dom_info");
4090         depth++;
4091
4092         if(!prs_align(ps))
4093                 return False;
4094
4095         if(!smb_io_pol_hnd("pol", &in->pol, ps, depth))
4096                 return False;
4097
4098         if(!prs_uint16("info_class", ps, depth, &in->info_class))
4099                 return False;
4100
4101         return True;
4102 }
4103
4104 /*******************************************************************
4105  Reads or writes an LSA_R_QUERY_DOM_INFO_POLICY structure.
4106 ********************************************************************/
4107
4108 static BOOL lsa_io_dominfo_query_3(const char *desc, LSA_DOM_INFO_POLICY_KERBEROS *krb_policy,
4109                                    prs_struct *ps, int depth)
4110 {
4111         if (!prs_align_uint64(ps))
4112                 return False;
4113
4114         if (!prs_align(ps))
4115                 return False;
4116
4117         if (!prs_uint32("enforce_restrictions", ps, depth, &krb_policy->enforce_restrictions))
4118                 return False;
4119
4120         if (!prs_align_uint64(ps))
4121                 return False;
4122
4123         if (!smb_io_nttime("service_tkt_lifetime", ps, depth, &krb_policy->service_tkt_lifetime))
4124                 return False;
4125
4126         if (!prs_align_uint64(ps))
4127                 return False;
4128
4129         if (!smb_io_nttime("user_tkt_lifetime", ps, depth, &krb_policy->user_tkt_lifetime))
4130                 return False;
4131
4132         if (!prs_align_uint64(ps))
4133                 return False;
4134
4135         if (!smb_io_nttime("user_tkt_renewaltime", ps, depth, &krb_policy->user_tkt_renewaltime))
4136                 return False;
4137
4138         if (!prs_align_uint64(ps))
4139                 return False;
4140
4141         if (!smb_io_nttime("clock_skew", ps, depth, &krb_policy->clock_skew))
4142                 return False;
4143
4144         if (!prs_align_uint64(ps))
4145                 return False;
4146
4147         if (!smb_io_nttime("unknown6", ps, depth, &krb_policy->unknown6))
4148                 return False;
4149
4150         return True;
4151 }
4152
4153 static BOOL lsa_io_dom_info_query(const char *desc, prs_struct *ps, int depth, LSA_DOM_INFO_UNION *info)
4154 {
4155         prs_debug(ps, depth, desc, "lsa_io_dom_info_query");
4156         depth++;
4157
4158         if(!prs_align_uint16(ps))
4159                 return False;
4160
4161         if(!prs_uint16("info_class", ps, depth, &info->info_class))
4162                 return False;
4163
4164         switch (info->info_class) {
4165         case 3:
4166                 if (!lsa_io_dominfo_query_3("krb_policy", &info->krb_policy, ps, depth))
4167                         return False;
4168                 break;
4169         default:
4170                 DEBUG(0,("unsupported info-level: %d\n", info->info_class));
4171                 return False;
4172                 break;
4173         }
4174
4175         return True;
4176 }
4177
4178
4179 BOOL lsa_io_r_query_dom_info(const char *desc, LSA_R_QUERY_DOM_INFO_POLICY *out,
4180                              prs_struct *ps, int depth)
4181 {
4182         prs_debug(ps, depth, desc, "lsa_io_r_query_dom_info");
4183         depth++;
4184
4185         if (!prs_pointer("dominfo", ps, depth, (void**)&out->info,
4186                          sizeof(LSA_DOM_INFO_UNION),
4187                          (PRS_POINTER_CAST)lsa_io_dom_info_query) )
4188                 return False;
4189
4190         if(!prs_ntstatus("status", ps, depth, &out->status))
4191                 return False;
4192
4193         return True;
4194 }