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