source3/rpc_parse/parse_lsa.c

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