source/rpc_parse/parse_lsa.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-1997,
   5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   6  *  Copyright (C) Paul Ashton                       1997,
   7  *  Copyright (C) Andrew Bartlett                   2002,
   8  *  Copyright (C) Jim McDonough                     2002.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #include "includes.h"
  26
  27 #undef DBGC_CLASS
  28 #define DBGC_CLASS DBGC_RPC_PARSE
  29
  30 static BOOL lsa_io_trans_names(const char *desc, LSA_TRANS_NAME_ENUM *trn, prs_struct *ps, int depth);
  31
  32 /*******************************************************************
  33  Inits a LSA_TRANS_NAME structure.
  34 ********************************************************************/
  35
  36 void init_lsa_trans_name(LSA_TRANS_NAME *trn, UNISTR2 *uni_name,
  37                          uint16 sid_name_use, const char *name, uint32 idx)
  38 {
  39         int len_name = strlen(name);
  40
  41         if(len_name == 0)
  42                 len_name = 1;
  43
  44         trn->sid_name_use = sid_name_use;
  45         init_uni_hdr(&trn->hdr_name, len_name);
  46         init_unistr2(uni_name, name);
  47         trn->domain_idx = idx;
  48 }
  49
  50 /*******************************************************************
  51  Reads or writes a LSA_TRANS_NAME structure.
  52 ********************************************************************/
  53
  54 static BOOL lsa_io_trans_name(const char *desc, LSA_TRANS_NAME *trn, prs_struct *ps,
  55                               int depth)
  56 {
  57         prs_debug(ps, depth, desc, "lsa_io_trans_name");
  58         depth++;
  59
  60         if(!prs_align(ps))
  61                 return False;
  62
  63         if(!prs_uint16("sid_name_use", ps, depth, &trn->sid_name_use))
  64                 return False;
  65         if(!prs_align(ps))
  66                 return False;
  67
  68         if(!smb_io_unihdr ("hdr_name", &trn->hdr_name, ps, depth))
  69                 return False;
  70         if(!prs_uint32("domain_idx  ", ps, depth, &trn->domain_idx))
  71                 return False;
  72
  73         return True;
  74 }
  75
  76 /*******************************************************************
  77  Reads or writes a DOM_R_REF structure.
  78 ********************************************************************/
  79
  80 static BOOL lsa_io_dom_r_ref(const char *desc, DOM_R_REF *r_r, prs_struct *ps,
  81                              int depth)
  82 {
  83         int i;
  84
  85         prs_debug(ps, depth, desc, "lsa_io_dom_r_ref");
  86         depth++;
  87
  88         if(!prs_align(ps))
  89                 return False;
  90
  91         if(!prs_uint32("num_ref_doms_1", ps, depth, &r_r->num_ref_doms_1)) /* num referenced domains? */
  92                 return False;
  93         if(!prs_uint32("ptr_ref_dom   ", ps, depth, &r_r->ptr_ref_dom)) /* undocumented buffer pointer. */
  94                 return False;
  95         if(!prs_uint32("max_entries   ", ps, depth, &r_r->max_entries)) /* 32 - max number of entries */
  96                 return False;
  97
  98         SMB_ASSERT_ARRAY(r_r->hdr_ref_dom, r_r->num_ref_doms_1);
  99
 100         if (r_r->ptr_ref_dom != 0) {
 101
 102                 if(!prs_uint32("num_ref_doms_2", ps, depth, &r_r->num_ref_doms_2)) /* 4 - num referenced domains? */
 103                         return False;
 104
 105                 SMB_ASSERT_ARRAY(r_r->ref_dom, r_r->num_ref_doms_2);
 106
 107                 for (i = 0; i < r_r->num_ref_doms_1; i++) {
 108                         fstring t;
 109
 110                         slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
 111                         if(!smb_io_unihdr(t, &r_r->hdr_ref_dom[i].hdr_dom_name, ps, depth))
 112                                 return False;
 113
 114                         slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
 115                         if(!prs_uint32(t, ps, depth, &r_r->hdr_ref_dom[i].ptr_dom_sid))
 116                                 return False;
 117                 }
 118
 119                 for (i = 0; i < r_r->num_ref_doms_2; i++) {
 120                         fstring t;
 121
 122                         if (r_r->hdr_ref_dom[i].hdr_dom_name.buffer != 0) {
 123                                 slprintf(t, sizeof(t) - 1, "dom_ref[%d] ", i);
 124                                 if(!smb_io_unistr2(t, &r_r->ref_dom[i].uni_dom_name, True, ps, depth)) /* domain name unicode string */
 125                                         return False;
 126                                 if(!prs_align(ps))
 127                                         return False;
 128                         }
 129
 130                         if (r_r->hdr_ref_dom[i].ptr_dom_sid != 0) {
 131                                 slprintf(t, sizeof(t) - 1, "sid_ptr[%d] ", i);
 132                                 if(!smb_io_dom_sid2(t, &r_r->ref_dom[i].ref_dom, ps, depth)) /* referenced domain SIDs */
 133                                         return False;
 134                         }
 135                 }
 136         }
 137
 138         return True;
 139 }
 140
 141 /*******************************************************************
 142  Inits an LSA_SEC_QOS structure.
 143 ********************************************************************/
 144
 145 void init_lsa_sec_qos(LSA_SEC_QOS *qos, uint16 imp_lev, uint8 ctxt, uint8 eff)
 146 {
 147         DEBUG(5, ("init_lsa_sec_qos\n"));
 148
 149         qos->len = 0x0c; /* length of quality of service block, in bytes */
 150         qos->sec_imp_level = imp_lev;
 151         qos->sec_ctxt_mode = ctxt;
 152         qos->effective_only = eff;
 153 }
 154
 155 /*******************************************************************
 156  Reads or writes an LSA_SEC_QOS structure.
 157 ********************************************************************/
 158
 159 static BOOL lsa_io_sec_qos(const char *desc,  LSA_SEC_QOS *qos, prs_struct *ps,
 160                            int depth)
 161 {
 162         uint32 start;
 163
 164         prs_debug(ps, depth, desc, "lsa_io_obj_qos");
 165         depth++;
 166
 167         if(!prs_align(ps))
 168                 return False;
 169
 170         start = prs_offset(ps);
 171
 172         /* these pointers had _better_ be zero, because we don't know
 173            what they point to!
 174          */
 175         if(!prs_uint32("len           ", ps, depth, &qos->len)) /* 0x18 - length (in bytes) inc. the length field. */
 176                 return False;
 177         if(!prs_uint16("sec_imp_level ", ps, depth, &qos->sec_imp_level ))
 178                 return False;
 179         if(!prs_uint8 ("sec_ctxt_mode ", ps, depth, &qos->sec_ctxt_mode ))
 180                 return False;
 181         if(!prs_uint8 ("effective_only", ps, depth, &qos->effective_only))
 182                 return False;
 183
 184         if (qos->len != prs_offset(ps) - start) {
 185                 DEBUG(3,("lsa_io_sec_qos: length %x does not match size %x\n",
 186                          qos->len, prs_offset(ps) - start));
 187         }
 188
 189         return True;
 190 }
 191
 192 /*******************************************************************
 193  Inits an LSA_OBJ_ATTR structure.
 194 ********************************************************************/
 195
 196 static void init_lsa_obj_attr(LSA_OBJ_ATTR *attr, uint32 attributes, LSA_SEC_QOS *qos)
 197 {
 198         DEBUG(5, ("init_lsa_obj_attr\n"));
 199
 200         attr->len = 0x18; /* length of object attribute block, in bytes */
 201         attr->ptr_root_dir = 0;
 202         attr->ptr_obj_name = 0;
 203         attr->attributes = attributes;
 204         attr->ptr_sec_desc = 0;
 205
 206         if (qos != NULL) {
 207                 attr->ptr_sec_qos = 1;
 208                 attr->sec_qos = qos;
 209         } else {
 210                 attr->ptr_sec_qos = 0;
 211                 attr->sec_qos = NULL;
 212         }
 213 }
 214
 215 /*******************************************************************
 216  Reads or writes an LSA_OBJ_ATTR structure.
 217 ********************************************************************/
 218
 219 static BOOL lsa_io_obj_attr(const char *desc, LSA_OBJ_ATTR *attr, prs_struct *ps,
 220                             int depth)
 221 {
 222         uint32 start;
 223
 224         prs_debug(ps, depth, desc, "lsa_io_obj_attr");
 225         depth++;
 226
 227         if(!prs_align(ps))
 228                 return False;
 229
 230         start = prs_offset(ps);
 231
 232         /* these pointers had _better_ be zero, because we don't know
 233            what they point to!
 234          */
 235         if(!prs_uint32("len         ", ps, depth, &attr->len)) /* 0x18 - length (in bytes) inc. the length field. */
 236                 return False;
 237         if(!prs_uint32("ptr_root_dir", ps, depth, &attr->ptr_root_dir)) /* 0 - root directory (pointer) */
 238                 return False;
 239         if(!prs_uint32("ptr_obj_name", ps, depth, &attr->ptr_obj_name)) /* 0 - object name (pointer) */
 240                 return False;
 241         if(!prs_uint32("attributes  ", ps, depth, &attr->attributes)) /* 0 - attributes (undocumented) */
 242                 return False;
 243         if(!prs_uint32("ptr_sec_desc", ps, depth, &attr->ptr_sec_desc)) /* 0 - security descriptior (pointer) */
 244                 return False;
 245         if(!prs_uint32("ptr_sec_qos ", ps, depth, &attr->ptr_sec_qos )) /* security quality of service (pointer) */
 246                 return False;
 247
 248         /* code commented out as it's not necessary true (tested with hyena). JFM, 11/22/2001 */
 249 #if 0
 250         if (attr->len != prs_offset(ps) - start) {
 251                 DEBUG(3,("lsa_io_obj_attr: length %x does not match size %x\n",
 252                          attr->len, prs_offset(ps) - start));
 253                 return False;
 254         }
 255 #endif
 256
 257         if (attr->ptr_sec_qos != 0) {
 258                 if (UNMARSHALLING(ps))
 259                         if (!(attr->sec_qos = (LSA_SEC_QOS *)prs_alloc_mem(ps,sizeof(LSA_SEC_QOS))))
 260                                 return False;
 261
 262                 if(!lsa_io_sec_qos("sec_qos", attr->sec_qos, ps, depth))
 263                         return False;
 264         }
 265
 266         return True;
 267 }
 268
 269
 270 /*******************************************************************
 271  Inits an LSA_Q_OPEN_POL structure.
 272 ********************************************************************/
 273
 274 void init_q_open_pol(LSA_Q_OPEN_POL *r_q, uint16 system_name,
 275                      uint32 attributes, uint32 desired_access,
 276                      LSA_SEC_QOS *qos)
 277 {
 278         DEBUG(5, ("init_open_pol: attr:%d da:%d\n", attributes,
 279                   desired_access));
 280
 281         r_q->ptr = 1; /* undocumented pointer */
 282
 283         r_q->des_access = desired_access;
 284
 285         r_q->system_name = system_name;
 286         init_lsa_obj_attr(&r_q->attr, attributes, qos);
 287 }
 288
 289 /*******************************************************************
 290  Reads or writes an LSA_Q_OPEN_POL structure.
 291 ********************************************************************/
 292
 293 BOOL lsa_io_q_open_pol(const char *desc, LSA_Q_OPEN_POL *r_q, prs_struct *ps,
 294                        int depth)
 295 {
 296         prs_debug(ps, depth, desc, "lsa_io_q_open_pol");
 297         depth++;
 298
 299         if(!prs_uint32("ptr       ", ps, depth, &r_q->ptr))
 300                 return False;
 301         if(!prs_uint16("system_name", ps, depth, &r_q->system_name))
 302                 return False;
 303         if(!prs_align( ps ))
 304                 return False;
 305
 306         if(!lsa_io_obj_attr("", &r_q->attr, ps, depth))
 307                 return False;
 308
 309         if(!prs_uint32("des_access", ps, depth, &r_q->des_access))
 310                 return False;
 311
 312         return True;
 313 }
 314
 315 /*******************************************************************
 316  Reads or writes an LSA_R_OPEN_POL structure.
 317 ********************************************************************/
 318
 319 BOOL lsa_io_r_open_pol(const char *desc, LSA_R_OPEN_POL *r_p, prs_struct *ps,
 320                        int depth)
 321 {
 322         prs_debug(ps, depth, desc, "lsa_io_r_open_pol");
 323         depth++;
 324
 325         if(!smb_io_pol_hnd("", &r_p->pol, ps, depth))
 326                 return False;
 327
 328         if(!prs_ntstatus("status", ps, depth, &r_p->status))
 329                 return False;
 330
 331         return True;
 332 }
 333
 334 /*******************************************************************
 335  Inits an LSA_Q_OPEN_POL2 structure.
 336 ********************************************************************/
 337
 338 void init_q_open_pol2(LSA_Q_OPEN_POL2 *r_q, const char *server_name,
 339                         uint32 attributes, uint32 desired_access,
 340                         LSA_SEC_QOS *qos)
 341 {
 342         DEBUG(5, ("init_q_open_pol2: attr:%d da:%d\n", attributes,
 343                   desired_access));
 344
 345         r_q->ptr = 1; /* undocumented pointer */
 346
 347         r_q->des_access = desired_access;
 348
 349         init_unistr2(&r_q->uni_server_name, server_name);
 350
 351         init_lsa_obj_attr(&r_q->attr, attributes, qos);
 352 }
 353
 354 /*******************************************************************
 355  Reads or writes an LSA_Q_OPEN_POL2 structure.
 356 ********************************************************************/
 357
 358 BOOL lsa_io_q_open_pol2(const char *desc, LSA_Q_OPEN_POL2 *r_q, prs_struct *ps,
 359                         int depth)
 360 {
 361         prs_debug(ps, depth, desc, "lsa_io_q_open_pol2");
 362         depth++;
 363
 364         if(!prs_uint32("ptr       ", ps, depth, &r_q->ptr))
 365                 return False;
 366
 367         if(!smb_io_unistr2 ("", &r_q->uni_server_name, r_q->ptr, ps, depth))
 368                 return False;
 369         if(!lsa_io_obj_attr("", &r_q->attr, ps, depth))
 370                 return False;
 371
 372         if(!prs_uint32("des_access", ps, depth, &r_q->des_access))
 373                 return False;
 374
 375         return True;
 376 }
 377
 378 /*******************************************************************
 379  Reads or writes an LSA_R_OPEN_POL2 structure.
 380 ********************************************************************/
 381
 382 BOOL lsa_io_r_open_pol2(const char *desc, LSA_R_OPEN_POL2 *r_p, prs_struct *ps,
 383                         int depth)
 384 {
 385         prs_debug(ps, depth, desc, "lsa_io_r_open_pol2");
 386         depth++;
 387
 388         if(!smb_io_pol_hnd("", &r_p->pol, ps, depth))
 389                 return False;
 390
 391         if(!prs_ntstatus("status", ps, depth, &r_p->status))
 392                 return False;
 393
 394         return True;
 395 }
 396
 397 /*******************************************************************
 398 makes an LSA_Q_QUERY_SEC_OBJ structure.
 399 ********************************************************************/
 400
 401 void init_q_query_sec_obj(LSA_Q_QUERY_SEC_OBJ *q_q, const POLICY_HND *hnd,
 402                           uint32 sec_info)
 403 {
 404         DEBUG(5, ("init_q_query_sec_obj\n"));
 405
 406         q_q->pol = *hnd;
 407         q_q->sec_info = sec_info;
 408
 409         return;
 410 }
 411
 412 /*******************************************************************
 413  Reads or writes an LSA_Q_QUERY_SEC_OBJ structure.
 414 ********************************************************************/
 415
 416 BOOL lsa_io_q_query_sec_obj(const char *desc, LSA_Q_QUERY_SEC_OBJ *q_q,
 417                             prs_struct *ps, int depth)
 418 {
 419         prs_debug(ps, depth, desc, "lsa_io_q_query_sec_obj");
 420         depth++;
 421
 422         if (!smb_io_pol_hnd("", &q_q->pol, ps, depth))
 423                 return False;
 424
 425         if (!prs_uint32("sec_info", ps, depth, &q_q->sec_info))
 426                 return False;
 427
 428         return True;
 429 }
 430
 431 /*******************************************************************
 432  Reads or writes a LSA_R_QUERY_SEC_OBJ structure.
 433 ********************************************************************/
 434
 435 BOOL lsa_io_r_query_sec_obj(const char *desc, LSA_R_QUERY_SEC_OBJ *r_u,
 436                             prs_struct *ps, int depth)
 437 {
 438         prs_debug(ps, depth, desc, "lsa_io_r_query_sec_obj");
 439         depth++;
 440
 441         if (!prs_align(ps))
 442                 return False;
 443
 444         if (!prs_uint32("ptr", ps, depth, &r_u->ptr))
 445                 return False;
 446
 447         if (r_u->ptr != 0) {
 448                 if (!sec_io_desc_buf("sec", &r_u->buf, ps, depth))
 449                         return False;
 450         }
 451
 452         if (!prs_ntstatus("status", ps, depth, &r_u->status))
 453                 return False;
 454
 455         return True;
 456 }
 457
 458 /*******************************************************************
 459  Inits an LSA_Q_QUERY_INFO structure.
 460 ********************************************************************/
 461
 462 void init_q_query(LSA_Q_QUERY_INFO *q_q, POLICY_HND *hnd, uint16 info_class)
 463 {
 464         DEBUG(5, ("init_q_query\n"));
 465
 466         memcpy(&q_q->pol, hnd, sizeof(q_q->pol));
 467
 468         q_q->info_class = info_class;
 469 }
 470
 471 /*******************************************************************
 472  Reads or writes an LSA_Q_QUERY_INFO structure.
 473 ********************************************************************/
 474
 475 BOOL lsa_io_q_query(const char *desc, LSA_Q_QUERY_INFO *q_q, prs_struct *ps,
 476                     int depth)
 477 {
 478         prs_debug(ps, depth, desc, "lsa_io_q_query");
 479         depth++;
 480
 481         if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
 482                 return False;
 483
 484         if(!prs_uint16("info_class", ps, depth, &q_q->info_class))
 485                 return False;
 486
 487         return True;
 488 }
 489
 490 /*******************************************************************
 491 makes an LSA_Q_ENUM_TRUST_DOM structure.
 492 ********************************************************************/
 493 BOOL init_q_enum_trust_dom(LSA_Q_ENUM_TRUST_DOM * q_e, POLICY_HND *pol,
 494                            uint32 enum_context, uint32 preferred_len)
 495 {
 496         DEBUG(5, ("init_q_enum_trust_dom\n"));
 497
 498         q_e->pol = *pol;
 499         q_e->enum_context = enum_context;
 500         q_e->preferred_len = preferred_len;
 501
 502         return True;
 503 }
 504
 505 /*******************************************************************
 506  Reads or writes an LSA_Q_ENUM_TRUST_DOM structure.
 507 ********************************************************************/
 508
 509 BOOL lsa_io_q_enum_trust_dom(const char *desc, LSA_Q_ENUM_TRUST_DOM *q_e,
 510                              prs_struct *ps, int depth)
 511 {
 512         prs_debug(ps, depth, desc, "lsa_io_q_enum_trust_dom");
 513         depth++;
 514
 515         if(!smb_io_pol_hnd("", &q_e->pol, ps, depth))
 516                 return False;
 517
 518         if(!prs_uint32("enum_context ", ps, depth, &q_e->enum_context))
 519                 return False;
 520         if(!prs_uint32("preferred_len", ps, depth, &q_e->preferred_len))
 521                 return False;
 522
 523         return True;
 524 }
 525
 526 /*******************************************************************
 527  Inits an LSA_R_ENUM_TRUST_DOM structure.
 528 ********************************************************************/
 529
 530 void init_r_enum_trust_dom(TALLOC_CTX *ctx, LSA_R_ENUM_TRUST_DOM *r_e, uint32 enum_context,
 531                            uint32 req_num_domains, uint32 num_domains, TRUSTDOM **td)
 532 {
 533         int i;
 534
 535         DEBUG(5, ("init_r_enum_trust_dom\n"));
 536
 537         r_e->enum_context = enum_context;
 538         r_e->num_domains = num_domains;
 539         r_e->ptr_enum_domains = 0;
 540         r_e->num_domains2 = num_domains;
 541
 542         if (num_domains != 0) {
 543
 544                 /*
 545                  * allocating empty arrays of unicode headers, strings
 546                  * and sids of enumerated trusted domains
 547                  */
 548                 if (!(r_e->hdr_domain_name = (UNIHDR2 *)talloc(ctx,sizeof(UNIHDR2) * num_domains))) {
 549                         r_e->status = NT_STATUS_NO_MEMORY;
 550                         return;
 551                 }
 552
 553                 if (!(r_e->uni_domain_name = (UNISTR2 *)talloc(ctx,sizeof(UNISTR2) * num_domains))) {
 554                         r_e->status = NT_STATUS_NO_MEMORY;
 555                         return;
 556                 }
 557
 558                 if (!(r_e->domain_sid = (DOM_SID2 *)talloc(ctx,sizeof(DOM_SID2) * num_domains))) {
 559                         r_e->status = NT_STATUS_NO_MEMORY;
 560                         return;
 561                 }
 562
 563                 for (i = 0; i < num_domains; i++) {
 564
 565                         /* don't know what actually is this for */
 566                         r_e->ptr_enum_domains = 1;
 567
 568                         init_uni_hdr2(&r_e->hdr_domain_name[i], strlen_w((td[i])->name));
 569                         init_dom_sid2(&r_e->domain_sid[i], &(td[i])->sid);
 570
 571                         init_unistr2_w(ctx, &r_e->uni_domain_name[i], (td[i])->name);
 572
 573                 };
 574         }
 575
 576 }
 577
 578 /*******************************************************************
 579  Reads or writes an LSA_R_ENUM_TRUST_DOM structure.
 580 ********************************************************************/
 581
 582 BOOL lsa_io_r_enum_trust_dom(const char *desc, LSA_R_ENUM_TRUST_DOM *r_e,
 583                              prs_struct *ps, int depth)
 584 {
 585         prs_debug(ps, depth, desc, "lsa_io_r_enum_trust_dom");
 586         depth++;
 587
 588         if(!prs_uint32("enum_context    ", ps, depth, &r_e->enum_context))
 589                 return False;
 590         if(!prs_uint32("num_domains     ", ps, depth, &r_e->num_domains))
 591                 return False;
 592         if(!prs_uint32("ptr_enum_domains", ps, depth, &r_e->ptr_enum_domains))
 593                 return False;
 594
 595         if (r_e->ptr_enum_domains) {
 596                 int i, num_domains;
 597
 598                 if(!prs_uint32("num_domains2", ps, depth, &r_e->num_domains2))
 599                         return False;
 600
 601                 num_domains = r_e->num_domains2;
 602
 603                 if (UNMARSHALLING(ps)) {
 604                         if (!(r_e->hdr_domain_name = (UNIHDR2 *)prs_alloc_mem(ps,sizeof(UNIHDR2) * num_domains)))
 605                                 return False;
 606
 607                         if (!(r_e->uni_domain_name = (UNISTR2 *)prs_alloc_mem(ps,sizeof(UNISTR2) * num_domains)))
 608                                 return False;
 609
 610                         if (!(r_e->domain_sid = (DOM_SID2 *)prs_alloc_mem(ps,sizeof(DOM_SID2) * num_domains)))
 611                                 return False;
 612                 }
 613
 614                 for (i = 0; i < num_domains; i++) {
 615                         if(!smb_io_unihdr2 ("", &r_e->hdr_domain_name[i], ps,
 616                                             depth))
 617                                 return False;
 618                 }
 619
 620                 for (i = 0; i < num_domains; i++) {
 621                         if(!smb_io_unistr2 ("", &r_e->uni_domain_name[i],
 622                                             r_e->hdr_domain_name[i].buffer,
 623                                             ps, depth))
 624                                 return False;
 625                         if(!smb_io_dom_sid2("", &r_e->domain_sid[i], ps,
 626                                             depth))
 627                                 return False;
 628                 }
 629         }
 630
 631         if(!prs_ntstatus("status", ps, depth, &r_e->status))
 632                 return False;
 633
 634         return True;
 635 }
 636
 637 /*******************************************************************
 638 reads or writes a dom query structure.
 639 ********************************************************************/
 640
 641 static BOOL lsa_io_dom_query(const char *desc, DOM_QUERY *d_q, prs_struct *ps, int depth)
 642 {
 643         if (d_q == NULL)
 644                 return False;
 645
 646         prs_debug(ps, depth, desc, "lsa_io_dom_query");
 647         depth++;
 648
 649         if(!prs_align(ps))
 650                 return False;
 651
 652         if(!prs_uint16("uni_dom_max_len", ps, depth, &d_q->uni_dom_max_len)) /* domain name string length * 2 */
 653                 return False;
 654         if(!prs_uint16("uni_dom_str_len", ps, depth, &d_q->uni_dom_str_len)) /* domain name string length * 2 */
 655                 return False;
 656
 657         if(!prs_uint32("buffer_dom_name", ps, depth, &d_q->buffer_dom_name)) /* undocumented domain name string buffer pointer */
 658                 return False;
 659         if(!prs_uint32("buffer_dom_sid ", ps, depth, &d_q->buffer_dom_sid)) /* undocumented domain SID string buffer pointer */
 660                 return False;
 661
 662         if(!smb_io_unistr2("unistr2", &d_q->uni_domain_name, d_q->buffer_dom_name, ps, depth)) /* domain name (unicode string) */
 663                 return False;
 664
 665         if(!prs_align(ps))
 666                 return False;
 667
 668         if (d_q->buffer_dom_sid != 0) {
 669                 if(!smb_io_dom_sid2("", &d_q->dom_sid, ps, depth)) /* domain SID */
 670                         return False;
 671         } else {
 672                 memset((char *)&d_q->dom_sid, '\0', sizeof(d_q->dom_sid));
 673         }
 674
 675         return True;
 676 }
 677
 678 /*******************************************************************
 679 reads or writes a structure.
 680 ********************************************************************/
 681
 682 static BOOL lsa_io_dom_query_2(const char *desc, DOM_QUERY_2 *d_q, prs_struct *ps, int depth)
 683 {
 684         uint32 ptr = 1;
 685
 686         if (d_q == NULL)
 687                 return False;
 688
 689         prs_debug(ps, depth, desc, "lsa_io_dom_query_2");
 690         depth++;
 691
 692         if (!prs_align(ps))
 693                 return False;
 694
 695         if (!prs_uint32("auditing_enabled", ps, depth, &d_q->auditing_enabled))
 696                 return False;
 697         if (!prs_uint32("ptr   ", ps, depth, &ptr))
 698                 return False;
 699         if (!prs_uint32("count1", ps, depth, &d_q->count1))
 700                 return False;
 701         if (!prs_uint32("count2", ps, depth, &d_q->count2))
 702                 return False;
 703
 704         if (UNMARSHALLING(ps)) {
 705                 d_q->auditsettings = (uint32 *)talloc_zero(ps->mem_ctx, d_q->count2 * sizeof(uint32));
 706         }
 707
 708         if (d_q->auditsettings == NULL) {
 709                 DEBUG(1, ("lsa_io_dom_query_2: NULL auditsettings!\n"));
 710                 return False;
 711         }
 712
 713         if (!prs_uint32s(False, "auditsettings", ps, depth, d_q->auditsettings, d_q->count2))
 714                 return False;
 715
 716     return True;
 717 }
 718
 719 /*******************************************************************
 720  Reads or writes a dom query structure.
 721 ********************************************************************/
 722
 723 static BOOL lsa_io_dom_query_3(const char *desc, DOM_QUERY_3 *d_q, prs_struct *ps, int depth)
 724 {
 725         return lsa_io_dom_query("", d_q, ps, depth);
 726 }
 727
 728 /*******************************************************************
 729  Reads or writes a dom query structure.
 730 ********************************************************************/
 731
 732 static BOOL lsa_io_dom_query_5(const char *desc, DOM_QUERY_5 *d_q, prs_struct *ps, int depth)
 733 {
 734         return lsa_io_dom_query("", d_q, ps, depth);
 735 }
 736
 737 /*******************************************************************
 738  Reads or writes a dom query structure.
 739 ********************************************************************/
 740
 741 static BOOL lsa_io_dom_query_6(const char *desc, DOM_QUERY_6 *d_q, prs_struct *ps, int depth)
 742 {
 743         if (d_q == NULL)
 744                 return False;
 745
 746         prs_debug(ps, depth, desc, "lsa_io_dom_query_6");
 747         depth++;
 748
 749         if (!prs_uint16("server_role", ps, depth, &d_q->server_role))
 750                 return False;
 751
 752         return True;
 753 }
 754
 755 /*******************************************************************
 756  Reads or writes an LSA_R_QUERY_INFO structure.
 757 ********************************************************************/
 758
 759 BOOL lsa_io_r_query(const char *desc, LSA_R_QUERY_INFO *r_q, prs_struct *ps,
 760                     int depth)
 761 {
 762         prs_debug(ps, depth, desc, "lsa_io_r_query");
 763         depth++;
 764
 765         if(!prs_uint32("undoc_buffer", ps, depth, &r_q->undoc_buffer))
 766                 return False;
 767
 768         if (r_q->undoc_buffer != 0) {
 769                 if(!prs_uint16("info_class", ps, depth, &r_q->info_class))
 770                         return False;
 771
 772                 if(!prs_align(ps))
 773                         return False;
 774
 775                 switch (r_q->info_class) {
 776                 case 2:
 777                         if(!lsa_io_dom_query_2("", &r_q->dom.id2, ps, depth))
 778                                 return False;
 779                         break;
 780                 case 3:
 781                         if(!lsa_io_dom_query_3("", &r_q->dom.id3, ps, depth))
 782                                 return False;
 783                         break;
 784                 case 5:
 785                         if(!lsa_io_dom_query_5("", &r_q->dom.id5, ps, depth))
 786                                 return False;
 787                         break;
 788                 case 6:
 789                         if(!lsa_io_dom_query_6("", &r_q->dom.id6, ps, depth))
 790                                 return False;
 791                         break;
 792                 default:
 793                         /* PANIC! */
 794                         break;
 795                 }
 796         }
 797
 798         if(!prs_align(ps))
 799                 return False;
 800
 801         if(!prs_ntstatus("status", ps, depth, &r_q->status))
 802                 return False;
 803
 804         return True;
 805 }
 806
 807 /*******************************************************************
 808  Inits a LSA_SID_ENUM structure.
 809 ********************************************************************/
 810
 811 static void init_lsa_sid_enum(TALLOC_CTX *mem_ctx, LSA_SID_ENUM *sen,
 812                        int num_entries, DOM_SID *sids)
 813 {
 814         int i;
 815
 816         DEBUG(5, ("init_lsa_sid_enum\n"));
 817
 818         sen->num_entries  = num_entries;
 819         sen->ptr_sid_enum = (num_entries != 0);
 820         sen->num_entries2 = num_entries;
 821
 822         /* Allocate memory for sids and sid pointers */
 823
 824         if (num_entries == 0) return;
 825
 826         if ((sen->ptr_sid = (uint32 *)talloc_zero(mem_ctx, num_entries *
 827                                              sizeof(uint32))) == NULL) {
 828                 DEBUG(3, ("init_lsa_sid_enum(): out of memory for ptr_sid\n"));
 829                 return;
 830         }
 831
 832         if ((sen->sid = (DOM_SID2 *)talloc_zero(mem_ctx, num_entries *
 833                                            sizeof(DOM_SID2))) == NULL) {
 834                 DEBUG(3, ("init_lsa_sid_enum(): out of memory for sids\n"));
 835                 return;
 836         }
 837
 838         /* Copy across SIDs and SID pointers */
 839
 840         for (i = 0; i < num_entries; i++) {
 841                 sen->ptr_sid[i] = 1;
 842                 init_dom_sid2(&sen->sid[i], &sids[i]);
 843         }
 844 }
 845
 846 /*******************************************************************
 847  Reads or writes a LSA_SID_ENUM structure.
 848 ********************************************************************/
 849
 850 static BOOL lsa_io_sid_enum(const char *desc, LSA_SID_ENUM *sen, prs_struct *ps,
 851                             int depth)
 852 {
 853         int i;
 854
 855         prs_debug(ps, depth, desc, "lsa_io_sid_enum");
 856         depth++;
 857
 858         if(!prs_align(ps))
 859                 return False;
 860
 861         if(!prs_uint32("num_entries ", ps, depth, &sen->num_entries))
 862                 return False;
 863         if(!prs_uint32("ptr_sid_enum", ps, depth, &sen->ptr_sid_enum))
 864                 return False;
 865
 866         /*
 867            if the ptr is NULL, leave here. checked from a real w2k trace.
 868            JFM, 11/23/2001
 869          */
 870
 871         if (sen->ptr_sid_enum==0)
 872                 return True;
 873
 874         if(!prs_uint32("num_entries2", ps, depth, &sen->num_entries2))
 875                 return False;
 876
 877         /* Mallocate memory if we're unpacking from the wire */
 878
 879         if (UNMARSHALLING(ps)) {
 880                 if ((sen->ptr_sid = (uint32 *)prs_alloc_mem( ps,
 881                         sen->num_entries * sizeof(uint32))) == NULL) {
 882                         DEBUG(3, ("init_lsa_sid_enum(): out of memory for "
 883                                   "ptr_sid\n"));
 884                         return False;
 885                 }
 886
 887                 if ((sen->sid = (DOM_SID2 *)prs_alloc_mem( ps,
 888                         sen->num_entries * sizeof(DOM_SID2))) == NULL) {
 889                         DEBUG(3, ("init_lsa_sid_enum(): out of memory for "
 890                                   "sids\n"));
 891                         return False;
 892                 }
 893         }
 894
 895         for (i = 0; i < sen->num_entries; i++) {
 896                 fstring temp;
 897
 898                 slprintf(temp, sizeof(temp) - 1, "ptr_sid[%d]", i);
 899                 if(!prs_uint32(temp, ps, depth, &sen->ptr_sid[i])) {
 900                         return False;
 901                 }
 902         }
 903
 904         for (i = 0; i < sen->num_entries; i++) {
 905                 fstring temp;
 906
 907                 slprintf(temp, sizeof(temp) - 1, "sid[%d]", i);
 908                 if(!smb_io_dom_sid2(temp, &sen->sid[i], ps, depth)) {
 909                         return False;
 910                 }
 911         }
 912
 913         return True;
 914 }
 915
 916 /*******************************************************************
 917  Inits an LSA_R_ENUM_TRUST_DOM structure.
 918 ********************************************************************/
 919
 920 void init_q_lookup_sids(TALLOC_CTX *mem_ctx, LSA_Q_LOOKUP_SIDS *q_l,
 921                         POLICY_HND *hnd, int num_sids, DOM_SID *sids,
 922                         uint16 level)
 923 {
 924         DEBUG(5, ("init_r_enum_trust_dom\n"));
 925
 926         ZERO_STRUCTP(q_l);
 927
 928         memcpy(&q_l->pol, hnd, sizeof(q_l->pol));
 929         init_lsa_sid_enum(mem_ctx, &q_l->sids, num_sids, sids);
 930
 931         q_l->level.value = level;
 932 }
 933
 934 /*******************************************************************
 935  Reads or writes a LSA_Q_LOOKUP_SIDS structure.
 936 ********************************************************************/
 937
 938 BOOL lsa_io_q_lookup_sids(const char *desc, LSA_Q_LOOKUP_SIDS *q_s, prs_struct *ps,
 939                           int depth)
 940 {
 941         prs_debug(ps, depth, desc, "lsa_io_q_lookup_sids");
 942         depth++;
 943
 944         if(!prs_align(ps))
 945                 return False;
 946
 947         if(!smb_io_pol_hnd("pol_hnd", &q_s->pol, ps, depth)) /* policy handle */
 948                 return False;
 949         if(!lsa_io_sid_enum("sids   ", &q_s->sids, ps, depth)) /* sids to be looked up */
 950                 return False;
 951         if(!lsa_io_trans_names("names  ", &q_s->names, ps, depth)) /* translated names */
 952                 return False;
 953         if(!smb_io_lookup_level("switch ", &q_s->level, ps, depth)) /* lookup level */
 954                 return False;
 955
 956         if(!prs_uint32("mapped_count", ps, depth, &q_s->mapped_count))
 957                 return False;
 958
 959         return True;
 960 }
 961
 962 /*******************************************************************
 963  Reads or writes a structure.
 964 ********************************************************************/
 965
 966 static BOOL lsa_io_trans_names(const char *desc, LSA_TRANS_NAME_ENUM *trn,
 967                 prs_struct *ps, int depth)
 968 {
 969         int i;
 970
 971         prs_debug(ps, depth, desc, "lsa_io_trans_names");
 972         depth++;
 973
 974         if(!prs_align(ps))
 975                 return False;
 976
 977         if(!prs_uint32("num_entries    ", ps, depth, &trn->num_entries))
 978                 return False;
 979         if(!prs_uint32("ptr_trans_names", ps, depth, &trn->ptr_trans_names))
 980                 return False;
 981
 982         if (trn->ptr_trans_names != 0) {
 983                 if(!prs_uint32("num_entries2   ", ps, depth,
 984                                &trn->num_entries2))
 985                         return False;
 986
 987                 if (UNMARSHALLING(ps)) {
 988                         if ((trn->name = (LSA_TRANS_NAME *)
 989                              prs_alloc_mem(ps, trn->num_entries *
 990                                     sizeof(LSA_TRANS_NAME))) == NULL) {
 991                                 return False;
 992                         }
 993
 994                         if ((trn->uni_name = (UNISTR2 *)
 995                              prs_alloc_mem(ps, trn->num_entries *
 996                                     sizeof(UNISTR2))) == NULL) {
 997                                 return False;
 998                         }
 999                 }
1000
1001                 for (i = 0; i < trn->num_entries2; i++) {
1002                         fstring t;
1003                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1004
1005                         if(!lsa_io_trans_name(t, &trn->name[i], ps, depth)) /* translated name */
1006                                 return False;
1007                 }
1008
1009                 for (i = 0; i < trn->num_entries2; i++) {
1010                         fstring t;
1011                         slprintf(t, sizeof(t) - 1, "name[%d] ", i);
1012
1013                         if(!smb_io_unistr2(t, &trn->uni_name[i], trn->name[i].hdr_name.buffer, ps, depth))
1014                                 return False;
1015                         if(!prs_align(ps))
1016                                 return False;
1017                 }
1018         }
1019
1020         return True;
1021 }
1022
1023 /*******************************************************************
1024  Reads or writes a structure.
1025 ********************************************************************/
1026
1027 BOOL lsa_io_r_lookup_sids(const char *desc, LSA_R_LOOKUP_SIDS *r_s,
1028                           prs_struct *ps, int depth)
1029 {
1030         prs_debug(ps, depth, desc, "lsa_io_r_lookup_sids");
1031         depth++;
1032
1033         if(!prs_align(ps))
1034                 return False;
1035
1036         if(!prs_uint32("ptr_dom_ref", ps, depth, &r_s->ptr_dom_ref))
1037                 return False;
1038
1039         if (r_s->ptr_dom_ref != 0)
1040                 if(!lsa_io_dom_r_ref ("dom_ref", r_s->dom_ref, ps, depth)) /* domain reference info */
1041                         return False;
1042
1043         if(!lsa_io_trans_names("names  ", r_s->names, ps, depth)) /* translated names */
1044                 return False;
1045
1046         if(!prs_align(ps))
1047                 return False;
1048
1049         if(!prs_uint32("mapped_count", ps, depth, &r_s->mapped_count))
1050                 return False;
1051
1052         if(!prs_ntstatus("status      ", ps, depth, &r_s->status))
1053                 return False;
1054
1055         return True;
1056 }
1057
1058 /*******************************************************************
1059 makes a structure.
1060 ********************************************************************/
1061
1062 void init_q_lookup_names(TALLOC_CTX *mem_ctx, LSA_Q_LOOKUP_NAMES *q_l,
1063                          POLICY_HND *hnd, int num_names, const char **names)
1064 {
1065         int i;
1066
1067         DEBUG(5, ("init_q_lookup_names\n"));
1068
1069         ZERO_STRUCTP(q_l);
1070
1071         q_l->pol = *hnd;
1072         q_l->num_entries = num_names;
1073         q_l->num_entries2 = num_names;
1074         q_l->lookup_level = 1;
1075
1076         if ((q_l->uni_name = (UNISTR2 *)talloc_zero(
1077                 mem_ctx, num_names * sizeof(UNISTR2))) == NULL) {
1078                 DEBUG(3, ("init_q_lookup_names(): out of memory\n"));
1079                 return;
1080         }
1081
1082         if ((q_l->hdr_name = (UNIHDR *)talloc_zero(
1083                 mem_ctx, num_names * sizeof(UNIHDR))) == NULL) {
1084                 DEBUG(3, ("init_q_lookup_names(): out of memory\n"));
1085                 return;
1086         }
1087
1088         for (i = 0; i < num_names; i++) {
1089                 int len;
1090                 len = strlen(names[i]);
1091
1092                 init_uni_hdr(&q_l->hdr_name[i], len);
1093                 init_unistr2(&q_l->uni_name[i], names[i]);
1094         }
1095 }
1096
1097 /*******************************************************************
1098 reads or writes a structure.
1099 ********************************************************************/
1100
1101 BOOL lsa_io_q_lookup_names(const char *desc, LSA_Q_LOOKUP_NAMES *q_r,
1102                            prs_struct *ps, int depth)
1103 {
1104         int i;
1105
1106         prs_debug(ps, depth, desc, "lsa_io_q_lookup_names");
1107         depth++;
1108
1109         if(!prs_align(ps))
1110                 return False;
1111
1112         if(!smb_io_pol_hnd("", &q_r->pol, ps, depth)) /* policy handle */
1113                 return False;
1114
1115         if(!prs_align(ps))
1116                 return False;
1117         if(!prs_uint32("num_entries    ", ps, depth, &q_r->num_entries))
1118                 return False;
1119         if(!prs_uint32("num_entries2   ", ps, depth, &q_r->num_entries2))
1120                 return False;
1121
1122         if (UNMARSHALLING(ps)) {
1123                 if (q_r->num_entries) {
1124                         if ((q_r->hdr_name = (UNIHDR *)prs_alloc_mem(ps,
1125                                         q_r->num_entries * sizeof(UNIHDR))) == NULL)
1126                                 return False;
1127                         if ((q_r->uni_name = (UNISTR2 *)prs_alloc_mem(ps,
1128                                         q_r->num_entries * sizeof(UNISTR2))) == NULL)
1129                                 return False;
1130                 }
1131         }
1132
1133         for (i = 0; i < q_r->num_entries; i++) {
1134                 if(!prs_align(ps))
1135                         return False;
1136                 if(!smb_io_unihdr("hdr_name", &q_r->hdr_name[i], ps, depth)) /* pointer names */
1137                         return False;
1138         }
1139
1140         for (i = 0; i < q_r->num_entries; i++) {
1141                 if(!prs_align(ps))
1142                         return False;
1143                 if(!smb_io_unistr2("dom_name", &q_r->uni_name[i], q_r->hdr_name[i].buffer, ps, depth)) /* names to be looked up */
1144                         return False;
1145         }
1146
1147         if(!prs_align(ps))
1148                 return False;
1149         if(!prs_uint32("num_trans_entries ", ps, depth, &q_r->num_trans_entries))
1150                 return False;
1151         if(!prs_uint32("ptr_trans_sids ", ps, depth, &q_r->ptr_trans_sids))
1152                 return False;
1153         if(!prs_uint32("lookup_level   ", ps, depth, &q_r->lookup_level))
1154                 return False;
1155         if(!prs_uint32("mapped_count   ", ps, depth, &q_r->mapped_count))
1156                 return False;
1157
1158         return True;
1159 }
1160
1161 /*******************************************************************
1162 reads or writes a structure.
1163 ********************************************************************/
1164
1165 BOOL lsa_io_r_lookup_names(const char *desc, LSA_R_LOOKUP_NAMES *r_r,
1166                            prs_struct *ps, int depth)
1167 {
1168         int i;
1169
1170         prs_debug(ps, depth, desc, "lsa_io_r_lookup_names");
1171         depth++;
1172
1173         if(!prs_align(ps))
1174                 return False;
1175
1176         if(!prs_uint32("ptr_dom_ref", ps, depth, &r_r->ptr_dom_ref))
1177                 return False;
1178
1179         if (r_r->ptr_dom_ref != 0)
1180                 if(!lsa_io_dom_r_ref("", r_r->dom_ref, ps, depth))
1181                         return False;
1182
1183         if(!prs_uint32("num_entries", ps, depth, &r_r->num_entries))
1184                 return False;
1185         if(!prs_uint32("ptr_entries", ps, depth, &r_r->ptr_entries))
1186                 return False;
1187
1188         if (r_r->ptr_entries != 0) {
1189                 if(!prs_uint32("num_entries2", ps, depth, &r_r->num_entries2))
1190                         return False;
1191
1192                 if (r_r->num_entries2 != r_r->num_entries) {
1193                         /* RPC fault */
1194                         return False;
1195                 }
1196
1197                 if (UNMARSHALLING(ps)) {
1198                         if ((r_r->dom_rid = (DOM_RID2 *)prs_alloc_mem(ps, r_r->num_entries2 * sizeof(DOM_RID2)))
1199                             == NULL) {
1200                                 DEBUG(3, ("lsa_io_r_lookup_names(): out of memory\n"));
1201                                 return False;
1202                         }
1203                 }
1204
1205                 for (i = 0; i < r_r->num_entries2; i++)
1206                         if(!smb_io_dom_rid2("", &r_r->dom_rid[i], ps, depth)) /* domain RIDs being looked up */
1207                                 return False;
1208         }
1209
1210         if(!prs_uint32("mapped_count", ps, depth, &r_r->mapped_count))
1211                 return False;
1212
1213         if(!prs_ntstatus("status      ", ps, depth, &r_r->status))
1214                 return False;
1215
1216         return True;
1217 }
1218
1219
1220 /*******************************************************************
1221  Inits an LSA_Q_CLOSE structure.
1222 ********************************************************************/
1223
1224 void init_lsa_q_close(LSA_Q_CLOSE *q_c, POLICY_HND *hnd)
1225 {
1226         DEBUG(5, ("init_lsa_q_close\n"));
1227
1228         memcpy(&q_c->pol, hnd, sizeof(q_c->pol));
1229 }
1230
1231 /*******************************************************************
1232  Reads or writes an LSA_Q_CLOSE structure.
1233 ********************************************************************/
1234
1235 BOOL lsa_io_q_close(const char *desc, LSA_Q_CLOSE *q_c, prs_struct *ps, int depth)
1236 {
1237         prs_debug(ps, depth, desc, "lsa_io_q_close");
1238         depth++;
1239
1240         if(!smb_io_pol_hnd("", &q_c->pol, ps, depth))
1241                 return False;
1242
1243         return True;
1244 }
1245
1246 /*******************************************************************
1247  Reads or writes an LSA_R_CLOSE structure.
1248 ********************************************************************/
1249
1250 BOOL lsa_io_r_close(const char *desc,  LSA_R_CLOSE *r_c, prs_struct *ps, int depth)
1251 {
1252         prs_debug(ps, depth, desc, "lsa_io_r_close");
1253         depth++;
1254
1255         if(!smb_io_pol_hnd("", &r_c->pol, ps, depth))
1256                 return False;
1257
1258         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1259                 return False;
1260
1261         return True;
1262 }
1263
1264 /*******************************************************************
1265  Reads or writes an LSA_Q_OPEN_SECRET structure.
1266 ********************************************************************/
1267
1268 BOOL lsa_io_q_open_secret(const char *desc, LSA_Q_OPEN_SECRET *q_c, prs_struct *ps, int depth)
1269 {
1270         prs_debug(ps, depth, desc, "lsa_io_q_open_secret");
1271         depth++;
1272
1273         /* Don't bother to read or write at present... */
1274         return True;
1275 }
1276
1277 /*******************************************************************
1278  Reads or writes an LSA_R_OPEN_SECRET structure.
1279 ********************************************************************/
1280
1281 BOOL lsa_io_r_open_secret(const char *desc, LSA_R_OPEN_SECRET *r_c, prs_struct *ps, int depth)
1282 {
1283         prs_debug(ps, depth, desc, "lsa_io_r_open_secret");
1284         depth++;
1285
1286         if(!prs_align(ps))
1287                 return False;
1288
1289         if(!prs_uint32("dummy1", ps, depth, &r_c->dummy1))
1290                 return False;
1291         if(!prs_uint32("dummy2", ps, depth, &r_c->dummy2))
1292                 return False;
1293         if(!prs_uint32("dummy3", ps, depth, &r_c->dummy3))
1294                 return False;
1295         if(!prs_uint32("dummy4", ps, depth, &r_c->dummy4))
1296                 return False;
1297         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1298                 return False;
1299
1300         return True;
1301 }
1302
1303 /*******************************************************************
1304  Inits an LSA_Q_ENUM_PRIVS structure.
1305 ********************************************************************/
1306
1307 void init_q_enum_privs(LSA_Q_ENUM_PRIVS *q_q, POLICY_HND *hnd, uint32 enum_context, uint32 pref_max_length)
1308 {
1309         DEBUG(5, ("init_q_enum_privs\n"));
1310
1311         memcpy(&q_q->pol, hnd, sizeof(q_q->pol));
1312
1313         q_q->enum_context = enum_context;
1314         q_q->pref_max_length = pref_max_length;
1315 }
1316
1317 /*******************************************************************
1318 reads or writes a structure.
1319 ********************************************************************/
1320 BOOL lsa_io_q_enum_privs(const char *desc, LSA_Q_ENUM_PRIVS *q_q, prs_struct *ps, int depth)
1321 {
1322         if (q_q == NULL)
1323                 return False;
1324
1325         prs_debug(ps, depth, desc, "lsa_io_q_enum_privs");
1326         depth++;
1327
1328         if (!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1329                 return False;
1330
1331         if(!prs_uint32("enum_context   ", ps, depth, &q_q->enum_context))
1332                 return False;
1333         if(!prs_uint32("pref_max_length", ps, depth, &q_q->pref_max_length))
1334                 return False;
1335
1336         return True;
1337 }
1338
1339 /*******************************************************************
1340 reads or writes a structure.
1341 ********************************************************************/
1342 static BOOL lsa_io_priv_entries(const char *desc, LSA_PRIV_ENTRY *entries, uint32 count, prs_struct *ps, int depth)
1343 {
1344         uint32 i;
1345
1346         if (entries == NULL)
1347                 return False;
1348
1349         prs_debug(ps, depth, desc, "lsa_io_priv_entries");
1350         depth++;
1351
1352         if(!prs_align(ps))
1353                 return False;
1354
1355         for (i = 0; i < count; i++) {
1356                 if (!smb_io_unihdr("", &entries[i].hdr_name, ps, depth))
1357                         return False;
1358                 if(!prs_uint32("luid_low ", ps, depth, &entries[i].luid_low))
1359                         return False;
1360                 if(!prs_uint32("luid_high", ps, depth, &entries[i].luid_high))
1361                         return False;
1362         }
1363
1364         for (i = 0; i < count; i++)
1365                 if (!smb_io_unistr2("", &entries[i].name, entries[i].hdr_name.buffer, ps, depth))
1366                         return False;
1367
1368         return True;
1369 }
1370
1371 /*******************************************************************
1372  Inits an LSA_R_ENUM_PRIVS structure.
1373 ********************************************************************/
1374
1375 void init_lsa_r_enum_privs(LSA_R_ENUM_PRIVS *r_u, uint32 enum_context,
1376                           uint32 count, LSA_PRIV_ENTRY *entries)
1377 {
1378         DEBUG(5, ("init_lsa_r_enum_privs\n"));
1379
1380         r_u->enum_context=enum_context;
1381         r_u->count=count;
1382
1383         if (entries!=NULL) {
1384                 r_u->ptr=1;
1385                 r_u->count1=count;
1386                 r_u->privs=entries;
1387         } else {
1388                 r_u->ptr=0;
1389                 r_u->count1=0;
1390                 r_u->privs=NULL;
1391         }
1392 }
1393
1394 /*******************************************************************
1395 reads or writes a structure.
1396 ********************************************************************/
1397 BOOL lsa_io_r_enum_privs(const char *desc, LSA_R_ENUM_PRIVS *r_q, prs_struct *ps, int depth)
1398 {
1399         if (r_q == NULL)
1400                 return False;
1401
1402         prs_debug(ps, depth, desc, "lsa_io_r_enum_privs");
1403         depth++;
1404
1405         if(!prs_align(ps))
1406                 return False;
1407
1408         if(!prs_uint32("enum_context", ps, depth, &r_q->enum_context))
1409                 return False;
1410         if(!prs_uint32("count", ps, depth, &r_q->count))
1411                 return False;
1412         if(!prs_uint32("ptr", ps, depth, &r_q->ptr))
1413                 return False;
1414
1415         if (r_q->ptr) {
1416                 if(!prs_uint32("count1", ps, depth, &r_q->count1))
1417                         return False;
1418
1419                 if (UNMARSHALLING(ps))
1420                         if (!(r_q->privs = (LSA_PRIV_ENTRY *)prs_alloc_mem(ps, sizeof(LSA_PRIV_ENTRY) * r_q->count1)))
1421                                 return False;
1422
1423                 if (!lsa_io_priv_entries("", r_q->privs, r_q->count1, ps, depth))
1424                         return False;
1425         }
1426
1427         if(!prs_align(ps))
1428                 return False;
1429
1430         if(!prs_ntstatus("status", ps, depth, &r_q->status))
1431                 return False;
1432
1433         return True;
1434 }
1435
1436 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)
1437 {
1438         int len_name = strlen(name);
1439
1440         if(len_name == 0)
1441                 len_name = 1;
1442
1443         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1444
1445         init_uni_hdr(&trn->hdr_name, len_name);
1446         init_unistr2(&trn->name, name);
1447         trn->lang_id = lang_id;
1448         trn->lang_id_sys = lang_id_sys;
1449 }
1450
1451 /*******************************************************************
1452 reads or writes a structure.
1453 ********************************************************************/
1454 BOOL lsa_io_q_priv_get_dispname(const char *desc, LSA_Q_PRIV_GET_DISPNAME *q_q, prs_struct *ps, int depth)
1455 {
1456         if (q_q == NULL)
1457                 return False;
1458
1459         prs_debug(ps, depth, desc, "lsa_io_q_priv_get_dispname");
1460         depth++;
1461
1462         if(!prs_align(ps))
1463                 return False;
1464
1465         if (!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1466                 return False;
1467
1468         if (!smb_io_unihdr("hdr_name", &q_q->hdr_name, ps, depth))
1469                 return False;
1470
1471         if (!smb_io_unistr2("name", &q_q->name, q_q->hdr_name.buffer, ps, depth))
1472                 return False;
1473
1474         if(!prs_uint16("lang_id    ", ps, depth, &q_q->lang_id))
1475                 return False;
1476         if(!prs_uint16("lang_id_sys", ps, depth, &q_q->lang_id_sys))
1477                 return False;
1478
1479         return True;
1480 }
1481
1482 /*******************************************************************
1483 reads or writes a structure.
1484 ********************************************************************/
1485 BOOL lsa_io_r_priv_get_dispname(const char *desc, LSA_R_PRIV_GET_DISPNAME *r_q, prs_struct *ps, int depth)
1486 {
1487         if (r_q == NULL)
1488                 return False;
1489
1490         prs_debug(ps, depth, desc, "lsa_io_r_priv_get_dispname");
1491         depth++;
1492
1493         if (!prs_align(ps))
1494                 return False;
1495
1496         if (!prs_uint32("ptr_info", ps, depth, &r_q->ptr_info))
1497                 return False;
1498
1499         if (r_q->ptr_info){
1500                 if (!smb_io_unihdr("hdr_name", &r_q->hdr_desc, ps, depth))
1501                         return False;
1502
1503                 if (!smb_io_unistr2("desc", &r_q->desc, r_q->hdr_desc.buffer, ps, depth))
1504                         return False;
1505         }
1506 /*
1507         if(!prs_align(ps))
1508                 return False;
1509 */
1510         if(!prs_uint16("lang_id", ps, depth, &r_q->lang_id))
1511                 return False;
1512
1513         if(!prs_align(ps))
1514                 return False;
1515         if(!prs_ntstatus("status", ps, depth, &r_q->status))
1516                 return False;
1517
1518         return True;
1519 }
1520
1521 void init_lsa_q_enum_accounts(LSA_Q_ENUM_ACCOUNTS *trn, POLICY_HND *hnd, uint32 enum_context, uint32 pref_max_length)
1522 {
1523         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1524
1525         trn->enum_context = enum_context;
1526         trn->pref_max_length = pref_max_length;
1527 }
1528
1529 /*******************************************************************
1530 reads or writes a structure.
1531 ********************************************************************/
1532 BOOL lsa_io_q_enum_accounts(const char *desc, LSA_Q_ENUM_ACCOUNTS *q_q, prs_struct *ps, int depth)
1533 {
1534         if (q_q == NULL)
1535                 return False;
1536
1537         prs_debug(ps, depth, desc, "lsa_io_q_enum_accounts");
1538         depth++;
1539
1540         if (!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1541                 return False;
1542
1543         if(!prs_uint32("enum_context   ", ps, depth, &q_q->enum_context))
1544                 return False;
1545         if(!prs_uint32("pref_max_length", ps, depth, &q_q->pref_max_length))
1546                 return False;
1547
1548         return True;
1549 }
1550
1551 /*******************************************************************
1552  Inits an LSA_R_ENUM_PRIVS structure.
1553 ********************************************************************/
1554
1555 void init_lsa_r_enum_accounts(LSA_R_ENUM_ACCOUNTS *r_u, uint32 enum_context)
1556 {
1557         DEBUG(5, ("init_lsa_r_enum_accounts\n"));
1558
1559         r_u->enum_context=enum_context;
1560         if (r_u->enum_context!=0) {
1561                 r_u->sids.num_entries=enum_context;
1562                 r_u->sids.ptr_sid_enum=1;
1563                 r_u->sids.num_entries2=enum_context;
1564         } else {
1565                 r_u->sids.num_entries=0;
1566                 r_u->sids.ptr_sid_enum=0;
1567                 r_u->sids.num_entries2=0;
1568         }
1569 }
1570
1571 /*******************************************************************
1572 reads or writes a structure.
1573 ********************************************************************/
1574 BOOL lsa_io_r_enum_accounts(const char *desc, LSA_R_ENUM_ACCOUNTS *r_q, prs_struct *ps, int depth)
1575 {
1576         if (r_q == NULL)
1577                 return False;
1578
1579         prs_debug(ps, depth, desc, "lsa_io_r_enum_accounts");
1580         depth++;
1581
1582         if (!prs_align(ps))
1583                 return False;
1584
1585         if(!prs_uint32("enum_context", ps, depth, &r_q->enum_context))
1586                 return False;
1587
1588         if (!lsa_io_sid_enum("sids", &r_q->sids, ps, depth))
1589                 return False;
1590
1591         if (!prs_align(ps))
1592                 return False;
1593
1594         if(!prs_ntstatus("status", ps, depth, &r_q->status))
1595                 return False;
1596
1597         return True;
1598 }
1599
1600
1601 /*******************************************************************
1602  Reads or writes an LSA_Q_UNK_GET_CONNUSER structure.
1603 ********************************************************************/
1604
1605 BOOL lsa_io_q_unk_get_connuser(const char *desc, LSA_Q_UNK_GET_CONNUSER *q_c, prs_struct *ps, int depth)
1606 {
1607         prs_debug(ps, depth, desc, "lsa_io_q_unk_get_connuser");
1608         depth++;
1609
1610         if(!prs_align(ps))
1611                 return False;
1612
1613         if(!prs_uint32("ptr_srvname", ps, depth, &q_c->ptr_srvname))
1614                 return False;
1615
1616         if(!smb_io_unistr2("uni2_srvname", &q_c->uni2_srvname, q_c->ptr_srvname, ps, depth)) /* server name to be looked up */
1617                 return False;
1618
1619         if (!prs_align(ps))
1620           return False;
1621
1622         if(!prs_uint32("unk1", ps, depth, &q_c->unk1))
1623                 return False;
1624         if(!prs_uint32("unk2", ps, depth, &q_c->unk2))
1625                 return False;
1626         if(!prs_uint32("unk3", ps, depth, &q_c->unk3))
1627                 return False;
1628
1629         /* Don't bother to read or write at present... */
1630         return True;
1631 }
1632
1633 /*******************************************************************
1634  Reads or writes an LSA_R_UNK_GET_CONNUSER structure.
1635 ********************************************************************/
1636
1637 BOOL lsa_io_r_unk_get_connuser(const char *desc, LSA_R_UNK_GET_CONNUSER *r_c, prs_struct *ps, int depth)
1638 {
1639         prs_debug(ps, depth, desc, "lsa_io_r_unk_get_connuser");
1640         depth++;
1641
1642         if(!prs_align(ps))
1643                 return False;
1644
1645         if(!prs_uint32("ptr_user_name", ps, depth, &r_c->ptr_user_name))
1646                 return False;
1647         if(!smb_io_unihdr("hdr_user_name", &r_c->hdr_user_name, ps, depth))
1648                 return False;
1649         if(!smb_io_unistr2("uni2_user_name", &r_c->uni2_user_name, r_c->ptr_user_name, ps, depth))
1650                 return False;
1651
1652         if (!prs_align(ps))
1653           return False;
1654
1655         if(!prs_uint32("unk1", ps, depth, &r_c->unk1))
1656                 return False;
1657
1658         if(!prs_uint32("ptr_dom_name", ps, depth, &r_c->ptr_dom_name))
1659                 return False;
1660         if(!smb_io_unihdr("hdr_dom_name", &r_c->hdr_dom_name, ps, depth))
1661                 return False;
1662         if(!smb_io_unistr2("uni2_dom_name", &r_c->uni2_dom_name, r_c->ptr_dom_name, ps, depth))
1663                 return False;
1664
1665         if (!prs_align(ps))
1666           return False;
1667
1668         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1669                 return False;
1670
1671         return True;
1672 }
1673
1674 void init_lsa_q_open_account(LSA_Q_OPENACCOUNT *trn, POLICY_HND *hnd, DOM_SID *sid, uint32 desired_access)
1675 {
1676         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1677
1678         init_dom_sid2(&trn->sid, sid);
1679         trn->access = desired_access;
1680 }
1681
1682 /*******************************************************************
1683  Reads or writes an LSA_Q_OPENACCOUNT structure.
1684 ********************************************************************/
1685
1686 BOOL lsa_io_q_open_account(const char *desc, LSA_Q_OPENACCOUNT *r_c, prs_struct *ps, int depth)
1687 {
1688         prs_debug(ps, depth, desc, "lsa_io_q_open_account");
1689         depth++;
1690
1691         if(!prs_align(ps))
1692                 return False;
1693
1694         if(!smb_io_pol_hnd("pol", &r_c->pol, ps, depth))
1695                 return False;
1696
1697         if(!smb_io_dom_sid2("sid", &r_c->sid, ps, depth)) /* domain SID */
1698                 return False;
1699
1700         if(!prs_uint32("access", ps, depth, &r_c->access))
1701                 return False;
1702
1703         return True;
1704 }
1705
1706 /*******************************************************************
1707  Reads or writes an LSA_R_OPENACCOUNT structure.
1708 ********************************************************************/
1709
1710 BOOL lsa_io_r_open_account(const char *desc, LSA_R_OPENACCOUNT  *r_c, prs_struct *ps, int depth)
1711 {
1712         prs_debug(ps, depth, desc, "lsa_io_r_open_account");
1713         depth++;
1714
1715         if(!prs_align(ps))
1716                 return False;
1717
1718         if(!smb_io_pol_hnd("pol", &r_c->pol, ps, depth))
1719                 return False;
1720
1721         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1722                 return False;
1723
1724         return True;
1725 }
1726
1727
1728 void init_lsa_q_enum_privsaccount(LSA_Q_ENUMPRIVSACCOUNT *trn, POLICY_HND *hnd)
1729 {
1730         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1731
1732 }
1733
1734 /*******************************************************************
1735  Reads or writes an LSA_Q_ENUMPRIVSACCOUNT structure.
1736 ********************************************************************/
1737
1738 BOOL lsa_io_q_enum_privsaccount(const char *desc, LSA_Q_ENUMPRIVSACCOUNT *r_c, prs_struct *ps, int depth)
1739 {
1740         prs_debug(ps, depth, desc, "lsa_io_q_enum_privsaccount");
1741         depth++;
1742
1743         if(!prs_align(ps))
1744                 return False;
1745
1746         if(!smb_io_pol_hnd("pol", &r_c->pol, ps, depth))
1747                 return False;
1748
1749         return True;
1750 }
1751
1752 /*******************************************************************
1753  Reads or writes an LUID structure.
1754 ********************************************************************/
1755
1756 static BOOL lsa_io_luid(const char *desc, LUID *r_c, prs_struct *ps, int depth)
1757 {
1758         prs_debug(ps, depth, desc, "lsa_io_luid");
1759         depth++;
1760
1761         if(!prs_align(ps))
1762                 return False;
1763
1764         if(!prs_uint32("low", ps, depth, &r_c->low))
1765                 return False;
1766
1767         if(!prs_uint32("high", ps, depth, &r_c->high))
1768                 return False;
1769
1770         return True;
1771 }
1772
1773 /*******************************************************************
1774  Reads or writes an LUID_ATTR structure.
1775 ********************************************************************/
1776
1777 static BOOL lsa_io_luid_attr(const char *desc, LUID_ATTR *r_c, prs_struct *ps, int depth)
1778 {
1779         prs_debug(ps, depth, desc, "lsa_io_luid_attr");
1780         depth++;
1781
1782         if(!prs_align(ps))
1783                 return False;
1784
1785         if (!lsa_io_luid(desc, &r_c->luid, ps, depth))
1786                 return False;
1787
1788         if(!prs_uint32("attr", ps, depth, &r_c->attr))
1789                 return False;
1790
1791         return True;
1792 }
1793
1794 /*******************************************************************
1795  Reads or writes an PRIVILEGE_SET structure.
1796 ********************************************************************/
1797
1798 static BOOL lsa_io_privilege_set(const char *desc, PRIVILEGE_SET *r_c, prs_struct *ps, int depth)
1799 {
1800         uint32 i;
1801
1802         prs_debug(ps, depth, desc, "lsa_io_privilege_set");
1803         depth++;
1804
1805         if(!prs_align(ps))
1806                 return False;
1807
1808         if(!prs_uint32("count", ps, depth, &r_c->count))
1809                 return False;
1810         if(!prs_uint32("control", ps, depth, &r_c->control))
1811                 return False;
1812
1813         for (i=0; i<r_c->count; i++) {
1814                 if (!lsa_io_luid_attr(desc, &r_c->set[i], ps, depth))
1815                         return False;
1816         }
1817
1818         return True;
1819 }
1820
1821 void init_lsa_r_enum_privsaccount(LSA_R_ENUMPRIVSACCOUNT *r_u, LUID_ATTR *set, uint32 count, uint32 control)
1822 {
1823         r_u->ptr=1;
1824         r_u->count=count;
1825         r_u->set.set=set;
1826         r_u->set.count=count;
1827         r_u->set.control=control;
1828         DEBUG(10,("init_lsa_r_enum_privsaccount: %d %d privileges\n", r_u->count, r_u->set.count));
1829 }
1830
1831 /*******************************************************************
1832  Reads or writes an LSA_R_ENUMPRIVSACCOUNT structure.
1833 ********************************************************************/
1834
1835 BOOL lsa_io_r_enum_privsaccount(const char *desc, LSA_R_ENUMPRIVSACCOUNT *r_c, prs_struct *ps, int depth)
1836 {
1837         prs_debug(ps, depth, desc, "lsa_io_r_enum_privsaccount");
1838         depth++;
1839
1840         if(!prs_align(ps))
1841                 return False;
1842
1843         if(!prs_uint32("ptr", ps, depth, &r_c->ptr))
1844                 return False;
1845
1846         if (r_c->ptr!=0) {
1847                 if(!prs_uint32("count", ps, depth, &r_c->count))
1848                         return False;
1849
1850                 /* malloc memory if unmarshalling here */
1851
1852                 if (UNMARSHALLING(ps) && r_c->count!=0) {
1853                         if (!(r_c->set.set = (LUID_ATTR *)prs_alloc_mem(ps,sizeof(LUID_ATTR) * r_c->count)))
1854                                 return False;
1855
1856                 }
1857
1858                 if(!lsa_io_privilege_set(desc, &r_c->set, ps, depth))
1859                         return False;
1860         }
1861
1862         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1863                 return False;
1864
1865         return True;
1866 }
1867
1868
1869
1870 /*******************************************************************
1871  Reads or writes an  LSA_Q_GETSYSTEMACCOUNTstructure.
1872 ********************************************************************/
1873
1874 BOOL lsa_io_q_getsystemaccount(const char *desc, LSA_Q_GETSYSTEMACCOUNT  *r_c, prs_struct *ps, int depth)
1875 {
1876         prs_debug(ps, depth, desc, "lsa_io_q_getsystemaccount");
1877         depth++;
1878
1879         if(!prs_align(ps))
1880                 return False;
1881
1882         if(!smb_io_pol_hnd("pol", &r_c->pol, ps, depth))
1883                 return False;
1884
1885         return True;
1886 }
1887
1888 /*******************************************************************
1889  Reads or writes an  LSA_R_GETSYSTEMACCOUNTstructure.
1890 ********************************************************************/
1891
1892 BOOL lsa_io_r_getsystemaccount(const char *desc, LSA_R_GETSYSTEMACCOUNT  *r_c, prs_struct *ps, int depth)
1893 {
1894         prs_debug(ps, depth, desc, "lsa_io_r_getsystemaccount");
1895         depth++;
1896
1897         if(!prs_align(ps))
1898                 return False;
1899
1900         if(!prs_uint32("access", ps, depth, &r_c->access))
1901                 return False;
1902
1903         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1904                 return False;
1905
1906         return True;
1907 }
1908
1909
1910 /*******************************************************************
1911  Reads or writes an LSA_Q_SETSYSTEMACCOUNT structure.
1912 ********************************************************************/
1913
1914 BOOL lsa_io_q_setsystemaccount(const char *desc, LSA_Q_SETSYSTEMACCOUNT  *r_c, prs_struct *ps, int depth)
1915 {
1916         prs_debug(ps, depth, desc, "lsa_io_q_setsystemaccount");
1917         depth++;
1918
1919         if(!prs_align(ps))
1920                 return False;
1921
1922         if(!smb_io_pol_hnd("pol", &r_c->pol, ps, depth))
1923                 return False;
1924
1925         if(!prs_uint32("access", ps, depth, &r_c->access))
1926                 return False;
1927
1928         return True;
1929 }
1930
1931 /*******************************************************************
1932  Reads or writes an LSA_R_SETSYSTEMACCOUNT structure.
1933 ********************************************************************/
1934
1935 BOOL lsa_io_r_setsystemaccount(const char *desc, LSA_R_SETSYSTEMACCOUNT  *r_c, prs_struct *ps, int depth)
1936 {
1937         prs_debug(ps, depth, desc, "lsa_io_r_setsystemaccount");
1938         depth++;
1939
1940         if(!prs_align(ps))
1941                 return False;
1942
1943         if(!prs_ntstatus("status", ps, depth, &r_c->status))
1944                 return False;
1945
1946         return True;
1947 }
1948
1949
1950 void init_lsa_q_lookupprivvalue(LSA_Q_LOOKUPPRIVVALUE *trn, POLICY_HND *hnd, const char *name)
1951 {
1952         int len_name = strlen(name);
1953         memcpy(&trn->pol, hnd, sizeof(trn->pol));
1954
1955         if(len_name == 0)
1956                 len_name = 1;
1957
1958         init_uni_hdr(&trn->hdr_right, len_name);
1959         init_unistr2(&trn->uni2_right, name);
1960 }
1961
1962 /*******************************************************************
1963  Reads or writes an LSA_Q_LOOKUPPRIVVALUE  structure.
1964 ********************************************************************/
1965
1966 BOOL lsa_io_q_lookupprivvalue(const char *desc, LSA_Q_LOOKUPPRIVVALUE  *r_c, prs_struct *ps, int depth)
1967 {
1968         prs_debug(ps, depth, desc, "lsa_io_q_lookupprivvalue");
1969         depth++;
1970
1971         if(!prs_align(ps))
1972                 return False;
1973
1974         if(!smb_io_pol_hnd("pol", &r_c->pol, ps, depth))
1975                 return False;
1976         if(!smb_io_unihdr ("hdr_name", &r_c->hdr_right, ps, depth))
1977                 return False;
1978         if(!smb_io_unistr2("uni2_right", &r_c->uni2_right, r_c->hdr_right.buffer, ps, depth))
1979                 return False;
1980
1981         return True;
1982 }
1983
1984 /*******************************************************************
1985  Reads or writes an  LSA_R_LOOKUPPRIVVALUE structure.
1986 ********************************************************************/
1987
1988 BOOL lsa_io_r_lookupprivvalue(const char *desc, LSA_R_LOOKUPPRIVVALUE  *r_c, prs_struct *ps, int depth)
1989 {
1990         prs_debug(ps, depth, desc, "lsa_io_r_lookupprivvalue");
1991         depth++;
1992
1993         if(!prs_align(ps))
1994                 return False;
1995
1996         if(!lsa_io_luid("luid", &r_c->luid, ps, depth))
1997                 return False;
1998
1999         if(!prs_ntstatus("status", ps, depth, &r_c->status))
2000                 return False;
2001
2002         return True;
2003 }
2004
2005
2006 /*******************************************************************
2007  Reads or writes an LSA_Q_ADDPRIVS structure.
2008 ********************************************************************/
2009
2010 BOOL lsa_io_q_addprivs(const char *desc, LSA_Q_ADDPRIVS *r_c, prs_struct *ps, int depth)
2011 {
2012         prs_debug(ps, depth, desc, "lsa_io_q_addprivs");
2013         depth++;
2014
2015         if(!prs_align(ps))
2016                 return False;
2017
2018         if(!smb_io_pol_hnd("pol", &r_c->pol, ps, depth))
2019                 return False;
2020
2021         if(!prs_uint32("count", ps, depth, &r_c->count))
2022                 return False;
2023
2024         if (UNMARSHALLING(ps) && r_c->count!=0) {
2025                 if (!(r_c->set.set = (LUID_ATTR *)prs_alloc_mem(ps,sizeof(LUID_ATTR) * r_c->count)))
2026                         return False;
2027         }
2028
2029         if(!lsa_io_privilege_set(desc, &r_c->set, ps, depth))
2030                 return False;
2031
2032         return True;
2033 }
2034
2035 /*******************************************************************
2036  Reads or writes an LSA_R_ADDPRIVS structure.
2037 ********************************************************************/
2038
2039 BOOL lsa_io_r_addprivs(const char *desc, LSA_R_ADDPRIVS *r_c, prs_struct *ps, int depth)
2040 {
2041         prs_debug(ps, depth, desc, "lsa_io_r_addprivs");
2042         depth++;
2043
2044         if(!prs_align(ps))
2045                 return False;
2046
2047         if(!prs_ntstatus("status", ps, depth, &r_c->status))
2048                 return False;
2049
2050         return True;
2051 }
2052
2053 /*******************************************************************
2054  Reads or writes an LSA_Q_REMOVEPRIVS structure.
2055 ********************************************************************/
2056
2057 BOOL lsa_io_q_removeprivs(const char *desc, LSA_Q_REMOVEPRIVS *r_c, prs_struct *ps, int depth)
2058 {
2059         prs_debug(ps, depth, desc, "lsa_io_q_removeprivs");
2060         depth++;
2061
2062         if(!prs_align(ps))
2063                 return False;
2064
2065         if(!smb_io_pol_hnd("pol", &r_c->pol, ps, depth))
2066                 return False;
2067
2068         if(!prs_uint32("allrights", ps, depth, &r_c->allrights))
2069                 return False;
2070
2071         if(!prs_uint32("ptr", ps, depth, &r_c->ptr))
2072                 return False;
2073
2074         /*
2075          * JFM: I'm not sure at all if the count is inside the ptr
2076          * never seen one with ptr=0
2077          */
2078
2079         if (r_c->ptr!=0) {
2080                 if(!prs_uint32("count", ps, depth, &r_c->count))
2081                         return False;
2082
2083                 if (UNMARSHALLING(ps) && r_c->count!=0) {
2084                         if (!(r_c->set.set = (LUID_ATTR *)prs_alloc_mem(ps,sizeof(LUID_ATTR) * r_c->count)))
2085                                 return False;
2086                 }
2087
2088                 if(!lsa_io_privilege_set(desc, &r_c->set, ps, depth))
2089                         return False;
2090         }
2091
2092         return True;
2093 }
2094
2095 /*******************************************************************
2096  Reads or writes an LSA_R_REMOVEPRIVS structure.
2097 ********************************************************************/
2098
2099 BOOL lsa_io_r_removeprivs(const char *desc, LSA_R_REMOVEPRIVS *r_c, prs_struct *ps, int depth)
2100 {
2101         prs_debug(ps, depth, desc, "lsa_io_r_removeprivs");
2102         depth++;
2103
2104         if(!prs_align(ps))
2105                 return False;
2106
2107         if(!prs_ntstatus("status", ps, depth, &r_c->status))
2108                 return False;
2109
2110         return True;
2111 }
2112
2113 BOOL policy_handle_is_valid(const POLICY_HND *hnd)
2114 {
2115         POLICY_HND zero_pol;
2116
2117         ZERO_STRUCT(zero_pol);
2118         return ((memcmp(&zero_pol, hnd, sizeof(POLICY_HND)) == 0) ? False : True );
2119 }
2120
2121 /*******************************************************************
2122  Reads or writes an LSA_DNS_DOM_INFO structure.
2123 ********************************************************************/
2124
2125 BOOL lsa_io_dns_dom_info(const char *desc, LSA_DNS_DOM_INFO *info,
2126                          prs_struct *ps, int depth)
2127 {
2128         prs_debug(ps, depth, desc, "lsa_io_dns_dom_info");
2129         depth++;
2130
2131         if(!prs_align(ps))
2132                 return False;
2133         if(!smb_io_unihdr("nb_name", &info->hdr_nb_dom_name, ps, depth))
2134                 return False;
2135         if(!smb_io_unihdr("dns_name", &info->hdr_dns_dom_name, ps, depth))
2136                 return False;
2137         if(!smb_io_unihdr("forest", &info->hdr_forest_name, ps, depth))
2138                 return False;
2139
2140         if(!prs_align(ps))
2141                 return False;
2142         if (!prs_uint8s(False, "dom_guid", ps, depth, info->dom_guid.info, GUID_SIZE))
2143                 return False;
2144
2145         if(!prs_align(ps))
2146                 return False;
2147         if(!prs_uint32("dom_sid", ps, depth, &info->ptr_dom_sid))
2148                 return False;
2149
2150         if(!smb_io_unistr2("nb_name", &info->uni_nb_dom_name,
2151                            info->hdr_nb_dom_name.buffer, ps, depth))
2152                 return False;
2153         if(!smb_io_unistr2("dns_name", &info->uni_dns_dom_name,
2154                            info->hdr_dns_dom_name.buffer, ps, depth))
2155                 return False;
2156         if(!smb_io_unistr2("forest", &info->uni_forest_name,
2157                            info->hdr_forest_name.buffer, ps, depth))
2158                 return False;
2159
2160         if(!smb_io_dom_sid2("dom_sid", &info->dom_sid, ps, depth))
2161                 return False;
2162
2163         return True;
2164
2165 }
2166
2167 /*******************************************************************
2168  Inits an LSA_Q_QUERY_INFO2 structure.
2169 ********************************************************************/
2170
2171 void init_q_query2(LSA_Q_QUERY_INFO2 *q_q, POLICY_HND *hnd, uint16 info_class)
2172 {
2173         DEBUG(5, ("init_q_query2\n"));
2174
2175         memcpy(&q_q->pol, hnd, sizeof(q_q->pol));
2176
2177         q_q->info_class = info_class;
2178 }
2179
2180 /*******************************************************************
2181  Reads or writes an LSA_Q_QUERY_DNSDOMINFO structure.
2182 ********************************************************************/
2183
2184 BOOL lsa_io_q_query_info2(const char *desc, LSA_Q_QUERY_INFO2 *q_c,
2185                           prs_struct *ps, int depth)
2186 {
2187         prs_debug(ps, depth, desc, "lsa_io_q_query_info2");
2188         depth++;
2189
2190         if(!prs_align(ps))
2191                 return False;
2192
2193         if(!smb_io_pol_hnd("pol", &q_c->pol, ps, depth))
2194                 return False;
2195
2196         if(!prs_uint16("info_class", ps, depth, &q_c->info_class))
2197                 return False;
2198
2199         return True;
2200 }
2201
2202 /*******************************************************************
2203  Reads or writes an LSA_R_QUERY_DNSDOMINFO structure.
2204 ********************************************************************/
2205
2206 BOOL lsa_io_r_query_info2(const char *desc, LSA_R_QUERY_INFO2 *r_c,
2207                           prs_struct *ps, int depth)
2208 {
2209         prs_debug(ps, depth, desc, "lsa_io_r_query_info2");
2210         depth++;
2211
2212         if(!prs_align(ps))
2213                 return False;
2214
2215         if(!prs_uint32("ptr", ps, depth, &r_c->ptr))
2216                 return False;
2217         if(!prs_uint16("info_class", ps, depth, &r_c->info_class))
2218                 return False;
2219         switch(r_c->info_class) {
2220         case 0x000c:
2221                 if (!lsa_io_dns_dom_info("info12", &r_c->info.dns_dom_info,
2222                                          ps, depth))
2223                         return False;
2224                 break;
2225         default:
2226                 DEBUG(0,("lsa_io_r_query_info2: unknown info class %d\n",
2227                          r_c->info_class));
2228                 return False;
2229         }
2230
2231         if(!prs_align(ps))
2232                 return False;
2233         if(!prs_ntstatus("status", ps, depth, &r_c->status))
2234                 return False;
2235
2236         return True;
2237 }
2238
2239
2240 /*******************************************************************
2241  Inits an LSA_Q_ENUM_ACCT_RIGHTS structure.
2242 ********************************************************************/
2243 void init_q_enum_acct_rights(LSA_Q_ENUM_ACCT_RIGHTS *q_q,
2244                              POLICY_HND *hnd,
2245                              uint32 count,
2246                              DOM_SID *sid)
2247 {
2248         DEBUG(5, ("init_q_enum_acct_rights\n"));
2249
2250         q_q->pol = *hnd;
2251         q_q->count = count;
2252         q_q->sid = *sid;
2253 }
2254
2255 /*******************************************************************
2256 reads or writes a LSA_Q_ENUM_ACCT_RIGHTS structure.
2257 ********************************************************************/
2258 BOOL lsa_io_q_enum_acct_rights(const char *desc, LSA_Q_ENUM_ACCT_RIGHTS *q_q, prs_struct *ps, int depth)
2259 {
2260         if (q_q == NULL)
2261                 return False;
2262
2263         prs_debug(ps, depth, desc, "lsa_io_q_enum_acct_rights");
2264         depth++;
2265
2266         if (!smb_io_pol_hnd("", &q_q->pol, ps, depth))
2267                 return False;
2268
2269         if(!prs_uint32("count   ", ps, depth, &q_q->count))
2270                 return False;
2271
2272         if(!smb_io_dom_sid("sid", &q_q->sid, ps, depth))
2273                 return False;
2274
2275         return True;
2276 }
2277
2278
2279 /*******************************************************************
2280 reads or writes a LSA_R_ENUM_ACCT_RIGHTS structure.
2281 ********************************************************************/
2282 BOOL lsa_io_r_enum_acct_rights(const char *desc, LSA_R_ENUM_ACCT_RIGHTS *r_c, prs_struct *ps, int depth)
2283 {
2284         prs_debug(ps, depth, desc, "lsa_io_r_enum_acct_rights");
2285         depth++;
2286
2287         if(!prs_uint32("count   ", ps, depth, &r_c->count))
2288                 return False;
2289
2290         if(!smb_io_unistr_array("rights", &r_c->rights, ps, depth))
2291                 return False;
2292
2293         if(!prs_ntstatus("status", ps, depth, &r_c->status))
2294                 return False;
2295
2296         return True;
2297 }