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