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