source/rpc_parse/parse_lsa.c

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