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_uint32("lookup_level   ", ps, depth, &q_r->lookup_level))
1372                 return False;
1373         if(!prs_uint32("mapped_count   ", ps, depth, &q_r->mapped_count))
1374                 return False;
1375
1376         return True;
1377 }
1378
1379 /*******************************************************************
1380 reads or writes a structure.
1381 ********************************************************************/
1382
1383 BOOL lsa_io_r_lookup_names(const char *desc, LSA_R_LOOKUP_NAMES *out, prs_struct *ps, int depth)
1384 {
1385         unsigned int i;
1386
1387         prs_debug(ps, depth, desc, "lsa_io_r_lookup_names");
1388         depth++;
1389
1390         if(!prs_align(ps))
1391                 return False;
1392
1393         if(!prs_uint32("ptr_dom_ref", ps, depth, &out->ptr_dom_ref))
1394                 return False;
1395
1396         if (out->ptr_dom_ref != 0)
1397                 if(!lsa_io_dom_r_ref("", out->dom_ref, ps, depth))
1398                         return False;
1399
1400         if(!prs_uint32("num_entries", ps, depth, &out->num_entries))
1401                 return False;
1402         if(!prs_uint32("ptr_entries", ps, depth, &out->ptr_entries))
1403                 return False;
1404
1405         if (out->ptr_entries != 0) {
1406                 if(!prs_uint32("num_entries2", ps, depth, &out->num_entries2))
1407                         return False;
1408
1409                 if (out->num_entries2 != out->num_entries) {
1410                         /* RPC fault */
1411                         return False;
1412                 }
1413
1414                 if (UNMARSHALLING(ps)) {
1415                         if ((out->dom_rid = PRS_ALLOC_MEM(ps, DOM_RID2, out->num_entries2))
1416                             == NULL) {
1417                                 DEBUG(3, ("lsa_io_r_lookup_names(): out of memory\n"));
1418                                 return False;
1419                         }
1420                 }
1421
1422                 for (i = 0; i < out->num_entries2; i++)
1423                         if(!smb_io_dom_rid2("", &out->dom_rid[i], ps, depth)) /* domain RIDs being looked up */
1424                                 return False;
1425         }
1426
1427         if(!prs_uint32("mapped_count", ps, depth, &out->mapped_count))
1428                 return False;
1429
1430         if(!prs_ntstatus("status      ", ps, depth, &out->status))
1431                 return False;
1432
1433         return True;
1434 }
1435
1436
1437 /*******************************************************************
1438  Inits an LSA_Q_CLOSE structure.
1439 ********************************************************************/
1440
1441 void init_lsa_q_close(LSA_Q_CLOSE *in, POLICY_HND *hnd)
1442 {
1443         DEBUG(5, ("init_lsa_q_close\n"));
1444
1445         memcpy(&in->pol, hnd, sizeof(in->pol));
1446 }
1447
1448 /*******************************************************************
1449  Reads or writes an LSA_Q_CLOSE structure.
1450 ********************************************************************/
1451
1452 BOOL lsa_io_q_close(const char *desc, LSA_Q_CLOSE *in, prs_struct *ps, int depth)
1453 {
1454         prs_debug(ps, depth, desc, "lsa_io_q_close");
1455         depth++;
1456
1457         if(!smb_io_pol_hnd("", &in->pol, ps, depth))
1458                 return False;
1459
1460         return True;
1461 }
1462
1463 /*******************************************************************
1464  Reads or writes an LSA_R_CLOSE structure.
1465 ********************************************************************/
1466
1467 BOOL lsa_io_r_close(const char *desc,  LSA_R_CLOSE *out, prs_struct *ps, int depth)
1468 {
1469         prs_debug(ps, depth, desc, "lsa_io_r_close");
1470         depth++;
1471
1472         if(!smb_io_pol_hnd("", &out->pol, ps, depth))
1473                 return False;
1474
1475         if(!prs_ntstatus("status", ps, depth, &out->status))
1476                 return False;
1477
1478         return True;
1479 }
1480
1481 /*******************************************************************
1482  Reads or writes an LSA_Q_OPEN_SECRET structure.
1483 ********************************************************************/
1484
1485 BOOL lsa_io_q_open_secret(const char *desc, LSA_Q_OPEN_SECRET *in, prs_struct *ps, int depth)
1486 {
1487         prs_debug(ps, depth, desc, "lsa_io_q_open_secret");
1488         depth++;
1489
1490         if(!prs_align(ps))
1491                 return False;
1492
1493         if(!smb_io_pol_hnd("", &in->handle, ps, depth))
1494                 return False;
1495
1496         if(!prs_unistr4 ("secretname", ps, depth, &in->secretname))
1497                 return False;
1498         if(!prs_align(ps))
1499                 return False;
1500
1501         if(!prs_uint32("access", ps, depth, &in->access))
1502                 return False;
1503
1504         return True;
1505 }
1506
1507 /*******************************************************************
1508  Reads or writes an LSA_R_OPEN_SECRET structure.
1509 ********************************************************************/
1510
1511 BOOL lsa_io_r_open_secret(const char *desc, LSA_R_OPEN_SECRET *out, prs_struct *ps, int depth)
1512 {
1513         prs_debug(ps, depth, desc, "lsa_io_r_open_secret");
1514         depth++;
1515
1516         if(!prs_align(ps))
1517                 return False;
1518
1519         if(!smb_io_pol_hnd("", &out->handle, ps, depth))
1520                 return False;
1521
1522         if(!prs_ntstatus("status", ps, depth, &out->status))
1523                 return False;
1524
1525         return True;
1526 }
1527
1528 /*******************************************************************
1529  Inits an LSA_Q_ENUM_PRIVS structure.
1530 ********************************************************************/
1531
1532 void init_q_enum_privs(LSA_Q_ENUM_PRIVS *in, POLICY_HND *hnd, uint32 enum_context, uint32 pref_max_length)
1533 {
1534         DEBUG(5, ("init_q_enum_privs\n"));
1535
1536         memcpy(&in->pol, hnd, sizeof(in->pol));
1537
1538         in->enum_context = enum_context;
1539         in->pref_max_length = pref_max_length;
1540 }
1541
1542 /*******************************************************************
1543 reads or writes a structure.
1544 ********************************************************************/
1545 BOOL lsa_io_q_enum_privs(const char *desc, LSA_Q_ENUM_PRIVS *in, prs_struct *ps, int depth)
1546 {
1547         if (in == NULL)
1548                 return False;
1549
1550         prs_debug(ps, depth, desc, "lsa_io_q_enum_privs");
1551         depth++;
1552
1553         if (!smb_io_pol_hnd("", &in->pol, ps, depth))
1554                 return False;
1555
1556         if(!prs_uint32("enum_context   ", ps, depth, &in->enum_context))
1557                 return False;
1558         if(!prs_uint32("pref_max_length", ps, depth, &in->pref_max_length))
1559                 return False;
1560
1561         return True;
1562 }
1563
1564 /*******************************************************************
1565 reads or writes a structure.
1566 ********************************************************************/
1567 static BOOL lsa_io_priv_entries(const char *desc, LSA_PRIV_ENTRY *entries, uint32 count, prs_struct *ps, int depth)
1568 {
1569         uint32 i;
1570
1571         if (entries == NULL)
1572                 return False;
1573
1574         prs_debug(ps, depth, desc, "lsa_io_priv_entries");
1575         depth++;
1576
1577         if(!prs_align(ps))
1578                 return False;
1579
1580         for (i = 0; i < count; i++) {
1581                 if (!smb_io_unihdr("", &entries[i].hdr_name, ps, depth))
1582                         return False;
1583                 if(!prs_uint32("luid_low ", ps, depth, &entries[i].luid_low))
1584                         return False;
1585                 if(!prs_uint32("luid_high", ps, depth, &entries[i].luid_high))
1586                         return False;
1587         }
1588
1589         for (i = 0; i < count; i++)
1590                 if (!smb_io_unistr2("", &entries[i].name, entries[i].hdr_name.buffer, ps, depth))
1591                         return False;
1592
1593         return True;
1594 }
1595
1596 /*******************************************************************
1597  Inits an LSA_R_ENUM_PRIVS structure.
1598 ********************************************************************/
1599
1600 void init_lsa_r_enum_privs(LSA_R_ENUM_PRIVS *out, uint32 enum_context,
1601                           uint32 count, LSA_PRIV_ENTRY *entries)
1602 {
1603         DEBUG(5, ("init_lsa_r_enum_privs\n"));
1604
1605         out->enum_context=enum_context;
1606         out->count=count;
1607
1608         if (entries!=NULL) {
1609                 out->ptr=1;
1610                 out->count1=count;
1611                 out->privs=entries;
1612         } else {
1613                 out->ptr=0;
1614                 out->count1=0;
1615                 out->privs=NULL;
1616         }
1617 }
1618
1619 /*******************************************************************
1620 reads or writes a structure.
1621 ********************************************************************/
1622 BOOL lsa_io_r_enum_privs(const char *desc, LSA_R_ENUM_PRIVS *out, prs_struct *ps, int depth)
1623 {
1624         if (out == NULL)
1625                 return False;
1626
1627         prs_debug(ps, depth, desc, "lsa_io_r_enum_privs");
1628         depth++;
1629
1630         if(!prs_align(ps))
1631                 return False;
1632
1633         if(!prs_uint32("enum_context", ps, depth, &out->enum_context))
1634                 return False;
1635         if(!prs_uint32("count", ps, depth, &out->count))
1636                 return False;
1637         if(!prs_uint32("ptr", ps, depth, &out->ptr))
1638                 return False;
1639
1640         if (out->ptr) {
1641                 if(!prs_uint32("count1", ps, depth, &out->count1))
1642                         return False;
1643
1644                 if (UNMARSHALLING(ps))
1645                         if (!(out->privs = PRS_ALLOC_MEM(ps, LSA_PRIV_ENTRY, out->count1)))
1646                                 return False;
1647
1648                 if (!lsa_io_priv_entries("", out->privs, out->count1, ps, depth))
1649                         return False;
1650         }
1651
1652         if(!prs_align(ps))
1653                 return False;
1654
1655         if(!prs_ntstatus("status", ps, depth, &out->status))
1656                 return False;
1657
1658         return True;
1659 }
1660
1661 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)
1662 {
1663         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1664
1665         init_unistr2(&trn->name, name, UNI_FLAGS_NONE);
1666         init_uni_hdr(&trn->hdr_name, &trn->name);
1667         trn->lang_id = lang_id;
1668         trn->lang_id_sys = lang_id_sys;
1669 }
1670
1671 /*******************************************************************
1672 reads or writes a structure.
1673 ********************************************************************/
1674 BOOL lsa_io_q_priv_get_dispname(const char *desc, LSA_Q_PRIV_GET_DISPNAME *in, prs_struct *ps, int depth)
1675 {
1676         if (in == NULL)
1677                 return False;
1678
1679         prs_debug(ps, depth, desc, "lsa_io_q_priv_get_dispname");
1680         depth++;
1681
1682         if(!prs_align(ps))
1683                 return False;
1684
1685         if (!smb_io_pol_hnd("", &in->pol, ps, depth))
1686                 return False;
1687
1688         if (!smb_io_unihdr("hdr_name", &in->hdr_name, ps, depth))
1689                 return False;
1690
1691         if (!smb_io_unistr2("name", &in->name, in->hdr_name.buffer, ps, depth))
1692                 return False;
1693
1694         if(!prs_uint16("lang_id    ", ps, depth, &in->lang_id))
1695                 return False;
1696         if(!prs_uint16("lang_id_sys", ps, depth, &in->lang_id_sys))
1697                 return False;
1698
1699         return True;
1700 }
1701
1702 /*******************************************************************
1703 reads or writes a structure.
1704 ********************************************************************/
1705 BOOL lsa_io_r_priv_get_dispname(const char *desc, LSA_R_PRIV_GET_DISPNAME *out, prs_struct *ps, int depth)
1706 {
1707         if (out == NULL)
1708                 return False;
1709
1710         prs_debug(ps, depth, desc, "lsa_io_r_priv_get_dispname");
1711         depth++;
1712
1713         if (!prs_align(ps))
1714                 return False;
1715
1716         if (!prs_uint32("ptr_info", ps, depth, &out->ptr_info))
1717                 return False;
1718
1719         if (out->ptr_info){
1720                 if (!smb_io_unihdr("hdr_name", &out->hdr_desc, ps, depth))
1721                         return False;
1722
1723                 if (!smb_io_unistr2("desc", &out->desc, out->hdr_desc.buffer, ps, depth))
1724                         return False;
1725         }
1726 /*
1727         if(!prs_align(ps))
1728                 return False;
1729 */
1730         if(!prs_uint16("lang_id", ps, depth, &out->lang_id))
1731                 return False;
1732
1733         if(!prs_align(ps))
1734                 return False;
1735         if(!prs_ntstatus("status", ps, depth, &out->status))
1736                 return False;
1737
1738         return True;
1739 }
1740
1741 /*
1742   initialise a LSA_Q_ENUM_ACCOUNTS structure
1743 */
1744 void init_lsa_q_enum_accounts(LSA_Q_ENUM_ACCOUNTS *trn, POLICY_HND *hnd, uint32 enum_context, uint32 pref_max_length)
1745 {
1746         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1747
1748         trn->enum_context = enum_context;
1749         trn->pref_max_length = pref_max_length;
1750 }
1751
1752 /*******************************************************************
1753 reads or writes a structure.
1754 ********************************************************************/
1755 BOOL lsa_io_q_enum_accounts(const char *desc, LSA_Q_ENUM_ACCOUNTS *in, prs_struct *ps, int depth)
1756 {
1757         if (in == NULL)
1758                 return False;
1759
1760         prs_debug(ps, depth, desc, "lsa_io_q_enum_accounts");
1761         depth++;
1762
1763         if (!smb_io_pol_hnd("", &in->pol, ps, depth))
1764                 return False;
1765
1766         if(!prs_uint32("enum_context   ", ps, depth, &in->enum_context))
1767                 return False;
1768         if(!prs_uint32("pref_max_length", ps, depth, &in->pref_max_length))
1769                 return False;
1770
1771         return True;
1772 }
1773
1774
1775 /*******************************************************************
1776  Inits an LSA_R_ENUM_PRIVS structure.
1777 ********************************************************************/
1778
1779 void init_lsa_r_enum_accounts(LSA_R_ENUM_ACCOUNTS *out, uint32 enum_context)
1780 {
1781         DEBUG(5, ("init_lsa_r_enum_accounts\n"));
1782
1783         out->enum_context=enum_context;
1784         if (out->enum_context!=0) {
1785                 out->sids.num_entries=enum_context;
1786                 out->sids.ptr_sid_enum=1;
1787                 out->sids.num_entries2=enum_context;
1788         } else {
1789                 out->sids.num_entries=0;
1790                 out->sids.ptr_sid_enum=0;
1791                 out->sids.num_entries2=0;
1792         }
1793 }
1794
1795 /*******************************************************************
1796 reads or writes a structure.
1797 ********************************************************************/
1798 BOOL lsa_io_r_enum_accounts(const char *desc, LSA_R_ENUM_ACCOUNTS *out, prs_struct *ps, int depth)
1799 {
1800         if (out == NULL)
1801                 return False;
1802
1803         prs_debug(ps, depth, desc, "lsa_io_r_enum_accounts");
1804         depth++;
1805
1806         if (!prs_align(ps))
1807                 return False;
1808
1809         if(!prs_uint32("enum_context", ps, depth, &out->enum_context))
1810                 return False;
1811
1812         if (!lsa_io_sid_enum("sids", &out->sids, ps, depth))
1813                 return False;
1814
1815         if (!prs_align(ps))
1816                 return False;
1817
1818         if(!prs_ntstatus("status", ps, depth, &out->status))
1819                 return False;
1820
1821         return True;
1822 }
1823
1824
1825 /*******************************************************************
1826  Reads or writes an LSA_Q_UNK_GET_CONNUSER structure.
1827 ********************************************************************/
1828
1829 BOOL lsa_io_q_unk_get_connuser(const char *desc, LSA_Q_UNK_GET_CONNUSER *in, prs_struct *ps, int depth)
1830 {
1831         prs_debug(ps, depth, desc, "lsa_io_q_unk_get_connuser");
1832         depth++;
1833
1834         if(!prs_align(ps))
1835                 return False;
1836
1837         if(!prs_uint32("ptr_srvname", ps, depth, &in->ptr_srvname))
1838                 return False;
1839
1840         if(!smb_io_unistr2("uni2_srvname", &in->uni2_srvname, in->ptr_srvname, ps, depth)) /* server name to be looked up */
1841                 return False;
1842
1843         if (!prs_align(ps))
1844           return False;
1845
1846         if(!prs_uint32("unk1", ps, depth, &in->unk1))
1847                 return False;
1848         if(!prs_uint32("unk2", ps, depth, &in->unk2))
1849                 return False;
1850         if(!prs_uint32("unk3", ps, depth, &in->unk3))
1851                 return False;
1852
1853         /* Don't bother to read or write at present... */
1854         return True;
1855 }
1856
1857 /*******************************************************************
1858  Reads or writes an LSA_R_UNK_GET_CONNUSER structure.
1859 ********************************************************************/
1860
1861 BOOL lsa_io_r_unk_get_connuser(const char *desc, LSA_R_UNK_GET_CONNUSER *out, prs_struct *ps, int depth)
1862 {
1863         prs_debug(ps, depth, desc, "lsa_io_r_unk_get_connuser");
1864         depth++;
1865
1866         if(!prs_align(ps))
1867                 return False;
1868
1869         if(!prs_uint32("ptr_user_name", ps, depth, &out->ptr_user_name))
1870                 return False;
1871         if(!smb_io_unihdr("hdr_user_name", &out->hdr_user_name, ps, depth))
1872                 return False;
1873         if(!smb_io_unistr2("uni2_user_name", &out->uni2_user_name, out->ptr_user_name, ps, depth))
1874                 return False;
1875
1876         if (!prs_align(ps))
1877           return False;
1878
1879         if(!prs_uint32("unk1", ps, depth, &out->unk1))
1880                 return False;
1881
1882         if(!prs_uint32("ptr_dom_name", ps, depth, &out->ptr_dom_name))
1883                 return False;
1884         if(!smb_io_unihdr("hdr_dom_name", &out->hdr_dom_name, ps, depth))
1885                 return False;
1886         if(!smb_io_unistr2("uni2_dom_name", &out->uni2_dom_name, out->ptr_dom_name, ps, depth))
1887                 return False;
1888
1889         if (!prs_align(ps))
1890           return False;
1891
1892         if(!prs_ntstatus("status", ps, depth, &out->status))
1893                 return False;
1894
1895         return True;
1896 }
1897
1898 void init_lsa_q_create_account(LSA_Q_CREATEACCOUNT *trn, POLICY_HND *hnd, DOM_SID *sid, uint32 desired_access)
1899 {
1900         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1901
1902         init_dom_sid2(&trn->sid, sid);
1903         trn->access = desired_access;
1904 }
1905
1906
1907 /*******************************************************************
1908  Reads or writes an LSA_Q_CREATEACCOUNT structure.
1909 ********************************************************************/
1910
1911 BOOL lsa_io_q_create_account(const char *desc, LSA_Q_CREATEACCOUNT *out, prs_struct *ps, int depth)
1912 {
1913         prs_debug(ps, depth, desc, "lsa_io_q_create_account");
1914         depth++;
1915
1916         if(!prs_align(ps))
1917                 return False;
1918
1919         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
1920                 return False;
1921
1922         if(!smb_io_dom_sid2("sid", &out->sid, ps, depth)) /* domain SID */
1923                 return False;
1924
1925         if(!prs_uint32("access", ps, depth, &out->access))
1926                 return False;
1927
1928         return True;
1929 }
1930
1931 /*******************************************************************
1932  Reads or writes an LSA_R_CREATEACCOUNT structure.
1933 ********************************************************************/
1934
1935 BOOL lsa_io_r_create_account(const char *desc, LSA_R_CREATEACCOUNT  *out, prs_struct *ps, int depth)
1936 {
1937         prs_debug(ps, depth, desc, "lsa_io_r_open_account");
1938         depth++;
1939
1940         if(!prs_align(ps))
1941                 return False;
1942
1943         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
1944                 return False;
1945
1946         if(!prs_ntstatus("status", ps, depth, &out->status))
1947                 return False;
1948
1949         return True;
1950 }
1951
1952
1953 void init_lsa_q_open_account(LSA_Q_OPENACCOUNT *trn, POLICY_HND *hnd, DOM_SID *sid, uint32 desired_access)
1954 {
1955         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1956
1957         init_dom_sid2(&trn->sid, sid);
1958         trn->access = desired_access;
1959 }
1960
1961 /*******************************************************************
1962  Reads or writes an LSA_Q_OPENACCOUNT structure.
1963 ********************************************************************/
1964
1965 BOOL lsa_io_q_open_account(const char *desc, LSA_Q_OPENACCOUNT *out, prs_struct *ps, int depth)
1966 {
1967         prs_debug(ps, depth, desc, "lsa_io_q_open_account");
1968         depth++;
1969
1970         if(!prs_align(ps))
1971                 return False;
1972
1973         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
1974                 return False;
1975
1976         if(!smb_io_dom_sid2("sid", &out->sid, ps, depth)) /* domain SID */
1977                 return False;
1978
1979         if(!prs_uint32("access", ps, depth, &out->access))
1980                 return False;
1981
1982         return True;
1983 }
1984
1985 /*******************************************************************
1986  Reads or writes an LSA_R_OPENACCOUNT structure.
1987 ********************************************************************/
1988
1989 BOOL lsa_io_r_open_account(const char *desc, LSA_R_OPENACCOUNT  *out, prs_struct *ps, int depth)
1990 {
1991         prs_debug(ps, depth, desc, "lsa_io_r_open_account");
1992         depth++;
1993
1994         if(!prs_align(ps))
1995                 return False;
1996
1997         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
1998                 return False;
1999
2000         if(!prs_ntstatus("status", ps, depth, &out->status))
2001                 return False;
2002
2003         return True;
2004 }
2005
2006
2007 void init_lsa_q_enum_privsaccount(LSA_Q_ENUMPRIVSACCOUNT *trn, POLICY_HND *hnd)
2008 {
2009         memcpy(&trn->pol, hnd, sizeof(trn->pol));
2010
2011 }
2012
2013 /*******************************************************************
2014  Reads or writes an LSA_Q_ENUMPRIVSACCOUNT structure.
2015 ********************************************************************/
2016
2017 BOOL lsa_io_q_enum_privsaccount(const char *desc, LSA_Q_ENUMPRIVSACCOUNT *out, prs_struct *ps, int depth)
2018 {
2019         prs_debug(ps, depth, desc, "lsa_io_q_enum_privsaccount");
2020         depth++;
2021
2022         if(!prs_align(ps))
2023                 return False;
2024
2025         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2026                 return False;
2027
2028         return True;
2029 }
2030
2031 /*******************************************************************
2032  Reads or writes an LUID structure.
2033 ********************************************************************/
2034
2035 static BOOL lsa_io_luid(const char *desc, LUID *out, prs_struct *ps, int depth)
2036 {
2037         prs_debug(ps, depth, desc, "lsa_io_luid");
2038         depth++;
2039
2040         if(!prs_align(ps))
2041                 return False;
2042
2043         if(!prs_uint32("low", ps, depth, &out->low))
2044                 return False;
2045
2046         if(!prs_uint32("high", ps, depth, &out->high))
2047                 return False;
2048
2049         return True;
2050 }
2051
2052 /*******************************************************************
2053  Reads or writes an LUID_ATTR structure.
2054 ********************************************************************/
2055
2056 static BOOL lsa_io_luid_attr(const char *desc, LUID_ATTR *out, prs_struct *ps, int depth)
2057 {
2058         prs_debug(ps, depth, desc, "lsa_io_luid_attr");
2059         depth++;
2060
2061         if(!prs_align(ps))
2062                 return False;
2063
2064         if (!lsa_io_luid(desc, &out->luid, ps, depth))
2065                 return False;
2066
2067         if(!prs_uint32("attr", ps, depth, &out->attr))
2068                 return False;
2069
2070         return True;
2071 }
2072
2073 /*******************************************************************
2074  Reads or writes an PRIVILEGE_SET structure.
2075 ********************************************************************/
2076
2077 static BOOL lsa_io_privilege_set(const char *desc, PRIVILEGE_SET *out, prs_struct *ps, int depth)
2078 {
2079         uint32 i;
2080
2081         prs_debug(ps, depth, desc, "lsa_io_privilege_set");
2082         depth++;
2083
2084         if(!prs_align(ps))
2085                 return False;
2086
2087         if(!prs_uint32("count", ps, depth, &out->count))
2088                 return False;
2089         if(!prs_uint32("control", ps, depth, &out->control))
2090                 return False;
2091
2092         for (i=0; i<out->count; i++) {
2093                 if (!lsa_io_luid_attr(desc, &out->set[i], ps, depth))
2094                         return False;
2095         }
2096
2097         return True;
2098 }
2099
2100 NTSTATUS init_lsa_r_enum_privsaccount(TALLOC_CTX *mem_ctx, LSA_R_ENUMPRIVSACCOUNT *out, LUID_ATTR *set, uint32 count, uint32 control)
2101 {
2102         NTSTATUS ret = NT_STATUS_OK;
2103
2104         out->ptr = 1;
2105         out->count = count;
2106
2107         if ( !NT_STATUS_IS_OK(ret = privilege_set_init_by_ctx(mem_ctx, &(out->set))) )
2108                 return ret;
2109
2110         out->set.count = count;
2111
2112         if (!NT_STATUS_IS_OK(ret = dup_luid_attr(out->set.mem_ctx, &(out->set.set), set, count)))
2113                 return ret;
2114
2115         DEBUG(10,("init_lsa_r_enum_privsaccount: %d privileges\n", out->count));
2116
2117         return ret;
2118 }
2119
2120 /*******************************************************************
2121  Reads or writes an LSA_R_ENUMPRIVSACCOUNT structure.
2122 ********************************************************************/
2123
2124 BOOL lsa_io_r_enum_privsaccount(const char *desc, LSA_R_ENUMPRIVSACCOUNT *out, prs_struct *ps, int depth)
2125 {
2126         prs_debug(ps, depth, desc, "lsa_io_r_enum_privsaccount");
2127         depth++;
2128
2129         if(!prs_align(ps))
2130                 return False;
2131
2132         if(!prs_uint32("ptr", ps, depth, &out->ptr))
2133                 return False;
2134
2135         if (out->ptr!=0) {
2136                 if(!prs_uint32("count", ps, depth, &out->count))
2137                         return False;
2138
2139                 /* malloc memory if unmarshalling here */
2140
2141                 if (UNMARSHALLING(ps) && out->count != 0) {
2142                         if (!NT_STATUS_IS_OK(privilege_set_init_by_ctx(ps->mem_ctx, &(out->set))))
2143                                 return False;
2144
2145                         if (!(out->set.set = PRS_ALLOC_MEM(ps,LUID_ATTR,out->count)))
2146                                 return False;
2147
2148                 }
2149
2150                 if(!lsa_io_privilege_set(desc, &out->set, ps, depth))
2151                         return False;
2152         }
2153
2154         if(!prs_ntstatus("status", ps, depth, &out->status))
2155                 return False;
2156
2157         return True;
2158 }
2159
2160
2161
2162 /*******************************************************************
2163  Reads or writes an  LSA_Q_GETSYSTEMACCOUNTstructure.
2164 ********************************************************************/
2165
2166 BOOL lsa_io_q_getsystemaccount(const char *desc, LSA_Q_GETSYSTEMACCOUNT  *out, prs_struct *ps, int depth)
2167 {
2168         prs_debug(ps, depth, desc, "lsa_io_q_getsystemaccount");
2169         depth++;
2170
2171         if(!prs_align(ps))
2172                 return False;
2173
2174         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2175                 return False;
2176
2177         return True;
2178 }
2179
2180 /*******************************************************************
2181  Reads or writes an  LSA_R_GETSYSTEMACCOUNTstructure.
2182 ********************************************************************/
2183
2184 BOOL lsa_io_r_getsystemaccount(const char *desc, LSA_R_GETSYSTEMACCOUNT  *out, prs_struct *ps, int depth)
2185 {
2186         prs_debug(ps, depth, desc, "lsa_io_r_getsystemaccount");
2187         depth++;
2188
2189         if(!prs_align(ps))
2190                 return False;
2191
2192         if(!prs_uint32("access", ps, depth, &out->access))
2193                 return False;
2194
2195         if(!prs_ntstatus("status", ps, depth, &out->status))
2196                 return False;
2197
2198         return True;
2199 }
2200
2201
2202 /*******************************************************************
2203  Reads or writes an LSA_Q_SETSYSTEMACCOUNT structure.
2204 ********************************************************************/
2205
2206 BOOL lsa_io_q_setsystemaccount(const char *desc, LSA_Q_SETSYSTEMACCOUNT  *out, prs_struct *ps, int depth)
2207 {
2208         prs_debug(ps, depth, desc, "lsa_io_q_setsystemaccount");
2209         depth++;
2210
2211         if(!prs_align(ps))
2212                 return False;
2213
2214         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2215                 return False;
2216
2217         if(!prs_uint32("access", ps, depth, &out->access))
2218                 return False;
2219
2220         return True;
2221 }
2222
2223 /*******************************************************************
2224  Reads or writes an LSA_R_SETSYSTEMACCOUNT structure.
2225 ********************************************************************/
2226
2227 BOOL lsa_io_r_setsystemaccount(const char *desc, LSA_R_SETSYSTEMACCOUNT  *out, prs_struct *ps, int depth)
2228 {
2229         prs_debug(ps, depth, desc, "lsa_io_r_setsystemaccount");
2230         depth++;
2231
2232         if(!prs_align(ps))
2233                 return False;
2234
2235         if(!prs_ntstatus("status", ps, depth, &out->status))
2236                 return False;
2237
2238         return True;
2239 }
2240
2241
2242 static void init_lsa_string( LSA_STRING *uni, const char *string )
2243 {
2244         init_unistr2(&uni->unistring, string, UNI_FLAGS_NONE);
2245         init_uni_hdr(&uni->hdr, &uni->unistring);
2246 }
2247
2248 void init_lsa_q_lookup_priv_value(LSA_Q_LOOKUP_PRIV_VALUE *q_u, POLICY_HND *hnd, const char *name)
2249 {
2250         memcpy(&q_u->pol, hnd, sizeof(q_u->pol));
2251         init_lsa_string( &q_u->privname, name );
2252 }
2253
2254 BOOL smb_io_lsa_string( const char *desc, LSA_STRING *string, prs_struct *ps, int depth )
2255 {
2256         prs_debug(ps, depth, desc, "smb_io_lsa_string");
2257         depth++;
2258
2259         if(!smb_io_unihdr ("hdr", &string->hdr, ps, depth))
2260                 return False;
2261         if(!smb_io_unistr2("unistring", &string->unistring, string->hdr.buffer, ps, depth))
2262                 return False;
2263
2264         return True;
2265 }
2266
2267 /*******************************************************************
2268  Reads or writes an LSA_Q_LOOKUP_PRIV_VALUE  structure.
2269 ********************************************************************/
2270
2271 BOOL lsa_io_q_lookup_priv_value(const char *desc, LSA_Q_LOOKUP_PRIV_VALUE  *out, prs_struct *ps, int depth)
2272 {
2273         prs_debug(ps, depth, desc, "lsa_io_q_lookup_priv_value");
2274         depth++;
2275
2276         if(!prs_align(ps))
2277                 return False;
2278
2279         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2280                 return False;
2281         if(!smb_io_lsa_string("privname", &out->privname, ps, depth))
2282                 return False;
2283
2284         return True;
2285 }
2286
2287 /*******************************************************************
2288  Reads or writes an  LSA_R_LOOKUP_PRIV_VALUE structure.
2289 ********************************************************************/
2290
2291 BOOL lsa_io_r_lookup_priv_value(const char *desc, LSA_R_LOOKUP_PRIV_VALUE  *out, prs_struct *ps, int depth)
2292 {
2293         prs_debug(ps, depth, desc, "lsa_io_r_lookup_priv_value");
2294         depth++;
2295
2296         if(!prs_align(ps))
2297                 return False;
2298
2299         if(!lsa_io_luid("luid", &out->luid, ps, depth))
2300                 return False;
2301
2302         if(!prs_ntstatus("status", ps, depth, &out->status))
2303                 return False;
2304
2305         return True;
2306 }
2307
2308
2309 /*******************************************************************
2310  Reads or writes an LSA_Q_ADDPRIVS structure.
2311 ********************************************************************/
2312
2313 BOOL lsa_io_q_addprivs(const char *desc, LSA_Q_ADDPRIVS *out, prs_struct *ps, int depth)
2314 {
2315         prs_debug(ps, depth, desc, "lsa_io_q_addprivs");
2316         depth++;
2317
2318         if(!prs_align(ps))
2319                 return False;
2320
2321         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2322                 return False;
2323
2324         if(!prs_uint32("count", ps, depth, &out->count))
2325                 return False;
2326
2327         if (UNMARSHALLING(ps) && out->count!=0) {
2328                 if (!NT_STATUS_IS_OK(privilege_set_init_by_ctx(ps->mem_ctx, &(out->set))))
2329                         return False;
2330
2331                 if (!(out->set.set = PRS_ALLOC_MEM(ps, LUID_ATTR, out->count)))
2332                         return False;
2333         }
2334
2335         if(!lsa_io_privilege_set(desc, &out->set, ps, depth))
2336                 return False;
2337
2338         return True;
2339 }
2340
2341 /*******************************************************************
2342  Reads or writes an LSA_R_ADDPRIVS structure.
2343 ********************************************************************/
2344
2345 BOOL lsa_io_r_addprivs(const char *desc, LSA_R_ADDPRIVS *out, prs_struct *ps, int depth)
2346 {
2347         prs_debug(ps, depth, desc, "lsa_io_r_addprivs");
2348         depth++;
2349
2350         if(!prs_align(ps))
2351                 return False;
2352
2353         if(!prs_ntstatus("status", ps, depth, &out->status))
2354                 return False;
2355
2356         return True;
2357 }
2358
2359 /*******************************************************************
2360  Reads or writes an LSA_Q_REMOVEPRIVS structure.
2361 ********************************************************************/
2362
2363 BOOL lsa_io_q_removeprivs(const char *desc, LSA_Q_REMOVEPRIVS *out, prs_struct *ps, int depth)
2364 {
2365         prs_debug(ps, depth, desc, "lsa_io_q_removeprivs");
2366         depth++;
2367
2368         if(!prs_align(ps))
2369                 return False;
2370
2371         if(!smb_io_pol_hnd("pol", &out->pol, ps, depth))
2372                 return False;
2373
2374         if(!prs_uint32("allrights", ps, depth, &out->allrights))
2375                 return False;
2376
2377         if(!prs_uint32("ptr", ps, depth, &out->ptr))
2378                 return False;
2379
2380         /*
2381          * JFM: I'm not sure at all if the count is inside the ptr
2382          * never seen one with ptr=0
2383          */
2384
2385         if (out->ptr!=0) {
2386                 if(!prs_uint32("count", ps, depth, &out->count))
2387                         return False;
2388
2389                 if (UNMARSHALLING(ps) && out->count!=0) {
2390                         if (!NT_STATUS_IS_OK(privilege_set_init_by_ctx(ps->mem_ctx, &(out->set))))
2391                                 return False;
2392
2393                         if (!(out->set.set = PRS_ALLOC_MEM(ps, LUID_ATTR, out->count)))
2394                                 return False;
2395                 }
2396
2397                 if(!lsa_io_privilege_set(desc, &out->set, ps, depth))
2398                         return False;
2399         }
2400
2401         return True;
2402 }
2403
2404 /*******************************************************************
2405  Reads or writes an LSA_R_REMOVEPRIVS structure.
2406 ********************************************************************/
2407
2408 BOOL lsa_io_r_removeprivs(const char *desc, LSA_R_REMOVEPRIVS *out, prs_struct *ps, int depth)
2409 {
2410         prs_debug(ps, depth, desc, "lsa_io_r_removeprivs");
2411         depth++;
2412
2413         if(!prs_align(ps))
2414                 return False;
2415
2416         if(!prs_ntstatus("status", ps, depth, &out->status))
2417                 return False;
2418
2419         return True;
2420 }
2421
2422 BOOL policy_handle_is_valid(const POLICY_HND *hnd)
2423 {
2424         POLICY_HND zero_pol;
2425
2426         ZERO_STRUCT(zero_pol);
2427         return ((memcmp(&zero_pol, hnd, sizeof(POLICY_HND)) == 0) ? False : True );
2428 }
2429
2430 /*******************************************************************
2431  Reads or writes an LSA_DNS_DOM_INFO structure.
2432 ********************************************************************/
2433
2434 BOOL lsa_io_dns_dom_info(const char *desc, LSA_DNS_DOM_INFO *info,
2435                          prs_struct *ps, int depth)
2436 {
2437         prs_debug(ps, depth, desc, "lsa_io_dns_dom_info");
2438         depth++;
2439
2440         if(!prs_align(ps))
2441                 return False;
2442         if(!smb_io_unihdr("nb_name", &info->hdr_nb_dom_name, ps, depth))
2443                 return False;
2444         if(!smb_io_unihdr("dns_name", &info->hdr_dns_dom_name, ps, depth))
2445                 return False;
2446         if(!smb_io_unihdr("forest", &info->hdr_forest_name, ps, depth))
2447                 return False;
2448
2449         if(!prs_align(ps))
2450                 return False;
2451         if ( !smb_io_uuid("dom_guid", &info->dom_guid, ps, depth) )
2452                 return False;
2453
2454         if(!prs_align(ps))
2455                 return False;
2456         if(!prs_uint32("dom_sid", ps, depth, &info->ptr_dom_sid))
2457                 return False;
2458
2459         if(!smb_io_unistr2("nb_name", &info->uni_nb_dom_name,
2460                            info->hdr_nb_dom_name.buffer, ps, depth))
2461                 return False;
2462         if(!smb_io_unistr2("dns_name", &info->uni_dns_dom_name,
2463                            info->hdr_dns_dom_name.buffer, ps, depth))
2464                 return False;
2465         if(!smb_io_unistr2("forest", &info->uni_forest_name,
2466                            info->hdr_forest_name.buffer, ps, depth))
2467                 return False;
2468
2469         if(!smb_io_dom_sid2("dom_sid", &info->dom_sid, ps, depth))
2470                 return False;
2471
2472         return True;
2473
2474 }
2475
2476 /*******************************************************************
2477  Inits an LSA_Q_QUERY_INFO2 structure.
2478 ********************************************************************/
2479
2480 void init_q_query2(LSA_Q_QUERY_INFO2 *in, POLICY_HND *hnd, uint16 info_class)
2481 {
2482         DEBUG(5, ("init_q_query2\n"));
2483
2484         memcpy(&in->pol, hnd, sizeof(in->pol));
2485
2486         in->info_class = info_class;
2487 }
2488
2489 /*******************************************************************
2490  Reads or writes an LSA_Q_QUERY_DNSDOMINFO structure.
2491 ********************************************************************/
2492
2493 BOOL lsa_io_q_query_info2(const char *desc, LSA_Q_QUERY_INFO2 *in, prs_struct *ps, int depth)
2494 {
2495         prs_debug(ps, depth, desc, "lsa_io_q_query_info2");
2496         depth++;
2497
2498         if(!prs_align(ps))
2499                 return False;
2500
2501         if(!smb_io_pol_hnd("pol", &in->pol, ps, depth))
2502                 return False;
2503
2504         if(!prs_uint16("info_class", ps, depth, &in->info_class))
2505                 return False;
2506
2507         return True;
2508 }
2509
2510 /*******************************************************************
2511  Reads or writes an LSA_R_QUERY_DNSDOMINFO structure.
2512 ********************************************************************/
2513
2514 BOOL lsa_io_r_query_info2(const char *desc, LSA_R_QUERY_INFO2 *out,
2515                           prs_struct *ps, int depth)
2516 {
2517         prs_debug(ps, depth, desc, "lsa_io_r_query_info2");
2518         depth++;
2519
2520         if(!prs_align(ps))
2521                 return False;
2522
2523         if(!prs_uint32("ptr", ps, depth, &out->ptr))
2524                 return False;
2525         if(!prs_uint16("info_class", ps, depth, &out->info_class))
2526                 return False;
2527         switch(out->info_class) {
2528         case 0x000c:
2529                 if (!lsa_io_dns_dom_info("info12", &out->info.dns_dom_info,
2530                                          ps, depth))
2531                         return False;
2532                 break;
2533         default:
2534                 DEBUG(0,("lsa_io_r_query_info2: unknown info class %d\n",
2535                          out->info_class));
2536                 return False;
2537         }
2538
2539         if(!prs_align(ps))
2540                 return False;
2541         if(!prs_ntstatus("status", ps, depth, &out->status))
2542                 return False;
2543
2544         return True;
2545 }
2546
2547 /*******************************************************************
2548  Inits an LSA_Q_ENUM_ACCT_RIGHTS structure.
2549 ********************************************************************/
2550 void init_q_enum_acct_rights(LSA_Q_ENUM_ACCT_RIGHTS *in,
2551                              POLICY_HND *hnd,
2552                              uint32 count,
2553                              DOM_SID *sid)
2554 {
2555         DEBUG(5, ("init_q_enum_acct_rights\n"));
2556
2557         in->pol = *hnd;
2558         init_dom_sid2(&in->sid, sid);
2559 }
2560
2561 /*******************************************************************
2562 ********************************************************************/
2563 NTSTATUS init_r_enum_acct_rights( LSA_R_ENUM_ACCT_RIGHTS *out, PRIVILEGE_SET *privileges )
2564 {
2565         uint32 i;
2566         char *privname;
2567         const char **privname_array = NULL;
2568         int num_priv = 0;
2569
2570         for ( i=0; i<privileges->count; i++ ) {
2571                 privname = luid_to_privilege_name( &privileges->set[i].luid );
2572                 if ( privname ) {
2573                         if ( !add_string_to_array( get_talloc_ctx(), privname, &privname_array, &num_priv ) )
2574                                 return NT_STATUS_NO_MEMORY;
2575                 }
2576         }
2577
2578         if ( num_priv ) {
2579                 out->rights = TALLOC_P( get_talloc_ctx(), UNISTR4_ARRAY );
2580
2581                 if ( !init_unistr4_array( out->rights, num_priv, privname_array ) )
2582                         return NT_STATUS_NO_MEMORY;
2583
2584                 out->count = num_priv;
2585         }
2586
2587         return NT_STATUS_OK;
2588 }
2589
2590 /*******************************************************************
2591 reads or writes a LSA_Q_ENUM_ACCT_RIGHTS structure.
2592 ********************************************************************/
2593 BOOL lsa_io_q_enum_acct_rights(const char *desc, LSA_Q_ENUM_ACCT_RIGHTS *in, prs_struct *ps, int depth)
2594 {
2595
2596         if (in == NULL)
2597                 return False;
2598
2599         prs_debug(ps, depth, desc, "lsa_io_q_enum_acct_rights");
2600         depth++;
2601
2602         if (!smb_io_pol_hnd("", &in->pol, ps, depth))
2603                 return False;
2604
2605         if(!smb_io_dom_sid2("sid", &in->sid, ps, depth))
2606                 return False;
2607
2608         return True;
2609 }
2610
2611
2612 /*******************************************************************
2613 reads or writes a LSA_R_ENUM_ACCT_RIGHTS structure.
2614 ********************************************************************/
2615 BOOL lsa_io_r_enum_acct_rights(const char *desc, LSA_R_ENUM_ACCT_RIGHTS *out, prs_struct *ps, int depth)
2616 {
2617         prs_debug(ps, depth, desc, "lsa_io_r_enum_acct_rights");
2618         depth++;
2619
2620         if(!prs_uint32("count   ", ps, depth, &out->count))
2621                 return False;
2622
2623         if ( !prs_pointer("rights", ps, depth, (void**)&out->rights, sizeof(UNISTR4_ARRAY), (PRS_POINTER_CAST)prs_unistr4_array) )
2624                 return False;
2625
2626         if(!prs_align(ps))
2627                 return False;
2628
2629         if(!prs_ntstatus("status", ps, depth, &out->status))
2630                 return False;
2631
2632         return True;
2633 }
2634
2635
2636 /*******************************************************************
2637  Inits an LSA_Q_ADD_ACCT_RIGHTS structure.
2638 ********************************************************************/
2639 void init_q_add_acct_rights( LSA_Q_ADD_ACCT_RIGHTS *in, POLICY_HND *hnd,
2640                              DOM_SID *sid, uint32 count, const char **rights )
2641 {
2642         DEBUG(5, ("init_q_add_acct_rights\n"));
2643
2644         in->pol = *hnd;
2645         init_dom_sid2(&in->sid, sid);
2646
2647         in->rights = TALLOC_P( get_talloc_ctx(), UNISTR4_ARRAY );
2648         init_unistr4_array( in->rights, count, rights );
2649
2650         in->count = count;
2651 }
2652
2653
2654 /*******************************************************************
2655 reads or writes a LSA_Q_ADD_ACCT_RIGHTS structure.
2656 ********************************************************************/
2657 BOOL lsa_io_q_add_acct_rights(const char *desc, LSA_Q_ADD_ACCT_RIGHTS *in, prs_struct *ps, int depth)
2658 {
2659         prs_debug(ps, depth, desc, "lsa_io_q_add_acct_rights");
2660         depth++;
2661
2662         if (!smb_io_pol_hnd("", &in->pol, ps, depth))
2663                 return False;
2664
2665         if(!smb_io_dom_sid2("sid", &in->sid, ps, depth))
2666                 return False;
2667
2668         if(!prs_uint32("count", ps, depth, &in->count))
2669                 return False;
2670
2671         if ( !prs_pointer("rights", ps, depth, (void**)&in->rights, sizeof(UNISTR4_ARRAY), (PRS_POINTER_CAST)prs_unistr4_array) )
2672                 return False;
2673
2674         return True;
2675 }
2676
2677 /*******************************************************************
2678 reads or writes a LSA_R_ENUM_ACCT_RIGHTS structure.
2679 ********************************************************************/
2680 BOOL lsa_io_r_add_acct_rights(const char *desc, LSA_R_ADD_ACCT_RIGHTS *out, prs_struct *ps, int depth)
2681 {
2682         prs_debug(ps, depth, desc, "lsa_io_r_add_acct_rights");
2683         depth++;
2684
2685         if(!prs_ntstatus("status", ps, depth, &out->status))
2686                 return False;
2687
2688         return True;
2689 }
2690
2691
2692 /*******************************************************************
2693  Inits an LSA_Q_REMOVE_ACCT_RIGHTS structure.
2694 ********************************************************************/
2695 void init_q_remove_acct_rights(LSA_Q_REMOVE_ACCT_RIGHTS *in,
2696                                POLICY_HND *hnd,
2697                                DOM_SID *sid,
2698                                uint32 removeall,
2699                                uint32 count,
2700                                const char **rights)
2701 {
2702         DEBUG(5, ("init_q_remove_acct_rights\n"));
2703
2704         in->pol = *hnd;
2705
2706         init_dom_sid2(&in->sid, sid);
2707
2708         in->removeall = removeall;
2709         in->count = count;
2710
2711         in->rights = TALLOC_P( get_talloc_ctx(), UNISTR4_ARRAY );
2712         init_unistr4_array( in->rights, count, rights );
2713 }
2714
2715
2716 /*******************************************************************
2717 reads or writes a LSA_Q_REMOVE_ACCT_RIGHTS structure.
2718 ********************************************************************/
2719 BOOL lsa_io_q_remove_acct_rights(const char *desc, LSA_Q_REMOVE_ACCT_RIGHTS *in, prs_struct *ps, int depth)
2720 {
2721         prs_debug(ps, depth, desc, "lsa_io_q_remove_acct_rights");
2722         depth++;
2723
2724         if (!smb_io_pol_hnd("", &in->pol, ps, depth))
2725                 return False;
2726
2727         if(!smb_io_dom_sid2("sid", &in->sid, ps, depth))
2728                 return False;
2729
2730         if(!prs_uint32("removeall", ps, depth, &in->removeall))
2731                 return False;
2732
2733         if(!prs_uint32("count", ps, depth, &in->count))
2734                 return False;
2735
2736         if ( !prs_pointer("rights", ps, depth, (void**)&in->rights, sizeof(UNISTR4_ARRAY), (PRS_POINTER_CAST)prs_unistr4_array) )
2737                 return False;
2738
2739         return True;
2740 }
2741
2742 /*******************************************************************
2743 reads or writes a LSA_R_ENUM_ACCT_RIGHTS structure.
2744 ********************************************************************/
2745 BOOL lsa_io_r_remove_acct_rights(const char *desc, LSA_R_REMOVE_ACCT_RIGHTS *out, prs_struct *ps, int depth)
2746 {
2747         prs_debug(ps, depth, desc, "lsa_io_r_remove_acct_rights");
2748         depth++;
2749
2750         if(!prs_ntstatus("status", ps, depth, &out->status))
2751                 return False;
2752
2753         return True;
2754 }
2755
2756 /*******************************************************************
2757  Inits an LSA_Q_OPEN_TRUSTED_DOMAIN structure.
2758 ********************************************************************/
2759
2760 void init_lsa_q_open_trusted_domain(LSA_Q_OPEN_TRUSTED_DOMAIN *q, POLICY_HND *hnd, DOM_SID *sid, uint32 desired_access)
2761 {
2762         memcpy(&q->pol, hnd, sizeof(q->pol));
2763
2764         init_dom_sid2(&q->sid, sid);
2765         q->access_mask = desired_access;
2766 }
2767
2768 /*******************************************************************
2769 ********************************************************************/
2770
2771 #if 0 /* jerry, I think this not correct - gd */
2772 BOOL lsa_io_q_open_trusted_domain(const char *desc, LSA_Q_OPEN_TRUSTED_DOMAIN *in, prs_struct *ps, int depth)
2773 {
2774         prs_debug(ps, depth, desc, "lsa_io_q_open_trusted_domain");
2775         depth++;
2776
2777         if(!prs_align(ps))
2778                 return False;
2779
2780         if (!smb_io_pol_hnd("", &in->handle, ps, depth))
2781                 return False;
2782
2783         if(!prs_uint32("count", ps, depth, &in->count))
2784                 return False;
2785
2786         if(!smb_io_dom_sid("sid", &in->sid, ps, depth))
2787                 return False;
2788
2789         return True;
2790 }
2791 #endif
2792
2793
2794 /*******************************************************************
2795  Inits an LSA_Q_OPEN_TRUSTED_DOMAIN_BY_NAME structure.
2796 ********************************************************************/
2797
2798 void init_lsa_q_open_trusted_domain_by_name(LSA_Q_OPEN_TRUSTED_DOMAIN_BY_NAME *q,
2799                                             POLICY_HND *hnd,
2800                                             const char *name,
2801                                             uint32 desired_access)
2802 {
2803         memcpy(&q->pol, hnd, sizeof(q->pol));
2804
2805         init_lsa_string(&q->name, name);
2806         q->access_mask = desired_access;
2807 }
2808
2809 /*******************************************************************
2810 ********************************************************************/
2811
2812
2813 /*******************************************************************
2814  Reads or writes an LSA_Q_OPEN_TRUSTED_DOMAIN_BY_NAME structure.
2815 ********************************************************************/
2816
2817 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)
2818 {
2819         prs_debug(ps, depth, desc, "lsa_io_q_open_trusted_domain_by_name");
2820         depth++;
2821
2822         if(!prs_align(ps))
2823                 return False;
2824
2825         if(!smb_io_pol_hnd("pol", &q_o->pol, ps, depth))
2826                 return False;
2827
2828         if(!prs_align(ps))
2829                 return False;
2830
2831         if(!smb_io_lsa_string("name", &q_o->name, ps, depth))
2832                 return False;
2833
2834         if(!prs_align(ps))
2835                 return False;
2836
2837         if(!prs_uint32("access", ps, depth, &q_o->access_mask))
2838                 return False;
2839
2840         return True;
2841 }
2842
2843 /*******************************************************************
2844  Reads or writes an LSA_R_OPEN_TRUSTED_DOMAIN_BY_NAME structure.
2845 ********************************************************************/
2846
2847 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)
2848 {
2849         prs_debug(ps, depth, desc, "lsa_io_r_open_trusted_domain_by_name");
2850         depth++;
2851
2852         if(!prs_align(ps))
2853                 return False;
2854
2855         if (!smb_io_pol_hnd("handle", &out->handle, ps, depth))
2856                 return False;
2857
2858         if(!prs_ntstatus("status", ps, depth, &out->status))
2859                 return False;
2860
2861         return True;
2862 }
2863
2864 /*******************************************************************
2865 ********************************************************************/
2866
2867 BOOL lsa_io_q_open_trusted_domain(const char *desc, LSA_Q_OPEN_TRUSTED_DOMAIN *q_o, prs_struct *ps, int depth)
2868 {
2869         prs_debug(ps, depth, desc, "lsa_io_q_open_trusted_domain");
2870         depth++;
2871
2872         if(!prs_align(ps))
2873                 return False;
2874
2875         if(!smb_io_pol_hnd("pol", &q_o->pol, ps, depth))
2876                 return False;
2877
2878         if(!smb_io_dom_sid2("sid", &q_o->sid, ps, depth))
2879                 return False;
2880
2881         if(!prs_uint32("access", ps, depth, &q_o->access_mask))
2882                 return False;
2883
2884         return True;
2885 }
2886
2887 /*******************************************************************
2888  Reads or writes an LSA_R_OPEN_TRUSTED_DOMAIN structure.
2889 ********************************************************************/
2890
2891 BOOL lsa_io_r_open_trusted_domain(const char *desc, LSA_R_OPEN_TRUSTED_DOMAIN *out, prs_struct *ps, int depth)
2892 {
2893         prs_debug(ps, depth, desc, "lsa_io_r_open_trusted_domain");
2894         depth++;
2895
2896         if(!prs_align(ps))
2897                 return False;
2898
2899         if (!smb_io_pol_hnd("handle", &out->handle, ps, depth))
2900                 return False;
2901
2902         if(!prs_ntstatus("status", ps, depth, &out->status))
2903                 return False;
2904
2905         return True;
2906 }
2907
2908 /*******************************************************************
2909 ********************************************************************/
2910
2911 BOOL lsa_io_q_create_trusted_domain(const char *desc, LSA_Q_CREATE_TRUSTED_DOMAIN *in, prs_struct *ps, int depth)
2912 {
2913         prs_debug(ps, depth, desc, "lsa_io_q_create_trusted_domain");
2914         depth++;
2915
2916         if(!prs_align(ps))
2917                 return False;
2918
2919         if(!smb_io_pol_hnd("", &in->handle, ps, depth))
2920                 return False;
2921
2922         if(!prs_unistr4 ("secretname", ps, depth, &in->secretname))
2923                 return False;
2924         if(!prs_align(ps))
2925                 return False;
2926
2927         if(!prs_uint32("access", ps, depth, &in->access))
2928                 return False;
2929
2930         return True;
2931 }
2932
2933 /*******************************************************************
2934 ********************************************************************/
2935
2936 BOOL lsa_io_r_create_trusted_domain(const char *desc, LSA_R_CREATE_TRUSTED_DOMAIN *out, prs_struct *ps, int depth)
2937 {
2938         prs_debug(ps, depth, desc, "lsa_io_r_create_trusted_domain");
2939         depth++;
2940
2941         if(!prs_align(ps))
2942                 return False;
2943
2944         if (!smb_io_pol_hnd("", &out->handle, ps, depth))
2945                 return False;
2946
2947         if(!prs_ntstatus("status", ps, depth, &out->status))
2948                 return False;
2949
2950         return True;
2951 }
2952
2953 /*******************************************************************
2954 ********************************************************************/
2955
2956 BOOL lsa_io_q_create_secret(const char *desc, LSA_Q_CREATE_SECRET *in, prs_struct *ps, int depth)
2957 {
2958         prs_debug(ps, depth, desc, "lsa_io_q_create_secret");
2959         depth++;
2960
2961         if(!prs_align(ps))
2962                 return False;
2963
2964         if(!smb_io_pol_hnd("", &in->handle, ps, depth))
2965                 return False;
2966
2967         if(!prs_unistr4 ("secretname", ps, depth, &in->secretname))
2968                 return False;
2969         if(!prs_align(ps))
2970                 return False;
2971
2972         if(!prs_uint32("access", ps, depth, &in->access))
2973                 return False;
2974
2975         return True;
2976 }
2977
2978 /*******************************************************************
2979 ********************************************************************/
2980
2981 BOOL lsa_io_r_create_secret(const char *desc, LSA_R_CREATE_SECRET *out, prs_struct *ps, int depth)
2982 {
2983         prs_debug(ps, depth, desc, "lsa_io_r_create_secret");
2984         depth++;
2985
2986         if(!prs_align(ps))
2987                 return False;
2988
2989         if (!smb_io_pol_hnd("", &out->handle, ps, depth))
2990                 return False;
2991
2992         if(!prs_ntstatus("status", ps, depth, &out->status))
2993                 return False;
2994
2995         return True;
2996 }
2997
2998
2999
3000 /*******************************************************************
3001 ********************************************************************/
3002
3003 static BOOL lsa_io_data_blob( const char *desc, prs_struct *ps, int depth, LSA_DATA_BLOB *blob )
3004 {
3005         prs_debug(ps, depth, desc, "lsa_io_data_blob");
3006         depth++;
3007
3008         if ( !prs_uint32("size", ps, depth, &blob->size) )
3009                 return False;
3010         if ( !prs_uint32("size", ps, depth, &blob->size) )
3011                 return False;
3012
3013         if ( !prs_io_unistr2_p(desc, ps, depth, &blob->data) )
3014                 return False;
3015
3016         return True;
3017 }
3018
3019 /*******************************************************************
3020 ********************************************************************/
3021
3022 BOOL lsa_io_q_set_secret(const char *desc, LSA_Q_SET_SECRET *in, prs_struct *ps, int depth)
3023 {
3024         prs_debug(ps, depth, desc, "lsa_io_q_set_secret");
3025         depth++;
3026
3027         if ( !prs_align(ps) )
3028                 return False;
3029
3030         if ( !smb_io_pol_hnd("", &in->handle, ps, depth) )
3031                 return False;
3032
3033         if ( !prs_pointer( "old_value", ps, depth, (void*)&in->old_value, sizeof(LSA_DATA_BLOB), (PRS_POINTER_CAST)lsa_io_data_blob ))
3034                 return False;
3035
3036         if( !prs_align(ps) )
3037                 return False;
3038         if ( !prs_pointer( "old_value", ps, depth, (void*)&in->old_value, sizeof(LSA_DATA_BLOB), (PRS_POINTER_CAST)lsa_io_data_blob ))
3039                 return False;
3040
3041
3042         return True;
3043 }
3044
3045 /*******************************************************************
3046 ********************************************************************/
3047
3048 BOOL lsa_io_r_set_secret(const char *desc, LSA_R_SET_SECRET *out, prs_struct *ps, int depth)
3049 {
3050         prs_debug(ps, depth, desc, "lsa_io_r_set_secret");
3051         depth++;
3052
3053         if(!prs_ntstatus("status", ps, depth, &out->status))
3054                 return False;
3055
3056         return True;
3057 }
3058
3059 /*******************************************************************
3060 ********************************************************************/
3061
3062 BOOL lsa_io_q_delete_object(const char *desc, LSA_Q_DELETE_OBJECT *in, prs_struct *ps, int depth)
3063 {
3064         prs_debug(ps, depth, desc, "lsa_io_q_delete_object");
3065         depth++;
3066
3067         if(!prs_align(ps))
3068                 return False;
3069
3070         if(!smb_io_pol_hnd("", &in->handle, ps, depth))
3071                 return False;
3072
3073         return True;
3074 }
3075
3076 /*******************************************************************
3077 ********************************************************************/
3078
3079 BOOL lsa_io_r_delete_object(const char *desc, LSA_R_DELETE_OBJECT *out, prs_struct *ps, int depth)
3080 {
3081         prs_debug(ps, depth, desc, "lsa_io_r_delete_object");
3082         depth++;
3083
3084         if(!prs_ntstatus("status", ps, depth, &out->status))
3085                 return False;
3086
3087         return True;
3088 }
3089
3090 /*******************************************************************
3091  Inits an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO structure.
3092 ********************************************************************/
3093
3094 void init_q_query_trusted_domain_info(LSA_Q_QUERY_TRUSTED_DOMAIN_INFO *q,
3095                                       POLICY_HND *hnd, uint16 info_class)
3096 {
3097         DEBUG(5, ("init_q_query_trusted_domain_info\n"));
3098
3099         q->pol = *hnd;
3100         q->info_class = info_class;
3101 }
3102
3103 /*******************************************************************
3104  Inits an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_NAME structure.
3105 ********************************************************************/
3106
3107 void init_q_query_trusted_domain_info_by_name(LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_NAME *q,
3108                                               POLICY_HND *hnd, uint16 info_class,
3109                                               const char *dom_name)
3110 {
3111         DEBUG(5, ("init_q_query_trusted_domain_info_by_name\n"));
3112
3113         q->pol = *hnd;
3114         init_lsa_string(&q->domain_name, dom_name );
3115         q->info_class = info_class;
3116 }
3117
3118 /*******************************************************************
3119  Inits an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_SID structure.
3120 ********************************************************************/
3121
3122 void init_q_query_trusted_domain_info_by_sid(LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_SID *q,
3123                                              POLICY_HND *hnd, uint16 info_class,
3124                                              DOM_SID *dom_sid)
3125 {
3126         DEBUG(5, ("init_q_query_trusted_domain_info_by_sid\n"));
3127
3128         q->pol = *hnd;
3129         init_dom_sid2(&q->dom_sid, dom_sid);
3130         q->info_class = info_class;
3131 }
3132
3133 /*******************************************************************
3134  Reads or writes an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO structure.
3135 ********************************************************************/
3136
3137 BOOL lsa_io_q_query_trusted_domain_info(const char *desc,
3138                                         LSA_Q_QUERY_TRUSTED_DOMAIN_INFO *q_q,
3139                                         prs_struct *ps, int depth)
3140 {
3141         prs_debug(ps, depth, desc, "lsa_io_q_query_trusted_domain_info");
3142         depth++;
3143
3144         if(!prs_align(ps))
3145                 return False;
3146
3147         if(!smb_io_pol_hnd("pol", &q_q->pol, ps, depth))
3148                 return False;
3149
3150         if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
3151                 return False;
3152
3153         return True;
3154 }
3155
3156
3157 /*******************************************************************
3158  Reads or writes an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_SID structure.
3159 ********************************************************************/
3160
3161 BOOL lsa_io_q_query_trusted_domain_info_by_sid(const char *desc,
3162                                                LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_SID *q_q,
3163                                                prs_struct *ps, int depth)
3164 {
3165         prs_debug(ps, depth, desc, "lsa_io_q_query_trusted_domain_info_by_sid");
3166         depth++;
3167
3168         if(!prs_align(ps))
3169                 return False;
3170
3171         if(!smb_io_pol_hnd("pol", &q_q->pol, ps, depth))
3172                 return False;
3173
3174         if(!prs_align(ps))
3175                 return False;
3176
3177         if(!smb_io_dom_sid2("dom_sid", &q_q->dom_sid, ps, depth))
3178                 return False;
3179
3180         if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
3181                 return False;
3182
3183         return True;
3184 }
3185
3186 /*******************************************************************
3187  Reads or writes an LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_NAME structure.
3188 ********************************************************************/
3189
3190 BOOL lsa_io_q_query_trusted_domain_info_by_name(const char *desc,
3191                                                 LSA_Q_QUERY_TRUSTED_DOMAIN_INFO_BY_NAME *q_q,
3192                                                 prs_struct *ps, int depth)
3193 {
3194         prs_debug(ps, depth, desc, "lsa_io_q_query_trusted_domain_info_by_name");
3195         depth++;
3196
3197         if(!prs_align(ps))
3198                 return False;
3199
3200         if(!smb_io_pol_hnd("pol", &q_q->pol, ps, depth))
3201                 return False;
3202
3203         if(!prs_align(ps))
3204                 return False;
3205
3206         if(!smb_io_lsa_string("domain_name", &q_q->domain_name, ps, depth))
3207                 return False;
3208
3209         if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
3210                 return False;
3211
3212         return True;
3213 }
3214
3215 /*******************************************************************
3216 ********************************************************************/
3217
3218 static BOOL smb_io_lsa_data_buf_hdr(const char *desc, LSA_DATA_BUF_HDR *buf_hdr,
3219                                     prs_struct *ps, int depth)
3220 {
3221         prs_debug(ps, depth, desc, "smb_io_lsa_data_buf_hdr");
3222         depth++;
3223
3224         if(!prs_align(ps))
3225                 return False;
3226
3227         if(!prs_uint32("length", ps, depth, &buf_hdr->length))
3228                 return False;
3229
3230         if(!prs_uint32("size", ps, depth, &buf_hdr->size))
3231                 return False;
3232
3233         if (!prs_uint32("data_ptr", ps, depth, &buf_hdr->data_ptr))
3234                 return False;
3235
3236         return True;
3237 }
3238
3239 /*******************************************************************
3240 ********************************************************************/
3241
3242 static BOOL smb_io_lsa_data_buf(const char *desc, LSA_DATA_BUF *buf,
3243                                 prs_struct *ps, int depth, int length, int size)
3244 {
3245         prs_debug(ps, depth, desc, "smb_io_lsa_data_buf");
3246         depth++;
3247
3248         if ( UNMARSHALLING(ps) ) {
3249                 if ( !(buf->data = PRS_ALLOC_MEM( ps, uint8, length )) )
3250                         return False;
3251         }
3252
3253         if (!prs_uint32("size", ps, depth, &buf->size))
3254                 return False;
3255
3256         if (!prs_uint32("offset", ps, depth, &buf->offset))
3257                 return False;
3258
3259         if (!prs_uint32("length", ps, depth, &buf->length))
3260                 return False;
3261
3262         if(!prs_uint8s(False, "data", ps, depth, buf->data, size))
3263                 return False;
3264
3265         return True;
3266 }
3267
3268 /*******************************************************************
3269 ********************************************************************/
3270
3271 static BOOL lsa_io_trustdom_query_1(const char *desc, TRUSTED_DOMAIN_INFO_NAME *name,
3272                                     prs_struct *ps, int depth)
3273 {
3274         if (!smb_io_lsa_string("netbios_name", &name->netbios_name, ps, depth))
3275                 return False;
3276
3277         return True;
3278 }
3279
3280 /*******************************************************************
3281 ********************************************************************/
3282
3283 static BOOL lsa_io_trustdom_query_3(const char *desc, TRUSTED_DOMAIN_INFO_POSIX_OFFSET *posix,
3284                                     prs_struct *ps, int depth)
3285 {
3286         if(!prs_uint32("posix_offset", ps, depth, &posix->posix_offset))
3287                 return False;
3288
3289         return True;
3290 }
3291
3292 /*******************************************************************
3293 ********************************************************************/
3294
3295 static BOOL lsa_io_trustdom_query_4(const char *desc, TRUSTED_DOMAIN_INFO_PASSWORD *password,
3296                                     prs_struct *ps, int depth)
3297 {
3298         if(!prs_align(ps))
3299                 return False;
3300
3301         if(!prs_uint32("ptr_password", ps, depth, &password->ptr_password))
3302                 return False;
3303
3304         if(!prs_uint32("ptr_old_password", ps, depth, &password->ptr_old_password))
3305                 return False;
3306
3307         if (&password->ptr_password) {
3308
3309                 if (!smb_io_lsa_data_buf_hdr("password_hdr", &password->password_hdr, ps, depth))
3310                         return False;
3311
3312                 if (!smb_io_lsa_data_buf("password", &password->password, ps, depth,
3313                                         password->password_hdr.length, password->password_hdr.size))
3314                         return False;
3315         }
3316
3317         if (&password->ptr_old_password) {
3318
3319                 if (!smb_io_lsa_data_buf_hdr("old_password_hdr", &password->old_password_hdr, ps, depth))
3320                         return False;
3321
3322                 if (!smb_io_lsa_data_buf("old_password", &password->old_password, ps, depth,
3323                                         password->old_password_hdr.length, password->old_password_hdr.size))
3324                         return False;
3325         }
3326
3327         return True;
3328 }
3329
3330 /*******************************************************************
3331 ********************************************************************/
3332
3333 static BOOL lsa_io_trustdom_query_6(const char *desc, TRUSTED_DOMAIN_INFO_EX *info_ex,
3334                                     prs_struct *ps, int depth)
3335 {
3336         uint32 dom_sid_ptr;
3337
3338         if (!smb_io_unihdr("domain_name_hdr", &info_ex->domain_name.hdr, ps, depth))
3339                 return False;
3340
3341         if (!smb_io_unihdr("netbios_name_hdr", &info_ex->netbios_name.hdr, ps, depth))
3342                 return False;
3343
3344         if (!prs_uint32("dom_sid_ptr", ps, depth, &dom_sid_ptr))
3345                 return False;
3346
3347         if (!prs_uint32("trust_direction", ps, depth, &info_ex->trust_direction))
3348                 return False;
3349
3350         if (!prs_uint32("trust_type", ps, depth, &info_ex->trust_type))
3351                 return False;
3352
3353         if (!prs_uint32("trust_attributes", ps, depth, &info_ex->trust_attributes))
3354                 return False;
3355
3356         if (!smb_io_unistr2("domain_name_unistring", &info_ex->domain_name.unistring, info_ex->domain_name.hdr.buffer, ps, depth))
3357                 return False;
3358
3359         if (!smb_io_unistr2("netbios_name_unistring", &info_ex->netbios_name.unistring, info_ex->netbios_name.hdr.buffer, ps, depth))
3360                 return False;
3361
3362         if (!smb_io_dom_sid2("sid", &info_ex->sid, ps, depth))
3363                 return False;
3364
3365         return True;
3366 }
3367
3368 /*******************************************************************
3369 ********************************************************************/
3370
3371 static BOOL lsa_io_trustdom_query(const char *desc, prs_struct *ps, int depth, LSA_TRUSTED_DOMAIN_INFO *info)
3372 {
3373         prs_debug(ps, depth, desc, "lsa_io_trustdom_query");
3374         depth++;
3375
3376         if(!prs_uint16("info_class", ps, depth, &info->info_class))
3377                 return False;
3378
3379         if(!prs_align(ps))
3380                 return False;
3381
3382         switch (info->info_class) {
3383         case 1:
3384                 if(!lsa_io_trustdom_query_1("name", &info->name, ps, depth))
3385                         return False;
3386                 break;
3387         case 3:
3388                 if(!lsa_io_trustdom_query_3("posix_offset", &info->posix_offset, ps, depth))
3389                         return False;
3390                 break;
3391         case 4:
3392                 if(!lsa_io_trustdom_query_4("password", &info->password, ps, depth))
3393                         return False;
3394                 break;
3395         case 6:
3396                 if(!lsa_io_trustdom_query_6("info_ex", &info->info_ex, ps, depth))
3397                         return False;
3398                 break;
3399         default:
3400                 DEBUG(0,("unsupported info-level: %d\n", info->info_class));
3401                 return False;
3402         }
3403
3404         return True;
3405 }
3406
3407 /*******************************************************************
3408  Reads or writes an LSA_R_QUERY_TRUSTED_DOMAIN_INFO structure.
3409 ********************************************************************/
3410
3411 BOOL lsa_io_r_query_trusted_domain_info(const char *desc,
3412                                         LSA_R_QUERY_TRUSTED_DOMAIN_INFO *r_q,
3413                                         prs_struct *ps, int depth)
3414 {
3415         if (r_q == NULL)
3416                 return False;
3417
3418         prs_debug(ps, depth, desc, "lsa_io_r_query_trusted_domain_info");
3419         depth++;
3420
3421         if (!prs_pointer("trustdom", ps, depth, (void**)&r_q->info,
3422                          sizeof(LSA_TRUSTED_DOMAIN_INFO),
3423                          (PRS_POINTER_CAST)lsa_io_trustdom_query) )
3424                 return False;
3425
3426         if(!prs_align(ps))
3427                 return False;
3428
3429         if(!prs_ntstatus("status", ps, depth, &r_q->status))
3430                 return False;
3431
3432         return True;
3433 }
3434
3435 /*******************************************************************
3436  Inits an LSA_Q_QUERY_DOM_INFO_POLICY structure.
3437 ********************************************************************/
3438
3439 void init_q_query_dom_info(LSA_Q_QUERY_DOM_INFO_POLICY *in, POLICY_HND *hnd, uint16 info_class)
3440 {
3441         DEBUG(5, ("init_q_query_dom_info\n"));
3442
3443         memcpy(&in->pol, hnd, sizeof(in->pol));
3444
3445         in->info_class = info_class;
3446 }
3447
3448 /*******************************************************************
3449  Reads or writes an LSA_Q_QUERY_DOM_INFO_POLICY structure.
3450 ********************************************************************/
3451
3452 BOOL lsa_io_q_query_dom_info(const char *desc, LSA_Q_QUERY_DOM_INFO_POLICY *in, prs_struct *ps, int depth)
3453 {
3454         prs_debug(ps, depth, desc, "lsa_io_q_query_dom_info");
3455         depth++;
3456
3457         if(!prs_align(ps))
3458                 return False;
3459
3460         if(!smb_io_pol_hnd("pol", &in->pol, ps, depth))
3461                 return False;
3462
3463         if(!prs_uint16("info_class", ps, depth, &in->info_class))
3464                 return False;
3465
3466         return True;
3467 }
3468
3469 /*******************************************************************
3470  Reads or writes an LSA_R_QUERY_DOM_INFO_POLICY structure.
3471 ********************************************************************/
3472
3473 static BOOL lsa_io_dominfo_query_3(const char *desc, LSA_DOM_INFO_POLICY_KERBEROS *krb_policy,
3474                                    prs_struct *ps, int depth)
3475 {
3476         if (!prs_align_uint64(ps))
3477                 return False;
3478
3479         if (!prs_align(ps))
3480                 return False;
3481
3482         if (!prs_uint32("enforce_restrictions", ps, depth, &krb_policy->enforce_restrictions))
3483                 return False;
3484
3485         if (!prs_align_uint64(ps))
3486                 return False;
3487
3488         if (!smb_io_nttime("service_tkt_lifetime", ps, depth, &krb_policy->service_tkt_lifetime))
3489                 return False;
3490
3491         if (!prs_align_uint64(ps))
3492                 return False;
3493
3494         if (!smb_io_nttime("user_tkt_lifetime", ps, depth, &krb_policy->user_tkt_lifetime))
3495                 return False;
3496
3497         if (!prs_align_uint64(ps))
3498                 return False;
3499
3500         if (!smb_io_nttime("user_tkt_renewaltime", ps, depth, &krb_policy->user_tkt_renewaltime))
3501                 return False;
3502
3503         if (!prs_align_uint64(ps))
3504                 return False;
3505
3506         if (!smb_io_nttime("clock_skew", ps, depth, &krb_policy->clock_skew))
3507                 return False;
3508
3509         if (!prs_align_uint64(ps))
3510                 return False;
3511
3512         if (!smb_io_nttime("unknown6", ps, depth, &krb_policy->unknown6))
3513                 return False;
3514
3515         return True;
3516 }
3517
3518 static BOOL lsa_io_dom_info_query(const char *desc, prs_struct *ps, int depth, LSA_DOM_INFO_UNION *info)
3519 {
3520         prs_debug(ps, depth, desc, "lsa_io_dom_info_query");
3521         depth++;
3522
3523         if(!prs_align_uint16(ps))
3524                 return False;
3525
3526         if(!prs_uint16("info_class", ps, depth, &info->info_class))
3527                 return False;
3528
3529         switch (info->info_class) {
3530         case 3:
3531                 if (!lsa_io_dominfo_query_3("krb_policy", &info->krb_policy, ps, depth))
3532                         return False;
3533                 break;
3534         default:
3535                 DEBUG(0,("unsupported info-level: %d\n", info->info_class));
3536                 return False;
3537                 break;
3538         }
3539
3540         return True;
3541 }
3542
3543
3544 BOOL lsa_io_r_query_dom_info(const char *desc, LSA_R_QUERY_DOM_INFO_POLICY *out,
3545                              prs_struct *ps, int depth)
3546 {
3547         prs_debug(ps, depth, desc, "lsa_io_r_query_dom_info");
3548         depth++;
3549
3550         if (!prs_pointer("dominfo", ps, depth, (void**)&out->info,
3551                          sizeof(LSA_DOM_INFO_UNION),
3552                          (PRS_POINTER_CAST)lsa_io_dom_info_query) )
3553                 return False;
3554
3555         if(!prs_ntstatus("status", ps, depth, &out->status))
3556                 return False;
3557
3558         return True;
3559 }