source3/rpc_parse/parse_samr.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-2000,
   5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
   6  *  Copyright (C) Paul Ashton                  1997-2000,
   7  *  Copyright (C) Elrond                            2000,
   8  *  Copyright (C) Jeremy Allison                    2001,
   9  *  Copyright (C) Jean François Micouleau      1998-2001,
  10  *  Copyright (C) Jim McDonough <jmcd@us.ibm.com>   2002.
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25  */
  26
  27 #include "includes.h"
  28
  29 #undef DBGC_CLASS
  30 #define DBGC_CLASS DBGC_RPC_PARSE
  31
  32 /*******************************************************************
  33 inits a SAMR_Q_CLOSE_HND structure.
  34 ********************************************************************/
  35
  36 void init_samr_q_close_hnd(SAMR_Q_CLOSE_HND * q_c, POLICY_HND *hnd)
  37 {
  38         DEBUG(5, ("init_samr_q_close_hnd\n"));
  39
  40         q_c->pol = *hnd;
  41 }
  42
  43 /*******************************************************************
  44 reads or writes a structure.
  45 ********************************************************************/
  46
  47 BOOL samr_io_q_close_hnd(const char *desc, SAMR_Q_CLOSE_HND * q_u,
  48                          prs_struct *ps, int depth)
  49 {
  50         if (q_u == NULL)
  51                 return False;
  52
  53         prs_debug(ps, depth, desc, "samr_io_q_close_hnd");
  54         depth++;
  55
  56         if(!prs_align(ps))
  57                 return False;
  58
  59         return smb_io_pol_hnd("pol", &q_u->pol, ps, depth);
  60 }
  61
  62 /*******************************************************************
  63 reads or writes a structure.
  64 ********************************************************************/
  65
  66 BOOL samr_io_r_close_hnd(const char *desc, SAMR_R_CLOSE_HND * r_u,
  67                          prs_struct *ps, int depth)
  68 {
  69         if (r_u == NULL)
  70                 return False;
  71
  72         prs_debug(ps, depth, desc, "samr_io_r_close_hnd");
  73         depth++;
  74
  75         if(!prs_align(ps))
  76                 return False;
  77
  78         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
  79                 return False;
  80
  81         if(!prs_ntstatus("status", ps, depth, &r_u->status))
  82                 return False;
  83
  84         return True;
  85 }
  86
  87 /*******************************************************************
  88 inits a SAMR_Q_LOOKUP_DOMAIN structure.
  89 ********************************************************************/
  90
  91 void init_samr_q_lookup_domain(SAMR_Q_LOOKUP_DOMAIN * q_u,
  92                                POLICY_HND *pol, char *dom_name)
  93 {
  94         DEBUG(5, ("init_samr_q_lookup_domain\n"));
  95
  96         q_u->connect_pol = *pol;
  97
  98         init_unistr2(&q_u->uni_domain, dom_name, UNI_FLAGS_NONE);
  99         init_uni_hdr(&q_u->hdr_domain, &q_u->uni_domain);
 100 }
 101
 102 /*******************************************************************
 103 reads or writes a structure.
 104 ********************************************************************/
 105 BOOL samr_io_q_lookup_domain(const char *desc, SAMR_Q_LOOKUP_DOMAIN * q_u,
 106                              prs_struct *ps, int depth)
 107 {
 108         if (q_u == NULL)
 109                 return False;
 110
 111         prs_debug(ps, depth, desc, "samr_io_q_lookup_domain");
 112         depth++;
 113
 114         if(!prs_align(ps))
 115                 return False;
 116
 117         if(!smb_io_pol_hnd("connect_pol", &q_u->connect_pol, ps, depth))
 118                 return False;
 119
 120         if(!smb_io_unihdr("hdr_domain", &q_u->hdr_domain, ps, depth))
 121                 return False;
 122
 123         if(!smb_io_unistr2("uni_domain", &q_u->uni_domain, q_u->hdr_domain.buffer, ps, depth))
 124                 return False;
 125
 126         return True;
 127 }
 128
 129 /*******************************************************************
 130 inits a SAMR_R_LOOKUP_DOMAIN structure.
 131 ********************************************************************/
 132
 133 void init_samr_r_lookup_domain(SAMR_R_LOOKUP_DOMAIN * r_u,
 134                                DOM_SID *dom_sid, NTSTATUS status)
 135 {
 136         DEBUG(5, ("init_samr_r_lookup_domain\n"));
 137
 138         r_u->status = status;
 139         r_u->ptr_sid = 0;
 140         if (NT_STATUS_IS_OK(status)) {
 141                 r_u->ptr_sid = 1;
 142                 init_dom_sid2(&r_u->dom_sid, dom_sid);
 143         }
 144 }
 145
 146 /*******************************************************************
 147 reads or writes a structure.
 148 ********************************************************************/
 149
 150 BOOL samr_io_r_lookup_domain(const char *desc, SAMR_R_LOOKUP_DOMAIN * r_u,
 151                              prs_struct *ps, int depth)
 152 {
 153         if (r_u == NULL)
 154                 return False;
 155
 156         prs_debug(ps, depth, desc, "samr_io_r_lookup_domain");
 157         depth++;
 158
 159         if(!prs_align(ps))
 160                 return False;
 161
 162         if(!prs_uint32("ptr", ps, depth, &r_u->ptr_sid))
 163                 return False;
 164
 165         if (r_u->ptr_sid != 0) {
 166                 if(!smb_io_dom_sid2("sid", &r_u->dom_sid, ps, depth))
 167                         return False;
 168                 if(!prs_align(ps))
 169                         return False;
 170         }
 171
 172         if(!prs_ntstatus("status", ps, depth, &r_u->status))
 173                 return False;
 174
 175         return True;
 176 }
 177
 178 /*******************************************************************
 179 reads or writes a structure.
 180 ********************************************************************/
 181
 182 void init_samr_q_remove_sid_foreign_domain(SAMR_Q_REMOVE_SID_FOREIGN_DOMAIN * q_u, POLICY_HND *dom_pol, DOM_SID *sid)
 183 {
 184         DEBUG(5, ("samr_init_samr_q_remove_sid_foreign_domain\n"));
 185
 186         q_u->dom_pol = *dom_pol;
 187         init_dom_sid2(&q_u->sid, sid);
 188 }
 189
 190 /*******************************************************************
 191 reads or writes a structure.
 192 ********************************************************************/
 193
 194 BOOL samr_io_q_remove_sid_foreign_domain(const char *desc, SAMR_Q_REMOVE_SID_FOREIGN_DOMAIN * q_u,
 195                           prs_struct *ps, int depth)
 196 {
 197         if (q_u == NULL)
 198                 return False;
 199
 200         prs_debug(ps, depth, desc, "samr_io_q_remove_sid_foreign_domain");
 201         depth++;
 202
 203         if(!prs_align(ps))
 204                 return False;
 205
 206         if(!smb_io_pol_hnd("domain_pol", &q_u->dom_pol, ps, depth))
 207                 return False;
 208
 209         if(!smb_io_dom_sid2("sid", &q_u->sid, ps, depth))
 210                 return False;
 211
 212         if(!prs_align(ps))
 213                 return False;
 214
 215         return True;
 216 }
 217
 218 /*******************************************************************
 219 reads or writes a structure.
 220 ********************************************************************/
 221
 222 BOOL samr_io_r_remove_sid_foreign_domain(const char *desc, SAMR_R_REMOVE_SID_FOREIGN_DOMAIN * r_u,
 223                           prs_struct *ps, int depth)
 224 {
 225         if (r_u == NULL)
 226                 return False;
 227
 228         prs_debug(ps, depth, desc, "samr_io_r_remove_sid_foreign_domain");
 229         depth++;
 230
 231         if(!prs_align(ps))
 232                 return False;
 233
 234         if(!prs_ntstatus("status", ps, depth, &r_u->status))
 235                 return False;
 236
 237         return True;
 238 }
 239
 240 /*******************************************************************
 241 reads or writes a structure.
 242 ********************************************************************/
 243
 244 void init_samr_q_open_domain(SAMR_Q_OPEN_DOMAIN * q_u,
 245                              POLICY_HND *pol, uint32 flags,
 246                              const DOM_SID *sid)
 247 {
 248         DEBUG(5, ("samr_init_samr_q_open_domain\n"));
 249
 250         q_u->pol = *pol;
 251         q_u->flags = flags;
 252         init_dom_sid2(&q_u->dom_sid, sid);
 253 }
 254
 255 /*******************************************************************
 256 reads or writes a structure.
 257 ********************************************************************/
 258
 259 BOOL samr_io_q_open_domain(const char *desc, SAMR_Q_OPEN_DOMAIN * q_u,
 260                            prs_struct *ps, int depth)
 261 {
 262         if (q_u == NULL)
 263                 return False;
 264
 265         prs_debug(ps, depth, desc, "samr_io_q_open_domain");
 266         depth++;
 267
 268         if(!prs_align(ps))
 269                 return False;
 270
 271         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
 272                 return False;
 273
 274         if(!prs_uint32("flags", ps, depth, &q_u->flags))
 275                 return False;
 276
 277         if(!smb_io_dom_sid2("sid", &q_u->dom_sid, ps, depth))
 278                 return False;
 279
 280         return True;
 281 }
 282
 283 /*******************************************************************
 284 reads or writes a structure.
 285 ********************************************************************/
 286
 287 BOOL samr_io_r_open_domain(const char *desc, SAMR_R_OPEN_DOMAIN * r_u,
 288                            prs_struct *ps, int depth)
 289 {
 290         if (r_u == NULL)
 291                 return False;
 292
 293         prs_debug(ps, depth, desc, "samr_io_r_open_domain");
 294         depth++;
 295
 296         if(!prs_align(ps))
 297                 return False;
 298
 299         if(!smb_io_pol_hnd("domain_pol", &r_u->domain_pol, ps, depth))
 300                 return False;
 301
 302         if(!prs_ntstatus("status", ps, depth, &r_u->status))
 303                 return False;
 304
 305         return True;
 306 }
 307
 308 /*******************************************************************
 309 reads or writes a structure.
 310 ********************************************************************/
 311
 312 void init_samr_q_get_usrdom_pwinfo(SAMR_Q_GET_USRDOM_PWINFO * q_u,
 313                                    POLICY_HND *user_pol)
 314 {
 315         DEBUG(5, ("samr_init_samr_q_get_usrdom_pwinfo\n"));
 316
 317         q_u->user_pol = *user_pol;
 318 }
 319
 320 /*******************************************************************
 321 reads or writes a structure.
 322 ********************************************************************/
 323
 324 BOOL samr_io_q_get_usrdom_pwinfo(const char *desc, SAMR_Q_GET_USRDOM_PWINFO * q_u,
 325                                  prs_struct *ps, int depth)
 326 {
 327         if (q_u == NULL)
 328                 return False;
 329
 330         prs_debug(ps, depth, desc, "samr_io_q_get_usrdom_pwinfo");
 331         depth++;
 332
 333         if(!prs_align(ps))
 334                 return False;
 335
 336         return smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth);
 337 }
 338
 339 /*******************************************************************
 340  Init.
 341 ********************************************************************/
 342
 343 void init_samr_r_get_usrdom_pwinfo(SAMR_R_GET_USRDOM_PWINFO *r_u, NTSTATUS status)
 344 {
 345         DEBUG(5, ("init_samr_r_get_usrdom_pwinfo\n"));
 346
 347         r_u->min_pwd_length = 0x0000;
 348
 349         /*
 350          * used to be
 351          * r_u->unknown_1 = 0x0015;
 352          * but for trusts.
 353          */
 354         r_u->unknown_1 = 0x01D1;
 355         r_u->unknown_1 = 0x0015;
 356
 357         r_u->password_properties = 0x00000000;
 358
 359         r_u->status = status;
 360 }
 361
 362 /*******************************************************************
 363 reads or writes a structure.
 364 ********************************************************************/
 365
 366 BOOL samr_io_r_get_usrdom_pwinfo(const char *desc, SAMR_R_GET_USRDOM_PWINFO * r_u,
 367                                  prs_struct *ps, int depth)
 368 {
 369         if (r_u == NULL)
 370                 return False;
 371
 372         prs_debug(ps, depth, desc, "samr_io_r_get_usrdom_pwinfo");
 373         depth++;
 374
 375         if(!prs_align(ps))
 376                 return False;
 377
 378         if(!prs_uint16("min_pwd_length", ps, depth, &r_u->min_pwd_length))
 379                 return False;
 380         if(!prs_uint16("unknown_1", ps, depth, &r_u->unknown_1))
 381                 return False;
 382         if(!prs_uint32("password_properties", ps, depth, &r_u->password_properties))
 383                 return False;
 384
 385         if(!prs_ntstatus("status   ", ps, depth, &r_u->status))
 386                 return False;
 387
 388         return True;
 389 }
 390
 391
 392 /*******************************************************************
 393 reads or writes a structure.
 394 ********************************************************************/
 395
 396 BOOL samr_io_q_set_sec_obj(const char *desc, SAMR_Q_SET_SEC_OBJ * q_u,
 397                              prs_struct *ps, int depth)
 398 {
 399         if (q_u == NULL)
 400                 return False;
 401
 402         prs_debug(ps, depth, desc, "samr_io_q_set_sec_obj");
 403         depth++;
 404
 405         if(!prs_align(ps))
 406                 return False;
 407
 408         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
 409                 return False;
 410
 411         if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
 412                 return False;
 413
 414         if(!sec_io_desc_buf("sec_desc", &q_u->buf, ps, depth))
 415                 return False;
 416
 417         return True;
 418 }
 419
 420
 421 /*******************************************************************
 422 reads or writes a structure.
 423 ********************************************************************/
 424
 425 void init_samr_q_query_sec_obj(SAMR_Q_QUERY_SEC_OBJ * q_u,
 426                                POLICY_HND *user_pol, uint32 sec_info)
 427 {
 428         DEBUG(5, ("samr_init_samr_q_query_sec_obj\n"));
 429
 430         q_u->user_pol = *user_pol;
 431         q_u->sec_info = sec_info;
 432 }
 433
 434
 435 /*******************************************************************
 436 reads or writes a structure.
 437 ********************************************************************/
 438
 439 BOOL samr_io_q_query_sec_obj(const char *desc, SAMR_Q_QUERY_SEC_OBJ * q_u,
 440                              prs_struct *ps, int depth)
 441 {
 442         if (q_u == NULL)
 443                 return False;
 444
 445         prs_debug(ps, depth, desc, "samr_io_q_query_sec_obj");
 446         depth++;
 447
 448         if(!prs_align(ps))
 449                 return False;
 450
 451         if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
 452                 return False;
 453
 454         if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
 455                 return False;
 456
 457         return True;
 458 }
 459
 460 /*******************************************************************
 461 reads or writes a structure.
 462 ********************************************************************/
 463
 464 void init_samr_q_query_dom_info(SAMR_Q_QUERY_DOMAIN_INFO * q_u,
 465                                 POLICY_HND *domain_pol, uint16 switch_value)
 466 {
 467         DEBUG(5, ("samr_init_samr_q_query_dom_info\n"));
 468
 469         q_u->domain_pol = *domain_pol;
 470         q_u->switch_value = switch_value;
 471 }
 472
 473 /*******************************************************************
 474 reads or writes a structure.
 475 ********************************************************************/
 476
 477 BOOL samr_io_q_query_dom_info(const char *desc, SAMR_Q_QUERY_DOMAIN_INFO * q_u,
 478                               prs_struct *ps, int depth)
 479 {
 480         if (q_u == NULL)
 481                 return False;
 482
 483         prs_debug(ps, depth, desc, "samr_io_q_query_dom_info");
 484         depth++;
 485
 486         if(!prs_align(ps))
 487                 return False;
 488
 489         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
 490                 return False;
 491
 492         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
 493                 return False;
 494
 495         return True;
 496 }
 497
 498
 499 /*******************************************************************
 500 inits a structure.
 501 ********************************************************************/
 502
 503 void init_unk_info3(SAM_UNK_INFO_3 *u_3, NTTIME nt_logout)
 504 {
 505         u_3->logout.low = nt_logout.low;
 506         u_3->logout.high = nt_logout.high;
 507 }
 508
 509 /*******************************************************************
 510 reads or writes a structure.
 511 ********************************************************************/
 512
 513 static BOOL sam_io_unk_info3(const char *desc, SAM_UNK_INFO_3 * u_3,
 514                              prs_struct *ps, int depth)
 515 {
 516         if (u_3 == NULL)
 517                 return False;
 518
 519         prs_debug(ps, depth, desc, "sam_io_unk_info3");
 520         depth++;
 521
 522         if(!smb_io_time("logout", &u_3->logout, ps, depth))
 523                 return False;
 524
 525         return True;
 526 }
 527
 528 /*******************************************************************
 529 inits a structure.
 530 ********************************************************************/
 531
 532 void init_unk_info6(SAM_UNK_INFO_6 * u_6)
 533 {
 534         u_6->unknown_0 = 0x00000000;
 535         u_6->ptr_0 = 1;
 536         memset(u_6->padding, 0, sizeof(u_6->padding));  /* 12 bytes zeros */
 537 }
 538
 539 /*******************************************************************
 540 reads or writes a structure.
 541 ********************************************************************/
 542
 543 static BOOL sam_io_unk_info6(const char *desc, SAM_UNK_INFO_6 * u_6,
 544                              prs_struct *ps, int depth)
 545 {
 546         if (u_6 == NULL)
 547                 return False;
 548
 549         prs_debug(ps, depth, desc, "sam_io_unk_info6");
 550         depth++;
 551
 552         if(!prs_uint32("unknown_0", ps, depth, &u_6->unknown_0)) /* 0x0000 0000 */
 553                 return False;
 554         if(!prs_uint32("ptr_0", ps, depth, &u_6->ptr_0)) /* pointer to unknown structure */
 555                 return False;
 556         if(!prs_uint8s(False, "padding", ps, depth, u_6->padding, sizeof(u_6->padding)))        /* 12 bytes zeros */
 557                 return False;
 558
 559         return True;
 560 }
 561
 562 /*******************************************************************
 563 inits a structure.
 564 ********************************************************************/
 565
 566 void init_unk_info7(SAM_UNK_INFO_7 * u_7, uint32 server_role)
 567 {
 568         u_7->server_role = server_role;
 569 }
 570
 571 /*******************************************************************
 572 reads or writes a structure.
 573 ********************************************************************/
 574
 575 static BOOL sam_io_unk_info7(const char *desc, SAM_UNK_INFO_7 * u_7,
 576                              prs_struct *ps, int depth)
 577 {
 578         if (u_7 == NULL)
 579                 return False;
 580
 581         prs_debug(ps, depth, desc, "sam_io_unk_info7");
 582         depth++;
 583
 584         if(!prs_uint16("server_role", ps, depth, &u_7->server_role))
 585                 return False;
 586
 587         return True;
 588 }
 589
 590 /*******************************************************************
 591 inits a structure.
 592 ********************************************************************/
 593
 594 void init_unk_info8(SAM_UNK_INFO_8 * u_8, uint32 seq_num)
 595 {
 596         unix_to_nt_time(&u_8->domain_create_time, 0);
 597         u_8->seq_num.low = seq_num;
 598         u_8->seq_num.high = 0x0000;
 599 }
 600
 601 /*******************************************************************
 602 reads or writes a structure.
 603 ********************************************************************/
 604
 605 static BOOL sam_io_unk_info8(const char *desc, SAM_UNK_INFO_8 * u_8,
 606                              prs_struct *ps, int depth)
 607 {
 608         if (u_8 == NULL)
 609                 return False;
 610
 611         prs_debug(ps, depth, desc, "sam_io_unk_info8");
 612         depth++;
 613
 614         if (!prs_uint64("seq_num", ps, depth, &u_8->seq_num))
 615                 return False;
 616
 617         if(!smb_io_time("domain_create_time", &u_8->domain_create_time, ps, depth))
 618                 return False;
 619
 620         return True;
 621 }
 622
 623
 624 /*******************************************************************
 625 inits a structure.
 626 ********************************************************************/
 627
 628 void init_unk_info12(SAM_UNK_INFO_12 * u_12, NTTIME nt_lock_duration, NTTIME nt_reset_time, uint16 lockout)
 629 {
 630         u_12->duration.low = nt_lock_duration.low;
 631         u_12->duration.high = nt_lock_duration.high;
 632         u_12->reset_count.low = nt_reset_time.low;
 633         u_12->reset_count.high = nt_reset_time.high;
 634
 635         u_12->bad_attempt_lockout = lockout;
 636 }
 637
 638 /*******************************************************************
 639 reads or writes a structure.
 640 ********************************************************************/
 641
 642 static BOOL sam_io_unk_info12(const char *desc, SAM_UNK_INFO_12 * u_12,
 643                               prs_struct *ps, int depth)
 644 {
 645         if (u_12 == NULL)
 646                 return False;
 647
 648         prs_debug(ps, depth, desc, "sam_io_unk_info12");
 649         depth++;
 650
 651         if(!smb_io_time("duration", &u_12->duration, ps, depth))
 652                 return False;
 653         if(!smb_io_time("reset_count", &u_12->reset_count, ps, depth))
 654                 return False;
 655         if(!prs_uint16("bad_attempt_lockout", ps, depth, &u_12->bad_attempt_lockout))
 656                 return False;
 657
 658         return True;
 659 }
 660
 661 /*******************************************************************
 662 inits a structure.
 663 ********************************************************************/
 664
 665 void init_unk_info5(SAM_UNK_INFO_5 * u_5,const char *server)
 666 {
 667         init_unistr2(&u_5->uni_server, server, UNI_FLAGS_NONE);
 668         init_uni_hdr(&u_5->hdr_server, &u_5->uni_server);
 669 }
 670
 671 /*******************************************************************
 672 reads or writes a structure.
 673 ********************************************************************/
 674
 675 static BOOL sam_io_unk_info5(const char *desc, SAM_UNK_INFO_5 * u_5,
 676                              prs_struct *ps, int depth)
 677 {
 678         if (u_5 == NULL)
 679                 return False;
 680
 681         prs_debug(ps, depth, desc, "sam_io_unk_info5");
 682         depth++;
 683
 684         if(!smb_io_unihdr("hdr_server", &u_5->hdr_server, ps, depth))
 685                 return False;
 686
 687         if(!smb_io_unistr2("uni_server", &u_5->uni_server, u_5->hdr_server.buffer, ps, depth))
 688                 return False;
 689
 690         return True;
 691 }
 692
 693 /*******************************************************************
 694 inits a structure.
 695 ********************************************************************/
 696
 697 void init_unk_info2(SAM_UNK_INFO_2 * u_2,
 698                         const char *comment, const char *domain, const char *server,
 699                         uint32 seq_num, uint32 num_users, uint32 num_groups, uint32 num_alias, NTTIME nt_logout, uint32 server_role)
 700 {
 701         u_2->logout.low = nt_logout.low;
 702         u_2->logout.high = nt_logout.high;
 703
 704         u_2->seq_num.low = seq_num;
 705         u_2->seq_num.high = 0x00000000;
 706
 707
 708         u_2->unknown_4 = 0x00000001;
 709         u_2->server_role = server_role;
 710         u_2->unknown_6 = 0x00000001;
 711         u_2->num_domain_usrs = num_users;
 712         u_2->num_domain_grps = num_groups;
 713         u_2->num_local_grps = num_alias;
 714
 715         memset(u_2->padding, 0, sizeof(u_2->padding));  /* 12 bytes zeros */
 716
 717         init_unistr2(&u_2->uni_comment, comment, UNI_FLAGS_NONE);
 718         init_uni_hdr(&u_2->hdr_comment, &u_2->uni_comment);
 719         init_unistr2(&u_2->uni_domain, domain, UNI_FLAGS_NONE);
 720         init_uni_hdr(&u_2->hdr_domain, &u_2->uni_domain);
 721         init_unistr2(&u_2->uni_server, server, UNI_FLAGS_NONE);
 722         init_uni_hdr(&u_2->hdr_server, &u_2->uni_server);
 723 }
 724
 725 /*******************************************************************
 726 reads or writes a structure.
 727 ********************************************************************/
 728
 729 static BOOL sam_io_unk_info2(const char *desc, SAM_UNK_INFO_2 * u_2,
 730                              prs_struct *ps, int depth)
 731 {
 732         if (u_2 == NULL)
 733                 return False;
 734
 735         prs_debug(ps, depth, desc, "sam_io_unk_info2");
 736         depth++;
 737
 738         if(!smb_io_time("logout", &u_2->logout, ps, depth))
 739                 return False;
 740         if(!smb_io_unihdr("hdr_comment", &u_2->hdr_comment, ps, depth))
 741                 return False;
 742         if(!smb_io_unihdr("hdr_domain", &u_2->hdr_domain, ps, depth))
 743                 return False;
 744         if(!smb_io_unihdr("hdr_server", &u_2->hdr_server, ps, depth))
 745                 return False;
 746
 747         /* put all the data in here, at the moment, including what the above
 748            pointer is referring to
 749          */
 750
 751         if(!prs_uint64("seq_num ", ps, depth, &u_2->seq_num))
 752                 return False;
 753
 754         if(!prs_uint32("unknown_4 ", ps, depth, &u_2->unknown_4)) /* 0x0000 0001 */
 755                 return False;
 756         if(!prs_uint32("server_role ", ps, depth, &u_2->server_role))
 757                 return False;
 758         if(!prs_uint32("unknown_6 ", ps, depth, &u_2->unknown_6)) /* 0x0000 0001 */
 759                 return False;
 760         if(!prs_uint32("num_domain_usrs ", ps, depth, &u_2->num_domain_usrs))
 761                 return False;
 762         if(!prs_uint32("num_domain_grps", ps, depth, &u_2->num_domain_grps))
 763                 return False;
 764         if(!prs_uint32("num_local_grps", ps, depth, &u_2->num_local_grps))
 765                 return False;
 766
 767         if(!smb_io_unistr2("uni_comment", &u_2->uni_comment, u_2->hdr_comment.buffer, ps, depth))
 768                 return False;
 769         if(!smb_io_unistr2("uni_domain", &u_2->uni_domain, u_2->hdr_domain.buffer, ps, depth))
 770                 return False;
 771         if(!smb_io_unistr2("uni_server", &u_2->uni_server, u_2->hdr_server.buffer, ps, depth))
 772                 return False;
 773
 774         return True;
 775 }
 776
 777 /*******************************************************************
 778 inits a structure.
 779 ********************************************************************/
 780
 781 void init_unk_info1(SAM_UNK_INFO_1 *u_1, uint16 min_pass_len, uint16 pass_hist,
 782                     uint32 password_properties, NTTIME nt_expire, NTTIME nt_min_age)
 783 {
 784         u_1->min_length_password = min_pass_len;
 785         u_1->password_history = pass_hist;
 786         u_1->password_properties = password_properties;
 787
 788         /* password never expire */
 789         u_1->expire.high = nt_expire.high;
 790         u_1->expire.low = nt_expire.low;
 791
 792         /* can change the password now */
 793         u_1->min_passwordage.high = nt_min_age.high;
 794         u_1->min_passwordage.low = nt_min_age.low;
 795
 796 }
 797
 798 /*******************************************************************
 799 reads or writes a structure.
 800 ********************************************************************/
 801
 802 static BOOL sam_io_unk_info1(const char *desc, SAM_UNK_INFO_1 * u_1,
 803                              prs_struct *ps, int depth)
 804 {
 805         if (u_1 == NULL)
 806           return False;
 807
 808         prs_debug(ps, depth, desc, "sam_io_unk_info1");
 809         depth++;
 810
 811         if(!prs_uint16("min_length_password", ps, depth, &u_1->min_length_password))
 812                 return False;
 813         if(!prs_uint16("password_history", ps, depth, &u_1->password_history))
 814                 return False;
 815         if(!prs_uint32("password_properties", ps, depth, &u_1->password_properties))
 816                 return False;
 817         if(!smb_io_time("expire", &u_1->expire, ps, depth))
 818                 return False;
 819         if(!smb_io_time("min_passwordage", &u_1->min_passwordage, ps, depth))
 820                 return False;
 821
 822         return True;
 823 }
 824
 825 /*******************************************************************
 826 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
 827 ********************************************************************/
 828
 829 void init_samr_r_query_dom_info(SAMR_R_QUERY_DOMAIN_INFO * r_u,
 830                                 uint16 switch_value, SAM_UNK_CTR * ctr,
 831                                 NTSTATUS status)
 832 {
 833         DEBUG(5, ("init_samr_r_query_dom_info\n"));
 834
 835         r_u->ptr_0 = 0;
 836         r_u->switch_value = 0;
 837         r_u->status = status;   /* return status */
 838
 839         if (NT_STATUS_IS_OK(status)) {
 840                 r_u->switch_value = switch_value;
 841                 r_u->ptr_0 = 1;
 842                 r_u->ctr = ctr;
 843         }
 844 }
 845
 846 /*******************************************************************
 847 reads or writes a structure.
 848 ********************************************************************/
 849
 850 BOOL samr_io_r_query_dom_info(const char *desc, SAMR_R_QUERY_DOMAIN_INFO * r_u,
 851                               prs_struct *ps, int depth)
 852 {
 853         if (r_u == NULL)
 854                 return False;
 855
 856         prs_debug(ps, depth, desc, "samr_io_r_query_dom_info");
 857         depth++;
 858
 859         if(!prs_align(ps))
 860                 return False;
 861
 862         if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
 863                 return False;
 864
 865         if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
 866                 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
 867                         return False;
 868                 if(!prs_align(ps))
 869                         return False;
 870
 871                 switch (r_u->switch_value) {
 872                 case 0x0c:
 873                         if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
 874                                 return False;
 875                         break;
 876                 case 0x08:
 877                         if(!sam_io_unk_info8("unk_inf8",&r_u->ctr->info.inf8, ps,depth))
 878                                 return False;
 879                         break;
 880                 case 0x07:
 881                         if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
 882                                 return False;
 883                         break;
 884                 case 0x06:
 885                         if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
 886                                 return False;
 887                         break;
 888                 case 0x05:
 889                         if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
 890                                 return False;
 891                         break;
 892                 case 0x03:
 893                         if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
 894                                 return False;
 895                         break;
 896                 case 0x02:
 897                         if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
 898                                 return False;
 899                         break;
 900                 case 0x01:
 901                         if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
 902                                 return False;
 903                         break;
 904                 default:
 905                         DEBUG(0, ("samr_io_r_query_dom_info: unknown switch level 0x%x\n",
 906                                 r_u->switch_value));
 907                         r_u->status = NT_STATUS_INVALID_INFO_CLASS;
 908                         return False;
 909                 }
 910         }
 911
 912         if(!prs_align(ps))
 913                 return False;
 914
 915         if(!prs_ntstatus("status", ps, depth, &r_u->status))
 916                 return False;
 917
 918         return True;
 919 }
 920
 921 /*******************************************************************
 922 reads or writes a SAMR_R_SET_SEC_OBJ structure.
 923 ********************************************************************/
 924
 925 BOOL samr_io_r_set_sec_obj(const char *desc, SAMR_R_SET_SEC_OBJ * r_u,
 926                              prs_struct *ps, int depth)
 927 {
 928         if (r_u == NULL)
 929                 return False;
 930
 931         prs_debug(ps, depth, desc, "samr_io_r_set_sec_obj");
 932         depth++;
 933
 934         if(!prs_align(ps))
 935                 return False;
 936
 937         if(!prs_ntstatus("status", ps, depth, &r_u->status))
 938                 return False;
 939
 940         return True;
 941 }
 942
 943 /*******************************************************************
 944 reads or writes a SAMR_R_QUERY_SEC_OBJ structure.
 945 ********************************************************************/
 946
 947 BOOL samr_io_r_query_sec_obj(const char *desc, SAMR_R_QUERY_SEC_OBJ * r_u,
 948                              prs_struct *ps, int depth)
 949 {
 950         if (r_u == NULL)
 951                 return False;
 952
 953         prs_debug(ps, depth, desc, "samr_io_r_query_sec_obj");
 954         depth++;
 955
 956         if(!prs_align(ps))
 957                 return False;
 958
 959         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
 960                 return False;
 961         if (r_u->ptr != 0) {
 962                 if(!sec_io_desc_buf("sec", &r_u->buf, ps, depth))
 963                         return False;
 964         }
 965
 966         if(!prs_ntstatus("status", ps, depth, &r_u->status))
 967                 return False;
 968
 969         return True;
 970 }
 971
 972 /*******************************************************************
 973 reads or writes a SAM_STR1 structure.
 974 ********************************************************************/
 975
 976 static BOOL sam_io_sam_str1(const char *desc, SAM_STR1 * sam, uint32 acct_buf,
 977                             uint32 name_buf, uint32 desc_buf,
 978                             prs_struct *ps, int depth)
 979 {
 980         if (sam == NULL)
 981                 return False;
 982
 983         prs_debug(ps, depth, desc, "sam_io_sam_str1");
 984         depth++;
 985
 986         if(!prs_align(ps))
 987                 return False;
 988         if (!smb_io_unistr2("name", &sam->uni_acct_name, acct_buf, ps, depth))
 989                 return False;
 990
 991         if (!smb_io_unistr2("desc", &sam->uni_acct_desc, desc_buf, ps, depth))
 992                 return False;
 993
 994         if (!smb_io_unistr2("full", &sam->uni_full_name, name_buf, ps, depth))
 995                 return False;
 996
 997         return True;
 998 }
 999
1000 /*******************************************************************
1001 inits a SAM_ENTRY1 structure.
1002 ********************************************************************/
1003
1004 static void init_sam_entry1(SAM_ENTRY1 *sam, uint32 user_idx,
1005                             UNISTR2 *sam_name, UNISTR2 *sam_full,
1006                             UNISTR2 *sam_desc, uint32 rid_user,
1007                             uint16 acb_info)
1008 {
1009         DEBUG(5, ("init_sam_entry1\n"));
1010
1011         ZERO_STRUCTP(sam);
1012
1013         sam->user_idx = user_idx;
1014         sam->rid_user = rid_user;
1015         sam->acb_info = acb_info;
1016
1017         init_uni_hdr(&sam->hdr_acct_name, sam_name);
1018         init_uni_hdr(&sam->hdr_user_name, sam_full);
1019         init_uni_hdr(&sam->hdr_user_desc, sam_desc);
1020 }
1021
1022 /*******************************************************************
1023 reads or writes a SAM_ENTRY1 structure.
1024 ********************************************************************/
1025
1026 static BOOL sam_io_sam_entry1(const char *desc, SAM_ENTRY1 * sam,
1027                               prs_struct *ps, int depth)
1028 {
1029         if (sam == NULL)
1030                 return False;
1031
1032         prs_debug(ps, depth, desc, "sam_io_sam_entry1");
1033         depth++;
1034
1035         if(!prs_align(ps))
1036                 return False;
1037
1038         if(!prs_uint32("user_idx ", ps, depth, &sam->user_idx))
1039                 return False;
1040
1041         if(!prs_uint32("rid_user ", ps, depth, &sam->rid_user))
1042                 return False;
1043         if(!prs_uint16("acb_info ", ps, depth, &sam->acb_info))
1044                 return False;
1045
1046         if(!prs_align(ps))
1047                 return False;
1048
1049         if (!smb_io_unihdr("hdr_acct_name", &sam->hdr_acct_name, ps, depth))
1050                 return False;
1051         if (!smb_io_unihdr("hdr_user_desc", &sam->hdr_user_desc, ps, depth))
1052                 return False;
1053         if (!smb_io_unihdr("hdr_user_name", &sam->hdr_user_name, ps, depth))
1054                 return False;
1055
1056         return True;
1057 }
1058
1059 /*******************************************************************
1060 reads or writes a SAM_STR2 structure.
1061 ********************************************************************/
1062
1063 static BOOL sam_io_sam_str2(const char *desc, SAM_STR2 * sam, uint32 acct_buf,
1064                             uint32 desc_buf, prs_struct *ps, int depth)
1065 {
1066         if (sam == NULL)
1067                 return False;
1068
1069         prs_debug(ps, depth, desc, "sam_io_sam_str2");
1070         depth++;
1071
1072         if(!prs_align(ps))
1073                 return False;
1074
1075         if(!smb_io_unistr2("uni_srv_name", &sam->uni_srv_name, acct_buf, ps, depth)) /* account name unicode string */
1076                 return False;
1077         if(!smb_io_unistr2("uni_srv_desc", &sam->uni_srv_desc, desc_buf, ps, depth))    /* account desc unicode string */
1078                 return False;
1079
1080         return True;
1081 }
1082
1083 /*******************************************************************
1084 inits a SAM_ENTRY2 structure.
1085 ********************************************************************/
1086 static void init_sam_entry2(SAM_ENTRY2 * sam, uint32 user_idx,
1087                             UNISTR2 *sam_name, UNISTR2 *sam_desc,
1088                             uint32 rid_user, uint16 acb_info)
1089 {
1090         DEBUG(5, ("init_sam_entry2\n"));
1091
1092         sam->user_idx = user_idx;
1093         sam->rid_user = rid_user;
1094         sam->acb_info = acb_info;
1095
1096         init_uni_hdr(&sam->hdr_srv_name, sam_name);
1097         init_uni_hdr(&sam->hdr_srv_desc, sam_desc);
1098 }
1099
1100 /*******************************************************************
1101 reads or writes a SAM_ENTRY2 structure.
1102 ********************************************************************/
1103
1104 static BOOL sam_io_sam_entry2(const char *desc, SAM_ENTRY2 * sam,
1105                               prs_struct *ps, int depth)
1106 {
1107         if (sam == NULL)
1108                 return False;
1109
1110         prs_debug(ps, depth, desc, "sam_io_sam_entry2");
1111         depth++;
1112
1113         if(!prs_align(ps))
1114                 return False;
1115
1116         if(!prs_uint32("user_idx ", ps, depth, &sam->user_idx))
1117                 return False;
1118
1119         if(!prs_uint32("rid_user ", ps, depth, &sam->rid_user))
1120                 return False;
1121         if(!prs_uint16("acb_info ", ps, depth, &sam->acb_info))
1122                 return False;
1123
1124         if(!prs_align(ps))
1125                 return False;
1126
1127         if(!smb_io_unihdr("unihdr", &sam->hdr_srv_name, ps, depth))     /* account name unicode string header */
1128                 return False;
1129         if(!smb_io_unihdr("unihdr", &sam->hdr_srv_desc, ps, depth))     /* account name unicode string header */
1130                 return False;
1131
1132         return True;
1133 }
1134
1135 /*******************************************************************
1136 reads or writes a SAM_STR3 structure.
1137 ********************************************************************/
1138
1139 static BOOL sam_io_sam_str3(const char *desc, SAM_STR3 * sam, uint32 acct_buf,
1140                             uint32 desc_buf, prs_struct *ps, int depth)
1141 {
1142         if (sam == NULL)
1143                 return False;
1144
1145         prs_debug(ps, depth, desc, "sam_io_sam_str3");
1146         depth++;
1147
1148         if(!prs_align(ps))
1149                 return False;
1150
1151         if(!smb_io_unistr2("uni_grp_name", &sam->uni_grp_name, acct_buf, ps, depth))    /* account name unicode string */
1152                 return False;
1153         if(!smb_io_unistr2("uni_grp_desc", &sam->uni_grp_desc, desc_buf, ps, depth))    /* account desc unicode string */
1154                 return False;
1155
1156         return True;
1157 }
1158
1159 /*******************************************************************
1160 inits a SAM_ENTRY3 structure.
1161 ********************************************************************/
1162
1163 static void init_sam_entry3(SAM_ENTRY3 * sam, uint32 grp_idx,
1164                             UNISTR2 *grp_name, UNISTR2 *grp_desc,
1165                             uint32 rid_grp)
1166 {
1167         DEBUG(5, ("init_sam_entry3\n"));
1168
1169         sam->grp_idx = grp_idx;
1170         sam->rid_grp = rid_grp;
1171         sam->attr = 0x07;       /* group rid attributes - gets ignored by nt 4.0 */
1172
1173         init_uni_hdr(&sam->hdr_grp_name, grp_name);
1174         init_uni_hdr(&sam->hdr_grp_desc, grp_desc);
1175 }
1176
1177 /*******************************************************************
1178 reads or writes a SAM_ENTRY3 structure.
1179 ********************************************************************/
1180
1181 static BOOL sam_io_sam_entry3(const char *desc, SAM_ENTRY3 * sam,
1182                               prs_struct *ps, int depth)
1183 {
1184         if (sam == NULL)
1185                 return False;
1186
1187         prs_debug(ps, depth, desc, "sam_io_sam_entry3");
1188         depth++;
1189
1190         if(!prs_align(ps))
1191                 return False;
1192
1193         if(!prs_uint32("grp_idx", ps, depth, &sam->grp_idx))
1194                 return False;
1195
1196         if(!prs_uint32("rid_grp", ps, depth, &sam->rid_grp))
1197                 return False;
1198         if(!prs_uint32("attr   ", ps, depth, &sam->attr))
1199                 return False;
1200
1201         if(!smb_io_unihdr("unihdr", &sam->hdr_grp_name, ps, depth))     /* account name unicode string header */
1202                 return False;
1203         if(!smb_io_unihdr("unihdr", &sam->hdr_grp_desc, ps, depth))     /* account name unicode string header */
1204                 return False;
1205
1206         return True;
1207 }
1208
1209 /*******************************************************************
1210 inits a SAM_ENTRY4 structure.
1211 ********************************************************************/
1212
1213 static void init_sam_entry4(SAM_ENTRY4 * sam, uint32 user_idx,
1214                             uint32 len_acct_name)
1215 {
1216         DEBUG(5, ("init_sam_entry4\n"));
1217
1218         sam->user_idx = user_idx;
1219         init_str_hdr(&sam->hdr_acct_name, len_acct_name+1, len_acct_name, len_acct_name != 0);
1220 }
1221
1222 /*******************************************************************
1223 reads or writes a SAM_ENTRY4 structure.
1224 ********************************************************************/
1225
1226 static BOOL sam_io_sam_entry4(const char *desc, SAM_ENTRY4 * sam,
1227                               prs_struct *ps, int depth)
1228 {
1229         if (sam == NULL)
1230                 return False;
1231
1232         prs_debug(ps, depth, desc, "sam_io_sam_entry4");
1233         depth++;
1234
1235         if(!prs_align(ps))
1236                 return False;
1237
1238         if(!prs_uint32("user_idx", ps, depth, &sam->user_idx))
1239                 return False;
1240         if(!smb_io_strhdr("strhdr", &sam->hdr_acct_name, ps, depth))
1241                 return False;
1242
1243         return True;
1244 }
1245
1246 /*******************************************************************
1247 inits a SAM_ENTRY5 structure.
1248 ********************************************************************/
1249
1250 static void init_sam_entry5(SAM_ENTRY5 * sam, uint32 grp_idx,
1251                             uint32 len_grp_name)
1252 {
1253         DEBUG(5, ("init_sam_entry5\n"));
1254
1255         sam->grp_idx = grp_idx;
1256         init_str_hdr(&sam->hdr_grp_name, len_grp_name, len_grp_name,
1257                      len_grp_name != 0);
1258 }
1259
1260 /*******************************************************************
1261 reads or writes a SAM_ENTRY5 structure.
1262 ********************************************************************/
1263
1264 static BOOL sam_io_sam_entry5(const char *desc, SAM_ENTRY5 * sam,
1265                               prs_struct *ps, int depth)
1266 {
1267         if (sam == NULL)
1268                 return False;
1269
1270         prs_debug(ps, depth, desc, "sam_io_sam_entry5");
1271         depth++;
1272
1273         if(!prs_align(ps))
1274                 return False;
1275
1276         if(!prs_uint32("grp_idx", ps, depth, &sam->grp_idx))
1277                 return False;
1278         if(!smb_io_strhdr("strhdr", &sam->hdr_grp_name, ps, depth))
1279                 return False;
1280
1281         return True;
1282 }
1283
1284 /*******************************************************************
1285 inits a SAM_ENTRY structure.
1286 ********************************************************************/
1287
1288 void init_sam_entry(SAM_ENTRY *sam, UNISTR2 *uni2, uint32 rid)
1289 {
1290         DEBUG(10, ("init_sam_entry: %d\n", rid));
1291
1292         sam->rid = rid;
1293         init_uni_hdr(&sam->hdr_name, uni2);
1294 }
1295
1296 /*******************************************************************
1297 reads or writes a SAM_ENTRY structure.
1298 ********************************************************************/
1299
1300 static BOOL sam_io_sam_entry(const char *desc, SAM_ENTRY * sam,
1301                              prs_struct *ps, int depth)
1302 {
1303         if (sam == NULL)
1304                 return False;
1305
1306         prs_debug(ps, depth, desc, "sam_io_sam_entry");
1307         depth++;
1308
1309         if(!prs_align(ps))
1310                 return False;
1311         if(!prs_uint32("rid", ps, depth, &sam->rid))
1312                 return False;
1313         if(!smb_io_unihdr("unihdr", &sam->hdr_name, ps, depth)) /* account name unicode string header */
1314                 return False;
1315
1316         return True;
1317 }
1318
1319 /*******************************************************************
1320 inits a SAMR_Q_ENUM_DOM_USERS structure.
1321 ********************************************************************/
1322
1323 void init_samr_q_enum_dom_users(SAMR_Q_ENUM_DOM_USERS * q_e, POLICY_HND *pol,
1324                                 uint32 start_idx,
1325                                 uint16 acb_mask, uint16 unk_1, uint32 size)
1326 {
1327         DEBUG(5, ("init_samr_q_enum_dom_users\n"));
1328
1329         q_e->pol = *pol;
1330
1331         q_e->start_idx = start_idx;     /* zero indicates lots */
1332         q_e->acb_mask = acb_mask;
1333         q_e->unknown_1 = unk_1;
1334         q_e->max_size = size;
1335 }
1336
1337 /*******************************************************************
1338 reads or writes a structure.
1339 ********************************************************************/
1340
1341 BOOL samr_io_q_enum_dom_users(const char *desc, SAMR_Q_ENUM_DOM_USERS * q_e,
1342                               prs_struct *ps, int depth)
1343 {
1344         if (q_e == NULL)
1345                 return False;
1346
1347         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_users");
1348         depth++;
1349
1350         if(!prs_align(ps))
1351                 return False;
1352
1353         if(!smb_io_pol_hnd("domain_pol", &q_e->pol, ps, depth))
1354                 return False;
1355
1356         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
1357                 return False;
1358         if(!prs_uint16("acb_mask ", ps, depth, &q_e->acb_mask))
1359                 return False;
1360         if(!prs_uint16("unknown_1", ps, depth, &q_e->unknown_1))
1361                 return False;
1362
1363         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
1364                 return False;
1365
1366         return True;
1367 }
1368
1369
1370 /*******************************************************************
1371 inits a SAMR_R_ENUM_DOM_USERS structure.
1372 ********************************************************************/
1373
1374 void init_samr_r_enum_dom_users(SAMR_R_ENUM_DOM_USERS * r_u,
1375                                 uint32 next_idx, uint32 num_sam_entries)
1376 {
1377         DEBUG(5, ("init_samr_r_enum_dom_users\n"));
1378
1379         r_u->next_idx = next_idx;
1380
1381         if (num_sam_entries != 0) {
1382                 r_u->ptr_entries1 = 1;
1383                 r_u->ptr_entries2 = 1;
1384                 r_u->num_entries2 = num_sam_entries;
1385                 r_u->num_entries3 = num_sam_entries;
1386
1387                 r_u->num_entries4 = num_sam_entries;
1388         } else {
1389                 r_u->ptr_entries1 = 0;
1390                 r_u->num_entries2 = num_sam_entries;
1391                 r_u->ptr_entries2 = 1;
1392         }
1393 }
1394
1395 /*******************************************************************
1396 reads or writes a structure.
1397 ********************************************************************/
1398
1399 BOOL samr_io_r_enum_dom_users(const char *desc, SAMR_R_ENUM_DOM_USERS * r_u,
1400                               prs_struct *ps, int depth)
1401 {
1402         uint32 i;
1403
1404         if (r_u == NULL)
1405                 return False;
1406
1407         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_users");
1408         depth++;
1409
1410         if(!prs_align(ps))
1411                 return False;
1412
1413         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
1414                 return False;
1415         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
1416                 return False;
1417
1418         if (r_u->ptr_entries1 != 0) {
1419                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
1420                         return False;
1421                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
1422                         return False;
1423                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
1424                         return False;
1425
1426                 if (UNMARSHALLING(ps) && (r_u->num_entries2 != 0)) {
1427                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY, r_u->num_entries2);
1428                         r_u->uni_acct_name = PRS_ALLOC_MEM(ps,UNISTR2, r_u->num_entries2);
1429                 }
1430
1431                 if ((r_u->sam == NULL || r_u->uni_acct_name == NULL) && r_u->num_entries2 != 0) {
1432                         DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_USERS\n"));
1433                         r_u->num_entries4 = 0;
1434                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
1435                         return False;
1436                 }
1437
1438                 for (i = 0; i < r_u->num_entries2; i++) {
1439                         if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
1440                                 return False;
1441                 }
1442
1443                 for (i = 0; i < r_u->num_entries2; i++) {
1444                         if(!smb_io_unistr2("", &r_u->uni_acct_name[i],r_u->sam[i].hdr_name.buffer, ps,depth))
1445                                 return False;
1446                 }
1447
1448         }
1449
1450         if(!prs_align(ps))
1451                 return False;
1452
1453         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
1454                 return False;
1455         if(!prs_ntstatus("status", ps, depth, &r_u->status))
1456                 return False;
1457
1458         return True;
1459 }
1460
1461 /*******************************************************************
1462 inits a SAMR_Q_QUERY_DISPINFO structure.
1463 ********************************************************************/
1464
1465 void init_samr_q_query_dispinfo(SAMR_Q_QUERY_DISPINFO * q_e, POLICY_HND *pol,
1466                                 uint16 switch_level, uint32 start_idx,
1467                                 uint32 max_entries, uint32 max_size)
1468 {
1469         DEBUG(5, ("init_samr_q_query_dispinfo\n"));
1470
1471         q_e->domain_pol = *pol;
1472
1473         q_e->switch_level = switch_level;
1474
1475         q_e->start_idx = start_idx;
1476         q_e->max_entries = max_entries;
1477         q_e->max_size = max_size;
1478 }
1479
1480 /*******************************************************************
1481 reads or writes a structure.
1482 ********************************************************************/
1483
1484 BOOL samr_io_q_query_dispinfo(const char *desc, SAMR_Q_QUERY_DISPINFO * q_e,
1485                               prs_struct *ps, int depth)
1486 {
1487         if (q_e == NULL)
1488                 return False;
1489
1490         prs_debug(ps, depth, desc, "samr_io_q_query_dispinfo");
1491         depth++;
1492
1493         if(!prs_align(ps))
1494                 return False;
1495
1496         if(!smb_io_pol_hnd("domain_pol", &q_e->domain_pol, ps, depth))
1497                 return False;
1498
1499         if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
1500                 return False;
1501         if(!prs_align(ps))
1502                 return False;
1503
1504         if(!prs_uint32("start_idx   ", ps, depth, &q_e->start_idx))
1505                 return False;
1506         if(!prs_uint32("max_entries ", ps, depth, &q_e->max_entries))
1507                 return False;
1508         if(!prs_uint32("max_size    ", ps, depth, &q_e->max_size))
1509                 return False;
1510
1511         return True;
1512 }
1513
1514 /*******************************************************************
1515 inits a SAM_DISPINFO_1 structure.
1516 ********************************************************************/
1517
1518 NTSTATUS init_sam_dispinfo_1(TALLOC_CTX *ctx, SAM_DISPINFO_1 **sam,
1519                              uint32 num_entries, uint32 start_idx,
1520                              struct samr_displayentry *entries)
1521 {
1522         uint32 i;
1523
1524         DEBUG(10, ("init_sam_dispinfo_1: num_entries: %d\n", num_entries));
1525
1526         if (num_entries==0)
1527                 return NT_STATUS_OK;
1528
1529         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_1, num_entries);
1530         if (*sam == NULL)
1531                 return NT_STATUS_NO_MEMORY;
1532
1533         (*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY1, num_entries);
1534         if ((*sam)->sam == NULL)
1535                 return NT_STATUS_NO_MEMORY;
1536
1537         (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR1, num_entries);
1538         if ((*sam)->str == NULL)
1539                 return NT_STATUS_NO_MEMORY;
1540
1541         for (i = 0; i < num_entries ; i++) {
1542                 init_unistr2(&(*sam)->str[i].uni_acct_name,
1543                              entries[i].account_name, UNI_FLAGS_NONE);
1544                 init_unistr2(&(*sam)->str[i].uni_full_name,
1545                              entries[i].fullname, UNI_FLAGS_NONE);
1546                 init_unistr2(&(*sam)->str[i].uni_acct_desc,
1547                              entries[i].description, UNI_FLAGS_NONE);
1548
1549                 init_sam_entry1(&(*sam)->sam[i], start_idx+i+1,
1550                                 &(*sam)->str[i].uni_acct_name,
1551                                 &(*sam)->str[i].uni_full_name,
1552                                 &(*sam)->str[i].uni_acct_desc,
1553                                 entries[i].rid, entries[i].acct_flags);
1554         }
1555
1556         return NT_STATUS_OK;
1557 }
1558
1559 /*******************************************************************
1560 reads or writes a structure.
1561 ********************************************************************/
1562
1563 static BOOL sam_io_sam_dispinfo_1(const char *desc, SAM_DISPINFO_1 * sam,
1564                                   uint32 num_entries,
1565                                   prs_struct *ps, int depth)
1566 {
1567         uint32 i;
1568
1569         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_1");
1570         depth++;
1571
1572         if(!prs_align(ps))
1573                 return False;
1574
1575         if (UNMARSHALLING(ps) && num_entries > 0) {
1576
1577                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY1, num_entries)) == NULL) {
1578                         DEBUG(0, ("out of memory allocating SAM_ENTRY1\n"));
1579                         return False;
1580                 }
1581
1582                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR1, num_entries)) == NULL) {
1583                         DEBUG(0, ("out of memory allocating SAM_STR1\n"));
1584                         return False;
1585                 }
1586         }
1587
1588         for (i = 0; i < num_entries; i++) {
1589                 if(!sam_io_sam_entry1("", &sam->sam[i], ps, depth))
1590                         return False;
1591         }
1592
1593         for (i = 0; i < num_entries; i++) {
1594                 if(!sam_io_sam_str1("", &sam->str[i],
1595                               sam->sam[i].hdr_acct_name.buffer,
1596                               sam->sam[i].hdr_user_name.buffer,
1597                               sam->sam[i].hdr_user_desc.buffer, ps, depth))
1598                         return False;
1599         }
1600
1601         return True;
1602 }
1603
1604 /*******************************************************************
1605 inits a SAM_DISPINFO_2 structure.
1606 ********************************************************************/
1607
1608 NTSTATUS init_sam_dispinfo_2(TALLOC_CTX *ctx, SAM_DISPINFO_2 **sam,
1609                              uint32 num_entries, uint32 start_idx,
1610                              struct samr_displayentry *entries)
1611 {
1612         uint32 i;
1613
1614         DEBUG(10, ("init_sam_dispinfo_2: num_entries: %d\n", num_entries));
1615
1616         if (num_entries==0)
1617                 return NT_STATUS_OK;
1618
1619         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_2, num_entries);
1620         if (*sam == NULL)
1621                 return NT_STATUS_NO_MEMORY;
1622
1623         (*sam)->sam = TALLOC_ARRAY(ctx, SAM_ENTRY2, num_entries);
1624         if ((*sam)->sam == NULL)
1625                 return NT_STATUS_NO_MEMORY;
1626
1627         (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR2, num_entries);
1628         if ((*sam)->str == NULL)
1629                 return NT_STATUS_NO_MEMORY;
1630
1631         for (i = 0; i < num_entries; i++) {
1632                 init_unistr2(&(*sam)->str[i].uni_srv_name,
1633                              entries[i].account_name, UNI_FLAGS_NONE);
1634                 init_unistr2(&(*sam)->str[i].uni_srv_desc,
1635                              entries[i].description, UNI_FLAGS_NONE);
1636
1637                 init_sam_entry2(&(*sam)->sam[i], start_idx + i + 1,
1638                                 &(*sam)->str[i].uni_srv_name,
1639                                 &(*sam)->str[i].uni_srv_desc,
1640                                 entries[i].rid, entries[i].acct_flags);
1641         }
1642
1643         return NT_STATUS_OK;
1644 }
1645
1646 /*******************************************************************
1647 reads or writes a structure.
1648 ********************************************************************/
1649
1650 static BOOL sam_io_sam_dispinfo_2(const char *desc, SAM_DISPINFO_2 * sam,
1651                                   uint32 num_entries,
1652                                   prs_struct *ps, int depth)
1653 {
1654         uint32 i;
1655
1656         if (sam == NULL)
1657                 return False;
1658
1659         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_2");
1660         depth++;
1661
1662         if(!prs_align(ps))
1663                 return False;
1664
1665         if (UNMARSHALLING(ps) && num_entries > 0) {
1666
1667                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY2, num_entries)) == NULL) {
1668                         DEBUG(0, ("out of memory allocating SAM_ENTRY2\n"));
1669                         return False;
1670                 }
1671
1672                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR2, num_entries)) == NULL) {
1673                         DEBUG(0, ("out of memory allocating SAM_STR2\n"));
1674                         return False;
1675                 }
1676         }
1677
1678         for (i = 0; i < num_entries; i++) {
1679                 if(!sam_io_sam_entry2("", &sam->sam[i], ps, depth))
1680                         return False;
1681         }
1682
1683         for (i = 0; i < num_entries; i++) {
1684                 if(!sam_io_sam_str2("", &sam->str[i],
1685                               sam->sam[i].hdr_srv_name.buffer,
1686                               sam->sam[i].hdr_srv_desc.buffer, ps, depth))
1687                         return False;
1688         }
1689
1690         return True;
1691 }
1692
1693 /*******************************************************************
1694 inits a SAM_DISPINFO_3 structure.
1695 ********************************************************************/
1696
1697 NTSTATUS init_sam_dispinfo_3(TALLOC_CTX *ctx, SAM_DISPINFO_3 **sam,
1698                              uint32 num_entries, uint32 start_idx,
1699                              struct samr_displayentry *entries)
1700 {
1701         uint32 i;
1702
1703         DEBUG(5, ("init_sam_dispinfo_3: num_entries: %d\n", num_entries));
1704
1705         if (num_entries==0)
1706                 return NT_STATUS_OK;
1707
1708         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_3, num_entries);
1709         if (*sam == NULL)
1710                 return NT_STATUS_NO_MEMORY;
1711
1712         if (!((*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY3, num_entries)))
1713                 return NT_STATUS_NO_MEMORY;
1714
1715         if (!((*sam)->str=TALLOC_ARRAY(ctx, SAM_STR3, num_entries)))
1716                 return NT_STATUS_NO_MEMORY;
1717
1718         for (i = 0; i < num_entries; i++) {
1719                 DEBUG(11, ("init_sam_dispinfo_3: entry: %d\n",i));
1720
1721                 init_unistr2(&(*sam)->str[i].uni_grp_name,
1722                              entries[i].account_name, UNI_FLAGS_NONE);
1723                 init_unistr2(&(*sam)->str[i].uni_grp_desc,
1724                              entries[i].description, UNI_FLAGS_NONE);
1725
1726                 init_sam_entry3(&(*sam)->sam[i], start_idx+i+1,
1727                                 &(*sam)->str[i].uni_grp_name,
1728                                 &(*sam)->str[i].uni_grp_desc,
1729                                 entries[i].rid);
1730         }
1731
1732         return NT_STATUS_OK;
1733 }
1734
1735 /*******************************************************************
1736 reads or writes a structure.
1737 ********************************************************************/
1738
1739 static BOOL sam_io_sam_dispinfo_3(const char *desc, SAM_DISPINFO_3 * sam,
1740                                   uint32 num_entries,
1741                                   prs_struct *ps, int depth)
1742 {
1743         uint32 i;
1744
1745         if (sam == NULL)
1746                 return False;
1747
1748         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_3");
1749         depth++;
1750
1751         if(!prs_align(ps))
1752                 return False;
1753
1754         if (UNMARSHALLING(ps) && num_entries > 0) {
1755
1756                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY3, num_entries)) == NULL) {
1757                         DEBUG(0, ("out of memory allocating SAM_ENTRY3\n"));
1758                         return False;
1759                 }
1760
1761                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR3, num_entries)) == NULL) {
1762                         DEBUG(0, ("out of memory allocating SAM_STR3\n"));
1763                         return False;
1764                 }
1765         }
1766
1767         for (i = 0; i < num_entries; i++) {
1768                 if(!sam_io_sam_entry3("", &sam->sam[i], ps, depth))
1769                         return False;
1770         }
1771
1772         for (i = 0; i < num_entries; i++) {
1773                 if(!sam_io_sam_str3("", &sam->str[i],
1774                               sam->sam[i].hdr_grp_name.buffer,
1775                               sam->sam[i].hdr_grp_desc.buffer, ps, depth))
1776                         return False;
1777         }
1778
1779         return True;
1780 }
1781
1782 /*******************************************************************
1783 inits a SAM_DISPINFO_4 structure.
1784 ********************************************************************/
1785
1786 NTSTATUS init_sam_dispinfo_4(TALLOC_CTX *ctx, SAM_DISPINFO_4 **sam,
1787                              uint32 num_entries, uint32 start_idx,
1788                              struct samr_displayentry *entries)
1789 {
1790         uint32 i;
1791
1792         DEBUG(5, ("init_sam_dispinfo_4: num_entries: %d\n", num_entries));
1793
1794         if (num_entries==0)
1795                 return NT_STATUS_OK;
1796
1797         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_4, num_entries);
1798         if (*sam == NULL)
1799                 return NT_STATUS_NO_MEMORY;
1800
1801         (*sam)->sam = TALLOC_ARRAY(ctx, SAM_ENTRY4, num_entries);
1802         if ((*sam)->sam == NULL)
1803                 return NT_STATUS_NO_MEMORY;
1804
1805         (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR4, num_entries);
1806         if ((*sam)->str == NULL)
1807                 return NT_STATUS_NO_MEMORY;
1808
1809         for (i = 0; i < num_entries; i++) {
1810                 size_t len_sam_name = strlen(entries[i].account_name);
1811
1812                 DEBUG(11, ("init_sam_dispinfo_2: entry: %d\n",i));
1813
1814                 init_sam_entry4(&(*sam)->sam[i], start_idx + i + 1,
1815                                 len_sam_name);
1816
1817                 init_string2(&(*sam)->str[i].acct_name,
1818                              entries[i].account_name, len_sam_name+1,
1819                              len_sam_name);
1820         }
1821
1822         return NT_STATUS_OK;
1823 }
1824
1825 /*******************************************************************
1826 reads or writes a structure.
1827 ********************************************************************/
1828
1829 static BOOL sam_io_sam_dispinfo_4(const char *desc, SAM_DISPINFO_4 * sam,
1830                                   uint32 num_entries,
1831                                   prs_struct *ps, int depth)
1832 {
1833         uint32 i;
1834
1835         if (sam == NULL)
1836                 return False;
1837
1838         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_4");
1839         depth++;
1840
1841         if(!prs_align(ps))
1842                 return False;
1843
1844         if (UNMARSHALLING(ps) && num_entries > 0) {
1845
1846                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY4, num_entries)) == NULL) {
1847                         DEBUG(0, ("out of memory allocating SAM_ENTRY4\n"));
1848                         return False;
1849                 }
1850
1851                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR4, num_entries)) == NULL) {
1852                         DEBUG(0, ("out of memory allocating SAM_STR4\n"));
1853                         return False;
1854                 }
1855         }
1856
1857         for (i = 0; i < num_entries; i++) {
1858                 if(!sam_io_sam_entry4("", &sam->sam[i], ps, depth))
1859                         return False;
1860         }
1861
1862         for (i = 0; i < num_entries; i++) {
1863                 if(!smb_io_string2("acct_name", &sam->str[i].acct_name,
1864                              sam->sam[i].hdr_acct_name.buffer, ps, depth))
1865                         return False;
1866         }
1867
1868         return True;
1869 }
1870
1871 /*******************************************************************
1872 inits a SAM_DISPINFO_5 structure.
1873 ********************************************************************/
1874
1875 NTSTATUS init_sam_dispinfo_5(TALLOC_CTX *ctx, SAM_DISPINFO_5 **sam,
1876                              uint32 num_entries, uint32 start_idx,
1877                              struct samr_displayentry *entries)
1878 {
1879         uint32 len_sam_name;
1880         uint32 i;
1881
1882         DEBUG(5, ("init_sam_dispinfo_5: num_entries: %d\n", num_entries));
1883
1884         if (num_entries==0)
1885                 return NT_STATUS_OK;
1886
1887         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_5, num_entries);
1888         if (*sam == NULL)
1889                 return NT_STATUS_NO_MEMORY;
1890
1891         if (!((*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY5, num_entries)))
1892                 return NT_STATUS_NO_MEMORY;
1893
1894         if (!((*sam)->str=TALLOC_ARRAY(ctx, SAM_STR5, num_entries)))
1895                 return NT_STATUS_NO_MEMORY;
1896
1897         for (i = 0; i < num_entries; i++) {
1898                 DEBUG(11, ("init_sam_dispinfo_5: entry: %d\n",i));
1899
1900                 len_sam_name = strlen(entries[i].account_name);
1901
1902                 init_sam_entry5(&(*sam)->sam[i], start_idx+i+1, len_sam_name);
1903                 init_string2(&(*sam)->str[i].grp_name, entries[i].account_name,
1904                              len_sam_name+1, len_sam_name);
1905         }
1906
1907         return NT_STATUS_OK;
1908 }
1909
1910 /*******************************************************************
1911 reads or writes a structure.
1912 ********************************************************************/
1913
1914 static BOOL sam_io_sam_dispinfo_5(const char *desc, SAM_DISPINFO_5 * sam,
1915                                   uint32 num_entries,
1916                                   prs_struct *ps, int depth)
1917 {
1918         uint32 i;
1919
1920         if (sam == NULL)
1921                 return False;
1922
1923         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_5");
1924         depth++;
1925
1926         if(!prs_align(ps))
1927                 return False;
1928
1929         if (UNMARSHALLING(ps) && num_entries > 0) {
1930
1931                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY5, num_entries)) == NULL) {
1932                         DEBUG(0, ("out of memory allocating SAM_ENTRY5\n"));
1933                         return False;
1934                 }
1935
1936                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR5, num_entries)) == NULL) {
1937                         DEBUG(0, ("out of memory allocating SAM_STR5\n"));
1938                         return False;
1939                 }
1940         }
1941
1942         for (i = 0; i < num_entries; i++) {
1943                 if(!sam_io_sam_entry5("", &sam->sam[i], ps, depth))
1944                         return False;
1945         }
1946
1947         for (i = 0; i < num_entries; i++) {
1948                 if(!smb_io_string2("grp_name", &sam->str[i].grp_name,
1949                              sam->sam[i].hdr_grp_name.buffer, ps, depth))
1950                         return False;
1951         }
1952
1953         return True;
1954 }
1955
1956 /*******************************************************************
1957 inits a SAMR_R_QUERY_DISPINFO structure.
1958 ********************************************************************/
1959
1960 void init_samr_r_query_dispinfo(SAMR_R_QUERY_DISPINFO * r_u,
1961                                 uint32 num_entries, uint32 total_size, uint32 data_size,
1962                                 uint16 switch_level, SAM_DISPINFO_CTR * ctr,
1963                                 NTSTATUS status)
1964 {
1965         DEBUG(5, ("init_samr_r_query_dispinfo: level %d\n", switch_level));
1966
1967         r_u->total_size = total_size;
1968
1969         r_u->data_size = data_size;
1970
1971         r_u->switch_level = switch_level;
1972         r_u->num_entries = num_entries;
1973
1974         if (num_entries==0)
1975                 r_u->ptr_entries = 0;
1976         else
1977                 r_u->ptr_entries = 1;
1978
1979         r_u->num_entries2 = num_entries;
1980         r_u->ctr = ctr;
1981
1982         r_u->status = status;
1983 }
1984
1985 /*******************************************************************
1986 reads or writes a structure.
1987 ********************************************************************/
1988
1989 BOOL samr_io_r_query_dispinfo(const char *desc, SAMR_R_QUERY_DISPINFO * r_u,
1990                               prs_struct *ps, int depth)
1991 {
1992         if (r_u == NULL)
1993                 return False;
1994
1995         prs_debug(ps, depth, desc, "samr_io_r_query_dispinfo");
1996         depth++;
1997
1998         if(!prs_align(ps))
1999                 return False;
2000
2001         if(!prs_uint32("total_size  ", ps, depth, &r_u->total_size))
2002                 return False;
2003         if(!prs_uint32("data_size   ", ps, depth, &r_u->data_size))
2004                 return False;
2005         if(!prs_uint16("switch_level", ps, depth, &r_u->switch_level))
2006                 return False;
2007         if(!prs_align(ps))
2008                 return False;
2009
2010         if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
2011                 return False;
2012         if(!prs_uint32("ptr_entries ", ps, depth, &r_u->ptr_entries))
2013                 return False;
2014
2015         if (r_u->ptr_entries==0) {
2016                 if(!prs_align(ps))
2017                         return False;
2018                 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2019                         return False;
2020
2021                 return True;
2022         }
2023
2024         if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
2025                 return False;
2026
2027         switch (r_u->switch_level) {
2028         case 0x1:
2029                 if(!sam_io_sam_dispinfo_1("users", r_u->ctr->sam.info1,
2030                                 r_u->num_entries, ps, depth))
2031                         return False;
2032                 break;
2033         case 0x2:
2034                 if(!sam_io_sam_dispinfo_2("servers", r_u->ctr->sam.info2,
2035                                 r_u->num_entries, ps, depth))
2036                         return False;
2037                 break;
2038         case 0x3:
2039                 if(!sam_io_sam_dispinfo_3("groups", r_u->ctr->sam.info3,
2040                                     r_u->num_entries, ps, depth))
2041                         return False;
2042                 break;
2043         case 0x4:
2044                 if(!sam_io_sam_dispinfo_4("user list",
2045                                     r_u->ctr->sam.info4,
2046                                     r_u->num_entries, ps, depth))
2047                         return False;
2048                 break;
2049         case 0x5:
2050                 if(!sam_io_sam_dispinfo_5("group list",
2051                                     r_u->ctr->sam.info5,
2052                                     r_u->num_entries, ps, depth))
2053                         return False;
2054                 break;
2055         default:
2056                 DEBUG(0,("samr_io_r_query_dispinfo: unknown switch value\n"));
2057                 break;
2058         }
2059
2060         if(!prs_align(ps))
2061                 return False;
2062         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2063                 return False;
2064
2065         return True;
2066 }
2067
2068 /*******************************************************************
2069 inits a SAMR_Q_OPEN_GROUP structure.
2070 ********************************************************************/
2071
2072 void init_samr_q_open_group(SAMR_Q_OPEN_GROUP * q_c,
2073                             POLICY_HND *hnd,
2074                             uint32 access_mask, uint32 rid)
2075 {
2076         DEBUG(5, ("init_samr_q_open_group\n"));
2077
2078         q_c->domain_pol = *hnd;
2079         q_c->access_mask = access_mask;
2080         q_c->rid_group = rid;
2081 }
2082
2083 /*******************************************************************
2084 reads or writes a structure.
2085 ********************************************************************/
2086
2087 BOOL samr_io_q_open_group(const char *desc, SAMR_Q_OPEN_GROUP * q_u,
2088                           prs_struct *ps, int depth)
2089 {
2090         if (q_u == NULL)
2091                 return False;
2092
2093         prs_debug(ps, depth, desc, "samr_io_q_open_group");
2094         depth++;
2095
2096         if(!prs_align(ps))
2097                 return False;
2098
2099         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
2100                 return False;
2101
2102         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
2103                 return False;
2104         if(!prs_uint32("rid_group", ps, depth, &q_u->rid_group))
2105                 return False;
2106
2107         return True;
2108 }
2109
2110 /*******************************************************************
2111 reads or writes a structure.
2112 ********************************************************************/
2113
2114 BOOL samr_io_r_open_group(const char *desc, SAMR_R_OPEN_GROUP * r_u,
2115                           prs_struct *ps, int depth)
2116 {
2117         if (r_u == NULL)
2118                 return False;
2119
2120         prs_debug(ps, depth, desc, "samr_io_r_open_group");
2121         depth++;
2122
2123         if(!prs_align(ps))
2124                 return False;
2125
2126         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2127                 return False;
2128
2129         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2130                 return False;
2131
2132         return True;
2133 }
2134
2135 /*******************************************************************
2136 inits a GROUP_INFO1 structure.
2137 ********************************************************************/
2138
2139 void init_samr_group_info1(GROUP_INFO1 * gr1,
2140                            char *acct_name, char *acct_desc,
2141                            uint32 num_members)
2142 {
2143         DEBUG(5, ("init_samr_group_info1\n"));
2144
2145         gr1->group_attr = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT); /* why not | SE_GROUP_ENABLED ? */
2146         gr1->num_members = num_members;
2147
2148         init_unistr2(&gr1->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2149         init_uni_hdr(&gr1->hdr_acct_name, &gr1->uni_acct_name);
2150         init_unistr2(&gr1->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2151         init_uni_hdr(&gr1->hdr_acct_desc, &gr1->uni_acct_desc);
2152 }
2153
2154 /*******************************************************************
2155 reads or writes a structure.
2156 ********************************************************************/
2157
2158 BOOL samr_io_group_info1(const char *desc, GROUP_INFO1 * gr1,
2159                          prs_struct *ps, int depth)
2160 {
2161         uint16 dummy = 1;
2162
2163         if (gr1 == NULL)
2164                 return False;
2165
2166         prs_debug(ps, depth, desc, "samr_io_group_info1");
2167         depth++;
2168
2169         if(!prs_uint16("level", ps, depth, &dummy))
2170                 return False;
2171
2172         if(!prs_align(ps))
2173                 return False;
2174
2175         if(!smb_io_unihdr("hdr_acct_name", &gr1->hdr_acct_name, ps, depth))
2176                 return False;
2177
2178         if(!prs_uint32("group_attr", ps, depth, &gr1->group_attr))
2179                 return False;
2180         if(!prs_uint32("num_members", ps, depth, &gr1->num_members))
2181                 return False;
2182
2183         if(!smb_io_unihdr("hdr_acct_desc", &gr1->hdr_acct_desc, ps, depth))
2184                 return False;
2185
2186         if(!smb_io_unistr2("uni_acct_name", &gr1->uni_acct_name,
2187                            gr1->hdr_acct_name.buffer, ps, depth))
2188                 return False;
2189
2190         if(!smb_io_unistr2("uni_acct_desc", &gr1->uni_acct_desc,
2191                            gr1->hdr_acct_desc.buffer, ps, depth))
2192                 return False;
2193
2194         return True;
2195 }
2196
2197 /*******************************************************************
2198 inits a GROUP_INFO2 structure.
2199 ********************************************************************/
2200
2201 void init_samr_group_info2(GROUP_INFO2 * gr2, const char *acct_name)
2202 {
2203         DEBUG(5, ("init_samr_group_info2\n"));
2204
2205         gr2->level = 2;
2206         init_unistr2(&gr2->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2207         init_uni_hdr(&gr2->hdr_acct_name, &gr2->uni_acct_name);
2208 }
2209
2210 /*******************************************************************
2211 reads or writes a structure.
2212 ********************************************************************/
2213
2214 BOOL samr_io_group_info2(const char *desc, GROUP_INFO2 *gr2, prs_struct *ps, int depth)
2215 {
2216         if (gr2 == NULL)
2217                 return False;
2218
2219         prs_debug(ps, depth, desc, "samr_io_group_info2");
2220         depth++;
2221
2222         if(!prs_uint16("hdr_level", ps, depth, &gr2->level))
2223                 return False;
2224
2225         if(!smb_io_unihdr("hdr_acct_name", &gr2->hdr_acct_name, ps, depth))
2226                 return False;
2227         if(!smb_io_unistr2("uni_acct_name", &gr2->uni_acct_name,
2228                            gr2->hdr_acct_name.buffer, ps, depth))
2229                 return False;
2230
2231         return True;
2232 }
2233
2234 /*******************************************************************
2235 inits a GROUP_INFO3 structure.
2236 ********************************************************************/
2237
2238 void init_samr_group_info3(GROUP_INFO3 *gr3)
2239 {
2240         DEBUG(5, ("init_samr_group_info3\n"));
2241
2242         gr3->group_attr = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT); /* why not | SE_GROUP_ENABLED ? */
2243 }
2244
2245 /*******************************************************************
2246 reads or writes a structure.
2247 ********************************************************************/
2248
2249 BOOL samr_io_group_info3(const char *desc, GROUP_INFO3 *gr3, prs_struct *ps, int depth)
2250 {
2251         if (gr3 == NULL)
2252                 return False;
2253
2254         prs_debug(ps, depth, desc, "samr_io_group_info3");
2255         depth++;
2256
2257         if(!prs_align(ps))
2258                 return False;
2259
2260         if(!prs_uint32("group_attr", ps, depth, &gr3->group_attr))
2261                 return False;
2262
2263         return True;
2264 }
2265
2266 /*******************************************************************
2267 inits a GROUP_INFO4 structure.
2268 ********************************************************************/
2269
2270 void init_samr_group_info4(GROUP_INFO4 * gr4, const char *acct_desc)
2271 {
2272         DEBUG(5, ("init_samr_group_info4\n"));
2273
2274         gr4->level = 4;
2275         init_unistr2(&gr4->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2276         init_uni_hdr(&gr4->hdr_acct_desc, &gr4->uni_acct_desc);
2277 }
2278
2279 /*******************************************************************
2280 reads or writes a structure.
2281 ********************************************************************/
2282
2283 BOOL samr_io_group_info4(const char *desc, GROUP_INFO4 * gr4,
2284                          prs_struct *ps, int depth)
2285 {
2286         if (gr4 == NULL)
2287                 return False;
2288
2289         prs_debug(ps, depth, desc, "samr_io_group_info4");
2290         depth++;
2291
2292         if(!prs_uint16("hdr_level", ps, depth, &gr4->level))
2293                 return False;
2294         if(!smb_io_unihdr("hdr_acct_desc", &gr4->hdr_acct_desc, ps, depth))
2295                 return False;
2296         if(!smb_io_unistr2("uni_acct_desc", &gr4->uni_acct_desc,
2297                            gr4->hdr_acct_desc.buffer, ps, depth))
2298                 return False;
2299
2300         return True;
2301 }
2302
2303 /*******************************************************************
2304 reads or writes a structure.
2305 ********************************************************************/
2306
2307 static BOOL samr_group_info_ctr(const char *desc, GROUP_INFO_CTR **ctr,
2308                                 prs_struct *ps, int depth)
2309 {
2310         if (UNMARSHALLING(ps))
2311                 *ctr = PRS_ALLOC_MEM(ps,GROUP_INFO_CTR,1);
2312
2313         if (*ctr == NULL)
2314                 return False;
2315
2316         prs_debug(ps, depth, desc, "samr_group_info_ctr");
2317         depth++;
2318
2319         if(!prs_uint16("switch_value1", ps, depth, &(*ctr)->switch_value1))
2320                 return False;
2321
2322         switch ((*ctr)->switch_value1) {
2323         case 1:
2324                 if(!samr_io_group_info1("group_info1", &(*ctr)->group.info1, ps, depth))
2325                         return False;
2326                 break;
2327         case 2:
2328                 if(!samr_io_group_info2("group_info2", &(*ctr)->group.info2, ps, depth))
2329                         return False;
2330                 break;
2331         case 3:
2332                 if(!samr_io_group_info3("group_info3", &(*ctr)->group.info3, ps, depth))
2333                         return False;
2334                 break;
2335         case 4:
2336                 if(!samr_io_group_info4("group_info4", &(*ctr)->group.info4, ps, depth))
2337                         return False;
2338                 break;
2339         default:
2340                 DEBUG(0,("samr_group_info_ctr: unsupported switch level\n"));
2341                 break;
2342         }
2343
2344         return True;
2345 }
2346
2347 /*******************************************************************
2348 inits a SAMR_Q_CREATE_DOM_GROUP structure.
2349 ********************************************************************/
2350
2351 void init_samr_q_create_dom_group(SAMR_Q_CREATE_DOM_GROUP * q_e,
2352                                   POLICY_HND *pol, const char *acct_desc,
2353                                   uint32 access_mask)
2354 {
2355         DEBUG(5, ("init_samr_q_create_dom_group\n"));
2356
2357         q_e->pol = *pol;
2358
2359         init_unistr2(&q_e->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2360         init_uni_hdr(&q_e->hdr_acct_desc, &q_e->uni_acct_desc);
2361
2362         q_e->access_mask = access_mask;
2363 }
2364
2365 /*******************************************************************
2366 reads or writes a structure.
2367 ********************************************************************/
2368
2369 BOOL samr_io_q_create_dom_group(const char *desc, SAMR_Q_CREATE_DOM_GROUP * q_e,
2370                                 prs_struct *ps, int depth)
2371 {
2372         if (q_e == NULL)
2373                 return False;
2374
2375         prs_debug(ps, depth, desc, "samr_io_q_create_dom_group");
2376         depth++;
2377
2378         if(!prs_align(ps))
2379                 return False;
2380
2381         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2382                 return False;
2383
2384         if(!smb_io_unihdr("hdr_acct_desc", &q_e->hdr_acct_desc, ps, depth))
2385                 return False;
2386         if(!smb_io_unistr2("uni_acct_desc", &q_e->uni_acct_desc,
2387                        q_e->hdr_acct_desc.buffer, ps, depth))
2388                 return False;
2389
2390         if(!prs_align(ps))
2391                 return False;
2392         if(!prs_uint32("access", ps, depth, &q_e->access_mask))
2393                 return False;
2394
2395         return True;
2396 }
2397
2398 /*******************************************************************
2399 reads or writes a structure.
2400 ********************************************************************/
2401
2402 BOOL samr_io_r_create_dom_group(const char *desc, SAMR_R_CREATE_DOM_GROUP * r_u,
2403                                 prs_struct *ps, int depth)
2404 {
2405         if (r_u == NULL)
2406                 return False;
2407
2408         prs_debug(ps, depth, desc, "samr_io_r_create_dom_group");
2409         depth++;
2410
2411         if(!prs_align(ps))
2412                 return False;
2413
2414         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2415                 return False;
2416
2417         if(!prs_uint32("rid   ", ps, depth, &r_u->rid))
2418                 return False;
2419         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2420                 return False;
2421
2422         return True;
2423 }
2424
2425 /*******************************************************************
2426 inits a SAMR_Q_DELETE_DOM_GROUP structure.
2427 ********************************************************************/
2428
2429 void init_samr_q_delete_dom_group(SAMR_Q_DELETE_DOM_GROUP * q_c,
2430                                   POLICY_HND *hnd)
2431 {
2432         DEBUG(5, ("init_samr_q_delete_dom_group\n"));
2433
2434         q_c->group_pol = *hnd;
2435 }
2436
2437 /*******************************************************************
2438 reads or writes a structure.
2439 ********************************************************************/
2440
2441 BOOL samr_io_q_delete_dom_group(const char *desc, SAMR_Q_DELETE_DOM_GROUP * q_u,
2442                                 prs_struct *ps, int depth)
2443 {
2444         if (q_u == NULL)
2445                 return False;
2446
2447         prs_debug(ps, depth, desc, "samr_io_q_delete_dom_group");
2448         depth++;
2449
2450         if(!prs_align(ps))
2451                 return False;
2452
2453         if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
2454                 return False;
2455
2456         return True;
2457 }
2458
2459 /*******************************************************************
2460 reads or writes a structure.
2461 ********************************************************************/
2462
2463 BOOL samr_io_r_delete_dom_group(const char *desc, SAMR_R_DELETE_DOM_GROUP * r_u,
2464                                 prs_struct *ps, int depth)
2465 {
2466         if (r_u == NULL)
2467                 return False;
2468
2469         prs_debug(ps, depth, desc, "samr_io_r_delete_dom_group");
2470         depth++;
2471
2472         if(!prs_align(ps))
2473                 return False;
2474
2475         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2476                 return False;
2477
2478         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2479                 return False;
2480
2481         return True;
2482 }
2483
2484 /*******************************************************************
2485 inits a SAMR_Q_DEL_GROUPMEM structure.
2486 ********************************************************************/
2487
2488 void init_samr_q_del_groupmem(SAMR_Q_DEL_GROUPMEM * q_e,
2489                               POLICY_HND *pol, uint32 rid)
2490 {
2491         DEBUG(5, ("init_samr_q_del_groupmem\n"));
2492
2493         q_e->pol = *pol;
2494         q_e->rid = rid;
2495 }
2496
2497 /*******************************************************************
2498 reads or writes a structure.
2499 ********************************************************************/
2500
2501 BOOL samr_io_q_del_groupmem(const char *desc, SAMR_Q_DEL_GROUPMEM * q_e,
2502                             prs_struct *ps, int depth)
2503 {
2504         if (q_e == NULL)
2505                 return False;
2506
2507         prs_debug(ps, depth, desc, "samr_io_q_del_groupmem");
2508         depth++;
2509
2510         if(!prs_align(ps))
2511                 return False;
2512
2513         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2514                 return False;
2515
2516         if(!prs_uint32("rid", ps, depth, &q_e->rid))
2517                 return False;
2518
2519         return True;
2520 }
2521
2522 /*******************************************************************
2523 inits a SAMR_R_DEL_GROUPMEM structure.
2524 ********************************************************************/
2525
2526 void init_samr_r_del_groupmem(SAMR_R_DEL_GROUPMEM * r_u, POLICY_HND *pol,
2527                               NTSTATUS status)
2528 {
2529         DEBUG(5, ("init_samr_r_del_groupmem\n"));
2530
2531         r_u->status = status;
2532 }
2533
2534 /*******************************************************************
2535 reads or writes a structure.
2536 ********************************************************************/
2537
2538 BOOL samr_io_r_del_groupmem(const char *desc, SAMR_R_DEL_GROUPMEM * r_u,
2539                             prs_struct *ps, int depth)
2540 {
2541         if (r_u == NULL)
2542                 return False;
2543
2544         prs_debug(ps, depth, desc, "samr_io_r_del_groupmem");
2545         depth++;
2546
2547         if(!prs_align(ps))
2548                 return False;
2549
2550         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2551                 return False;
2552
2553         return True;
2554 }
2555
2556 /*******************************************************************
2557 inits a SAMR_Q_ADD_GROUPMEM structure.
2558 ********************************************************************/
2559
2560 void init_samr_q_add_groupmem(SAMR_Q_ADD_GROUPMEM * q_e,
2561                               POLICY_HND *pol, uint32 rid)
2562 {
2563         DEBUG(5, ("init_samr_q_add_groupmem\n"));
2564
2565         q_e->pol = *pol;
2566         q_e->rid = rid;
2567         q_e->unknown = 0x0005;
2568 }
2569
2570 /*******************************************************************
2571 reads or writes a structure.
2572 ********************************************************************/
2573
2574 BOOL samr_io_q_add_groupmem(const char *desc, SAMR_Q_ADD_GROUPMEM * q_e,
2575                             prs_struct *ps, int depth)
2576 {
2577         if (q_e == NULL)
2578                 return False;
2579
2580         prs_debug(ps, depth, desc, "samr_io_q_add_groupmem");
2581         depth++;
2582
2583         if(!prs_align(ps))
2584                 return False;
2585
2586         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2587                 return False;
2588
2589         if(!prs_uint32("rid    ", ps, depth, &q_e->rid))
2590                 return False;
2591         if(!prs_uint32("unknown", ps, depth, &q_e->unknown))
2592                 return False;
2593
2594         return True;
2595 }
2596
2597 /*******************************************************************
2598 inits a SAMR_R_ADD_GROUPMEM structure.
2599 ********************************************************************/
2600
2601 void init_samr_r_add_groupmem(SAMR_R_ADD_GROUPMEM * r_u, POLICY_HND *pol,
2602                               NTSTATUS status)
2603 {
2604         DEBUG(5, ("init_samr_r_add_groupmem\n"));
2605
2606         r_u->status = status;
2607 }
2608
2609 /*******************************************************************
2610 reads or writes a structure.
2611 ********************************************************************/
2612
2613 BOOL samr_io_r_add_groupmem(const char *desc, SAMR_R_ADD_GROUPMEM * r_u,
2614                             prs_struct *ps, int depth)
2615 {
2616         if (r_u == NULL)
2617                 return False;
2618
2619         prs_debug(ps, depth, desc, "samr_io_r_add_groupmem");
2620         depth++;
2621
2622         if(!prs_align(ps))
2623                 return False;
2624
2625         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2626                 return False;
2627
2628         return True;
2629 }
2630
2631 /*******************************************************************
2632 inits a SAMR_Q_SET_GROUPINFO structure.
2633 ********************************************************************/
2634
2635 void init_samr_q_set_groupinfo(SAMR_Q_SET_GROUPINFO * q_e,
2636                                POLICY_HND *pol, GROUP_INFO_CTR * ctr)
2637 {
2638         DEBUG(5, ("init_samr_q_set_groupinfo\n"));
2639
2640         q_e->pol = *pol;
2641         q_e->ctr = ctr;
2642 }
2643
2644 /*******************************************************************
2645 reads or writes a structure.
2646 ********************************************************************/
2647
2648 BOOL samr_io_q_set_groupinfo(const char *desc, SAMR_Q_SET_GROUPINFO * q_e,
2649                              prs_struct *ps, int depth)
2650 {
2651         if (q_e == NULL)
2652                 return False;
2653
2654         prs_debug(ps, depth, desc, "samr_io_q_set_groupinfo");
2655         depth++;
2656
2657         if(!prs_align(ps))
2658                 return False;
2659
2660         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2661                 return False;
2662
2663         if(!samr_group_info_ctr("ctr", &q_e->ctr, ps, depth))
2664                 return False;
2665
2666         return True;
2667 }
2668
2669 /*******************************************************************
2670 inits a SAMR_R_SET_GROUPINFO structure.
2671 ********************************************************************/
2672
2673 void init_samr_r_set_groupinfo(SAMR_R_SET_GROUPINFO * r_u, NTSTATUS status)
2674 {
2675         DEBUG(5, ("init_samr_r_set_groupinfo\n"));
2676
2677         r_u->status = status;
2678 }
2679
2680 /*******************************************************************
2681 reads or writes a structure.
2682 ********************************************************************/
2683
2684 BOOL samr_io_r_set_groupinfo(const char *desc, SAMR_R_SET_GROUPINFO * r_u,
2685                              prs_struct *ps, int depth)
2686 {
2687         if (r_u == NULL)
2688                 return False;
2689
2690         prs_debug(ps, depth, desc, "samr_io_r_set_groupinfo");
2691         depth++;
2692
2693         if(!prs_align(ps))
2694                 return False;
2695
2696         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2697                 return False;
2698
2699         return True;
2700 }
2701
2702 /*******************************************************************
2703 inits a SAMR_Q_QUERY_GROUPINFO structure.
2704 ********************************************************************/
2705
2706 void init_samr_q_query_groupinfo(SAMR_Q_QUERY_GROUPINFO * q_e,
2707                                  POLICY_HND *pol, uint16 switch_level)
2708 {
2709         DEBUG(5, ("init_samr_q_query_groupinfo\n"));
2710
2711         q_e->pol = *pol;
2712
2713         q_e->switch_level = switch_level;
2714 }
2715
2716 /*******************************************************************
2717 reads or writes a structure.
2718 ********************************************************************/
2719
2720 BOOL samr_io_q_query_groupinfo(const char *desc, SAMR_Q_QUERY_GROUPINFO * q_e,
2721                                prs_struct *ps, int depth)
2722 {
2723         if (q_e == NULL)
2724                 return False;
2725
2726         prs_debug(ps, depth, desc, "samr_io_q_query_groupinfo");
2727         depth++;
2728
2729         if(!prs_align(ps))
2730                 return False;
2731
2732         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2733                 return False;
2734
2735         if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
2736                 return False;
2737
2738         return True;
2739 }
2740
2741 /*******************************************************************
2742 inits a SAMR_R_QUERY_GROUPINFO structure.
2743 ********************************************************************/
2744
2745 void init_samr_r_query_groupinfo(SAMR_R_QUERY_GROUPINFO * r_u,
2746                                  GROUP_INFO_CTR * ctr, NTSTATUS status)
2747 {
2748         DEBUG(5, ("init_samr_r_query_groupinfo\n"));
2749
2750         r_u->ptr = (NT_STATUS_IS_OK(status) && ctr != NULL) ? 1 : 0;
2751         r_u->ctr = ctr;
2752         r_u->status = status;
2753 }
2754
2755 /*******************************************************************
2756 reads or writes a structure.
2757 ********************************************************************/
2758
2759 BOOL samr_io_r_query_groupinfo(const char *desc, SAMR_R_QUERY_GROUPINFO * r_u,
2760                                prs_struct *ps, int depth)
2761 {
2762         if (r_u == NULL)
2763                 return False;
2764
2765         prs_debug(ps, depth, desc, "samr_io_r_query_groupinfo");
2766         depth++;
2767
2768         if(!prs_align(ps))
2769                 return False;
2770
2771         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
2772                 return False;
2773
2774         if (r_u->ptr != 0) {
2775                 if(!samr_group_info_ctr("ctr", &r_u->ctr, ps, depth))
2776                         return False;
2777         }
2778
2779         if(!prs_align(ps))
2780                 return False;
2781         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2782                 return False;
2783
2784         return True;
2785 }
2786
2787 /*******************************************************************
2788 inits a SAMR_Q_QUERY_GROUPMEM structure.
2789 ********************************************************************/
2790
2791 void init_samr_q_query_groupmem(SAMR_Q_QUERY_GROUPMEM * q_c, POLICY_HND *hnd)
2792 {
2793         DEBUG(5, ("init_samr_q_query_groupmem\n"));
2794
2795         q_c->group_pol = *hnd;
2796 }
2797
2798 /*******************************************************************
2799 reads or writes a structure.
2800 ********************************************************************/
2801
2802 BOOL samr_io_q_query_groupmem(const char *desc, SAMR_Q_QUERY_GROUPMEM * q_u,
2803                               prs_struct *ps, int depth)
2804 {
2805         if (q_u == NULL)
2806                 return False;
2807
2808         prs_debug(ps, depth, desc, "samr_io_q_query_groupmem");
2809         depth++;
2810
2811         if(!prs_align(ps))
2812                 return False;
2813
2814         if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
2815                 return False;
2816
2817         return True;
2818 }
2819
2820 /*******************************************************************
2821 inits a SAMR_R_QUERY_GROUPMEM structure.
2822 ********************************************************************/
2823
2824 void init_samr_r_query_groupmem(SAMR_R_QUERY_GROUPMEM * r_u,
2825                                 uint32 num_entries, uint32 *rid,
2826                                 uint32 *attr, NTSTATUS status)
2827 {
2828         DEBUG(5, ("init_samr_r_query_groupmem\n"));
2829
2830         if (NT_STATUS_IS_OK(status)) {
2831                 r_u->ptr = 1;
2832                 r_u->num_entries = num_entries;
2833
2834                 r_u->ptr_attrs = attr != NULL ? 1 : 0;
2835                 r_u->ptr_rids = rid != NULL ? 1 : 0;
2836
2837                 r_u->num_rids = num_entries;
2838                 r_u->rid = rid;
2839
2840                 r_u->num_attrs = num_entries;
2841                 r_u->attr = attr;
2842         } else {
2843                 r_u->ptr = 0;
2844                 r_u->num_entries = 0;
2845         }
2846
2847         r_u->status = status;
2848 }
2849
2850 /*******************************************************************
2851 reads or writes a structure.
2852 ********************************************************************/
2853
2854 BOOL samr_io_r_query_groupmem(const char *desc, SAMR_R_QUERY_GROUPMEM * r_u,
2855                               prs_struct *ps, int depth)
2856 {
2857         uint32 i;
2858
2859         if (r_u == NULL)
2860                 return False;
2861
2862         if (UNMARSHALLING(ps))
2863                 ZERO_STRUCTP(r_u);
2864
2865         prs_debug(ps, depth, desc, "samr_io_r_query_groupmem");
2866         depth++;
2867
2868         if(!prs_align(ps))
2869                 return False;
2870
2871         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
2872                 return False;
2873         if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
2874                 return False;
2875
2876         if (r_u->ptr != 0) {
2877                 if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
2878                         return False;
2879                 if(!prs_uint32("ptr_attrs", ps, depth, &r_u->ptr_attrs))
2880                         return False;
2881
2882                 if (r_u->ptr_rids != 0) {
2883                         if(!prs_uint32("num_rids", ps, depth, &r_u->num_rids))
2884                                 return False;
2885                         if (UNMARSHALLING(ps) && r_u->num_rids != 0) {
2886                                 r_u->rid = PRS_ALLOC_MEM(ps,uint32,r_u->num_rids);
2887                                 if (r_u->rid == NULL)
2888                                         return False;
2889                         }
2890
2891                         for (i = 0; i < r_u->num_rids; i++) {
2892                                 if(!prs_uint32("", ps, depth, &r_u->rid[i]))
2893                                         return False;
2894                         }
2895                 }
2896
2897                 if (r_u->ptr_attrs != 0) {
2898                         if(!prs_uint32("num_attrs", ps, depth, &r_u->num_attrs))
2899                                 return False;
2900
2901                         if (UNMARSHALLING(ps) && r_u->num_attrs != 0) {
2902                                 r_u->attr = PRS_ALLOC_MEM(ps,uint32,r_u->num_attrs);
2903                                 if (r_u->attr == NULL)
2904                                         return False;
2905                         }
2906
2907                         for (i = 0; i < r_u->num_attrs; i++) {
2908                                 if(!prs_uint32("", ps, depth, &r_u->attr[i]))
2909                                         return False;
2910                         }
2911                 }
2912         }
2913
2914         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2915                 return False;
2916
2917         return True;
2918 }
2919
2920 /*******************************************************************
2921 inits a SAMR_Q_QUERY_USERGROUPS structure.
2922 ********************************************************************/
2923
2924 void init_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS * q_u,
2925                                   POLICY_HND *hnd)
2926 {
2927         DEBUG(5, ("init_samr_q_query_usergroups\n"));
2928
2929         q_u->pol = *hnd;
2930 }
2931
2932 /*******************************************************************
2933 reads or writes a structure.
2934 ********************************************************************/
2935
2936 BOOL samr_io_q_query_usergroups(const char *desc, SAMR_Q_QUERY_USERGROUPS * q_u,
2937                                 prs_struct *ps, int depth)
2938 {
2939         if (q_u == NULL)
2940                 return False;
2941
2942         prs_debug(ps, depth, desc, "samr_io_q_query_usergroups");
2943         depth++;
2944
2945         if(!prs_align(ps))
2946                 return False;
2947
2948         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
2949                 return False;
2950
2951         return True;
2952 }
2953
2954 /*******************************************************************
2955 inits a SAMR_R_QUERY_USERGROUPS structure.
2956 ********************************************************************/
2957
2958 void init_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS * r_u,
2959                                   uint32 num_gids, DOM_GID * gid,
2960                                   NTSTATUS status)
2961 {
2962         DEBUG(5, ("init_samr_r_query_usergroups\n"));
2963
2964         if (NT_STATUS_IS_OK(status)) {
2965                 r_u->ptr_0 = 1;
2966                 r_u->num_entries = num_gids;
2967                 r_u->ptr_1 = (num_gids != 0) ? 1 : 0;
2968                 r_u->num_entries2 = num_gids;
2969
2970                 r_u->gid = gid;
2971         } else {
2972                 r_u->ptr_0 = 0;
2973                 r_u->num_entries = 0;
2974                 r_u->ptr_1 = 0;
2975                 r_u->gid = NULL;
2976         }
2977
2978         r_u->status = status;
2979 }
2980
2981 /*******************************************************************
2982 reads or writes a structure.
2983 ********************************************************************/
2984
2985 BOOL samr_io_gids(const char *desc, uint32 *num_gids, DOM_GID ** gid,
2986                   prs_struct *ps, int depth)
2987 {
2988         uint32 i;
2989         if (gid == NULL)
2990                 return False;
2991
2992         prs_debug(ps, depth, desc, "samr_io_gids");
2993         depth++;
2994
2995         if(!prs_align(ps))
2996                 return False;
2997
2998         if(!prs_uint32("num_gids", ps, depth, num_gids))
2999                 return False;
3000
3001         if ((*num_gids) != 0) {
3002                 if (UNMARSHALLING(ps)) {
3003                         (*gid) = PRS_ALLOC_MEM(ps,DOM_GID,*num_gids);
3004                 }
3005
3006                 if ((*gid) == NULL) {
3007                         return False;
3008                 }
3009
3010                 for (i = 0; i < (*num_gids); i++) {
3011                         if(!smb_io_gid("gids", &(*gid)[i], ps, depth))
3012                                 return False;
3013                 }
3014         }
3015
3016         return True;
3017 }
3018
3019 /*******************************************************************
3020 reads or writes a structure.
3021 ********************************************************************/
3022
3023 BOOL samr_io_r_query_usergroups(const char *desc, SAMR_R_QUERY_USERGROUPS * r_u,
3024                                 prs_struct *ps, int depth)
3025 {
3026         if (r_u == NULL)
3027                 return False;
3028
3029         prs_debug(ps, depth, desc, "samr_io_r_query_usergroups");
3030         depth++;
3031
3032         if(!prs_align(ps))
3033                 return False;
3034
3035         if(!prs_uint32("ptr_0       ", ps, depth, &r_u->ptr_0))
3036                 return False;
3037
3038         if (r_u->ptr_0 != 0) {
3039                 if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
3040                         return False;
3041                 if(!prs_uint32("ptr_1       ", ps, depth, &r_u->ptr_1))
3042                         return False;
3043
3044                 if (r_u->num_entries != 0 && r_u->ptr_1 != 0) {
3045                         if(!samr_io_gids("gids", &r_u->num_entries2, &r_u->gid, ps, depth))
3046                                 return False;
3047                 }
3048         }
3049
3050         if(!prs_align(ps))
3051                 return False;
3052         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3053           return False;
3054
3055         return True;
3056 }
3057
3058 /*******************************************************************
3059 inits a SAMR_Q_ENUM_DOMAINS structure.
3060 ********************************************************************/
3061
3062 void init_samr_q_enum_domains(SAMR_Q_ENUM_DOMAINS * q_e,
3063                               POLICY_HND *pol,
3064                               uint32 start_idx, uint32 size)
3065 {
3066         DEBUG(5, ("init_samr_q_enum_domains\n"));
3067
3068         q_e->pol = *pol;
3069
3070         q_e->start_idx = start_idx;
3071         q_e->max_size = size;
3072 }
3073
3074 /*******************************************************************
3075 reads or writes a structure.
3076 ********************************************************************/
3077
3078 BOOL samr_io_q_enum_domains(const char *desc, SAMR_Q_ENUM_DOMAINS * q_e,
3079                             prs_struct *ps, int depth)
3080 {
3081         if (q_e == NULL)
3082                 return False;
3083
3084         prs_debug(ps, depth, desc, "samr_io_q_enum_domains");
3085         depth++;
3086
3087         if(!prs_align(ps))
3088                 return False;
3089
3090         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3091                 return False;
3092
3093         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3094                 return False;
3095         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3096                 return False;
3097
3098         return True;
3099 }
3100
3101 /*******************************************************************
3102 inits a SAMR_R_ENUM_DOMAINS structure.
3103 ********************************************************************/
3104
3105 void init_samr_r_enum_domains(SAMR_R_ENUM_DOMAINS * r_u,
3106                               uint32 next_idx, uint32 num_sam_entries)
3107 {
3108         DEBUG(5, ("init_samr_r_enum_domains\n"));
3109
3110         r_u->next_idx = next_idx;
3111
3112         if (num_sam_entries != 0) {
3113                 r_u->ptr_entries1 = 1;
3114                 r_u->ptr_entries2 = 1;
3115                 r_u->num_entries2 = num_sam_entries;
3116                 r_u->num_entries3 = num_sam_entries;
3117
3118                 r_u->num_entries4 = num_sam_entries;
3119         } else {
3120                 r_u->ptr_entries1 = 0;
3121                 r_u->num_entries2 = num_sam_entries;
3122                 r_u->ptr_entries2 = 1;
3123         }
3124 }
3125
3126 /*******************************************************************
3127 reads or writes a structure.
3128 ********************************************************************/
3129
3130 BOOL samr_io_r_enum_domains(const char *desc, SAMR_R_ENUM_DOMAINS * r_u,
3131                             prs_struct *ps, int depth)
3132 {
3133         uint32 i;
3134
3135         if (r_u == NULL)
3136                 return False;
3137
3138         prs_debug(ps, depth, desc, "samr_io_r_enum_domains");
3139         depth++;
3140
3141         if(!prs_align(ps))
3142                 return False;
3143
3144         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
3145                 return False;
3146         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3147                 return False;
3148
3149         if (r_u->ptr_entries1 != 0) {
3150                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3151                         return False;
3152                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3153                         return False;
3154                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3155                         return False;
3156
3157                 if (UNMARSHALLING(ps)) {
3158                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3159                         r_u->uni_dom_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3160                 }
3161
3162                 if ((r_u->sam == NULL || r_u->uni_dom_name == NULL) && r_u->num_entries2 != 0) {
3163                         DEBUG(0, ("NULL pointers in SAMR_R_ENUM_DOMAINS\n"));
3164                         r_u->num_entries4 = 0;
3165                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3166                         return False;
3167                 }
3168
3169                 for (i = 0; i < r_u->num_entries2; i++) {
3170                         fstring tmp;
3171                         slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3172                         if(!sam_io_sam_entry(tmp, &r_u->sam[i], ps, depth))
3173                                 return False;
3174                 }
3175
3176                 for (i = 0; i < r_u->num_entries2; i++) {
3177                         fstring tmp;
3178                         slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3179                         if(!smb_io_unistr2(tmp, &r_u->uni_dom_name[i],
3180                                        r_u->sam[i].hdr_name.buffer, ps,
3181                                        depth))
3182                                 return False;
3183                 }
3184
3185         }
3186
3187         if(!prs_align(ps))
3188                 return False;
3189         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3190                 return False;
3191         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3192                 return False;
3193
3194         return True;
3195 }
3196
3197 /*******************************************************************
3198 inits a SAMR_Q_ENUM_DOM_GROUPS structure.
3199 ********************************************************************/
3200
3201 void init_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS * q_e,
3202                                  POLICY_HND *pol,
3203                                  uint32 start_idx, uint32 size)
3204 {
3205         DEBUG(5, ("init_samr_q_enum_dom_groups\n"));
3206
3207         q_e->pol = *pol;
3208
3209         q_e->start_idx = start_idx;
3210         q_e->max_size = size;
3211 }
3212
3213 /*******************************************************************
3214 reads or writes a structure.
3215 ********************************************************************/
3216
3217 BOOL samr_io_q_enum_dom_groups(const char *desc, SAMR_Q_ENUM_DOM_GROUPS * q_e,
3218                                prs_struct *ps, int depth)
3219 {
3220         if (q_e == NULL)
3221                 return False;
3222
3223         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_groups");
3224         depth++;
3225
3226         if(!prs_align(ps))
3227                 return False;
3228
3229         if(!smb_io_pol_hnd("pol", &(q_e->pol), ps, depth))
3230                 return False;
3231
3232         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3233                 return False;
3234         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3235                 return False;
3236
3237         return True;
3238 }
3239
3240 /*******************************************************************
3241 inits a SAMR_R_ENUM_DOM_GROUPS structure.
3242 ********************************************************************/
3243
3244 void init_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS * r_u,
3245                                  uint32 next_idx, uint32 num_sam_entries)
3246 {
3247         DEBUG(5, ("init_samr_r_enum_dom_groups\n"));
3248
3249         r_u->next_idx = next_idx;
3250
3251         if (num_sam_entries != 0) {
3252                 r_u->ptr_entries1 = 1;
3253                 r_u->ptr_entries2 = 1;
3254                 r_u->num_entries2 = num_sam_entries;
3255                 r_u->num_entries3 = num_sam_entries;
3256
3257                 r_u->num_entries4 = num_sam_entries;
3258         } else {
3259                 r_u->ptr_entries1 = 0;
3260                 r_u->num_entries2 = num_sam_entries;
3261                 r_u->ptr_entries2 = 1;
3262         }
3263 }
3264
3265 /*******************************************************************
3266 reads or writes a structure.
3267 ********************************************************************/
3268
3269 BOOL samr_io_r_enum_dom_groups(const char *desc, SAMR_R_ENUM_DOM_GROUPS * r_u,
3270                                prs_struct *ps, int depth)
3271 {
3272         uint32 i;
3273
3274         if (r_u == NULL)
3275                 return False;
3276
3277         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_groups");
3278         depth++;
3279
3280         if(!prs_align(ps))
3281                 return False;
3282
3283         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
3284                 return False;
3285         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3286                 return False;
3287
3288         if (r_u->ptr_entries1 != 0) {
3289                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3290                         return False;
3291                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3292                         return False;
3293                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3294                         return False;
3295
3296                 if (UNMARSHALLING(ps)) {
3297                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3298                         r_u->uni_grp_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3299                 }
3300
3301                 if ((r_u->sam == NULL || r_u->uni_grp_name == NULL) && r_u->num_entries2 != 0) {
3302                         DEBUG(0,
3303                               ("NULL pointers in SAMR_R_ENUM_DOM_GROUPS\n"));
3304                         r_u->num_entries4 = 0;
3305                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3306                         return False;
3307                 }
3308
3309                 for (i = 0; i < r_u->num_entries2; i++) {
3310                         if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
3311                                 return False;
3312                 }
3313
3314                 for (i = 0; i < r_u->num_entries2; i++) {
3315                         if(!smb_io_unistr2("", &r_u->uni_grp_name[i],
3316                                        r_u->sam[i].hdr_name.buffer, ps, depth))
3317                                 return False;
3318                 }
3319         }
3320
3321         if(!prs_align(ps))
3322                 return False;
3323         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3324                 return False;
3325         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3326                 return False;
3327
3328         return True;
3329 }
3330
3331 /*******************************************************************
3332 inits a SAMR_Q_ENUM_DOM_ALIASES structure.
3333 ********************************************************************/
3334
3335 void init_samr_q_enum_dom_aliases(SAMR_Q_ENUM_DOM_ALIASES * q_e,
3336                                   POLICY_HND *pol, uint32 start_idx,
3337                                   uint32 size)
3338 {
3339         DEBUG(5, ("init_samr_q_enum_dom_aliases\n"));
3340
3341         q_e->pol = *pol;
3342
3343         q_e->start_idx = start_idx;
3344         q_e->max_size = size;
3345 }
3346
3347
3348 /*******************************************************************
3349 reads or writes a structure.
3350 ********************************************************************/
3351
3352 BOOL samr_io_q_enum_dom_aliases(const char *desc, SAMR_Q_ENUM_DOM_ALIASES * q_e,
3353                                 prs_struct *ps, int depth)
3354 {
3355         if (q_e == NULL)
3356                 return False;
3357
3358         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_aliases");
3359         depth++;
3360
3361         if(!prs_align(ps))
3362                 return False;
3363
3364         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3365                 return False;
3366
3367         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3368                 return False;
3369         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3370                 return False;
3371
3372         return True;
3373 }
3374
3375 /*******************************************************************
3376 inits a SAMR_R_ENUM_DOM_ALIASES structure.
3377 ********************************************************************/
3378
3379 void init_samr_r_enum_dom_aliases(SAMR_R_ENUM_DOM_ALIASES *r_u, uint32 next_idx, uint32 num_sam_entries)
3380 {
3381         DEBUG(5, ("init_samr_r_enum_dom_aliases\n"));
3382
3383         r_u->next_idx = next_idx;
3384
3385         if (num_sam_entries != 0) {
3386                 r_u->ptr_entries1 = 1;
3387                 r_u->ptr_entries2 = 1;
3388                 r_u->num_entries2 = num_sam_entries;
3389                 r_u->num_entries3 = num_sam_entries;
3390
3391                 r_u->num_entries4 = num_sam_entries;
3392         } else {
3393                 r_u->ptr_entries1 = 0;
3394                 r_u->num_entries2 = num_sam_entries;
3395                 r_u->ptr_entries2 = 1;
3396         }
3397 }
3398
3399 /*******************************************************************
3400 reads or writes a structure.
3401 ********************************************************************/
3402
3403 BOOL samr_io_r_enum_dom_aliases(const char *desc, SAMR_R_ENUM_DOM_ALIASES * r_u,
3404                                 prs_struct *ps, int depth)
3405 {
3406         uint32 i;
3407
3408         if (r_u == NULL)
3409                 return False;
3410
3411         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_aliases");
3412         depth++;
3413
3414         if(!prs_align(ps))
3415                 return False;
3416
3417         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
3418                 return False;
3419         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3420                 return False;
3421
3422         if (r_u->ptr_entries1 != 0) {
3423                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3424                         return False;
3425                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3426                         return False;
3427                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3428                         return False;
3429
3430                 if (UNMARSHALLING(ps) && (r_u->num_entries2 > 0)) {
3431                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3432                         r_u->uni_grp_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3433                 }
3434
3435                 if (r_u->num_entries2 != 0 &&
3436                     (r_u->sam == NULL || r_u->uni_grp_name == NULL)) {
3437                         DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_ALIASES\n"));
3438                         r_u->num_entries4 = 0;
3439                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3440                         return False;
3441                 }
3442
3443                 for (i = 0; i < r_u->num_entries2; i++) {
3444                         if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
3445                                 return False;
3446                 }
3447
3448                 for (i = 0; i < r_u->num_entries2; i++) {
3449                         if(!smb_io_unistr2("", &r_u->uni_grp_name[i],
3450                                        r_u->sam[i].hdr_name.buffer, ps,
3451                                        depth))
3452                                 return False;
3453                 }
3454         }
3455
3456         if(!prs_align(ps))
3457                 return False;
3458         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3459                 return False;
3460         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3461                 return False;
3462
3463         return True;
3464 }
3465
3466 /*******************************************************************
3467 inits a ALIAS_INFO1 structure.
3468 ********************************************************************/
3469
3470 void init_samr_alias_info1(ALIAS_INFO1 * al1, char *acct_name, uint32 num_member, char *acct_desc)
3471 {
3472         DEBUG(5, ("init_samr_alias_info1\n"));
3473
3474         init_unistr4(&al1->name, acct_name, UNI_FLAGS_NONE);
3475         al1->num_member = num_member;
3476         init_unistr4(&al1->description, acct_desc, UNI_FLAGS_NONE);
3477 }
3478
3479 /*******************************************************************
3480 reads or writes a structure.
3481 ********************************************************************/
3482
3483 BOOL samr_io_alias_info1(const char *desc, ALIAS_INFO1 * al1,
3484                          prs_struct *ps, int depth)
3485 {
3486         if (al1 == NULL)
3487                 return False;
3488
3489         prs_debug(ps, depth, desc, "samr_io_alias_info1");
3490         depth++;
3491
3492         if(!prs_align(ps))
3493                 return False;
3494
3495         if ( !prs_unistr4_hdr("name", ps, depth, &al1->name) )
3496                 return False;
3497         if ( !prs_uint32("num_member", ps, depth, &al1->num_member) )
3498                 return False;
3499         if ( !prs_unistr4_hdr("description", ps, depth, &al1->description) )
3500                 return False;
3501
3502         if ( !prs_unistr4_str("name", ps, depth, &al1->name) )
3503                 return False;
3504         if ( !prs_align(ps) )
3505                 return False;
3506         if ( !prs_unistr4_str("description", ps, depth, &al1->description) )
3507                 return False;
3508         if ( !prs_align(ps) )
3509                 return False;
3510
3511         return True;
3512 }
3513
3514 /*******************************************************************
3515 inits a ALIAS_INFO3 structure.
3516 ********************************************************************/
3517
3518 void init_samr_alias_info3(ALIAS_INFO3 * al3, const char *acct_desc)
3519 {
3520         DEBUG(5, ("init_samr_alias_info3\n"));
3521
3522         init_unistr4(&al3->description, acct_desc, UNI_FLAGS_NONE);
3523 }
3524
3525 /*******************************************************************
3526 reads or writes a structure.
3527 ********************************************************************/
3528
3529 BOOL samr_io_alias_info3(const char *desc, ALIAS_INFO3 *al3,
3530                          prs_struct *ps, int depth)
3531 {
3532         if (al3 == NULL)
3533                 return False;
3534
3535         prs_debug(ps, depth, desc, "samr_io_alias_info3");
3536         depth++;
3537
3538         if(!prs_align(ps))
3539                 return False;
3540
3541         if (!prs_unistr4("description", ps, depth, &al3->description))
3542                 return False;
3543
3544         return True;
3545 }
3546
3547 /*******************************************************************
3548 reads or writes a structure.
3549 ********************************************************************/
3550
3551 BOOL samr_alias_info_ctr(const char *desc, prs_struct *ps, int depth, ALIAS_INFO_CTR * ctr)
3552 {
3553         if ( !ctr )
3554                 return False;
3555
3556         prs_debug(ps, depth, desc, "samr_alias_info_ctr");
3557         depth++;
3558
3559         if ( !prs_uint16("level", ps, depth, &ctr->level) )
3560                 return False;
3561
3562         if(!prs_align(ps))
3563                 return False;
3564         switch (ctr->level) {
3565         case 1:
3566                 if(!samr_io_alias_info1("alias_info1", &ctr->alias.info1, ps, depth))
3567                         return False;
3568                 break;
3569         case 3:
3570                 if(!samr_io_alias_info3("alias_info3", &ctr->alias.info3, ps, depth))
3571                         return False;
3572                 break;
3573         default:
3574                 DEBUG(0,("samr_alias_info_ctr: unsupported switch level\n"));
3575                 break;
3576         }
3577
3578         return True;
3579 }
3580
3581 /*******************************************************************
3582 inits a SAMR_Q_QUERY_ALIASINFO structure.
3583 ********************************************************************/
3584
3585 void init_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO * q_e,
3586                                  POLICY_HND *pol, uint32 switch_level)
3587 {
3588         DEBUG(5, ("init_samr_q_query_aliasinfo\n"));
3589
3590         q_e->pol = *pol;
3591         q_e->level = switch_level;
3592 }
3593
3594 /*******************************************************************
3595 reads or writes a structure.
3596 ********************************************************************/
3597
3598 BOOL samr_io_q_query_aliasinfo(const char *desc, SAMR_Q_QUERY_ALIASINFO *in,
3599                                prs_struct *ps, int depth)
3600 {
3601         if ( !in )
3602                 return False;
3603
3604         prs_debug(ps, depth, desc, "samr_io_q_query_aliasinfo");
3605         depth++;
3606
3607         if(!prs_align(ps))
3608                 return False;
3609
3610         if ( !smb_io_pol_hnd("pol", &(in->pol), ps, depth) )
3611                 return False;
3612
3613         if ( !prs_uint16("level", ps, depth, &in->level) )
3614                 return False;
3615
3616         return True;
3617 }
3618
3619 /*******************************************************************
3620 inits a SAMR_R_QUERY_ALIASINFO structure.
3621 ********************************************************************/
3622
3623 void init_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *out,
3624                                  ALIAS_INFO_CTR * ctr, NTSTATUS status)
3625 {
3626         DEBUG(5, ("init_samr_r_query_aliasinfo\n"));
3627
3628         out->ctr = ctr;
3629         out->status = status;
3630 }
3631
3632 /*******************************************************************
3633 reads or writes a structure.
3634 ********************************************************************/
3635
3636 BOOL samr_io_r_query_aliasinfo(const char *desc, SAMR_R_QUERY_ALIASINFO *out,
3637                                prs_struct *ps, int depth)
3638 {
3639         if ( !out )
3640                 return False;
3641
3642         prs_debug(ps, depth, desc, "samr_io_r_query_aliasinfo");
3643         depth++;
3644
3645         if(!prs_align(ps))
3646                 return False;
3647
3648         if ( !prs_pointer("alias", ps, depth, (void**)&out->ctr, sizeof(ALIAS_INFO_CTR), (PRS_POINTER_CAST)samr_alias_info_ctr))
3649                 return False;
3650         if(!prs_align(ps))
3651                 return False;
3652
3653         if(!prs_ntstatus("status", ps, depth, &out->status))
3654                 return False;
3655
3656         return True;
3657 }
3658
3659 /*******************************************************************
3660 inits a SAMR_Q_SET_ALIASINFO structure.
3661 ********************************************************************/
3662
3663 void init_samr_q_set_aliasinfo(SAMR_Q_SET_ALIASINFO * q_u,
3664                                POLICY_HND *hnd, ALIAS_INFO_CTR * ctr)
3665 {
3666         DEBUG(5, ("init_samr_q_set_aliasinfo\n"));
3667
3668         q_u->alias_pol = *hnd;
3669         q_u->ctr = *ctr;
3670 }
3671
3672 /*******************************************************************
3673 reads or writes a structure.
3674 ********************************************************************/
3675
3676 BOOL samr_io_q_set_aliasinfo(const char *desc, SAMR_Q_SET_ALIASINFO * q_u,
3677                              prs_struct *ps, int depth)
3678 {
3679         if (q_u == NULL)
3680                 return False;
3681
3682         prs_debug(ps, depth, desc, "samr_io_q_set_aliasinfo");
3683         depth++;
3684
3685         if(!prs_align(ps))
3686                 return False;
3687
3688         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
3689                 return False;
3690         if(!samr_alias_info_ctr("ctr", ps, depth, &q_u->ctr))
3691                 return False;
3692
3693         return True;
3694 }
3695
3696 /*******************************************************************
3697 reads or writes a structure.
3698 ********************************************************************/
3699
3700 BOOL samr_io_r_set_aliasinfo(const char *desc, SAMR_R_SET_ALIASINFO * r_u,
3701                              prs_struct *ps, int depth)
3702 {
3703         if (r_u == NULL)
3704                 return False;
3705
3706         prs_debug(ps, depth, desc, "samr_io_r_set_aliasinfo");
3707         depth++;
3708
3709         if(!prs_align(ps))
3710                 return False;
3711         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3712                 return False;
3713
3714         return True;
3715 }
3716
3717 /*******************************************************************
3718 inits a SAMR_Q_QUERY_USERALIASES structure.
3719 ********************************************************************/
3720
3721 void init_samr_q_query_useraliases(SAMR_Q_QUERY_USERALIASES * q_u,
3722                                    POLICY_HND *hnd,
3723                                    uint32 num_sids,
3724                                    uint32 *ptr_sid, DOM_SID2 * sid)
3725 {
3726         DEBUG(5, ("init_samr_q_query_useraliases\n"));
3727
3728         q_u->pol = *hnd;
3729
3730         q_u->num_sids1 = num_sids;
3731         q_u->ptr = 1;
3732         q_u->num_sids2 = num_sids;
3733
3734         q_u->ptr_sid = ptr_sid;
3735         q_u->sid = sid;
3736 }
3737
3738 /*******************************************************************
3739 reads or writes a SAMR_Q_QUERY_USERALIASES structure.
3740 ********************************************************************/
3741
3742 BOOL samr_io_q_query_useraliases(const char *desc, SAMR_Q_QUERY_USERALIASES * q_u,
3743                                  prs_struct *ps, int depth)
3744 {
3745         fstring tmp;
3746         uint32 i;
3747
3748         if (q_u == NULL)
3749                 return False;
3750
3751         prs_debug(ps, depth, desc, "samr_io_q_query_useraliases");
3752         depth++;
3753
3754         if(!prs_align(ps))
3755                 return False;
3756
3757         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
3758                 return False;
3759
3760         if(!prs_uint32("num_sids1", ps, depth, &q_u->num_sids1))
3761                 return False;
3762         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
3763                 return False;
3764
3765         if (q_u->ptr==0)
3766                 return True;
3767
3768         if(!prs_uint32("num_sids2", ps, depth, &q_u->num_sids2))
3769                 return False;
3770
3771         if (UNMARSHALLING(ps) && (q_u->num_sids2 != 0)) {
3772                 q_u->ptr_sid = PRS_ALLOC_MEM(ps,uint32,q_u->num_sids2);
3773                 if (q_u->ptr_sid == NULL)
3774                         return False;
3775
3776                 q_u->sid = PRS_ALLOC_MEM(ps, DOM_SID2, q_u->num_sids2);
3777                 if (q_u->sid == NULL)
3778                         return False;
3779         }
3780
3781         for (i = 0; i < q_u->num_sids2; i++) {
3782                 slprintf(tmp, sizeof(tmp) - 1, "ptr[%02d]", i);
3783                 if(!prs_uint32(tmp, ps, depth, &q_u->ptr_sid[i]))
3784                         return False;
3785         }
3786
3787         for (i = 0; i < q_u->num_sids2; i++) {
3788                 if (q_u->ptr_sid[i] != 0) {
3789                         slprintf(tmp, sizeof(tmp) - 1, "sid[%02d]", i);
3790                         if(!smb_io_dom_sid2(tmp, &q_u->sid[i], ps, depth))
3791                                 return False;
3792                 }
3793         }
3794
3795         return True;
3796 }
3797
3798 /*******************************************************************
3799 inits a SAMR_R_QUERY_USERALIASES structure.
3800 ********************************************************************/
3801
3802 void init_samr_r_query_useraliases(SAMR_R_QUERY_USERALIASES * r_u,
3803                                    uint32 num_rids, uint32 *rid,
3804                                    NTSTATUS status)
3805 {
3806         DEBUG(5, ("init_samr_r_query_useraliases\n"));
3807
3808         if (NT_STATUS_IS_OK(status)) {
3809                 r_u->num_entries = num_rids;
3810                 r_u->ptr = 1;
3811                 r_u->num_entries2 = num_rids;
3812
3813                 r_u->rid = rid;
3814         } else {
3815                 r_u->num_entries = 0;
3816                 r_u->ptr = 0;
3817                 r_u->num_entries2 = 0;
3818         }
3819
3820         r_u->status = status;
3821 }
3822
3823 /*******************************************************************
3824 reads or writes a structure.
3825 ********************************************************************/
3826
3827 BOOL samr_io_rids(const char *desc, uint32 *num_rids, uint32 **rid,
3828                   prs_struct *ps, int depth)
3829 {
3830         fstring tmp;
3831         uint32 i;
3832         if (rid == NULL)
3833                 return False;
3834
3835         prs_debug(ps, depth, desc, "samr_io_rids");
3836         depth++;
3837
3838         if(!prs_align(ps))
3839                 return False;
3840
3841         if(!prs_uint32("num_rids", ps, depth, num_rids))
3842                 return False;
3843
3844         if ((*num_rids) != 0) {
3845                 if (UNMARSHALLING(ps)) {
3846                         /* reading */
3847                         (*rid) = PRS_ALLOC_MEM(ps,uint32, *num_rids);
3848                 }
3849                 if ((*rid) == NULL)
3850                         return False;
3851
3852                 for (i = 0; i < (*num_rids); i++) {
3853                         slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]", i);
3854                         if(!prs_uint32(tmp, ps, depth, &((*rid)[i])))
3855                                 return False;
3856                 }
3857         }
3858
3859         return True;
3860 }
3861
3862 /*******************************************************************
3863 reads or writes a structure.
3864 ********************************************************************/
3865
3866 BOOL samr_io_r_query_useraliases(const char *desc, SAMR_R_QUERY_USERALIASES * r_u,
3867                                  prs_struct *ps, int depth)
3868 {
3869         if (r_u == NULL)
3870                 return False;
3871
3872         prs_debug(ps, depth, desc, "samr_io_r_query_useraliases");
3873         depth++;
3874
3875         if(!prs_align(ps))
3876                 return False;
3877
3878         if(!prs_uint32("num_entries", ps, depth, &r_u->num_entries))
3879                 return False;
3880         if(!prs_uint32("ptr        ", ps, depth, &r_u->ptr))
3881                 return False;
3882
3883         if (r_u->ptr != 0) {
3884                 if(!samr_io_rids("rids", &r_u->num_entries2, &r_u->rid, ps, depth))
3885                         return False;
3886         }
3887
3888         if(!prs_align(ps))
3889                 return False;
3890         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3891                 return False;
3892
3893         return True;
3894 }
3895
3896 /*******************************************************************
3897 inits a SAMR_Q_OPEN_ALIAS structure.
3898 ********************************************************************/
3899
3900 void init_samr_q_open_alias(SAMR_Q_OPEN_ALIAS * q_u, POLICY_HND *pol,
3901                             uint32 access_mask, uint32 rid)
3902 {
3903         DEBUG(5, ("init_samr_q_open_alias\n"));
3904
3905         q_u->dom_pol = *pol;
3906         q_u->access_mask = access_mask;
3907         q_u->rid_alias = rid;
3908 }
3909
3910 /*******************************************************************
3911 reads or writes a structure.
3912 ********************************************************************/
3913
3914 BOOL samr_io_q_open_alias(const char *desc, SAMR_Q_OPEN_ALIAS * q_u,
3915                           prs_struct *ps, int depth)
3916 {
3917         if (q_u == NULL)
3918                 return False;
3919
3920         prs_debug(ps, depth, desc, "samr_io_q_open_alias");
3921         depth++;
3922
3923         if(!prs_align(ps))
3924                 return False;
3925
3926         if(!smb_io_pol_hnd("domain_pol", &q_u->dom_pol, ps, depth))
3927                 return False;
3928
3929         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
3930                 return False;
3931         if(!prs_uint32("rid_alias", ps, depth, &q_u->rid_alias))
3932                 return False;
3933
3934         return True;
3935 }
3936
3937 /*******************************************************************
3938 reads or writes a structure.
3939 ********************************************************************/
3940
3941 BOOL samr_io_r_open_alias(const char *desc, SAMR_R_OPEN_ALIAS * r_u,
3942                           prs_struct *ps, int depth)
3943 {
3944         if (r_u == NULL)
3945                 return False;
3946
3947         prs_debug(ps, depth, desc, "samr_io_r_open_alias");
3948         depth++;
3949
3950         if(!prs_align(ps))
3951                 return False;
3952
3953         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
3954                 return False;
3955
3956         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3957                 return False;
3958
3959         return True;
3960 }
3961
3962 /*******************************************************************
3963 inits a SAMR_Q_LOOKUP_RIDS structure.
3964 ********************************************************************/
3965
3966 void init_samr_q_lookup_rids(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_RIDS * q_u,
3967                              POLICY_HND *pol, uint32 flags,
3968                              uint32 num_rids, uint32 *rid)
3969 {
3970         DEBUG(5, ("init_samr_q_lookup_rids\n"));
3971
3972         q_u->pol = *pol;
3973
3974         q_u->num_rids1 = num_rids;
3975         q_u->flags = flags;
3976         q_u->ptr = 0;
3977         q_u->num_rids2 = num_rids;
3978         q_u->rid = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids );
3979         if (q_u->rid == NULL) {
3980                 q_u->num_rids1 = 0;
3981                 q_u->num_rids2 = 0;
3982         } else {
3983