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_user_foreign_domain(SAMR_Q_REMOVE_USER_FOREIGN_DOMAIN * q_u, POLICY_HND *dom_pol, DOM_SID *sid)
 185 {
 186         DEBUG(5, ("samr_init_samr_q_remove_user_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_user_foreign_domain(const char *desc, SAMR_Q_REMOVE_USER_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_user_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_user_foreign_domain(const char *desc, SAMR_R_REMOVE_USER_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_user_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  unknown_3 = 0x09f8 27fa
5320  unknown_5 = 0x0001 0000
5321  unknown_6 = 0x0000 04ec
5322
5323  *************************************************************************/
5324
5325 void init_sam_user_info24(SAM_USER_INFO_24 * usr, char newpass[516], uint16 pw_len)
5326 {
5327         DEBUG(10, ("init_sam_user_info24:\n"));
5328         memcpy(usr->pass, newpass, sizeof(usr->pass));
5329         usr->pw_len = pw_len;
5330 }
5331
5332 /*******************************************************************
5333 reads or writes a structure.
5334 ********************************************************************/
5335
5336 static BOOL sam_io_user_info24(const char *desc, SAM_USER_INFO_24 * usr,
5337                                prs_struct *ps, int depth)
5338 {
5339         if (usr == NULL)
5340                 return False;
5341
5342         prs_debug(ps, depth, desc, "sam_io_user_info24");
5343         depth++;
5344
5345         if(!prs_align(ps))
5346                 return False;
5347
5348         if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5349                        sizeof(usr->pass)))
5350                 return False;
5351
5352         if (MARSHALLING(ps) && (usr->pw_len != 0)) {
5353                 if (!prs_uint16("pw_len", ps, depth, &usr->pw_len))
5354                         return False;
5355         }
5356         if(!prs_align(ps))
5357                 return False;
5358
5359         return True;
5360 }
5361
5362 /*************************************************************************
5363  init_sam_user_info23
5364
5365  unknown_3 = 0x09f8 27fa
5366  unknown_6 = 0x0000 04ec
5367
5368  *************************************************************************/
5369
5370 void init_sam_user_info23W(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5371                         NTTIME * logoff_time,   /* all zeros */
5372                         NTTIME * kickoff_time,  /* all zeros */
5373                         NTTIME * pass_last_set_time,    /* all zeros */
5374                         NTTIME * pass_can_change_time,  /* all zeros */
5375                         NTTIME * pass_must_change_time, /* all zeros */
5376                         UNISTR2 *user_name,
5377                         UNISTR2 *full_name,
5378                         UNISTR2 *home_dir,
5379                         UNISTR2 *dir_drive,
5380                         UNISTR2 *log_scr,
5381                         UNISTR2 *prof_path,
5382                         UNISTR2 *desc,
5383                         UNISTR2 *wkstas,
5384                         UNISTR2 *unk_str,
5385                         UNISTR2 *mung_dial,
5386                         uint32 user_rid,        /* 0x0000 0000 */
5387                         uint32 group_rid,
5388                         uint32 acb_info,
5389                         uint32 unknown_3,
5390                         uint16 logon_divs,
5391                         LOGON_HRS * hrs,
5392                         uint16 bad_password_count,
5393                         uint16 logon_count,
5394                         char newpass[516], uint32 unknown_6)
5395 {
5396         usr->logon_time = *logon_time;  /* all zeros */
5397         usr->logoff_time = *logoff_time;        /* all zeros */
5398         usr->kickoff_time = *kickoff_time;      /* all zeros */
5399         usr->pass_last_set_time = *pass_last_set_time;  /* all zeros */
5400         usr->pass_can_change_time = *pass_can_change_time;      /* all zeros */
5401         usr->pass_must_change_time = *pass_must_change_time;    /* all zeros */
5402
5403         ZERO_STRUCT(usr->nt_pwd);
5404         ZERO_STRUCT(usr->lm_pwd);
5405
5406         usr->user_rid = user_rid;       /* 0x0000 0000 */
5407         usr->group_rid = group_rid;
5408         usr->acb_info = acb_info;
5409         usr->unknown_3 = unknown_3;     /* 09f8 27fa */
5410
5411         usr->logon_divs = logon_divs;   /* should be 168 (hours/week) */
5412         usr->ptr_logon_hrs = hrs ? 1 : 0;
5413
5414         if (nt_time_is_zero(pass_must_change_time)) {
5415                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5416         } else {
5417                 usr->passmustchange=0;
5418         }
5419
5420         ZERO_STRUCT(usr->padding1);
5421         ZERO_STRUCT(usr->padding2);
5422
5423         usr->bad_password_count = bad_password_count;
5424         usr->logon_count = logon_count;
5425
5426         memcpy(usr->pass, newpass, sizeof(usr->pass));
5427
5428         copy_unistr2(&usr->uni_user_name, user_name);
5429         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5430
5431         copy_unistr2(&usr->uni_full_name, full_name);
5432         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5433
5434         copy_unistr2(&usr->uni_home_dir, home_dir);
5435         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5436
5437         copy_unistr2(&usr->uni_dir_drive, dir_drive);
5438         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5439
5440         copy_unistr2(&usr->uni_logon_script, log_scr);
5441         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5442
5443         copy_unistr2(&usr->uni_profile_path, prof_path);
5444         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5445
5446         copy_unistr2(&usr->uni_acct_desc, desc);
5447         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5448
5449         copy_unistr2(&usr->uni_workstations, wkstas);
5450         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5451
5452         copy_unistr2(&usr->uni_unknown_str, unk_str);
5453         init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
5454
5455         copy_unistr2(&usr->uni_munged_dial, mung_dial);
5456         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5457
5458         usr->unknown_6 = unknown_6;     /* 0x0000 04ec */
5459         usr->padding4 = 0;
5460
5461         memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5462 }
5463
5464 /*************************************************************************
5465  init_sam_user_info23
5466
5467  unknown_3 = 0x09f8 27fa
5468  unknown_6 = 0x0000 04ec
5469
5470  *************************************************************************/
5471
5472 void init_sam_user_info23A(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5473                            NTTIME * logoff_time,        /* all zeros */
5474                            NTTIME * kickoff_time,       /* all zeros */
5475                            NTTIME * pass_last_set_time, /* all zeros */
5476                            NTTIME * pass_can_change_time,       /* all zeros */
5477                            NTTIME * pass_must_change_time,      /* all zeros */
5478                            char *user_name,     /* NULL */
5479                            char *full_name,
5480                            char *home_dir, char *dir_drive, char *log_scr,
5481                            char *prof_path, const char *desc, char *wkstas,
5482                            char *unk_str, char *mung_dial, uint32 user_rid,     /* 0x0000 0000 */
5483                            uint32 group_rid, uint32 acb_info,
5484                            uint32 unknown_3, uint16 logon_divs,
5485                            LOGON_HRS * hrs, uint16 bad_password_count, uint16 logon_count,
5486                            char newpass[516], uint32 unknown_6)
5487 {
5488         DATA_BLOB blob = base64_decode_data_blob(mung_dial);
5489
5490         usr->logon_time = *logon_time;  /* all zeros */
5491         usr->logoff_time = *logoff_time;        /* all zeros */
5492         usr->kickoff_time = *kickoff_time;      /* all zeros */
5493         usr->pass_last_set_time = *pass_last_set_time;  /* all zeros */
5494         usr->pass_can_change_time = *pass_can_change_time;      /* all zeros */
5495         usr->pass_must_change_time = *pass_must_change_time;    /* all zeros */
5496
5497         ZERO_STRUCT(usr->nt_pwd);
5498         ZERO_STRUCT(usr->lm_pwd);
5499
5500         usr->user_rid = user_rid;       /* 0x0000 0000 */
5501         usr->group_rid = group_rid;
5502         usr->acb_info = acb_info;
5503         usr->unknown_3 = unknown_3;     /* 09f8 27fa */
5504
5505         usr->logon_divs = logon_divs;   /* should be 168 (hours/week) */
5506         usr->ptr_logon_hrs = hrs ? 1 : 0;
5507
5508         if (nt_time_is_zero(pass_must_change_time)) {
5509                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5510         } else {
5511                 usr->passmustchange=0;
5512         }
5513
5514         ZERO_STRUCT(usr->padding1);
5515         ZERO_STRUCT(usr->padding2);
5516
5517         usr->bad_password_count = bad_password_count;
5518         usr->logon_count = logon_count;
5519
5520         memcpy(usr->pass, newpass, sizeof(usr->pass));
5521
5522         init_unistr2(&usr->uni_user_name, user_name, UNI_FLAGS_NONE);
5523         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5524
5525         init_unistr2(&usr->uni_full_name, full_name, UNI_FLAGS_NONE);
5526         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5527
5528         init_unistr2(&usr->uni_home_dir, home_dir, UNI_FLAGS_NONE);
5529         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5530
5531         init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_FLAGS_NONE);
5532         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5533
5534         init_unistr2(&usr->uni_logon_script, log_scr, UNI_FLAGS_NONE);
5535         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5536
5537         init_unistr2(&usr->uni_profile_path, prof_path, UNI_FLAGS_NONE);
5538         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5539
5540         init_unistr2(&usr->uni_acct_desc, desc, UNI_FLAGS_NONE);
5541         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5542
5543         init_unistr2(&usr->uni_workstations, wkstas, UNI_FLAGS_NONE);
5544         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5545
5546         init_unistr2(&usr->uni_unknown_str, unk_str, UNI_FLAGS_NONE);
5547         init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
5548
5549         init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
5550         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5551
5552         data_blob_free(&blob);
5553
5554         usr->unknown_6 = unknown_6;     /* 0x0000 04ec */
5555         usr->padding4 = 0;
5556
5557         memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5558 }
5559
5560 /*******************************************************************
5561 reads or writes a structure.
5562 ********************************************************************/
5563
5564 static BOOL sam_io_user_info23(const char *desc, SAM_USER_INFO_23 * usr,
5565                                prs_struct *ps, int depth)
5566 {
5567         if (usr == NULL)
5568                 return False;
5569
5570         prs_debug(ps, depth, desc, "sam_io_user_info23");
5571         depth++;
5572
5573         if(!prs_align(ps))
5574                 return False;
5575
5576         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
5577                 return False;
5578         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
5579                 return False;
5580         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
5581                 return False;
5582         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps, depth))
5583                 return False;
5584         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
5585                 return False;
5586         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
5587                 return False;
5588
5589         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth))  /* username unicode string header */
5590                 return False;
5591         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth))  /* user's full name unicode string header */
5592                 return False;
5593         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth))   /* home directory unicode string header */
5594                 return False;
5595         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth))  /* home directory drive */
5596                 return False;
5597         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth))       /* logon script unicode string header */
5598                 return False;
5599         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth))       /* profile path unicode string header */
5600                 return False;
5601         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth))  /* account desc */
5602                 return False;
5603         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth))       /* wkstas user can log on from */
5604                 return False;
5605         if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth))        /* unknown string */
5606                 return False;
5607         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
5608                 return False;
5609
5610         if(!prs_uint8s(False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
5611                 return False;
5612         if(!prs_uint8s(False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
5613                 return False;
5614
5615         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))    /* User ID */
5616                 return False;
5617         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))   /* Group ID */
5618                 return False;
5619         if(!prs_uint32("acb_info      ", ps, depth, &usr->acb_info))
5620                 return False;
5621
5622         if(!prs_uint32("unknown_3     ", ps, depth, &usr->unknown_3))
5623                 return False;
5624         if(!prs_uint16("logon_divs    ", ps, depth, &usr->logon_divs))  /* logon divisions per week */
5625                 return False;
5626         if(!prs_align(ps))
5627                 return False;
5628         if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
5629                 return False;
5630
5631         if(!prs_uint16("bad_password_count     ", ps, depth, &usr->bad_password_count))
5632                 return False;
5633         if(!prs_uint16("logon_count     ", ps, depth, &usr->logon_count))
5634                 return False;
5635
5636         if(!prs_uint8s(False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1)))
5637                 return False;
5638         if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
5639                 return False;
5640         if(!prs_uint8("padding2       ", ps, depth, &usr->padding2))
5641                 return False;
5642
5643
5644         if(!prs_uint8s(False, "password      ", ps, depth, usr->pass, sizeof(usr->pass)))
5645                 return False;
5646
5647         /* here begins pointed-to data */
5648
5649         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth))      /* username unicode string */
5650                 return False;
5651
5652         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))      /* user's full name unicode string */
5653                 return False;
5654
5655         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))        /* home directory unicode string */
5656                 return False;
5657
5658         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))      /* home directory drive unicode string */
5659                 return False;
5660
5661         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))        /* logon script unicode string */
5662                 return False;
5663
5664         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))        /* profile path unicode string */
5665                 return False;
5666
5667         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))      /* user desc unicode string */
5668                 return False;
5669
5670         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))        /* worksations user can log on from */
5671                 return False;
5672
5673         if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str.buffer, ps, depth))  /* unknown string */
5674                 return False;
5675
5676         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
5677                 return False;
5678
5679         /* ok, this is only guess-work (as usual) */
5680         if (usr->ptr_logon_hrs) {
5681                 if(!prs_uint32("unknown_6     ", ps, depth, &usr->unknown_6))
5682                         return False;
5683                 if(!prs_uint32("padding4      ", ps, depth, &usr->padding4))
5684                         return False;
5685                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
5686                         return False;
5687         } else if (UNMARSHALLING(ps)) {
5688                 usr->unknown_6 = 0;
5689                 usr->padding4 = 0;
5690         }
5691
5692         return True;
5693 }
5694
5695 /*******************************************************************
5696  reads or writes a structure.
5697  NB. This structure is *definately* incorrect. It's my best guess
5698  currently for W2K SP2. The password field is encrypted in a different
5699  way than normal... And there are definately other problems. JRA.
5700 ********************************************************************/
5701
5702 static BOOL sam_io_user_info25(const char *desc, SAM_USER_INFO_25 * usr, prs_struct *ps, int depth)
5703 {
5704         if (usr == NULL)
5705                 return False;
5706
5707         prs_debug(ps, depth, desc, "sam_io_user_info25");
5708         depth++;
5709
5710         if(!prs_align(ps))
5711                 return False;
5712
5713         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
5714                 return False;
5715         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
5716                 return False;
5717         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
5718                 return False;
5719         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps, depth))
5720                 return False;
5721         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
5722                 return False;
5723         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
5724                 return False;
5725
5726         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth))  /* username unicode string header */
5727                 return False;
5728         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth))  /* user's full name unicode string header */
5729                 return False;
5730         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth))   /* home directory unicode string header */
5731                 return False;
5732         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth))  /* home directory drive */
5733                 return False;
5734         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth))       /* logon script unicode string header */
5735                 return False;
5736         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth))       /* profile path unicode string header */
5737                 return False;
5738         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth))  /* account desc */
5739                 return False;
5740         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth))       /* wkstas user can log on from */
5741                 return False;
5742         if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth))        /* unknown string */
5743                 return False;
5744         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
5745                 return False;
5746
5747         if(!prs_uint8s(False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
5748                 return False;
5749         if(!prs_uint8s(False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
5750                 return False;
5751
5752         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))    /* User ID */
5753                 return False;
5754         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))   /* Group ID */
5755                 return False;
5756         if(!prs_uint32("acb_info      ", ps, depth, &usr->acb_info))
5757                 return False;
5758
5759         if(!prs_uint32s(False, "unknown_6      ", ps, depth, usr->unknown_6, 6))
5760                 return False;
5761
5762         if(!prs_uint8s(False, "password      ", ps, depth, usr->pass, sizeof(usr->pass)))
5763                 return False;
5764
5765         /* here begins pointed-to data */
5766
5767         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth))      /* username unicode string */
5768                 return False;
5769
5770         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))      /* user's full name unicode string */
5771                 return False;
5772
5773         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))        /* home directory unicode string */
5774                 return False;
5775
5776         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))      /* home directory drive unicode string */
5777                 return False;
5778
5779         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))        /* logon script unicode string */
5780                 return False;
5781
5782         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))        /* profile path unicode string */
5783                 return False;
5784
5785         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))      /* user desc unicode string */
5786                 return False;
5787
5788         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))        /* worksations user can log on from */
5789                 return False;
5790
5791         if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str.buffer, ps, depth))  /* unknown string */
5792                 return False;
5793
5794         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
5795                 return False;
5796
5797 #if 0 /* JRA - unknown... */
5798         /* ok, this is only guess-work (as usual) */
5799         if (usr->ptr_logon_hrs) {
5800                 if(!prs_uint32("unknown_6     ", ps, depth, &usr->unknown_6))
5801                         return False;
5802                 if(!prs_uint32("padding4      ", ps, depth, &usr->padding4))
5803                         return False;
5804                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
5805                         return False;
5806         } else if (UNMARSHALLING(ps)) {
5807                 usr->unknown_6 = 0;
5808                 usr->padding4 = 0;
5809         }
5810 #endif
5811
5812         return True;
5813 }
5814
5815
5816 /*************************************************************************
5817  init_sam_user_info21W
5818
5819  unknown_3 = 0x00ff ffff
5820  unknown_6 = 0x0000 04ec
5821
5822  *************************************************************************/
5823
5824 void init_sam_user_info21W(SAM_USER_INFO_21 * usr,
5825                            NTTIME * logon_time,
5826                            NTTIME * logoff_time,
5827                            NTTIME * kickoff_time,
5828                            NTTIME * pass_last_set_time,
5829                            NTTIME * pass_can_change_time,
5830                            NTTIME * pass_must_change_time,
5831                            UNISTR2 *user_name,
5832                            UNISTR2 *full_name,
5833                            UNISTR2 *home_dir,
5834                            UNISTR2 *dir_drive,
5835                            UNISTR2 *log_scr,
5836                            UNISTR2 *prof_path,
5837                            UNISTR2 *desc,
5838                            UNISTR2 *wkstas,
5839                            UNISTR2 *unk_str,
5840                            UNISTR2 *mung_dial,
5841                            uchar lm_pwd[16],
5842                            uchar nt_pwd[16],
5843                            uint32 user_rid,
5844                            uint32 group_rid,
5845                            uint32 acb_info,
5846                            uint32 unknown_3,
5847                            uint16 logon_divs,
5848                            LOGON_HRS * hrs,
5849                            uint16 bad_password_count,
5850                            uint16 logon_count,
5851                            uint32 unknown_6)
5852 {
5853         usr->logon_time = *logon_time;
5854         usr->logoff_time = *logoff_time;
5855         usr->kickoff_time = *kickoff_time;
5856         usr->pass_last_set_time = *pass_last_set_time;
5857         usr->pass_can_change_time = *pass_can_change_time;
5858         usr->pass_must_change_time = *pass_must_change_time;
5859
5860         memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd));
5861         memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd));
5862
5863         usr->user_rid = user_rid;
5864         usr->group_rid = group_rid;
5865         usr->acb_info = acb_info;
5866         usr->unknown_3 = unknown_3;     /* 0x00ff ffff */
5867
5868         usr->logon_divs = logon_divs;   /* should be 168 (hours/week) */
5869         usr->ptr_logon_hrs = hrs ? 1 : 0;
5870         usr->bad_password_count = bad_password_count;
5871         usr->logon_count = logon_count;
5872
5873         if (nt_time_is_zero(pass_must_change_time)) {
5874                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5875         } else {
5876                 usr->passmustchange=0;
5877         }
5878
5879         ZERO_STRUCT(usr->padding1);
5880         ZERO_STRUCT(usr->padding2);
5881
5882         copy_unistr2(&usr->uni_user_name, user_name);
5883         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5884
5885         copy_unistr2(&usr->uni_full_name, full_name);
5886         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5887
5888         copy_unistr2(&usr->uni_home_dir, home_dir);
5889         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5890
5891         copy_unistr2(&usr->uni_dir_drive, dir_drive);
5892         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5893
5894         copy_unistr2(&usr->uni_logon_script, log_scr);
5895         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5896
5897         copy_unistr2(&usr->uni_profile_path, prof_path);
5898         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5899
5900         copy_unistr2(&usr->uni_acct_desc, desc);
5901         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5902
5903         copy_unistr2(&usr->uni_workstations, wkstas);
5904         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5905
5906         copy_unistr2(&usr->uni_unknown_str, unk_str);
5907         init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
5908
5909         copy_unistr2(&usr->uni_munged_dial, mung_dial);
5910         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5911
5912         usr->unknown_6 = unknown_6;     /* 0x0000 04ec */
5913         usr->padding4 = 0;
5914
5915         memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5916 }
5917
5918 /*************************************************************************
5919  init_sam_user_info21
5920
5921  unknown_3 = 0x00ff ffff
5922  unknown_6 = 0x0000 04ec
5923
5924  *************************************************************************/
5925
5926 NTSTATUS init_sam_user_info21A(SAM_USER_INFO_21 *usr, SAM_ACCOUNT *pw, DOM_SID *domain_sid)
5927 {
5928         NTTIME          logon_time, logoff_time, kickoff_time,
5929                         pass_last_set_time, pass_can_change_time,
5930                         pass_must_change_time;
5931
5932         const char*             user_name = pdb_get_username(pw);
5933         const char*             full_name = pdb_get_fullname(pw);
5934         const char*             home_dir  = pdb_get_homedir(pw);
5935         const char*             dir_drive = pdb_get_dir_drive(pw);
5936         const char*             logon_script = pdb_get_logon_script(pw);
5937         const char*             profile_path = pdb_get_profile_path(pw);
5938         const char*             description = pdb_get_acct_desc(pw);
5939         const char*             workstations = pdb_get_workstations(pw);
5940         const char*             munged_dial = pdb_get_munged_dial(pw);
5941         DATA_BLOB blob = base64_decode_data_blob(munged_dial);
5942
5943         uint32 user_rid;
5944         const DOM_SID *user_sid;
5945
5946         uint32 group_rid;
5947         const DOM_SID *group_sid;
5948
5949         /* Create NTTIME structs */
5950         unix_to_nt_time (&logon_time,           pdb_get_logon_time(pw));
5951         unix_to_nt_time (&logoff_time,          pdb_get_logoff_time(pw));
5952         unix_to_nt_time (&kickoff_time,         pdb_get_kickoff_time(pw));
5953         unix_to_nt_time (&pass_last_set_time,   pdb_get_pass_last_set_time(pw));
5954         unix_to_nt_time (&pass_can_change_time, pdb_get_pass_can_change_time(pw));
5955         unix_to_nt_time (&pass_must_change_time,pdb_get_pass_must_change_time(pw));
5956
5957         /* structure assignment */
5958         usr->logon_time            = logon_time;
5959         usr->logoff_time           = logoff_time;
5960         usr->kickoff_time          = kickoff_time;
5961         usr->pass_last_set_time    = pass_last_set_time;
5962         usr->pass_can_change_time  = pass_can_change_time;
5963         usr->pass_must_change_time = pass_must_change_time;
5964
5965         ZERO_STRUCT(usr->nt_pwd);
5966         ZERO_STRUCT(usr->lm_pwd);
5967
5968         user_sid = pdb_get_user_sid(pw);
5969
5970         if (!sid_peek_check_rid(domain_sid, user_sid, &user_rid)) {
5971                 fstring user_sid_string;
5972                 fstring domain_sid_string;
5973                 DEBUG(0, ("init_sam_user_info_21A: User %s has SID %s, \nwhich conflicts with "
5974                           "the domain sid %s.  Failing operation.\n",
5975                           user_name,
5976                           sid_to_string(user_sid_string, user_sid),
5977                           sid_to_string(domain_sid_string, domain_sid)));
5978                 data_blob_free(&blob);
5979                 return NT_STATUS_UNSUCCESSFUL;
5980         }
5981
5982         group_sid = pdb_get_group_sid(pw);
5983
5984         if (!sid_peek_check_rid(domain_sid, group_sid, &group_rid)) {
5985                 fstring group_sid_string;
5986                 fstring domain_sid_string;
5987                 DEBUG(0, ("init_sam_user_info_21A: User %s has Primary Group SID %s, \n"
5988                           "which conflicts with the domain sid %s.  Failing operation.\n",
5989                           user_name,
5990                           sid_to_string(group_sid_string, group_sid),
5991                           sid_to_string(domain_sid_string, domain_sid)));
5992                 data_blob_free(&blob);
5993                 return NT_STATUS_UNSUCCESSFUL;
5994         }
5995
5996         usr->user_rid  = user_rid;
5997         usr->group_rid = group_rid;
5998         usr->acb_info  = pdb_get_acct_ctrl(pw);
5999
6000         /*
6001           Look at a user on a real NT4 PDC with usrmgr, press
6002           'ok'. Then you will see that unknown_3 is set to
6003           0x08f827fa. Look at the user immediately after that again,
6004           and you will see that 0x00fffff is returned. This solves
6005           the problem that you get access denied after having looked
6006           at the user.
6007           -- Volker
6008         */
6009         usr->unknown_3 = 0x00ffffff;
6010
6011         usr->logon_divs = pdb_get_logon_divs(pw);
6012         usr->ptr_logon_hrs = pdb_get_hours(pw) ? 1 : 0;
6013         usr->bad_password_count = pdb_get_bad_password_count(pw);
6014         usr->logon_count = pdb_get_logon_count(pw);
6015
6016         if (pdb_get_pass_must_change_time(pw) == 0) {
6017                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6018         } else {
6019                 usr->passmustchange=0;
6020         }
6021
6022         ZERO_STRUCT(usr->padding1);
6023         ZERO_STRUCT(usr->padding2);
6024
6025         init_unistr2(&usr->uni_user_name, user_name, UNI_STR_TERMINATE);
6026         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6027
6028         init_unistr2(&usr->uni_full_name, full_name, UNI_STR_TERMINATE);
6029         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6030
6031         init_unistr2(&usr->uni_home_dir, home_dir, UNI_STR_TERMINATE);
6032         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6033
6034         init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_STR_TERMINATE);
6035         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6036
6037         init_unistr2(&usr->uni_logon_script, logon_script, UNI_STR_TERMINATE);
6038         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6039
6040         init_unistr2(&usr->uni_profile_path, profile_path, UNI_STR_TERMINATE);
6041         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6042
6043         init_unistr2(&usr->uni_acct_desc, description, UNI_STR_TERMINATE);
6044         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6045
6046         init_unistr2(&usr->uni_workstations, workstations, UNI_STR_TERMINATE);
6047         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6048
6049         init_unistr2(&usr->uni_unknown_str, NULL, UNI_STR_TERMINATE);
6050         init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
6051
6052         init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
6053         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6054         data_blob_free(&blob);
6055
6056         usr->unknown_6 = pdb_get_unknown_6(pw);
6057         usr->padding4 = 0;
6058
6059         if (pdb_get_hours(pw)) {
6060                 usr->logon_hrs.len = pdb_get_hours_len(pw);
6061                 memcpy(&usr->logon_hrs.hours, pdb_get_hours(pw), MAX_HOURS_LEN);
6062         } else
6063                 memset(&usr->logon_hrs, 0xff, sizeof(usr->logon_hrs));
6064
6065         return NT_STATUS_OK;
6066 }
6067
6068 /*******************************************************************
6069 reads or writes a structure.
6070 ********************************************************************/
6071
6072 static BOOL sam_io_user_info21(const char *desc, SAM_USER_INFO_21 * usr,
6073                         prs_struct *ps, int depth)
6074 {
6075         if (usr == NULL)
6076                 return False;
6077
6078         prs_debug(ps, depth, desc, "sam_io_user_info21");
6079         depth++;
6080
6081         if(!prs_align(ps))
6082                 return False;
6083
6084         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
6085                 return False;
6086         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
6087                 return False;
6088         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps,depth))
6089                 return False;
6090         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
6091                 return False;
6092         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps,depth))
6093                 return False;
6094         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time,  ps, depth))
6095                 return False;
6096
6097         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth))  /* username unicode string header */
6098                 return False;
6099         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth))  /* user's full name unicode string header */
6100                 return False;
6101         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth))   /* home directory unicode string header */
6102                 return False;
6103         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth))  /* home directory drive */
6104                 return False;
6105         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth))       /* logon script unicode string header */
6106                 return False;
6107         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth))       /* profile path unicode string header */
6108                 return False;
6109         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth))  /* account desc */
6110                 return False;
6111         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth))       /* wkstas user can log on from */
6112                 return False;
6113         if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth))        /* unknown string */
6114                 return False;
6115         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
6116                 return False;
6117
6118         if(!prs_uint8s(False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6119                 return False;
6120         if(!prs_uint8s(False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6121                 return False;
6122
6123         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))    /* User ID */
6124                 return False;
6125         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))   /* Group ID */
6126                 return False;
6127         if(!prs_uint32("acb_info      ", ps, depth, &usr->acb_info))
6128                 return False;
6129
6130         if(!prs_uint32("unknown_3     ", ps, depth, &usr->unknown_3))
6131                 return False;
6132         if(!prs_uint16("logon_divs    ", ps, depth, &usr->logon_divs))  /* logon divisions per week */
6133                 return False;
6134         if(!prs_align(ps))
6135                 return False;
6136         if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6137                 return False;
6138
6139         if(!prs_uint16("bad_password_count     ", ps, depth, &usr->bad_password_count))
6140                 return False;
6141         if(!prs_uint16("logon_count     ", ps, depth, &usr->logon_count))
6142                 return False;
6143
6144         if(!prs_uint8s(False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6145                 return False;
6146         if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6147                 return False;
6148         if(!prs_uint8("padding2       ", ps, depth, &usr->padding2))
6149                 return False;
6150
6151         /* here begins pointed-to data */
6152
6153         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name,usr->hdr_user_name.buffer, ps, depth))       /* username unicode string */
6154                 return False;
6155         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))      /* user's full name unicode string */
6156                 return False;
6157         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))        /* home directory unicode string */
6158                 return False;
6159         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))      /* home directory drive unicode string */
6160                 return False;
6161         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))        /* logon script unicode string */
6162                 return False;
6163         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))        /* profile path unicode string */
6164                 return False;
6165         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))      /* user desc unicode string */
6166                 return False;
6167         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))        /* worksations user can log on from */
6168                 return False;
6169         if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str.buffer, ps, depth))  /* unknown string */
6170                 return False;
6171         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))   /* worksations user can log on from */
6172                 return False;
6173
6174         /* ok, this is only guess-work (as usual) */
6175         if (usr->ptr_logon_hrs) {
6176                 if(!prs_align(ps))
6177                         return False;
6178                 if(!prs_uint32("unknown_6     ", ps, depth, &usr->unknown_6))
6179                         return False;
6180                 if(!prs_uint32("padding4      ", ps, depth, &usr->padding4))
6181                         return False;
6182                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6183                         return False;
6184         } else if (UNMARSHALLING(ps)) {
6185                 usr->unknown_6 = 0;
6186                 usr->padding4 = 0;
6187         }
6188
6189         return True;
6190 }
6191
6192 void init_sam_user_info20A(SAM_USER_INFO_20 *usr, SAM_ACCOUNT *pw)
6193 {
6194         const char *munged_dial = pdb_get_munged_dial(pw);
6195         DATA_BLOB blob = base64_decode_data_blob(munged_dial);
6196
6197         init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
6198         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6199         data_blob_free(&blob);
6200 }
6201
6202 /*******************************************************************
6203 reads or writes a structure.
6204 ********************************************************************/
6205
6206 static BOOL sam_io_user_info20(const char *desc, SAM_USER_INFO_20 *usr,
6207                         prs_struct *ps, int depth)
6208 {
6209         if (usr == NULL)
6210                 return False;
6211
6212         prs_debug(ps, depth, desc, "sam_io_user_info20");
6213         depth++;
6214
6215         if(!prs_align(ps))
6216                 return False;
6217
6218         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
6219                 return False;
6220
6221         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))   /* worksations user can log on from */
6222                 return False;
6223
6224         return True;
6225 }
6226
6227 /*******************************************************************
6228 inits a SAM_USERINFO_CTR structure.
6229 ********************************************************************/
6230
6231 NTSTATUS make_samr_userinfo_ctr_usr21(TALLOC_CTX *ctx, SAM_USERINFO_CTR * ctr,
6232                                     uint16 switch_value,
6233                                     SAM_USER_INFO_21 * usr)
6234 {
6235         DEBUG(5, ("init_samr_userinfo_ctr\n"));
6236
6237         ctr->switch_value = switch_value;
6238         ctr->info.id = NULL;
6239
6240         switch (switch_value) {
6241         case 0x10:
6242                 ctr->info.id10 = (SAM_USER_INFO_10 *)talloc_zero(ctx,sizeof(SAM_USER_INFO_10));
6243                 if (ctr->info.id10 == NULL)
6244                         return NT_STATUS_NO_MEMORY;
6245
6246                 init_sam_user_info10(ctr->info.id10, usr->acb_info);
6247                 break;
6248 #if 0
6249 /* whoops - got this wrong.  i think.  or don't understand what's happening. */
6250         case 0x11:
6251                 {
6252                         NTTIME expire;
6253                         info = (void *)&id11;
6254
6255                         expire.low = 0xffffffff;
6256                         expire.high = 0x7fffffff;
6257
6258                         ctr->info.id = (SAM_USER_INFO_11 *) talloc_zero(ctx,sizeof(*ctr->info.id11));
6259                         init_sam_user_info11(ctr->info.id11, &expire,
6260                                              "BROOKFIELDS$",    /* name */
6261                                              0x03ef,    /* user rid */
6262                                              0x201,     /* group rid */
6263                                              0x0080);   /* acb info */
6264
6265                         break;
6266                 }
6267 #endif
6268         case 0x12:
6269                 ctr->info.id12 = (SAM_USER_INFO_12 *)talloc_zero(ctx,sizeof(SAM_USER_INFO_12));
6270                 if (ctr->info.id12 == NULL)
6271                         return NT_STATUS_NO_MEMORY;
6272
6273                 init_sam_user_info12(ctr->info.id12, usr->lm_pwd, usr->nt_pwd);
6274                 break;
6275         case 21:
6276                 {
6277                         SAM_USER_INFO_21 *cusr;
6278                         cusr = (SAM_USER_INFO_21 *)talloc_zero(ctx,sizeof(SAM_USER_INFO_21));
6279                         ctr->info.id21 = cusr;
6280                         if (ctr->info.id21 == NULL)
6281                                 return NT_STATUS_NO_MEMORY;
6282                         memcpy(cusr, usr, sizeof(*usr));
6283                         memset(cusr->lm_pwd, 0, sizeof(cusr->lm_pwd));
6284                         memset(cusr->nt_pwd, 0, sizeof(cusr->nt_pwd));
6285                         break;
6286                 }
6287         default:
6288                 DEBUG(4,("make_samr_userinfo_ctr: unsupported info\n"));
6289                 return NT_STATUS_INVALID_INFO_CLASS;
6290         }
6291
6292         return NT_STATUS_OK;
6293 }
6294
6295 /*******************************************************************
6296 inits a SAM_USERINFO_CTR structure.
6297 ********************************************************************/
6298
6299 void init_samr_userinfo_ctr(SAM_USERINFO_CTR * ctr, uchar * sess_key,
6300                             uint16 switch_value, void *info)
6301 {
6302         DEBUG(5, ("init_samr_userinfo_ctr\n"));
6303
6304         ctr->switch_value = switch_value;
6305         ctr->info.id = info;
6306
6307         switch (switch_value) {
6308         case 0x18:
6309                 SamOEMhash(ctr->info.id24->pass, sess_key, 516);
6310                 dump_data(100, (char *)sess_key, 16);
6311                 dump_data(100, (char *)ctr->info.id24->pass, 516);
6312                 break;
6313         case 0x17:
6314                 SamOEMhash(ctr->info.id23->pass, sess_key, 516);
6315                 dump_data(100, (char *)sess_key, 16);
6316                 dump_data(100, (char *)ctr->info.id23->pass, 516);
6317                 break;
6318         default:
6319                 DEBUG(4,("init_samr_userinfo_ctr: unsupported switch level\n"));
6320         }
6321 }
6322
6323 /*******************************************************************
6324 reads or writes a structure.
6325 ********************************************************************/
6326
6327 static BOOL samr_io_userinfo_ctr(const char *desc, SAM_USERINFO_CTR **ppctr,
6328                                  prs_struct *ps, int depth)
6329 {
6330         BOOL ret;
6331         SAM_USERINFO_CTR *ctr;
6332
6333         prs_debug(ps, depth, desc, "samr_io_userinfo_ctr");
6334         depth++;
6335
6336         if (UNMARSHALLING(ps)) {
6337                 ctr = (SAM_USERINFO_CTR *)prs_alloc_mem(ps,sizeof(SAM_USERINFO_CTR));
6338                 if (ctr == NULL)
6339                         return False;
6340                 *ppctr = ctr;
6341         } else {
6342                 ctr = *ppctr;
6343         }
6344
6345         /* lkclXXXX DO NOT ALIGN BEFORE READING SWITCH VALUE! */
6346
6347         if(!prs_uint16("switch_value", ps, depth, &ctr->switch_value))
6348                 return False;
6349         if(!prs_align(ps))
6350                 return False;
6351
6352         ret = False;
6353
6354         switch (ctr->switch_value) {
6355         case 0x10:
6356                 if (UNMARSHALLING(ps))
6357                         ctr->info.id10 = (SAM_USER_INFO_10 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_10));
6358                 if (ctr->info.id10 == NULL) {
6359                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6360                         return False;
6361                 }
6362                 ret = sam_io_user_info10("", ctr->info.id10, ps, depth);
6363                 break;
6364         case 0x11:
6365                 if (UNMARSHALLING(ps))
6366                         ctr->info.id11 = (SAM_USER_INFO_11 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_11));
6367
6368                 if (ctr->info.id11 == NULL) {
6369                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6370                         return False;
6371                 }
6372                 ret = sam_io_user_info11("", ctr->info.id11, ps, depth);
6373                 break;
6374         case 0x12:
6375                 if (UNMARSHALLING(ps))
6376                         ctr->info.id12 = (SAM_USER_INFO_12 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_12));
6377
6378                 if (ctr->info.id12 == NULL) {
6379                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6380                         return False;
6381                 }
6382                 ret = sam_io_user_info12("", ctr->info.id12, ps, depth);
6383                 break;
6384         case 20:
6385                 if (UNMARSHALLING(ps))
6386                         ctr->info.id20 = (SAM_USER_INFO_20 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_20));
6387
6388                 if (ctr->info.id20 == NULL) {
6389                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6390                         return False;
6391                 }
6392                 ret = sam_io_user_info20("", ctr->info.id20, ps, depth);
6393                 break;
6394         case 21:
6395                 if (UNMARSHALLING(ps))
6396                         ctr->info.id21 = (SAM_USER_INFO_21 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_21));
6397
6398                 if (ctr->info.id21 == NULL) {
6399                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6400                         return False;
6401                 }
6402                 ret = sam_io_user_info21("", ctr->info.id21, ps, depth);
6403                 break;
6404         case 23:
6405                 if (UNMARSHALLING(ps))
6406                         ctr->info.id23 = (SAM_USER_INFO_23 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_23));
6407
6408                 if (ctr->info.id23 == NULL) {
6409                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6410                         return False;
6411                 }
6412                 ret = sam_io_user_info23("", ctr->info.id23, ps, depth);
6413                 break;
6414         case 24:
6415                 if (UNMARSHALLING(ps))
6416                         ctr->info.id24 = (SAM_USER_INFO_24 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_24));
6417
6418                 if (ctr->info.id24 == NULL) {
6419                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6420                         return False;
6421                 }
6422                 ret = sam_io_user_info24("", ctr->info.id24, ps,  depth);
6423                 break;
6424         case 25:
6425                 if (UNMARSHALLING(ps))
6426                         ctr->info.id25 = (SAM_USER_INFO_25 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_25));
6427
6428                 if (ctr->info.id25 == NULL) {
6429                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6430                         return False;
6431                 }
6432                 ret = sam_io_user_info25("", ctr->info.id25, ps, depth);
6433                 break;
6434         default:
6435                 DEBUG(2, ("samr_io_userinfo_ctr: unknown switch level 0x%x\n", ctr->switch_value));
6436                 ret = False;
6437                 break;
6438         }
6439
6440         return ret;
6441 }
6442
6443 /*******************************************************************
6444 inits a SAMR_R_QUERY_USERINFO structure.
6445 ********************************************************************/
6446
6447 void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO * r_u,
6448                                 SAM_USERINFO_CTR * ctr, NTSTATUS status)
6449 {
6450         DEBUG(5, ("init_samr_r_query_userinfo\n"));
6451
6452         r_u->ptr = 0;
6453         r_u->ctr = NULL;
6454
6455         if (NT_STATUS_IS_OK(status)) {
6456                 r_u->ptr = 1;
6457                 r_u->ctr = ctr;
6458         }
6459
6460         r_u->status = status;   /* return status */
6461 }
6462
6463 /*******************************************************************
6464 reads or writes a structure.
6465 ********************************************************************/
6466
6467 BOOL samr_io_r_query_userinfo(const char *desc, SAMR_R_QUERY_USERINFO * r_u,
6468                               prs_struct *ps, int depth)
6469 {
6470         if (r_u == NULL)
6471                 return False;
6472
6473         prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
6474         depth++;
6475
6476         if(!prs_align(ps))
6477                 return False;
6478
6479         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
6480                 return False;
6481
6482         if (r_u->ptr != 0) {
6483                 if(!samr_io_userinfo_ctr("ctr", &r_u->ctr, ps, depth))
6484                         return False;
6485         }
6486
6487         if(!prs_align(ps))
6488                 return False;
6489         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6490                 return False;
6491
6492         return True;
6493 }
6494
6495 /*******************************************************************
6496 inits a SAMR_Q_SET_USERINFO structure.
6497 ********************************************************************/
6498
6499 void init_samr_q_set_userinfo(SAMR_Q_SET_USERINFO * q_u,
6500                               POLICY_HND *hnd,  unsigned char sess_key[16],
6501                               uint16 switch_value, void *info)
6502 {
6503         DEBUG(5, ("init_samr_q_set_userinfo\n"));
6504
6505         q_u->pol = *hnd;
6506         q_u->switch_value = switch_value;
6507         init_samr_userinfo_ctr(q_u->ctr, sess_key, switch_value, info);
6508 }
6509
6510 /*******************************************************************
6511 reads or writes a structure.
6512 ********************************************************************/
6513
6514 BOOL samr_io_q_set_userinfo(const char *desc, SAMR_Q_SET_USERINFO * q_u,
6515                             prs_struct *ps, int depth)
6516 {
6517         if (q_u == NULL)
6518                 return False;
6519
6520         prs_debug(ps, depth, desc, "samr_io_q_set_userinfo");
6521         depth++;
6522
6523         if(!prs_align(ps))
6524                 return False;
6525
6526         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
6527
6528         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6529                 return False;
6530         if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6531                 return False;
6532
6533         return True;
6534 }
6535
6536 /*******************************************************************
6537 inits a SAMR_R_SET_USERINFO structure.
6538 ********************************************************************/
6539
6540 void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO * r_u, NTSTATUS status)
6541 {
6542         DEBUG(5, ("init_samr_r_set_userinfo\n"));
6543
6544         r_u->status = status;   /* return status */
6545 }
6546
6547 /*******************************************************************
6548 reads or writes a structure.
6549 ********************************************************************/
6550
6551 BOOL samr_io_r_set_userinfo(const char *desc, SAMR_R_SET_USERINFO * r_u,
6552                             prs_struct *ps, int depth)
6553 {
6554         if (r_u == NULL)
6555                 return False;
6556
6557         prs_debug(ps, depth, desc, "samr_io_r_set_userinfo");
6558         depth++;
6559
6560         if(!prs_align(ps))
6561                 return False;
6562
6563         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6564                 return False;
6565
6566         return True;
6567 }
6568
6569 /*******************************************************************
6570 inits a SAMR_Q_SET_USERINFO2 structure.
6571 ********************************************************************/
6572
6573 void init_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2 * q_u,
6574                                POLICY_HND *hnd, unsigned char sess_key[16],
6575                                uint16 switch_value, SAM_USERINFO_CTR * ctr)
6576 {
6577         DEBUG(5, ("init_samr_q_set_userinfo2\n"));
6578
6579         q_u->pol = *hnd;
6580         q_u->switch_value = switch_value;
6581         q_u->ctr = ctr;
6582
6583         if (q_u->ctr != NULL)
6584                 q_u->ctr->switch_value = switch_value;
6585
6586         switch (switch_value) {
6587         case 0x12:
6588                 SamOEMhash(ctr->info.id12->lm_pwd, sess_key, 16);
6589                 SamOEMhash(ctr->info.id12->nt_pwd, sess_key, 16);
6590                 dump_data(100, (char *)sess_key, 16);
6591                 dump_data(100, (char *)ctr->info.id12->lm_pwd, 16);
6592                 dump_data(100, (char *)ctr->info.id12->nt_pwd, 16);
6593                 break;
6594         }
6595 }
6596
6597 /*******************************************************************
6598 reads or writes a structure.
6599 ********************************************************************/
6600
6601 BOOL samr_io_q_set_userinfo2(const char *desc, SAMR_Q_SET_USERINFO2 * q_u,
6602                              prs_struct *ps, int depth)
6603 {
6604         if (q_u == NULL)
6605                 return False;
6606
6607         prs_debug(ps, depth, desc, "samr_io_q_set_userinfo2");
6608         depth++;
6609
6610         if(!prs_align(ps))
6611                 return False;
6612
6613         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
6614                 return False;
6615
6616         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6617                 return False;
6618         if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6619                 return False;
6620
6621         return True;
6622 }
6623
6624 /*******************************************************************
6625 inits a SAMR_R_SET_USERINFO2 structure.
6626 ********************************************************************/
6627
6628 void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 * r_u, NTSTATUS status)
6629 {
6630         DEBUG(5, ("init_samr_r_set_userinfo2\n"));
6631
6632         r_u->status = status;   /* return status */
6633 }
6634
6635 /*******************************************************************
6636 reads or writes a structure.
6637 ********************************************************************/
6638
6639 BOOL samr_io_r_set_userinfo2(const char *desc, SAMR_R_SET_USERINFO2 * r_u,
6640                              prs_struct *ps, int depth)
6641 {
6642         if (r_u == NULL)
6643                 return False;
6644
6645         prs_debug(ps, depth, desc, "samr_io_r_set_userinfo2");
6646         depth++;
6647
6648         if(!prs_align(ps))
6649                 return False;
6650
6651         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6652                 return False;
6653
6654         return True;
6655 }
6656
6657 /*******************************************************************
6658 inits a SAMR_Q_CONNECT structure.
6659 ********************************************************************/
6660
6661 void init_samr_q_connect(SAMR_Q_CONNECT * q_u,
6662                          char *srv_name, uint32 access_mask)
6663 {
6664         DEBUG(5, ("init_samr_q_connect\n"));
6665
6666         /* make PDC server name \\server */
6667         q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
6668         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
6669
6670         /* example values: 0x0000 0002 */
6671         q_u->access_mask = access_mask;
6672 }
6673
6674 /*******************************************************************
6675 reads or writes a structure.
6676 ********************************************************************/
6677
6678 BOOL samr_io_q_connect(const char *desc, SAMR_Q_CONNECT * q_u,
6679                        prs_struct *ps, int depth)
6680 {
6681         if (q_u == NULL)
6682                 return False;
6683
6684         prs_debug(ps, depth, desc, "samr_io_q_connect");
6685         depth++;
6686
6687         if(!prs_align(ps))
6688                 return False;
6689
6690         if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
6691                 return False;
6692         if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
6693                 return False;
6694
6695         if(!prs_align(ps))
6696                 return False;
6697         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6698                 return False;
6699
6700         return True;
6701 }
6702
6703 /*******************************************************************
6704 reads or writes a structure.
6705 ********************************************************************/
6706
6707 BOOL samr_io_r_connect(const char *desc, SAMR_R_CONNECT * r_u,
6708                        prs_struct *ps, int depth)
6709 {
6710         if (r_u == NULL)
6711                 return False;
6712
6713         prs_debug(ps, depth, desc, "samr_io_r_connect");
6714         depth++;
6715
6716         if(!prs_align(ps))
6717                 return False;
6718
6719         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6720                 return False;
6721
6722         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6723                 return False;
6724
6725         return True;
6726 }
6727
6728 /*******************************************************************
6729 inits a SAMR_Q_CONNECT4 structure.
6730 ********************************************************************/
6731
6732 void init_samr_q_connect4(SAMR_Q_CONNECT4 * q_u,
6733                           char *srv_name, uint32 access_mask)
6734 {
6735         DEBUG(5, ("init_samr_q_connect\n"));
6736
6737         /* make PDC server name \\server */
6738         q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
6739         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
6740
6741         /* Only value we've seen, possibly an address type ? */
6742         q_u->unk_0 = 2;
6743
6744         /* example values: 0x0000 0002 */
6745         q_u->access_mask = access_mask;
6746 }
6747
6748 /*******************************************************************
6749 reads or writes a structure.
6750 ********************************************************************/
6751
6752 BOOL samr_io_q_connect4(const char *desc, SAMR_Q_CONNECT4 * q_u,
6753                         prs_struct *ps, int depth)
6754 {
6755         if (q_u == NULL)
6756                 return False;
6757
6758         prs_debug(ps, depth, desc, "samr_io_q_connect4");
6759         depth++;
6760
6761         if(!prs_align(ps))
6762                 return False;
6763
6764         if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
6765                 return False;
6766         if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
6767                 return False;
6768
6769         if(!prs_align(ps))
6770                 return False;
6771         if(!prs_uint32("unk_0", ps, depth, &q_u->unk_0))
6772                 return False;
6773         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6774                 return False;
6775
6776         return True;
6777 }
6778
6779 /*******************************************************************
6780 reads or writes a structure.
6781 ********************************************************************/
6782
6783 BOOL samr_io_r_connect4(const char *desc, SAMR_R_CONNECT4 * r_u,
6784                         prs_struct *ps, int depth)
6785 {
6786         if (r_u == NULL)
6787                 return False;
6788
6789         prs_debug(ps, depth, desc, "samr_io_r_connect4");
6790         depth++;
6791
6792         if(!prs_align(ps))
6793                 return False;
6794
6795         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6796                 return False;
6797
6798         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6799                 return False;
6800
6801         return True;
6802 }
6803
6804 /*******************************************************************
6805 inits a SAMR_Q_CONNECT_ANON structure.
6806 ********************************************************************/
6807
6808 void init_samr_q_connect_anon(SAMR_Q_CONNECT_ANON * q_u)
6809 {
6810         DEBUG(5, ("init_samr_q_connect_anon\n"));
6811
6812         q_u->ptr = 1;
6813         q_u->unknown_0 = 0x5c;  /* server name (?!!) */
6814         q_u->unknown_1 = 0x01;
6815         q_u->access_mask = 0x20;
6816 }
6817
6818 /*******************************************************************
6819 reads or writes a structure.
6820 ********************************************************************/
6821
6822 BOOL samr_io_q_connect_anon(const char *desc, SAMR_Q_CONNECT_ANON * q_u,
6823                             prs_struct *ps, int depth)
6824 {
6825         if (q_u == NULL)
6826                 return False;
6827
6828         prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
6829         depth++;
6830
6831         if(!prs_align(ps))
6832                 return False;
6833
6834         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
6835                 return False;
6836         if(!prs_uint16("unknown_0", ps, depth, &q_u->unknown_0))
6837                 return False;
6838         if(!prs_uint16("unknown_1", ps, depth, &q_u->unknown_1))
6839                 return False;
6840         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6841                 return False;
6842
6843         return True;
6844 }
6845
6846 /*******************************************************************
6847 reads or writes a structure.
6848 ********************************************************************/
6849
6850 BOOL samr_io_r_connect_anon(const char *desc, SAMR_R_CONNECT_ANON * r_u,
6851                             prs_struct *ps, int depth)
6852 {
6853         if (r_u == NULL)
6854                 return False;
6855
6856         prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
6857         depth++;
6858
6859         if(!prs_align(ps))
6860                 return False;
6861
6862         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6863                 return False;
6864
6865         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6866                 return False;
6867
6868         return True;
6869 }
6870
6871 /*******************************************************************
6872 inits a SAMR_Q_GET_DOM_PWINFO structure.
6873 ********************************************************************/
6874
6875 void init_samr_q_get_dom_pwinfo(SAMR_Q_GET_DOM_PWINFO * q_u,
6876                                 char *srv_name)
6877 {
6878         DEBUG(5, ("init_samr_q_get_dom_pwinfo\n"));
6879
6880         q_u->ptr = 1;
6881         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_FLAGS_NONE);
6882         init_uni_hdr(&q_u->hdr_srv_name, &q_u->uni_srv_name);
6883 }
6884
6885 /*******************************************************************
6886 reads or writes a structure.
6887 ********************************************************************/
6888
6889 BOOL samr_io_q_get_dom_pwinfo(const char *desc, SAMR_Q_GET_DOM_PWINFO * q_u,
6890                               prs_struct *ps, int depth)
6891 {
6892         if (q_u == NULL)
6893                 return False;
6894
6895         prs_debug(ps, depth, desc, "samr_io_q_get_dom_pwinfo");
6896         depth++;
6897
6898         if(!prs_align(ps))
6899                 return False;
6900
6901         if(!prs_uint32("ptr", ps, depth, &q_u->ptr))
6902                 return False;
6903         if (q_u->ptr != 0) {
6904                 if(!smb_io_unihdr("", &q_u->hdr_srv_name, ps, depth))
6905                         return False;
6906                 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->hdr_srv_name.buffer, ps, depth))
6907                         return False;
6908         }
6909
6910         return True;
6911 }
6912
6913 /*******************************************************************
6914 reads or writes a structure.
6915 ********************************************************************/
6916
6917 BOOL samr_io_r_get_dom_pwinfo(const char *desc, SAMR_R_GET_DOM_PWINFO * r_u,
6918                               prs_struct *ps, int depth)
6919 {
6920         if (r_u == NULL)
6921                 return False;
6922
6923         prs_debug(ps, depth, desc, "samr_io_r_get_dom_pwinfo");
6924         depth++;
6925
6926         if(!prs_align(ps))
6927                 return False;
6928
6929         /*
6930          * We need 16 bytes here according to tests.  Don't know
6931          * what they are, but the length is important for the singing
6932         */
6933
6934         if(!prs_uint32("unk_0", ps, depth, &r_u->unk_0))
6935                 return False;
6936         if(!prs_uint32("unk_1", ps, depth, &r_u->unk_1))
6937                 return False;
6938         if(!prs_uint32("unk_2", ps, depth, &r_u->unk_2))
6939                 return False;
6940
6941         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6942                 return False;
6943
6944         return True;
6945 }
6946
6947 /*******************************************************************
6948 make a SAMR_ENC_PASSWD structure.
6949 ********************************************************************/
6950
6951 void init_enc_passwd(SAMR_ENC_PASSWD * pwd, char pass[512])
6952 {
6953         ZERO_STRUCTP(pwd);
6954
6955         if (pass == NULL) {
6956                 pwd->ptr = 0;
6957         } else {
6958                 pwd->ptr = 1;
6959                 memcpy(pwd->pass, pass, sizeof(pwd->pass));
6960         }
6961 }
6962
6963 /*******************************************************************
6964 reads or writes a SAMR_ENC_PASSWD structure.
6965 ********************************************************************/
6966
6967 BOOL samr_io_enc_passwd(const char *desc, SAMR_ENC_PASSWD * pwd,
6968                         prs_struct *ps, int depth)
6969 {
6970         if (pwd == NULL)
6971                 return False;
6972
6973         prs_debug(ps, depth, desc, "samr_io_enc_passwd");
6974         depth++;
6975
6976         if(!prs_align(ps))
6977                 return False;
6978
6979         if(!prs_uint32("ptr", ps, depth, &pwd->ptr))
6980                 return False;
6981
6982         if (pwd->ptr != 0) {
6983                 if(!prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass)))
6984                         return False;
6985         }
6986
6987         return True;
6988 }
6989
6990 /*******************************************************************
6991 inits a SAMR_ENC_HASH structure.
6992 ********************************************************************/
6993
6994 void init_enc_hash(SAMR_ENC_HASH * hsh, uchar hash[16])
6995 {
6996         ZERO_STRUCTP(hsh);
6997
6998         if (hash == NULL) {
6999                 hsh->ptr = 0;
7000         } else {
7001                 hsh->ptr = 1;
7002                 memcpy(hsh->hash, hash, sizeof(hsh->hash));
7003         }
7004 }
7005
7006 /*******************************************************************
7007 reads or writes a SAMR_ENC_HASH structure.
7008 ********************************************************************/
7009
7010 BOOL samr_io_enc_hash(const char *desc, SAMR_ENC_HASH * hsh,
7011                       prs_struct *ps, int depth)
7012 {
7013         if (hsh == NULL)
7014                 return False;
7015
7016         prs_debug(ps, depth, desc, "samr_io_enc_hash");
7017         depth++;
7018
7019         if(!prs_align(ps))
7020                 return False;
7021
7022         if(!prs_uint32("ptr ", ps, depth, &hsh->ptr))
7023                 return False;
7024         if (hsh->ptr != 0) {
7025                 if(!prs_uint8s(False, "hash", ps, depth, hsh->hash,sizeof(hsh->hash)))
7026                         return False;
7027         }
7028
7029         return True;
7030 }
7031
7032 /*******************************************************************
7033 inits a SAMR_R_GET_DOM_PWINFO structure.
7034 ********************************************************************/
7035
7036 void init_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER * q_u,
7037                                 char *dest_host, char *user_name,
7038                                 char nt_newpass[516],
7039                                 uchar nt_oldhash[16],
7040                                 char lm_newpass[516],
7041                                 uchar lm_oldhash[16])
7042 {
7043         DEBUG(5, ("init_samr_q_chgpasswd_user\n"));
7044
7045         q_u->ptr_0 = 1;
7046         init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7047         init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7048
7049         init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7050         init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7051
7052         init_enc_passwd(&q_u->nt_newpass, nt_newpass);
7053         init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7054
7055         q_u->unknown = 0x01;
7056
7057         init_enc_passwd(&q_u->lm_newpass, lm_newpass);
7058         init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7059 }
7060
7061 /*******************************************************************
7062 reads or writes a structure.
7063 ********************************************************************/
7064
7065 BOOL samr_io_q_chgpasswd_user(const char *desc, SAMR_Q_CHGPASSWD_USER * q_u,
7066                               prs_struct *ps, int depth)
7067 {
7068         if (q_u == NULL)
7069                 return False;
7070
7071         prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
7072         depth++;
7073
7074         if(!prs_align(ps))
7075                 return False;
7076
7077         if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7078                 return False;
7079
7080         if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7081                 return False;
7082         if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7083                 return False;
7084
7085         if(!prs_align(ps))
7086                 return False;
7087         if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7088                 return False;
7089         if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7090                 return False;
7091
7092         if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7093                 return False;
7094         if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7095                 return False;
7096
7097         if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
7098                 return False;
7099
7100         if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7101                 return False;
7102         if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7103                 return False;
7104
7105         return True;
7106 }
7107
7108 /*******************************************************************
7109 inits a SAMR_R_CHGPASSWD_USER structure.
7110 ********************************************************************/
7111
7112 void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER * r_u, NTSTATUS status)
7113 {
7114         DEBUG(5, ("init_r_chgpasswd_user\n"));
7115
7116         r_u->status = status;
7117 }
7118
7119 /*******************************************************************
7120 reads or writes a structure.
7121 ********************************************************************/
7122
7123 BOOL samr_io_r_chgpasswd_user(const char *desc, SAMR_R_CHGPASSWD_USER * r_u,
7124                               prs_struct *ps, int depth)
7125 {
7126         if (r_u == NULL)
7127                 return False;
7128
7129         prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
7130         depth++;
7131
7132         if(!prs_align(ps))
7133                 return False;
7134
7135         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7136                 return False;
7137
7138         return True;
7139 }
7140
7141 /*******************************************************************
7142 reads or writes a structure.
7143 ********************************************************************/
7144
7145 void init_samr_q_unknown_2e(SAMR_Q_UNKNOWN_2E *q_u,
7146                                 POLICY_HND *domain_pol, uint16 switch_value)
7147 {
7148         DEBUG(5, ("init_samr_q_unknown_2e\n"));
7149
7150         q_u->domain_pol = *domain_pol;
7151         q_u->switch_value = switch_value;
7152 }
7153
7154 /*******************************************************************
7155 reads or writes a structure.
7156 ********************************************************************/
7157
7158 BOOL samr_io_q_unknown_2e(const char *desc, SAMR_Q_UNKNOWN_2E *q_u,
7159                               prs_struct *ps, int depth)
7160 {
7161         if (q_u == NULL)
7162                 return False;
7163
7164         prs_debug(ps, depth, desc, "samr_io_q_unknown_2e");
7165         depth++;
7166
7167         if(!prs_align(ps))
7168                 return False;
7169
7170         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7171                 return False;
7172
7173         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7174                 return False;
7175
7176         return True;
7177 }
7178
7179 /*******************************************************************
7180 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7181 ********************************************************************/
7182
7183 void init_samr_r_samr_unknown_2e(SAMR_R_UNKNOWN_2E * r_u,
7184                                 uint16 switch_value, SAM_UNK_CTR * ctr,
7185                                 NTSTATUS status)
7186 {
7187         DEBUG(5, ("init_samr_r_samr_unknown_2e\n"));
7188
7189         r_u->ptr_0 = 0;
7190         r_u->switch_value = 0;
7191         r_u->status = status;   /* return status */
7192
7193         if (NT_STATUS_IS_OK(status)) {
7194                 r_u->switch_value = switch_value;
7195                 r_u->ptr_0 = 1;
7196                 r_u->ctr = ctr;
7197         }
7198 }
7199
7200 /*******************************************************************
7201 reads or writes a structure.
7202 ********************************************************************/
7203
7204 BOOL samr_io_r_samr_unknown_2e(const char *desc, SAMR_R_UNKNOWN_2E * r_u,
7205                               prs_struct *ps, int depth)
7206 {
7207         if (r_u == NULL)
7208                 return False;
7209
7210         prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
7211         depth++;
7212
7213         if(!prs_align(ps))
7214                 return False;
7215
7216         if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
7217                 return False;
7218
7219         if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
7220                 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
7221                         return False;
7222                 if(!prs_align(ps))
7223                         return False;
7224
7225                 switch (r_u->switch_value) {
7226                 case 0x0c:
7227                         if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
7228                                 return False;
7229                         break;
7230                 case 0x07:
7231                         if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
7232                                 return False;
7233                         break;
7234                 case 0x06:
7235                         if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
7236                                 return False;
7237                         break;
7238                 case 0x05:
7239                         if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
7240                                 return False;
7241                         break;
7242                 case 0x03:
7243                         if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
7244                                 return False;
7245                         break;
7246                 case 0x02:
7247                         if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
7248                                 return False;
7249                         break;
7250                 case 0x01:
7251                         if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
7252                                 return False;
7253                         break;
7254                 default:
7255                         DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
7256                                 r_u->switch_value));
7257                         r_u->status = NT_STATUS_INVALID_INFO_CLASS;
7258                         return False;
7259                 }
7260         }
7261
7262         if(!prs_align(ps))
7263                 return False;
7264
7265         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7266                 return False;
7267
7268         return True;
7269 }
7270
7271
7272 /*******************************************************************
7273 reads or writes a structure.
7274 ********************************************************************/
7275
7276 void init_samr_q_set_domain_info(SAMR_Q_SET_DOMAIN_INFO *q_u,
7277                                 POLICY_HND *domain_pol, uint16 switch_value, SAM_UNK_CTR *ctr)
7278 {
7279         DEBUG(5, ("init_samr_q_set_domain_info\n"));
7280
7281         q_u->domain_pol = *domain_pol;
7282         q_u->switch_value0 = switch_value;
7283
7284         q_u->switch_value = switch_value;
7285         q_u->ctr = ctr;
7286
7287 }
7288
7289 /*******************************************************************
7290 reads or writes a structure.
7291 ********************************************************************/
7292
7293 BOOL samr_io_q_set_domain_info(const char *desc, SAMR_Q_SET_DOMAIN_INFO *q_u,
7294                               prs_struct *ps, int depth)
7295 {
7296         if (q_u == NULL)
7297                 return False;
7298
7299         prs_debug(ps, depth, desc, "samr_io_q_set_domain_info");
7300         depth++;
7301
7302         if(!prs_align(ps))
7303                 return False;
7304
7305         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7306                 return False;
7307
7308         if(!prs_uint16("switch_value0", ps, depth, &q_u->switch_value0))
7309                 return False;
7310
7311         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7312                 return False;
7313
7314         if(!prs_align(ps))
7315                 return False;
7316
7317         if ((q_u->ctr = (SAM_UNK_CTR *)prs_alloc_mem(ps, sizeof(SAM_UNK_CTR))) == NULL)
7318                 return False;
7319
7320         switch (q_u->switch_value) {
7321
7322         case 0x0c:
7323                 if(!sam_io_unk_info12("unk_inf12", &q_u->ctr->info.inf12, ps, depth))
7324                         return False;
7325                 break;
7326         case 0x07:
7327                 if(!sam_io_unk_info7("unk_inf7",&q_u->ctr->info.inf7, ps,depth))
7328                         return False;
7329                 break;
7330         case 0x06:
7331                 if(!sam_io_unk_info6("unk_inf6",&q_u->ctr->info.inf6, ps,depth))
7332                         return False;
7333                 break;
7334         case 0x05:
7335                 if(!sam_io_unk_info5("unk_inf5",&q_u->ctr->info.inf5, ps,depth))
7336                         return False;
7337                 break;
7338         case 0x03:
7339                 if(!sam_io_unk_info3("unk_inf3",&q_u->ctr->info.inf3, ps,depth))
7340                         return False;
7341                 break;
7342         case 0x02:
7343                 if(!sam_io_unk_info2("unk_inf2",&q_u->ctr->info.inf2, ps,depth))
7344                         return False;
7345                 break;
7346         case 0x01:
7347                 if(!sam_io_unk_info1("unk_inf1",&q_u->ctr->info.inf1, ps,depth))
7348                         return False;
7349                 break;
7350         default:
7351                 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
7352                         q_u->switch_value));
7353                 return False;
7354         }
7355
7356         return True;
7357 }
7358
7359 /*******************************************************************
7360 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7361 ********************************************************************/
7362
7363 void init_samr_r_set_domain_info(SAMR_R_SET_DOMAIN_INFO * r_u, NTSTATUS status)
7364 {
7365         DEBUG(5, ("init_samr_r_set_domain_info\n"));
7366
7367         r_u->status = status;   /* return status */
7368 }
7369
7370 /*******************************************************************
7371 reads or writes a structure.
7372 ********************************************************************/
7373
7374 BOOL samr_io_r_set_domain_info(const char *desc, SAMR_R_SET_DOMAIN_INFO * r_u,
7375                               prs_struct *ps, int depth)
7376 {
7377         if (r_u == NULL)
7378                 return False;
7379
7380         prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
7381         depth++;
7382
7383         if(!prs_align(ps))
7384                 return False;
7385
7386         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7387                 return False;
7388
7389         return True;
7390 }