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->unknown_0 = 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->unknown_2 = 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("unknown_0", ps, depth, &r_u->unknown_0))
 379                 return False;
 380         if(!prs_uint16("unknown_1", ps, depth, &r_u->unknown_1))
 381                 return False;
 382         if(!prs_uint32("unknown_2", ps, depth, &r_u->unknown_2))
 383                 return False;
 384         if(!prs_ntstatus("status   ", ps, depth, &r_u->status))
 385                 return False;
 386
 387         return True;
 388 }
 389
 390
 391 /*******************************************************************
 392 reads or writes a structure.
 393 ********************************************************************/
 394
 395 BOOL samr_io_q_set_sec_obj(const char *desc, SAMR_Q_SET_SEC_OBJ * q_u,
 396                              prs_struct *ps, int depth)
 397 {
 398         if (q_u == NULL)
 399                 return False;
 400
 401         prs_debug(ps, depth, desc, "samr_io_q_set_sec_obj");
 402         depth++;
 403
 404         if(!prs_align(ps))
 405                 return False;
 406
 407         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
 408                 return False;
 409
 410         if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
 411                 return False;
 412
 413         if(!sec_io_desc_buf("sec_desc", &q_u->buf, ps, depth))
 414                 return False;
 415
 416         return True;
 417 }
 418
 419
 420 /*******************************************************************
 421 reads or writes a structure.
 422 ********************************************************************/
 423
 424 void init_samr_q_query_sec_obj(SAMR_Q_QUERY_SEC_OBJ * q_u,
 425                                POLICY_HND *user_pol, uint32 sec_info)
 426 {
 427         DEBUG(5, ("samr_init_samr_q_query_sec_obj\n"));
 428
 429         q_u->user_pol = *user_pol;
 430         q_u->sec_info = sec_info;
 431 }
 432
 433
 434 /*******************************************************************
 435 reads or writes a structure.
 436 ********************************************************************/
 437
 438 BOOL samr_io_q_query_sec_obj(const char *desc, SAMR_Q_QUERY_SEC_OBJ * q_u,
 439                              prs_struct *ps, int depth)
 440 {
 441         if (q_u == NULL)
 442                 return False;
 443
 444         prs_debug(ps, depth, desc, "samr_io_q_query_sec_obj");
 445         depth++;
 446
 447         if(!prs_align(ps))
 448                 return False;
 449
 450         if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
 451                 return False;
 452
 453         if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
 454                 return False;
 455
 456         return True;
 457 }
 458
 459 /*******************************************************************
 460 reads or writes a structure.
 461 ********************************************************************/
 462
 463 void init_samr_q_query_dom_info(SAMR_Q_QUERY_DOMAIN_INFO * q_u,
 464                                 POLICY_HND *domain_pol, uint16 switch_value)
 465 {
 466         DEBUG(5, ("samr_init_samr_q_query_dom_info\n"));
 467
 468         q_u->domain_pol = *domain_pol;
 469         q_u->switch_value = switch_value;
 470 }
 471
 472 /*******************************************************************
 473 reads or writes a structure.
 474 ********************************************************************/
 475
 476 BOOL samr_io_q_query_dom_info(const char *desc, SAMR_Q_QUERY_DOMAIN_INFO * q_u,
 477                               prs_struct *ps, int depth)
 478 {
 479         if (q_u == NULL)
 480                 return False;
 481
 482         prs_debug(ps, depth, desc, "samr_io_q_query_dom_info");
 483         depth++;
 484
 485         if(!prs_align(ps))
 486                 return False;
 487
 488         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
 489                 return False;
 490
 491         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
 492                 return False;
 493
 494         return True;
 495 }
 496
 497
 498 /*******************************************************************
 499 inits a structure.
 500 ********************************************************************/
 501
 502 void init_unk_info3(SAM_UNK_INFO_3 *u_3, NTTIME nt_logout)
 503 {
 504         u_3->logout.low = nt_logout.low;
 505         u_3->logout.high = nt_logout.high;
 506 }
 507
 508 /*******************************************************************
 509 reads or writes a structure.
 510 ********************************************************************/
 511
 512 static BOOL sam_io_unk_info3(const char *desc, SAM_UNK_INFO_3 * u_3,
 513                              prs_struct *ps, int depth)
 514 {
 515         if (u_3 == NULL)
 516                 return False;
 517
 518         prs_debug(ps, depth, desc, "sam_io_unk_info3");
 519         depth++;
 520
 521         if(!smb_io_time("logout", &u_3->logout, ps, depth))
 522                 return False;
 523
 524         return True;
 525 }
 526
 527 /*******************************************************************
 528 inits a structure.
 529 ********************************************************************/
 530
 531 void init_unk_info6(SAM_UNK_INFO_6 * u_6)
 532 {
 533         u_6->unknown_0 = 0x00000000;
 534         u_6->ptr_0 = 1;
 535         memset(u_6->padding, 0, sizeof(u_6->padding));  /* 12 bytes zeros */
 536 }
 537
 538 /*******************************************************************
 539 reads or writes a structure.
 540 ********************************************************************/
 541
 542 static BOOL sam_io_unk_info6(const char *desc, SAM_UNK_INFO_6 * u_6,
 543                              prs_struct *ps, int depth)
 544 {
 545         if (u_6 == NULL)
 546                 return False;
 547
 548         prs_debug(ps, depth, desc, "sam_io_unk_info6");
 549         depth++;
 550
 551         if(!prs_uint32("unknown_0", ps, depth, &u_6->unknown_0)) /* 0x0000 0000 */
 552                 return False;
 553         if(!prs_uint32("ptr_0", ps, depth, &u_6->ptr_0)) /* pointer to unknown structure */
 554                 return False;
 555         if(!prs_uint8s(False, "padding", ps, depth, u_6->padding, sizeof(u_6->padding)))        /* 12 bytes zeros */
 556                 return False;
 557
 558         return True;
 559 }
 560
 561 /*******************************************************************
 562 inits a structure.
 563 ********************************************************************/
 564
 565 void init_unk_info7(SAM_UNK_INFO_7 * u_7, uint32 server_role)
 566 {
 567         u_7->server_role = server_role;
 568 }
 569
 570 /*******************************************************************
 571 reads or writes a structure.
 572 ********************************************************************/
 573
 574 static BOOL sam_io_unk_info7(const char *desc, SAM_UNK_INFO_7 * u_7,
 575                              prs_struct *ps, int depth)
 576 {
 577         if (u_7 == NULL)
 578                 return False;
 579
 580         prs_debug(ps, depth, desc, "sam_io_unk_info7");
 581         depth++;
 582
 583         if(!prs_uint16("server_role", ps, depth, &u_7->server_role))
 584                 return False;
 585
 586         return True;
 587 }
 588
 589 /*******************************************************************
 590 inits a structure.
 591 ********************************************************************/
 592
 593 void init_unk_info8(SAM_UNK_INFO_8 * u_8, uint32 seq_num)
 594 {
 595         unix_to_nt_time(&u_8->domain_create_time, 0);
 596         u_8->seq_num.low = seq_num;
 597         u_8->seq_num.high = 0x0000;
 598 }
 599
 600 /*******************************************************************
 601 reads or writes a structure.
 602 ********************************************************************/
 603
 604 static BOOL sam_io_unk_info8(const char *desc, SAM_UNK_INFO_8 * u_8,
 605                              prs_struct *ps, int depth)
 606 {
 607         if (u_8 == NULL)
 608                 return False;
 609
 610         prs_debug(ps, depth, desc, "sam_io_unk_info8");
 611         depth++;
 612
 613         if (!prs_uint64("seq_num", ps, depth, &u_8->seq_num))
 614                 return False;
 615
 616         if(!smb_io_time("domain_create_time", &u_8->domain_create_time, ps, depth))
 617                 return False;
 618
 619         return True;
 620 }
 621
 622
 623 /*******************************************************************
 624 inits a structure.
 625 ********************************************************************/
 626
 627 void init_unk_info12(SAM_UNK_INFO_12 * u_12, NTTIME nt_lock_duration, NTTIME nt_reset_time, uint16 lockout)
 628 {
 629         u_12->duration.low = nt_lock_duration.low;
 630         u_12->duration.high = nt_lock_duration.high;
 631         u_12->reset_count.low = nt_reset_time.low;
 632         u_12->reset_count.high = nt_reset_time.high;
 633
 634         u_12->bad_attempt_lockout = lockout;
 635 }
 636
 637 /*******************************************************************
 638 reads or writes a structure.
 639 ********************************************************************/
 640
 641 static BOOL sam_io_unk_info12(const char *desc, SAM_UNK_INFO_12 * u_12,
 642                               prs_struct *ps, int depth)
 643 {
 644         if (u_12 == NULL)
 645                 return False;
 646
 647         prs_debug(ps, depth, desc, "sam_io_unk_info12");
 648         depth++;
 649
 650         if(!smb_io_time("duration", &u_12->duration, ps, depth))
 651                 return False;
 652         if(!smb_io_time("reset_count", &u_12->reset_count, ps, depth))
 653                 return False;
 654         if(!prs_uint16("bad_attempt_lockout", ps, depth, &u_12->bad_attempt_lockout))
 655                 return False;
 656
 657         return True;
 658 }
 659
 660 /*******************************************************************
 661 inits a structure.
 662 ********************************************************************/
 663
 664 void init_unk_info5(SAM_UNK_INFO_5 * u_5,const char *server)
 665 {
 666         init_unistr2(&u_5->uni_server, server, UNI_FLAGS_NONE);
 667         init_uni_hdr(&u_5->hdr_server, &u_5->uni_server);
 668 }
 669
 670 /*******************************************************************
 671 reads or writes a structure.
 672 ********************************************************************/
 673
 674 static BOOL sam_io_unk_info5(const char *desc, SAM_UNK_INFO_5 * u_5,
 675                              prs_struct *ps, int depth)
 676 {
 677         if (u_5 == NULL)
 678                 return False;
 679
 680         prs_debug(ps, depth, desc, "sam_io_unk_info5");
 681         depth++;
 682
 683         if(!smb_io_unihdr("hdr_server", &u_5->hdr_server, ps, depth))
 684                 return False;
 685
 686         if(!smb_io_unistr2("uni_server", &u_5->uni_server, u_5->hdr_server.buffer, ps, depth))
 687                 return False;
 688
 689         return True;
 690 }
 691
 692 /*******************************************************************
 693 inits a structure.
 694 ********************************************************************/
 695
 696 void init_unk_info2(SAM_UNK_INFO_2 * u_2,
 697                         const char *comment, const char *domain, const char *server,
 698                         uint32 seq_num, uint32 num_users, uint32 num_groups, uint32 num_alias, NTTIME nt_logout, uint32 server_role)
 699 {
 700         u_2->logout.low = nt_logout.low;
 701         u_2->logout.high = nt_logout.high;
 702
 703         u_2->seq_num.low = seq_num;
 704         u_2->seq_num.high = 0x00000000;
 705
 706
 707         u_2->unknown_4 = 0x00000001;
 708         u_2->server_role = server_role;
 709         u_2->unknown_6 = 0x00000001;
 710         u_2->num_domain_usrs = num_users;
 711         u_2->num_domain_grps = num_groups;
 712         u_2->num_local_grps = num_alias;
 713
 714         memset(u_2->padding, 0, sizeof(u_2->padding));  /* 12 bytes zeros */
 715
 716         init_unistr2(&u_2->uni_comment, comment, UNI_FLAGS_NONE);
 717         init_uni_hdr(&u_2->hdr_comment, &u_2->uni_comment);
 718         init_unistr2(&u_2->uni_domain, domain, UNI_FLAGS_NONE);
 719         init_uni_hdr(&u_2->hdr_domain, &u_2->uni_domain);
 720         init_unistr2(&u_2->uni_server, server, UNI_FLAGS_NONE);
 721         init_uni_hdr(&u_2->hdr_server, &u_2->uni_server);
 722 }
 723
 724 /*******************************************************************
 725 reads or writes a structure.
 726 ********************************************************************/
 727
 728 static BOOL sam_io_unk_info2(const char *desc, SAM_UNK_INFO_2 * u_2,
 729                              prs_struct *ps, int depth)
 730 {
 731         if (u_2 == NULL)
 732                 return False;
 733
 734         prs_debug(ps, depth, desc, "sam_io_unk_info2");
 735         depth++;
 736
 737         if(!smb_io_time("logout", &u_2->logout, ps, depth))
 738                 return False;
 739         if(!smb_io_unihdr("hdr_comment", &u_2->hdr_comment, ps, depth))
 740                 return False;
 741         if(!smb_io_unihdr("hdr_domain", &u_2->hdr_domain, ps, depth))
 742                 return False;
 743         if(!smb_io_unihdr("hdr_server", &u_2->hdr_server, ps, depth))
 744                 return False;
 745
 746         /* put all the data in here, at the moment, including what the above
 747            pointer is referring to
 748          */
 749
 750         if(!prs_uint64("seq_num ", ps, depth, &u_2->seq_num))
 751                 return False;
 752
 753         if(!prs_uint32("unknown_4 ", ps, depth, &u_2->unknown_4)) /* 0x0000 0001 */
 754                 return False;
 755         if(!prs_uint32("server_role ", ps, depth, &u_2->server_role))
 756                 return False;
 757         if(!prs_uint32("unknown_6 ", ps, depth, &u_2->unknown_6)) /* 0x0000 0001 */
 758                 return False;
 759         if(!prs_uint32("num_domain_usrs ", ps, depth, &u_2->num_domain_usrs))
 760                 return False;
 761         if(!prs_uint32("num_domain_grps", ps, depth, &u_2->num_domain_grps))
 762                 return False;
 763         if(!prs_uint32("num_local_grps", ps, depth, &u_2->num_local_grps))
 764                 return False;
 765
 766         if(!smb_io_unistr2("uni_comment", &u_2->uni_comment, u_2->hdr_comment.buffer, ps, depth))
 767                 return False;
 768         if(!smb_io_unistr2("uni_domain", &u_2->uni_domain, u_2->hdr_domain.buffer, ps, depth))
 769                 return False;
 770         if(!smb_io_unistr2("uni_server", &u_2->uni_server, u_2->hdr_server.buffer, ps, depth))
 771                 return False;
 772
 773         return True;
 774 }
 775
 776 /*******************************************************************
 777 inits a structure.
 778 ********************************************************************/
 779
 780 void init_unk_info1(SAM_UNK_INFO_1 *u_1, uint16 min_pass_len, uint16 pass_hist,
 781                     uint32 flag, NTTIME nt_expire, NTTIME nt_min_age)
 782 {
 783         u_1->min_length_password = min_pass_len;
 784         u_1->password_history = pass_hist;
 785         u_1->flag = flag;
 786
 787         /* password never expire */
 788         u_1->expire.high = nt_expire.high;
 789         u_1->expire.low = nt_expire.low;
 790
 791         /* can change the password now */
 792         u_1->min_passwordage.high = nt_min_age.high;
 793         u_1->min_passwordage.low = nt_min_age.low;
 794
 795 }
 796
 797 /*******************************************************************
 798 reads or writes a structure.
 799 ********************************************************************/
 800
 801 static BOOL sam_io_unk_info1(const char *desc, SAM_UNK_INFO_1 * u_1,
 802                              prs_struct *ps, int depth)
 803 {
 804         if (u_1 == NULL)
 805           return False;
 806
 807         prs_debug(ps, depth, desc, "sam_io_unk_info1");
 808         depth++;
 809
 810         if(!prs_uint16("min_length_password", ps, depth, &u_1->min_length_password))
 811                 return False;
 812         if(!prs_uint16("password_history", ps, depth, &u_1->password_history))
 813                 return False;
 814         if(!prs_uint32("flag", ps, depth, &u_1->flag))
 815                 return False;
 816         if(!smb_io_time("expire", &u_1->expire, ps, depth))
 817                 return False;
 818         if(!smb_io_time("min_passwordage", &u_1->min_passwordage, ps, depth))
 819                 return False;
 820
 821         return True;
 822 }
 823
 824 /*******************************************************************
 825 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
 826 ********************************************************************/
 827
 828 void init_samr_r_query_dom_info(SAMR_R_QUERY_DOMAIN_INFO * r_u,
 829                                 uint16 switch_value, SAM_UNK_CTR * ctr,
 830                                 NTSTATUS status)
 831 {
 832         DEBUG(5, ("init_samr_r_query_dom_info\n"));
 833
 834         r_u->ptr_0 = 0;
 835         r_u->switch_value = 0;
 836         r_u->status = status;   /* return status */
 837
 838         if (NT_STATUS_IS_OK(status)) {
 839                 r_u->switch_value = switch_value;
 840                 r_u->ptr_0 = 1;
 841                 r_u->ctr = ctr;
 842         }
 843 }
 844
 845 /*******************************************************************
 846 reads or writes a structure.
 847 ********************************************************************/
 848
 849 BOOL samr_io_r_query_dom_info(const char *desc, SAMR_R_QUERY_DOMAIN_INFO * r_u,
 850                               prs_struct *ps, int depth)
 851 {
 852         if (r_u == NULL)
 853                 return False;
 854
 855         prs_debug(ps, depth, desc, "samr_io_r_query_dom_info");
 856         depth++;
 857
 858         if(!prs_align(ps))
 859                 return False;
 860
 861         if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
 862                 return False;
 863
 864         if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
 865                 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
 866                         return False;
 867                 if(!prs_align(ps))
 868                         return False;
 869
 870                 switch (r_u->switch_value) {
 871                 case 0x0c:
 872                         if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
 873                                 return False;
 874                         break;
 875                 case 0x08:
 876                         if(!sam_io_unk_info8("unk_inf8",&r_u->ctr->info.inf8, ps,depth))
 877                                 return False;
 878                         break;
 879                 case 0x07:
 880                         if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
 881                                 return False;
 882                         break;
 883                 case 0x06:
 884                         if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
 885                                 return False;
 886                         break;
 887                 case 0x05:
 888                         if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
 889                                 return False;
 890                         break;
 891                 case 0x03:
 892                         if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
 893                                 return False;
 894                         break;
 895                 case 0x02:
 896                         if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
 897                                 return False;
 898                         break;
 899                 case 0x01:
 900                         if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
 901                                 return False;
 902                         break;
 903                 default:
 904                         DEBUG(0, ("samr_io_r_query_dom_info: unknown switch level 0x%x\n",
 905                                 r_u->switch_value));
 906                         r_u->status = NT_STATUS_INVALID_INFO_CLASS;
 907                         return False;
 908                 }
 909         }
 910
 911         if(!prs_align(ps))
 912                 return False;
 913
 914         if(!prs_ntstatus("status", ps, depth, &r_u->status))
 915                 return False;
 916
 917         return True;
 918 }
 919
 920 /*******************************************************************
 921 reads or writes a SAMR_R_SET_SEC_OBJ structure.
 922 ********************************************************************/
 923
 924 BOOL samr_io_r_set_sec_obj(const char *desc, SAMR_R_SET_SEC_OBJ * r_u,
 925                              prs_struct *ps, int depth)
 926 {
 927         if (r_u == NULL)
 928                 return False;
 929
 930         prs_debug(ps, depth, desc, "samr_io_r_set_sec_obj");
 931         depth++;
 932
 933         if(!prs_align(ps))
 934                 return False;
 935
 936         if(!prs_ntstatus("status", ps, depth, &r_u->status))
 937                 return False;
 938
 939         return True;
 940 }
 941
 942 /*******************************************************************
 943 reads or writes a SAMR_R_QUERY_SEC_OBJ structure.
 944 ********************************************************************/
 945
 946 BOOL samr_io_r_query_sec_obj(const char *desc, SAMR_R_QUERY_SEC_OBJ * r_u,
 947                              prs_struct *ps, int depth)
 948 {
 949         if (r_u == NULL)
 950                 return False;
 951
 952         prs_debug(ps, depth, desc, "samr_io_r_query_sec_obj");
 953         depth++;
 954
 955         if(!prs_align(ps))
 956                 return False;
 957
 958         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
 959                 return False;
 960         if (r_u->ptr != 0) {
 961                 if(!sec_io_desc_buf("sec", &r_u->buf, ps, depth))
 962                         return False;
 963         }
 964
 965         if(!prs_ntstatus("status", ps, depth, &r_u->status))
 966                 return False;
 967
 968         return True;
 969 }
 970
 971 /*******************************************************************
 972 reads or writes a SAM_STR1 structure.
 973 ********************************************************************/
 974
 975 static BOOL sam_io_sam_str1(const char *desc, SAM_STR1 * sam, uint32 acct_buf,
 976                             uint32 name_buf, uint32 desc_buf,
 977                             prs_struct *ps, int depth)
 978 {
 979         if (sam == NULL)
 980                 return False;
 981
 982         prs_debug(ps, depth, desc, "sam_io_sam_str1");
 983         depth++;
 984
 985         if(!prs_align(ps))
 986                 return False;
 987         if (!smb_io_unistr2("name", &sam->uni_acct_name, acct_buf, ps, depth))
 988                 return False;
 989
 990         if (!smb_io_unistr2("desc", &sam->uni_acct_desc, desc_buf, ps, depth))
 991                 return False;
 992
 993         if (!smb_io_unistr2("full", &sam->uni_full_name, name_buf, ps, depth))
 994                 return False;
 995
 996         return True;
 997 }
 998
 999 /*******************************************************************
1000 inits a SAM_ENTRY1 structure.
1001 ********************************************************************/
1002
1003 static void init_sam_entry1(SAM_ENTRY1 *sam, uint32 user_idx,
1004                             UNISTR2 *sam_name, UNISTR2 *sam_full,
1005                             UNISTR2 *sam_desc, uint32 rid_user,
1006                             uint16 acb_info)
1007 {
1008         DEBUG(5, ("init_sam_entry1\n"));
1009
1010         ZERO_STRUCTP(sam);
1011
1012         sam->user_idx = user_idx;
1013         sam->rid_user = rid_user;
1014         sam->acb_info = acb_info;
1015
1016         init_uni_hdr(&sam->hdr_acct_name, sam_name);
1017         init_uni_hdr(&sam->hdr_user_name, sam_full);
1018         init_uni_hdr(&sam->hdr_user_desc, sam_desc);
1019 }
1020
1021 /*******************************************************************
1022 reads or writes a SAM_ENTRY1 structure.
1023 ********************************************************************/
1024
1025 static BOOL sam_io_sam_entry1(const char *desc, SAM_ENTRY1 * sam,
1026                               prs_struct *ps, int depth)
1027 {
1028         if (sam == NULL)
1029                 return False;
1030
1031         prs_debug(ps, depth, desc, "sam_io_sam_entry1");
1032         depth++;
1033
1034         if(!prs_align(ps))
1035                 return False;
1036
1037         if(!prs_uint32("user_idx ", ps, depth, &sam->user_idx))
1038                 return False;
1039
1040         if(!prs_uint32("rid_user ", ps, depth, &sam->rid_user))
1041                 return False;
1042         if(!prs_uint16("acb_info ", ps, depth, &sam->acb_info))
1043                 return False;
1044
1045         if(!prs_align(ps))
1046                 return False;
1047
1048         if (!smb_io_unihdr("hdr_acct_name", &sam->hdr_acct_name, ps, depth))
1049                 return False;
1050         if (!smb_io_unihdr("hdr_user_desc", &sam->hdr_user_desc, ps, depth))
1051                 return False;
1052         if (!smb_io_unihdr("hdr_user_name", &sam->hdr_user_name, ps, depth))
1053                 return False;
1054
1055         return True;
1056 }
1057
1058 /*******************************************************************
1059 reads or writes a SAM_STR2 structure.
1060 ********************************************************************/
1061
1062 static BOOL sam_io_sam_str2(const char *desc, SAM_STR2 * sam, uint32 acct_buf,
1063                             uint32 desc_buf, prs_struct *ps, int depth)
1064 {
1065         if (sam == NULL)
1066                 return False;
1067
1068         prs_debug(ps, depth, desc, "sam_io_sam_str2");
1069         depth++;
1070
1071         if(!prs_align(ps))
1072                 return False;
1073
1074         if(!smb_io_unistr2("uni_srv_name", &sam->uni_srv_name, acct_buf, ps, depth)) /* account name unicode string */
1075                 return False;
1076         if(!smb_io_unistr2("uni_srv_desc", &sam->uni_srv_desc, desc_buf, ps, depth))    /* account desc unicode string */
1077                 return False;
1078
1079         return True;
1080 }
1081
1082 /*******************************************************************
1083 inits a SAM_ENTRY2 structure.
1084 ********************************************************************/
1085 static void init_sam_entry2(SAM_ENTRY2 * sam, uint32 user_idx,
1086                             UNISTR2 *sam_name, UNISTR2 *sam_desc,
1087                             uint32 rid_user, uint16 acb_info)
1088 {
1089         DEBUG(5, ("init_sam_entry2\n"));
1090
1091         sam->user_idx = user_idx;
1092         sam->rid_user = rid_user;
1093         sam->acb_info = acb_info;
1094
1095         init_uni_hdr(&sam->hdr_srv_name, sam_name);
1096         init_uni_hdr(&sam->hdr_srv_desc, sam_desc);
1097 }
1098
1099 /*******************************************************************
1100 reads or writes a SAM_ENTRY2 structure.
1101 ********************************************************************/
1102
1103 static BOOL sam_io_sam_entry2(const char *desc, SAM_ENTRY2 * sam,
1104                               prs_struct *ps, int depth)
1105 {
1106         if (sam == NULL)
1107                 return False;
1108
1109         prs_debug(ps, depth, desc, "sam_io_sam_entry2");
1110         depth++;
1111
1112         if(!prs_align(ps))
1113                 return False;
1114
1115         if(!prs_uint32("user_idx ", ps, depth, &sam->user_idx))
1116                 return False;
1117
1118         if(!prs_uint32("rid_user ", ps, depth, &sam->rid_user))
1119                 return False;
1120         if(!prs_uint16("acb_info ", ps, depth, &sam->acb_info))
1121                 return False;
1122
1123         if(!prs_align(ps))
1124                 return False;
1125
1126         if(!smb_io_unihdr("unihdr", &sam->hdr_srv_name, ps, depth))     /* account name unicode string header */
1127                 return False;
1128         if(!smb_io_unihdr("unihdr", &sam->hdr_srv_desc, ps, depth))     /* account name unicode string header */
1129                 return False;
1130
1131         return True;
1132 }
1133
1134 /*******************************************************************
1135 reads or writes a SAM_STR3 structure.
1136 ********************************************************************/
1137
1138 static BOOL sam_io_sam_str3(const char *desc, SAM_STR3 * sam, uint32 acct_buf,
1139                             uint32 desc_buf, prs_struct *ps, int depth)
1140 {
1141         if (sam == NULL)
1142                 return False;
1143
1144         prs_debug(ps, depth, desc, "sam_io_sam_str3");
1145         depth++;
1146
1147         if(!prs_align(ps))
1148                 return False;
1149
1150         if(!smb_io_unistr2("uni_grp_name", &sam->uni_grp_name, acct_buf, ps, depth))    /* account name unicode string */
1151                 return False;
1152         if(!smb_io_unistr2("uni_grp_desc", &sam->uni_grp_desc, desc_buf, ps, depth))    /* account desc unicode string */
1153                 return False;
1154
1155         return True;
1156 }
1157
1158 /*******************************************************************
1159 inits a SAM_ENTRY3 structure.
1160 ********************************************************************/
1161
1162 static void init_sam_entry3(SAM_ENTRY3 * sam, uint32 grp_idx,
1163                             UNISTR2 *grp_name, UNISTR2 *grp_desc,
1164                             uint32 rid_grp)
1165 {
1166         DEBUG(5, ("init_sam_entry3\n"));
1167
1168         sam->grp_idx = grp_idx;
1169         sam->rid_grp = rid_grp;
1170         sam->attr = 0x07;       /* group rid attributes - gets ignored by nt 4.0 */
1171
1172         init_uni_hdr(&sam->hdr_grp_name, grp_name);
1173         init_uni_hdr(&sam->hdr_grp_desc, grp_desc);
1174 }
1175
1176 /*******************************************************************
1177 reads or writes a SAM_ENTRY3 structure.
1178 ********************************************************************/
1179
1180 static BOOL sam_io_sam_entry3(const char *desc, SAM_ENTRY3 * sam,
1181                               prs_struct *ps, int depth)
1182 {
1183         if (sam == NULL)
1184                 return False;
1185
1186         prs_debug(ps, depth, desc, "sam_io_sam_entry3");
1187         depth++;
1188
1189         if(!prs_align(ps))
1190                 return False;
1191
1192         if(!prs_uint32("grp_idx", ps, depth, &sam->grp_idx))
1193                 return False;
1194
1195         if(!prs_uint32("rid_grp", ps, depth, &sam->rid_grp))
1196                 return False;
1197         if(!prs_uint32("attr   ", ps, depth, &sam->attr))
1198                 return False;
1199
1200         if(!smb_io_unihdr("unihdr", &sam->hdr_grp_name, ps, depth))     /* account name unicode string header */
1201                 return False;
1202         if(!smb_io_unihdr("unihdr", &sam->hdr_grp_desc, ps, depth))     /* account name unicode string header */
1203                 return False;
1204
1205         return True;
1206 }
1207
1208 /*******************************************************************
1209 inits a SAM_ENTRY4 structure.
1210 ********************************************************************/
1211
1212 static void init_sam_entry4(SAM_ENTRY4 * sam, uint32 user_idx,
1213                             uint32 len_acct_name)
1214 {
1215         DEBUG(5, ("init_sam_entry4\n"));
1216
1217         sam->user_idx = user_idx;
1218         init_str_hdr(&sam->hdr_acct_name, len_acct_name+1, len_acct_name, len_acct_name != 0);
1219 }
1220
1221 /*******************************************************************
1222 reads or writes a SAM_ENTRY4 structure.
1223 ********************************************************************/
1224
1225 static BOOL sam_io_sam_entry4(const char *desc, SAM_ENTRY4 * sam,
1226                               prs_struct *ps, int depth)
1227 {
1228         if (sam == NULL)
1229                 return False;
1230
1231         prs_debug(ps, depth, desc, "sam_io_sam_entry4");
1232         depth++;
1233
1234         if(!prs_align(ps))
1235                 return False;
1236
1237         if(!prs_uint32("user_idx", ps, depth, &sam->user_idx))
1238                 return False;
1239         if(!smb_io_strhdr("strhdr", &sam->hdr_acct_name, ps, depth))
1240                 return False;
1241
1242         return True;
1243 }
1244
1245 /*******************************************************************
1246 inits a SAM_ENTRY5 structure.
1247 ********************************************************************/
1248
1249 static void init_sam_entry5(SAM_ENTRY5 * sam, uint32 grp_idx,
1250                             uint32 len_grp_name)
1251 {
1252         DEBUG(5, ("init_sam_entry5\n"));
1253
1254         sam->grp_idx = grp_idx;
1255         init_str_hdr(&sam->hdr_grp_name, len_grp_name, len_grp_name,
1256                      len_grp_name != 0);
1257 }
1258
1259 /*******************************************************************
1260 reads or writes a SAM_ENTRY5 structure.
1261 ********************************************************************/
1262
1263 static BOOL sam_io_sam_entry5(const char *desc, SAM_ENTRY5 * sam,
1264                               prs_struct *ps, int depth)
1265 {
1266         if (sam == NULL)
1267                 return False;
1268
1269         prs_debug(ps, depth, desc, "sam_io_sam_entry5");
1270         depth++;
1271
1272         if(!prs_align(ps))
1273                 return False;
1274
1275         if(!prs_uint32("grp_idx", ps, depth, &sam->grp_idx))
1276                 return False;
1277         if(!smb_io_strhdr("strhdr", &sam->hdr_grp_name, ps, depth))
1278                 return False;
1279
1280         return True;
1281 }
1282
1283 /*******************************************************************
1284 inits a SAM_ENTRY structure.
1285 ********************************************************************/
1286
1287 void init_sam_entry(SAM_ENTRY *sam, UNISTR2 *uni2, uint32 rid)
1288 {
1289         DEBUG(10, ("init_sam_entry: %d\n", rid));
1290
1291         sam->rid = rid;
1292         init_uni_hdr(&sam->hdr_name, uni2);
1293 }
1294
1295 /*******************************************************************
1296 reads or writes a SAM_ENTRY structure.
1297 ********************************************************************/
1298
1299 static BOOL sam_io_sam_entry(const char *desc, SAM_ENTRY * sam,
1300                              prs_struct *ps, int depth)
1301 {
1302         if (sam == NULL)
1303                 return False;
1304
1305         prs_debug(ps, depth, desc, "sam_io_sam_entry");
1306         depth++;
1307
1308         if(!prs_align(ps))
1309                 return False;
1310         if(!prs_uint32("rid", ps, depth, &sam->rid))
1311                 return False;
1312         if(!smb_io_unihdr("unihdr", &sam->hdr_name, ps, depth)) /* account name unicode string header */
1313                 return False;
1314
1315         return True;
1316 }
1317
1318 /*******************************************************************
1319 inits a SAMR_Q_ENUM_DOM_USERS structure.
1320 ********************************************************************/
1321
1322 void init_samr_q_enum_dom_users(SAMR_Q_ENUM_DOM_USERS * q_e, POLICY_HND *pol,
1323                                 uint32 start_idx,
1324                                 uint16 acb_mask, uint16 unk_1, uint32 size)
1325 {
1326         DEBUG(5, ("init_samr_q_enum_dom_users\n"));
1327
1328         q_e->pol = *pol;
1329
1330         q_e->start_idx = start_idx;     /* zero indicates lots */
1331         q_e->acb_mask = acb_mask;
1332         q_e->unknown_1 = unk_1;
1333         q_e->max_size = size;
1334 }
1335
1336 /*******************************************************************
1337 reads or writes a structure.
1338 ********************************************************************/
1339
1340 BOOL samr_io_q_enum_dom_users(const char *desc, SAMR_Q_ENUM_DOM_USERS * q_e,
1341                               prs_struct *ps, int depth)
1342 {
1343         if (q_e == NULL)
1344                 return False;
1345
1346         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_users");
1347         depth++;
1348
1349         if(!prs_align(ps))
1350                 return False;
1351
1352         if(!smb_io_pol_hnd("domain_pol", &q_e->pol, ps, depth))
1353                 return False;
1354
1355         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
1356                 return False;
1357         if(!prs_uint16("acb_mask ", ps, depth, &q_e->acb_mask))
1358                 return False;
1359         if(!prs_uint16("unknown_1", ps, depth, &q_e->unknown_1))
1360                 return False;
1361
1362         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
1363                 return False;
1364
1365         return True;
1366 }
1367
1368
1369 /*******************************************************************
1370 inits a SAMR_R_ENUM_DOM_USERS structure.
1371 ********************************************************************/
1372
1373 void init_samr_r_enum_dom_users(SAMR_R_ENUM_DOM_USERS * r_u,
1374                                 uint32 next_idx, uint32 num_sam_entries)
1375 {
1376         DEBUG(5, ("init_samr_r_enum_dom_users\n"));
1377
1378         r_u->next_idx = next_idx;
1379
1380         if (num_sam_entries != 0) {
1381                 r_u->ptr_entries1 = 1;
1382                 r_u->ptr_entries2 = 1;
1383                 r_u->num_entries2 = num_sam_entries;
1384                 r_u->num_entries3 = num_sam_entries;
1385
1386                 r_u->num_entries4 = num_sam_entries;
1387         } else {
1388                 r_u->ptr_entries1 = 0;
1389                 r_u->num_entries2 = num_sam_entries;
1390                 r_u->ptr_entries2 = 1;
1391         }
1392 }
1393
1394 /*******************************************************************
1395 reads or writes a structure.
1396 ********************************************************************/
1397
1398 BOOL samr_io_r_enum_dom_users(const char *desc, SAMR_R_ENUM_DOM_USERS * r_u,
1399                               prs_struct *ps, int depth)
1400 {
1401         uint32 i;
1402
1403         if (r_u == NULL)
1404                 return False;
1405
1406         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_users");
1407         depth++;
1408
1409         if(!prs_align(ps))
1410                 return False;
1411
1412         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
1413                 return False;
1414         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
1415                 return False;
1416
1417         if (r_u->ptr_entries1 != 0) {
1418                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
1419                         return False;
1420                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
1421                         return False;
1422                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
1423                         return False;
1424
1425                 if (UNMARSHALLING(ps) && (r_u->num_entries2 != 0)) {
1426                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY, r_u->num_entries2);
1427                         r_u->uni_acct_name = PRS_ALLOC_MEM(ps,UNISTR2, r_u->num_entries2);
1428                 }
1429
1430                 if ((r_u->sam == NULL || r_u->uni_acct_name == NULL) && r_u->num_entries2 != 0) {
1431                         DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_USERS\n"));
1432                         r_u->num_entries4 = 0;
1433                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
1434                         return False;
1435                 }
1436
1437                 for (i = 0; i < r_u->num_entries2; i++) {
1438                         if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
1439                                 return False;
1440                 }
1441
1442                 for (i = 0; i < r_u->num_entries2; i++) {
1443                         if(!smb_io_unistr2("", &r_u->uni_acct_name[i],r_u->sam[i].hdr_name.buffer, ps,depth))
1444                                 return False;
1445                 }
1446
1447         }
1448
1449         if(!prs_align(ps))
1450                 return False;
1451
1452         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
1453                 return False;
1454         if(!prs_ntstatus("status", ps, depth, &r_u->status))
1455                 return False;
1456
1457         return True;
1458 }
1459
1460 /*******************************************************************
1461 inits a SAMR_Q_QUERY_DISPINFO structure.
1462 ********************************************************************/
1463
1464 void init_samr_q_query_dispinfo(SAMR_Q_QUERY_DISPINFO * q_e, POLICY_HND *pol,
1465                                 uint16 switch_level, uint32 start_idx,
1466                                 uint32 max_entries, uint32 max_size)
1467 {
1468         DEBUG(5, ("init_samr_q_query_dispinfo\n"));
1469
1470         q_e->domain_pol = *pol;
1471
1472         q_e->switch_level = switch_level;
1473
1474         q_e->start_idx = start_idx;
1475         q_e->max_entries = max_entries;
1476         q_e->max_size = max_size;
1477 }
1478
1479 /*******************************************************************
1480 reads or writes a structure.
1481 ********************************************************************/
1482
1483 BOOL samr_io_q_query_dispinfo(const char *desc, SAMR_Q_QUERY_DISPINFO * q_e,
1484                               prs_struct *ps, int depth)
1485 {
1486         if (q_e == NULL)
1487                 return False;
1488
1489         prs_debug(ps, depth, desc, "samr_io_q_query_dispinfo");
1490         depth++;
1491
1492         if(!prs_align(ps))
1493                 return False;
1494
1495         if(!smb_io_pol_hnd("domain_pol", &q_e->domain_pol, ps, depth))
1496                 return False;
1497
1498         if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
1499                 return False;
1500         if(!prs_align(ps))
1501                 return False;
1502
1503         if(!prs_uint32("start_idx   ", ps, depth, &q_e->start_idx))
1504                 return False;
1505         if(!prs_uint32("max_entries ", ps, depth, &q_e->max_entries))
1506                 return False;
1507         if(!prs_uint32("max_size    ", ps, depth, &q_e->max_size))
1508                 return False;
1509
1510         return True;
1511 }
1512
1513 /*******************************************************************
1514 inits a SAM_DISPINFO_1 structure.
1515 ********************************************************************/
1516
1517 NTSTATUS init_sam_dispinfo_1(TALLOC_CTX *ctx, SAM_DISPINFO_1 **sam,
1518                              uint32 num_entries, uint32 start_idx,
1519                              struct samr_displayentry *entries)
1520 {
1521         uint32 i;
1522
1523         DEBUG(10, ("init_sam_dispinfo_1: num_entries: %d\n", num_entries));
1524
1525         if (num_entries==0)
1526                 return NT_STATUS_OK;
1527
1528         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_1, num_entries);
1529         if (*sam == NULL)
1530                 return NT_STATUS_NO_MEMORY;
1531
1532         (*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY1, num_entries);
1533         if ((*sam)->sam == NULL)
1534                 return NT_STATUS_NO_MEMORY;
1535
1536         (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR1, num_entries);
1537         if ((*sam)->str == NULL)
1538                 return NT_STATUS_NO_MEMORY;
1539
1540         for (i = 0; i < num_entries ; i++) {
1541                 init_unistr2(&(*sam)->str[i].uni_acct_name,
1542                              entries[i].account_name, UNI_FLAGS_NONE);
1543                 init_unistr2(&(*sam)->str[i].uni_full_name,
1544                              entries[i].fullname, UNI_FLAGS_NONE);
1545                 init_unistr2(&(*sam)->str[i].uni_acct_desc,
1546                              entries[i].description, UNI_FLAGS_NONE);
1547
1548                 init_sam_entry1(&(*sam)->sam[i], start_idx+i+1,
1549                                 &(*sam)->str[i].uni_acct_name,
1550                                 &(*sam)->str[i].uni_full_name,
1551                                 &(*sam)->str[i].uni_acct_desc,
1552                                 entries[i].rid, entries[i].acct_flags);
1553         }
1554
1555         return NT_STATUS_OK;
1556 }
1557
1558 /*******************************************************************
1559 reads or writes a structure.
1560 ********************************************************************/
1561
1562 static BOOL sam_io_sam_dispinfo_1(const char *desc, SAM_DISPINFO_1 * sam,
1563                                   uint32 num_entries,
1564                                   prs_struct *ps, int depth)
1565 {
1566         uint32 i;
1567
1568         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_1");
1569         depth++;
1570
1571         if(!prs_align(ps))
1572                 return False;
1573
1574         if (UNMARSHALLING(ps) && num_entries > 0) {
1575
1576                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY1, num_entries)) == NULL) {
1577                         DEBUG(0, ("out of memory allocating SAM_ENTRY1\n"));
1578                         return False;
1579                 }
1580
1581                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR1, num_entries)) == NULL) {
1582                         DEBUG(0, ("out of memory allocating SAM_STR1\n"));
1583                         return False;
1584                 }
1585         }
1586
1587         for (i = 0; i < num_entries; i++) {
1588                 if(!sam_io_sam_entry1("", &sam->sam[i], ps, depth))
1589                         return False;
1590         }
1591
1592         for (i = 0; i < num_entries; i++) {
1593                 if(!sam_io_sam_str1("", &sam->str[i],
1594                               sam->sam[i].hdr_acct_name.buffer,
1595                               sam->sam[i].hdr_user_name.buffer,
1596                               sam->sam[i].hdr_user_desc.buffer, ps, depth))
1597                         return False;
1598         }
1599
1600         return True;
1601 }
1602
1603 /*******************************************************************
1604 inits a SAM_DISPINFO_2 structure.
1605 ********************************************************************/
1606
1607 NTSTATUS init_sam_dispinfo_2(TALLOC_CTX *ctx, SAM_DISPINFO_2 **sam,
1608                              uint32 num_entries, uint32 start_idx,
1609                              struct samr_displayentry *entries)
1610 {
1611         uint32 i;
1612
1613         DEBUG(10, ("init_sam_dispinfo_2: num_entries: %d\n", num_entries));
1614
1615         if (num_entries==0)
1616                 return NT_STATUS_OK;
1617
1618         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_2, num_entries);
1619         if (*sam == NULL)
1620                 return NT_STATUS_NO_MEMORY;
1621
1622         (*sam)->sam = TALLOC_ARRAY(ctx, SAM_ENTRY2, num_entries);
1623         if ((*sam)->sam == NULL)
1624                 return NT_STATUS_NO_MEMORY;
1625
1626         (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR2, num_entries);
1627         if ((*sam)->str == NULL)
1628                 return NT_STATUS_NO_MEMORY;
1629
1630         for (i = 0; i < num_entries; i++) {
1631                 init_unistr2(&(*sam)->str[i].uni_srv_name,
1632                              entries[i].account_name, UNI_FLAGS_NONE);
1633                 init_unistr2(&(*sam)->str[i].uni_srv_desc,
1634                              entries[i].description, UNI_FLAGS_NONE);
1635
1636                 init_sam_entry2(&(*sam)->sam[i], start_idx + i + 1,
1637                                 &(*sam)->str[i].uni_srv_name,
1638                                 &(*sam)->str[i].uni_srv_desc,
1639                                 entries[i].rid, entries[i].acct_flags);
1640         }
1641
1642         return NT_STATUS_OK;
1643 }
1644
1645 /*******************************************************************
1646 reads or writes a structure.
1647 ********************************************************************/
1648
1649 static BOOL sam_io_sam_dispinfo_2(const char *desc, SAM_DISPINFO_2 * sam,
1650                                   uint32 num_entries,
1651                                   prs_struct *ps, int depth)
1652 {
1653         uint32 i;
1654
1655         if (sam == NULL)
1656                 return False;
1657
1658         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_2");
1659         depth++;
1660
1661         if(!prs_align(ps))
1662                 return False;
1663
1664         if (UNMARSHALLING(ps) && num_entries > 0) {
1665
1666                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY2, num_entries)) == NULL) {
1667                         DEBUG(0, ("out of memory allocating SAM_ENTRY2\n"));
1668                         return False;
1669                 }
1670
1671                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR2, num_entries)) == NULL) {
1672                         DEBUG(0, ("out of memory allocating SAM_STR2\n"));
1673                         return False;
1674                 }
1675         }
1676
1677         for (i = 0; i < num_entries; i++) {
1678                 if(!sam_io_sam_entry2("", &sam->sam[i], ps, depth))
1679                         return False;
1680         }
1681
1682         for (i = 0; i < num_entries; i++) {
1683                 if(!sam_io_sam_str2("", &sam->str[i],
1684                               sam->sam[i].hdr_srv_name.buffer,
1685                               sam->sam[i].hdr_srv_desc.buffer, ps, depth))
1686                         return False;
1687         }
1688
1689         return True;
1690 }
1691
1692 /*******************************************************************
1693 inits a SAM_DISPINFO_3 structure.
1694 ********************************************************************/
1695
1696 NTSTATUS init_sam_dispinfo_3(TALLOC_CTX *ctx, SAM_DISPINFO_3 **sam,
1697                              uint32 num_entries, uint32 start_idx,
1698                              struct samr_displayentry *entries)
1699 {
1700         uint32 i;
1701
1702         DEBUG(5, ("init_sam_dispinfo_3: num_entries: %d\n", num_entries));
1703
1704         if (num_entries==0)
1705                 return NT_STATUS_OK;
1706
1707         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_3, num_entries);
1708         if (*sam == NULL)
1709                 return NT_STATUS_NO_MEMORY;
1710
1711         if (!((*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY3, num_entries)))
1712                 return NT_STATUS_NO_MEMORY;
1713
1714         if (!((*sam)->str=TALLOC_ARRAY(ctx, SAM_STR3, num_entries)))
1715                 return NT_STATUS_NO_MEMORY;
1716
1717         for (i = 0; i < num_entries; i++) {
1718                 DEBUG(11, ("init_sam_dispinfo_3: entry: %d\n",i));
1719
1720                 init_unistr2(&(*sam)->str[i].uni_grp_name,
1721                              entries[i].account_name, UNI_FLAGS_NONE);
1722                 init_unistr2(&(*sam)->str[i].uni_grp_desc,
1723                              entries[i].description, UNI_FLAGS_NONE);
1724
1725                 init_sam_entry3(&(*sam)->sam[i], start_idx+i+1,
1726                                 &(*sam)->str[i].uni_grp_name,
1727                                 &(*sam)->str[i].uni_grp_desc,
1728                                 entries[i].rid);
1729         }
1730
1731         return NT_STATUS_OK;
1732 }
1733
1734 /*******************************************************************
1735 reads or writes a structure.
1736 ********************************************************************/
1737
1738 static BOOL sam_io_sam_dispinfo_3(const char *desc, SAM_DISPINFO_3 * sam,
1739                                   uint32 num_entries,
1740                                   prs_struct *ps, int depth)
1741 {
1742         uint32 i;
1743
1744         if (sam == NULL)
1745                 return False;
1746
1747         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_3");
1748         depth++;
1749
1750         if(!prs_align(ps))
1751                 return False;
1752
1753         if (UNMARSHALLING(ps) && num_entries > 0) {
1754
1755                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY3, num_entries)) == NULL) {
1756                         DEBUG(0, ("out of memory allocating SAM_ENTRY3\n"));
1757                         return False;
1758                 }
1759
1760                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR3, num_entries)) == NULL) {
1761                         DEBUG(0, ("out of memory allocating SAM_STR3\n"));
1762                         return False;
1763                 }
1764         }
1765
1766         for (i = 0; i < num_entries; i++) {
1767                 if(!sam_io_sam_entry3("", &sam->sam[i], ps, depth))
1768                         return False;
1769         }
1770
1771         for (i = 0; i < num_entries; i++) {
1772                 if(!sam_io_sam_str3("", &sam->str[i],
1773                               sam->sam[i].hdr_grp_name.buffer,
1774                               sam->sam[i].hdr_grp_desc.buffer, ps, depth))
1775                         return False;
1776         }
1777
1778         return True;
1779 }
1780
1781 /*******************************************************************
1782 inits a SAM_DISPINFO_4 structure.
1783 ********************************************************************/
1784
1785 NTSTATUS init_sam_dispinfo_4(TALLOC_CTX *ctx, SAM_DISPINFO_4 **sam,
1786                              uint32 num_entries, uint32 start_idx,
1787                              struct samr_displayentry *entries)
1788 {
1789         uint32 i;
1790
1791         DEBUG(5, ("init_sam_dispinfo_4: num_entries: %d\n", num_entries));
1792
1793         if (num_entries==0)
1794                 return NT_STATUS_OK;
1795
1796         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_4, num_entries);
1797         if (*sam == NULL)
1798                 return NT_STATUS_NO_MEMORY;
1799
1800         (*sam)->sam = TALLOC_ARRAY(ctx, SAM_ENTRY4, num_entries);
1801         if ((*sam)->sam == NULL)
1802                 return NT_STATUS_NO_MEMORY;
1803
1804         (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR4, num_entries);
1805         if ((*sam)->str == NULL)
1806                 return NT_STATUS_NO_MEMORY;
1807
1808         for (i = 0; i < num_entries; i++) {
1809                 size_t len_sam_name = strlen(entries[i].account_name);
1810
1811                 DEBUG(11, ("init_sam_dispinfo_2: entry: %d\n",i));
1812
1813                 init_sam_entry4(&(*sam)->sam[i], start_idx + i + 1,
1814                                 len_sam_name);
1815
1816                 init_string2(&(*sam)->str[i].acct_name,
1817                              entries[i].account_name, len_sam_name+1,
1818                              len_sam_name);
1819         }
1820
1821         return NT_STATUS_OK;
1822 }
1823
1824 /*******************************************************************
1825 reads or writes a structure.
1826 ********************************************************************/
1827
1828 static BOOL sam_io_sam_dispinfo_4(const char *desc, SAM_DISPINFO_4 * sam,
1829                                   uint32 num_entries,
1830                                   prs_struct *ps, int depth)
1831 {
1832         uint32 i;
1833
1834         if (sam == NULL)
1835                 return False;
1836
1837         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_4");
1838         depth++;
1839
1840         if(!prs_align(ps))
1841                 return False;
1842
1843         if (UNMARSHALLING(ps) && num_entries > 0) {
1844
1845                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY4, num_entries)) == NULL) {
1846                         DEBUG(0, ("out of memory allocating SAM_ENTRY4\n"));
1847                         return False;
1848                 }
1849
1850                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR4, num_entries)) == NULL) {
1851                         DEBUG(0, ("out of memory allocating SAM_STR4\n"));
1852                         return False;
1853                 }
1854         }
1855
1856         for (i = 0; i < num_entries; i++) {
1857                 if(!sam_io_sam_entry4("", &sam->sam[i], ps, depth))
1858                         return False;
1859         }
1860
1861         for (i = 0; i < num_entries; i++) {
1862                 if(!smb_io_string2("acct_name", &sam->str[i].acct_name,
1863                              sam->sam[i].hdr_acct_name.buffer, ps, depth))
1864                         return False;
1865         }
1866
1867         return True;
1868 }
1869
1870 /*******************************************************************
1871 inits a SAM_DISPINFO_5 structure.
1872 ********************************************************************/
1873
1874 NTSTATUS init_sam_dispinfo_5(TALLOC_CTX *ctx, SAM_DISPINFO_5 **sam,
1875                              uint32 num_entries, uint32 start_idx,
1876                              struct samr_displayentry *entries)
1877 {
1878         uint32 len_sam_name;
1879         uint32 i;
1880
1881         DEBUG(5, ("init_sam_dispinfo_5: num_entries: %d\n", num_entries));
1882
1883         if (num_entries==0)
1884                 return NT_STATUS_OK;
1885
1886         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_5, num_entries);
1887         if (*sam == NULL)
1888                 return NT_STATUS_NO_MEMORY;
1889
1890         if (!((*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY5, num_entries)))
1891                 return NT_STATUS_NO_MEMORY;
1892
1893         if (!((*sam)->str=TALLOC_ARRAY(ctx, SAM_STR5, num_entries)))
1894                 return NT_STATUS_NO_MEMORY;
1895
1896         for (i = 0; i < num_entries; i++) {
1897                 DEBUG(11, ("init_sam_dispinfo_5: entry: %d\n",i));
1898
1899                 len_sam_name = strlen(entries[i].account_name);
1900
1901                 init_sam_entry5(&(*sam)->sam[i], start_idx+i+1, len_sam_name);
1902                 init_string2(&(*sam)->str[i].grp_name, entries[i].account_name,
1903                              len_sam_name+1, len_sam_name);
1904         }
1905
1906         return NT_STATUS_OK;
1907 }
1908
1909 /*******************************************************************
1910 reads or writes a structure.
1911 ********************************************************************/
1912
1913 static BOOL sam_io_sam_dispinfo_5(const char *desc, SAM_DISPINFO_5 * sam,
1914                                   uint32 num_entries,
1915                                   prs_struct *ps, int depth)
1916 {
1917         uint32 i;
1918
1919         if (sam == NULL)
1920                 return False;
1921
1922         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_5");
1923         depth++;
1924
1925         if(!prs_align(ps))
1926                 return False;
1927
1928         if (UNMARSHALLING(ps) && num_entries > 0) {
1929
1930                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY5, num_entries)) == NULL) {
1931                         DEBUG(0, ("out of memory allocating SAM_ENTRY5\n"));
1932                         return False;
1933                 }
1934
1935                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR5, num_entries)) == NULL) {
1936                         DEBUG(0, ("out of memory allocating SAM_STR5\n"));
1937                         return False;
1938                 }
1939         }
1940
1941         for (i = 0; i < num_entries; i++) {
1942                 if(!sam_io_sam_entry5("", &sam->sam[i], ps, depth))
1943                         return False;
1944         }
1945
1946         for (i = 0; i < num_entries; i++) {
1947                 if(!smb_io_string2("grp_name", &sam->str[i].grp_name,
1948                              sam->sam[i].hdr_grp_name.buffer, ps, depth))
1949                         return False;
1950         }
1951
1952         return True;
1953 }
1954
1955 /*******************************************************************
1956 inits a SAMR_R_QUERY_DISPINFO structure.
1957 ********************************************************************/
1958
1959 void init_samr_r_query_dispinfo(SAMR_R_QUERY_DISPINFO * r_u,
1960                                 uint32 num_entries, uint32 total_size, uint32 data_size,
1961                                 uint16 switch_level, SAM_DISPINFO_CTR * ctr,
1962                                 NTSTATUS status)
1963 {
1964         DEBUG(5, ("init_samr_r_query_dispinfo: level %d\n", switch_level));
1965
1966         r_u->total_size = total_size;
1967
1968         r_u->data_size = data_size;
1969
1970         r_u->switch_level = switch_level;
1971         r_u->num_entries = num_entries;
1972
1973         if (num_entries==0)
1974                 r_u->ptr_entries = 0;
1975         else
1976                 r_u->ptr_entries = 1;
1977
1978         r_u->num_entries2 = num_entries;
1979         r_u->ctr = ctr;
1980
1981         r_u->status = status;
1982 }
1983
1984 /*******************************************************************
1985 reads or writes a structure.
1986 ********************************************************************/
1987
1988 BOOL samr_io_r_query_dispinfo(const char *desc, SAMR_R_QUERY_DISPINFO * r_u,
1989                               prs_struct *ps, int depth)
1990 {
1991         if (r_u == NULL)
1992                 return False;
1993
1994         prs_debug(ps, depth, desc, "samr_io_r_query_dispinfo");
1995         depth++;
1996
1997         if(!prs_align(ps))
1998                 return False;
1999
2000         if(!prs_uint32("total_size  ", ps, depth, &r_u->total_size))
2001                 return False;
2002         if(!prs_uint32("data_size   ", ps, depth, &r_u->data_size))
2003                 return False;
2004         if(!prs_uint16("switch_level", ps, depth, &r_u->switch_level))
2005                 return False;
2006         if(!prs_align(ps))
2007                 return False;
2008
2009         if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
2010                 return False;
2011         if(!prs_uint32("ptr_entries ", ps, depth, &r_u->ptr_entries))
2012                 return False;
2013
2014         if (r_u->ptr_entries==0) {
2015                 if(!prs_align(ps))
2016                         return False;
2017                 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2018                         return False;
2019
2020                 return True;
2021         }
2022
2023         if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
2024                 return False;
2025
2026         switch (r_u->switch_level) {
2027         case 0x1:
2028                 if(!sam_io_sam_dispinfo_1("users", r_u->ctr->sam.info1,
2029                                 r_u->num_entries, ps, depth))
2030                         return False;
2031                 break;
2032         case 0x2:
2033                 if(!sam_io_sam_dispinfo_2("servers", r_u->ctr->sam.info2,
2034                                 r_u->num_entries, ps, depth))
2035                         return False;
2036                 break;
2037         case 0x3:
2038                 if(!sam_io_sam_dispinfo_3("groups", r_u->ctr->sam.info3,
2039                                     r_u->num_entries, ps, depth))
2040                         return False;
2041                 break;
2042         case 0x4:
2043                 if(!sam_io_sam_dispinfo_4("user list",
2044                                     r_u->ctr->sam.info4,
2045                                     r_u->num_entries, ps, depth))
2046                         return False;
2047                 break;
2048         case 0x5:
2049                 if(!sam_io_sam_dispinfo_5("group list",
2050                                     r_u->ctr->sam.info5,
2051                                     r_u->num_entries, ps, depth))
2052                         return False;
2053                 break;
2054         default:
2055                 DEBUG(0,("samr_io_r_query_dispinfo: unknown switch value\n"));
2056                 break;
2057         }
2058
2059         if(!prs_align(ps))
2060                 return False;
2061         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2062                 return False;
2063
2064         return True;
2065 }
2066
2067 /*******************************************************************
2068 inits a SAMR_Q_OPEN_GROUP structure.
2069 ********************************************************************/
2070
2071 void init_samr_q_open_group(SAMR_Q_OPEN_GROUP * q_c,
2072                             POLICY_HND *hnd,
2073                             uint32 access_mask, uint32 rid)
2074 {
2075         DEBUG(5, ("init_samr_q_open_group\n"));
2076
2077         q_c->domain_pol = *hnd;
2078         q_c->access_mask = access_mask;
2079         q_c->rid_group = rid;
2080 }
2081
2082 /*******************************************************************
2083 reads or writes a structure.
2084 ********************************************************************/
2085
2086 BOOL samr_io_q_open_group(const char *desc, SAMR_Q_OPEN_GROUP * q_u,
2087                           prs_struct *ps, int depth)
2088 {
2089         if (q_u == NULL)
2090                 return False;
2091
2092         prs_debug(ps, depth, desc, "samr_io_q_open_group");
2093         depth++;
2094
2095         if(!prs_align(ps))
2096                 return False;
2097
2098         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
2099                 return False;
2100
2101         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
2102                 return False;
2103         if(!prs_uint32("rid_group", ps, depth, &q_u->rid_group))
2104                 return False;
2105
2106         return True;
2107 }
2108
2109 /*******************************************************************
2110 reads or writes a structure.
2111 ********************************************************************/
2112
2113 BOOL samr_io_r_open_group(const char *desc, SAMR_R_OPEN_GROUP * r_u,
2114                           prs_struct *ps, int depth)
2115 {
2116         if (r_u == NULL)
2117                 return False;
2118
2119         prs_debug(ps, depth, desc, "samr_io_r_open_group");
2120         depth++;
2121
2122         if(!prs_align(ps))
2123                 return False;
2124
2125         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2126                 return False;
2127
2128         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2129                 return False;
2130
2131         return True;
2132 }
2133
2134 /*******************************************************************
2135 inits a GROUP_INFO1 structure.
2136 ********************************************************************/
2137
2138 void init_samr_group_info1(GROUP_INFO1 * gr1,
2139                            char *acct_name, char *acct_desc,
2140                            uint32 num_members)
2141 {
2142         DEBUG(5, ("init_samr_group_info1\n"));
2143
2144         gr1->unknown_1 = 0x3;
2145         gr1->num_members = num_members;
2146
2147         init_unistr2(&gr1->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2148         init_uni_hdr(&gr1->hdr_acct_name, &gr1->uni_acct_name);
2149         init_unistr2(&gr1->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2150         init_uni_hdr(&gr1->hdr_acct_desc, &gr1->uni_acct_desc);
2151 }
2152
2153 /*******************************************************************
2154 reads or writes a structure.
2155 ********************************************************************/
2156
2157 BOOL samr_io_group_info1(const char *desc, GROUP_INFO1 * gr1,
2158                          prs_struct *ps, int depth)
2159 {
2160         uint16 dummy = 1;
2161
2162         if (gr1 == NULL)
2163                 return False;
2164
2165         prs_debug(ps, depth, desc, "samr_io_group_info1");
2166         depth++;
2167
2168         if(!prs_uint16("level", ps, depth, &dummy))
2169                 return False;
2170
2171         if(!prs_align(ps))
2172                 return False;
2173
2174         if(!smb_io_unihdr("hdr_acct_name", &gr1->hdr_acct_name, ps, depth))
2175                 return False;
2176
2177         if(!prs_uint32("unknown_1", ps, depth, &gr1->unknown_1))
2178                 return False;
2179         if(!prs_uint32("num_members", ps, depth, &gr1->num_members))
2180                 return False;
2181
2182         if(!smb_io_unihdr("hdr_acct_desc", &gr1->hdr_acct_desc, ps, depth))
2183                 return False;
2184
2185         if(!smb_io_unistr2("uni_acct_name", &gr1->uni_acct_name,
2186                            gr1->hdr_acct_name.buffer, ps, depth))
2187                 return False;
2188
2189         if(!smb_io_unistr2("uni_acct_desc", &gr1->uni_acct_desc,
2190                            gr1->hdr_acct_desc.buffer, ps, depth))
2191                 return False;
2192
2193         return True;
2194 }
2195
2196 /*******************************************************************
2197 inits a GROUP_INFO2 structure.
2198 ********************************************************************/
2199
2200 void init_samr_group_info2(GROUP_INFO2 * gr2, const char *acct_name)
2201 {
2202         DEBUG(5, ("init_samr_group_info2\n"));
2203
2204         gr2->level = 2;
2205         init_unistr2(&gr2->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2206         init_uni_hdr(&gr2->hdr_acct_name, &gr2->uni_acct_name);
2207 }
2208
2209 /*******************************************************************
2210 reads or writes a structure.
2211 ********************************************************************/
2212
2213 BOOL samr_io_group_info2(const char *desc, GROUP_INFO2 *gr2, prs_struct *ps, int depth)
2214 {
2215         if (gr2 == NULL)
2216                 return False;
2217
2218         prs_debug(ps, depth, desc, "samr_io_group_info2");
2219         depth++;
2220
2221         if(!prs_uint16("hdr_level", ps, depth, &gr2->level))
2222                 return False;
2223
2224         if(!smb_io_unihdr("hdr_acct_name", &gr2->hdr_acct_name, ps, depth))
2225                 return False;
2226         if(!smb_io_unistr2("uni_acct_name", &gr2->uni_acct_name,
2227                            gr2->hdr_acct_name.buffer, ps, depth))
2228                 return False;
2229
2230         return True;
2231 }
2232
2233 /*******************************************************************
2234 inits a GROUP_INFO3 structure.
2235 ********************************************************************/
2236
2237 void init_samr_group_info3(GROUP_INFO3 *gr3)
2238 {
2239         DEBUG(5, ("init_samr_group_info3\n"));
2240
2241         gr3->unknown_1 = 0x3;
2242 }
2243
2244 /*******************************************************************
2245 reads or writes a structure.
2246 ********************************************************************/
2247
2248 BOOL samr_io_group_info3(const char *desc, GROUP_INFO3 *gr3, prs_struct *ps, int depth)
2249 {
2250         if (gr3 == NULL)
2251                 return False;
2252
2253         prs_debug(ps, depth, desc, "samr_io_group_info3");
2254         depth++;
2255
2256         if(!prs_align(ps))
2257                 return False;
2258
2259         if(!prs_uint32("unknown_1", ps, depth, &gr3->unknown_1))
2260                 return False;
2261
2262         return True;
2263 }
2264
2265 /*******************************************************************
2266 inits a GROUP_INFO4 structure.
2267 ********************************************************************/
2268
2269 void init_samr_group_info4(GROUP_INFO4 * gr4, const char *acct_desc)
2270 {
2271         DEBUG(5, ("init_samr_group_info4\n"));
2272
2273         gr4->level = 4;
2274         init_unistr2(&gr4->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2275         init_uni_hdr(&gr4->hdr_acct_desc, &gr4->uni_acct_desc);
2276 }
2277
2278 /*******************************************************************
2279 reads or writes a structure.
2280 ********************************************************************/
2281
2282 BOOL samr_io_group_info4(const char *desc, GROUP_INFO4 * gr4,
2283                          prs_struct *ps, int depth)
2284 {
2285         if (gr4 == NULL)
2286                 return False;
2287
2288         prs_debug(ps, depth, desc, "samr_io_group_info4");
2289         depth++;
2290
2291         if(!prs_uint16("hdr_level", ps, depth, &gr4->level))
2292                 return False;
2293         if(!smb_io_unihdr("hdr_acct_desc", &gr4->hdr_acct_desc, ps, depth))
2294                 return False;
2295         if(!smb_io_unistr2("uni_acct_desc", &gr4->uni_acct_desc,
2296                            gr4->hdr_acct_desc.buffer, ps, depth))
2297                 return False;
2298
2299         return True;
2300 }
2301
2302 /*******************************************************************
2303 reads or writes a structure.
2304 ********************************************************************/
2305
2306 static BOOL samr_group_info_ctr(const char *desc, GROUP_INFO_CTR **ctr,
2307                                 prs_struct *ps, int depth)
2308 {
2309         if (UNMARSHALLING(ps))
2310                 *ctr = PRS_ALLOC_MEM(ps,GROUP_INFO_CTR,1);
2311
2312         if (*ctr == NULL)
2313                 return False;
2314
2315         prs_debug(ps, depth, desc, "samr_group_info_ctr");
2316         depth++;
2317
2318         if(!prs_uint16("switch_value1", ps, depth, &(*ctr)->switch_value1))
2319                 return False;
2320
2321         switch ((*ctr)->switch_value1) {
2322         case 1:
2323                 if(!samr_io_group_info1("group_info1", &(*ctr)->group.info1, ps, depth))
2324                         return False;
2325                 break;
2326         case 2:
2327                 if(!samr_io_group_info2("group_info2", &(*ctr)->group.info2, ps, depth))
2328                         return False;
2329                 break;
2330         case 3:
2331                 if(!samr_io_group_info3("group_info3", &(*ctr)->group.info3, ps, depth))
2332                         return False;
2333                 break;
2334         case 4:
2335                 if(!samr_io_group_info4("group_info4", &(*ctr)->group.info4, ps, depth))
2336                         return False;
2337                 break;
2338         default:
2339                 DEBUG(0,("samr_group_info_ctr: unsupported switch level\n"));
2340                 break;
2341         }
2342
2343         return True;
2344 }
2345
2346 /*******************************************************************
2347 inits a SAMR_Q_CREATE_DOM_GROUP structure.
2348 ********************************************************************/
2349
2350 void init_samr_q_create_dom_group(SAMR_Q_CREATE_DOM_GROUP * q_e,
2351                                   POLICY_HND *pol, const char *acct_desc,
2352                                   uint32 access_mask)
2353 {
2354         DEBUG(5, ("init_samr_q_create_dom_group\n"));
2355
2356         q_e->pol = *pol;
2357
2358         init_unistr2(&q_e->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2359         init_uni_hdr(&q_e->hdr_acct_desc, &q_e->uni_acct_desc);
2360
2361         q_e->access_mask = access_mask;
2362 }
2363
2364 /*******************************************************************
2365 reads or writes a structure.
2366 ********************************************************************/
2367
2368 BOOL samr_io_q_create_dom_group(const char *desc, SAMR_Q_CREATE_DOM_GROUP * q_e,
2369                                 prs_struct *ps, int depth)
2370 {
2371         if (q_e == NULL)
2372                 return False;
2373
2374         prs_debug(ps, depth, desc, "samr_io_q_create_dom_group");
2375         depth++;
2376
2377         if(!prs_align(ps))
2378                 return False;
2379
2380         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2381                 return False;
2382
2383         if(!smb_io_unihdr("hdr_acct_desc", &q_e->hdr_acct_desc, ps, depth))
2384                 return False;
2385         if(!smb_io_unistr2("uni_acct_desc", &q_e->uni_acct_desc,
2386                        q_e->hdr_acct_desc.buffer, ps, depth))
2387                 return False;
2388
2389         if(!prs_align(ps))
2390                 return False;
2391         if(!prs_uint32("access", ps, depth, &q_e->access_mask))
2392                 return False;
2393
2394         return True;
2395 }
2396
2397 /*******************************************************************
2398 reads or writes a structure.
2399 ********************************************************************/
2400
2401 BOOL samr_io_r_create_dom_group(const char *desc, SAMR_R_CREATE_DOM_GROUP * r_u,
2402                                 prs_struct *ps, int depth)
2403 {
2404         if (r_u == NULL)
2405                 return False;
2406
2407         prs_debug(ps, depth, desc, "samr_io_r_create_dom_group");
2408         depth++;
2409
2410         if(!prs_align(ps))
2411                 return False;
2412
2413         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2414                 return False;
2415
2416         if(!prs_uint32("rid   ", ps, depth, &r_u->rid))
2417                 return False;
2418         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2419                 return False;
2420
2421         return True;
2422 }
2423
2424 /*******************************************************************
2425 inits a SAMR_Q_DELETE_DOM_GROUP structure.
2426 ********************************************************************/
2427
2428 void init_samr_q_delete_dom_group(SAMR_Q_DELETE_DOM_GROUP * q_c,
2429                                   POLICY_HND *hnd)
2430 {
2431         DEBUG(5, ("init_samr_q_delete_dom_group\n"));
2432
2433         q_c->group_pol = *hnd;
2434 }
2435
2436 /*******************************************************************
2437 reads or writes a structure.
2438 ********************************************************************/
2439
2440 BOOL samr_io_q_delete_dom_group(const char *desc, SAMR_Q_DELETE_DOM_GROUP * q_u,
2441                                 prs_struct *ps, int depth)
2442 {
2443         if (q_u == NULL)
2444                 return False;
2445
2446         prs_debug(ps, depth, desc, "samr_io_q_delete_dom_group");
2447         depth++;
2448
2449         if(!prs_align(ps))
2450                 return False;
2451
2452         if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
2453                 return False;
2454
2455         return True;
2456 }
2457
2458 /*******************************************************************
2459 reads or writes a structure.
2460 ********************************************************************/
2461
2462 BOOL samr_io_r_delete_dom_group(const char *desc, SAMR_R_DELETE_DOM_GROUP * r_u,
2463                                 prs_struct *ps, int depth)
2464 {
2465         if (r_u == NULL)
2466                 return False;
2467
2468         prs_debug(ps, depth, desc, "samr_io_r_delete_dom_group");
2469         depth++;
2470
2471         if(!prs_align(ps))
2472                 return False;
2473
2474         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2475                 return False;
2476
2477         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2478                 return False;
2479
2480         return True;
2481 }
2482
2483 /*******************************************************************
2484 inits a SAMR_Q_DEL_GROUPMEM structure.
2485 ********************************************************************/
2486
2487 void init_samr_q_del_groupmem(SAMR_Q_DEL_GROUPMEM * q_e,
2488                               POLICY_HND *pol, uint32 rid)
2489 {
2490         DEBUG(5, ("init_samr_q_del_groupmem\n"));
2491
2492         q_e->pol = *pol;
2493         q_e->rid = rid;
2494 }
2495
2496 /*******************************************************************
2497 reads or writes a structure.
2498 ********************************************************************/
2499
2500 BOOL samr_io_q_del_groupmem(const char *desc, SAMR_Q_DEL_GROUPMEM * q_e,
2501                             prs_struct *ps, int depth)
2502 {
2503         if (q_e == NULL)
2504                 return False;
2505
2506         prs_debug(ps, depth, desc, "samr_io_q_del_groupmem");
2507         depth++;
2508
2509         if(!prs_align(ps))
2510                 return False;
2511
2512         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2513                 return False;
2514
2515         if(!prs_uint32("rid", ps, depth, &q_e->rid))
2516                 return False;
2517
2518         return True;
2519 }
2520
2521 /*******************************************************************
2522 inits a SAMR_R_DEL_GROUPMEM structure.
2523 ********************************************************************/
2524
2525 void init_samr_r_del_groupmem(SAMR_R_DEL_GROUPMEM * r_u, POLICY_HND *pol,
2526                               NTSTATUS status)
2527 {
2528         DEBUG(5, ("init_samr_r_del_groupmem\n"));
2529
2530         r_u->status = status;
2531 }
2532
2533 /*******************************************************************
2534 reads or writes a structure.
2535 ********************************************************************/
2536
2537 BOOL samr_io_r_del_groupmem(const char *desc, SAMR_R_DEL_GROUPMEM * r_u,
2538                             prs_struct *ps, int depth)
2539 {
2540         if (r_u == NULL)
2541                 return False;
2542
2543         prs_debug(ps, depth, desc, "samr_io_r_del_groupmem");
2544         depth++;
2545
2546         if(!prs_align(ps))
2547                 return False;
2548
2549         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2550                 return False;
2551
2552         return True;
2553 }
2554
2555 /*******************************************************************
2556 inits a SAMR_Q_ADD_GROUPMEM structure.
2557 ********************************************************************/
2558
2559 void init_samr_q_add_groupmem(SAMR_Q_ADD_GROUPMEM * q_e,
2560                               POLICY_HND *pol, uint32 rid)
2561 {
2562         DEBUG(5, ("init_samr_q_add_groupmem\n"));
2563
2564         q_e->pol = *pol;
2565         q_e->rid = rid;
2566         q_e->unknown = 0x0005;
2567 }
2568
2569 /*******************************************************************
2570 reads or writes a structure.
2571 ********************************************************************/
2572
2573 BOOL samr_io_q_add_groupmem(const char *desc, SAMR_Q_ADD_GROUPMEM * q_e,
2574                             prs_struct *ps, int depth)
2575 {
2576         if (q_e == NULL)
2577                 return False;
2578
2579         prs_debug(ps, depth, desc, "samr_io_q_add_groupmem");
2580         depth++;
2581
2582         if(!prs_align(ps))
2583                 return False;
2584
2585         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2586                 return False;
2587
2588         if(!prs_uint32("rid    ", ps, depth, &q_e->rid))
2589                 return False;
2590         if(!prs_uint32("unknown", ps, depth, &q_e->unknown))
2591                 return False;
2592
2593         return True;
2594 }
2595
2596 /*******************************************************************
2597 inits a SAMR_R_ADD_GROUPMEM structure.
2598 ********************************************************************/
2599
2600 void init_samr_r_add_groupmem(SAMR_R_ADD_GROUPMEM * r_u, POLICY_HND *pol,
2601                               NTSTATUS status)
2602 {
2603         DEBUG(5, ("init_samr_r_add_groupmem\n"));
2604
2605         r_u->status = status;
2606 }
2607
2608 /*******************************************************************
2609 reads or writes a structure.
2610 ********************************************************************/
2611
2612 BOOL samr_io_r_add_groupmem(const char *desc, SAMR_R_ADD_GROUPMEM * r_u,
2613                             prs_struct *ps, int depth)
2614 {
2615         if (r_u == NULL)
2616                 return False;
2617
2618         prs_debug(ps, depth, desc, "samr_io_r_add_groupmem");
2619         depth++;
2620
2621         if(!prs_align(ps))
2622                 return False;
2623
2624         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2625                 return False;
2626
2627         return True;
2628 }
2629
2630 /*******************************************************************
2631 inits a SAMR_Q_SET_GROUPINFO structure.
2632 ********************************************************************/
2633
2634 void init_samr_q_set_groupinfo(SAMR_Q_SET_GROUPINFO * q_e,
2635                                POLICY_HND *pol, GROUP_INFO_CTR * ctr)
2636 {
2637         DEBUG(5, ("init_samr_q_set_groupinfo\n"));
2638
2639         q_e->pol = *pol;
2640         q_e->ctr = ctr;
2641 }
2642
2643 /*******************************************************************
2644 reads or writes a structure.
2645 ********************************************************************/
2646
2647 BOOL samr_io_q_set_groupinfo(const char *desc, SAMR_Q_SET_GROUPINFO * q_e,
2648                              prs_struct *ps, int depth)
2649 {
2650         if (q_e == NULL)
2651                 return False;
2652
2653         prs_debug(ps, depth, desc, "samr_io_q_set_groupinfo");
2654         depth++;
2655
2656         if(!prs_align(ps))
2657                 return False;
2658
2659         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2660                 return False;
2661
2662         if(!samr_group_info_ctr("ctr", &q_e->ctr, ps, depth))
2663                 return False;
2664
2665         return True;
2666 }
2667
2668 /*******************************************************************
2669 inits a SAMR_R_SET_GROUPINFO structure.
2670 ********************************************************************/
2671
2672 void init_samr_r_set_groupinfo(SAMR_R_SET_GROUPINFO * r_u, NTSTATUS status)
2673 {
2674         DEBUG(5, ("init_samr_r_set_groupinfo\n"));
2675
2676         r_u->status = status;
2677 }
2678
2679 /*******************************************************************
2680 reads or writes a structure.
2681 ********************************************************************/
2682
2683 BOOL samr_io_r_set_groupinfo(const char *desc, SAMR_R_SET_GROUPINFO * r_u,
2684                              prs_struct *ps, int depth)
2685 {
2686         if (r_u == NULL)
2687                 return False;
2688
2689         prs_debug(ps, depth, desc, "samr_io_r_set_groupinfo");
2690         depth++;
2691
2692         if(!prs_align(ps))
2693                 return False;
2694
2695         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2696                 return False;
2697
2698         return True;
2699 }
2700
2701 /*******************************************************************
2702 inits a SAMR_Q_QUERY_GROUPINFO structure.
2703 ********************************************************************/
2704
2705 void init_samr_q_query_groupinfo(SAMR_Q_QUERY_GROUPINFO * q_e,
2706                                  POLICY_HND *pol, uint16 switch_level)
2707 {
2708         DEBUG(5, ("init_samr_q_query_groupinfo\n"));
2709
2710         q_e->pol = *pol;
2711
2712         q_e->switch_level = switch_level;
2713 }
2714
2715 /*******************************************************************
2716 reads or writes a structure.
2717 ********************************************************************/
2718
2719 BOOL samr_io_q_query_groupinfo(const char *desc, SAMR_Q_QUERY_GROUPINFO * q_e,
2720                                prs_struct *ps, int depth)
2721 {
2722         if (q_e == NULL)
2723                 return False;
2724
2725         prs_debug(ps, depth, desc, "samr_io_q_query_groupinfo");
2726         depth++;
2727
2728         if(!prs_align(ps))
2729                 return False;
2730
2731         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2732                 return False;
2733
2734         if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
2735                 return False;
2736
2737         return True;
2738 }
2739
2740 /*******************************************************************
2741 inits a SAMR_R_QUERY_GROUPINFO structure.
2742 ********************************************************************/
2743
2744 void init_samr_r_query_groupinfo(SAMR_R_QUERY_GROUPINFO * r_u,
2745                                  GROUP_INFO_CTR * ctr, NTSTATUS status)
2746 {
2747         DEBUG(5, ("init_samr_r_query_groupinfo\n"));
2748
2749         r_u->ptr = (NT_STATUS_IS_OK(status) && ctr != NULL) ? 1 : 0;
2750         r_u->ctr = ctr;
2751         r_u->status = status;
2752 }
2753
2754 /*******************************************************************
2755 reads or writes a structure.
2756 ********************************************************************/
2757
2758 BOOL samr_io_r_query_groupinfo(const char *desc, SAMR_R_QUERY_GROUPINFO * r_u,
2759                                prs_struct *ps, int depth)
2760 {
2761         if (r_u == NULL)
2762                 return False;
2763
2764         prs_debug(ps, depth, desc, "samr_io_r_query_groupinfo");
2765         depth++;
2766
2767         if(!prs_align(ps))
2768                 return False;
2769
2770         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
2771                 return False;
2772
2773         if (r_u->ptr != 0) {
2774                 if(!samr_group_info_ctr("ctr", &r_u->ctr, ps, depth))
2775                         return False;
2776         }
2777
2778         if(!prs_align(ps))
2779                 return False;
2780         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2781                 return False;
2782
2783         return True;
2784 }
2785
2786 /*******************************************************************
2787 inits a SAMR_Q_QUERY_GROUPMEM structure.
2788 ********************************************************************/
2789
2790 void init_samr_q_query_groupmem(SAMR_Q_QUERY_GROUPMEM * q_c, POLICY_HND *hnd)
2791 {
2792         DEBUG(5, ("init_samr_q_query_groupmem\n"));
2793
2794         q_c->group_pol = *hnd;
2795 }
2796
2797 /*******************************************************************
2798 reads or writes a structure.
2799 ********************************************************************/
2800
2801 BOOL samr_io_q_query_groupmem(const char *desc, SAMR_Q_QUERY_GROUPMEM * q_u,
2802                               prs_struct *ps, int depth)
2803 {
2804         if (q_u == NULL)
2805                 return False;
2806
2807         prs_debug(ps, depth, desc, "samr_io_q_query_groupmem");
2808         depth++;
2809
2810         if(!prs_align(ps))
2811                 return False;
2812
2813         if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
2814                 return False;
2815
2816         return True;
2817 }
2818
2819 /*******************************************************************
2820 inits a SAMR_R_QUERY_GROUPMEM structure.
2821 ********************************************************************/
2822
2823 void init_samr_r_query_groupmem(SAMR_R_QUERY_GROUPMEM * r_u,
2824                                 uint32 num_entries, uint32 *rid,
2825                                 uint32 *attr, NTSTATUS status)
2826 {
2827         DEBUG(5, ("init_samr_r_query_groupmem\n"));
2828
2829         if (NT_STATUS_IS_OK(status)) {
2830                 r_u->ptr = 1;
2831                 r_u->num_entries = num_entries;
2832
2833                 r_u->ptr_attrs = attr != NULL ? 1 : 0;
2834                 r_u->ptr_rids = rid != NULL ? 1 : 0;
2835
2836                 r_u->num_rids = num_entries;
2837                 r_u->rid = rid;
2838
2839                 r_u->num_attrs = num_entries;
2840                 r_u->attr = attr;
2841         } else {
2842                 r_u->ptr = 0;
2843                 r_u->num_entries = 0;
2844         }
2845
2846         r_u->status = status;
2847 }
2848
2849 /*******************************************************************
2850 reads or writes a structure.
2851 ********************************************************************/
2852
2853 BOOL samr_io_r_query_groupmem(const char *desc, SAMR_R_QUERY_GROUPMEM * r_u,
2854                               prs_struct *ps, int depth)
2855 {
2856         uint32 i;
2857
2858         if (r_u == NULL)
2859                 return False;
2860
2861         if (UNMARSHALLING(ps))
2862                 ZERO_STRUCTP(r_u);
2863
2864         prs_debug(ps, depth, desc, "samr_io_r_query_groupmem");
2865         depth++;
2866
2867         if(!prs_align(ps))
2868                 return False;
2869
2870         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
2871                 return False;
2872         if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
2873                 return False;
2874
2875         if (r_u->ptr != 0) {
2876                 if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
2877                         return False;
2878                 if(!prs_uint32("ptr_attrs", ps, depth, &r_u->ptr_attrs))
2879                         return False;
2880
2881                 if (r_u->ptr_rids != 0) {
2882                         if(!prs_uint32("num_rids", ps, depth, &r_u->num_rids))
2883                                 return False;
2884                         if (UNMARSHALLING(ps) && r_u->num_rids != 0) {
2885                                 r_u->rid = PRS_ALLOC_MEM(ps,uint32,r_u->num_rids);
2886                                 if (r_u->rid == NULL)
2887                                         return False;
2888                         }
2889
2890                         for (i = 0; i < r_u->num_rids; i++) {
2891                                 if(!prs_uint32("", ps, depth, &r_u->rid[i]))
2892                                         return False;
2893                         }
2894                 }
2895
2896                 if (r_u->ptr_attrs != 0) {
2897                         if(!prs_uint32("num_attrs", ps, depth, &r_u->num_attrs))
2898                                 return False;
2899
2900                         if (UNMARSHALLING(ps) && r_u->num_attrs != 0) {
2901                                 r_u->attr = PRS_ALLOC_MEM(ps,uint32,r_u->num_attrs);
2902                                 if (r_u->attr == NULL)
2903                                         return False;
2904                         }
2905
2906                         for (i = 0; i < r_u->num_attrs; i++) {
2907                                 if(!prs_uint32("", ps, depth, &r_u->attr[i]))
2908                                         return False;
2909                         }
2910                 }
2911         }
2912
2913         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2914                 return False;
2915
2916         return True;
2917 }
2918
2919 /*******************************************************************
2920 inits a SAMR_Q_QUERY_USERGROUPS structure.
2921 ********************************************************************/
2922
2923 void init_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS * q_u,
2924                                   POLICY_HND *hnd)
2925 {
2926         DEBUG(5, ("init_samr_q_query_usergroups\n"));
2927
2928         q_u->pol = *hnd;
2929 }
2930
2931 /*******************************************************************
2932 reads or writes a structure.
2933 ********************************************************************/
2934
2935 BOOL samr_io_q_query_usergroups(const char *desc, SAMR_Q_QUERY_USERGROUPS * q_u,
2936                                 prs_struct *ps, int depth)
2937 {
2938         if (q_u == NULL)
2939                 return False;
2940
2941         prs_debug(ps, depth, desc, "samr_io_q_query_usergroups");
2942         depth++;
2943
2944         if(!prs_align(ps))
2945                 return False;
2946
2947         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
2948                 return False;
2949
2950         return True;
2951 }
2952
2953 /*******************************************************************
2954 inits a SAMR_R_QUERY_USERGROUPS structure.
2955 ********************************************************************/
2956
2957 void init_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS * r_u,
2958                                   uint32 num_gids, DOM_GID * gid,
2959                                   NTSTATUS status)
2960 {
2961         DEBUG(5, ("init_samr_r_query_usergroups\n"));
2962
2963         if (NT_STATUS_IS_OK(status)) {
2964                 r_u->ptr_0 = 1;
2965                 r_u->num_entries = num_gids;
2966                 r_u->ptr_1 = (num_gids != 0) ? 1 : 0;
2967                 r_u->num_entries2 = num_gids;
2968
2969                 r_u->gid = gid;
2970         } else {
2971                 r_u->ptr_0 = 0;
2972                 r_u->num_entries = 0;
2973                 r_u->ptr_1 = 0;
2974                 r_u->gid = NULL;
2975         }
2976
2977         r_u->status = status;
2978 }
2979
2980 /*******************************************************************
2981 reads or writes a structure.
2982 ********************************************************************/
2983
2984 BOOL samr_io_gids(const char *desc, uint32 *num_gids, DOM_GID ** gid,
2985                   prs_struct *ps, int depth)
2986 {
2987         uint32 i;
2988         if (gid == NULL)
2989                 return False;
2990
2991         prs_debug(ps, depth, desc, "samr_io_gids");
2992         depth++;
2993
2994         if(!prs_align(ps))
2995                 return False;
2996
2997         if(!prs_uint32("num_gids", ps, depth, num_gids))
2998                 return False;
2999
3000         if ((*num_gids) != 0) {
3001                 if (UNMARSHALLING(ps)) {
3002                         (*gid) = PRS_ALLOC_MEM(ps,DOM_GID,*num_gids);
3003                 }
3004
3005                 if ((*gid) == NULL) {
3006                         return False;
3007                 }
3008
3009                 for (i = 0; i < (*num_gids); i++) {
3010                         if(!smb_io_gid("gids", &(*gid)[i], ps, depth))
3011                                 return False;
3012                 }
3013         }
3014
3015         return True;
3016 }
3017
3018 /*******************************************************************
3019 reads or writes a structure.
3020 ********************************************************************/
3021
3022 BOOL samr_io_r_query_usergroups(const char *desc, SAMR_R_QUERY_USERGROUPS * r_u,
3023                                 prs_struct *ps, int depth)
3024 {
3025         if (r_u == NULL)
3026                 return False;
3027
3028         prs_debug(ps, depth, desc, "samr_io_r_query_usergroups");
3029         depth++;
3030
3031         if(!prs_align(ps))
3032                 return False;
3033
3034         if(!prs_uint32("ptr_0       ", ps, depth, &r_u->ptr_0))
3035                 return False;
3036
3037         if (r_u->ptr_0 != 0) {
3038                 if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
3039                         return False;
3040                 if(!prs_uint32("ptr_1       ", ps, depth, &r_u->ptr_1))
3041                         return False;
3042
3043                 if (r_u->num_entries != 0 && r_u->ptr_1 != 0) {
3044                         if(!samr_io_gids("gids", &r_u->num_entries2, &r_u->gid, ps, depth))
3045                                 return False;
3046                 }
3047         }
3048
3049         if(!prs_align(ps))
3050                 return False;
3051         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3052           return False;
3053
3054         return True;
3055 }
3056
3057 /*******************************************************************
3058 inits a SAMR_Q_ENUM_DOMAINS structure.
3059 ********************************************************************/
3060
3061 void init_samr_q_enum_domains(SAMR_Q_ENUM_DOMAINS * q_e,
3062                               POLICY_HND *pol,
3063                               uint32 start_idx, uint32 size)
3064 {
3065         DEBUG(5, ("init_samr_q_enum_domains\n"));
3066
3067         q_e->pol = *pol;
3068
3069         q_e->start_idx = start_idx;
3070         q_e->max_size = size;
3071 }
3072
3073 /*******************************************************************
3074 reads or writes a structure.
3075 ********************************************************************/
3076
3077 BOOL samr_io_q_enum_domains(const char *desc, SAMR_Q_ENUM_DOMAINS * q_e,
3078                             prs_struct *ps, int depth)
3079 {
3080         if (q_e == NULL)
3081                 return False;
3082
3083         prs_debug(ps, depth, desc, "samr_io_q_enum_domains");
3084         depth++;
3085
3086         if(!prs_align(ps))
3087                 return False;
3088
3089         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3090                 return False;
3091
3092         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3093                 return False;
3094         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3095                 return False;
3096
3097         return True;
3098 }
3099
3100 /*******************************************************************
3101 inits a SAMR_R_ENUM_DOMAINS structure.
3102 ********************************************************************/
3103
3104 void init_samr_r_enum_domains(SAMR_R_ENUM_DOMAINS * r_u,
3105                               uint32 next_idx, uint32 num_sam_entries)
3106 {
3107         DEBUG(5, ("init_samr_r_enum_domains\n"));
3108
3109         r_u->next_idx = next_idx;
3110
3111         if (num_sam_entries != 0) {
3112                 r_u->ptr_entries1 = 1;
3113                 r_u->ptr_entries2 = 1;
3114                 r_u->num_entries2 = num_sam_entries;
3115                 r_u->num_entries3 = num_sam_entries;
3116
3117                 r_u->num_entries4 = num_sam_entries;
3118         } else {
3119                 r_u->ptr_entries1 = 0;
3120                 r_u->num_entries2 = num_sam_entries;
3121                 r_u->ptr_entries2 = 1;
3122         }
3123 }
3124
3125 /*******************************************************************
3126 reads or writes a structure.
3127 ********************************************************************/
3128
3129 BOOL samr_io_r_enum_domains(const char *desc, SAMR_R_ENUM_DOMAINS * r_u,
3130                             prs_struct *ps, int depth)
3131 {
3132         uint32 i;
3133
3134         if (r_u == NULL)
3135                 return False;
3136
3137         prs_debug(ps, depth, desc, "samr_io_r_enum_domains");
3138         depth++;
3139
3140         if(!prs_align(ps))
3141                 return False;
3142
3143         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
3144                 return False;
3145         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3146                 return False;
3147
3148         if (r_u->ptr_entries1 != 0) {
3149                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3150                         return False;
3151                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3152                         return False;
3153                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3154                         return False;
3155
3156                 if (UNMARSHALLING(ps)) {
3157                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3158                         r_u->uni_dom_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3159                 }
3160
3161                 if ((r_u->sam == NULL || r_u->uni_dom_name == NULL) && r_u->num_entries2 != 0) {
3162                         DEBUG(0, ("NULL pointers in SAMR_R_ENUM_DOMAINS\n"));
3163                         r_u->num_entries4 = 0;
3164                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3165                         return False;
3166                 }
3167
3168                 for (i = 0; i < r_u->num_entries2; i++) {
3169                         fstring tmp;
3170                         slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3171                         if(!sam_io_sam_entry(tmp, &r_u->sam[i], ps, depth))
3172                                 return False;
3173                 }
3174
3175                 for (i = 0; i < r_u->num_entries2; i++) {
3176                         fstring tmp;
3177                         slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3178                         if(!smb_io_unistr2(tmp, &r_u->uni_dom_name[i],
3179                                        r_u->sam[i].hdr_name.buffer, ps,
3180                                        depth))
3181                                 return False;
3182                 }
3183
3184         }
3185
3186         if(!prs_align(ps))
3187                 return False;
3188         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3189                 return False;
3190         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3191                 return False;
3192
3193         return True;
3194 }
3195
3196 /*******************************************************************
3197 inits a SAMR_Q_ENUM_DOM_GROUPS structure.
3198 ********************************************************************/
3199
3200 void init_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS * q_e,
3201                                  POLICY_HND *pol,
3202                                  uint32 start_idx, uint32 size)
3203 {
3204         DEBUG(5, ("init_samr_q_enum_dom_groups\n"));
3205
3206         q_e->pol = *pol;
3207
3208         q_e->start_idx = start_idx;
3209         q_e->max_size = size;
3210 }
3211
3212 /*******************************************************************
3213 reads or writes a structure.
3214 ********************************************************************/
3215
3216 BOOL samr_io_q_enum_dom_groups(const char *desc, SAMR_Q_ENUM_DOM_GROUPS * q_e,
3217                                prs_struct *ps, int depth)
3218 {
3219         if (q_e == NULL)
3220                 return False;
3221
3222         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_groups");
3223         depth++;
3224
3225         if(!prs_align(ps))
3226                 return False;
3227
3228         if(!smb_io_pol_hnd("pol", &(q_e->pol), ps, depth))
3229                 return False;
3230
3231         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3232                 return False;
3233         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3234                 return False;
3235
3236         return True;
3237 }
3238
3239 /*******************************************************************
3240 inits a SAMR_R_ENUM_DOM_GROUPS structure.
3241 ********************************************************************/
3242
3243 void init_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS * r_u,
3244                                  uint32 next_idx, uint32 num_sam_entries)
3245 {
3246         DEBUG(5, ("init_samr_r_enum_dom_groups\n"));
3247
3248         r_u->next_idx = next_idx;
3249
3250         if (num_sam_entries != 0) {
3251                 r_u->ptr_entries1 = 1;
3252                 r_u->ptr_entries2 = 1;
3253                 r_u->num_entries2 = num_sam_entries;
3254                 r_u->num_entries3 = num_sam_entries;
3255
3256                 r_u->num_entries4 = num_sam_entries;
3257         } else {
3258                 r_u->ptr_entries1 = 0;
3259                 r_u->num_entries2 = num_sam_entries;
3260                 r_u->ptr_entries2 = 1;
3261         }
3262 }
3263
3264 /*******************************************************************
3265 reads or writes a structure.
3266 ********************************************************************/
3267
3268 BOOL samr_io_r_enum_dom_groups(const char *desc, SAMR_R_ENUM_DOM_GROUPS * r_u,
3269                                prs_struct *ps, int depth)
3270 {
3271         uint32 i;
3272
3273         if (r_u == NULL)
3274                 return False;
3275
3276         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_groups");
3277         depth++;
3278
3279         if(!prs_align(ps))
3280                 return False;
3281
3282         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
3283                 return False;
3284         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3285                 return False;
3286
3287         if (r_u->ptr_entries1 != 0) {
3288                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3289                         return False;
3290                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3291                         return False;
3292                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3293                         return False;
3294
3295                 if (UNMARSHALLING(ps)) {
3296                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3297                         r_u->uni_grp_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3298                 }
3299
3300                 if ((r_u->sam == NULL || r_u->uni_grp_name == NULL) && r_u->num_entries2 != 0) {
3301                         DEBUG(0,
3302                               ("NULL pointers in SAMR_R_ENUM_DOM_GROUPS\n"));
3303                         r_u->num_entries4 = 0;
3304                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3305                         return False;
3306                 }
3307
3308                 for (i = 0; i < r_u->num_entries2; i++) {
3309                         if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
3310                                 return False;
3311                 }
3312
3313                 for (i = 0; i < r_u->num_entries2; i++) {
3314                         if(!smb_io_unistr2("", &r_u->uni_grp_name[i],
3315                                        r_u->sam[i].hdr_name.buffer, ps, depth))
3316                                 return False;
3317                 }
3318         }
3319
3320         if(!prs_align(ps))
3321                 return False;
3322         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3323                 return False;
3324         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3325                 return False;
3326
3327         return True;
3328 }
3329
3330 /*******************************************************************
3331 inits a SAMR_Q_ENUM_DOM_ALIASES structure.
3332 ********************************************************************/
3333
3334 void init_samr_q_enum_dom_aliases(SAMR_Q_ENUM_DOM_ALIASES * q_e,
3335                                   POLICY_HND *pol, uint32 start_idx,
3336                                   uint32 size)
3337 {
3338         DEBUG(5, ("init_samr_q_enum_dom_aliases\n"));
3339
3340         q_e->pol = *pol;
3341
3342         q_e->start_idx = start_idx;
3343         q_e->max_size = size;
3344 }
3345
3346
3347 /*******************************************************************
3348 reads or writes a structure.
3349 ********************************************************************/
3350
3351 BOOL samr_io_q_enum_dom_aliases(const char *desc, SAMR_Q_ENUM_DOM_ALIASES * q_e,
3352                                 prs_struct *ps, int depth)
3353 {
3354         if (q_e == NULL)
3355                 return False;
3356
3357         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_aliases");
3358         depth++;
3359
3360         if(!prs_align(ps))
3361                 return False;
3362
3363         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3364                 return False;
3365
3366         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3367                 return False;
3368         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3369                 return False;
3370
3371         return True;
3372 }
3373
3374 /*******************************************************************
3375 inits a SAMR_R_ENUM_DOM_ALIASES structure.
3376 ********************************************************************/
3377
3378 void init_samr_r_enum_dom_aliases(SAMR_R_ENUM_DOM_ALIASES *r_u, uint32 next_idx, uint32 num_sam_entries)
3379 {
3380         DEBUG(5, ("init_samr_r_enum_dom_aliases\n"));
3381
3382         r_u->next_idx = next_idx;
3383
3384         if (num_sam_entries != 0) {
3385                 r_u->ptr_entries1 = 1;
3386                 r_u->ptr_entries2 = 1;
3387                 r_u->num_entries2 = num_sam_entries;
3388                 r_u->num_entries3 = num_sam_entries;
3389
3390                 r_u->num_entries4 = num_sam_entries;
3391         } else {
3392                 r_u->ptr_entries1 = 0;
3393                 r_u->num_entries2 = num_sam_entries;
3394                 r_u->ptr_entries2 = 1;
3395         }
3396 }
3397
3398 /*******************************************************************
3399 reads or writes a structure.
3400 ********************************************************************/
3401
3402 BOOL samr_io_r_enum_dom_aliases(const char *desc, SAMR_R_ENUM_DOM_ALIASES * r_u,
3403                                 prs_struct *ps, int depth)
3404 {
3405         uint32 i;
3406
3407         if (r_u == NULL)
3408                 return False;
3409
3410         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_aliases");
3411         depth++;
3412
3413         if(!prs_align(ps))
3414                 return False;
3415
3416         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
3417                 return False;
3418         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3419                 return False;
3420
3421         if (r_u->ptr_entries1 != 0) {
3422                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3423                         return False;
3424                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3425                         return False;
3426                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3427                         return False;
3428
3429                 if (UNMARSHALLING(ps) && (r_u->num_entries2 > 0)) {
3430                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3431                         r_u->uni_grp_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3432                 }
3433
3434                 if (r_u->num_entries2 != 0 &&
3435                     (r_u->sam == NULL || r_u->uni_grp_name == NULL)) {
3436                         DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_ALIASES\n"));
3437                         r_u->num_entries4 = 0;
3438                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3439                         return False;
3440                 }
3441
3442                 for (i = 0; i < r_u->num_entries2; i++) {
3443                         if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
3444                                 return False;
3445                 }
3446
3447                 for (i = 0; i < r_u->num_entries2; i++) {
3448                         if(!smb_io_unistr2("", &r_u->uni_grp_name[i],
3449                                        r_u->sam[i].hdr_name.buffer, ps,
3450                                        depth))
3451                                 return False;
3452                 }
3453         }
3454
3455         if(!prs_align(ps))
3456                 return False;
3457         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3458                 return False;
3459         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3460                 return False;
3461
3462         return True;
3463 }
3464
3465 /*******************************************************************
3466 inits a ALIAS_INFO1 structure.
3467 ********************************************************************/
3468
3469 void init_samr_alias_info1(ALIAS_INFO1 * al1, char *acct_name, uint32 num_member, char *acct_desc)
3470 {
3471         DEBUG(5, ("init_samr_alias_info1\n"));
3472
3473         init_unistr4(&al1->name, acct_name, UNI_FLAGS_NONE);
3474         al1->num_member = num_member;
3475         init_unistr4(&al1->description, acct_desc, UNI_FLAGS_NONE);
3476 }
3477
3478 /*******************************************************************
3479 reads or writes a structure.
3480 ********************************************************************/
3481
3482 BOOL samr_io_alias_info1(const char *desc, ALIAS_INFO1 * al1,
3483                          prs_struct *ps, int depth)
3484 {
3485         if (al1 == NULL)
3486                 return False;
3487
3488         prs_debug(ps, depth, desc, "samr_io_alias_info1");
3489         depth++;
3490
3491         if(!prs_align(ps))
3492                 return False;
3493
3494         if ( !prs_unistr4_hdr("name", ps, depth, &al1->name) )
3495                 return False;
3496         if ( !prs_uint32("num_member", ps, depth, &al1->num_member) )
3497                 return False;
3498         if ( !prs_unistr4_hdr("description", ps, depth, &al1->description) )
3499                 return False;
3500
3501         if ( !prs_unistr4_str("name", ps, depth, &al1->name) )
3502                 return False;
3503         if ( !prs_align(ps) )
3504                 return False;
3505         if ( !prs_unistr4_str("description", ps, depth, &al1->description) )
3506                 return False;
3507         if ( !prs_align(ps) )
3508                 return False;
3509
3510         return True;
3511 }
3512
3513 /*******************************************************************
3514 inits a ALIAS_INFO3 structure.
3515 ********************************************************************/
3516
3517 void init_samr_alias_info3(ALIAS_INFO3 * al3, const char *acct_desc)
3518 {
3519         DEBUG(5, ("init_samr_alias_info3\n"));
3520
3521         init_unistr4(&al3->description, acct_desc, UNI_FLAGS_NONE);
3522 }
3523
3524 /*******************************************************************
3525 reads or writes a structure.
3526 ********************************************************************/
3527
3528 BOOL samr_io_alias_info3(const char *desc, ALIAS_INFO3 *al3,
3529                          prs_struct *ps, int depth)
3530 {
3531         if (al3 == NULL)
3532                 return False;
3533
3534         prs_debug(ps, depth, desc, "samr_io_alias_info3");
3535         depth++;
3536
3537         if(!prs_align(ps))
3538                 return False;
3539
3540         if (!prs_unistr4("description", ps, depth, &al3->description))
3541                 return False;
3542
3543         return True;
3544 }
3545
3546 /*******************************************************************
3547 reads or writes a structure.
3548 ********************************************************************/
3549
3550 BOOL samr_alias_info_ctr(const char *desc, prs_struct *ps, int depth, ALIAS_INFO_CTR * ctr)
3551 {
3552         if ( !ctr )
3553                 return False;
3554
3555         prs_debug(ps, depth, desc, "samr_alias_info_ctr");
3556         depth++;
3557
3558         if ( !prs_uint16("level", ps, depth, &ctr->level) )
3559                 return False;
3560
3561         if(!prs_align(ps))
3562                 return False;
3563         switch (ctr->level) {
3564         case 1:
3565                 if(!samr_io_alias_info1("alias_info1", &ctr->alias.info1, ps, depth))
3566                         return False;
3567                 break;
3568         case 3:
3569                 if(!samr_io_alias_info3("alias_info3", &ctr->alias.info3, ps, depth))
3570                         return False;
3571                 break;
3572         default:
3573                 DEBUG(0,("samr_alias_info_ctr: unsupported switch level\n"));
3574                 break;
3575         }
3576
3577         return True;
3578 }
3579
3580 /*******************************************************************
3581 inits a SAMR_Q_QUERY_ALIASINFO structure.
3582 ********************************************************************/
3583
3584 void init_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO * q_e,
3585                                  POLICY_HND *pol, uint32 switch_level)
3586 {
3587         DEBUG(5, ("init_samr_q_query_aliasinfo\n"));
3588
3589         q_e->pol = *pol;
3590         q_e->level = switch_level;
3591 }
3592
3593 /*******************************************************************
3594 reads or writes a structure.
3595 ********************************************************************/
3596
3597 BOOL samr_io_q_query_aliasinfo(const char *desc, SAMR_Q_QUERY_ALIASINFO *in,
3598                                prs_struct *ps, int depth)
3599 {
3600         if ( !in )
3601                 return False;
3602
3603         prs_debug(ps, depth, desc, "samr_io_q_query_aliasinfo");
3604         depth++;
3605
3606         if(!prs_align(ps))
3607                 return False;
3608
3609         if ( !smb_io_pol_hnd("pol", &(in->pol), ps, depth) )
3610                 return False;
3611
3612         if ( !prs_uint16("level", ps, depth, &in->level) )
3613                 return False;
3614
3615         return True;
3616 }
3617
3618 /*******************************************************************
3619 inits a SAMR_R_QUERY_ALIASINFO structure.
3620 ********************************************************************/
3621
3622 void init_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *out,
3623                                  ALIAS_INFO_CTR * ctr, NTSTATUS status)
3624 {
3625         DEBUG(5, ("init_samr_r_query_aliasinfo\n"));
3626
3627         out->ctr = ctr;
3628         out->status = status;
3629 }
3630
3631 /*******************************************************************
3632 reads or writes a structure.
3633 ********************************************************************/
3634
3635 BOOL samr_io_r_query_aliasinfo(const char *desc, SAMR_R_QUERY_ALIASINFO *out,
3636                                prs_struct *ps, int depth)
3637 {
3638         if ( !out )
3639                 return False;
3640
3641         prs_debug(ps, depth, desc, "samr_io_r_query_aliasinfo");
3642         depth++;
3643
3644         if(!prs_align(ps))
3645                 return False;
3646
3647         if ( !prs_pointer("alias", ps, depth, (void**)&out->ctr, sizeof(ALIAS_INFO_CTR), (PRS_POINTER_CAST)samr_alias_info_ctr))
3648                 return False;
3649         if(!prs_align(ps))
3650                 return False;
3651
3652         if(!prs_ntstatus("status", ps, depth, &out->status))
3653                 return False;
3654
3655         return True;
3656 }
3657
3658 /*******************************************************************
3659 inits a SAMR_Q_SET_ALIASINFO structure.
3660 ********************************************************************/
3661
3662 void init_samr_q_set_aliasinfo(SAMR_Q_SET_ALIASINFO * q_u,
3663                                POLICY_HND *hnd, ALIAS_INFO_CTR * ctr)
3664 {
3665         DEBUG(5, ("init_samr_q_set_aliasinfo\n"));
3666
3667         q_u->alias_pol = *hnd;
3668         q_u->ctr = *ctr;
3669 }
3670
3671 /*******************************************************************
3672 reads or writes a structure.
3673 ********************************************************************/
3674
3675 BOOL samr_io_q_set_aliasinfo(const char *desc, SAMR_Q_SET_ALIASINFO * q_u,
3676                              prs_struct *ps, int depth)
3677 {
3678         if (q_u == NULL)
3679                 return False;
3680
3681         prs_debug(ps, depth, desc, "samr_io_q_set_aliasinfo");
3682         depth++;
3683
3684         if(!prs_align(ps))
3685                 return False;
3686
3687         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
3688                 return False;
3689         if(!samr_alias_info_ctr("ctr", ps, depth, &q_u->ctr))
3690                 return False;
3691
3692         return True;
3693 }
3694
3695 /*******************************************************************
3696 reads or writes a structure.
3697 ********************************************************************/
3698
3699 BOOL samr_io_r_set_aliasinfo(const char *desc, SAMR_R_SET_ALIASINFO * r_u,
3700                              prs_struct *ps, int depth)
3701 {
3702         if (r_u == NULL)
3703                 return False;
3704
3705         prs_debug(ps, depth, desc, "samr_io_r_set_aliasinfo");
3706         depth++;
3707
3708         if(!prs_align(ps))
3709                 return False;
3710         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3711                 return False;
3712
3713         return True;
3714 }
3715
3716 /*******************************************************************
3717 inits a SAMR_Q_QUERY_USERALIASES structure.
3718 ********************************************************************/
3719
3720 void init_samr_q_query_useraliases(SAMR_Q_QUERY_USERALIASES * q_u,
3721                                    POLICY_HND *hnd,
3722                                    uint32 num_sids,
3723                                    uint32 *ptr_sid, DOM_SID2 * sid)
3724 {
3725         DEBUG(5, ("init_samr_q_query_useraliases\n"));
3726
3727         q_u->pol = *hnd;
3728
3729         q_u->num_sids1 = num_sids;
3730         q_u->ptr = 1;
3731         q_u->num_sids2 = num_sids;
3732
3733         q_u->ptr_sid = ptr_sid;
3734         q_u->sid = sid;
3735 }
3736
3737 /*******************************************************************
3738 reads or writes a SAMR_Q_QUERY_USERALIASES structure.
3739 ********************************************************************/
3740
3741 BOOL samr_io_q_query_useraliases(const char *desc, SAMR_Q_QUERY_USERALIASES * q_u,
3742                                  prs_struct *ps, int depth)
3743 {
3744         fstring tmp;
3745         uint32 i;
3746
3747         if (q_u == NULL)
3748                 return False;
3749
3750         prs_debug(ps, depth, desc, "samr_io_q_query_useraliases");
3751         depth++;
3752
3753         if(!prs_align(ps))
3754                 return False;
3755
3756         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
3757                 return False;
3758
3759         if(!prs_uint32("num_sids1", ps, depth, &q_u->num_sids1))
3760                 return False;
3761         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
3762                 return False;
3763
3764         if (q_u->ptr==0)
3765                 return True;
3766
3767         if(!prs_uint32("num_sids2", ps, depth, &q_u->num_sids2))
3768                 return False;
3769
3770         if (UNMARSHALLING(ps) && (q_u->num_sids2 != 0)) {
3771                 q_u->ptr_sid = PRS_ALLOC_MEM(ps,uint32,q_u->num_sids2);
3772                 if (q_u->ptr_sid == NULL)
3773                         return False;
3774
3775                 q_u->sid = PRS_ALLOC_MEM(ps, DOM_SID2, q_u->num_sids2);
3776                 if (q_u->sid == NULL)
3777                         return False;
3778         }
3779
3780         for (i = 0; i < q_u->num_sids2; i++) {
3781                 slprintf(tmp, sizeof(tmp) - 1, "ptr[%02d]", i);
3782                 if(!prs_uint32(tmp, ps, depth, &q_u->ptr_sid[i]))
3783                         return False;
3784         }
3785
3786         for (i = 0; i < q_u->num_sids2; i++) {
3787                 if (q_u->ptr_sid[i] != 0) {
3788                         slprintf(tmp, sizeof(tmp) - 1, "sid[%02d]", i);
3789                         if(!smb_io_dom_sid2(tmp, &q_u->sid[i], ps, depth))
3790                                 return False;
3791                 }
3792         }
3793
3794         return True;
3795 }
3796
3797 /*******************************************************************
3798 inits a SAMR_R_QUERY_USERALIASES structure.
3799 ********************************************************************/
3800
3801 void init_samr_r_query_useraliases(SAMR_R_QUERY_USERALIASES * r_u,
3802                                    uint32 num_rids, uint32 *rid,
3803                                    NTSTATUS status)
3804 {
3805         DEBUG(5, ("init_samr_r_query_useraliases\n"));
3806
3807         if (NT_STATUS_IS_OK(status)) {
3808                 r_u->num_entries = num_rids;
3809                 r_u->ptr = 1;
3810                 r_u->num_entries2 = num_rids;
3811
3812                 r_u->rid = rid;
3813         } else {
3814                 r_u->num_entries = 0;
3815                 r_u->ptr = 0;
3816                 r_u->num_entries2 = 0;
3817         }
3818
3819         r_u->status = status;
3820 }
3821
3822 /*******************************************************************
3823 reads or writes a structure.
3824 ********************************************************************/
3825
3826 BOOL samr_io_rids(const char *desc, uint32 *num_rids, uint32 **rid,
3827                   prs_struct *ps, int depth)
3828 {
3829         fstring tmp;
3830         uint32 i;
3831         if (rid == NULL)
3832                 return False;
3833
3834         prs_debug(ps, depth, desc, "samr_io_rids");
3835         depth++;
3836
3837         if(!prs_align(ps))
3838                 return False;
3839
3840         if(!prs_uint32("num_rids", ps, depth, num_rids))
3841                 return False;
3842
3843         if ((*num_rids) != 0) {
3844                 if (UNMARSHALLING(ps)) {
3845                         /* reading */
3846                         (*rid) = PRS_ALLOC_MEM(ps,uint32, *num_rids);
3847                 }
3848                 if ((*rid) == NULL)
3849                         return False;
3850
3851                 for (i = 0; i < (*num_rids); i++) {
3852                         slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]", i);
3853                         if(!prs_uint32(tmp, ps, depth, &((*rid)[i])))
3854                                 return False;
3855                 }
3856         }
3857
3858         return True;
3859 }
3860
3861 /*******************************************************************
3862 reads or writes a structure.
3863 ********************************************************************/
3864
3865 BOOL samr_io_r_query_useraliases(const char *desc, SAMR_R_QUERY_USERALIASES * r_u,
3866                                  prs_struct *ps, int depth)
3867 {
3868         if (r_u == NULL)
3869                 return False;
3870
3871         prs_debug(ps, depth, desc, "samr_io_r_query_useraliases");
3872         depth++;
3873
3874         if(!prs_align(ps))
3875                 return False;
3876
3877         if(!prs_uint32("num_entries", ps, depth, &r_u->num_entries))
3878                 return False;
3879         if(!prs_uint32("ptr        ", ps, depth, &r_u->ptr))
3880                 return False;
3881
3882         if (r_u->ptr != 0) {
3883                 if(!samr_io_rids("rids", &r_u->num_entries2, &r_u->rid, ps, depth))
3884                         return False;
3885         }
3886
3887         if(!prs_align(ps))
3888                 return False;
3889         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3890                 return False;
3891
3892         return True;
3893 }
3894
3895 /*******************************************************************
3896 inits a SAMR_Q_OPEN_ALIAS structure.
3897 ********************************************************************/
3898
3899 void init_samr_q_open_alias(SAMR_Q_OPEN_ALIAS * q_u, POLICY_HND *pol,
3900                             uint32 access_mask, uint32 rid)
3901 {
3902         DEBUG(5, ("init_samr_q_open_alias\n"));
3903
3904         q_u->dom_pol = *pol;
3905         q_u->access_mask = access_mask;
3906         q_u->rid_alias = rid;
3907 }
3908
3909 /*******************************************************************
3910 reads or writes a structure.
3911 ********************************************************************/
3912
3913 BOOL samr_io_q_open_alias(const char *desc, SAMR_Q_OPEN_ALIAS * q_u,
3914                           prs_struct *ps, int depth)
3915 {
3916         if (q_u == NULL)
3917                 return False;
3918
3919         prs_debug(ps, depth, desc, "samr_io_q_open_alias");
3920         depth++;
3921
3922         if(!prs_align(ps))
3923                 return False;
3924
3925         if(!smb_io_pol_hnd("domain_pol", &q_u->dom_pol, ps, depth))
3926                 return False;
3927
3928         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
3929                 return False;
3930         if(!prs_uint32("rid_alias", ps, depth, &q_u->rid_alias))
3931                 return False;
3932
3933         return True;
3934 }
3935
3936 /*******************************************************************
3937 reads or writes a structure.
3938 ********************************************************************/
3939
3940 BOOL samr_io_r_open_alias(const char *desc, SAMR_R_OPEN_ALIAS * r_u,
3941                           prs_struct *ps, int depth)
3942 {
3943         if (r_u == NULL)
3944                 return False;
3945
3946         prs_debug(ps, depth, desc, "samr_io_r_open_alias");
3947         depth++;
3948
3949         if(!prs_align(ps))
3950                 return False;
3951
3952         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
3953                 return False;
3954
3955         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3956                 return False;
3957
3958         return True;
3959 }
3960
3961 /*******************************************************************
3962 inits a SAMR_Q_LOOKUP_RIDS structure.
3963 ********************************************************************/
3964
3965 void init_samr_q_lookup_rids(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_RIDS * q_u,
3966                              POLICY_HND *pol, uint32 flags,
3967                              uint32 num_rids, uint32 *rid)
3968 {
3969         DEBUG(5, ("init_samr_q_lookup_rids\n"));
3970
3971         q_u->pol = *pol;
3972
3973         q_u->num_rids1 = num_rids;
3974         q_u->flags = flags;
3975         q_u->ptr = 0;
3976         q_u->num_rids2 = num_rids;
3977         q_u->rid = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids );
3978         if (q_u->rid == NULL) {
3979                 q_u->num_rids1 = 0;
3980                 q_u->num_rids2 = 0;
3981         } else {
3982                 memcpy(q_u->rid, rid, num_rids * sizeof(q_u->rid[0]));
3983         }
3984 }
3985
3986 /*******************************************************************
3987 reads or writes a structure.
3988 ********************************************************************/
3989
3990 BOOL samr_io_q_lookup_rids(const char *desc, SAMR_Q_LOOKUP_RIDS * q_u,
3991                            prs_struct *ps, int depth)
3992 {
3993         uint32 i;
3994         fstring tmp;
3995
3996         if (q_u == NULL)
3997                 return False;
3998
3999         prs_debug(ps, depth, desc, "samr_io_q_lookup_rids");
4000         depth++;
4001
4002         if (UNMARSHALLING(ps))
4003                 ZERO_STRUCTP(q_u);
4004
4005         if(!prs_align(ps))
4006                 return False;
4007
4008         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4009                 return False;
4010
4011         if(!prs_uint32("num_rids1", ps, depth, &q_u->num_rids1))
4012                 return False;
4013         if(!prs_uint32("flags    ", ps, depth, &q_u->flags))
4014                 return False;
4015         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
4016                 return False;
4017         if(!prs_uint32("num_rids2", ps, depth, &q_u->num_rids2))
4018                 return False;
4019
4020         if (UNMARSHALLING(ps) && (q_u->num_rids2 != 0)) {
4021                 q_u->rid = PRS_ALLOC_MEM(ps, uint32, q_u->num_rids2);
4022                 if (q_u->rid == NULL)
4023                         return False;
4024         }
4025
4026         for (i = 0; i < q_u->num_rids2; i++) {
4027                 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]  ", i);
4028                 if(!prs_uint32(tmp, ps, depth, &q_u->rid[i]))
4029                         return False;
4030         }
4031
4032         return True;
4033 }
4034
4035 /*******************************************************************
4036 inits a SAMR_R_LOOKUP_RIDS structure.
4037 ********************************************************************/
4038
4039 void init_samr_r_lookup_rids(SAMR_R_LOOKUP_RIDS * r_u,
4040                              uint32 num_names, UNIHDR * hdr_name,
4041                              UNISTR2 *uni_name, uint32 *type)
4042 {
4043         DEBUG(5, ("init_samr_r_lookup_rids\n"));
4044
4045         r_u->hdr_name = NULL;
4046         r_u->uni_name = NULL;
4047         r_u->type = NULL;
4048
4049         if (num_names != 0) {
4050                 r_u->num_names1 = num_names;
4051                 r_u->ptr_names = 1;
4052                 r_u->num_names2 = num_names;
4053
4054                 r_u->num_types1 = num_names;
4055                 r_u->ptr_types = 1;
4056                 r_u->num_types2 = num_names;
4057
4058                 r_u->hdr_name = hdr_name;
4059                 r_u->uni_name = uni_name;
4060                 r_u->type = type;
4061         } else {
4062                 r_u->num_names1 = num_names;
4063                 r_u->ptr_names = 0;
4064                 r_u->num_names2 = num_names;
4065
4066                 r_u->num_types1 = num_names;
4067                 r_u->ptr_types = 0;
4068                 r_u->num_types2 = num_names;
4069         }
4070 }
4071
4072 /*******************************************************************
4073 reads or writes a structure.
4074 ********************************************************************/
4075
4076 BOOL samr_io_r_lookup_rids(const char *desc, SAMR_R_LOOKUP_RIDS * r_u,
4077                            prs_struct *ps, int depth)
4078 {
4079         uint32 i;
4080         fstring tmp;
4081         if (r_u == NULL)
4082                 return False;
4083
4084         prs_debug(ps, depth, desc, "samr_io_r_lookup_rids");
4085         depth++;
4086
4087         if(!prs_align(ps))
4088                 return False;
4089
4090         if(!prs_uint32("num_names1", ps, depth, &r_u->num_names1))
4091                 return False;
4092         if(!prs_uint32("ptr_names ", ps, depth, &r_u->ptr_names))
4093                 return False;
4094
4095         if (r_u->ptr_names != 0) {
4096
4097                 if(!prs_uint32("num_names2", ps, depth, &r_u->num_names2))
4098                         return False;
4099
4100
4101                 if (UNMARSHALLING(ps) && (r_u->num_names2 != 0)) {
4102                         r_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, r_u->num_names2);
4103                         if (r_u->hdr_name == NULL)
4104                                 return False;
4105
4106                         r_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, r_u->num_names2);
4107                         if (r_u->uni_name == NULL)
4108                                 return False;
4109                 }
4110
4111                 for (i = 0; i < r_u->num_names2; i++) {
4112                         slprintf(tmp, sizeof(tmp) - 1, "hdr[%02d]  ", i);
4113                         if(!smb_io_unihdr("", &r_u->hdr_name[i], ps, depth))
4114                                 return False;
4115                 }
4116                 for (i = 0; i < r_u->num_names2; i++) {
4117                         slprintf(tmp, sizeof(tmp) - 1, "str[%02d]  ", i);
4118                         if(!smb_io_unistr2("", &r_u->uni_name[i], r_u->hdr_name[i].buffer, ps, depth))
4119                                 return False;
4120                 }
4121
4122         }
4123
4124         if(!prs_align(ps))
4125                 return False;
4126         if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
4127                 return False;
4128         if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
4129                 return False;
4130
4131         if (r_u->ptr_types != 0) {
4132
4133                 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
4134                         return False;
4135
4136                 if (UNMARSHALLING(ps) && (r_u->num_types2 != 0)) {
4137                         r_u->type = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
4138                         if (r_u->type == NULL)
4139                                 return False;
4140                 }
4141
4142                 for (i = 0; i < r_u->num_types2; i++) {
4143                         slprintf(tmp, sizeof(tmp) - 1, "type[%02d]  ", i);
4144                         if(!prs_uint32(tmp, ps, depth, &r_u->type[i]))
4145                                 return False;
4146                 }
4147         }
4148
4149         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4150                 return False;
4151
4152         return True;
4153 }
4154
4155 /*******************************************************************
4156 inits a SAMR_Q_OPEN_ALIAS structure.
4157 ********************************************************************/
4158
4159 void init_samr_q_delete_alias(SAMR_Q_DELETE_DOM_ALIAS * q_u, POLICY_HND *hnd)
4160 {
4161         DEBUG(5, ("init_samr_q_delete_alias\n"));
4162
4163         q_u->alias_pol = *hnd;
4164 }
4165
4166 /*******************************************************************
4167 reads or writes a structure.
4168 ********************************************************************/
4169
4170 BOOL samr_io_q_delete_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4171                             prs_struct *ps, int depth)
4172 {
4173         if (q_u == NULL)
4174                 return False;
4175
4176         prs_debug(ps, depth, desc, "samr_io_q_delete_alias");
4177         depth++;
4178
4179         if(!prs_align(ps))
4180                 return False;
4181
4182         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4183                 return False;
4184
4185         return True;
4186 }
4187
4188 /*******************************************************************
4189 reads or writes a structure.
4190 ********************************************************************/
4191
4192 BOOL samr_io_r_delete_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4193                             prs_struct *ps, int depth)
4194 {
4195         if (r_u == NULL)
4196                 return False;
4197
4198         prs_debug(ps, depth, desc, "samr_io_r_delete_alias");
4199         depth++;
4200
4201         if(!prs_align(ps))
4202                 return False;
4203
4204         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4205                 return False;
4206         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4207                 return False;
4208
4209         return True;
4210 }
4211
4212 /*******************************************************************
4213 inits a SAMR_Q_CREATE_DOM_ALIAS structure.
4214 ********************************************************************/
4215
4216 void init_samr_q_create_dom_alias(SAMR_Q_CREATE_DOM_ALIAS * q_u,
4217                                   POLICY_HND *hnd, const char *acct_desc)
4218 {
4219         DEBUG(5, ("init_samr_q_create_dom_alias\n"));
4220
4221         q_u->dom_pol = *hnd;
4222
4223         init_unistr2(&q_u->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
4224         init_uni_hdr(&q_u->hdr_acct_desc, &q_u->uni_acct_desc);
4225
4226         q_u->access_mask = MAXIMUM_ALLOWED_ACCESS;
4227 }
4228
4229 /*******************************************************************
4230 reads or writes a structure.
4231 ********************************************************************/
4232
4233 BOOL samr_io_q_create_dom_alias(const char *desc, SAMR_Q_CREATE_DOM_ALIAS * q_u,
4234                                 prs_struct *ps, int depth)
4235 {
4236         if (q_u == NULL)
4237                 return False;
4238
4239         prs_debug(ps, depth, desc, "samr_io_q_create_dom_alias");
4240         depth++;
4241
4242         if(!prs_align(ps))
4243                 return False;
4244
4245         if(!smb_io_pol_hnd("dom_pol", &q_u->dom_pol, ps, depth))
4246                 return False;
4247
4248         if(!smb_io_unihdr("hdr_acct_desc", &q_u->hdr_acct_desc, ps, depth))
4249                 return False;
4250         if(!smb_io_unistr2("uni_acct_desc", &q_u->uni_acct_desc,
4251                        q_u->hdr_acct_desc.buffer, ps, depth))
4252                 return False;
4253
4254         if(!prs_align(ps))
4255                 return False;
4256         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
4257                 return False;
4258
4259         return True;
4260 }
4261
4262 /*******************************************************************
4263 reads or writes a structure.
4264 ********************************************************************/
4265
4266 BOOL samr_io_r_create_dom_alias(const char *desc, SAMR_R_CREATE_DOM_ALIAS * r_u,
4267                                 prs_struct *ps, int depth)
4268 {
4269         if (r_u == NULL)
4270                 return False;
4271
4272         prs_debug(ps, depth, desc, "samr_io_r_create_dom_alias");
4273         depth++;
4274
4275         if(!prs_align(ps))
4276                 return False;
4277
4278         if(!smb_io_pol_hnd("alias_pol", &r_u->alias_pol, ps, depth))
4279                 return False;
4280
4281         if(!prs_uint32("rid", ps, depth, &r_u->rid))
4282                 return False;
4283
4284         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4285                 return False;
4286
4287         return True;
4288 }
4289
4290 /*******************************************************************
4291 inits a SAMR_Q_ADD_ALIASMEM structure.
4292 ********************************************************************/
4293
4294 void init_samr_q_add_aliasmem(SAMR_Q_ADD_ALIASMEM * q_u, POLICY_HND *hnd,
4295                               DOM_SID *sid)
4296 {
4297         DEBUG(5, ("init_samr_q_add_aliasmem\n"));
4298
4299         q_u->alias_pol = *hnd;
4300         init_dom_sid2(&q_u->sid, sid);
4301 }
4302
4303 /*******************************************************************
4304 reads or writes a structure.
4305 ********************************************************************/
4306
4307 BOOL samr_io_q_add_aliasmem(const char *desc, SAMR_Q_ADD_ALIASMEM * q_u,
4308                             prs_struct *ps, int depth)
4309 {
4310         if (q_u == NULL)
4311                 return False;
4312
4313         prs_debug(ps, depth, desc, "samr_io_q_add_aliasmem");
4314         depth++;
4315
4316         if(!prs_align(ps))
4317                 return False;
4318
4319         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4320                 return False;
4321         if(!smb_io_dom_sid2("sid      ", &q_u->sid, ps, depth))
4322                 return False;
4323
4324         return True;
4325 }
4326
4327 /*******************************************************************
4328 reads or writes a structure.
4329 ********************************************************************/
4330
4331 BOOL samr_io_r_add_aliasmem(const char *desc, SAMR_R_ADD_ALIASMEM * r_u,
4332                             prs_struct *ps, int depth)
4333 {
4334         if (r_u == NULL)
4335                 return False;
4336
4337         prs_debug(ps, depth, desc, "samr_io_r_add_aliasmem");
4338         depth++;
4339
4340         if(!prs_align(ps))
4341                 return False;
4342
4343         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4344                 return False;
4345
4346         return True;
4347 }
4348
4349 /*******************************************************************
4350 inits a SAMR_Q_DEL_ALIASMEM structure.
4351 ********************************************************************/
4352
4353 void init_samr_q_del_aliasmem(SAMR_Q_DEL_ALIASMEM * q_u, POLICY_HND *hnd,
4354                               DOM_SID *sid)
4355 {
4356         DEBUG(5, ("init_samr_q_del_aliasmem\n"));
4357
4358         q_u->alias_pol = *hnd;
4359         init_dom_sid2(&q_u->sid, sid);
4360 }
4361
4362 /*******************************************************************
4363 reads or writes a structure.
4364 ********************************************************************/
4365
4366 BOOL samr_io_q_del_aliasmem(const char *desc, SAMR_Q_DEL_ALIASMEM * q_u,
4367                             prs_struct *ps, int depth)
4368 {
4369         if (q_u == NULL)
4370                 return False;
4371
4372         prs_debug(ps, depth, desc, "samr_io_q_del_aliasmem");
4373         depth++;
4374
4375         if(!prs_align(ps))
4376                 return False;
4377
4378         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4379                 return False;
4380         if(!smb_io_dom_sid2("sid      ", &q_u->sid, ps, depth))
4381                 return False;
4382
4383         return True;
4384 }
4385
4386 /*******************************************************************
4387 reads or writes a structure.
4388 ********************************************************************/
4389
4390 BOOL samr_io_r_del_aliasmem(const char *desc, SAMR_R_DEL_ALIASMEM * r_u,
4391                             prs_struct *ps, int depth)
4392 {
4393         if (r_u == NULL)
4394                 return False;
4395
4396         prs_debug(ps, depth, desc, "samr_io_r_del_aliasmem");
4397         depth++;
4398
4399         if(!prs_align(ps))
4400                 return False;
4401
4402         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4403                 return False;
4404
4405         return True;
4406 }
4407
4408 /*******************************************************************
4409 inits a SAMR_Q_DELETE_DOM_ALIAS structure.
4410 ********************************************************************/
4411
4412 void init_samr_q_delete_dom_alias(SAMR_Q_DELETE_DOM_ALIAS * q_c,
4413                                   POLICY_HND *hnd)
4414 {
4415         DEBUG(5, ("init_samr_q_delete_dom_alias\n"));
4416
4417         q_c->alias_pol = *hnd;
4418 }
4419
4420 /*******************************************************************
4421 reads or writes a structure.
4422 ********************************************************************/
4423
4424 BOOL samr_io_q_delete_dom_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4425                                 prs_struct *ps, int depth)
4426 {
4427         if (q_u == NULL)
4428                 return False;
4429
4430         prs_debug(ps, depth, desc, "samr_io_q_delete_dom_alias");
4431         depth++;
4432
4433         if(!prs_align(ps))
4434                 return False;
4435
4436         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4437                 return False;
4438
4439         return True;
4440 }
4441
4442 /*******************************************************************
4443 inits a SAMR_R_DELETE_DOM_ALIAS structure.
4444 ********************************************************************/
4445
4446 void init_samr_r_delete_dom_alias(SAMR_R_DELETE_DOM_ALIAS * r_u,
4447                                   NTSTATUS status)
4448 {
4449         DEBUG(5, ("init_samr_r_delete_dom_alias\n"));
4450
4451         r_u->status = status;
4452 }
4453
4454 /*******************************************************************
4455 reads or writes a structure.
4456 ********************************************************************/
4457
4458 BOOL samr_io_r_delete_dom_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4459                                 prs_struct *ps, int depth)
4460 {
4461         if (r_u == NULL)
4462                 return False;
4463
4464         prs_debug(ps, depth, desc, "samr_io_r_delete_dom_alias");
4465         depth++;
4466
4467         if(!prs_align(ps))
4468                 return False;
4469
4470         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4471                 return False;
4472
4473         return True;
4474 }
4475
4476 /*******************************************************************
4477 inits a SAMR_Q_QUERY_ALIASMEM structure.
4478 ********************************************************************/
4479
4480 void init_samr_q_query_aliasmem(SAMR_Q_QUERY_ALIASMEM * q_c,
4481                                 POLICY_HND *hnd)
4482 {
4483         DEBUG(5, ("init_samr_q_query_aliasmem\n"));
4484
4485         q_c->alias_pol = *hnd;
4486 }
4487
4488 /*******************************************************************
4489 reads or writes a structure.
4490 ********************************************************************/
4491
4492 BOOL samr_io_q_query_aliasmem(const char *desc, SAMR_Q_QUERY_ALIASMEM * q_u,
4493                               prs_struct *ps, int depth)
4494 {
4495         if (q_u == NULL)
4496                 return False;
4497
4498         prs_debug(ps, depth, desc, "samr_io_q_query_aliasmem");
4499         depth++;
4500
4501         if(!prs_align(ps))
4502                 return False;
4503
4504         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4505                 return False;
4506
4507         return True;
4508 }
4509
4510 /*******************************************************************
4511 inits a SAMR_R_QUERY_ALIASMEM structure.
4512 ********************************************************************/
4513
4514 void init_samr_r_query_aliasmem(SAMR_R_QUERY_ALIASMEM * r_u,
4515                                 uint32 num_sids, DOM_SID2 * sid,
4516                                 NTSTATUS status)
4517 {
4518         DEBUG(5, ("init_samr_r_query_aliasmem\n"));
4519
4520         if (NT_STATUS_IS_OK(status)) {
4521                 r_u->num_sids = num_sids;
4522                 r_u->ptr = (num_sids != 0) ? 1 : 0;
4523                 r_u->num_sids1 = num_sids;
4524
4525                 r_u->sid = sid;
4526         } else {
4527                 r_u->ptr = 0;
4528                 r_u->num_sids = 0;
4529         }
4530
4531         r_u->status = status;
4532 }
4533
4534 /*******************************************************************
4535 reads or writes a structure.
4536 ********************************************************************/
4537
4538 BOOL samr_io_r_query_aliasmem(const char *desc, SAMR_R_QUERY_ALIASMEM * r_u,
4539                               prs_struct *ps, int depth)
4540 {
4541         uint32 i;
4542
4543         if (r_u == NULL)
4544                 return False;
4545
4546         prs_debug(ps, depth, desc, "samr_io_r_query_aliasmem");
4547         depth++;
4548
4549         if(!prs_align(ps))
4550                 return False;
4551
4552         if(!prs_uint32("num_sids ", ps, depth, &r_u->num_sids))
4553                 return False;
4554         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
4555                 return False;
4556
4557         if (r_u->ptr != 0 && r_u->num_sids != 0) {
4558                 uint32 *ptr_sid = NULL;
4559
4560                 if(!prs_uint32("num_sids1", ps, depth, &r_u->num_sids1))
4561                         return False;
4562
4563                 ptr_sid = TALLOC_ARRAY(ps->mem_ctx, uint32, r_u->num_sids1);
4564                 if (!ptr_sid) {
4565                         return False;
4566                 }
4567
4568                 for (i = 0; i < r_u->num_sids1; i++) {
4569                         ptr_sid[i] = 1;
4570                         if(!prs_uint32("ptr_sid", ps, depth, &ptr_sid[i]))
4571                                 return False;
4572                 }
4573
4574                 if (UNMARSHALLING(ps)) {
4575                         r_u->sid = TALLOC_ARRAY(ps->mem_ctx, DOM_SID2, r_u->num_sids1);
4576                 }
4577
4578                 for (i = 0; i < r_u->num_sids1; i++) {
4579                         if (ptr_sid[i] != 0) {
4580                                 if(!smb_io_dom_sid2("sid", &r_u->sid[i], ps, depth))
4581                                         return False;
4582                         }
4583                 }
4584         }
4585
4586         if(!prs_align(ps))
4587                 return False;
4588         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4589                 return False;
4590
4591         return True;
4592 }
4593
4594 /*******************************************************************
4595 inits a SAMR_Q_LOOKUP_NAMES structure.
4596 ********************************************************************/
4597
4598 NTSTATUS init_samr_q_lookup_names(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_NAMES * q_u,
4599                               POLICY_HND *pol, uint32 flags,
4600                               uint32 num_names, const char **name)
4601 {
4602         uint32 i;
4603
4604         DEBUG(5, ("init_samr_q_lookup_names\n"));
4605
4606         q_u->pol = *pol;
4607
4608         q_u->num_names1 = num_names;
4609         q_u->flags = flags;
4610         q_u->ptr = 0;
4611         q_u->num_names2 = num_names;
4612
4613         if (!(q_u->hdr_name = TALLOC_ZERO_ARRAY(ctx, UNIHDR, num_names)))
4614                 return NT_STATUS_NO_MEMORY;
4615
4616         if (!(q_u->uni_name = TALLOC_ZERO_ARRAY(ctx, UNISTR2, num_names)))
4617                 return NT_STATUS_NO_MEMORY;
4618
4619         for (i = 0; i < num_names; i++) {
4620                 init_unistr2(&q_u->uni_name[i], name[i], UNI_FLAGS_NONE);       /* unicode string for machine account */
4621                 init_uni_hdr(&q_u->hdr_name[i], &q_u->uni_name[i]);     /* unicode header for user_name */
4622         }
4623
4624         return NT_STATUS_OK;
4625 }
4626
4627 /*******************************************************************
4628 reads or writes a structure.
4629 ********************************************************************/
4630
4631 BOOL samr_io_q_lookup_names(const char *desc, SAMR_Q_LOOKUP_NAMES * q_u,
4632                             prs_struct *ps, int depth)
4633 {
4634         uint32 i;
4635
4636         if (q_u == NULL)
4637                 return False;
4638
4639         prs_debug(ps, depth, desc, "samr_io_q_lookup_names");
4640         depth++;
4641
4642         if (UNMARSHALLING(ps))
4643                 ZERO_STRUCTP(q_u);
4644
4645         if(!prs_align(ps))
4646                 return False;
4647
4648         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4649                 return False;
4650
4651         if(!prs_uint32("num_names1", ps, depth, &q_u->num_names1))
4652                 return False;
4653         if(!prs_uint32("flags     ", ps, depth, &q_u->flags))
4654                 return False;
4655         if(!prs_uint32("ptr       ", ps, depth, &q_u->ptr))
4656                 return False;
4657         if(!prs_uint32("num_names2", ps, depth, &q_u->num_names2))
4658                 return False;
4659
4660         if (UNMARSHALLING(ps) && (q_u->num_names2 != 0)) {
4661                 q_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_u->num_names2);
4662                 q_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_u->num_names2);
4663                 if (!q_u->hdr_name || !q_u->uni_name)
4664                         return False;
4665         }
4666
4667         for (i = 0; i < q_u->num_names2; i++) {
4668                 if(!smb_io_unihdr("", &q_u->hdr_name[i], ps, depth))
4669                         return False;
4670         }
4671
4672         for (i = 0; i < q_u->num_names2; i++) {
4673                 if(!smb_io_unistr2("", &q_u->uni_name[i], q_u->hdr_name[i].buffer, ps, depth))
4674                         return False;
4675         }
4676
4677         return True;
4678 }
4679
4680 /*******************************************************************
4681 inits a SAMR_R_LOOKUP_NAMES structure.
4682 ********************************************************************/
4683
4684 NTSTATUS init_samr_r_lookup_names(TALLOC_CTX *ctx, SAMR_R_LOOKUP_NAMES * r_u,
4685                               uint32 num_rids,
4686                               uint32 *rid, uint32 *type,
4687                               NTSTATUS status)
4688 {
4689         DEBUG(5, ("init_samr_r_lookup_names\n"));
4690
4691         if (NT_STATUS_IS_OK(status) && (num_rids != 0)) {
4692                 uint32 i;
4693
4694                 r_u->num_types1 = num_rids;
4695                 r_u->ptr_types = 1;
4696                 r_u->num_types2 = num_rids;
4697
4698                 r_u->num_rids1 = num_rids;
4699                 r_u->ptr_rids = 1;
4700                 r_u->num_rids2 = num_rids;
4701
4702                 if (!(r_u->rids = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
4703                         return NT_STATUS_NO_MEMORY;
4704                 if (!(r_u->types = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
4705                         return NT_STATUS_NO_MEMORY;
4706
4707                 if (!r_u->rids || !r_u->types)
4708                         goto empty;
4709
4710                 for (i = 0; i < num_rids; i++) {
4711                         r_u->rids[i] = rid[i];
4712                         r_u->types[i] = type[i];
4713                 }
4714         } else {
4715
4716   empty:
4717                 r_u->num_types1 = 0;
4718                 r_u->ptr_types = 0;
4719                 r_u->num_types2 = 0;
4720
4721                 r_u->num_rids1 = 0;
4722                 r_u->ptr_rids = 0;
4723                 r_u->num_rids2 = 0;
4724
4725                 r_u->rids = NULL;
4726                 r_u->types = NULL;
4727         }
4728
4729         r_u->status = status;
4730
4731         return NT_STATUS_OK;
4732 }
4733
4734 /*******************************************************************
4735 reads or writes a structure.
4736 ********************************************************************/
4737
4738 BOOL samr_io_r_lookup_names(const char *desc, SAMR_R_LOOKUP_NAMES * r_u,
4739                             prs_struct *ps, int depth)
4740 {
4741         uint32 i;
4742         fstring tmp;
4743
4744         if (r_u == NULL)
4745                 return False;
4746
4747         prs_debug(ps, depth, desc, "samr_io_r_lookup_names");
4748         depth++;
4749
4750         if (UNMARSHALLING(ps))
4751                 ZERO_STRUCTP(r_u);
4752
4753         if(!prs_align(ps))
4754                 return False;
4755
4756         if(!prs_uint32("num_rids1", ps, depth, &r_u->num_rids1))
4757                 return False;
4758         if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
4759                 return False;
4760
4761         if (r_u->ptr_rids != 0) {
4762                 if(!prs_uint32("num_rids2", ps, depth, &r_u->num_rids2))
4763                         return False;
4764
4765                 if (r_u->num_rids2 != r_u->num_rids1) {
4766                         /* RPC fault */
4767                         return False;
4768                 }
4769
4770                 if (UNMARSHALLING(ps))
4771                         r_u->rids = PRS_ALLOC_MEM(ps, uint32, r_u->num_rids2);
4772
4773                 if (!r_u->rids) {
4774                         DEBUG(0, ("NULL rids in samr_io_r_lookup_names\n"));
4775                         return False;
4776                 }
4777
4778                 for (i = 0; i < r_u->num_rids2; i++) {
4779                         slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]  ", i);
4780                         if(!prs_uint32(tmp, ps, depth, &r_u->rids[i]))
4781                                 return False;
4782                 }
4783         }
4784
4785         if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
4786                 return False;
4787         if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
4788                 return False;
4789
4790         if (r_u->ptr_types != 0) {
4791                 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
4792                         return False;
4793
4794                 if (r_u->num_types2 != r_u->num_types1) {
4795                         /* RPC fault */
4796                         return False;
4797                 }
4798
4799                 if (UNMARSHALLING(ps))
4800                         r_u->types = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
4801
4802                 if (!r_u->types) {
4803                         DEBUG(0, ("NULL types in samr_io_r_lookup_names\n"));
4804                         return False;
4805                 }
4806
4807                 for (i = 0; i < r_u->num_types2; i++) {
4808                         slprintf(tmp, sizeof(tmp) - 1, "type[%02d]  ", i);
4809                         if(!prs_uint32(tmp, ps, depth, &r_u->types[i]))
4810                                 return False;
4811                 }
4812         }
4813
4814         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4815                 return False;
4816
4817         return True;
4818 }
4819
4820 /*******************************************************************
4821 inits a SAMR_Q_DELETE_DOM_USER structure.
4822 ********************************************************************/
4823
4824 void init_samr_q_delete_dom_user(SAMR_Q_DELETE_DOM_USER * q_c,
4825                                  POLICY_HND *hnd)
4826 {
4827         DEBUG(5, ("init_samr_q_delete_dom_user\n"));
4828
4829         q_c->user_pol = *hnd;
4830 }
4831
4832 /*******************************************************************
4833 reads or writes a structure.
4834 ********************************************************************/
4835
4836 BOOL samr_io_q_delete_dom_user(const char *desc, SAMR_Q_DELETE_DOM_USER * q_u,
4837                                prs_struct *ps, int depth)
4838 {
4839         if (q_u == NULL)
4840                 return False;
4841
4842         prs_debug(ps, depth, desc, "samr_io_q_delete_dom_user");
4843         depth++;
4844
4845         if(!prs_align(ps))
4846                 return False;
4847
4848         if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
4849                 return False;
4850
4851         return True;
4852 }
4853
4854 /*******************************************************************
4855 reads or writes a structure.
4856 ********************************************************************/
4857
4858 BOOL samr_io_r_delete_dom_user(const char *desc, SAMR_R_DELETE_DOM_USER * r_u,
4859                                prs_struct *ps, int depth)
4860 {
4861         if (r_u == NULL)
4862                 return False;
4863
4864         prs_debug(ps, depth, desc, "samr_io_r_delete_dom_user");
4865         depth++;
4866
4867         if(!prs_align(ps))
4868                 return False;
4869
4870         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4871                 return False;
4872         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4873                 return False;
4874
4875         return True;
4876 }
4877
4878 /*******************************************************************
4879 reads or writes a structure.
4880 ********************************************************************/
4881
4882 void init_samr_q_open_user(SAMR_Q_OPEN_USER * q_u,
4883                            POLICY_HND *pol,
4884                            uint32 access_mask, uint32 rid)
4885 {
4886         DEBUG(5, ("samr_init_samr_q_open_user\n"));
4887
4888         q_u->domain_pol = *pol;
4889         q_u->access_mask = access_mask;
4890         q_u->user_rid = rid;
4891 }
4892
4893 /*******************************************************************
4894 reads or writes a structure.
4895 ********************************************************************/
4896
4897 BOOL samr_io_q_open_user(const char *desc, SAMR_Q_OPEN_USER * q_u,
4898                          prs_struct *ps, int depth)
4899 {
4900         if (q_u == NULL)
4901                 return False;
4902
4903         prs_debug(ps, depth, desc, "samr_io_q_open_user");
4904         depth++;
4905
4906         if(!prs_align(ps))
4907                 return False;
4908
4909         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
4910                 return False;
4911
4912         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
4913                 return False;
4914         if(!prs_uint32("user_rid ", ps, depth, &q_u->user_rid))
4915                 return False;
4916
4917         return True;
4918 }
4919
4920 /*******************************************************************
4921 reads or writes a structure.
4922 ********************************************************************/
4923
4924 BOOL samr_io_r_open_user(const char *desc, SAMR_R_OPEN_USER * r_u,
4925                          prs_struct *ps, int depth)
4926 {
4927         if (r_u == NULL)
4928                 return False;
4929
4930         prs_debug(ps, depth, desc, "samr_io_r_open_user");
4931         depth++;
4932
4933         if(!prs_align(ps))
4934                 return False;
4935
4936         if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
4937                 return False;
4938
4939         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4940                 return False;
4941
4942         return True;
4943 }
4944
4945
4946 /*******************************************************************
4947 reads or writes a structure.
4948 ********************************************************************/
4949
4950 void init_samr_q_create_user(SAMR_Q_CREATE_USER * q_u,
4951                              POLICY_HND *pol,
4952                              const char *name,
4953                              uint32 acb_info, uint32 access_mask)
4954 {
4955         DEBUG(5, ("samr_init_samr_q_create_user\n"));
4956
4957         q_u->domain_pol = *pol;
4958
4959         init_unistr2(&q_u->uni_name, name, UNI_FLAGS_NONE);
4960         init_uni_hdr(&q_u->hdr_name, &q_u->uni_name);
4961
4962         q_u->acb_info = acb_info;
4963         q_u->access_mask = access_mask;
4964 }
4965
4966 /*******************************************************************
4967 reads or writes a structure.
4968 ********************************************************************/
4969
4970 BOOL samr_io_q_create_user(const char *desc, SAMR_Q_CREATE_USER * q_u,
4971                            prs_struct *ps, int depth)
4972 {
4973         if (q_u == NULL)
4974                 return False;
4975
4976         prs_debug(ps, depth, desc, "samr_io_q_create_user");
4977         depth++;
4978
4979         if(!prs_align(ps))
4980                 return False;
4981
4982         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
4983                 return False;
4984
4985         if(!smb_io_unihdr("hdr_name", &q_u->hdr_name, ps, depth))
4986                 return False;
4987         if(!smb_io_unistr2("uni_name", &q_u->uni_name, q_u->hdr_name.buffer, ps, depth))
4988                 return False;
4989
4990         if(!prs_align(ps))
4991                 return False;
4992         if(!prs_uint32("acb_info   ", ps, depth, &q_u->acb_info))
4993                 return False;
4994         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
4995                 return False;
4996
4997         return True;
4998 }
4999
5000 /*******************************************************************
5001 reads or writes a structure.
5002 ********************************************************************/
5003
5004 BOOL samr_io_r_create_user(const char *desc, SAMR_R_CREATE_USER * r_u,
5005                            prs_struct *ps, int depth)
5006 {
5007         if (r_u == NULL)
5008                 return False;
5009
5010         prs_debug(ps, depth, desc, "samr_io_r_create_user");
5011         depth++;
5012
5013         if(!prs_align(ps))
5014                 return False;
5015
5016         if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
5017                 return False;
5018
5019         if(!prs_uint32("access_granted", ps, depth, &r_u->access_granted))
5020                 return False;
5021         if(!prs_uint32("user_rid ", ps, depth, &r_u->user_rid))
5022                 return False;
5023         if(!prs_ntstatus("status", ps, depth, &r_u->status))
5024                 return False;
5025
5026         return True;
5027 }
5028
5029 /*******************************************************************
5030 inits a SAMR_Q_QUERY_USERINFO structure.
5031 ********************************************************************/
5032
5033 void init_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO * q_u,
5034                                 POLICY_HND *hnd, uint16 switch_value)
5035 {
5036         DEBUG(5, ("init_samr_q_query_userinfo\n"));
5037
5038         q_u->pol = *hnd;
5039         q_u->switch_value = switch_value;
5040 }
5041
5042 /*******************************************************************
5043 reads or writes a structure.
5044 ********************************************************************/
5045
5046 BOOL samr_io_q_query_userinfo(const char *desc, SAMR_Q_QUERY_USERINFO * q_u,
5047                               prs_struct *ps, int depth)
5048 {
5049         if (q_u == NULL)
5050                 return False;
5051
5052         prs_debug(ps, depth, desc, "samr_io_q_query_userinfo");
5053         depth++;
5054
5055         if(!prs_align(ps))
5056                 return False;
5057
5058         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
5059                 return False;
5060
5061         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value)) /* 0x0015 or 0x0011 */
5062                 return False;
5063
5064         return True;
5065 }
5066
5067 /*******************************************************************
5068 reads or writes a LOGON_HRS structure.
5069 ********************************************************************/
5070
5071 static BOOL sam_io_logon_hrs(const char *desc, LOGON_HRS * hrs,
5072                              prs_struct *ps, int depth)
5073 {
5074         if (hrs == NULL)
5075                 return False;
5076
5077         prs_debug(ps, depth, desc, "sam_io_logon_hrs");
5078         depth++;
5079
5080         if(!prs_align(ps))
5081                 return False;
5082
5083         if(!prs_uint32("maxlen", ps, depth, &hrs->max_len))
5084                 return False;
5085
5086         if(!prs_uint32("offset", ps, depth, &hrs->offset))
5087                 return False;
5088
5089         if(!prs_uint32("len  ", ps, depth, &hrs->len))
5090                 return False;
5091
5092         if (hrs->len > sizeof(hrs->hours)) {
5093                 DEBUG(3, ("sam_io_logon_hrs: truncating length from %d\n", hrs->len));
5094                 hrs->len = sizeof(hrs->hours);
5095         }
5096
5097         if(!prs_uint8s(False, "hours", ps, depth, hrs->hours, hrs->len))
5098                 return False;
5099
5100         return True;
5101 }
5102
5103 /*******************************************************************
5104 inits a SAM_USER_INFO_18 structure.
5105 ********************************************************************/
5106
5107 void init_sam_user_info18(SAM_USER_INFO_18 * usr,
5108                           const uint8 lm_pwd[16], const uint8 nt_pwd[16])
5109 {
5110         DEBUG(5, ("init_sam_user_info18\n"));
5111
5112         usr->lm_pwd_active =
5113                 memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd)) ? 1 : 0;
5114         usr->nt_pwd_active =
5115                 memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd)) ? 1 : 0;
5116 }
5117
5118 /*******************************************************************
5119 reads or writes a structure.
5120 ********************************************************************/
5121
5122 static BOOL sam_io_user_info18(const char *desc, SAM_USER_INFO_18 * u,
5123                         prs_struct *ps, int depth)
5124 {
5125         if (u == NULL)
5126                 return False;
5127
5128         prs_debug(ps, depth, desc, "samr_io_r_user_info18");
5129         depth++;
5130
5131         if(!prs_align(ps))
5132                 return False;
5133
5134         if(!prs_uint8s(False, "lm_pwd", ps, depth, u->lm_pwd, sizeof(u->lm_pwd)))
5135                 return False;
5136         if(!prs_uint8s(False, "nt_pwd", ps, depth, u->nt_pwd, sizeof(u->nt_pwd)))
5137                 return False;
5138
5139         if(!prs_uint8("lm_pwd_active", ps, depth, &u->lm_pwd_active))
5140                 return False;
5141         if(!prs_uint8("nt_pwd_active", ps, depth, &u->nt_pwd_active))
5142                 return False;
5143
5144         return True;
5145 }
5146
5147 /*******************************************************************
5148 inits a SAM_USER_INFO_7 structure.
5149 ********************************************************************/
5150
5151 void init_sam_user_info7(SAM_USER_INFO_7 * usr, const char *name)
5152 {
5153         DEBUG(5, ("init_sam_user_info7\n"));
5154
5155         init_unistr2(&usr->uni_name, name, UNI_FLAGS_NONE);     /* unicode string for name */
5156         init_uni_hdr(&usr->hdr_name, &usr->uni_name);           /* unicode header for name */
5157
5158 }
5159
5160 /*******************************************************************
5161 reads or writes a structure.
5162 ********************************************************************/
5163
5164 static BOOL sam_io_user_info7(const char *desc, SAM_USER_INFO_7 * usr,
5165                         prs_struct *ps, int depth)
5166 {
5167         if (usr == NULL)
5168                 return False;
5169
5170         prs_debug(ps, depth, desc, "samr_io_r_user_info7");
5171         depth++;
5172
5173         if(!prs_align(ps))
5174                 return False;
5175
5176         if(!smb_io_unihdr("unihdr", &usr->hdr_name, ps, depth))
5177                 return False;
5178
5179         if(!smb_io_unistr2("unistr2", &usr->uni_name, True, ps, depth))
5180                 return False;
5181
5182         return True;
5183 }
5184
5185 /*******************************************************************
5186 inits a SAM_USER_INFO_16 structure.
5187 ********************************************************************/
5188
5189 void init_sam_user_info16(SAM_USER_INFO_16 * usr, uint32 acb_info)
5190 {
5191         DEBUG(5, ("init_sam_user_info16\n"));
5192
5193         usr->acb_info = acb_info;
5194 }
5195
5196 /*******************************************************************
5197 reads or writes a structure.
5198 ********************************************************************/
5199
5200 static BOOL sam_io_user_info16(const char *desc, SAM_USER_INFO_16 * usr,
5201                         prs_struct *ps, int depth)
5202 {
5203         if (usr == NULL)
5204                 return False;
5205
5206         prs_debug(ps, depth, desc, "samr_io_r_user_info16");
5207         depth++;
5208
5209         if(!prs_align(ps))
5210                 return False;
5211
5212         if(!prs_uint32("acb_info", ps, depth, &usr->acb_info))
5213                 return False;
5214
5215         return True;
5216 }
5217
5218 /*******************************************************************
5219 inits a SAM_USER_INFO_17 structure.
5220 ********************************************************************/
5221
5222 void init_sam_user_info17(SAM_USER_INFO_17 * usr,
5223                           NTTIME * expiry,
5224                           char *mach_acct,
5225                           uint32 rid_user, uint32 rid_group, uint16 acct_ctrl)
5226 {
5227         DEBUG(5, ("init_sam_user_info17\n"));
5228
5229         memcpy(&usr->expiry, expiry, sizeof(usr->expiry));      /* expiry time or something? */
5230         ZERO_STRUCT(usr->padding_1);    /* 0 - padding 24 bytes */
5231
5232         usr->padding_2 = 0;     /* 0 - padding 4 bytes */
5233
5234         usr->ptr_1 = 1;         /* pointer */
5235         ZERO_STRUCT(usr->padding_3);    /* 0 - padding 32 bytes */
5236         usr->padding_4 = 0;     /* 0 - padding 4 bytes */
5237
5238         usr->ptr_2 = 1;         /* pointer */
5239         usr->padding_5 = 0;     /* 0 - padding 4 bytes */
5240
5241         usr->ptr_3 = 1;         /* pointer */
5242         ZERO_STRUCT(usr->padding_6);    /* 0 - padding 32 bytes */
5243
5244         usr->rid_user = rid_user;
5245         usr->rid_group = rid_group;
5246
5247         usr->acct_ctrl = acct_ctrl;
5248         usr->unknown_3 = 0x0000;
5249
5250         usr->unknown_4 = 0x003f;        /* 0x003f      - 16 bit unknown */
5251         usr->unknown_5 = 0x003c;        /* 0x003c      - 16 bit unknown */
5252
5253         ZERO_STRUCT(usr->padding_7);    /* 0 - padding 16 bytes */
5254         usr->padding_8 = 0;     /* 0 - padding 4 bytes */
5255
5256         init_unistr2(&usr->uni_mach_acct, mach_acct, UNI_FLAGS_NONE);   /* unicode string for machine account */
5257         init_uni_hdr(&usr->hdr_mach_acct, &usr->uni_mach_acct); /* unicode header for machine account */
5258 }
5259
5260 /*******************************************************************
5261 reads or writes a structure.
5262 ********************************************************************/
5263
5264 static BOOL sam_io_user_info17(const char *desc, SAM_USER_INFO_17 * usr,
5265                         prs_struct *ps, int depth)
5266 {
5267         if (usr == NULL)
5268                 return False;
5269
5270         prs_debug(ps, depth, desc, "samr_io_r_unknown_17");
5271         depth++;
5272
5273         if(!prs_align(ps))
5274                 return False;
5275
5276         if(!prs_uint8s(False, "padding_0", ps, depth, usr->padding_0, sizeof(usr->padding_0)))
5277                 return False;
5278
5279         if(!smb_io_time("time", &usr->expiry, ps, depth))
5280                 return False;
5281
5282         if(!prs_uint8s(False, "padding_1", ps, depth, usr->padding_1, sizeof(usr->padding_1)))
5283                 return False;
5284
5285         if(!smb_io_unihdr("unihdr", &usr->hdr_mach_acct, ps, depth))
5286                 return False;
5287
5288         if(!prs_uint32("padding_2", ps, depth, &usr->padding_2))
5289                 return False;
5290
5291         if(!prs_uint32("ptr_1    ", ps, depth, &usr->ptr_1))
5292                 return False;
5293         if(!prs_uint8s(False, "padding_3", ps, depth, usr->padding_3, sizeof(usr->padding_3)))
5294                 return False;
5295
5296         if(!prs_uint32("padding_4", ps, depth, &usr->padding_4))
5297                 return False;
5298
5299         if(!prs_uint32("ptr_2    ", ps, depth, &usr->ptr_2))
5300                 return False;
5301         if(!prs_uint32("padding_5", ps, depth, &usr->padding_5))
5302                 return False;
5303
5304         if(!prs_uint32("ptr_3    ", ps, depth, &usr->ptr_3))
5305                 return False;
5306         if(!prs_uint8s(False, "padding_6", ps, depth, usr->padding_6,sizeof(usr->padding_6)))
5307                 return False;
5308
5309         if(!prs_uint32("rid_user ", ps, depth, &usr->rid_user))
5310                 return False;
5311         if(!prs_uint32("rid_group", ps, depth, &usr->rid_group))
5312                 return False;
5313         if(!prs_uint16("acct_ctrl", ps, depth, &usr->acct_ctrl))
5314                 return False;
5315         if(!prs_uint16("unknown_3", ps, depth, &usr->unknown_3))
5316                 return False;
5317         if(!prs_uint16("unknown_4", ps, depth, &usr->unknown_4))
5318                 return False;
5319         if(!prs_uint16("unknown_5", ps, depth, &usr->unknown_5))
5320                 return False;
5321
5322         if(!prs_uint8s(False, "padding_7", ps, depth, usr->padding_7, sizeof(usr->padding_7)))
5323                 return False;
5324
5325         if(!prs_uint32("padding_8", ps, depth, &(usr->padding_8)))
5326                 return False;
5327
5328         if(!smb_io_unistr2("unistr2", &usr->uni_mach_acct, True, ps, depth))
5329                 return False;
5330
5331         if(!prs_align(ps))
5332                 return False;
5333
5334         if(!prs_uint8s(False, "padding_9", ps, depth, usr->padding_9, sizeof(usr->padding_9)))
5335                 return False;
5336
5337         return True;
5338 }
5339
5340 /*************************************************************************
5341  init_sam_user_infoa
5342  *************************************************************************/
5343
5344 void init_sam_user_info24(SAM_USER_INFO_24 * usr, char newpass[516], uint16 pw_len)
5345 {
5346         DEBUG(10, ("init_sam_user_info24:\n"));
5347         memcpy(usr->pass, newpass, sizeof(usr->pass));
5348         usr->pw_len = pw_len;
5349 }
5350
5351 /*******************************************************************
5352 reads or writes a structure.
5353 ********************************************************************/
5354
5355 static BOOL sam_io_user_info24(const char *desc, SAM_USER_INFO_24 * usr,
5356                                prs_struct *ps, int depth)
5357 {
5358         if (usr == NULL)
5359                 return False;
5360
5361         prs_debug(ps, depth, desc, "sam_io_user_info24");
5362         depth++;
5363
5364         if(!prs_align(ps))
5365                 return False;
5366
5367         if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5368                        sizeof(usr->pass)))
5369                 return False;
5370
5371         if (MARSHALLING(ps) && (usr->pw_len != 0)) {
5372                 if (!prs_uint16("pw_len", ps, depth, &usr->pw_len))
5373                         return False;
5374         }
5375         if(!prs_align(ps))
5376                 return False;
5377
5378         return True;
5379 }
5380
5381 /*************************************************************************
5382  init_sam_user_info23
5383
5384  unknown_6 = 0x0000 04ec
5385
5386  *************************************************************************/
5387
5388 void init_sam_user_info23W(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5389                         NTTIME * logoff_time,   /* all zeros */
5390                         NTTIME * kickoff_time,  /* all zeros */
5391                         NTTIME * pass_last_set_time,    /* all zeros */
5392                         NTTIME * pass_can_change_time,  /* all zeros */
5393                         NTTIME * pass_must_change_time, /* all zeros */
5394                         UNISTR2 *user_name,
5395                         UNISTR2 *full_name,
5396                         UNISTR2 *home_dir,
5397                         UNISTR2 *dir_drive,
5398                         UNISTR2 *log_scr,
5399                         UNISTR2 *prof_path,
5400                         UNISTR2 *desc,
5401                         UNISTR2 *wkstas,
5402                         UNISTR2 *unk_str,
5403                         UNISTR2 *mung_dial,
5404                         uint32 user_rid,        /* 0x0000 0000 */
5405                         uint32 group_rid,
5406                         uint32 acb_info,
5407                         uint32 fields_present,
5408                         uint16 logon_divs,
5409                         LOGON_HRS * hrs,
5410                         uint16 bad_password_count,
5411                         uint16 logon_count,
5412                         char newpass[516])
5413 {
5414         usr->logon_time = *logon_time;  /* all zeros */
5415         usr->logoff_time = *logoff_time;        /* all zeros */
5416         usr->kickoff_time = *kickoff_time;      /* all zeros */
5417         usr->pass_last_set_time = *pass_last_set_time;  /* all zeros */
5418         usr->pass_can_change_time = *pass_can_change_time;      /* all zeros */
5419         usr->pass_must_change_time = *pass_must_change_time;    /* all zeros */
5420
5421         ZERO_STRUCT(usr->nt_pwd);
5422         ZERO_STRUCT(usr->lm_pwd);
5423
5424         usr->user_rid = user_rid;       /* 0x0000 0000 */
5425         usr->group_rid = group_rid;
5426         usr->acb_info = acb_info;
5427         usr->fields_present = fields_present;   /* 09f8 27fa */
5428
5429         usr->logon_divs = logon_divs;   /* should be 168 (hours/week) */
5430         usr->ptr_logon_hrs = hrs ? 1 : 0;
5431
5432         if (nt_time_is_zero(pass_must_change_time)) {
5433                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5434         } else {
5435                 usr->passmustchange=0;
5436         }
5437
5438         ZERO_STRUCT(usr->padding1);
5439         ZERO_STRUCT(usr->padding2);
5440
5441         usr->bad_password_count = bad_password_count;
5442         usr->logon_count = logon_count;
5443
5444         memcpy(usr->pass, newpass, sizeof(usr->pass));
5445
5446         copy_unistr2(&usr->uni_user_name, user_name);
5447         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5448
5449         copy_unistr2(&usr->uni_full_name, full_name);
5450         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5451
5452         copy_unistr2(&usr->uni_home_dir, home_dir);
5453         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5454
5455         copy_unistr2(&usr->uni_dir_drive, dir_drive);
5456         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5457
5458         copy_unistr2(&usr->uni_logon_script, log_scr);
5459         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5460
5461         copy_unistr2(&usr->uni_profile_path, prof_path);
5462         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5463
5464         copy_unistr2(&usr->uni_acct_desc, desc);
5465         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5466
5467         copy_unistr2(&usr->uni_workstations, wkstas);
5468         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5469
5470         copy_unistr2(&usr->uni_unknown_str, unk_str);
5471         init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
5472
5473         copy_unistr2(&usr->uni_munged_dial, mung_dial);
5474         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5475
5476         memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5477 }
5478
5479 /*************************************************************************
5480  init_sam_user_info23
5481
5482  unknown_6 = 0x0000 04ec
5483
5484  *************************************************************************/
5485
5486 void init_sam_user_info23A(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5487                            NTTIME * logoff_time,        /* all zeros */
5488                            NTTIME * kickoff_time,       /* all zeros */
5489                            NTTIME * pass_last_set_time, /* all zeros */
5490                            NTTIME * pass_can_change_time,       /* all zeros */
5491                            NTTIME * pass_must_change_time,      /* all zeros */
5492                            char *user_name,     /* NULL */
5493                            char *full_name,
5494                            char *home_dir, char *dir_drive, char *log_scr,
5495                            char *prof_path, const char *desc, char *wkstas,
5496                            char *unk_str, char *mung_dial, uint32 user_rid,     /* 0x0000 0000 */
5497                            uint32 group_rid, uint32 acb_info,
5498                            uint32 fields_present, uint16 logon_divs,
5499                            LOGON_HRS * hrs, uint16 bad_password_count, uint16 logon_count,
5500                            char newpass[516])
5501 {
5502         DATA_BLOB blob = base64_decode_data_blob(mung_dial);
5503
5504         usr->logon_time = *logon_time;  /* all zeros */
5505         usr->logoff_time = *logoff_time;        /* all zeros */
5506         usr->kickoff_time = *kickoff_time;      /* all zeros */
5507         usr->pass_last_set_time = *pass_last_set_time;  /* all zeros */
5508         usr->pass_can_change_time = *pass_can_change_time;      /* all zeros */
5509         usr->pass_must_change_time = *pass_must_change_time;    /* all zeros */
5510
5511         ZERO_STRUCT(usr->nt_pwd);
5512         ZERO_STRUCT(usr->lm_pwd);
5513
5514         usr->user_rid = user_rid;       /* 0x0000 0000 */
5515         usr->group_rid = group_rid;
5516         usr->acb_info = acb_info;
5517         usr->fields_present = fields_present;   /* 09f8 27fa */
5518
5519         usr->logon_divs = logon_divs;   /* should be 168 (hours/week) */
5520         usr->ptr_logon_hrs = hrs ? 1 : 0;
5521
5522         if (nt_time_is_zero(pass_must_change_time)) {
5523                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5524         } else {
5525                 usr->passmustchange=0;
5526         }
5527
5528         ZERO_STRUCT(usr->padding1);
5529         ZERO_STRUCT(usr->padding2);
5530
5531         usr->bad_password_count = bad_password_count;
5532         usr->logon_count = logon_count;
5533
5534         memcpy(usr->pass, newpass, sizeof(usr->pass));
5535
5536         init_unistr2(&usr->uni_user_name, user_name, UNI_FLAGS_NONE);
5537         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5538
5539         init_unistr2(&usr->uni_full_name, full_name, UNI_FLAGS_NONE);
5540         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5541
5542         init_unistr2(&usr->uni_home_dir, home_dir, UNI_FLAGS_NONE);
5543         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5544
5545         init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_FLAGS_NONE);
5546         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5547
5548         init_unistr2(&usr->uni_logon_script, log_scr, UNI_FLAGS_NONE);
5549         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5550
5551         init_unistr2(&usr->uni_profile_path, prof_path, UNI_FLAGS_NONE);
5552         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5553
5554         init_unistr2(&usr->uni_acct_desc, desc, UNI_FLAGS_NONE);
5555         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5556
5557         init_unistr2(&usr->uni_workstations, wkstas, UNI_FLAGS_NONE);
5558         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5559
5560         init_unistr2(&usr->uni_unknown_str, unk_str, UNI_FLAGS_NONE);
5561         init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
5562
5563         init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
5564         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5565
5566         data_blob_free(&blob);
5567
5568         memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5569 }
5570
5571 /*******************************************************************
5572 reads or writes a structure.
5573 ********************************************************************/
5574
5575 static BOOL sam_io_user_info23(const char *desc, SAM_USER_INFO_23 * usr,
5576                                prs_struct *ps, int depth)
5577 {
5578         if (usr == NULL)
5579                 return False;
5580
5581         prs_debug(ps, depth, desc, "sam_io_user_info23");
5582         depth++;
5583
5584         if(!prs_align(ps))
5585                 return False;
5586
5587         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
5588                 return False;
5589         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
5590                 return False;
5591         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
5592                 return False;
5593         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps, depth))
5594                 return False;
5595         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
5596                 return False;
5597         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
5598                 return False;
5599
5600         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth))  /* username unicode string header */
5601                 return False;
5602         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth))  /* user's full name unicode string header */
5603                 return False;
5604         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth))   /* home directory unicode string header */
5605                 return False;
5606         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth))  /* home directory drive */
5607                 return False;
5608         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth))       /* logon script unicode string header */
5609                 return False;
5610         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth))       /* profile path unicode string header */
5611                 return False;
5612         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth))  /* account desc */
5613                 return False;
5614         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth))       /* wkstas user can log on from */
5615                 return False;
5616         if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth))        /* unknown string */
5617                 return False;
5618         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
5619                 return False;
5620
5621         if(!prs_uint8s(False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
5622                 return False;
5623         if(!prs_uint8s(False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
5624                 return False;
5625
5626         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))    /* User ID */
5627                 return False;
5628         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))   /* Group ID */
5629                 return False;
5630         if(!prs_uint32("acb_info      ", ps, depth, &usr->acb_info))
5631                 return False;
5632
5633         if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
5634                 return False;
5635         if(!prs_uint16("logon_divs    ", ps, depth, &usr->logon_divs))  /* logon divisions per week */
5636                 return False;
5637         if(!prs_align(ps))
5638                 return False;
5639         if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
5640                 return False;
5641
5642         if(!prs_uint16("bad_password_count     ", ps, depth, &usr->bad_password_count))
5643                 return False;
5644         if(!prs_uint16("logon_count     ", ps, depth, &usr->logon_count))
5645                 return False;
5646
5647         if(!prs_uint8s(False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1)))
5648                 return False;
5649         if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
5650                 return False;
5651         if(!prs_uint8("padding2       ", ps, depth, &usr->padding2))
5652                 return False;
5653
5654
5655         if(!prs_uint8s(False, "password      ", ps, depth, usr->pass, sizeof(usr->pass)))
5656                 return False;
5657
5658         /* here begins pointed-to data */
5659
5660         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth))      /* username unicode string */
5661                 return False;
5662
5663         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))      /* user's full name unicode string */
5664                 return False;
5665
5666         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))        /* home directory unicode string */
5667                 return False;
5668
5669         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))      /* home directory drive unicode string */
5670                 return False;
5671
5672         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))        /* logon script unicode string */
5673                 return False;
5674
5675         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))        /* profile path unicode string */
5676                 return False;
5677
5678         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))      /* user desc unicode string */
5679                 return False;
5680
5681         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))        /* worksations user can log on from */
5682                 return False;
5683
5684         if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str.buffer, ps, depth))  /* unknown string */
5685                 return False;
5686
5687         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
5688                 return False;
5689
5690         /* ok, this is only guess-work (as usual) */
5691         if (usr->ptr_logon_hrs) {
5692                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
5693                         return False;
5694         }
5695
5696         return True;
5697 }
5698
5699 /*******************************************************************
5700  reads or writes a structure.
5701  NB. This structure is *definately* incorrect. It's my best guess
5702  currently for W2K SP2. The password field is encrypted in a different
5703  way than normal... And there are definately other problems. JRA.
5704 ********************************************************************/
5705
5706 static BOOL sam_io_user_info25(const char *desc, SAM_USER_INFO_25 * usr, prs_struct *ps, int depth)
5707 {
5708         if (usr == NULL)
5709                 return False;
5710
5711         prs_debug(ps, depth, desc, "sam_io_user_info25");
5712         depth++;
5713
5714         if(!prs_align(ps))
5715                 return False;
5716
5717         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
5718                 return False;
5719         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
5720                 return False;
5721         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
5722                 return False;
5723         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps, depth))
5724                 return False;
5725         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
5726                 return False;
5727         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
5728                 return False;
5729
5730         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth))  /* username unicode string header */
5731                 return False;
5732         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth))  /* user's full name unicode string header */
5733                 return False;
5734         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth))   /* home directory unicode string header */
5735                 return False;
5736         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth))  /* home directory drive */
5737                 return False;
5738         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth))       /* logon script unicode string header */
5739                 return False;
5740         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth))       /* profile path unicode string header */
5741                 return False;
5742         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth))  /* account desc */
5743                 return False;
5744         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth))       /* wkstas user can log on from */
5745                 return False;
5746         if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth))        /* unknown string */
5747                 return False;
5748         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
5749                 return False;
5750
5751         if(!prs_uint8s(False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
5752                 return False;
5753         if(!prs_uint8s(False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
5754                 return False;
5755
5756         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))    /* User ID */
5757                 return False;
5758         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))   /* Group ID */
5759                 return False;
5760         if(!prs_uint32("acb_info      ", ps, depth, &usr->acb_info))
5761                 return False;
5762
5763         if(!prs_uint32s(False, "unknown_6      ", ps, depth, usr->unknown_6, 6))
5764                 return False;
5765
5766         if(!prs_uint8s(False, "password      ", ps, depth, usr->pass, sizeof(usr->pass)))
5767                 return False;
5768
5769         /* here begins pointed-to data */
5770
5771         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth))      /* username unicode string */
5772                 return False;
5773
5774         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))      /* user's full name unicode string */
5775                 return False;
5776
5777         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))        /* home directory unicode string */
5778                 return False;
5779
5780         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))      /* home directory drive unicode string */
5781                 return False;
5782
5783         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))        /* logon script unicode string */
5784                 return False;
5785
5786         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))        /* profile path unicode string */
5787                 return False;
5788
5789         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))      /* user desc unicode string */
5790                 return False;
5791
5792         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))        /* worksations user can log on from */
5793                 return False;
5794
5795         if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str.buffer, ps, depth))  /* unknown string */
5796                 return False;
5797
5798         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
5799                 return False;
5800
5801 #if 0 /* JRA - unknown... */
5802         /* ok, this is only guess-work (as usual) */
5803         if (usr->ptr_logon_hrs) {
5804                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
5805                         return False;
5806         }
5807 #endif
5808
5809         return True;
5810 }
5811
5812
5813 /*************************************************************************
5814  init_sam_user_info21W
5815
5816  unknown_6 = 0x0000 04ec
5817
5818  *************************************************************************/
5819
5820 void init_sam_user_info21W(SAM_USER_INFO_21 * usr,
5821                            NTTIME * logon_time,
5822                            NTTIME * logoff_time,
5823                            NTTIME * kickoff_time,
5824                            NTTIME * pass_last_set_time,
5825                            NTTIME * pass_can_change_time,
5826                            NTTIME * pass_must_change_time,
5827                            UNISTR2 *user_name,
5828                            UNISTR2 *full_name,
5829                            UNISTR2 *home_dir,
5830                            UNISTR2 *dir_drive,
5831                            UNISTR2 *log_scr,
5832                            UNISTR2 *prof_path,
5833                            UNISTR2 *desc,
5834                            UNISTR2 *wkstas,
5835                            UNISTR2 *unk_str,
5836                            UNISTR2 *mung_dial,
5837                            uchar lm_pwd[16],
5838                            uchar nt_pwd[16],
5839                            uint32 user_rid,
5840                            uint32 group_rid,
5841                            uint32 acb_info,
5842                            uint32 fields_present,
5843                            uint16 logon_divs,
5844                            LOGON_HRS * hrs,
5845                            uint16 bad_password_count,
5846                            uint16 logon_count)
5847 {
5848         usr->logon_time = *logon_time;
5849         usr->logoff_time = *logoff_time;
5850         usr->kickoff_time = *kickoff_time;
5851         usr->pass_last_set_time = *pass_last_set_time;
5852         usr->pass_can_change_time = *pass_can_change_time;
5853         usr->pass_must_change_time = *pass_must_change_time;
5854
5855         memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd));
5856         memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd));
5857
5858         usr->user_rid = user_rid;
5859         usr->group_rid = group_rid;
5860         usr->acb_info = acb_info;
5861         usr->fields_present = fields_present;   /* 0x00ff ffff */
5862
5863         usr->logon_divs = logon_divs;   /* should be 168 (hours/week) */
5864         usr->ptr_logon_hrs = hrs ? 1 : 0;
5865         usr->bad_password_count = bad_password_count;
5866         usr->logon_count = logon_count;
5867
5868         if (nt_time_is_zero(pass_must_change_time)) {
5869                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5870         } else {
5871                 usr->passmustchange=0;
5872         }
5873
5874         ZERO_STRUCT(usr->padding1);
5875         ZERO_STRUCT(usr->padding2);
5876
5877         copy_unistr2(&usr->uni_user_name, user_name);
5878         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5879
5880         copy_unistr2(&usr->uni_full_name, full_name);
5881         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5882
5883         copy_unistr2(&usr->uni_home_dir, home_dir);
5884         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5885
5886         copy_unistr2(&usr->uni_dir_drive, dir_drive);
5887         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5888
5889         copy_unistr2(&usr->uni_logon_script, log_scr);
5890         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5891
5892         copy_unistr2(&usr->uni_profile_path, prof_path);
5893         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5894
5895         copy_unistr2(&usr->uni_acct_desc, desc);
5896         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5897
5898         copy_unistr2(&usr->uni_workstations, wkstas);
5899         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5900
5901         copy_unistr2(&usr->uni_unknown_str, unk_str);
5902         init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
5903
5904         copy_unistr2(&usr->uni_munged_dial, mung_dial);
5905         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5906
5907         memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5908 }
5909
5910 /*************************************************************************
5911  init_sam_user_info21
5912
5913  unknown_6 = 0x0000 04ec
5914
5915  *************************************************************************/
5916
5917 NTSTATUS init_sam_user_info21A(SAM_USER_INFO_21 *usr, SAM_ACCOUNT *pw, DOM_SID *domain_sid)
5918 {
5919         NTTIME          logon_time, logoff_time, kickoff_time,
5920                         pass_last_set_time, pass_can_change_time,
5921                         pass_must_change_time;
5922
5923         const char*             user_name = pdb_get_username(pw);
5924         const char*             full_name = pdb_get_fullname(pw);
5925         const char*             home_dir  = pdb_get_homedir(pw);
5926         const char*             dir_drive = pdb_get_dir_drive(pw);
5927         const char*             logon_script = pdb_get_logon_script(pw);
5928         const char*             profile_path = pdb_get_profile_path(pw);
5929         const char*             description = pdb_get_acct_desc(pw);
5930         const char*             workstations = pdb_get_workstations(pw);
5931         const char*             munged_dial = pdb_get_munged_dial(pw);
5932         DATA_BLOB               munged_dial_blob;
5933
5934         uint32 user_rid;
5935         const DOM_SID *user_sid;
5936
5937         uint32 group_rid;
5938         const DOM_SID *group_sid;
5939
5940         if (munged_dial) {
5941                 munged_dial_blob = base64_decode_data_blob(munged_dial);
5942         } else {
5943                 munged_dial_blob = data_blob(NULL, 0);
5944         }
5945
5946         /* Create NTTIME structs */
5947         unix_to_nt_time (&logon_time,           pdb_get_logon_time(pw));
5948         unix_to_nt_time (&logoff_time,          pdb_get_logoff_time(pw));
5949         unix_to_nt_time (&kickoff_time,         pdb_get_kickoff_time(pw));
5950         unix_to_nt_time (&pass_last_set_time,   pdb_get_pass_last_set_time(pw));
5951         unix_to_nt_time (&pass_can_change_time, pdb_get_pass_can_change_time(pw));
5952         unix_to_nt_time (&pass_must_change_time,pdb_get_pass_must_change_time(pw));
5953
5954         /* structure assignment */
5955         usr->logon_time            = logon_time;
5956         usr->logoff_time           = logoff_time;
5957         usr->kickoff_time          = kickoff_time;
5958         usr->pass_last_set_time    = pass_last_set_time;
5959         usr->pass_can_change_time  = pass_can_change_time;
5960         usr->pass_must_change_time = pass_must_change_time;
5961
5962         ZERO_STRUCT(usr->nt_pwd);
5963         ZERO_STRUCT(usr->lm_pwd);
5964
5965         user_sid = pdb_get_user_sid(pw);
5966
5967         if (!sid_peek_check_rid(domain_sid, user_sid, &user_rid)) {
5968                 fstring user_sid_string;
5969                 fstring domain_sid_string;
5970                 DEBUG(0, ("init_sam_user_info_21A: User %s has SID %s, \nwhich conflicts with "
5971                           "the domain sid %s.  Failing operation.\n",
5972                           user_name,
5973                           sid_to_string(user_sid_string, user_sid),
5974                           sid_to_string(domain_sid_string, domain_sid)));
5975                 data_blob_free(&munged_dial_blob);
5976                 return NT_STATUS_UNSUCCESSFUL;
5977         }
5978
5979         group_sid = pdb_get_group_sid(pw);
5980
5981         if (!sid_peek_check_rid(domain_sid, group_sid, &group_rid)) {
5982                 fstring group_sid_string;
5983                 fstring domain_sid_string;
5984                 DEBUG(0, ("init_sam_user_info_21A: User %s has Primary Group SID %s, \n"
5985                           "which conflicts with the domain sid %s.  Failing operation.\n",
5986                           user_name,
5987                           sid_to_string(group_sid_string, group_sid),
5988                           sid_to_string(domain_sid_string, domain_sid)));
5989                 data_blob_free(&munged_dial_blob);
5990                 return NT_STATUS_UNSUCCESSFUL;
5991         }
5992
5993         usr->user_rid  = user_rid;
5994         usr->group_rid = group_rid;
5995         usr->acb_info  = pdb_get_acct_ctrl(pw);
5996
5997         /*
5998           Look at a user on a real NT4 PDC with usrmgr, press
5999           'ok'. Then you will see that fields_present is set to
6000           0x08f827fa. Look at the user immediately after that again,
6001           and you will see that 0x00fffff is returned. This solves
6002           the problem that you get access denied after having looked
6003           at the user.
6004           -- Volker
6005         */
6006         usr->fields_present = pdb_build_fields_present(pw);
6007
6008         usr->logon_divs = pdb_get_logon_divs(pw);
6009         usr->ptr_logon_hrs = pdb_get_hours(pw) ? 1 : 0;
6010         usr->bad_password_count = pdb_get_bad_password_count(pw);
6011         usr->logon_count = pdb_get_logon_count(pw);
6012
6013         if (pdb_get_pass_must_change_time(pw) == 0) {
6014                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6015         } else {
6016                 usr->passmustchange=0;
6017         }
6018
6019         ZERO_STRUCT(usr->padding1);
6020         ZERO_STRUCT(usr->padding2);
6021
6022         init_unistr2(&usr->uni_user_name, user_name, UNI_STR_TERMINATE);
6023         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6024
6025         init_unistr2(&usr->uni_full_name, full_name, UNI_STR_TERMINATE);
6026         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6027
6028         init_unistr2(&usr->uni_home_dir, home_dir, UNI_STR_TERMINATE);
6029         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6030
6031         init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_STR_TERMINATE);
6032         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6033
6034         init_unistr2(&usr->uni_logon_script, logon_script, UNI_STR_TERMINATE);
6035         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6036
6037         init_unistr2(&usr->uni_profile_path, profile_path, UNI_STR_TERMINATE);
6038         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6039
6040         init_unistr2(&usr->uni_acct_desc, description, UNI_STR_TERMINATE);
6041         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6042
6043         init_unistr2(&usr->uni_workstations, workstations, UNI_STR_TERMINATE);
6044         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6045
6046         init_unistr2(&usr->uni_unknown_str, NULL, UNI_STR_TERMINATE);
6047         init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
6048
6049         init_unistr2_from_datablob(&usr->uni_munged_dial, &munged_dial_blob);
6050         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6051         data_blob_free(&munged_dial_blob);
6052
6053         if (pdb_get_hours(pw)) {
6054                 usr->logon_hrs.max_len = 1260;
6055                 usr->logon_hrs.offset = 0;
6056                 usr->logon_hrs.len = pdb_get_hours_len(pw);
6057                 memcpy(&usr->logon_hrs.hours, pdb_get_hours(pw), MAX_HOURS_LEN);
6058         } else {
6059                 usr->logon_hrs.max_len = 1260;
6060                 usr->logon_hrs.offset = 0;
6061                 usr->logon_hrs.len = 0;
6062                 memset(&usr->logon_hrs, 0xff, sizeof(usr->logon_hrs));
6063         }
6064
6065         return NT_STATUS_OK;
6066 }
6067
6068 /*******************************************************************
6069 reads or writes a structure.
6070 ********************************************************************/
6071
6072 static BOOL sam_io_user_info21(const char *desc, SAM_USER_INFO_21 * usr,
6073                         prs_struct *ps, int depth)
6074 {
6075         if (usr == NULL)
6076                 return False;
6077
6078         prs_debug(ps, depth, desc, "sam_io_user_info21");
6079         depth++;
6080
6081         if(!prs_align(ps))
6082                 return False;
6083
6084         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
6085                 return False;
6086         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
6087                 return False;
6088         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps,depth))
6089                 return False;
6090         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
6091                 return False;
6092         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps,depth))
6093                 return False;
6094         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time,  ps, depth))
6095                 return False;
6096
6097         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth))  /* username unicode string header */
6098                 return False;
6099         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth))  /* user's full name unicode string header */
6100                 return False;
6101         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth))   /* home directory unicode string header */
6102                 return False;
6103         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth))  /* home directory drive */
6104                 return False;
6105         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth))       /* logon script unicode string header */
6106                 return False;
6107         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth))       /* profile path unicode string header */
6108                 return False;
6109         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth))  /* account desc */
6110                 return False;
6111         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth))       /* wkstas user can log on from */
6112                 return False;
6113         if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth))        /* unknown string */
6114                 return False;
6115         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
6116                 return False;
6117
6118         if(!prs_uint8s(False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6119                 return False;
6120         if(!prs_uint8s(False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6121                 return False;
6122
6123         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))    /* User ID */
6124                 return False;
6125         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))   /* Group ID */
6126                 return False;
6127         if(!prs_uint32("acb_info      ", ps, depth, &usr->acb_info))
6128                 return False;
6129
6130         if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6131                 return False;
6132         if(!prs_uint16("logon_divs    ", ps, depth, &usr->logon_divs))  /* logon divisions per week */
6133                 return False;
6134         if(!prs_align(ps))
6135                 return False;
6136         if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6137                 return False;
6138
6139         if(!prs_uint16("bad_password_count     ", ps, depth, &usr->bad_password_count))
6140                 return False;
6141         if(!prs_uint16("logon_count     ", ps, depth, &usr->logon_count))
6142                 return False;
6143
6144         if(!prs_uint8s(False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6145                 return False;
6146         if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6147                 return False;
6148         if(!prs_uint8("padding2       ", ps, depth, &usr->padding2))
6149                 return False;
6150
6151         /* here begins pointed-to data */
6152
6153         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name,usr->hdr_user_name.buffer, ps, depth))       /* username unicode string */
6154                 return False;
6155         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))      /* user's full name unicode string */
6156                 return False;
6157         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))        /* home directory unicode string */
6158                 return False;
6159         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))      /* home directory drive unicode string */
6160                 return False;
6161         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))        /* logon script unicode string */
6162                 return False;
6163         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))        /* profile path unicode string */
6164                 return False;
6165         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))      /* user desc unicode string */
6166                 return False;
6167         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))        /* worksations user can log on from */
6168                 return False;
6169         if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str.buffer, ps, depth))  /* unknown string */
6170                 return False;
6171         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))   /* worksations user can log on from */
6172                 return False;
6173
6174         /* ok, this is only guess-work (as usual) */
6175         if (usr->ptr_logon_hrs) {
6176                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6177                         return False;
6178         }
6179
6180         return True;
6181 }
6182
6183 void init_sam_user_info20A(SAM_USER_INFO_20 *usr, SAM_ACCOUNT *pw)
6184 {
6185         const char *munged_dial = pdb_get_munged_dial(pw);
6186         DATA_BLOB blob = base64_decode_data_blob(munged_dial);
6187
6188         init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
6189         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6190         data_blob_free(&blob);
6191 }
6192
6193 /*******************************************************************
6194 reads or writes a structure.
6195 ********************************************************************/
6196
6197 static BOOL sam_io_user_info20(const char *desc, SAM_USER_INFO_20 *usr,
6198                         prs_struct *ps, int depth)
6199 {
6200         if (usr == NULL)
6201                 return False;
6202
6203         prs_debug(ps, depth, desc, "sam_io_user_info20");
6204         depth++;
6205
6206         if(!prs_align(ps))
6207                 return False;
6208
6209         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
6210                 return False;
6211
6212         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))   /* worksations user can log on from */
6213                 return False;
6214
6215         return True;
6216 }
6217
6218 /*******************************************************************
6219 inits a SAM_USERINFO_CTR structure.
6220 ********************************************************************/
6221
6222 NTSTATUS make_samr_userinfo_ctr_usr21(TALLOC_CTX *ctx, SAM_USERINFO_CTR * ctr,
6223                                     uint16 switch_value,
6224                                     SAM_USER_INFO_21 * usr)
6225 {
6226         DEBUG(5, ("make_samr_userinfo_ctr_usr21\n"));
6227
6228         ctr->switch_value = switch_value;
6229         ctr->info.id = NULL;
6230
6231         switch (switch_value) {
6232         case 16:
6233                 ctr->info.id16 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_16);
6234                 if (ctr->info.id16 == NULL)
6235                         return NT_STATUS_NO_MEMORY;
6236
6237                 init_sam_user_info16(ctr->info.id16, usr->acb_info);
6238                 break;
6239 #if 0
6240 /* whoops - got this wrong.  i think.  or don't understand what's happening. */
6241         case 17:
6242                 {
6243                         NTTIME expire;
6244                         info = (void *)&id11;
6245
6246                         expire.low = 0xffffffff;
6247                         expire.high = 0x7fffffff;
6248
6249                         ctr->info.id = TALLOC_ZERO_P(ctx,SAM_USER_INFO_17);
6250                         init_sam_user_info11(ctr->info.id17, &expire,
6251                                              "BROOKFIELDS$",    /* name */
6252                                              0x03ef,    /* user rid */
6253                                              0x201,     /* group rid */
6254                                              0x0080);   /* acb info */
6255
6256                         break;
6257                 }
6258 #endif
6259         case 18:
6260                 ctr->info.id18 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_18);
6261                 if (ctr->info.id18 == NULL)
6262                         return NT_STATUS_NO_MEMORY;
6263
6264                 init_sam_user_info18(ctr->info.id18, usr->lm_pwd, usr->nt_pwd);
6265                 break;
6266         case 21:
6267                 {
6268                         SAM_USER_INFO_21 *cusr;
6269                         cusr = TALLOC_ZERO_P(ctx,SAM_USER_INFO_21);
6270                         ctr->info.id21 = cusr;
6271                         if (ctr->info.id21 == NULL)
6272                                 return NT_STATUS_NO_MEMORY;
6273                         memcpy(cusr, usr, sizeof(*usr));
6274                         memset(cusr->lm_pwd, 0, sizeof(cusr->lm_pwd));
6275                         memset(cusr->nt_pwd, 0, sizeof(cusr->nt_pwd));
6276                         break;
6277                 }
6278         default:
6279                 DEBUG(4,("make_samr_userinfo_ctr: unsupported info\n"));
6280                 return NT_STATUS_INVALID_INFO_CLASS;
6281         }
6282
6283         return NT_STATUS_OK;
6284 }
6285
6286 /*******************************************************************
6287 inits a SAM_USERINFO_CTR structure.
6288 ********************************************************************/
6289
6290 static void init_samr_userinfo_ctr(SAM_USERINFO_CTR * ctr, DATA_BLOB *sess_key,
6291                                    uint16 switch_value, void *info)
6292 {
6293         DEBUG(5, ("init_samr_userinfo_ctr\n"));
6294
6295         ctr->switch_value = switch_value;
6296         ctr->info.id = info;
6297
6298         switch (switch_value) {
6299         case 0x18:
6300                 SamOEMhashBlob(ctr->info.id24->pass, 516, sess_key);
6301                 dump_data(100, (char *)sess_key->data, sess_key->length);
6302                 dump_data(100, (char *)ctr->info.id24->pass, 516);
6303                 break;
6304         case 0x17:
6305                 SamOEMhashBlob(ctr->info.id23->pass, 516, sess_key);
6306                 dump_data(100, (char *)sess_key->data, sess_key->length);
6307                 dump_data(100, (char *)ctr->info.id23->pass, 516);
6308                 break;
6309         case 0x07:
6310                 break;
6311         default:
6312                 DEBUG(4,("init_samr_userinfo_ctr: unsupported switch level: %d\n", switch_value));
6313         }
6314 }
6315
6316 /*******************************************************************
6317 reads or writes a structure.
6318 ********************************************************************/
6319
6320 static BOOL samr_io_userinfo_ctr(const char *desc, SAM_USERINFO_CTR **ppctr,
6321                                  prs_struct *ps, int depth)
6322 {
6323         BOOL ret;
6324         SAM_USERINFO_CTR *ctr;
6325
6326         prs_debug(ps, depth, desc, "samr_io_userinfo_ctr");
6327         depth++;
6328
6329         if (UNMARSHALLING(ps)) {
6330                 ctr = PRS_ALLOC_MEM(ps,SAM_USERINFO_CTR,1);
6331                 if (ctr == NULL)
6332                         return False;
6333                 *ppctr = ctr;
6334         } else {
6335                 ctr = *ppctr;
6336         }
6337
6338         /* lkclXXXX DO NOT ALIGN BEFORE READING SWITCH VALUE! */
6339
6340         if(!prs_uint16("switch_value", ps, depth, &ctr->switch_value))
6341                 return False;
6342         if(!prs_align(ps))
6343                 return False;
6344
6345         ret = False;
6346
6347         switch (ctr->switch_value) {
6348         case 7:
6349                 if (UNMARSHALLING(ps))
6350                         ctr->info.id7 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_7,1);
6351                 if (ctr->info.id7 == NULL) {
6352                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6353                         return False;
6354                 }
6355                 ret = sam_io_user_info7("", ctr->info.id7, ps, depth);
6356                 break;
6357         case 16:
6358                 if (UNMARSHALLING(ps))
6359                         ctr->info.id16 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_16,1);
6360                 if (ctr->info.id16 == NULL) {
6361                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6362                         return False;
6363                 }
6364                 ret = sam_io_user_info16("", ctr->info.id16, ps, depth);
6365                 break;
6366         case 17:
6367                 if (UNMARSHALLING(ps))
6368                         ctr->info.id17 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_17,1);
6369
6370                 if (ctr->info.id17 == NULL) {
6371                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6372                         return False;
6373                 }
6374                 ret = sam_io_user_info17("", ctr->info.id17, ps, depth);
6375                 break;
6376         case 18:
6377                 if (UNMARSHALLING(ps))
6378                         ctr->info.id18 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_18,1);
6379
6380                 if (ctr->info.id18 == NULL) {
6381                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6382                         return False;
6383                 }
6384                 ret = sam_io_user_info18("", ctr->info.id18, ps, depth);
6385                 break;
6386         case 20:
6387                 if (UNMARSHALLING(ps))
6388                         ctr->info.id20 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_20,1);
6389
6390                 if (ctr->info.id20 == NULL) {
6391                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6392                         return False;
6393                 }
6394                 ret = sam_io_user_info20("", ctr->info.id20, ps, depth);
6395                 break;
6396         case 21:
6397                 if (UNMARSHALLING(ps))
6398                         ctr->info.id21 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_21,1);
6399
6400                 if (ctr->info.id21 == NULL) {
6401                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6402                         return False;
6403                 }
6404                 ret = sam_io_user_info21("", ctr->info.id21, ps, depth);
6405                 break;
6406         case 23:
6407                 if (UNMARSHALLING(ps))
6408                         ctr->info.id23 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_23,1);
6409
6410                 if (ctr->info.id23 == NULL) {
6411                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6412                         return False;
6413                 }
6414                 ret = sam_io_user_info23("", ctr->info.id23, ps, depth);
6415                 break;
6416         case 24:
6417                 if (UNMARSHALLING(ps))
6418                         ctr->info.id24 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_24,1);
6419
6420                 if (ctr->info.id24 == NULL) {
6421                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6422                         return False;
6423                 }
6424                 ret = sam_io_user_info24("", ctr->info.id24, ps,  depth);
6425                 break;
6426         case 25:
6427                 if (UNMARSHALLING(ps))
6428                         ctr->info.id25 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_25,1);
6429
6430                 if (ctr->info.id25 == NULL) {
6431                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6432                         return False;
6433                 }
6434                 ret = sam_io_user_info25("", ctr->info.id25, ps, depth);
6435                 break;
6436         default:
6437                 DEBUG(2, ("samr_io_userinfo_ctr: unknown switch level 0x%x\n", ctr->switch_value));
6438                 ret = False;
6439                 break;
6440         }
6441
6442         return ret;
6443 }
6444
6445 /*******************************************************************
6446 inits a SAMR_R_QUERY_USERINFO structure.
6447 ********************************************************************/
6448
6449 void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO * r_u,
6450                                 SAM_USERINFO_CTR * ctr, NTSTATUS status)
6451 {
6452         DEBUG(5, ("init_samr_r_query_userinfo\n"));
6453
6454         r_u->ptr = 0;
6455         r_u->ctr = NULL;
6456
6457         if (NT_STATUS_IS_OK(status)) {
6458                 r_u->ptr = 1;
6459                 r_u->ctr = ctr;
6460         }
6461
6462         r_u->status = status;   /* return status */
6463 }
6464
6465 /*******************************************************************
6466 reads or writes a structure.
6467 ********************************************************************/
6468
6469 BOOL samr_io_r_query_userinfo(const char *desc, SAMR_R_QUERY_USERINFO * r_u,
6470                               prs_struct *ps, int depth)
6471 {
6472         if (r_u == NULL)
6473                 return False;
6474
6475         prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
6476         depth++;
6477
6478         if(!prs_align(ps))
6479                 return False;
6480
6481         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
6482                 return False;
6483
6484         if (r_u->ptr != 0) {
6485                 if(!samr_io_userinfo_ctr("ctr", &r_u->ctr, ps, depth))
6486                         return False;
6487         }
6488
6489         if(!prs_align(ps))
6490                 return False;
6491         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6492                 return False;
6493
6494         return True;
6495 }
6496
6497 /*******************************************************************
6498 inits a SAMR_Q_SET_USERINFO structure.
6499 ********************************************************************/
6500
6501 void init_samr_q_set_userinfo(SAMR_Q_SET_USERINFO * q_u,
6502                               POLICY_HND *hnd, DATA_BLOB *sess_key,
6503                               uint16 switch_value, void *info)
6504 {
6505         DEBUG(5, ("init_samr_q_set_userinfo\n"));
6506
6507         q_u->pol = *hnd;
6508         q_u->switch_value = switch_value;
6509         init_samr_userinfo_ctr(q_u->ctr, sess_key, switch_value, info);
6510 }
6511
6512 /*******************************************************************
6513 reads or writes a structure.
6514 ********************************************************************/
6515
6516 BOOL samr_io_q_set_userinfo(const char *desc, SAMR_Q_SET_USERINFO * q_u,
6517                             prs_struct *ps, int depth)
6518 {
6519         if (q_u == NULL)
6520                 return False;
6521
6522         prs_debug(ps, depth, desc, "samr_io_q_set_userinfo");
6523         depth++;
6524
6525         if(!prs_align(ps))
6526                 return False;
6527
6528         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
6529
6530         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6531                 return False;
6532         if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6533                 return False;
6534
6535         return True;
6536 }
6537
6538 /*******************************************************************
6539 inits a SAMR_R_SET_USERINFO structure.
6540 ********************************************************************/
6541
6542 void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO * r_u, NTSTATUS status)
6543 {
6544         DEBUG(5, ("init_samr_r_set_userinfo\n"));
6545
6546         r_u->status = status;   /* return status */
6547 }
6548
6549 /*******************************************************************
6550 reads or writes a structure.
6551 ********************************************************************/
6552
6553 BOOL samr_io_r_set_userinfo(const char *desc, SAMR_R_SET_USERINFO * r_u,
6554                             prs_struct *ps, int depth)
6555 {
6556         if (r_u == NULL)
6557                 return False;
6558
6559         prs_debug(ps, depth, desc, "samr_io_r_set_userinfo");
6560         depth++;
6561
6562         if(!prs_align(ps))
6563                 return False;
6564
6565         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6566                 return False;
6567
6568         return True;
6569 }
6570
6571 /*******************************************************************
6572 inits a SAMR_Q_SET_USERINFO2 structure.
6573 ********************************************************************/
6574
6575 void init_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2 * q_u,
6576                                POLICY_HND *hnd, DATA_BLOB *sess_key,
6577                                uint16 switch_value, SAM_USERINFO_CTR * ctr)
6578 {
6579         DEBUG(5, ("init_samr_q_set_userinfo2\n"));
6580
6581         q_u->pol = *hnd;
6582         q_u->switch_value = switch_value;
6583         q_u->ctr = ctr;
6584
6585         if (q_u->ctr != NULL)
6586                 q_u->ctr->switch_value = switch_value;
6587
6588         switch (switch_value) {
6589         case 18:
6590                 SamOEMhashBlob(ctr->info.id18->lm_pwd, 16, sess_key);
6591                 SamOEMhashBlob(ctr->info.id18->nt_pwd, 16, sess_key);
6592                 dump_data(100, (char *)sess_key->data, sess_key->length);
6593                 dump_data(100, (char *)ctr->info.id18->lm_pwd, 16);
6594                 dump_data(100, (char *)ctr->info.id18->nt_pwd, 16);
6595                 break;
6596         }
6597 }
6598
6599 /*******************************************************************
6600 reads or writes a structure.
6601 ********************************************************************/
6602
6603 BOOL samr_io_q_set_userinfo2(const char *desc, SAMR_Q_SET_USERINFO2 * q_u,
6604                              prs_struct *ps, int depth)
6605 {
6606         if (q_u == NULL)
6607                 return False;
6608
6609         prs_debug(ps, depth, desc, "samr_io_q_set_userinfo2");
6610         depth++;
6611
6612         if(!prs_align(ps))
6613                 return False;
6614
6615         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
6616                 return False;
6617
6618         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6619                 return False;
6620         if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6621                 return False;
6622
6623         return True;
6624 }
6625
6626 /*******************************************************************
6627 inits a SAMR_R_SET_USERINFO2 structure.
6628 ********************************************************************/
6629
6630 void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 * r_u, NTSTATUS status)
6631 {
6632         DEBUG(5, ("init_samr_r_set_userinfo2\n"));
6633
6634         r_u->status = status;   /* return status */
6635 }
6636
6637 /*******************************************************************
6638 reads or writes a structure.
6639 ********************************************************************/
6640
6641 BOOL samr_io_r_set_userinfo2(const char *desc, SAMR_R_SET_USERINFO2 * r_u,
6642                              prs_struct *ps, int depth)
6643 {
6644         if (r_u == NULL)
6645                 return False;
6646
6647         prs_debug(ps, depth, desc, "samr_io_r_set_userinfo2");
6648         depth++;
6649
6650         if(!prs_align(ps))
6651                 return False;
6652
6653         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6654                 return False;
6655
6656         return True;
6657 }
6658
6659 /*******************************************************************
6660 inits a SAMR_Q_CONNECT structure.
6661 ********************************************************************/
6662
6663 void init_samr_q_connect(SAMR_Q_CONNECT * q_u,
6664                          char *srv_name, uint32 access_mask)
6665 {
6666         DEBUG(5, ("init_samr_q_connect\n"));
6667
6668         /* make PDC server name \\server */
6669         q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
6670         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
6671
6672         /* example values: 0x0000 0002 */
6673         q_u->access_mask = access_mask;
6674 }
6675
6676 /*******************************************************************
6677 reads or writes a structure.
6678 ********************************************************************/
6679
6680 BOOL samr_io_q_connect(const char *desc, SAMR_Q_CONNECT * q_u,
6681                        prs_struct *ps, int depth)
6682 {
6683         if (q_u == NULL)
6684                 return False;
6685
6686         prs_debug(ps, depth, desc, "samr_io_q_connect");
6687         depth++;
6688
6689         if(!prs_align(ps))
6690                 return False;
6691
6692         if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
6693                 return False;
6694         if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
6695                 return False;
6696
6697         if(!prs_align(ps))
6698                 return False;
6699         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6700                 return False;
6701
6702         return True;
6703 }
6704
6705 /*******************************************************************
6706 reads or writes a structure.
6707 ********************************************************************/
6708
6709 BOOL samr_io_r_connect(const char *desc, SAMR_R_CONNECT * r_u,
6710                        prs_struct *ps, int depth)
6711 {
6712         if (r_u == NULL)
6713                 return False;
6714
6715         prs_debug(ps, depth, desc, "samr_io_r_connect");
6716         depth++;
6717
6718         if(!prs_align(ps))
6719                 return False;
6720
6721         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6722                 return False;
6723
6724         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6725                 return False;
6726
6727         return True;
6728 }
6729
6730 /*******************************************************************
6731 inits a SAMR_Q_CONNECT4 structure.
6732 ********************************************************************/
6733
6734 void init_samr_q_connect4(SAMR_Q_CONNECT4 * q_u,
6735                           char *srv_name, uint32 access_mask)
6736 {
6737         DEBUG(5, ("init_samr_q_connect\n"));
6738
6739         /* make PDC server name \\server */
6740         q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
6741         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
6742
6743         /* Only value we've seen, possibly an address type ? */
6744         q_u->unk_0 = 2;
6745
6746         /* example values: 0x0000 0002 */
6747         q_u->access_mask = access_mask;
6748 }
6749
6750 /*******************************************************************
6751 reads or writes a structure.
6752 ********************************************************************/
6753
6754 BOOL samr_io_q_connect4(const char *desc, SAMR_Q_CONNECT4 * q_u,
6755                         prs_struct *ps, int depth)
6756 {
6757         if (q_u == NULL)
6758                 return False;
6759
6760         prs_debug(ps, depth, desc, "samr_io_q_connect4");
6761         depth++;
6762
6763         if(!prs_align(ps))
6764                 return False;
6765
6766         if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
6767                 return False;
6768         if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
6769                 return False;
6770
6771         if(!prs_align(ps))
6772                 return False;
6773         if(!prs_uint32("unk_0", ps, depth, &q_u->unk_0))
6774                 return False;
6775         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6776                 return False;
6777
6778         return True;
6779 }
6780
6781 /*******************************************************************
6782 reads or writes a structure.
6783 ********************************************************************/
6784
6785 BOOL samr_io_r_connect4(const char *desc, SAMR_R_CONNECT4 * r_u,
6786                         prs_struct *ps, int depth)
6787 {
6788         if (r_u == NULL)
6789                 return False;
6790
6791         prs_debug(ps, depth, desc, "samr_io_r_connect4");
6792         depth++;
6793
6794         if(!prs_align(ps))
6795                 return False;
6796
6797         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6798                 return False;
6799
6800         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6801                 return False;
6802
6803         return True;
6804 }
6805
6806 /*******************************************************************
6807 inits a SAMR_Q_CONNECT_ANON structure.
6808 ********************************************************************/
6809
6810 void init_samr_q_connect_anon(SAMR_Q_CONNECT_ANON * q_u)
6811 {
6812         DEBUG(5, ("init_samr_q_connect_anon\n"));
6813
6814         q_u->ptr = 1;
6815         q_u->unknown_0 = 0x5c;  /* server name (?!!) */
6816         q_u->unknown_1 = 0x01;
6817         q_u->access_mask = 0x20;
6818 }
6819
6820 /*******************************************************************
6821 reads or writes a structure.
6822 ********************************************************************/
6823
6824 BOOL samr_io_q_connect_anon(const char *desc, SAMR_Q_CONNECT_ANON * q_u,
6825                             prs_struct *ps, int depth)
6826 {
6827         if (q_u == NULL)
6828                 return False;
6829
6830         prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
6831         depth++;
6832
6833         if(!prs_align(ps))
6834                 return False;
6835
6836         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
6837                 return False;
6838         if(!prs_uint16("unknown_0", ps, depth, &q_u->unknown_0))
6839                 return False;
6840         if(!prs_uint16("unknown_1", ps, depth, &q_u->unknown_1))
6841                 return False;
6842         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6843                 return False;
6844
6845         return True;
6846 }
6847
6848 /*******************************************************************
6849 reads or writes a structure.
6850 ********************************************************************/
6851
6852 BOOL samr_io_r_connect_anon(const char *desc, SAMR_R_CONNECT_ANON * r_u,
6853                             prs_struct *ps, int depth)
6854 {
6855         if (r_u == NULL)
6856                 return False;
6857
6858         prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
6859         depth++;
6860
6861         if(!prs_align(ps))
6862                 return False;
6863
6864         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6865                 return False;
6866
6867         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6868                 return False;
6869
6870         return True;
6871 }
6872
6873 /*******************************************************************
6874 inits a SAMR_Q_GET_DOM_PWINFO structure.
6875 ********************************************************************/
6876
6877 void init_samr_q_get_dom_pwinfo(SAMR_Q_GET_DOM_PWINFO * q_u,
6878                                 char *srv_name)
6879 {
6880         DEBUG(5, ("init_samr_q_get_dom_pwinfo\n"));
6881
6882         q_u->ptr = 1;
6883         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_FLAGS_NONE);
6884         init_uni_hdr(&q_u->hdr_srv_name, &q_u->uni_srv_name);
6885 }
6886
6887 /*******************************************************************
6888 reads or writes a structure.
6889 ********************************************************************/
6890
6891 BOOL samr_io_q_get_dom_pwinfo(const char *desc, SAMR_Q_GET_DOM_PWINFO * q_u,
6892                               prs_struct *ps, int depth)
6893 {
6894         if (q_u == NULL)
6895                 return False;
6896
6897         prs_debug(ps, depth, desc, "samr_io_q_get_dom_pwinfo");
6898         depth++;
6899
6900         if(!prs_align(ps))
6901                 return False;
6902
6903         if(!prs_uint32("ptr", ps, depth, &q_u->ptr))
6904                 return False;
6905         if (q_u->ptr != 0) {
6906                 if(!smb_io_unihdr("", &q_u->hdr_srv_name, ps, depth))
6907                         return False;
6908                 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->hdr_srv_name.buffer, ps, depth))
6909                         return False;
6910         }
6911
6912         return True;
6913 }
6914
6915 /*******************************************************************
6916 reads or writes a structure.
6917 ********************************************************************/
6918
6919 BOOL samr_io_r_get_dom_pwinfo(const char *desc, SAMR_R_GET_DOM_PWINFO * r_u,
6920                               prs_struct *ps, int depth)
6921 {
6922         if (r_u == NULL)
6923                 return False;
6924
6925         prs_debug(ps, depth, desc, "samr_io_r_get_dom_pwinfo");
6926         depth++;
6927
6928         if(!prs_align(ps))
6929                 return False;
6930
6931         /*
6932          * see the Samba4 IDL for what these actually are.
6933         */
6934
6935         if(!prs_uint16("unk_0", ps, depth, &r_u->unk_0))
6936                 return False;
6937         if(!prs_align(ps))
6938                 return False;
6939         if(!prs_uint32("unk_1", ps, depth, &r_u->unk_1))
6940                 return False;
6941
6942         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6943                 return False;
6944
6945         return True;
6946 }
6947
6948 /*******************************************************************
6949 make a SAMR_ENC_PASSWD structure.
6950 ********************************************************************/
6951
6952 void init_enc_passwd(SAMR_ENC_PASSWD * pwd, const char pass[512])
6953 {
6954         ZERO_STRUCTP(pwd);
6955
6956         if (pass == NULL) {
6957                 pwd->ptr = 0;
6958         } else {
6959                 pwd->ptr = 1;
6960                 memcpy(pwd->pass, pass, sizeof(pwd->pass));
6961         }
6962 }
6963
6964 /*******************************************************************
6965 reads or writes a SAMR_ENC_PASSWD structure.
6966 ********************************************************************/
6967
6968 BOOL samr_io_enc_passwd(const char *desc, SAMR_ENC_PASSWD * pwd,
6969                         prs_struct *ps, int depth)
6970 {
6971         if (pwd == NULL)
6972                 return False;
6973
6974         prs_debug(ps, depth, desc, "samr_io_enc_passwd");
6975         depth++;
6976
6977         if(!prs_align(ps))
6978                 return False;
6979
6980         if(!prs_uint32("ptr", ps, depth, &pwd->ptr))
6981                 return False;
6982
6983         if (pwd->ptr != 0) {
6984                 if(!prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass)))
6985                         return False;
6986         }
6987
6988         return True;
6989 }
6990
6991 /*******************************************************************
6992 inits a SAMR_ENC_HASH structure.
6993 ********************************************************************/
6994
6995 void init_enc_hash(SAMR_ENC_HASH * hsh, const uchar hash[16])
6996 {
6997         ZERO_STRUCTP(hsh);
6998
6999         if (hash == NULL) {
7000                 hsh->ptr = 0;
7001         } else {
7002                 hsh->ptr = 1;
7003                 memcpy(hsh->hash, hash, sizeof(hsh->hash));
7004         }
7005 }
7006
7007 /*******************************************************************
7008 reads or writes a SAMR_ENC_HASH structure.
7009 ********************************************************************/
7010
7011 BOOL samr_io_enc_hash(const char *desc, SAMR_ENC_HASH * hsh,
7012                       prs_struct *ps, int depth)
7013 {
7014         if (hsh == NULL)
7015                 return False;
7016
7017         prs_debug(ps, depth, desc, "samr_io_enc_hash");
7018         depth++;
7019
7020         if(!prs_align(ps))
7021                 return False;
7022
7023         if(!prs_uint32("ptr ", ps, depth, &hsh->ptr))
7024                 return False;
7025         if (hsh->ptr != 0) {
7026                 if(!prs_uint8s(False, "hash", ps, depth, hsh->hash,sizeof(hsh->hash)))
7027                         return False;
7028         }
7029
7030         return True;
7031 }
7032
7033 /*******************************************************************
7034 inits a SAMR_R_GET_DOM_PWINFO structure.
7035 ********************************************************************/
7036
7037 void init_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER * q_u,
7038                                 const char *dest_host, const char *user_name,
7039                                 const uchar nt_newpass[516],
7040                                 const uchar nt_oldhash[16],
7041                                 const uchar lm_newpass[516],
7042                                 const uchar lm_oldhash[16])
7043 {
7044         DEBUG(5, ("init_samr_q_chgpasswd_user\n"));
7045
7046         q_u->ptr_0 = 1;
7047         init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7048         init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7049
7050         init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7051         init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7052
7053         init_enc_passwd(&q_u->nt_newpass, nt_newpass);
7054         init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7055
7056         q_u->unknown = 0x01;
7057
7058         init_enc_passwd(&q_u->lm_newpass, lm_newpass);
7059         init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7060 }
7061
7062 /*******************************************************************
7063 reads or writes a structure.
7064 ********************************************************************/
7065
7066 BOOL samr_io_q_chgpasswd_user(const char *desc, SAMR_Q_CHGPASSWD_USER * q_u,
7067                               prs_struct *ps, int depth)
7068 {
7069         if (q_u == NULL)
7070                 return False;
7071
7072         prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
7073         depth++;
7074
7075         if(!prs_align(ps))
7076                 return False;
7077
7078         if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7079                 return False;
7080
7081         if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7082                 return False;
7083         if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7084                 return False;
7085
7086         if(!prs_align(ps))
7087                 return False;
7088         if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7089                 return False;
7090         if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7091                 return False;
7092
7093         if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7094                 return False;
7095         if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7096                 return False;
7097
7098         if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
7099                 return False;
7100
7101         if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7102                 return False;
7103         if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7104                 return False;
7105
7106         return True;
7107 }
7108
7109 /*******************************************************************
7110 inits a SAMR_R_CHGPASSWD_USER structure.
7111 ********************************************************************/
7112
7113 void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER * r_u, NTSTATUS status)
7114 {
7115         DEBUG(5, ("init_r_chgpasswd_user\n"));
7116
7117         r_u->status = status;
7118 }
7119
7120 /*******************************************************************
7121 reads or writes a structure.
7122 ********************************************************************/
7123
7124 BOOL samr_io_r_chgpasswd_user(const char *desc, SAMR_R_CHGPASSWD_USER * r_u,
7125                               prs_struct *ps, int depth)
7126 {
7127         if (r_u == NULL)
7128                 return False;
7129
7130         prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
7131         depth++;
7132
7133         if(!prs_align(ps))
7134                 return False;
7135
7136         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7137                 return False;
7138
7139         return True;
7140 }
7141
7142 /*******************************************************************
7143 reads or writes a structure.
7144 ********************************************************************/
7145
7146 void init_samr_q_unknown_2e(SAMR_Q_UNKNOWN_2E *q_u,
7147                                 POLICY_HND *domain_pol, uint16 switch_value)
7148 {
7149         DEBUG(5, ("init_samr_q_unknown_2e\n"));
7150
7151         q_u->domain_pol = *domain_pol;
7152         q_u->switch_value = switch_value;
7153 }
7154
7155 /*******************************************************************
7156 reads or writes a structure.
7157 ********************************************************************/
7158
7159 BOOL samr_io_q_unknown_2e(const char *desc, SAMR_Q_UNKNOWN_2E *q_u,
7160                               prs_struct *ps, int depth)
7161 {
7162         if (q_u == NULL)
7163                 return False;
7164
7165         prs_debug(ps, depth, desc, "samr_io_q_unknown_2e");
7166         depth++;
7167
7168         if(!prs_align(ps))
7169                 return False;
7170
7171         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7172                 return False;
7173
7174         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7175                 return False;
7176
7177         return True;
7178 }
7179
7180 /*******************************************************************
7181 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7182 ********************************************************************/
7183
7184 void init_samr_r_samr_unknown_2e(SAMR_R_UNKNOWN_2E * r_u,
7185                                 uint16 switch_value, SAM_UNK_CTR * ctr,
7186                                 NTSTATUS status)
7187 {
7188         DEBUG(5, ("init_samr_r_samr_unknown_2e\n"));
7189
7190         r_u->ptr_0 = 0;
7191         r_u->switch_value = 0;
7192         r_u->status = status;   /* return status */
7193
7194         if (NT_STATUS_IS_OK(status)) {
7195                 r_u->switch_value = switch_value;
7196                 r_u->ptr_0 = 1;
7197                 r_u->ctr = ctr;
7198         }
7199 }
7200
7201 /*******************************************************************
7202 reads or writes a structure.
7203 ********************************************************************/
7204
7205 BOOL samr_io_r_samr_unknown_2e(const char *desc, SAMR_R_UNKNOWN_2E * r_u,
7206                               prs_struct *ps, int depth)
7207 {
7208         if (r_u == NULL)
7209                 return False;
7210
7211         prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
7212         depth++;
7213
7214         if(!prs_align(ps))
7215                 return False;
7216
7217         if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
7218                 return False;
7219
7220         if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
7221                 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
7222                         return False;
7223                 if(!prs_align(ps))
7224                         return False;
7225
7226                 switch (r_u->switch_value) {
7227                 case 0x0c:
7228                         if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
7229                                 return False;
7230                         break;
7231                 case 0x07:
7232                         if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
7233                                 return False;
7234                         break;
7235                 case 0x06:
7236                         if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
7237                                 return False;
7238                         break;
7239                 case 0x05:
7240                         if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
7241                                 return False;
7242                         break;
7243                 case 0x03:
7244                         if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
7245                                 return False;
7246                         break;
7247                 case 0x02:
7248                         if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
7249                                 return False;
7250                         break;
7251                 case 0x01:
7252                         if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
7253                                 return False;
7254                         break;
7255                 default:
7256                         DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
7257                                 r_u->switch_value));
7258                         r_u->status = NT_STATUS_INVALID_INFO_CLASS;
7259                         return False;
7260                 }
7261         }
7262
7263         if(!prs_align(ps))
7264                 return False;
7265
7266         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7267                 return False;
7268
7269         return True;
7270 }
7271
7272
7273 /*******************************************************************
7274 reads or writes a structure.
7275 ********************************************************************/
7276
7277 void init_samr_q_set_domain_info(SAMR_Q_SET_DOMAIN_INFO *q_u,
7278                                 POLICY_HND *domain_pol, uint16 switch_value, SAM_UNK_CTR *ctr)
7279 {
7280         DEBUG(5, ("init_samr_q_set_domain_info\n"));
7281
7282         q_u->domain_pol = *domain_pol;
7283         q_u->switch_value0 = switch_value;
7284
7285         q_u->switch_value = switch_value;
7286         q_u->ctr = ctr;
7287
7288 }
7289
7290 /*******************************************************************
7291 reads or writes a structure.
7292 ********************************************************************/
7293
7294 BOOL samr_io_q_set_domain_info(const char *desc, SAMR_Q_SET_DOMAIN_INFO *q_u,
7295                               prs_struct *ps, int depth)
7296 {
7297         if (q_u == NULL)
7298                 return False;
7299
7300         prs_debug(ps, depth, desc, "samr_io_q_set_domain_info");
7301         depth++;
7302
7303         if(!prs_align(ps))
7304                 return False;
7305
7306         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7307                 return False;
7308
7309         if(!prs_uint16("switch_value0", ps, depth, &q_u->switch_value0))
7310                 return False;
7311
7312         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7313                 return False;
7314
7315         if(!prs_align(ps))
7316                 return False;
7317
7318         if ((q_u->ctr = PRS_ALLOC_MEM(ps, SAM_UNK_CTR, 1)) == NULL)
7319                 return False;
7320
7321         switch (q_u->switch_value) {
7322
7323         case 0x0c:
7324                 if(!sam_io_unk_info12("unk_inf12", &q_u->ctr->info.inf12, ps, depth))
7325                         return False;
7326                 break;
7327         case 0x07:
7328                 if(!sam_io_unk_info7("unk_inf7",&q_u->ctr->info.inf7, ps,depth))
7329                         return False;
7330                 break;
7331         case 0x06:
7332                 if(!sam_io_unk_info6("unk_inf6",&q_u->ctr->info.inf6, ps,depth))
7333                         return False;
7334                 break;
7335         case 0x05:
7336                 if(!sam_io_unk_info5("unk_inf5",&q_u->ctr->info.inf5, ps,depth))
7337                         return False;
7338                 break;
7339         case 0x03:
7340                 if(!sam_io_unk_info3("unk_inf3",&q_u->ctr->info.inf3, ps,depth))
7341                         return False;
7342                 break;
7343         case 0x02:
7344                 if(!sam_io_unk_info2("unk_inf2",&q_u->ctr->info.inf2, ps,depth))
7345                         return False;
7346                 break;
7347         case 0x01:
7348                 if(!sam_io_unk_info1("unk_inf1",&q_u->ctr->info.inf1, ps,depth))
7349                         return False;
7350                 break;
7351         default:
7352                 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
7353                         q_u->switch_value));
7354                 return False;
7355         }
7356
7357         return True;
7358 }
7359
7360 /*******************************************************************
7361 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7362 ********************************************************************/
7363
7364 void init_samr_r_set_domain_info(SAMR_R_SET_DOMAIN_INFO * r_u, NTSTATUS status)
7365 {
7366         DEBUG(5, ("init_samr_r_set_domain_info\n"));
7367
7368         r_u->status = status;   /* return status */
7369 }
7370
7371 /*******************************************************************
7372 reads or writes a structure.
7373 ********************************************************************/
7374
7375 BOOL samr_io_r_set_domain_info(const char *desc, SAMR_R_SET_DOMAIN_INFO * r_u,
7376                               prs_struct *ps, int depth)
7377 {
7378         if (r_u == NULL)
7379                 return False;
7380
7381         prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
7382         depth++;
7383
7384         if(!prs_align(ps))
7385                 return False;
7386
7387         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7388                 return False;
7389
7390         return True;
7391 }