source3/rpc_parse/parse_lsa.c

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