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