source/rpc_parse/parse_samr.c

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