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, char *acct_desc)
2275 {
2276         DEBUG(5, ("init_samr_group_info4\n"));
2277
2278         init_unistr2(&gr4->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2279         init_uni_hdr(&gr4->hdr_acct_desc, &gr4->uni_acct_desc);
2280 }
2281
2282 /*******************************************************************
2283 reads or writes a structure.
2284 ********************************************************************/
2285
2286 BOOL samr_io_group_info4(const char *desc, GROUP_INFO4 * gr4,
2287                          prs_struct *ps, int depth)
2288 {
2289         if (gr4 == NULL)
2290                 return False;
2291
2292         prs_debug(ps, depth, desc, "samr_io_group_info4");
2293         depth++;
2294
2295         if(!prs_align(ps))
2296                 return False;
2297
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, 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, 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, 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 = 0x001f000f;
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         usr->fields_present = pdb_build_fields_present(pw);
5998
5999         usr->logon_divs = pdb_get_logon_divs(pw);
6000         usr->ptr_logon_hrs = pdb_get_hours(pw) ? 1 : 0;
6001         usr->bad_password_count = pdb_get_bad_password_count(pw);
6002         usr->logon_count = pdb_get_logon_count(pw);
6003
6004         if (pdb_get_pass_must_change_time(pw) == 0) {
6005                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6006         } else {
6007                 usr->passmustchange=0;
6008         }
6009
6010         ZERO_STRUCT(usr->padding1);
6011         ZERO_STRUCT(usr->padding2);
6012
6013         init_unistr2(&usr->uni_user_name, user_name, UNI_STR_TERMINATE);
6014         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6015
6016         init_unistr2(&usr->uni_full_name, full_name, UNI_STR_TERMINATE);
6017         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6018
6019         init_unistr2(&usr->uni_home_dir, home_dir, UNI_STR_TERMINATE);
6020         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6021
6022         init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_STR_TERMINATE);
6023         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6024
6025         init_unistr2(&usr->uni_logon_script, logon_script, UNI_STR_TERMINATE);
6026         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6027
6028         init_unistr2(&usr->uni_profile_path, profile_path, UNI_STR_TERMINATE);
6029         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6030
6031         init_unistr2(&usr->uni_acct_desc, description, UNI_STR_TERMINATE);
6032         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6033
6034         init_unistr2(&usr->uni_workstations, workstations, UNI_STR_TERMINATE);
6035         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6036
6037         init_unistr2(&usr->uni_unknown_str, NULL, UNI_STR_TERMINATE);
6038         init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
6039
6040         init_unistr2_from_datablob(&usr->uni_munged_dial, &munged_dial_blob);
6041         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6042         data_blob_free(&munged_dial_blob);
6043
6044         usr->unknown_6 = pdb_get_unknown_6(pw);
6045         usr->padding4 = 0;
6046
6047         if (pdb_get_hours(pw)) {
6048                 usr->logon_hrs.len = pdb_get_hours_len(pw);
6049                 memcpy(&usr->logon_hrs.hours, pdb_get_hours(pw), MAX_HOURS_LEN);
6050         } else
6051                 memset(&usr->logon_hrs, 0xff, sizeof(usr->logon_hrs));
6052
6053         return NT_STATUS_OK;
6054 }
6055
6056 /*******************************************************************
6057 reads or writes a structure.
6058 ********************************************************************/
6059
6060 static BOOL sam_io_user_info21(const char *desc, SAM_USER_INFO_21 * usr,
6061                         prs_struct *ps, int depth)
6062 {
6063         if (usr == NULL)
6064                 return False;
6065
6066         prs_debug(ps, depth, desc, "sam_io_user_info21");
6067         depth++;
6068
6069         if(!prs_align(ps))
6070                 return False;
6071
6072         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
6073                 return False;
6074         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
6075                 return False;
6076         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps,depth))
6077                 return False;
6078         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
6079                 return False;
6080         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps,depth))
6081                 return False;
6082         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time,  ps, depth))
6083                 return False;
6084
6085         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth))  /* username unicode string header */
6086                 return False;
6087         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth))  /* user's full name unicode string header */
6088                 return False;
6089         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth))   /* home directory unicode string header */
6090                 return False;
6091         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth))  /* home directory drive */
6092                 return False;
6093         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth))       /* logon script unicode string header */
6094                 return False;
6095         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth))       /* profile path unicode string header */
6096                 return False;
6097         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth))  /* account desc */
6098                 return False;
6099         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth))       /* wkstas user can log on from */
6100                 return False;
6101         if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth))        /* unknown string */
6102                 return False;
6103         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
6104                 return False;
6105
6106         if(!prs_uint8s(False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6107                 return False;
6108         if(!prs_uint8s(False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6109                 return False;
6110
6111         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))    /* User ID */
6112                 return False;
6113         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))   /* Group ID */
6114                 return False;
6115         if(!prs_uint32("acb_info      ", ps, depth, &usr->acb_info))
6116                 return False;
6117
6118         if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6119                 return False;
6120         if(!prs_uint16("logon_divs    ", ps, depth, &usr->logon_divs))  /* logon divisions per week */
6121                 return False;
6122         if(!prs_align(ps))
6123                 return False;
6124         if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6125                 return False;
6126
6127         if(!prs_uint16("bad_password_count     ", ps, depth, &usr->bad_password_count))
6128                 return False;
6129         if(!prs_uint16("logon_count     ", ps, depth, &usr->logon_count))
6130                 return False;
6131
6132         if(!prs_uint8s(False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6133                 return False;
6134         if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6135                 return False;
6136         if(!prs_uint8("padding2       ", ps, depth, &usr->padding2))
6137                 return False;
6138
6139         /* here begins pointed-to data */
6140
6141         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name,usr->hdr_user_name.buffer, ps, depth))       /* username unicode string */
6142                 return False;
6143         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))      /* user's full name unicode string */
6144                 return False;
6145         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))        /* home directory unicode string */
6146                 return False;
6147         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))      /* home directory drive unicode string */
6148                 return False;
6149         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))        /* logon script unicode string */
6150                 return False;
6151         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))        /* profile path unicode string */
6152                 return False;
6153         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))      /* user desc unicode string */
6154                 return False;
6155         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))        /* worksations user can log on from */
6156                 return False;
6157         if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str.buffer, ps, depth))  /* unknown string */
6158                 return False;
6159         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))   /* worksations user can log on from */
6160                 return False;
6161
6162         /* ok, this is only guess-work (as usual) */
6163         if (usr->ptr_logon_hrs) {
6164                 if(!prs_align(ps))
6165                         return False;
6166                 if(!prs_uint32("unknown_6     ", ps, depth, &usr->unknown_6))
6167                         return False;
6168                 if(!prs_uint32("padding4      ", ps, depth, &usr->padding4))
6169                         return False;
6170                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6171                         return False;
6172         } else if (UNMARSHALLING(ps)) {
6173                 usr->unknown_6 = 0;
6174                 usr->padding4 = 0;
6175         }
6176
6177         return True;
6178 }
6179
6180 void init_sam_user_info20A(SAM_USER_INFO_20 *usr, SAM_ACCOUNT *pw)
6181 {
6182         const char *munged_dial = pdb_get_munged_dial(pw);
6183         DATA_BLOB blob = base64_decode_data_blob(munged_dial);
6184
6185         init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
6186         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6187         data_blob_free(&blob);
6188 }
6189
6190 /*******************************************************************
6191 reads or writes a structure.
6192 ********************************************************************/
6193
6194 static BOOL sam_io_user_info20(const char *desc, SAM_USER_INFO_20 *usr,
6195                         prs_struct *ps, int depth)
6196 {
6197         if (usr == NULL)
6198                 return False;
6199
6200         prs_debug(ps, depth, desc, "sam_io_user_info20");
6201         depth++;
6202
6203         if(!prs_align(ps))
6204                 return False;
6205
6206         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
6207                 return False;
6208
6209         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))   /* worksations user can log on from */
6210                 return False;
6211
6212         return True;
6213 }
6214
6215 /*******************************************************************
6216 inits a SAM_USERINFO_CTR structure.
6217 ********************************************************************/
6218
6219 NTSTATUS make_samr_userinfo_ctr_usr21(TALLOC_CTX *ctx, SAM_USERINFO_CTR * ctr,
6220                                     uint16 switch_value,
6221                                     SAM_USER_INFO_21 * usr)
6222 {
6223         DEBUG(5, ("init_samr_userinfo_ctr\n"));
6224
6225         ctr->switch_value = switch_value;
6226         ctr->info.id = NULL;
6227
6228         switch (switch_value) {
6229         case 0x10:
6230                 ctr->info.id10 = (SAM_USER_INFO_10 *)talloc_zero(ctx,sizeof(SAM_USER_INFO_10));
6231                 if (ctr->info.id10 == NULL)
6232                         return NT_STATUS_NO_MEMORY;
6233
6234                 init_sam_user_info10(ctr->info.id10, usr->acb_info);
6235                 break;
6236 #if 0
6237 /* whoops - got this wrong.  i think.  or don't understand what's happening. */
6238         case 0x11:
6239                 {
6240                         NTTIME expire;
6241                         info = (void *)&id11;
6242
6243                         expire.low = 0xffffffff;
6244                         expire.high = 0x7fffffff;
6245
6246                         ctr->info.id = (SAM_USER_INFO_11 *) talloc_zero(ctx,sizeof(*ctr->info.id11));
6247                         init_sam_user_info11(ctr->info.id11, &expire,
6248                                              "BROOKFIELDS$",    /* name */
6249                                              0x03ef,    /* user rid */
6250                                              0x201,     /* group rid */
6251                                              0x0080);   /* acb info */
6252
6253                         break;
6254                 }
6255 #endif
6256         case 0x12:
6257                 ctr->info.id12 = (SAM_USER_INFO_12 *)talloc_zero(ctx,sizeof(SAM_USER_INFO_12));
6258                 if (ctr->info.id12 == NULL)
6259                         return NT_STATUS_NO_MEMORY;
6260
6261                 init_sam_user_info12(ctr->info.id12, usr->lm_pwd, usr->nt_pwd);
6262                 break;
6263         case 21:
6264                 {
6265                         SAM_USER_INFO_21 *cusr;
6266                         cusr = (SAM_USER_INFO_21 *)talloc_zero(ctx,sizeof(SAM_USER_INFO_21));
6267                         ctr->info.id21 = cusr;
6268                         if (ctr->info.id21 == NULL)
6269                                 return NT_STATUS_NO_MEMORY;
6270                         memcpy(cusr, usr, sizeof(*usr));
6271                         memset(cusr->lm_pwd, 0, sizeof(cusr->lm_pwd));
6272                         memset(cusr->nt_pwd, 0, sizeof(cusr->nt_pwd));
6273                         break;
6274                 }
6275         default:
6276                 DEBUG(4,("make_samr_userinfo_ctr: unsupported info\n"));
6277                 return NT_STATUS_INVALID_INFO_CLASS;
6278         }
6279
6280         return NT_STATUS_OK;
6281 }
6282
6283 /*******************************************************************
6284 inits a SAM_USERINFO_CTR structure.
6285 ********************************************************************/
6286
6287 static void init_samr_userinfo_ctr(SAM_USERINFO_CTR * ctr, DATA_BLOB *sess_key,
6288                                    uint16 switch_value, void *info)
6289 {
6290         DEBUG(5, ("init_samr_userinfo_ctr\n"));
6291
6292         ctr->switch_value = switch_value;
6293         ctr->info.id = info;
6294
6295         switch (switch_value) {
6296         case 0x18:
6297                 SamOEMhashBlob(ctr->info.id24->pass, 516, sess_key);
6298                 dump_data(100, (char *)sess_key->data, sess_key->length);
6299                 dump_data(100, (char *)ctr->info.id24->pass, 516);
6300                 break;
6301         case 0x17:
6302                 SamOEMhashBlob(ctr->info.id23->pass, 516, sess_key);
6303                 dump_data(100, (char *)sess_key->data, sess_key->length);
6304                 dump_data(100, (char *)ctr->info.id23->pass, 516);
6305                 break;
6306         default:
6307                 DEBUG(4,("init_samr_userinfo_ctr: unsupported switch level\n"));
6308         }
6309 }
6310
6311 /*******************************************************************
6312 reads or writes a structure.
6313 ********************************************************************/
6314
6315 static BOOL samr_io_userinfo_ctr(const char *desc, SAM_USERINFO_CTR **ppctr,
6316                                  prs_struct *ps, int depth)
6317 {
6318         BOOL ret;
6319         SAM_USERINFO_CTR *ctr;
6320
6321         prs_debug(ps, depth, desc, "samr_io_userinfo_ctr");
6322         depth++;
6323
6324         if (UNMARSHALLING(ps)) {
6325                 ctr = (SAM_USERINFO_CTR *)prs_alloc_mem(ps,sizeof(SAM_USERINFO_CTR));
6326                 if (ctr == NULL)
6327                         return False;
6328                 *ppctr = ctr;
6329         } else {
6330                 ctr = *ppctr;
6331         }
6332
6333         /* lkclXXXX DO NOT ALIGN BEFORE READING SWITCH VALUE! */
6334
6335         if(!prs_uint16("switch_value", ps, depth, &ctr->switch_value))
6336                 return False;
6337         if(!prs_align(ps))
6338                 return False;
6339
6340         ret = False;
6341
6342         switch (ctr->switch_value) {
6343         case 0x10:
6344                 if (UNMARSHALLING(ps))
6345                         ctr->info.id10 = (SAM_USER_INFO_10 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_10));
6346                 if (ctr->info.id10 == NULL) {
6347                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6348                         return False;
6349                 }
6350                 ret = sam_io_user_info10("", ctr->info.id10, ps, depth);
6351                 break;
6352         case 0x11:
6353                 if (UNMARSHALLING(ps))
6354                         ctr->info.id11 = (SAM_USER_INFO_11 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_11));
6355
6356                 if (ctr->info.id11 == NULL) {
6357                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6358                         return False;
6359                 }
6360                 ret = sam_io_user_info11("", ctr->info.id11, ps, depth);
6361                 break;
6362         case 0x12:
6363                 if (UNMARSHALLING(ps))
6364                         ctr->info.id12 = (SAM_USER_INFO_12 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_12));
6365
6366                 if (ctr->info.id12 == NULL) {
6367                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6368                         return False;
6369                 }
6370                 ret = sam_io_user_info12("", ctr->info.id12, ps, depth);
6371                 break;
6372         case 20:
6373                 if (UNMARSHALLING(ps))
6374                         ctr->info.id20 = (SAM_USER_INFO_20 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_20));
6375
6376                 if (ctr->info.id20 == NULL) {
6377                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6378                         return False;
6379                 }
6380                 ret = sam_io_user_info20("", ctr->info.id20, ps, depth);
6381                 break;
6382         case 21:
6383                 if (UNMARSHALLING(ps))
6384                         ctr->info.id21 = (SAM_USER_INFO_21 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_21));
6385
6386                 if (ctr->info.id21 == NULL) {
6387                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6388                         return False;
6389                 }
6390                 ret = sam_io_user_info21("", ctr->info.id21, ps, depth);
6391                 break;
6392         case 23:
6393                 if (UNMARSHALLING(ps))
6394                         ctr->info.id23 = (SAM_USER_INFO_23 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_23));
6395
6396                 if (ctr->info.id23 == NULL) {
6397                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6398                         return False;
6399                 }
6400                 ret = sam_io_user_info23("", ctr->info.id23, ps, depth);
6401                 break;
6402         case 24:
6403                 if (UNMARSHALLING(ps))
6404                         ctr->info.id24 = (SAM_USER_INFO_24 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_24));
6405
6406                 if (ctr->info.id24 == NULL) {
6407                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6408                         return False;
6409                 }
6410                 ret = sam_io_user_info24("", ctr->info.id24, ps,  depth);
6411                 break;
6412         case 25:
6413                 if (UNMARSHALLING(ps))
6414                         ctr->info.id25 = (SAM_USER_INFO_25 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_25));
6415
6416                 if (ctr->info.id25 == NULL) {
6417                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6418                         return False;
6419                 }
6420                 ret = sam_io_user_info25("", ctr->info.id25, ps, depth);
6421                 break;
6422         default:
6423                 DEBUG(2, ("samr_io_userinfo_ctr: unknown switch level 0x%x\n", ctr->switch_value));
6424                 ret = False;
6425                 break;
6426         }
6427
6428         return ret;
6429 }
6430
6431 /*******************************************************************
6432 inits a SAMR_R_QUERY_USERINFO structure.
6433 ********************************************************************/
6434
6435 void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO * r_u,
6436                                 SAM_USERINFO_CTR * ctr, NTSTATUS status)
6437 {
6438         DEBUG(5, ("init_samr_r_query_userinfo\n"));
6439
6440         r_u->ptr = 0;
6441         r_u->ctr = NULL;
6442
6443         if (NT_STATUS_IS_OK(status)) {
6444                 r_u->ptr = 1;
6445                 r_u->ctr = ctr;
6446         }
6447
6448         r_u->status = status;   /* return status */
6449 }
6450
6451 /*******************************************************************
6452 reads or writes a structure.
6453 ********************************************************************/
6454
6455 BOOL samr_io_r_query_userinfo(const char *desc, SAMR_R_QUERY_USERINFO * r_u,
6456                               prs_struct *ps, int depth)
6457 {
6458         if (r_u == NULL)
6459                 return False;
6460
6461         prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
6462         depth++;
6463
6464         if(!prs_align(ps))
6465                 return False;
6466
6467         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
6468                 return False;
6469
6470         if (r_u->ptr != 0) {
6471                 if(!samr_io_userinfo_ctr("ctr", &r_u->ctr, ps, depth))
6472                         return False;
6473         }
6474
6475         if(!prs_align(ps))
6476                 return False;
6477         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6478                 return False;
6479
6480         return True;
6481 }
6482
6483 /*******************************************************************
6484 inits a SAMR_Q_SET_USERINFO structure.
6485 ********************************************************************/
6486
6487 void init_samr_q_set_userinfo(SAMR_Q_SET_USERINFO * q_u,
6488                               POLICY_HND *hnd, DATA_BLOB *sess_key,
6489                               uint16 switch_value, void *info)
6490 {
6491         DEBUG(5, ("init_samr_q_set_userinfo\n"));
6492
6493         q_u->pol = *hnd;
6494         q_u->switch_value = switch_value;
6495         init_samr_userinfo_ctr(q_u->ctr, sess_key, switch_value, info);
6496 }
6497
6498 /*******************************************************************
6499 reads or writes a structure.
6500 ********************************************************************/
6501
6502 BOOL samr_io_q_set_userinfo(const char *desc, SAMR_Q_SET_USERINFO * q_u,
6503                             prs_struct *ps, int depth)
6504 {
6505         if (q_u == NULL)
6506                 return False;
6507
6508         prs_debug(ps, depth, desc, "samr_io_q_set_userinfo");
6509         depth++;
6510
6511         if(!prs_align(ps))
6512                 return False;
6513
6514         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
6515
6516         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6517                 return False;
6518         if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6519                 return False;
6520
6521         return True;
6522 }
6523
6524 /*******************************************************************
6525 inits a SAMR_R_SET_USERINFO structure.
6526 ********************************************************************/
6527
6528 void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO * r_u, NTSTATUS status)
6529 {
6530         DEBUG(5, ("init_samr_r_set_userinfo\n"));
6531
6532         r_u->status = status;   /* return status */
6533 }
6534
6535 /*******************************************************************
6536 reads or writes a structure.
6537 ********************************************************************/
6538
6539 BOOL samr_io_r_set_userinfo(const char *desc, SAMR_R_SET_USERINFO * r_u,
6540                             prs_struct *ps, int depth)
6541 {
6542         if (r_u == NULL)
6543                 return False;
6544
6545         prs_debug(ps, depth, desc, "samr_io_r_set_userinfo");
6546         depth++;
6547
6548         if(!prs_align(ps))
6549                 return False;
6550
6551         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6552                 return False;
6553
6554         return True;
6555 }
6556
6557 /*******************************************************************
6558 inits a SAMR_Q_SET_USERINFO2 structure.
6559 ********************************************************************/
6560
6561 void init_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2 * q_u,
6562                                POLICY_HND *hnd, DATA_BLOB *sess_key,
6563                                uint16 switch_value, SAM_USERINFO_CTR * ctr)
6564 {
6565         DEBUG(5, ("init_samr_q_set_userinfo2\n"));
6566
6567         q_u->pol = *hnd;
6568         q_u->switch_value = switch_value;
6569         q_u->ctr = ctr;
6570
6571         if (q_u->ctr != NULL)
6572                 q_u->ctr->switch_value = switch_value;
6573
6574         switch (switch_value) {
6575         case 0x12:
6576                 SamOEMhashBlob(ctr->info.id12->lm_pwd, 16, sess_key);
6577                 SamOEMhashBlob(ctr->info.id12->nt_pwd, 16, sess_key);
6578                 dump_data(100, (char *)sess_key->data, sess_key->length);
6579                 dump_data(100, (char *)ctr->info.id12->lm_pwd, 16);
6580                 dump_data(100, (char *)ctr->info.id12->nt_pwd, 16);
6581                 break;
6582         }
6583 }
6584
6585 /*******************************************************************
6586 reads or writes a structure.
6587 ********************************************************************/
6588
6589 BOOL samr_io_q_set_userinfo2(const char *desc, SAMR_Q_SET_USERINFO2 * q_u,
6590                              prs_struct *ps, int depth)
6591 {
6592         if (q_u == NULL)
6593                 return False;
6594
6595         prs_debug(ps, depth, desc, "samr_io_q_set_userinfo2");
6596         depth++;
6597
6598         if(!prs_align(ps))
6599                 return False;
6600
6601         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
6602                 return False;
6603
6604         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6605                 return False;
6606         if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6607                 return False;
6608
6609         return True;
6610 }
6611
6612 /*******************************************************************
6613 inits a SAMR_R_SET_USERINFO2 structure.
6614 ********************************************************************/
6615
6616 void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 * r_u, NTSTATUS status)
6617 {
6618         DEBUG(5, ("init_samr_r_set_userinfo2\n"));
6619
6620         r_u->status = status;   /* return status */
6621 }
6622
6623 /*******************************************************************
6624 reads or writes a structure.
6625 ********************************************************************/
6626
6627 BOOL samr_io_r_set_userinfo2(const char *desc, SAMR_R_SET_USERINFO2 * r_u,
6628                              prs_struct *ps, int depth)
6629 {
6630         if (r_u == NULL)
6631                 return False;
6632
6633         prs_debug(ps, depth, desc, "samr_io_r_set_userinfo2");
6634         depth++;
6635
6636         if(!prs_align(ps))
6637                 return False;
6638
6639         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6640                 return False;
6641
6642         return True;
6643 }
6644
6645 /*******************************************************************
6646 inits a SAMR_Q_CONNECT structure.
6647 ********************************************************************/
6648
6649 void init_samr_q_connect(SAMR_Q_CONNECT * q_u,
6650                          char *srv_name, uint32 access_mask)
6651 {
6652         DEBUG(5, ("init_samr_q_connect\n"));
6653
6654         /* make PDC server name \\server */
6655         q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
6656         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
6657
6658         /* example values: 0x0000 0002 */
6659         q_u->access_mask = access_mask;
6660 }
6661
6662 /*******************************************************************
6663 reads or writes a structure.
6664 ********************************************************************/
6665
6666 BOOL samr_io_q_connect(const char *desc, SAMR_Q_CONNECT * q_u,
6667                        prs_struct *ps, int depth)
6668 {
6669         if (q_u == NULL)
6670                 return False;
6671
6672         prs_debug(ps, depth, desc, "samr_io_q_connect");
6673         depth++;
6674
6675         if(!prs_align(ps))
6676                 return False;
6677
6678         if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
6679                 return False;
6680         if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
6681                 return False;
6682
6683         if(!prs_align(ps))
6684                 return False;
6685         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6686                 return False;
6687
6688         return True;
6689 }
6690
6691 /*******************************************************************
6692 reads or writes a structure.
6693 ********************************************************************/
6694
6695 BOOL samr_io_r_connect(const char *desc, SAMR_R_CONNECT * r_u,
6696                        prs_struct *ps, int depth)
6697 {
6698         if (r_u == NULL)
6699                 return False;
6700
6701         prs_debug(ps, depth, desc, "samr_io_r_connect");
6702         depth++;
6703
6704         if(!prs_align(ps))
6705                 return False;
6706
6707         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6708                 return False;
6709
6710         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6711                 return False;
6712
6713         return True;
6714 }
6715
6716 /*******************************************************************
6717 inits a SAMR_Q_CONNECT4 structure.
6718 ********************************************************************/
6719
6720 void init_samr_q_connect4(SAMR_Q_CONNECT4 * q_u,
6721                           char *srv_name, uint32 access_mask)
6722 {
6723         DEBUG(5, ("init_samr_q_connect\n"));
6724
6725         /* make PDC server name \\server */
6726         q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
6727         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
6728
6729         /* Only value we've seen, possibly an address type ? */
6730         q_u->unk_0 = 2;
6731
6732         /* example values: 0x0000 0002 */
6733         q_u->access_mask = access_mask;
6734 }
6735
6736 /*******************************************************************
6737 reads or writes a structure.
6738 ********************************************************************/
6739
6740 BOOL samr_io_q_connect4(const char *desc, SAMR_Q_CONNECT4 * q_u,
6741                         prs_struct *ps, int depth)
6742 {
6743         if (q_u == NULL)
6744                 return False;
6745
6746         prs_debug(ps, depth, desc, "samr_io_q_connect4");
6747         depth++;
6748
6749         if(!prs_align(ps))
6750                 return False;
6751
6752         if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
6753                 return False;
6754         if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
6755                 return False;
6756
6757         if(!prs_align(ps))
6758                 return False;
6759         if(!prs_uint32("unk_0", ps, depth, &q_u->unk_0))
6760                 return False;
6761         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6762                 return False;
6763
6764         return True;
6765 }
6766
6767 /*******************************************************************
6768 reads or writes a structure.
6769 ********************************************************************/
6770
6771 BOOL samr_io_r_connect4(const char *desc, SAMR_R_CONNECT4 * r_u,
6772                         prs_struct *ps, int depth)
6773 {
6774         if (r_u == NULL)
6775                 return False;
6776
6777         prs_debug(ps, depth, desc, "samr_io_r_connect4");
6778         depth++;
6779
6780         if(!prs_align(ps))
6781                 return False;
6782
6783         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6784                 return False;
6785
6786         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6787                 return False;
6788
6789         return True;
6790 }
6791
6792 /*******************************************************************
6793 inits a SAMR_Q_CONNECT_ANON structure.
6794 ********************************************************************/
6795
6796 void init_samr_q_connect_anon(SAMR_Q_CONNECT_ANON * q_u)
6797 {
6798         DEBUG(5, ("init_samr_q_connect_anon\n"));
6799
6800         q_u->ptr = 1;
6801         q_u->unknown_0 = 0x5c;  /* server name (?!!) */
6802         q_u->unknown_1 = 0x01;
6803         q_u->access_mask = 0x20;
6804 }
6805
6806 /*******************************************************************
6807 reads or writes a structure.
6808 ********************************************************************/
6809
6810 BOOL samr_io_q_connect_anon(const char *desc, SAMR_Q_CONNECT_ANON * q_u,
6811                             prs_struct *ps, int depth)
6812 {
6813         if (q_u == NULL)
6814                 return False;
6815
6816         prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
6817         depth++;
6818
6819         if(!prs_align(ps))
6820                 return False;
6821
6822         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
6823                 return False;
6824         if(!prs_uint16("unknown_0", ps, depth, &q_u->unknown_0))
6825                 return False;
6826         if(!prs_uint16("unknown_1", ps, depth, &q_u->unknown_1))
6827                 return False;
6828         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6829                 return False;
6830
6831         return True;
6832 }
6833
6834 /*******************************************************************
6835 reads or writes a structure.
6836 ********************************************************************/
6837
6838 BOOL samr_io_r_connect_anon(const char *desc, SAMR_R_CONNECT_ANON * r_u,
6839                             prs_struct *ps, int depth)
6840 {
6841         if (r_u == NULL)
6842                 return False;
6843
6844         prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
6845         depth++;
6846
6847         if(!prs_align(ps))
6848                 return False;
6849
6850         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6851                 return False;
6852
6853         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6854                 return False;
6855
6856         return True;
6857 }
6858
6859 /*******************************************************************
6860 inits a SAMR_Q_GET_DOM_PWINFO structure.
6861 ********************************************************************/
6862
6863 void init_samr_q_get_dom_pwinfo(SAMR_Q_GET_DOM_PWINFO * q_u,
6864                                 char *srv_name)
6865 {
6866         DEBUG(5, ("init_samr_q_get_dom_pwinfo\n"));
6867
6868         q_u->ptr = 1;
6869         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_FLAGS_NONE);
6870         init_uni_hdr(&q_u->hdr_srv_name, &q_u->uni_srv_name);
6871 }
6872
6873 /*******************************************************************
6874 reads or writes a structure.
6875 ********************************************************************/
6876
6877 BOOL samr_io_q_get_dom_pwinfo(const char *desc, SAMR_Q_GET_DOM_PWINFO * q_u,
6878                               prs_struct *ps, int depth)
6879 {
6880         if (q_u == NULL)
6881                 return False;
6882
6883         prs_debug(ps, depth, desc, "samr_io_q_get_dom_pwinfo");
6884         depth++;
6885
6886         if(!prs_align(ps))
6887                 return False;
6888
6889         if(!prs_uint32("ptr", ps, depth, &q_u->ptr))
6890                 return False;
6891         if (q_u->ptr != 0) {
6892                 if(!smb_io_unihdr("", &q_u->hdr_srv_name, ps, depth))
6893                         return False;
6894                 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->hdr_srv_name.buffer, ps, depth))
6895                         return False;
6896         }
6897
6898         return True;
6899 }
6900
6901 /*******************************************************************
6902 reads or writes a structure.
6903 ********************************************************************/
6904
6905 BOOL samr_io_r_get_dom_pwinfo(const char *desc, SAMR_R_GET_DOM_PWINFO * r_u,
6906                               prs_struct *ps, int depth)
6907 {
6908         if (r_u == NULL)
6909                 return False;
6910
6911         prs_debug(ps, depth, desc, "samr_io_r_get_dom_pwinfo");
6912         depth++;
6913
6914         if(!prs_align(ps))
6915                 return False;
6916
6917         /*
6918          * We need 16 bytes here according to tests.  Don't know
6919          * what they are, but the length is important for the singing
6920         */
6921
6922         if(!prs_uint32("unk_0", ps, depth, &r_u->unk_0))
6923                 return False;
6924         if(!prs_uint32("unk_1", ps, depth, &r_u->unk_1))
6925                 return False;
6926         if(!prs_uint32("unk_2", ps, depth, &r_u->unk_2))
6927                 return False;
6928
6929         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6930                 return False;
6931
6932         return True;
6933 }
6934
6935 /*******************************************************************
6936 make a SAMR_ENC_PASSWD structure.
6937 ********************************************************************/
6938
6939 void init_enc_passwd(SAMR_ENC_PASSWD * pwd, char pass[512])
6940 {
6941         ZERO_STRUCTP(pwd);
6942
6943         if (pass == NULL) {
6944                 pwd->ptr = 0;
6945         } else {
6946                 pwd->ptr = 1;
6947                 memcpy(pwd->pass, pass, sizeof(pwd->pass));
6948         }
6949 }
6950
6951 /*******************************************************************
6952 reads or writes a SAMR_ENC_PASSWD structure.
6953 ********************************************************************/
6954
6955 BOOL samr_io_enc_passwd(const char *desc, SAMR_ENC_PASSWD * pwd,
6956                         prs_struct *ps, int depth)
6957 {
6958         if (pwd == NULL)
6959                 return False;
6960
6961         prs_debug(ps, depth, desc, "samr_io_enc_passwd");
6962         depth++;
6963
6964         if(!prs_align(ps))
6965                 return False;
6966
6967         if(!prs_uint32("ptr", ps, depth, &pwd->ptr))
6968                 return False;
6969
6970         if (pwd->ptr != 0) {
6971                 if(!prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass)))
6972                         return False;
6973         }
6974
6975         return True;
6976 }
6977
6978 /*******************************************************************
6979 inits a SAMR_ENC_HASH structure.
6980 ********************************************************************/
6981
6982 void init_enc_hash(SAMR_ENC_HASH * hsh, uchar hash[16])
6983 {
6984         ZERO_STRUCTP(hsh);
6985
6986         if (hash == NULL) {
6987                 hsh->ptr = 0;
6988         } else {
6989                 hsh->ptr = 1;
6990                 memcpy(hsh->hash, hash, sizeof(hsh->hash));
6991         }
6992 }
6993
6994 /*******************************************************************
6995 reads or writes a SAMR_ENC_HASH structure.
6996 ********************************************************************/
6997
6998 BOOL samr_io_enc_hash(const char *desc, SAMR_ENC_HASH * hsh,
6999                       prs_struct *ps, int depth)
7000 {
7001         if (hsh == NULL)
7002                 return False;
7003
7004         prs_debug(ps, depth, desc, "samr_io_enc_hash");
7005         depth++;
7006
7007         if(!prs_align(ps))
7008                 return False;
7009
7010         if(!prs_uint32("ptr ", ps, depth, &hsh->ptr))
7011                 return False;
7012         if (hsh->ptr != 0) {
7013                 if(!prs_uint8s(False, "hash", ps, depth, hsh->hash,sizeof(hsh->hash)))
7014                         return False;
7015         }
7016
7017         return True;
7018 }
7019
7020 /*******************************************************************
7021 inits a SAMR_R_GET_DOM_PWINFO structure.
7022 ********************************************************************/
7023
7024 void init_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER * q_u,
7025                                 char *dest_host, char *user_name,
7026                                 char nt_newpass[516],
7027                                 uchar nt_oldhash[16],
7028                                 char lm_newpass[516],
7029                                 uchar lm_oldhash[16])
7030 {
7031         DEBUG(5, ("init_samr_q_chgpasswd_user\n"));
7032
7033         q_u->ptr_0 = 1;
7034         init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7035         init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7036
7037         init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7038         init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7039
7040         init_enc_passwd(&q_u->nt_newpass, nt_newpass);
7041         init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7042
7043         q_u->unknown = 0x01;
7044
7045         init_enc_passwd(&q_u->lm_newpass, lm_newpass);
7046         init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7047 }
7048
7049 /*******************************************************************
7050 reads or writes a structure.
7051 ********************************************************************/
7052
7053 BOOL samr_io_q_chgpasswd_user(const char *desc, SAMR_Q_CHGPASSWD_USER * q_u,
7054                               prs_struct *ps, int depth)
7055 {
7056         if (q_u == NULL)
7057                 return False;
7058
7059         prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
7060         depth++;
7061
7062         if(!prs_align(ps))
7063                 return False;
7064
7065         if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7066                 return False;
7067
7068         if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7069                 return False;
7070         if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7071                 return False;
7072
7073         if(!prs_align(ps))
7074                 return False;
7075         if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7076                 return False;
7077         if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7078                 return False;
7079
7080         if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7081                 return False;
7082         if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7083                 return False;
7084
7085         if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
7086                 return False;
7087
7088         if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7089                 return False;
7090         if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7091                 return False;
7092
7093         return True;
7094 }
7095
7096 /*******************************************************************
7097 inits a SAMR_R_CHGPASSWD_USER structure.
7098 ********************************************************************/
7099
7100 void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER * r_u, NTSTATUS status)
7101 {
7102         DEBUG(5, ("init_r_chgpasswd_user\n"));
7103
7104         r_u->status = status;
7105 }
7106
7107 /*******************************************************************
7108 reads or writes a structure.
7109 ********************************************************************/
7110
7111 BOOL samr_io_r_chgpasswd_user(const char *desc, SAMR_R_CHGPASSWD_USER * r_u,
7112                               prs_struct *ps, int depth)
7113 {
7114         if (r_u == NULL)
7115                 return False;
7116
7117         prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
7118         depth++;
7119
7120         if(!prs_align(ps))
7121                 return False;
7122
7123         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7124                 return False;
7125
7126         return True;
7127 }
7128
7129 /*******************************************************************
7130 reads or writes a structure.
7131 ********************************************************************/
7132
7133 void init_samr_q_unknown_2e(SAMR_Q_UNKNOWN_2E *q_u,
7134                                 POLICY_HND *domain_pol, uint16 switch_value)
7135 {
7136         DEBUG(5, ("init_samr_q_unknown_2e\n"));
7137
7138         q_u->domain_pol = *domain_pol;
7139         q_u->switch_value = switch_value;
7140 }
7141
7142 /*******************************************************************
7143 reads or writes a structure.
7144 ********************************************************************/
7145
7146 BOOL samr_io_q_unknown_2e(const char *desc, SAMR_Q_UNKNOWN_2E *q_u,
7147                               prs_struct *ps, int depth)
7148 {
7149         if (q_u == NULL)
7150                 return False;
7151
7152         prs_debug(ps, depth, desc, "samr_io_q_unknown_2e");
7153         depth++;
7154
7155         if(!prs_align(ps))
7156                 return False;
7157
7158         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7159                 return False;
7160
7161         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7162                 return False;
7163
7164         return True;
7165 }
7166
7167 /*******************************************************************
7168 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7169 ********************************************************************/
7170
7171 void init_samr_r_samr_unknown_2e(SAMR_R_UNKNOWN_2E * r_u,
7172                                 uint16 switch_value, SAM_UNK_CTR * ctr,
7173                                 NTSTATUS status)
7174 {
7175         DEBUG(5, ("init_samr_r_samr_unknown_2e\n"));
7176
7177         r_u->ptr_0 = 0;
7178         r_u->switch_value = 0;
7179         r_u->status = status;   /* return status */
7180
7181         if (NT_STATUS_IS_OK(status)) {
7182                 r_u->switch_value = switch_value;
7183                 r_u->ptr_0 = 1;
7184                 r_u->ctr = ctr;
7185         }
7186 }
7187
7188 /*******************************************************************
7189 reads or writes a structure.
7190 ********************************************************************/
7191
7192 BOOL samr_io_r_samr_unknown_2e(const char *desc, SAMR_R_UNKNOWN_2E * r_u,
7193                               prs_struct *ps, int depth)
7194 {
7195         if (r_u == NULL)
7196                 return False;
7197
7198         prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
7199         depth++;
7200
7201         if(!prs_align(ps))
7202                 return False;
7203
7204         if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
7205                 return False;
7206
7207         if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
7208                 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
7209                         return False;
7210                 if(!prs_align(ps))
7211                         return False;
7212
7213                 switch (r_u->switch_value) {
7214                 case 0x0c:
7215                         if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
7216                                 return False;
7217                         break;
7218                 case 0x07:
7219                         if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
7220                                 return False;
7221                         break;
7222                 case 0x06:
7223                         if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
7224                                 return False;
7225                         break;
7226                 case 0x05:
7227                         if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
7228                                 return False;
7229                         break;
7230                 case 0x03:
7231                         if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
7232                                 return False;
7233                         break;
7234                 case 0x02:
7235                         if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
7236                                 return False;
7237                         break;
7238                 case 0x01:
7239                         if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
7240                                 return False;
7241                         break;
7242                 default:
7243                         DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
7244                                 r_u->switch_value));
7245                         r_u->status = NT_STATUS_INVALID_INFO_CLASS;
7246                         return False;
7247                 }
7248         }
7249
7250         if(!prs_align(ps))
7251                 return False;
7252
7253         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7254                 return False;
7255
7256         return True;
7257 }
7258
7259
7260 /*******************************************************************
7261 reads or writes a structure.
7262 ********************************************************************/
7263
7264 void init_samr_q_set_domain_info(SAMR_Q_SET_DOMAIN_INFO *q_u,
7265                                 POLICY_HND *domain_pol, uint16 switch_value, SAM_UNK_CTR *ctr)
7266 {
7267         DEBUG(5, ("init_samr_q_set_domain_info\n"));
7268
7269         q_u->domain_pol = *domain_pol;
7270         q_u->switch_value0 = switch_value;
7271
7272         q_u->switch_value = switch_value;
7273         q_u->ctr = ctr;
7274
7275 }
7276
7277 /*******************************************************************
7278 reads or writes a structure.
7279 ********************************************************************/
7280
7281 BOOL samr_io_q_set_domain_info(const char *desc, SAMR_Q_SET_DOMAIN_INFO *q_u,
7282                               prs_struct *ps, int depth)
7283 {
7284         if (q_u == NULL)
7285                 return False;
7286
7287         prs_debug(ps, depth, desc, "samr_io_q_set_domain_info");
7288         depth++;
7289
7290         if(!prs_align(ps))
7291                 return False;
7292
7293         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7294                 return False;
7295
7296         if(!prs_uint16("switch_value0", ps, depth, &q_u->switch_value0))
7297                 return False;
7298
7299         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7300                 return False;
7301
7302         if(!prs_align(ps))
7303                 return False;
7304
7305         if ((q_u->ctr = (SAM_UNK_CTR *)prs_alloc_mem(ps, sizeof(SAM_UNK_CTR))) == NULL)
7306                 return False;
7307
7308         switch (q_u->switch_value) {
7309
7310         case 0x0c:
7311                 if(!sam_io_unk_info12("unk_inf12", &q_u->ctr->info.inf12, ps, depth))
7312                         return False;
7313                 break;
7314         case 0x07:
7315                 if(!sam_io_unk_info7("unk_inf7",&q_u->ctr->info.inf7, ps,depth))
7316                         return False;
7317                 break;
7318         case 0x06:
7319                 if(!sam_io_unk_info6("unk_inf6",&q_u->ctr->info.inf6, ps,depth))
7320                         return False;
7321                 break;
7322         case 0x05:
7323                 if(!sam_io_unk_info5("unk_inf5",&q_u->ctr->info.inf5, ps,depth))
7324                         return False;
7325                 break;
7326         case 0x03:
7327                 if(!sam_io_unk_info3("unk_inf3",&q_u->ctr->info.inf3, ps,depth))
7328                         return False;
7329                 break;
7330         case 0x02:
7331                 if(!sam_io_unk_info2("unk_inf2",&q_u->ctr->info.inf2, ps,depth))
7332                         return False;
7333                 break;
7334         case 0x01:
7335                 if(!sam_io_unk_info1("unk_inf1",&q_u->ctr->info.inf1, ps,depth))
7336                         return False;
7337                 break;
7338         default:
7339                 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
7340                         q_u->switch_value));
7341                 return False;
7342         }
7343
7344         return True;
7345 }
7346
7347 /*******************************************************************
7348 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7349 ********************************************************************/
7350
7351 void init_samr_r_set_domain_info(SAMR_R_SET_DOMAIN_INFO * r_u, NTSTATUS status)
7352 {
7353         DEBUG(5, ("init_samr_r_set_domain_info\n"));
7354
7355         r_u->status = status;   /* return status */
7356 }
7357
7358 /*******************************************************************
7359 reads or writes a structure.
7360 ********************************************************************/
7361
7362 BOOL samr_io_r_set_domain_info(const char *desc, SAMR_R_SET_DOMAIN_INFO * r_u,
7363                               prs_struct *ps, int depth)
7364 {
7365         if (r_u == NULL)
7366                 return False;
7367
7368         prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
7369         depth++;
7370
7371         if(!prs_align(ps))
7372                 return False;
7373
7374         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7375                 return False;
7376
7377         return True;
7378 }