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