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