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_GET_DISPENUM_INDEX structure.
2176 ********************************************************************/
2177
2178 void init_samr_q_get_dispenum_index(SAMR_Q_GET_DISPENUM_INDEX * q_e, POLICY_HND *pol,
2179                                     uint16 switch_level, const char *name)
2180 {
2181         DEBUG(5, ("init_samr_q_get_dispenum_index\n"));
2182
2183         q_e->domain_pol = *pol;
2184
2185         q_e->switch_level = switch_level;
2186
2187         init_lsa_string(&q_e->name, name);
2188 }
2189
2190 /*******************************************************************
2191 reads or writes a structure.
2192 ********************************************************************/
2193
2194 BOOL samr_io_q_get_dispenum_index(const char *desc, SAMR_Q_GET_DISPENUM_INDEX * q_e,
2195                                   prs_struct *ps, int depth)
2196 {
2197         if (q_e == NULL)
2198                 return False;
2199
2200         prs_debug(ps, depth, desc, "samr_io_q_get_dispenum_index");
2201         depth++;
2202
2203         if(!prs_align(ps))
2204                 return False;
2205
2206         if(!smb_io_pol_hnd("domain_pol", &q_e->domain_pol, ps, depth))
2207                 return False;
2208
2209         if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
2210                 return False;
2211
2212         if (!smb_io_lsa_string("name", &q_e->name, ps, depth))
2213                 return False;
2214
2215         return True;
2216 }
2217
2218 /*******************************************************************
2219 reads or writes a structure.
2220 ********************************************************************/
2221
2222 BOOL samr_io_r_get_dispenum_index(const char *desc, SAMR_R_GET_DISPENUM_INDEX * r_u,
2223                                   prs_struct *ps, int depth)
2224 {
2225         if (r_u == NULL)
2226                 return False;
2227
2228         prs_debug(ps, depth, desc, "samr_io_r_get_dispenum_index");
2229         depth++;
2230
2231         if(!prs_align(ps))
2232                 return False;
2233
2234         if(!prs_uint32("idx", ps, depth, &r_u->idx))
2235                 return False;
2236
2237         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2238                 return False;
2239
2240         return True;
2241 }
2242
2243
2244 /*******************************************************************
2245 inits a SAMR_Q_OPEN_GROUP structure.
2246 ********************************************************************/
2247
2248 void init_samr_q_open_group(SAMR_Q_OPEN_GROUP * q_c,
2249                             POLICY_HND *hnd,
2250                             uint32 access_mask, uint32 rid)
2251 {
2252         DEBUG(5, ("init_samr_q_open_group\n"));
2253
2254         q_c->domain_pol = *hnd;
2255         q_c->access_mask = access_mask;
2256         q_c->rid_group = rid;
2257 }
2258
2259 /*******************************************************************
2260 reads or writes a structure.
2261 ********************************************************************/
2262
2263 BOOL samr_io_q_open_group(const char *desc, SAMR_Q_OPEN_GROUP * q_u,
2264                           prs_struct *ps, int depth)
2265 {
2266         if (q_u == NULL)
2267                 return False;
2268
2269         prs_debug(ps, depth, desc, "samr_io_q_open_group");
2270         depth++;
2271
2272         if(!prs_align(ps))
2273                 return False;
2274
2275         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
2276                 return False;
2277
2278         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
2279                 return False;
2280         if(!prs_uint32("rid_group", ps, depth, &q_u->rid_group))
2281                 return False;
2282
2283         return True;
2284 }
2285
2286 /*******************************************************************
2287 reads or writes a structure.
2288 ********************************************************************/
2289
2290 BOOL samr_io_r_open_group(const char *desc, SAMR_R_OPEN_GROUP * r_u,
2291                           prs_struct *ps, int depth)
2292 {
2293         if (r_u == NULL)
2294                 return False;
2295
2296         prs_debug(ps, depth, desc, "samr_io_r_open_group");
2297         depth++;
2298
2299         if(!prs_align(ps))
2300                 return False;
2301
2302         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2303                 return False;
2304
2305         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2306                 return False;
2307
2308         return True;
2309 }
2310
2311 /*******************************************************************
2312 inits a GROUP_INFO1 structure.
2313 ********************************************************************/
2314
2315 void init_samr_group_info1(GROUP_INFO1 * gr1,
2316                            char *acct_name, char *acct_desc,
2317                            uint32 num_members)
2318 {
2319         DEBUG(5, ("init_samr_group_info1\n"));
2320
2321         gr1->group_attr = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT); /* why not | SE_GROUP_ENABLED ? */
2322         gr1->num_members = num_members;
2323
2324         init_unistr2(&gr1->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2325         init_uni_hdr(&gr1->hdr_acct_name, &gr1->uni_acct_name);
2326         init_unistr2(&gr1->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2327         init_uni_hdr(&gr1->hdr_acct_desc, &gr1->uni_acct_desc);
2328 }
2329
2330 /*******************************************************************
2331 reads or writes a structure.
2332 ********************************************************************/
2333
2334 BOOL samr_io_group_info1(const char *desc, GROUP_INFO1 * gr1,
2335                          prs_struct *ps, int depth)
2336 {
2337         uint16 dummy = 1;
2338
2339         if (gr1 == NULL)
2340                 return False;
2341
2342         prs_debug(ps, depth, desc, "samr_io_group_info1");
2343         depth++;
2344
2345         if(!prs_uint16("level", ps, depth, &dummy))
2346                 return False;
2347
2348         if(!prs_align(ps))
2349                 return False;
2350
2351         if(!smb_io_unihdr("hdr_acct_name", &gr1->hdr_acct_name, ps, depth))
2352                 return False;
2353
2354         if(!prs_uint32("group_attr", ps, depth, &gr1->group_attr))
2355                 return False;
2356         if(!prs_uint32("num_members", ps, depth, &gr1->num_members))
2357                 return False;
2358
2359         if(!smb_io_unihdr("hdr_acct_desc", &gr1->hdr_acct_desc, ps, depth))
2360                 return False;
2361
2362         if(!smb_io_unistr2("uni_acct_name", &gr1->uni_acct_name,
2363                            gr1->hdr_acct_name.buffer, ps, depth))
2364                 return False;
2365
2366         if(!smb_io_unistr2("uni_acct_desc", &gr1->uni_acct_desc,
2367                            gr1->hdr_acct_desc.buffer, ps, depth))
2368                 return False;
2369
2370         return True;
2371 }
2372
2373 /*******************************************************************
2374 inits a GROUP_INFO2 structure.
2375 ********************************************************************/
2376
2377 void init_samr_group_info2(GROUP_INFO2 * gr2, const char *acct_name)
2378 {
2379         DEBUG(5, ("init_samr_group_info2\n"));
2380
2381         gr2->level = 2;
2382         init_unistr2(&gr2->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2383         init_uni_hdr(&gr2->hdr_acct_name, &gr2->uni_acct_name);
2384 }
2385
2386 /*******************************************************************
2387 reads or writes a structure.
2388 ********************************************************************/
2389
2390 BOOL samr_io_group_info2(const char *desc, GROUP_INFO2 *gr2, prs_struct *ps, int depth)
2391 {
2392         if (gr2 == NULL)
2393                 return False;
2394
2395         prs_debug(ps, depth, desc, "samr_io_group_info2");
2396         depth++;
2397
2398         if(!prs_uint16("hdr_level", ps, depth, &gr2->level))
2399                 return False;
2400
2401         if(!smb_io_unihdr("hdr_acct_name", &gr2->hdr_acct_name, ps, depth))
2402                 return False;
2403         if(!smb_io_unistr2("uni_acct_name", &gr2->uni_acct_name,
2404                            gr2->hdr_acct_name.buffer, ps, depth))
2405                 return False;
2406
2407         return True;
2408 }
2409
2410 /*******************************************************************
2411 inits a GROUP_INFO3 structure.
2412 ********************************************************************/
2413
2414 void init_samr_group_info3(GROUP_INFO3 *gr3)
2415 {
2416         DEBUG(5, ("init_samr_group_info3\n"));
2417
2418         gr3->group_attr = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT); /* why not | SE_GROUP_ENABLED ? */
2419 }
2420
2421 /*******************************************************************
2422 reads or writes a structure.
2423 ********************************************************************/
2424
2425 BOOL samr_io_group_info3(const char *desc, GROUP_INFO3 *gr3, prs_struct *ps, int depth)
2426 {
2427         if (gr3 == NULL)
2428                 return False;
2429
2430         prs_debug(ps, depth, desc, "samr_io_group_info3");
2431         depth++;
2432
2433         if(!prs_align(ps))
2434                 return False;
2435
2436         if(!prs_uint32("group_attr", ps, depth, &gr3->group_attr))
2437                 return False;
2438
2439         return True;
2440 }
2441
2442 /*******************************************************************
2443 inits a GROUP_INFO4 structure.
2444 ********************************************************************/
2445
2446 void init_samr_group_info4(GROUP_INFO4 * gr4, const char *acct_desc)
2447 {
2448         DEBUG(5, ("init_samr_group_info4\n"));
2449
2450         gr4->level = 4;
2451         init_unistr2(&gr4->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2452         init_uni_hdr(&gr4->hdr_acct_desc, &gr4->uni_acct_desc);
2453 }
2454
2455 /*******************************************************************
2456 reads or writes a structure.
2457 ********************************************************************/
2458
2459 BOOL samr_io_group_info4(const char *desc, GROUP_INFO4 * gr4,
2460                          prs_struct *ps, int depth)
2461 {
2462         if (gr4 == NULL)
2463                 return False;
2464
2465         prs_debug(ps, depth, desc, "samr_io_group_info4");
2466         depth++;
2467
2468         if(!prs_uint16("hdr_level", ps, depth, &gr4->level))
2469                 return False;
2470         if(!smb_io_unihdr("hdr_acct_desc", &gr4->hdr_acct_desc, ps, depth))
2471                 return False;
2472         if(!smb_io_unistr2("uni_acct_desc", &gr4->uni_acct_desc,
2473                            gr4->hdr_acct_desc.buffer, ps, depth))
2474                 return False;
2475
2476         return True;
2477 }
2478
2479 /*******************************************************************
2480 inits a GROUP_INFO5 structure.
2481 ********************************************************************/
2482
2483 void init_samr_group_info5(GROUP_INFO5 * gr5,
2484                            char *acct_name, char *acct_desc,
2485                            uint32 num_members)
2486 {
2487         DEBUG(5, ("init_samr_group_info5\n"));
2488
2489         gr5->group_attr = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT); /* why not | SE_GROUP_ENABLED ? */
2490         gr5->num_members = num_members;
2491
2492         init_unistr2(&gr5->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2493         init_uni_hdr(&gr5->hdr_acct_name, &gr5->uni_acct_name);
2494         init_unistr2(&gr5->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2495         init_uni_hdr(&gr5->hdr_acct_desc, &gr5->uni_acct_desc);
2496 }
2497
2498 /*******************************************************************
2499 reads or writes a structure.
2500 ********************************************************************/
2501
2502 BOOL samr_io_group_info5(const char *desc, GROUP_INFO5 * gr5,
2503                          prs_struct *ps, int depth)
2504 {
2505         uint16 dummy = 1;
2506
2507         if (gr5 == NULL)
2508                 return False;
2509
2510         prs_debug(ps, depth, desc, "samr_io_group_info5");
2511         depth++;
2512
2513         if(!prs_uint16("level", ps, depth, &dummy))
2514                 return False;
2515
2516         if(!prs_align(ps))
2517                 return False;
2518
2519         if(!smb_io_unihdr("hdr_acct_name", &gr5->hdr_acct_name, ps, depth))
2520                 return False;
2521
2522         if(!prs_uint32("group_attr", ps, depth, &gr5->group_attr))
2523                 return False;
2524         if(!prs_uint32("num_members", ps, depth, &gr5->num_members))
2525                 return False;
2526
2527         if(!smb_io_unihdr("hdr_acct_desc", &gr5->hdr_acct_desc, ps, depth))
2528                 return False;
2529
2530         if(!smb_io_unistr2("uni_acct_name", &gr5->uni_acct_name,
2531                            gr5->hdr_acct_name.buffer, ps, depth))
2532                 return False;
2533
2534         if(!smb_io_unistr2("uni_acct_desc", &gr5->uni_acct_desc,
2535                            gr5->hdr_acct_desc.buffer, ps, depth))
2536                 return False;
2537
2538         return True;
2539 }
2540
2541
2542 /*******************************************************************
2543 reads or writes a structure.
2544 ********************************************************************/
2545
2546 static BOOL samr_group_info_ctr(const char *desc, GROUP_INFO_CTR **ctr,
2547                                 prs_struct *ps, int depth)
2548 {
2549         if (UNMARSHALLING(ps))
2550                 *ctr = PRS_ALLOC_MEM(ps,GROUP_INFO_CTR,1);
2551
2552         if (*ctr == NULL)
2553                 return False;
2554
2555         prs_debug(ps, depth, desc, "samr_group_info_ctr");
2556         depth++;
2557
2558         if(!prs_uint16("switch_value1", ps, depth, &(*ctr)->switch_value1))
2559                 return False;
2560
2561         switch ((*ctr)->switch_value1) {
2562         case 1:
2563                 if(!samr_io_group_info1("group_info1", &(*ctr)->group.info1, ps, depth))
2564                         return False;
2565                 break;
2566         case 2:
2567                 if(!samr_io_group_info2("group_info2", &(*ctr)->group.info2, ps, depth))
2568                         return False;
2569                 break;
2570         case 3:
2571                 if(!samr_io_group_info3("group_info3", &(*ctr)->group.info3, ps, depth))
2572                         return False;
2573                 break;
2574         case 4:
2575                 if(!samr_io_group_info4("group_info4", &(*ctr)->group.info4, ps, depth))
2576                         return False;
2577                 break;
2578         case 5:
2579                 if(!samr_io_group_info5("group_info5", &(*ctr)->group.info5, ps, depth))
2580                         return False;
2581                 break;
2582         default:
2583                 DEBUG(0,("samr_group_info_ctr: unsupported switch level\n"));
2584                 break;
2585         }
2586
2587         return True;
2588 }
2589
2590 /*******************************************************************
2591 inits a SAMR_Q_CREATE_DOM_GROUP structure.
2592 ********************************************************************/
2593
2594 void init_samr_q_create_dom_group(SAMR_Q_CREATE_DOM_GROUP * q_e,
2595                                   POLICY_HND *pol, const char *acct_desc,
2596                                   uint32 access_mask)
2597 {
2598         DEBUG(5, ("init_samr_q_create_dom_group\n"));
2599
2600         q_e->pol = *pol;
2601
2602         init_unistr2(&q_e->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2603         init_uni_hdr(&q_e->hdr_acct_desc, &q_e->uni_acct_desc);
2604
2605         q_e->access_mask = access_mask;
2606 }
2607
2608 /*******************************************************************
2609 reads or writes a structure.
2610 ********************************************************************/
2611
2612 BOOL samr_io_q_create_dom_group(const char *desc, SAMR_Q_CREATE_DOM_GROUP * q_e,
2613                                 prs_struct *ps, int depth)
2614 {
2615         if (q_e == NULL)
2616                 return False;
2617
2618         prs_debug(ps, depth, desc, "samr_io_q_create_dom_group");
2619         depth++;
2620
2621         if(!prs_align(ps))
2622                 return False;
2623
2624         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2625                 return False;
2626
2627         if(!smb_io_unihdr("hdr_acct_desc", &q_e->hdr_acct_desc, ps, depth))
2628                 return False;
2629         if(!smb_io_unistr2("uni_acct_desc", &q_e->uni_acct_desc,
2630                        q_e->hdr_acct_desc.buffer, ps, depth))
2631                 return False;
2632
2633         if(!prs_align(ps))
2634                 return False;
2635         if(!prs_uint32("access", ps, depth, &q_e->access_mask))
2636                 return False;
2637
2638         return True;
2639 }
2640
2641 /*******************************************************************
2642 reads or writes a structure.
2643 ********************************************************************/
2644
2645 BOOL samr_io_r_create_dom_group(const char *desc, SAMR_R_CREATE_DOM_GROUP * r_u,
2646                                 prs_struct *ps, int depth)
2647 {
2648         if (r_u == NULL)
2649                 return False;
2650
2651         prs_debug(ps, depth, desc, "samr_io_r_create_dom_group");
2652         depth++;
2653
2654         if(!prs_align(ps))
2655                 return False;
2656
2657         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2658                 return False;
2659
2660         if(!prs_uint32("rid   ", ps, depth, &r_u->rid))
2661                 return False;
2662         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2663                 return False;
2664
2665         return True;
2666 }
2667
2668 /*******************************************************************
2669 inits a SAMR_Q_DELETE_DOM_GROUP structure.
2670 ********************************************************************/
2671
2672 void init_samr_q_delete_dom_group(SAMR_Q_DELETE_DOM_GROUP * q_c,
2673                                   POLICY_HND *hnd)
2674 {
2675         DEBUG(5, ("init_samr_q_delete_dom_group\n"));
2676
2677         q_c->group_pol = *hnd;
2678 }
2679
2680 /*******************************************************************
2681 reads or writes a structure.
2682 ********************************************************************/
2683
2684 BOOL samr_io_q_delete_dom_group(const char *desc, SAMR_Q_DELETE_DOM_GROUP * q_u,
2685                                 prs_struct *ps, int depth)
2686 {
2687         if (q_u == NULL)
2688                 return False;
2689
2690         prs_debug(ps, depth, desc, "samr_io_q_delete_dom_group");
2691         depth++;
2692
2693         if(!prs_align(ps))
2694                 return False;
2695
2696         if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
2697                 return False;
2698
2699         return True;
2700 }
2701
2702 /*******************************************************************
2703 reads or writes a structure.
2704 ********************************************************************/
2705
2706 BOOL samr_io_r_delete_dom_group(const char *desc, SAMR_R_DELETE_DOM_GROUP * r_u,
2707                                 prs_struct *ps, int depth)
2708 {
2709         if (r_u == NULL)
2710                 return False;
2711
2712         prs_debug(ps, depth, desc, "samr_io_r_delete_dom_group");
2713         depth++;
2714
2715         if(!prs_align(ps))
2716                 return False;
2717
2718         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2719                 return False;
2720
2721         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2722                 return False;
2723
2724         return True;
2725 }
2726
2727 /*******************************************************************
2728 inits a SAMR_Q_DEL_GROUPMEM structure.
2729 ********************************************************************/
2730
2731 void init_samr_q_del_groupmem(SAMR_Q_DEL_GROUPMEM * q_e,
2732                               POLICY_HND *pol, uint32 rid)
2733 {
2734         DEBUG(5, ("init_samr_q_del_groupmem\n"));
2735
2736         q_e->pol = *pol;
2737         q_e->rid = rid;
2738 }
2739
2740 /*******************************************************************
2741 reads or writes a structure.
2742 ********************************************************************/
2743
2744 BOOL samr_io_q_del_groupmem(const char *desc, SAMR_Q_DEL_GROUPMEM * q_e,
2745                             prs_struct *ps, int depth)
2746 {
2747         if (q_e == NULL)
2748                 return False;
2749
2750         prs_debug(ps, depth, desc, "samr_io_q_del_groupmem");
2751         depth++;
2752
2753         if(!prs_align(ps))
2754                 return False;
2755
2756         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2757                 return False;
2758
2759         if(!prs_uint32("rid", ps, depth, &q_e->rid))
2760                 return False;
2761
2762         return True;
2763 }
2764
2765 /*******************************************************************
2766 inits a SAMR_R_DEL_GROUPMEM structure.
2767 ********************************************************************/
2768
2769 void init_samr_r_del_groupmem(SAMR_R_DEL_GROUPMEM * r_u, POLICY_HND *pol,
2770                               NTSTATUS status)
2771 {
2772         DEBUG(5, ("init_samr_r_del_groupmem\n"));
2773
2774         r_u->status = status;
2775 }
2776
2777 /*******************************************************************
2778 reads or writes a structure.
2779 ********************************************************************/
2780
2781 BOOL samr_io_r_del_groupmem(const char *desc, SAMR_R_DEL_GROUPMEM * r_u,
2782                             prs_struct *ps, int depth)
2783 {
2784         if (r_u == NULL)
2785                 return False;
2786
2787         prs_debug(ps, depth, desc, "samr_io_r_del_groupmem");
2788         depth++;
2789
2790         if(!prs_align(ps))
2791                 return False;
2792
2793         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2794                 return False;
2795
2796         return True;
2797 }
2798
2799 /*******************************************************************
2800 inits a SAMR_Q_ADD_GROUPMEM structure.
2801 ********************************************************************/
2802
2803 void init_samr_q_add_groupmem(SAMR_Q_ADD_GROUPMEM * q_e,
2804                               POLICY_HND *pol, uint32 rid)
2805 {
2806         DEBUG(5, ("init_samr_q_add_groupmem\n"));
2807
2808         q_e->pol = *pol;
2809         q_e->rid = rid;
2810         q_e->unknown = 0x0005;
2811 }
2812
2813 /*******************************************************************
2814 reads or writes a structure.
2815 ********************************************************************/
2816
2817 BOOL samr_io_q_add_groupmem(const char *desc, SAMR_Q_ADD_GROUPMEM * q_e,
2818                             prs_struct *ps, int depth)
2819 {
2820         if (q_e == NULL)
2821                 return False;
2822
2823         prs_debug(ps, depth, desc, "samr_io_q_add_groupmem");
2824         depth++;
2825
2826         if(!prs_align(ps))
2827                 return False;
2828
2829         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2830                 return False;
2831
2832         if(!prs_uint32("rid    ", ps, depth, &q_e->rid))
2833                 return False;
2834         if(!prs_uint32("unknown", ps, depth, &q_e->unknown))
2835                 return False;
2836
2837         return True;
2838 }
2839
2840 /*******************************************************************
2841 inits a SAMR_R_ADD_GROUPMEM structure.
2842 ********************************************************************/
2843
2844 void init_samr_r_add_groupmem(SAMR_R_ADD_GROUPMEM * r_u, POLICY_HND *pol,
2845                               NTSTATUS status)
2846 {
2847         DEBUG(5, ("init_samr_r_add_groupmem\n"));
2848
2849         r_u->status = status;
2850 }
2851
2852 /*******************************************************************
2853 reads or writes a structure.
2854 ********************************************************************/
2855
2856 BOOL samr_io_r_add_groupmem(const char *desc, SAMR_R_ADD_GROUPMEM * r_u,
2857                             prs_struct *ps, int depth)
2858 {
2859         if (r_u == NULL)
2860                 return False;
2861
2862         prs_debug(ps, depth, desc, "samr_io_r_add_groupmem");
2863         depth++;
2864
2865         if(!prs_align(ps))
2866                 return False;
2867
2868         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2869                 return False;
2870
2871         return True;
2872 }
2873
2874 /*******************************************************************
2875 inits a SAMR_Q_SET_GROUPINFO structure.
2876 ********************************************************************/
2877
2878 void init_samr_q_set_groupinfo(SAMR_Q_SET_GROUPINFO * q_e,
2879                                POLICY_HND *pol, GROUP_INFO_CTR * ctr)
2880 {
2881         DEBUG(5, ("init_samr_q_set_groupinfo\n"));
2882
2883         q_e->pol = *pol;
2884         q_e->ctr = ctr;
2885 }
2886
2887 /*******************************************************************
2888 reads or writes a structure.
2889 ********************************************************************/
2890
2891 BOOL samr_io_q_set_groupinfo(const char *desc, SAMR_Q_SET_GROUPINFO * q_e,
2892                              prs_struct *ps, int depth)
2893 {
2894         if (q_e == NULL)
2895                 return False;
2896
2897         prs_debug(ps, depth, desc, "samr_io_q_set_groupinfo");
2898         depth++;
2899
2900         if(!prs_align(ps))
2901                 return False;
2902
2903         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2904                 return False;
2905
2906         if(!samr_group_info_ctr("ctr", &q_e->ctr, ps, depth))
2907                 return False;
2908
2909         return True;
2910 }
2911
2912 /*******************************************************************
2913 inits a SAMR_R_SET_GROUPINFO structure.
2914 ********************************************************************/
2915
2916 void init_samr_r_set_groupinfo(SAMR_R_SET_GROUPINFO * r_u, NTSTATUS status)
2917 {
2918         DEBUG(5, ("init_samr_r_set_groupinfo\n"));
2919
2920         r_u->status = status;
2921 }
2922
2923 /*******************************************************************
2924 reads or writes a structure.
2925 ********************************************************************/
2926
2927 BOOL samr_io_r_set_groupinfo(const char *desc, SAMR_R_SET_GROUPINFO * r_u,
2928                              prs_struct *ps, int depth)
2929 {
2930         if (r_u == NULL)
2931                 return False;
2932
2933         prs_debug(ps, depth, desc, "samr_io_r_set_groupinfo");
2934         depth++;
2935
2936         if(!prs_align(ps))
2937                 return False;
2938
2939         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2940                 return False;
2941
2942         return True;
2943 }
2944
2945 /*******************************************************************
2946 inits a SAMR_Q_QUERY_GROUPINFO structure.
2947 ********************************************************************/
2948
2949 void init_samr_q_query_groupinfo(SAMR_Q_QUERY_GROUPINFO * q_e,
2950                                  POLICY_HND *pol, uint16 switch_level)
2951 {
2952         DEBUG(5, ("init_samr_q_query_groupinfo\n"));
2953
2954         q_e->pol = *pol;
2955
2956         q_e->switch_level = switch_level;
2957 }
2958
2959 /*******************************************************************
2960 reads or writes a structure.
2961 ********************************************************************/
2962
2963 BOOL samr_io_q_query_groupinfo(const char *desc, SAMR_Q_QUERY_GROUPINFO * q_e,
2964                                prs_struct *ps, int depth)
2965 {
2966         if (q_e == NULL)
2967                 return False;
2968
2969         prs_debug(ps, depth, desc, "samr_io_q_query_groupinfo");
2970         depth++;
2971
2972         if(!prs_align(ps))
2973                 return False;
2974
2975         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2976                 return False;
2977
2978         if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
2979                 return False;
2980
2981         return True;
2982 }
2983
2984 /*******************************************************************
2985 inits a SAMR_R_QUERY_GROUPINFO structure.
2986 ********************************************************************/
2987
2988 void init_samr_r_query_groupinfo(SAMR_R_QUERY_GROUPINFO * r_u,
2989                                  GROUP_INFO_CTR * ctr, NTSTATUS status)
2990 {
2991         DEBUG(5, ("init_samr_r_query_groupinfo\n"));
2992
2993         r_u->ptr = (NT_STATUS_IS_OK(status) && ctr != NULL) ? 1 : 0;
2994         r_u->ctr = ctr;
2995         r_u->status = status;
2996 }
2997
2998 /*******************************************************************
2999 reads or writes a structure.
3000 ********************************************************************/
3001
3002 BOOL samr_io_r_query_groupinfo(const char *desc, SAMR_R_QUERY_GROUPINFO * r_u,
3003                                prs_struct *ps, int depth)
3004 {
3005         if (r_u == NULL)
3006                 return False;
3007
3008         prs_debug(ps, depth, desc, "samr_io_r_query_groupinfo");
3009         depth++;
3010
3011         if(!prs_align(ps))
3012                 return False;
3013
3014         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
3015                 return False;
3016
3017         if (r_u->ptr != 0) {
3018                 if(!samr_group_info_ctr("ctr", &r_u->ctr, ps, depth))
3019                         return False;
3020         }
3021
3022         if(!prs_align(ps))
3023                 return False;
3024         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3025                 return False;
3026
3027         return True;
3028 }
3029
3030 /*******************************************************************
3031 inits a SAMR_Q_QUERY_GROUPMEM structure.
3032 ********************************************************************/
3033
3034 void init_samr_q_query_groupmem(SAMR_Q_QUERY_GROUPMEM * q_c, POLICY_HND *hnd)
3035 {
3036         DEBUG(5, ("init_samr_q_query_groupmem\n"));
3037
3038         q_c->group_pol = *hnd;
3039 }
3040
3041 /*******************************************************************
3042 reads or writes a structure.
3043 ********************************************************************/
3044
3045 BOOL samr_io_q_query_groupmem(const char *desc, SAMR_Q_QUERY_GROUPMEM * q_u,
3046                               prs_struct *ps, int depth)
3047 {
3048         if (q_u == NULL)
3049                 return False;
3050
3051         prs_debug(ps, depth, desc, "samr_io_q_query_groupmem");
3052         depth++;
3053
3054         if(!prs_align(ps))
3055                 return False;
3056
3057         if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
3058                 return False;
3059
3060         return True;
3061 }
3062
3063 /*******************************************************************
3064 inits a SAMR_R_QUERY_GROUPMEM structure.
3065 ********************************************************************/
3066
3067 void init_samr_r_query_groupmem(SAMR_R_QUERY_GROUPMEM * r_u,
3068                                 uint32 num_entries, uint32 *rid,
3069                                 uint32 *attr, NTSTATUS status)
3070 {
3071         DEBUG(5, ("init_samr_r_query_groupmem\n"));
3072
3073         if (NT_STATUS_IS_OK(status)) {
3074                 r_u->ptr = 1;
3075                 r_u->num_entries = num_entries;
3076
3077                 r_u->ptr_attrs = attr != NULL ? 1 : 0;
3078                 r_u->ptr_rids = rid != NULL ? 1 : 0;
3079
3080                 r_u->num_rids = num_entries;
3081                 r_u->rid = rid;
3082
3083                 r_u->num_attrs = num_entries;
3084                 r_u->attr = attr;
3085         } else {
3086                 r_u->ptr = 0;
3087                 r_u->num_entries = 0;
3088         }
3089
3090         r_u->status = status;
3091 }
3092
3093 /*******************************************************************
3094 reads or writes a structure.
3095 ********************************************************************/
3096
3097 BOOL samr_io_r_query_groupmem(const char *desc, SAMR_R_QUERY_GROUPMEM * r_u,
3098                               prs_struct *ps, int depth)
3099 {
3100         uint32 i;
3101
3102         if (r_u == NULL)
3103                 return False;
3104
3105         if (UNMARSHALLING(ps))
3106                 ZERO_STRUCTP(r_u);
3107
3108         prs_debug(ps, depth, desc, "samr_io_r_query_groupmem");
3109         depth++;
3110
3111         if(!prs_align(ps))
3112                 return False;
3113
3114         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
3115                 return False;
3116         if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
3117                 return False;
3118
3119         if (r_u->ptr != 0) {
3120                 if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
3121                         return False;
3122                 if(!prs_uint32("ptr_attrs", ps, depth, &r_u->ptr_attrs))
3123                         return False;
3124
3125                 if (r_u->ptr_rids != 0) {
3126                         if(!prs_uint32("num_rids", ps, depth, &r_u->num_rids))
3127                                 return False;
3128                         if (UNMARSHALLING(ps) && r_u->num_rids != 0) {
3129                                 r_u->rid = PRS_ALLOC_MEM(ps,uint32,r_u->num_rids);
3130                                 if (r_u->rid == NULL)
3131                                         return False;
3132                         }
3133
3134                         for (i = 0; i < r_u->num_rids; i++) {
3135                                 if(!prs_uint32("", ps, depth, &r_u->rid[i]))
3136                                         return False;
3137                         }
3138                 }
3139
3140                 if (r_u->ptr_attrs != 0) {
3141                         if(!prs_uint32("num_attrs", ps, depth, &r_u->num_attrs))
3142                                 return False;
3143
3144                         if (UNMARSHALLING(ps) && r_u->num_attrs != 0) {
3145                                 r_u->attr = PRS_ALLOC_MEM(ps,uint32,r_u->num_attrs);
3146                                 if (r_u->attr == NULL)
3147                                         return False;
3148                         }
3149
3150                         for (i = 0; i < r_u->num_attrs; i++) {
3151                                 if(!prs_uint32("", ps, depth, &r_u->attr[i]))
3152                                         return False;
3153                         }
3154                 }
3155         }
3156
3157         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3158                 return False;
3159
3160         return True;
3161 }
3162
3163 /*******************************************************************
3164 inits a SAMR_Q_QUERY_USERGROUPS structure.
3165 ********************************************************************/
3166
3167 void init_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS * q_u,
3168                                   POLICY_HND *hnd)
3169 {
3170         DEBUG(5, ("init_samr_q_query_usergroups\n"));
3171
3172         q_u->pol = *hnd;
3173 }
3174
3175 /*******************************************************************
3176 reads or writes a structure.
3177 ********************************************************************/
3178
3179 BOOL samr_io_q_query_usergroups(const char *desc, SAMR_Q_QUERY_USERGROUPS * q_u,
3180                                 prs_struct *ps, int depth)
3181 {
3182         if (q_u == NULL)
3183                 return False;
3184
3185         prs_debug(ps, depth, desc, "samr_io_q_query_usergroups");
3186         depth++;
3187
3188         if(!prs_align(ps))
3189                 return False;
3190
3191         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
3192                 return False;
3193
3194         return True;
3195 }
3196
3197 /*******************************************************************
3198 inits a SAMR_R_QUERY_USERGROUPS structure.
3199 ********************************************************************/
3200
3201 void init_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS * r_u,
3202                                   uint32 num_gids, DOM_GID * gid,
3203                                   NTSTATUS status)
3204 {
3205         DEBUG(5, ("init_samr_r_query_usergroups\n"));
3206
3207         if (NT_STATUS_IS_OK(status)) {
3208                 r_u->ptr_0 = 1;
3209                 r_u->num_entries = num_gids;
3210                 r_u->ptr_1 = (num_gids != 0) ? 1 : 0;
3211                 r_u->num_entries2 = num_gids;
3212
3213                 r_u->gid = gid;
3214         } else {
3215                 r_u->ptr_0 = 0;
3216                 r_u->num_entries = 0;
3217                 r_u->ptr_1 = 0;
3218                 r_u->gid = NULL;
3219         }
3220
3221         r_u->status = status;
3222 }
3223
3224 /*******************************************************************
3225 reads or writes a structure.
3226 ********************************************************************/
3227
3228 BOOL samr_io_gids(const char *desc, uint32 *num_gids, DOM_GID ** gid,
3229                   prs_struct *ps, int depth)
3230 {
3231         uint32 i;
3232         if (gid == NULL)
3233                 return False;
3234
3235         prs_debug(ps, depth, desc, "samr_io_gids");
3236         depth++;
3237
3238         if(!prs_align(ps))
3239                 return False;
3240
3241         if(!prs_uint32("num_gids", ps, depth, num_gids))
3242                 return False;
3243
3244         if ((*num_gids) != 0) {
3245                 if (UNMARSHALLING(ps)) {
3246                         (*gid) = PRS_ALLOC_MEM(ps,DOM_GID,*num_gids);
3247                 }
3248
3249                 if ((*gid) == NULL) {
3250                         return False;
3251                 }
3252
3253                 for (i = 0; i < (*num_gids); i++) {
3254                         if(!smb_io_gid("gids", &(*gid)[i], ps, depth))
3255                                 return False;
3256                 }
3257         }
3258
3259         return True;
3260 }
3261
3262 /*******************************************************************
3263 reads or writes a structure.
3264 ********************************************************************/
3265
3266 BOOL samr_io_r_query_usergroups(const char *desc, SAMR_R_QUERY_USERGROUPS * r_u,
3267                                 prs_struct *ps, int depth)
3268 {
3269         if (r_u == NULL)
3270                 return False;
3271
3272         prs_debug(ps, depth, desc, "samr_io_r_query_usergroups");
3273         depth++;
3274
3275         if(!prs_align(ps))
3276                 return False;
3277
3278         if(!prs_uint32("ptr_0       ", ps, depth, &r_u->ptr_0))
3279                 return False;
3280
3281         if (r_u->ptr_0 != 0) {
3282                 if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
3283                         return False;
3284                 if(!prs_uint32("ptr_1       ", ps, depth, &r_u->ptr_1))
3285                         return False;
3286
3287                 if (r_u->num_entries != 0 && r_u->ptr_1 != 0) {
3288                         if(!samr_io_gids("gids", &r_u->num_entries2, &r_u->gid, ps, depth))
3289                                 return False;
3290                 }
3291         }
3292
3293         if(!prs_align(ps))
3294                 return False;
3295         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3296           return False;
3297
3298         return True;
3299 }
3300
3301 /*******************************************************************
3302 inits a SAMR_Q_ENUM_DOMAINS structure.
3303 ********************************************************************/
3304
3305 void init_samr_q_enum_domains(SAMR_Q_ENUM_DOMAINS * q_e,
3306                               POLICY_HND *pol,
3307                               uint32 start_idx, uint32 size)
3308 {
3309         DEBUG(5, ("init_samr_q_enum_domains\n"));
3310
3311         q_e->pol = *pol;
3312
3313         q_e->start_idx = start_idx;
3314         q_e->max_size = size;
3315 }
3316
3317 /*******************************************************************
3318 reads or writes a structure.
3319 ********************************************************************/
3320
3321 BOOL samr_io_q_enum_domains(const char *desc, SAMR_Q_ENUM_DOMAINS * q_e,
3322                             prs_struct *ps, int depth)
3323 {
3324         if (q_e == NULL)
3325                 return False;
3326
3327         prs_debug(ps, depth, desc, "samr_io_q_enum_domains");
3328         depth++;
3329
3330         if(!prs_align(ps))
3331                 return False;
3332
3333         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3334                 return False;
3335
3336         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3337                 return False;
3338         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3339                 return False;
3340
3341         return True;
3342 }
3343
3344 /*******************************************************************
3345 inits a SAMR_R_ENUM_DOMAINS structure.
3346 ********************************************************************/
3347
3348 void init_samr_r_enum_domains(SAMR_R_ENUM_DOMAINS * r_u,
3349                               uint32 next_idx, uint32 num_sam_entries)
3350 {
3351         DEBUG(5, ("init_samr_r_enum_domains\n"));
3352
3353         r_u->next_idx = next_idx;
3354
3355         if (num_sam_entries != 0) {
3356                 r_u->ptr_entries1 = 1;
3357                 r_u->ptr_entries2 = 1;
3358                 r_u->num_entries2 = num_sam_entries;
3359                 r_u->num_entries3 = num_sam_entries;
3360
3361                 r_u->num_entries4 = num_sam_entries;
3362         } else {
3363                 r_u->ptr_entries1 = 0;
3364                 r_u->num_entries2 = num_sam_entries;
3365                 r_u->ptr_entries2 = 1;
3366         }
3367 }
3368
3369 /*******************************************************************
3370 reads or writes a structure.
3371 ********************************************************************/
3372
3373 BOOL samr_io_r_enum_domains(const char *desc, SAMR_R_ENUM_DOMAINS * r_u,
3374                             prs_struct *ps, int depth)
3375 {
3376         uint32 i;
3377
3378         if (r_u == NULL)
3379                 return False;
3380
3381         prs_debug(ps, depth, desc, "samr_io_r_enum_domains");
3382         depth++;
3383
3384         if(!prs_align(ps))
3385                 return False;
3386
3387         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
3388                 return False;
3389         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3390                 return False;
3391
3392         if (r_u->ptr_entries1 != 0) {
3393                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3394                         return False;
3395                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3396                         return False;
3397                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3398                         return False;
3399
3400                 if (UNMARSHALLING(ps) && r_u->num_entries2) {
3401                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3402                         r_u->uni_dom_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3403                 }
3404
3405                 if ((r_u->sam == NULL || r_u->uni_dom_name == NULL) && r_u->num_entries2 != 0) {
3406                         DEBUG(0, ("NULL pointers in SAMR_R_ENUM_DOMAINS\n"));
3407                         r_u->num_entries4 = 0;
3408                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3409                         return False;
3410                 }
3411
3412                 for (i = 0; i < r_u->num_entries2; i++) {
3413                         fstring tmp;
3414                         slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3415                         if(!sam_io_sam_entry(tmp, &r_u->sam[i], ps, depth))
3416                                 return False;
3417                 }
3418
3419                 for (i = 0; i < r_u->num_entries2; i++) {
3420                         fstring tmp;
3421                         slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3422                         if(!smb_io_unistr2(tmp, &r_u->uni_dom_name[i],
3423                                        r_u->sam[i].hdr_name.buffer, ps,
3424                                        depth))
3425                                 return False;
3426                 }
3427
3428         }
3429
3430         if(!prs_align(ps))
3431                 return False;
3432         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3433                 return False;
3434         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3435                 return False;
3436
3437         return True;
3438 }
3439
3440 /*******************************************************************
3441 inits a SAMR_Q_ENUM_DOM_GROUPS structure.
3442 ********************************************************************/
3443
3444 void init_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS * q_e,
3445                                  POLICY_HND *pol,
3446                                  uint32 start_idx, uint32 size)
3447 {
3448         DEBUG(5, ("init_samr_q_enum_dom_groups\n"));
3449
3450         q_e->pol = *pol;
3451
3452         q_e->start_idx = start_idx;
3453         q_e->max_size = size;
3454 }
3455
3456 /*******************************************************************
3457 reads or writes a structure.
3458 ********************************************************************/
3459
3460 BOOL samr_io_q_enum_dom_groups(const char *desc, SAMR_Q_ENUM_DOM_GROUPS * q_e,
3461                                prs_struct *ps, int depth)
3462 {
3463         if (q_e == NULL)
3464                 return False;
3465
3466         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_groups");
3467         depth++;
3468
3469         if(!prs_align(ps))
3470                 return False;
3471
3472         if(!smb_io_pol_hnd("pol", &(q_e->pol), ps, depth))
3473                 return False;
3474
3475         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3476                 return False;
3477         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3478                 return False;
3479
3480         return True;
3481 }
3482
3483 /*******************************************************************
3484 inits a SAMR_R_ENUM_DOM_GROUPS structure.
3485 ********************************************************************/
3486
3487 void init_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS * r_u,
3488                                  uint32 next_idx, uint32 num_sam_entries)
3489 {
3490         DEBUG(5, ("init_samr_r_enum_dom_groups\n"));
3491
3492         r_u->next_idx = next_idx;
3493
3494         if (num_sam_entries != 0) {
3495                 r_u->ptr_entries1 = 1;
3496                 r_u->ptr_entries2 = 1;
3497                 r_u->num_entries2 = num_sam_entries;
3498                 r_u->num_entries3 = num_sam_entries;
3499
3500                 r_u->num_entries4 = num_sam_entries;
3501         } else {
3502                 r_u->ptr_entries1 = 0;
3503                 r_u->num_entries2 = num_sam_entries;
3504                 r_u->ptr_entries2 = 1;
3505         }
3506 }
3507
3508 /*******************************************************************
3509 reads or writes a structure.
3510 ********************************************************************/
3511
3512 BOOL samr_io_r_enum_dom_groups(const char *desc, SAMR_R_ENUM_DOM_GROUPS * r_u,
3513                                prs_struct *ps, int depth)
3514 {
3515         uint32 i;
3516
3517         if (r_u == NULL)
3518                 return False;
3519
3520         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_groups");
3521         depth++;
3522
3523         if(!prs_align(ps))
3524                 return False;
3525
3526         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
3527                 return False;
3528         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3529                 return False;
3530
3531         if (r_u->ptr_entries1 != 0) {
3532                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3533                         return False;
3534                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3535                         return False;
3536                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3537                         return False;
3538
3539                 if (UNMARSHALLING(ps) && r_u->num_entries2) {
3540                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3541                         r_u->uni_grp_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3542                 }
3543
3544                 if ((r_u->sam == NULL || r_u->uni_grp_name == NULL) && r_u->num_entries2 != 0) {
3545                         DEBUG(0,
3546                               ("NULL pointers in SAMR_R_ENUM_DOM_GROUPS\n"));
3547                         r_u->num_entries4 = 0;
3548                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3549                         return False;
3550                 }
3551
3552                 for (i = 0; i < r_u->num_entries2; i++) {
3553                         if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
3554                                 return False;
3555                 }
3556
3557                 for (i = 0; i < r_u->num_entries2; i++) {
3558                         if(!smb_io_unistr2("", &r_u->uni_grp_name[i],
3559                                        r_u->sam[i].hdr_name.buffer, ps, depth))
3560                                 return False;
3561                 }
3562         }
3563
3564         if(!prs_align(ps))
3565                 return False;
3566         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3567                 return False;
3568         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3569                 return False;
3570
3571         return True;
3572 }
3573
3574 /*******************************************************************
3575 inits a SAMR_Q_ENUM_DOM_ALIASES structure.
3576 ********************************************************************/
3577
3578 void init_samr_q_enum_dom_aliases(SAMR_Q_ENUM_DOM_ALIASES * q_e,
3579                                   POLICY_HND *pol, uint32 start_idx,
3580                                   uint32 size)
3581 {
3582         DEBUG(5, ("init_samr_q_enum_dom_aliases\n"));
3583
3584         q_e->pol = *pol;
3585
3586         q_e->start_idx = start_idx;
3587         q_e->max_size = size;
3588 }
3589
3590
3591 /*******************************************************************
3592 reads or writes a structure.
3593 ********************************************************************/
3594
3595 BOOL samr_io_q_enum_dom_aliases(const char *desc, SAMR_Q_ENUM_DOM_ALIASES * q_e,
3596                                 prs_struct *ps, int depth)
3597 {
3598         if (q_e == NULL)
3599                 return False;
3600
3601         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_aliases");
3602         depth++;
3603
3604         if(!prs_align(ps))
3605                 return False;
3606
3607         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3608                 return False;
3609
3610         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3611                 return False;
3612         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3613                 return False;
3614
3615         return True;
3616 }
3617
3618 /*******************************************************************
3619 inits a SAMR_R_ENUM_DOM_ALIASES structure.
3620 ********************************************************************/
3621
3622 void init_samr_r_enum_dom_aliases(SAMR_R_ENUM_DOM_ALIASES *r_u, uint32 next_idx, uint32 num_sam_entries)
3623 {
3624         DEBUG(5, ("init_samr_r_enum_dom_aliases\n"));
3625
3626         r_u->next_idx = next_idx;
3627
3628         if (num_sam_entries != 0) {
3629                 r_u->ptr_entries1 = 1;
3630                 r_u->ptr_entries2 = 1;
3631                 r_u->num_entries2 = num_sam_entries;
3632                 r_u->num_entries3 = num_sam_entries;
3633
3634                 r_u->num_entries4 = num_sam_entries;
3635         } else {
3636                 r_u->ptr_entries1 = 0;
3637                 r_u->num_entries2 = num_sam_entries;
3638                 r_u->ptr_entries2 = 1;
3639         }
3640 }
3641
3642 /*******************************************************************
3643 reads or writes a structure.
3644 ********************************************************************/
3645
3646 BOOL samr_io_r_enum_dom_aliases(const char *desc, SAMR_R_ENUM_DOM_ALIASES * r_u,
3647                                 prs_struct *ps, int depth)
3648 {
3649         uint32 i;
3650
3651         if (r_u == NULL)
3652                 return False;
3653
3654         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_aliases");
3655         depth++;
3656
3657         if(!prs_align(ps))
3658                 return False;
3659
3660         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
3661                 return False;
3662         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3663                 return False;
3664
3665         if (r_u->ptr_entries1 != 0) {
3666                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3667                         return False;
3668                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3669                         return False;
3670                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3671                         return False;
3672
3673                 if (UNMARSHALLING(ps) && (r_u->num_entries2 > 0)) {
3674                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3675                         r_u->uni_grp_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3676                 }
3677
3678                 if (r_u->num_entries2 != 0 &&
3679                     (r_u->sam == NULL || r_u->uni_grp_name == NULL)) {
3680                         DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_ALIASES\n"));
3681                         r_u->num_entries4 = 0;
3682                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3683                         return False;
3684                 }
3685
3686                 for (i = 0; i < r_u->num_entries2; i++) {
3687                         if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
3688                                 return False;
3689                 }
3690
3691                 for (i = 0; i < r_u->num_entries2; i++) {
3692                         if(!smb_io_unistr2("", &r_u->uni_grp_name[i],
3693                                        r_u->sam[i].hdr_name.buffer, ps,
3694                                        depth))
3695                                 return False;
3696                 }
3697         }
3698
3699         if(!prs_align(ps))
3700                 return False;
3701         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3702                 return False;
3703         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3704                 return False;
3705
3706         return True;
3707 }
3708
3709 /*******************************************************************
3710 inits a ALIAS_INFO1 structure.
3711 ********************************************************************/
3712
3713 void init_samr_alias_info1(ALIAS_INFO1 * al1, char *acct_name, uint32 num_member, char *acct_desc)
3714 {
3715         DEBUG(5, ("init_samr_alias_info1\n"));
3716
3717         init_unistr4(&al1->name, acct_name, UNI_FLAGS_NONE);
3718         al1->num_member = num_member;
3719         init_unistr4(&al1->description, acct_desc, UNI_FLAGS_NONE);
3720 }
3721
3722 /*******************************************************************
3723 reads or writes a structure.
3724 ********************************************************************/
3725
3726 BOOL samr_io_alias_info1(const char *desc, ALIAS_INFO1 * al1,
3727                          prs_struct *ps, int depth)
3728 {
3729         if (al1 == NULL)
3730                 return False;
3731
3732         prs_debug(ps, depth, desc, "samr_io_alias_info1");
3733         depth++;
3734
3735         if(!prs_align(ps))
3736                 return False;
3737
3738         if ( !prs_unistr4_hdr("name", ps, depth, &al1->name) )
3739                 return False;
3740         if ( !prs_uint32("num_member", ps, depth, &al1->num_member) )
3741                 return False;
3742         if ( !prs_unistr4_hdr("description", ps, depth, &al1->description) )
3743                 return False;
3744
3745         if ( !prs_unistr4_str("name", ps, depth, &al1->name) )
3746                 return False;
3747         if ( !prs_align(ps) )
3748                 return False;
3749         if ( !prs_unistr4_str("description", ps, depth, &al1->description) )
3750                 return False;
3751         if ( !prs_align(ps) )
3752                 return False;
3753
3754         return True;
3755 }
3756
3757 /*******************************************************************
3758 inits a ALIAS_INFO3 structure.
3759 ********************************************************************/
3760
3761 void init_samr_alias_info3(ALIAS_INFO3 * al3, const char *acct_desc)
3762 {
3763         DEBUG(5, ("init_samr_alias_info3\n"));
3764
3765         init_unistr4(&al3->description, acct_desc, UNI_FLAGS_NONE);
3766 }
3767
3768 /*******************************************************************
3769 reads or writes a structure.
3770 ********************************************************************/
3771
3772 BOOL samr_io_alias_info3(const char *desc, ALIAS_INFO3 *al3,
3773                          prs_struct *ps, int depth)
3774 {
3775         if (al3 == NULL)
3776                 return False;
3777
3778         prs_debug(ps, depth, desc, "samr_io_alias_info3");
3779         depth++;
3780
3781         if(!prs_align(ps))
3782                 return False;
3783
3784         if (!prs_unistr4("description", ps, depth, &al3->description))
3785                 return False;
3786
3787         return True;
3788 }
3789
3790 /*******************************************************************
3791 reads or writes a structure.
3792 ********************************************************************/
3793
3794 BOOL samr_io_alias_info2(const char *desc, ALIAS_INFO2 *al2,
3795                          prs_struct *ps, int depth)
3796 {
3797         if (al2 == NULL)
3798                 return False;
3799
3800         prs_debug(ps, depth, desc, "samr_io_alias_info2");
3801         depth++;
3802
3803         if(!prs_align(ps))
3804                 return False;
3805
3806         if (!prs_unistr4("name", ps, depth, &al2->name))
3807                 return False;
3808
3809         return True;
3810 }
3811
3812 /*******************************************************************
3813 reads or writes a structure.
3814 ********************************************************************/
3815
3816 BOOL samr_alias_info_ctr(const char *desc, prs_struct *ps, int depth, ALIAS_INFO_CTR * ctr)
3817 {
3818         if ( !ctr )
3819                 return False;
3820
3821         prs_debug(ps, depth, desc, "samr_alias_info_ctr");
3822         depth++;
3823
3824         if ( !prs_uint16("level", ps, depth, &ctr->level) )
3825                 return False;
3826
3827         if(!prs_align(ps))
3828                 return False;
3829         switch (ctr->level) {
3830         case 1:
3831                 if(!samr_io_alias_info1("alias_info1", &ctr->alias.info1, ps, depth))
3832                         return False;
3833                 break;
3834         case 2:
3835                 if(!samr_io_alias_info2("alias_info2", &ctr->alias.info2, ps, depth))
3836                         return False;
3837                 break;
3838         case 3:
3839                 if(!samr_io_alias_info3("alias_info3", &ctr->alias.info3, ps, depth))
3840                         return False;
3841                 break;
3842         default:
3843                 DEBUG(0,("samr_alias_info_ctr: unsupported switch level\n"));
3844                 break;
3845         }
3846
3847         return True;
3848 }
3849
3850 /*******************************************************************
3851 inits a SAMR_Q_QUERY_ALIASINFO structure.
3852 ********************************************************************/
3853
3854 void init_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO * q_e,
3855                                  POLICY_HND *pol, uint32 switch_level)
3856 {
3857         DEBUG(5, ("init_samr_q_query_aliasinfo\n"));
3858
3859         q_e->pol = *pol;
3860         q_e->level = switch_level;
3861 }
3862
3863 /*******************************************************************
3864 reads or writes a structure.
3865 ********************************************************************/
3866
3867 BOOL samr_io_q_query_aliasinfo(const char *desc, SAMR_Q_QUERY_ALIASINFO *in,
3868                                prs_struct *ps, int depth)
3869 {
3870         if ( !in )
3871                 return False;
3872
3873         prs_debug(ps, depth, desc, "samr_io_q_query_aliasinfo");
3874         depth++;
3875
3876         if(!prs_align(ps))
3877                 return False;
3878
3879         if ( !smb_io_pol_hnd("pol", &(in->pol), ps, depth) )
3880                 return False;
3881
3882         if ( !prs_uint16("level", ps, depth, &in->level) )
3883                 return False;
3884
3885         return True;
3886 }
3887
3888 /*******************************************************************
3889 inits a SAMR_R_QUERY_ALIASINFO structure.
3890 ********************************************************************/
3891
3892 void init_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *out,
3893                                  ALIAS_INFO_CTR * ctr, NTSTATUS status)
3894 {
3895         DEBUG(5, ("init_samr_r_query_aliasinfo\n"));
3896
3897         out->ctr = ctr;
3898         out->status = status;
3899 }
3900
3901 /*******************************************************************
3902 reads or writes a structure.
3903 ********************************************************************/
3904
3905 BOOL samr_io_r_query_aliasinfo(const char *desc, SAMR_R_QUERY_ALIASINFO *out,
3906                                prs_struct *ps, int depth)
3907 {
3908         if ( !out )
3909                 return False;
3910
3911         prs_debug(ps, depth, desc, "samr_io_r_query_aliasinfo");
3912         depth++;
3913
3914         if(!prs_align(ps))
3915                 return False;
3916
3917         if ( !prs_pointer("alias", ps, depth, (void*)&out->ctr, sizeof(ALIAS_INFO_CTR), (PRS_POINTER_CAST)samr_alias_info_ctr))
3918                 return False;
3919         if(!prs_align(ps))
3920                 return False;
3921
3922         if(!prs_ntstatus("status", ps, depth, &out->status))
3923                 return False;
3924
3925         return True;
3926 }
3927
3928 /*******************************************************************
3929 inits a SAMR_Q_SET_ALIASINFO structure.
3930 ********************************************************************/
3931
3932 void init_samr_q_set_aliasinfo(SAMR_Q_SET_ALIASINFO * q_u,
3933                                POLICY_HND *hnd, ALIAS_INFO_CTR * ctr)
3934 {
3935         DEBUG(5, ("init_samr_q_set_aliasinfo\n"));
3936
3937         q_u->alias_pol = *hnd;
3938         q_u->ctr = *ctr;
3939 }
3940
3941 /*******************************************************************
3942 reads or writes a structure.
3943 ********************************************************************/
3944
3945 BOOL samr_io_q_set_aliasinfo(const char *desc, SAMR_Q_SET_ALIASINFO * q_u,
3946                              prs_struct *ps, int depth)
3947 {
3948         if (q_u == NULL)
3949                 return False;
3950
3951         prs_debug(ps, depth, desc, "samr_io_q_set_aliasinfo");
3952         depth++;
3953
3954         if(!prs_align(ps))
3955                 return False;
3956
3957         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
3958                 return False;
3959         if(!samr_alias_info_ctr("ctr", ps, depth, &q_u->ctr))
3960                 return False;
3961
3962         return True;
3963 }
3964
3965 /*******************************************************************
3966 reads or writes a structure.
3967 ********************************************************************/
3968
3969 BOOL samr_io_r_set_aliasinfo(const char *desc, SAMR_R_SET_ALIASINFO * r_u,
3970                              prs_struct *ps, int depth)
3971 {
3972         if (r_u == NULL)
3973                 return False;
3974
3975         prs_debug(ps, depth, desc, "samr_io_r_set_aliasinfo");
3976         depth++;
3977
3978         if(!prs_align(ps))
3979                 return False;
3980         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3981                 return False;
3982
3983         return True;
3984 }
3985
3986 /*******************************************************************
3987 inits a SAMR_Q_QUERY_USERALIASES structure.
3988 ********************************************************************/
3989
3990 void init_samr_q_query_useraliases(SAMR_Q_QUERY_USERALIASES * q_u,
3991                                    POLICY_HND *hnd,
3992                                    uint32 num_sids,
3993                                    uint32 *ptr_sid, DOM_SID2 * sid)
3994 {
3995         DEBUG(5, ("init_samr_q_query_useraliases\n"));
3996
3997         q_u->pol = *hnd;
3998
3999         q_u->num_sids1 = num_sids;
4000         q_u->ptr = 1;
4001         q_u->num_sids2 = num_sids;
4002
4003         q_u->ptr_sid = ptr_sid;
4004         q_u->sid = sid;
4005 }
4006
4007 /*******************************************************************
4008 reads or writes a SAMR_Q_QUERY_USERALIASES structure.
4009 ********************************************************************/
4010
4011 BOOL samr_io_q_query_useraliases(const char *desc, SAMR_Q_QUERY_USERALIASES * q_u,
4012                                  prs_struct *ps, int depth)
4013 {
4014         fstring tmp;
4015         uint32 i;
4016
4017         if (q_u == NULL)
4018                 return False;
4019
4020         prs_debug(ps, depth, desc, "samr_io_q_query_useraliases");
4021         depth++;
4022
4023         if(!prs_align(ps))
4024                 return False;
4025
4026         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4027                 return False;
4028
4029         if(!prs_uint32("num_sids1", ps, depth, &q_u->num_sids1))
4030                 return False;
4031         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
4032                 return False;
4033
4034         if (q_u->ptr==0)
4035                 return True;
4036
4037         if(!prs_uint32("num_sids2", ps, depth, &q_u->num_sids2))
4038                 return False;
4039
4040         if (UNMARSHALLING(ps) && (q_u->num_sids2 != 0)) {
4041                 q_u->ptr_sid = PRS_ALLOC_MEM(ps,uint32,q_u->num_sids2);
4042                 if (q_u->ptr_sid == NULL)
4043                         return False;
4044
4045                 q_u->sid = PRS_ALLOC_MEM(ps, DOM_SID2, q_u->num_sids2);
4046                 if (q_u->sid == NULL)
4047                         return False;
4048         }
4049
4050         for (i = 0; i < q_u->num_sids2; i++) {
4051                 slprintf(tmp, sizeof(tmp) - 1, "ptr[%02d]", i);
4052                 if(!prs_uint32(tmp, ps, depth, &q_u->ptr_sid[i]))
4053                         return False;
4054         }
4055
4056         for (i = 0; i < q_u->num_sids2; i++) {
4057                 if (q_u->ptr_sid[i] != 0) {
4058                         slprintf(tmp, sizeof(tmp) - 1, "sid[%02d]", i);
4059                         if(!smb_io_dom_sid2(tmp, &q_u->sid[i], ps, depth))
4060                                 return False;
4061                 }
4062         }
4063
4064         return True;
4065 }
4066
4067 /*******************************************************************
4068 inits a SAMR_R_QUERY_USERALIASES structure.
4069 ********************************************************************/
4070
4071 void init_samr_r_query_useraliases(SAMR_R_QUERY_USERALIASES * r_u,
4072                                    uint32 num_rids, uint32 *rid,
4073                                    NTSTATUS status)
4074 {
4075         DEBUG(5, ("init_samr_r_query_useraliases\n"));
4076
4077         if (NT_STATUS_IS_OK(status)) {
4078                 r_u->num_entries = num_rids;
4079                 r_u->ptr = 1;
4080                 r_u->num_entries2 = num_rids;
4081
4082                 r_u->rid = rid;
4083         } else {
4084                 r_u->num_entries = 0;
4085                 r_u->ptr = 0;
4086                 r_u->num_entries2 = 0;
4087         }
4088
4089         r_u->status = status;
4090 }
4091
4092 /*******************************************************************
4093 reads or writes a structure.
4094 ********************************************************************/
4095
4096 BOOL samr_io_rids(const char *desc, uint32 *num_rids, uint32 **rid,
4097                   prs_struct *ps, int depth)
4098 {
4099         fstring tmp;
4100         uint32 i;
4101         if (rid == NULL)
4102                 return False;
4103
4104         prs_debug(ps, depth, desc, "samr_io_rids");
4105         depth++;
4106
4107         if(!prs_align(ps))
4108                 return False;
4109
4110         if(!prs_uint32("num_rids", ps, depth, num_rids))
4111                 return False;
4112
4113         if ((*num_rids) != 0) {
4114                 if (UNMARSHALLING(ps)) {
4115                         /* reading */
4116                         (*rid) = PRS_ALLOC_MEM(ps,uint32, *num_rids);
4117                 }
4118                 if ((*rid) == NULL)
4119                         return False;
4120
4121                 for (i = 0; i < (*num_rids); i++) {
4122                         slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]", i);
4123                         if(!prs_uint32(tmp, ps, depth, &((*rid)[i])))
4124                                 return False;
4125                 }
4126         }
4127
4128         return True;
4129 }
4130
4131 /*******************************************************************
4132 reads or writes a structure.
4133 ********************************************************************/
4134
4135 BOOL samr_io_r_query_useraliases(const char *desc, SAMR_R_QUERY_USERALIASES * r_u,
4136                                  prs_struct *ps, int depth)
4137 {
4138         if (r_u == NULL)
4139                 return False;
4140
4141         prs_debug(ps, depth, desc, "samr_io_r_query_useraliases");
4142         depth++;
4143
4144         if(!prs_align(ps))
4145                 return False;
4146
4147         if(!prs_uint32("num_entries", ps, depth, &r_u->num_entries))
4148                 return False;
4149         if(!prs_uint32("ptr        ", ps, depth, &r_u->ptr))
4150                 return False;
4151
4152         if (r_u->ptr != 0) {
4153                 if(!samr_io_rids("rids", &r_u->num_entries2, &r_u->rid, ps, depth))
4154                         return False;
4155         }
4156
4157         if(!prs_align(ps))
4158                 return False;
4159         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4160                 return False;
4161
4162         return True;
4163 }
4164
4165 /*******************************************************************
4166 inits a SAMR_Q_OPEN_ALIAS structure.
4167 ********************************************************************/
4168
4169 void init_samr_q_open_alias(SAMR_Q_OPEN_ALIAS * q_u, POLICY_HND *pol,
4170                             uint32 access_mask, uint32 rid)
4171 {
4172         DEBUG(5, ("init_samr_q_open_alias\n"));
4173
4174         q_u->dom_pol = *pol;
4175         q_u->access_mask = access_mask;
4176         q_u->rid_alias = rid;
4177 }
4178
4179 /*******************************************************************
4180 reads or writes a structure.
4181 ********************************************************************/
4182
4183 BOOL samr_io_q_open_alias(const char *desc, SAMR_Q_OPEN_ALIAS * q_u,
4184                           prs_struct *ps, int depth)
4185 {
4186         if (q_u == NULL)
4187                 return False;
4188
4189         prs_debug(ps, depth, desc, "samr_io_q_open_alias");
4190         depth++;
4191
4192         if(!prs_align(ps))
4193                 return False;
4194
4195         if(!smb_io_pol_hnd("domain_pol", &q_u->dom_pol, ps, depth))
4196                 return False;
4197
4198         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
4199                 return False;
4200         if(!prs_uint32("rid_alias", ps, depth, &q_u->rid_alias))
4201                 return False;
4202
4203         return True;
4204 }
4205
4206 /*******************************************************************
4207 reads or writes a structure.
4208 ********************************************************************/
4209
4210 BOOL samr_io_r_open_alias(const char *desc, SAMR_R_OPEN_ALIAS * r_u,
4211                           prs_struct *ps, int depth)
4212 {
4213         if (r_u == NULL)
4214                 return False;
4215
4216         prs_debug(ps, depth, desc, "samr_io_r_open_alias");
4217         depth++;
4218
4219         if(!prs_align(ps))
4220                 return False;
4221
4222         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4223                 return False;
4224
4225         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4226                 return False;
4227
4228         return True;
4229 }
4230
4231 /*******************************************************************
4232 inits a SAMR_Q_LOOKUP_RIDS structure.
4233 ********************************************************************/
4234
4235 void init_samr_q_lookup_rids(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_RIDS * q_u,
4236                              POLICY_HND *pol, uint32 flags,
4237                              uint32 num_rids, uint32 *rid)
4238 {
4239         DEBUG(5, ("init_samr_q_lookup_rids\n"));
4240
4241         q_u->pol = *pol;
4242
4243         q_u->num_rids1 = num_rids;
4244         q_u->flags = flags;
4245         q_u->ptr = 0;
4246         q_u->num_rids2 = num_rids;
4247         if (num_rids) {
4248                 q_u->rid = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids );
4249         } else {
4250                 q_u->rid = NULL;
4251         }
4252         if (q_u->rid == NULL) {
4253                 q_u->num_rids1 = 0;
4254                 q_u->num_rids2 = 0;
4255         } else {
4256                 memcpy(q_u->rid, rid, num_rids * sizeof(q_u->rid[0]));
4257         }
4258 }
4259
4260 /*******************************************************************
4261 reads or writes a structure.
4262 ********************************************************************/
4263
4264 BOOL samr_io_q_lookup_rids(const char *desc, SAMR_Q_LOOKUP_RIDS * q_u,
4265                            prs_struct *ps, int depth)
4266 {
4267         uint32 i;
4268         fstring tmp;
4269
4270         if (q_u == NULL)
4271                 return False;
4272
4273         prs_debug(ps, depth, desc, "samr_io_q_lookup_rids");
4274         depth++;
4275
4276         if (UNMARSHALLING(ps))
4277                 ZERO_STRUCTP(q_u);
4278
4279         if(!prs_align(ps))
4280                 return False;
4281
4282         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4283                 return False;
4284
4285         if(!prs_uint32("num_rids1", ps, depth, &q_u->num_rids1))
4286                 return False;
4287         if(!prs_uint32("flags    ", ps, depth, &q_u->flags))
4288                 return False;
4289         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
4290                 return False;
4291         if(!prs_uint32("num_rids2", ps, depth, &q_u->num_rids2))
4292                 return False;
4293
4294         if (UNMARSHALLING(ps) && (q_u->num_rids2 != 0)) {
4295                 q_u->rid = PRS_ALLOC_MEM(ps, uint32, q_u->num_rids2);
4296                 if (q_u->rid == NULL)
4297                         return False;
4298         }
4299
4300         for (i = 0; i < q_u->num_rids2; i++) {
4301                 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]  ", i);
4302                 if(!prs_uint32(tmp, ps, depth, &q_u->rid[i]))
4303                         return False;
4304         }
4305
4306         return True;
4307 }
4308
4309 /*******************************************************************
4310 inits a SAMR_R_LOOKUP_RIDS structure.
4311 ********************************************************************/
4312
4313 void init_samr_r_lookup_rids(SAMR_R_LOOKUP_RIDS * r_u,
4314                              uint32 num_names, UNIHDR * hdr_name,
4315                              UNISTR2 *uni_name, uint32 *type)
4316 {
4317         DEBUG(5, ("init_samr_r_lookup_rids\n"));
4318
4319         r_u->hdr_name = NULL;
4320         r_u->uni_name = NULL;
4321         r_u->type = NULL;
4322
4323         if (num_names != 0) {
4324                 r_u->num_names1 = num_names;
4325                 r_u->ptr_names = 1;
4326                 r_u->num_names2 = num_names;
4327
4328                 r_u->num_types1 = num_names;
4329                 r_u->ptr_types = 1;
4330                 r_u->num_types2 = num_names;
4331
4332                 r_u->hdr_name = hdr_name;
4333                 r_u->uni_name = uni_name;
4334                 r_u->type = type;
4335         } else {
4336                 r_u->num_names1 = num_names;
4337                 r_u->ptr_names = 0;
4338                 r_u->num_names2 = num_names;
4339
4340                 r_u->num_types1 = num_names;
4341                 r_u->ptr_types = 0;
4342                 r_u->num_types2 = num_names;
4343         }
4344 }
4345
4346 /*******************************************************************
4347 reads or writes a structure.
4348 ********************************************************************/
4349
4350 BOOL samr_io_r_lookup_rids(const char *desc, SAMR_R_LOOKUP_RIDS * r_u,
4351                            prs_struct *ps, int depth)
4352 {
4353         uint32 i;
4354         fstring tmp;
4355         if (r_u == NULL)
4356                 return False;
4357
4358         prs_debug(ps, depth, desc, "samr_io_r_lookup_rids");
4359         depth++;
4360
4361         if(!prs_align(ps))
4362                 return False;
4363
4364         if(!prs_uint32("num_names1", ps, depth, &r_u->num_names1))
4365                 return False;
4366         if(!prs_uint32("ptr_names ", ps, depth, &r_u->ptr_names))
4367                 return False;
4368
4369         if (r_u->ptr_names != 0) {
4370
4371                 if(!prs_uint32("num_names2", ps, depth, &r_u->num_names2))
4372                         return False;
4373
4374
4375                 if (UNMARSHALLING(ps) && (r_u->num_names2 != 0)) {
4376                         r_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, r_u->num_names2);
4377                         if (r_u->hdr_name == NULL)
4378                                 return False;
4379
4380                         r_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, r_u->num_names2);
4381                         if (r_u->uni_name == NULL)
4382                                 return False;
4383                 }
4384
4385                 for (i = 0; i < r_u->num_names2; i++) {
4386                         slprintf(tmp, sizeof(tmp) - 1, "hdr[%02d]  ", i);
4387                         if(!smb_io_unihdr("", &r_u->hdr_name[i], ps, depth))
4388                                 return False;
4389                 }
4390                 for (i = 0; i < r_u->num_names2; i++) {
4391                         slprintf(tmp, sizeof(tmp) - 1, "str[%02d]  ", i);
4392                         if(!smb_io_unistr2("", &r_u->uni_name[i], r_u->hdr_name[i].buffer, ps, depth))
4393                                 return False;
4394                 }
4395
4396         }
4397
4398         if(!prs_align(ps))
4399                 return False;
4400         if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
4401                 return False;
4402         if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
4403                 return False;
4404
4405         if (r_u->ptr_types != 0) {
4406
4407                 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
4408                         return False;
4409
4410                 if (UNMARSHALLING(ps) && (r_u->num_types2 != 0)) {
4411                         r_u->type = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
4412                         if (r_u->type == NULL)
4413                                 return False;
4414                 }
4415
4416                 for (i = 0; i < r_u->num_types2; i++) {
4417                         slprintf(tmp, sizeof(tmp) - 1, "type[%02d]  ", i);
4418                         if(!prs_uint32(tmp, ps, depth, &r_u->type[i]))
4419                                 return False;
4420                 }
4421         }
4422
4423         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4424                 return False;
4425
4426         return True;
4427 }
4428
4429 /*******************************************************************
4430 inits a SAMR_Q_OPEN_ALIAS structure.
4431 ********************************************************************/
4432
4433 void init_samr_q_delete_alias(SAMR_Q_DELETE_DOM_ALIAS * q_u, POLICY_HND *hnd)
4434 {
4435         DEBUG(5, ("init_samr_q_delete_alias\n"));
4436
4437         q_u->alias_pol = *hnd;
4438 }
4439
4440 /*******************************************************************
4441 reads or writes a structure.
4442 ********************************************************************/
4443
4444 BOOL samr_io_q_delete_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4445                             prs_struct *ps, int depth)
4446 {
4447         if (q_u == NULL)
4448                 return False;
4449
4450         prs_debug(ps, depth, desc, "samr_io_q_delete_alias");
4451         depth++;
4452
4453         if(!prs_align(ps))
4454                 return False;
4455
4456         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4457                 return False;
4458
4459         return True;
4460 }
4461
4462 /*******************************************************************
4463 reads or writes a structure.
4464 ********************************************************************/
4465
4466 BOOL samr_io_r_delete_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4467                             prs_struct *ps, int depth)
4468 {
4469         if (r_u == NULL)
4470                 return False;
4471
4472         prs_debug(ps, depth, desc, "samr_io_r_delete_alias");
4473         depth++;
4474
4475         if(!prs_align(ps))
4476                 return False;
4477
4478         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4479                 return False;
4480         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4481                 return False;
4482
4483         return True;
4484 }
4485
4486 /*******************************************************************
4487 inits a SAMR_Q_CREATE_DOM_ALIAS structure.
4488 ********************************************************************/
4489
4490 void init_samr_q_create_dom_alias(SAMR_Q_CREATE_DOM_ALIAS * q_u,
4491                                   POLICY_HND *hnd, const char *acct_desc)
4492 {
4493         DEBUG(5, ("init_samr_q_create_dom_alias\n"));
4494
4495         q_u->dom_pol = *hnd;
4496
4497         init_unistr2(&q_u->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
4498         init_uni_hdr(&q_u->hdr_acct_desc, &q_u->uni_acct_desc);
4499
4500         q_u->access_mask = MAXIMUM_ALLOWED_ACCESS;
4501 }
4502
4503 /*******************************************************************
4504 reads or writes a structure.
4505 ********************************************************************/
4506
4507 BOOL samr_io_q_create_dom_alias(const char *desc, SAMR_Q_CREATE_DOM_ALIAS * q_u,
4508                                 prs_struct *ps, int depth)
4509 {
4510         if (q_u == NULL)
4511                 return False;
4512
4513         prs_debug(ps, depth, desc, "samr_io_q_create_dom_alias");
4514         depth++;
4515
4516         if(!prs_align(ps))
4517                 return False;
4518
4519         if(!smb_io_pol_hnd("dom_pol", &q_u->dom_pol, ps, depth))
4520                 return False;
4521
4522         if(!smb_io_unihdr("hdr_acct_desc", &q_u->hdr_acct_desc, ps, depth))
4523                 return False;
4524         if(!smb_io_unistr2("uni_acct_desc", &q_u->uni_acct_desc,
4525                        q_u->hdr_acct_desc.buffer, ps, depth))
4526                 return False;
4527
4528         if(!prs_align(ps))
4529                 return False;
4530         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
4531                 return False;
4532
4533         return True;
4534 }
4535
4536 /*******************************************************************
4537 reads or writes a structure.
4538 ********************************************************************/
4539
4540 BOOL samr_io_r_create_dom_alias(const char *desc, SAMR_R_CREATE_DOM_ALIAS * r_u,
4541                                 prs_struct *ps, int depth)
4542 {
4543         if (r_u == NULL)
4544                 return False;
4545
4546         prs_debug(ps, depth, desc, "samr_io_r_create_dom_alias");
4547         depth++;
4548
4549         if(!prs_align(ps))
4550                 return False;
4551
4552         if(!smb_io_pol_hnd("alias_pol", &r_u->alias_pol, ps, depth))
4553                 return False;
4554
4555         if(!prs_uint32("rid", ps, depth, &r_u->rid))
4556                 return False;
4557
4558         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4559                 return False;
4560
4561         return True;
4562 }
4563
4564 /*******************************************************************
4565 inits a SAMR_Q_ADD_ALIASMEM structure.
4566 ********************************************************************/
4567
4568 void init_samr_q_add_aliasmem(SAMR_Q_ADD_ALIASMEM * q_u, POLICY_HND *hnd,
4569                               DOM_SID *sid)
4570 {
4571         DEBUG(5, ("init_samr_q_add_aliasmem\n"));
4572
4573         q_u->alias_pol = *hnd;
4574         init_dom_sid2(&q_u->sid, sid);
4575 }
4576
4577 /*******************************************************************
4578 reads or writes a structure.
4579 ********************************************************************/
4580
4581 BOOL samr_io_q_add_aliasmem(const char *desc, SAMR_Q_ADD_ALIASMEM * q_u,
4582                             prs_struct *ps, int depth)
4583 {
4584         if (q_u == NULL)
4585                 return False;
4586
4587         prs_debug(ps, depth, desc, "samr_io_q_add_aliasmem");
4588         depth++;
4589
4590         if(!prs_align(ps))
4591                 return False;
4592
4593         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4594                 return False;
4595         if(!smb_io_dom_sid2("sid      ", &q_u->sid, ps, depth))
4596                 return False;
4597
4598         return True;
4599 }
4600
4601 /*******************************************************************
4602 reads or writes a structure.
4603 ********************************************************************/
4604
4605 BOOL samr_io_r_add_aliasmem(const char *desc, SAMR_R_ADD_ALIASMEM * r_u,
4606                             prs_struct *ps, int depth)
4607 {
4608         if (r_u == NULL)
4609                 return False;
4610
4611         prs_debug(ps, depth, desc, "samr_io_r_add_aliasmem");
4612         depth++;
4613
4614         if(!prs_align(ps))
4615                 return False;
4616
4617         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4618                 return False;
4619
4620         return True;
4621 }
4622
4623 /*******************************************************************
4624 inits a SAMR_Q_DEL_ALIASMEM structure.
4625 ********************************************************************/
4626
4627 void init_samr_q_del_aliasmem(SAMR_Q_DEL_ALIASMEM * q_u, POLICY_HND *hnd,
4628                               DOM_SID *sid)
4629 {
4630         DEBUG(5, ("init_samr_q_del_aliasmem\n"));
4631
4632         q_u->alias_pol = *hnd;
4633         init_dom_sid2(&q_u->sid, sid);
4634 }
4635
4636 /*******************************************************************
4637 reads or writes a structure.
4638 ********************************************************************/
4639
4640 BOOL samr_io_q_del_aliasmem(const char *desc, SAMR_Q_DEL_ALIASMEM * q_u,
4641                             prs_struct *ps, int depth)
4642 {
4643         if (q_u == NULL)
4644                 return False;
4645
4646         prs_debug(ps, depth, desc, "samr_io_q_del_aliasmem");
4647         depth++;
4648
4649         if(!prs_align(ps))
4650                 return False;
4651
4652         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4653                 return False;
4654         if(!smb_io_dom_sid2("sid      ", &q_u->sid, ps, depth))
4655                 return False;
4656
4657         return True;
4658 }
4659
4660 /*******************************************************************
4661 reads or writes a structure.
4662 ********************************************************************/
4663
4664 BOOL samr_io_r_del_aliasmem(const char *desc, SAMR_R_DEL_ALIASMEM * r_u,
4665                             prs_struct *ps, int depth)
4666 {
4667         if (r_u == NULL)
4668                 return False;
4669
4670         prs_debug(ps, depth, desc, "samr_io_r_del_aliasmem");
4671         depth++;
4672
4673         if(!prs_align(ps))
4674                 return False;
4675
4676         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4677                 return False;
4678
4679         return True;
4680 }
4681
4682 /*******************************************************************
4683 inits a SAMR_Q_DELETE_DOM_ALIAS structure.
4684 ********************************************************************/
4685
4686 void init_samr_q_delete_dom_alias(SAMR_Q_DELETE_DOM_ALIAS * q_c,
4687                                   POLICY_HND *hnd)
4688 {
4689         DEBUG(5, ("init_samr_q_delete_dom_alias\n"));
4690
4691         q_c->alias_pol = *hnd;
4692 }
4693
4694 /*******************************************************************
4695 reads or writes a structure.
4696 ********************************************************************/
4697
4698 BOOL samr_io_q_delete_dom_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4699                                 prs_struct *ps, int depth)
4700 {
4701         if (q_u == NULL)
4702                 return False;
4703
4704         prs_debug(ps, depth, desc, "samr_io_q_delete_dom_alias");
4705         depth++;
4706
4707         if(!prs_align(ps))
4708                 return False;
4709
4710         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4711                 return False;
4712
4713         return True;
4714 }
4715
4716 /*******************************************************************
4717 inits a SAMR_R_DELETE_DOM_ALIAS structure.
4718 ********************************************************************/
4719
4720 void init_samr_r_delete_dom_alias(SAMR_R_DELETE_DOM_ALIAS * r_u,
4721                                   NTSTATUS status)
4722 {
4723         DEBUG(5, ("init_samr_r_delete_dom_alias\n"));
4724
4725         r_u->status = status;
4726 }
4727
4728 /*******************************************************************
4729 reads or writes a structure.
4730 ********************************************************************/
4731
4732 BOOL samr_io_r_delete_dom_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4733                                 prs_struct *ps, int depth)
4734 {
4735         if (r_u == NULL)
4736                 return False;
4737
4738         prs_debug(ps, depth, desc, "samr_io_r_delete_dom_alias");
4739         depth++;
4740
4741         if(!prs_align(ps))
4742                 return False;
4743
4744         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4745                 return False;
4746
4747         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4748                 return False;
4749
4750         return True;
4751 }
4752
4753 /*******************************************************************
4754 inits a SAMR_Q_QUERY_ALIASMEM structure.
4755 ********************************************************************/
4756
4757 void init_samr_q_query_aliasmem(SAMR_Q_QUERY_ALIASMEM * q_c,
4758                                 POLICY_HND *hnd)
4759 {
4760         DEBUG(5, ("init_samr_q_query_aliasmem\n"));
4761
4762         q_c->alias_pol = *hnd;
4763 }
4764
4765 /*******************************************************************
4766 reads or writes a structure.
4767 ********************************************************************/
4768
4769 BOOL samr_io_q_query_aliasmem(const char *desc, SAMR_Q_QUERY_ALIASMEM * q_u,
4770                               prs_struct *ps, int depth)
4771 {
4772         if (q_u == NULL)
4773                 return False;
4774
4775         prs_debug(ps, depth, desc, "samr_io_q_query_aliasmem");
4776         depth++;
4777
4778         if(!prs_align(ps))
4779                 return False;
4780
4781         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4782                 return False;
4783
4784         return True;
4785 }
4786
4787 /*******************************************************************
4788 inits a SAMR_R_QUERY_ALIASMEM structure.
4789 ********************************************************************/
4790
4791 void init_samr_r_query_aliasmem(SAMR_R_QUERY_ALIASMEM * r_u,
4792                                 uint32 num_sids, DOM_SID2 * sid,
4793                                 NTSTATUS status)
4794 {
4795         DEBUG(5, ("init_samr_r_query_aliasmem\n"));
4796
4797         if (NT_STATUS_IS_OK(status)) {
4798                 r_u->num_sids = num_sids;
4799                 r_u->ptr = (num_sids != 0) ? 1 : 0;
4800                 r_u->num_sids1 = num_sids;
4801
4802                 r_u->sid = sid;
4803         } else {
4804                 r_u->ptr = 0;
4805                 r_u->num_sids = 0;
4806         }
4807
4808         r_u->status = status;
4809 }
4810
4811 /*******************************************************************
4812 reads or writes a structure.
4813 ********************************************************************/
4814
4815 BOOL samr_io_r_query_aliasmem(const char *desc, SAMR_R_QUERY_ALIASMEM * r_u,
4816                               prs_struct *ps, int depth)
4817 {
4818         uint32 i;
4819
4820         if (r_u == NULL)
4821                 return False;
4822
4823         prs_debug(ps, depth, desc, "samr_io_r_query_aliasmem");
4824         depth++;
4825
4826         if(!prs_align(ps))
4827                 return False;
4828
4829         if(!prs_uint32("num_sids ", ps, depth, &r_u->num_sids))
4830                 return False;
4831         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
4832                 return False;
4833
4834         if (r_u->ptr != 0 && r_u->num_sids != 0) {
4835                 uint32 *ptr_sid = NULL;
4836
4837                 if(!prs_uint32("num_sids1", ps, depth, &r_u->num_sids1))
4838                         return False;
4839
4840                 /* We must always use talloc here even when marshalling. */
4841                 if (r_u->num_sids1) {
4842                         ptr_sid = TALLOC_ARRAY(ps->mem_ctx, uint32, r_u->num_sids1);
4843                         if (!ptr_sid) {
4844                                 return False;
4845                         }
4846                 } else {
4847                         ptr_sid = NULL;
4848                 }
4849
4850                 for (i = 0; i < r_u->num_sids1; i++) {
4851                         ptr_sid[i] = 1;
4852                         if(!prs_uint32("ptr_sid", ps, depth, &ptr_sid[i]))
4853                                 return False;
4854                 }
4855
4856                 if (UNMARSHALLING(ps)) {
4857                         if (r_u->num_sids1) {
4858                                 r_u->sid = TALLOC_ARRAY(ps->mem_ctx, DOM_SID2, r_u->num_sids1);
4859                                 if (!r_u->sid) {
4860                                         return False;
4861                                 }
4862                         } else {
4863                                 r_u->sid = NULL;
4864                         }
4865                 }
4866
4867                 for (i = 0; i < r_u->num_sids1; i++) {
4868                         if (ptr_sid[i] != 0) {
4869                                 if(!smb_io_dom_sid2("sid", &r_u->sid[i], ps, depth))
4870                                         return False;
4871                         }
4872                 }
4873         }
4874
4875         if(!prs_align(ps))
4876                 return False;
4877         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4878                 return False;
4879
4880         return True;
4881 }
4882
4883 /*******************************************************************
4884 inits a SAMR_Q_LOOKUP_NAMES structure.
4885 ********************************************************************/
4886
4887 NTSTATUS init_samr_q_lookup_names(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_NAMES * q_u,
4888                               POLICY_HND *pol, uint32 flags,
4889                               uint32 num_names, const char **name)
4890 {
4891         uint32 i;
4892
4893         DEBUG(5, ("init_samr_q_lookup_names\n"));
4894
4895         q_u->pol = *pol;
4896
4897         q_u->num_names1 = num_names;
4898         q_u->flags = flags;
4899         q_u->ptr = 0;
4900         q_u->num_names2 = num_names;
4901
4902         if (num_names) {
4903                 if (!(q_u->hdr_name = TALLOC_ZERO_ARRAY(ctx, UNIHDR, num_names)))
4904                         return NT_STATUS_NO_MEMORY;
4905
4906                 if (!(q_u->uni_name = TALLOC_ZERO_ARRAY(ctx, UNISTR2, num_names)))
4907                         return NT_STATUS_NO_MEMORY;
4908         } else {
4909                 q_u->hdr_name = NULL;
4910                 q_u->uni_name = NULL;
4911         }
4912
4913         for (i = 0; i < num_names; i++) {
4914                 init_unistr2(&q_u->uni_name[i], name[i], UNI_FLAGS_NONE);       /* unicode string for machine account */
4915                 init_uni_hdr(&q_u->hdr_name[i], &q_u->uni_name[i]);     /* unicode header for user_name */
4916         }
4917
4918         return NT_STATUS_OK;
4919 }
4920
4921 /*******************************************************************
4922 reads or writes a structure.
4923 ********************************************************************/
4924
4925 BOOL samr_io_q_lookup_names(const char *desc, SAMR_Q_LOOKUP_NAMES * q_u,
4926                             prs_struct *ps, int depth)
4927 {
4928         uint32 i;
4929
4930         if (q_u == NULL)
4931                 return False;
4932
4933         prs_debug(ps, depth, desc, "samr_io_q_lookup_names");
4934         depth++;
4935
4936         if (UNMARSHALLING(ps))
4937                 ZERO_STRUCTP(q_u);
4938
4939         if(!prs_align(ps))
4940                 return False;
4941
4942         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4943                 return False;
4944
4945         if(!prs_uint32("num_names1", ps, depth, &q_u->num_names1))
4946                 return False;
4947         if(!prs_uint32("flags     ", ps, depth, &q_u->flags))
4948                 return False;
4949         if(!prs_uint32("ptr       ", ps, depth, &q_u->ptr))
4950                 return False;
4951         if(!prs_uint32("num_names2", ps, depth, &q_u->num_names2))
4952                 return False;
4953
4954         if (UNMARSHALLING(ps) && (q_u->num_names2 != 0)) {
4955                 q_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_u->num_names2);
4956                 q_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_u->num_names2);
4957                 if (!q_u->hdr_name || !q_u->uni_name)
4958                         return False;
4959         }
4960
4961         for (i = 0; i < q_u->num_names2; i++) {
4962                 if(!smb_io_unihdr("", &q_u->hdr_name[i], ps, depth))
4963                         return False;
4964         }
4965
4966         for (i = 0; i < q_u->num_names2; i++) {
4967                 if(!smb_io_unistr2("", &q_u->uni_name[i], q_u->hdr_name[i].buffer, ps, depth))
4968                         return False;
4969         }
4970
4971         return True;
4972 }
4973
4974 /*******************************************************************
4975 inits a SAMR_R_LOOKUP_NAMES structure.
4976 ********************************************************************/
4977
4978 NTSTATUS init_samr_r_lookup_names(TALLOC_CTX *ctx, SAMR_R_LOOKUP_NAMES * r_u,
4979                               uint32 num_rids,
4980                               uint32 *rid, enum lsa_SidType *type,
4981                               NTSTATUS status)
4982 {
4983         DEBUG(5, ("init_samr_r_lookup_names\n"));
4984
4985         if (NT_STATUS_IS_OK(status) && (num_rids != 0)) {
4986                 uint32 i;
4987
4988                 r_u->num_types1 = num_rids;
4989                 r_u->ptr_types = 1;
4990                 r_u->num_types2 = num_rids;
4991
4992                 r_u->num_rids1 = num_rids;
4993                 r_u->ptr_rids = 1;
4994                 r_u->num_rids2 = num_rids;
4995
4996                 if (num_rids) {
4997                         if (!(r_u->rids = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
4998                                 return NT_STATUS_NO_MEMORY;
4999                         if (!(r_u->types = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
5000                                 return NT_STATUS_NO_MEMORY;
5001                 } else {
5002                         r_u->rids = NULL;
5003                         r_u->types = NULL;
5004                 }
5005
5006                 if (!r_u->rids || !r_u->types)
5007                         goto empty;
5008
5009                 for (i = 0; i < num_rids; i++) {
5010                         r_u->rids[i] = rid[i];
5011                         r_u->types[i] = type[i];
5012                 }
5013         } else {
5014
5015   empty:
5016                 r_u->num_types1 = 0;
5017                 r_u->ptr_types = 0;
5018                 r_u->num_types2 = 0;
5019
5020                 r_u->num_rids1 = 0;
5021                 r_u->ptr_rids = 0;
5022                 r_u->num_rids2 = 0;
5023
5024                 r_u->rids = NULL;
5025                 r_u->types = NULL;
5026         }
5027
5028         r_u->status = status;
5029
5030         return NT_STATUS_OK;
5031 }
5032
5033 /*******************************************************************
5034 reads or writes a structure.
5035 ********************************************************************/
5036
5037 BOOL samr_io_r_lookup_names(const char *desc, SAMR_R_LOOKUP_NAMES * r_u,
5038                             prs_struct *ps, int depth)
5039 {
5040         uint32 i;
5041         fstring tmp;
5042
5043         if (r_u == NULL)
5044                 return False;
5045
5046         prs_debug(ps, depth, desc, "samr_io_r_lookup_names");
5047         depth++;
5048
5049         if (UNMARSHALLING(ps))
5050                 ZERO_STRUCTP(r_u);
5051
5052         if(!prs_align(ps))
5053                 return False;
5054
5055         if(!prs_uint32("num_rids1", ps, depth, &r_u->num_rids1))
5056                 return False;
5057         if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
5058                 return False;
5059
5060         if (r_u->ptr_rids != 0) {
5061                 if(!prs_uint32("num_rids2", ps, depth, &r_u->num_rids2))
5062                         return False;
5063
5064                 if (r_u->num_rids2 != r_u->num_rids1) {
5065                         /* RPC fault */
5066                         return False;
5067                 }
5068
5069                 if (UNMARSHALLING(ps) && r_u->num_rids2) {
5070                         r_u->rids = PRS_ALLOC_MEM(ps, uint32, r_u->num_rids2);
5071
5072                         if (!r_u->rids) {
5073                                 DEBUG(0, ("NULL rids in samr_io_r_lookup_names\n"));
5074                                 return False;
5075                         }
5076                 }
5077
5078                 for (i = 0; i < r_u->num_rids2; i++) {
5079                         slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]  ", i);
5080                         if(!prs_uint32(tmp, ps, depth, &r_u->rids[i]))
5081                                 return False;
5082                 }
5083         }
5084
5085         if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
5086                 return False;
5087         if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
5088                 return False;
5089
5090         if (r_u->ptr_types != 0) {
5091                 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
5092                         return False;
5093
5094                 if (r_u->num_types2 != r_u->num_types1) {
5095                         /* RPC fault */
5096                         return False;
5097                 }
5098
5099                 if (UNMARSHALLING(ps) && r_u->num_types2) {
5100                         r_u->types = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
5101
5102                         if (!r_u->types) {
5103                                 DEBUG(0, ("NULL types in samr_io_r_lookup_names\n"));
5104                                 return False;
5105                         }
5106                 }
5107
5108                 for (i = 0; i < r_u->num_types2; i++) {
5109                         slprintf(tmp, sizeof(tmp) - 1, "type[%02d]  ", i);
5110                         if(!prs_uint32(tmp, ps, depth, &r_u->types[i]))
5111                                 return False;
5112                 }
5113         }
5114
5115         if(!prs_ntstatus("status", ps, depth, &r_u->status))
5116                 return False;
5117
5118         return True;
5119 }
5120
5121 /*******************************************************************
5122 inits a SAMR_Q_DELETE_DOM_USER structure.
5123 ********************************************************************/
5124
5125 void init_samr_q_delete_dom_user(SAMR_Q_DELETE_DOM_USER * q_c,
5126                                  POLICY_HND *hnd)
5127 {
5128         DEBUG(5, ("init_samr_q_delete_dom_user\n"));
5129
5130         q_c->user_pol = *hnd;
5131 }
5132
5133 /*******************************************************************
5134 reads or writes a structure.
5135 ********************************************************************/
5136
5137 BOOL samr_io_q_delete_dom_user(const char *desc, SAMR_Q_DELETE_DOM_USER * q_u,
5138                                prs_struct *ps, int depth)
5139 {
5140         if (q_u == NULL)
5141                 return False;
5142
5143         prs_debug(ps, depth, desc, "samr_io_q_delete_dom_user");
5144         depth++;
5145
5146         if(!prs_align(ps))
5147                 return False;
5148
5149         if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
5150                 return False;
5151
5152         return True;
5153 }
5154
5155 /*******************************************************************
5156 reads or writes a structure.
5157 ********************************************************************/
5158
5159 BOOL samr_io_r_delete_dom_user(const char *desc, SAMR_R_DELETE_DOM_USER * r_u,
5160                                prs_struct *ps, int depth)
5161 {
5162         if (r_u == NULL)
5163                 return False;
5164
5165         prs_debug(ps, depth, desc, "samr_io_r_delete_dom_user");
5166         depth++;
5167
5168         if(!prs_align(ps))
5169                 return False;
5170
5171         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
5172                 return False;
5173         if(!prs_ntstatus("status", ps, depth, &r_u->status))
5174                 return False;
5175
5176         return True;
5177 }
5178
5179 /*******************************************************************
5180 reads or writes a structure.
5181 ********************************************************************/
5182
5183 void init_samr_q_open_user(SAMR_Q_OPEN_USER * q_u,
5184                            POLICY_HND *pol,
5185                            uint32 access_mask, uint32 rid)
5186 {
5187         DEBUG(5, ("samr_init_samr_q_open_user\n"));
5188
5189         q_u->domain_pol = *pol;
5190         q_u->access_mask = access_mask;
5191         q_u->user_rid = rid;
5192 }
5193
5194 /*******************************************************************
5195 reads or writes a structure.
5196 ********************************************************************/
5197
5198 BOOL samr_io_q_open_user(const char *desc, SAMR_Q_OPEN_USER * q_u,
5199                          prs_struct *ps, int depth)
5200 {
5201         if (q_u == NULL)
5202                 return False;
5203
5204         prs_debug(ps, depth, desc, "samr_io_q_open_user");
5205         depth++;
5206
5207         if(!prs_align(ps))
5208                 return False;
5209
5210         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
5211                 return False;
5212
5213         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
5214                 return False;
5215         if(!prs_uint32("user_rid ", ps, depth, &q_u->user_rid))
5216                 return False;
5217
5218         return True;
5219 }
5220
5221 /*******************************************************************
5222 reads or writes a structure.
5223 ********************************************************************/
5224
5225 BOOL samr_io_r_open_user(const char *desc, SAMR_R_OPEN_USER * r_u,
5226                          prs_struct *ps, int depth)
5227 {
5228         if (r_u == NULL)
5229                 return False;
5230
5231         prs_debug(ps, depth, desc, "samr_io_r_open_user");
5232         depth++;
5233
5234         if(!prs_align(ps))
5235                 return False;
5236
5237         if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
5238                 return False;
5239
5240         if(!prs_ntstatus("status", ps, depth, &r_u->status))
5241                 return False;
5242
5243         return True;
5244 }
5245
5246
5247 /*******************************************************************
5248 reads or writes a structure.
5249 ********************************************************************/
5250
5251 void init_samr_q_create_user(SAMR_Q_CREATE_USER * q_u,
5252                              POLICY_HND *pol,
5253                              const char *name,
5254                              uint32 acb_info, uint32 access_mask)
5255 {
5256         DEBUG(5, ("samr_init_samr_q_create_user\n"));
5257
5258         q_u->domain_pol = *pol;
5259
5260         init_unistr2(&q_u->uni_name, name, UNI_FLAGS_NONE);
5261         init_uni_hdr(&q_u->hdr_name, &q_u->uni_name);
5262
5263         q_u->acb_info = acb_info;
5264         q_u->access_mask = access_mask;
5265 }
5266
5267 /*******************************************************************
5268 reads or writes a structure.
5269 ********************************************************************/
5270
5271 BOOL samr_io_q_create_user(const char *desc, SAMR_Q_CREATE_USER * q_u,
5272                            prs_struct *ps, int depth)
5273 {
5274         if (q_u == NULL)
5275                 return False;
5276
5277         prs_debug(ps, depth, desc, "samr_io_q_create_user");
5278         depth++;
5279
5280         if(!prs_align(ps))
5281                 return False;
5282
5283         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
5284                 return False;
5285
5286         if(!smb_io_unihdr("hdr_name", &q_u->hdr_name, ps, depth))
5287                 return False;
5288         if(!smb_io_unistr2("uni_name", &q_u->uni_name, q_u->hdr_name.buffer, ps, depth))
5289                 return False;
5290
5291         if(!prs_align(ps))
5292                 return False;
5293         if(!prs_uint32("acb_info   ", ps, depth, &q_u->acb_info))
5294                 return False;
5295         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
5296                 return False;
5297
5298         return True;
5299 }
5300
5301 /*******************************************************************
5302 reads or writes a structure.
5303 ********************************************************************/
5304
5305 BOOL samr_io_r_create_user(const char *desc, SAMR_R_CREATE_USER * r_u,
5306                            prs_struct *ps, int depth)
5307 {
5308         if (r_u == NULL)
5309                 return False;
5310
5311         prs_debug(ps, depth, desc, "samr_io_r_create_user");
5312         depth++;
5313
5314         if(!prs_align(ps))
5315                 return False;
5316
5317         if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
5318                 return False;
5319
5320         if(!prs_uint32("access_granted", ps, depth, &r_u->access_granted))
5321                 return False;
5322         if(!prs_uint32("user_rid ", ps, depth, &r_u->user_rid))
5323                 return False;
5324         if(!prs_ntstatus("status", ps, depth, &r_u->status))
5325                 return False;
5326
5327         return True;
5328 }
5329
5330 /*******************************************************************
5331 inits a SAMR_Q_QUERY_USERINFO structure.
5332 ********************************************************************/
5333
5334 void init_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO * q_u,
5335                                 const POLICY_HND *hnd, uint16 switch_value)
5336 {
5337         DEBUG(5, ("init_samr_q_query_userinfo\n"));
5338
5339         q_u->pol = *hnd;
5340         q_u->switch_value = switch_value;
5341 }
5342
5343 /*******************************************************************
5344 reads or writes a structure.
5345 ********************************************************************/
5346
5347 BOOL samr_io_q_query_userinfo(const char *desc, SAMR_Q_QUERY_USERINFO * q_u,
5348                               prs_struct *ps, int depth)
5349 {
5350         if (q_u == NULL)
5351                 return False;
5352
5353         prs_debug(ps, depth, desc, "samr_io_q_query_userinfo");
5354         depth++;
5355
5356         if(!prs_align(ps))
5357                 return False;
5358
5359         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
5360                 return False;
5361
5362         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value)) /* 0x0015 or 0x0011 */
5363                 return False;
5364
5365         return True;
5366 }
5367
5368 /*******************************************************************
5369 reads or writes a LOGON_HRS structure.
5370 ********************************************************************/
5371
5372 static BOOL sam_io_logon_hrs(const char *desc, LOGON_HRS * hrs,
5373                              prs_struct *ps, int depth)
5374 {
5375         if (hrs == NULL)
5376                 return False;
5377
5378         prs_debug(ps, depth, desc, "sam_io_logon_hrs");
5379         depth++;
5380
5381         if(!prs_align(ps))
5382                 return False;
5383
5384         if(!prs_uint32("maxlen", ps, depth, &hrs->max_len))
5385                 return False;
5386
5387         if(!prs_uint32("offset", ps, depth, &hrs->offset))
5388                 return False;
5389
5390         if(!prs_uint32("len  ", ps, depth, &hrs->len))
5391                 return False;
5392
5393         if (hrs->len > sizeof(hrs->hours)) {
5394                 DEBUG(3, ("sam_io_logon_hrs: truncating length from %d\n", hrs->len));
5395                 hrs->len = sizeof(hrs->hours);
5396         }
5397
5398         if(!prs_uint8s(False, "hours", ps, depth, hrs->hours, hrs->len))
5399                 return False;
5400
5401         return True;
5402 }
5403
5404 /*******************************************************************
5405 inits a SAM_USER_INFO_18 structure.
5406 ********************************************************************/
5407
5408 void init_sam_user_info18(SAM_USER_INFO_18 * usr,
5409                           const uint8 lm_pwd[16], const uint8 nt_pwd[16])
5410 {
5411         DEBUG(5, ("init_sam_user_info18\n"));
5412
5413         usr->lm_pwd_active =
5414                 memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd)) ? 1 : 0;
5415         usr->nt_pwd_active =
5416                 memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd)) ? 1 : 0;
5417 }
5418
5419 /*******************************************************************
5420 reads or writes a structure.
5421 ********************************************************************/
5422
5423 static BOOL sam_io_user_info18(const char *desc, SAM_USER_INFO_18 * u,
5424                         prs_struct *ps, int depth)
5425 {
5426         if (u == NULL)
5427                 return False;
5428
5429         prs_debug(ps, depth, desc, "samr_io_r_user_info18");
5430         depth++;
5431
5432         if(!prs_align(ps))
5433                 return False;
5434
5435         if(!prs_uint8s(False, "lm_pwd", ps, depth, u->lm_pwd, sizeof(u->lm_pwd)))
5436                 return False;
5437         if(!prs_uint8s(False, "nt_pwd", ps, depth, u->nt_pwd, sizeof(u->nt_pwd)))
5438                 return False;
5439
5440         if(!prs_uint8("lm_pwd_active", ps, depth, &u->lm_pwd_active))
5441                 return False;
5442         if(!prs_uint8("nt_pwd_active", ps, depth, &u->nt_pwd_active))
5443                 return False;
5444
5445         return True;
5446 }
5447
5448 /*******************************************************************
5449 inits a SAM_USER_INFO_7 structure.
5450 ********************************************************************/
5451
5452 void init_sam_user_info7(SAM_USER_INFO_7 * usr, const char *name)
5453 {
5454         DEBUG(5, ("init_sam_user_info7\n"));
5455
5456         init_unistr2(&usr->uni_name, name, UNI_FLAGS_NONE);     /* unicode string for name */
5457         init_uni_hdr(&usr->hdr_name, &usr->uni_name);           /* unicode header for name */
5458
5459 }
5460
5461 /*******************************************************************
5462 reads or writes a structure.
5463 ********************************************************************/
5464
5465 static BOOL sam_io_user_info7(const char *desc, SAM_USER_INFO_7 * usr,
5466                         prs_struct *ps, int depth)
5467 {
5468         if (usr == NULL)
5469                 return False;
5470
5471         prs_debug(ps, depth, desc, "samr_io_r_user_info7");
5472         depth++;
5473
5474         if(!prs_align(ps))
5475                 return False;
5476
5477         if(!smb_io_unihdr("unihdr", &usr->hdr_name, ps, depth))
5478                 return False;
5479
5480         if(!smb_io_unistr2("unistr2", &usr->uni_name, True, ps, depth))
5481                 return False;
5482
5483         return True;
5484 }
5485
5486 /*******************************************************************
5487 inits a SAM_USER_INFO_9 structure.
5488 ********************************************************************/
5489
5490 void init_sam_user_info9(SAM_USER_INFO_9 * usr, uint32 rid_group)
5491 {
5492         DEBUG(5, ("init_sam_user_info9\n"));
5493
5494         usr->rid_group = rid_group;
5495 }
5496
5497 /*******************************************************************
5498 reads or writes a structure.
5499 ********************************************************************/
5500
5501 static BOOL sam_io_user_info9(const char *desc, SAM_USER_INFO_9 * usr,
5502                         prs_struct *ps, int depth)
5503 {
5504         if (usr == NULL)
5505                 return False;
5506
5507         prs_debug(ps, depth, desc, "samr_io_r_user_info9");
5508         depth++;
5509
5510         if(!prs_align(ps))
5511                 return False;
5512
5513         if(!prs_uint32("rid_group", ps, depth, &usr->rid_group))
5514                 return False;
5515
5516         return True;
5517 }
5518
5519 /*******************************************************************
5520 inits a SAM_USER_INFO_16 structure.
5521 ********************************************************************/
5522
5523 void init_sam_user_info16(SAM_USER_INFO_16 * usr, uint32 acb_info)
5524 {
5525         DEBUG(5, ("init_sam_user_info16\n"));
5526
5527         usr->acb_info = acb_info;
5528 }
5529
5530 /*******************************************************************
5531 reads or writes a structure.
5532 ********************************************************************/
5533
5534 static BOOL sam_io_user_info16(const char *desc, SAM_USER_INFO_16 * usr,
5535                         prs_struct *ps, int depth)
5536 {
5537         if (usr == NULL)
5538                 return False;
5539
5540         prs_debug(ps, depth, desc, "samr_io_r_user_info16");
5541         depth++;
5542
5543         if(!prs_align(ps))
5544                 return False;
5545
5546         if(!prs_uint32("acb_info", ps, depth, &usr->acb_info))
5547                 return False;
5548
5549         return True;
5550 }
5551
5552 /*******************************************************************
5553 inits a SAM_USER_INFO_17 structure.
5554 ********************************************************************/
5555
5556 void init_sam_user_info17(SAM_USER_INFO_17 * usr,
5557                           NTTIME * expiry,
5558                           char *mach_acct,
5559                           uint32 rid_user, uint32 rid_group, uint16 acct_ctrl)
5560 {
5561         DEBUG(5, ("init_sam_user_info17\n"));
5562
5563         memcpy(&usr->expiry, expiry, sizeof(usr->expiry));      /* expiry time or something? */
5564         ZERO_STRUCT(usr->padding_1);    /* 0 - padding 24 bytes */
5565
5566         usr->padding_2 = 0;     /* 0 - padding 4 bytes */
5567
5568         usr->ptr_1 = 1;         /* pointer */
5569         ZERO_STRUCT(usr->padding_3);    /* 0 - padding 32 bytes */
5570         usr->padding_4 = 0;     /* 0 - padding 4 bytes */
5571
5572         usr->ptr_2 = 1;         /* pointer */
5573         usr->padding_5 = 0;     /* 0 - padding 4 bytes */
5574
5575         usr->ptr_3 = 1;         /* pointer */
5576         ZERO_STRUCT(usr->padding_6);    /* 0 - padding 32 bytes */
5577
5578         usr->rid_user = rid_user;
5579         usr->rid_group = rid_group;
5580
5581         usr->acct_ctrl = acct_ctrl;
5582         usr->unknown_3 = 0x0000;
5583
5584         usr->unknown_4 = 0x003f;        /* 0x003f      - 16 bit unknown */
5585         usr->unknown_5 = 0x003c;        /* 0x003c      - 16 bit unknown */
5586
5587         ZERO_STRUCT(usr->padding_7);    /* 0 - padding 16 bytes */
5588         usr->padding_8 = 0;     /* 0 - padding 4 bytes */
5589
5590         init_unistr2(&usr->uni_mach_acct, mach_acct, UNI_FLAGS_NONE);   /* unicode string for machine account */
5591         init_uni_hdr(&usr->hdr_mach_acct, &usr->uni_mach_acct); /* unicode header for machine account */
5592 }
5593
5594 /*******************************************************************
5595 reads or writes a structure.
5596 ********************************************************************/
5597
5598 static BOOL sam_io_user_info17(const char *desc, SAM_USER_INFO_17 * usr,
5599                         prs_struct *ps, int depth)
5600 {
5601         if (usr == NULL)
5602                 return False;
5603
5604         prs_debug(ps, depth, desc, "samr_io_r_unknown_17");
5605         depth++;
5606
5607         if(!prs_align(ps))
5608                 return False;
5609
5610         if(!prs_uint8s(False, "padding_0", ps, depth, usr->padding_0, sizeof(usr->padding_0)))
5611                 return False;
5612
5613         if(!smb_io_time("time", &usr->expiry, ps, depth))
5614                 return False;
5615
5616         if(!prs_uint8s(False, "padding_1", ps, depth, usr->padding_1, sizeof(usr->padding_1)))
5617                 return False;
5618
5619         if(!smb_io_unihdr("unihdr", &usr->hdr_mach_acct, ps, depth))
5620                 return False;
5621
5622         if(!prs_uint32("padding_2", ps, depth, &usr->padding_2))
5623                 return False;
5624
5625         if(!prs_uint32("ptr_1    ", ps, depth, &usr->ptr_1))
5626                 return False;
5627         if(!prs_uint8s(False, "padding_3", ps, depth, usr->padding_3, sizeof(usr->padding_3)))
5628                 return False;
5629
5630         if(!prs_uint32("padding_4", ps, depth, &usr->padding_4))
5631                 return False;
5632
5633         if(!prs_uint32("ptr_2    ", ps, depth, &usr->ptr_2))
5634                 return False;
5635         if(!prs_uint32("padding_5", ps, depth, &usr->padding_5))
5636                 return False;
5637
5638         if(!prs_uint32("ptr_3    ", ps, depth, &usr->ptr_3))
5639                 return False;
5640         if(!prs_uint8s(False, "padding_6", ps, depth, usr->padding_6,sizeof(usr->padding_6)))
5641                 return False;
5642
5643         if(!prs_uint32("rid_user ", ps, depth, &usr->rid_user))
5644                 return False;
5645         if(!prs_uint32("rid_group", ps, depth, &usr->rid_group))
5646                 return False;
5647         if(!prs_uint16("acct_ctrl", ps, depth, &usr->acct_ctrl))
5648                 return False;
5649         if(!prs_uint16("unknown_3", ps, depth, &usr->unknown_3))
5650                 return False;
5651         if(!prs_uint16("unknown_4", ps, depth, &usr->unknown_4))
5652                 return False;
5653         if(!prs_uint16("unknown_5", ps, depth, &usr->unknown_5))
5654                 return False;
5655
5656         if(!prs_uint8s(False, "padding_7", ps, depth, usr->padding_7, sizeof(usr->padding_7)))
5657                 return False;
5658
5659         if(!prs_uint32("padding_8", ps, depth, &(usr->padding_8)))
5660                 return False;
5661
5662         if(!smb_io_unistr2("unistr2", &usr->uni_mach_acct, True, ps, depth))
5663                 return False;
5664
5665         if(!prs_align(ps))
5666                 return False;
5667
5668         if(!prs_uint8s(False, "padding_9", ps, depth, usr->padding_9, sizeof(usr->padding_9)))
5669                 return False;
5670
5671         return True;
5672 }
5673
5674 /*************************************************************************
5675  init_sam_user_infoa
5676  *************************************************************************/
5677
5678 void init_sam_user_info24(SAM_USER_INFO_24 * usr, char newpass[516],
5679                           uint8 pw_len)
5680 {
5681         DEBUG(10, ("init_sam_user_info24:\n"));
5682         memcpy(usr->pass, newpass, sizeof(usr->pass));
5683         usr->pw_len = pw_len;
5684 }
5685
5686 /*******************************************************************
5687 reads or writes a structure.
5688 ********************************************************************/
5689
5690 static BOOL sam_io_user_info24(const char *desc, SAM_USER_INFO_24 * usr,
5691                                prs_struct *ps, int depth)
5692 {
5693         if (usr == NULL)
5694                 return False;
5695
5696         prs_debug(ps, depth, desc, "sam_io_user_info24");
5697         depth++;
5698
5699         if(!prs_align(ps))
5700                 return False;
5701
5702         if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5703                        sizeof(usr->pass)))
5704                 return False;
5705
5706         if (MARSHALLING(ps) && (usr->pw_len != 0)) {
5707                 if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5708                         return False;
5709         } else if (UNMARSHALLING(ps)) {
5710                 if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5711                         return False;
5712         }
5713
5714         return True;
5715 }
5716
5717 /*******************************************************************
5718 reads or writes a structure.
5719 ********************************************************************/
5720
5721 static BOOL sam_io_user_info26(const char *desc, SAM_USER_INFO_26 * usr,
5722                                prs_struct *ps, int depth)
5723 {
5724         if (usr == NULL)
5725                 return False;
5726
5727         prs_debug(ps, depth, desc, "sam_io_user_info26");
5728         depth++;
5729
5730         if(!prs_align(ps))
5731                 return False;
5732
5733         if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5734                        sizeof(usr->pass)))
5735                 return False;
5736
5737         if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5738                 return False;
5739
5740         return True;
5741 }
5742
5743
5744 /*************************************************************************
5745  init_sam_user_info23
5746
5747  unknown_6 = 0x0000 04ec
5748
5749  *************************************************************************/
5750
5751 void init_sam_user_info23W(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5752                         NTTIME * logoff_time,   /* all zeros */
5753                         NTTIME * kickoff_time,  /* all zeros */
5754                         NTTIME * pass_last_set_time,    /* all zeros */
5755                         NTTIME * pass_can_change_time,  /* all zeros */
5756                         NTTIME * pass_must_change_time, /* all zeros */
5757                         UNISTR2 *user_name,
5758                         UNISTR2 *full_name,
5759                         UNISTR2 *home_dir,
5760                         UNISTR2 *dir_drive,
5761                         UNISTR2 *log_scr,
5762                         UNISTR2 *prof_path,
5763                         UNISTR2 *desc,
5764                         UNISTR2 *wkstas,
5765                         UNISTR2 *unk_str,
5766                         UNISTR2 *mung_dial,
5767                         uint32 user_rid,        /* 0x0000 0000 */
5768                         uint32 group_rid,
5769                         uint32 acb_info,
5770                         uint32 fields_present,
5771                         uint16 logon_divs,
5772                         LOGON_HRS * hrs,
5773                         uint16 bad_password_count,
5774                         uint16 logon_count,
5775                         char newpass[516])
5776 {
5777         usr->logon_time = *logon_time;  /* all zeros */
5778         usr->logoff_time = *logoff_time;        /* all zeros */
5779         usr->kickoff_time = *kickoff_time;      /* all zeros */
5780         usr->pass_last_set_time = *pass_last_set_time;  /* all zeros */
5781         usr->pass_can_change_time = *pass_can_change_time;      /* all zeros */
5782         usr->pass_must_change_time = *pass_must_change_time;    /* all zeros */
5783
5784         ZERO_STRUCT(usr->nt_pwd);
5785         ZERO_STRUCT(usr->lm_pwd);
5786
5787         usr->user_rid = user_rid;       /* 0x0000 0000 */
5788         usr->group_rid = group_rid;
5789         usr->acb_info = acb_info;
5790         usr->fields_present = fields_present;   /* 09f8 27fa */
5791
5792         usr->logon_divs = logon_divs;   /* should be 168 (hours/week) */
5793         usr->ptr_logon_hrs = hrs ? 1 : 0;
5794
5795         if (nt_time_is_zero(pass_must_change_time)) {
5796                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5797         } else {
5798                 usr->passmustchange=0;
5799         }
5800
5801         ZERO_STRUCT(usr->padding1);
5802         ZERO_STRUCT(usr->padding2);
5803
5804         usr->bad_password_count = bad_password_count;
5805         usr->logon_count = logon_count;
5806
5807         memcpy(usr->pass, newpass, sizeof(usr->pass));
5808
5809         copy_unistr2(&usr->uni_user_name, user_name);
5810         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5811
5812         copy_unistr2(&usr->uni_full_name, full_name);
5813         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5814
5815         copy_unistr2(&usr->uni_home_dir, home_dir);
5816         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5817
5818         copy_unistr2(&usr->uni_dir_drive, dir_drive);
5819         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5820
5821         copy_unistr2(&usr->uni_logon_script, log_scr);
5822         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5823
5824         copy_unistr2(&usr->uni_profile_path, prof_path);
5825         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5826
5827         copy_unistr2(&usr->uni_acct_desc, desc);
5828         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5829
5830         copy_unistr2(&usr->uni_workstations, wkstas);
5831         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5832
5833         copy_unistr2(&usr->uni_comment, unk_str);
5834         init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
5835
5836         copy_unistr2(&usr->uni_munged_dial, mung_dial);
5837         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5838
5839         if (hrs) {
5840                 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5841         } else {
5842                 ZERO_STRUCT(usr->logon_hrs);
5843         }
5844 }
5845
5846 /*************************************************************************
5847  init_sam_user_info23
5848
5849  unknown_6 = 0x0000 04ec
5850
5851  *************************************************************************/
5852
5853 void init_sam_user_info23A(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5854                            NTTIME * logoff_time,        /* all zeros */
5855                            NTTIME * kickoff_time,       /* all zeros */
5856                            NTTIME * pass_last_set_time, /* all zeros */
5857                            NTTIME * pass_can_change_time,       /* all zeros */
5858                            NTTIME * pass_must_change_time,      /* all zeros */
5859                            char *user_name,     /* NULL */
5860                            char *full_name,
5861                            char *home_dir, char *dir_drive, char *log_scr,
5862                            char *prof_path, const char *desc, char *wkstas,
5863                            char *unk_str, char *mung_dial, uint32 user_rid,     /* 0x0000 0000 */
5864                            uint32 group_rid, uint32 acb_info,
5865                            uint32 fields_present, uint16 logon_divs,
5866                            LOGON_HRS * hrs, uint16 bad_password_count, uint16 logon_count,
5867                            char newpass[516])
5868 {
5869         DATA_BLOB blob = base64_decode_data_blob(mung_dial);
5870
5871         usr->logon_time = *logon_time;  /* all zeros */
5872         usr->logoff_time = *logoff_time;        /* all zeros */
5873         usr->kickoff_time = *kickoff_time;      /* all zeros */
5874         usr->pass_last_set_time = *pass_last_set_time;  /* all zeros */
5875         usr->pass_can_change_time = *pass_can_change_time;      /* all zeros */
5876         usr->pass_must_change_time = *pass_must_change_time;    /* all zeros */
5877
5878         ZERO_STRUCT(usr->nt_pwd);
5879         ZERO_STRUCT(usr->lm_pwd);
5880
5881         usr->user_rid = user_rid;       /* 0x0000 0000 */
5882         usr->group_rid = group_rid;
5883         usr->acb_info = acb_info;
5884         usr->fields_present = fields_present;   /* 09f8 27fa */
5885
5886         usr->logon_divs = logon_divs;   /* should be 168 (hours/week) */
5887         usr->ptr_logon_hrs = hrs ? 1 : 0;
5888
5889         if (nt_time_is_zero(pass_must_change_time)) {
5890                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5891         } else {
5892                 usr->passmustchange=0;
5893         }
5894
5895         ZERO_STRUCT(usr->padding1);
5896         ZERO_STRUCT(usr->padding2);
5897
5898         usr->bad_password_count = bad_password_count;
5899         usr->logon_count = logon_count;
5900
5901         memcpy(usr->pass, newpass, sizeof(usr->pass));
5902
5903         init_unistr2(&usr->uni_user_name, user_name, UNI_FLAGS_NONE);
5904         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5905
5906         init_unistr2(&usr->uni_full_name, full_name, UNI_FLAGS_NONE);
5907         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5908
5909         init_unistr2(&usr->uni_home_dir, home_dir, UNI_FLAGS_NONE);
5910         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5911
5912         init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_FLAGS_NONE);
5913         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5914
5915         init_unistr2(&usr->uni_logon_script, log_scr, UNI_FLAGS_NONE);
5916         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5917
5918         init_unistr2(&usr->uni_profile_path, prof_path, UNI_FLAGS_NONE);
5919         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5920
5921         init_unistr2(&usr->uni_acct_desc, desc, UNI_FLAGS_NONE);
5922         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5923
5924         init_unistr2(&usr->uni_workstations, wkstas, UNI_FLAGS_NONE);
5925         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5926
5927         init_unistr2(&usr->uni_comment, unk_str, UNI_FLAGS_NONE);
5928         init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
5929
5930         init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
5931         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5932
5933         data_blob_free(&blob);
5934
5935         if (hrs) {
5936                 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5937         } else {
5938                 ZERO_STRUCT(usr->logon_hrs);
5939         }
5940 }
5941
5942 /*******************************************************************
5943 reads or writes a structure.
5944 ********************************************************************/
5945
5946 static BOOL sam_io_user_info23(const char *desc, SAM_USER_INFO_23 * usr,
5947                                prs_struct *ps, int depth)
5948 {
5949         if (usr == NULL)
5950                 return False;
5951
5952         prs_debug(ps, depth, desc, "sam_io_user_info23");
5953         depth++;
5954
5955         if(!prs_align(ps))
5956                 return False;
5957
5958         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
5959                 return False;
5960         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
5961                 return False;
5962         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
5963                 return False;
5964         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps, depth))
5965                 return False;
5966         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
5967                 return False;
5968         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
5969                 return False;
5970
5971         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth))  /* username unicode string header */
5972                 return False;
5973         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth))  /* user's full name unicode string header */
5974                 return False;
5975         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth))   /* home directory unicode string header */
5976                 return False;
5977         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth))  /* home directory drive */
5978                 return False;
5979         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth))       /* logon script unicode string header */
5980                 return False;
5981         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth))       /* profile path unicode string header */
5982                 return False;
5983         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth))  /* account desc */
5984                 return False;
5985         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth))       /* wkstas user can log on from */
5986                 return False;
5987         if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth))        /* unknown string */
5988                 return False;
5989         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
5990                 return False;
5991
5992         if(!prs_uint8s(False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
5993                 return False;
5994         if(!prs_uint8s(False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
5995                 return False;
5996
5997         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))    /* User ID */
5998                 return False;
5999         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))   /* Group ID */
6000                 return False;
6001         if(!prs_uint32("acb_info      ", ps, depth, &usr->acb_info))
6002                 return False;
6003
6004         if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6005                 return False;
6006         if(!prs_uint16("logon_divs    ", ps, depth, &usr->logon_divs))  /* logon divisions per week */
6007                 return False;
6008         if(!prs_align(ps))
6009                 return False;
6010         if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6011                 return False;
6012
6013         if(!prs_uint16("bad_password_count     ", ps, depth, &usr->bad_password_count))
6014                 return False;
6015         if(!prs_uint16("logon_count     ", ps, depth, &usr->logon_count))
6016                 return False;
6017
6018         if(!prs_uint8s(False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6019                 return False;
6020         if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6021                 return False;
6022         if(!prs_uint8("padding2       ", ps, depth, &usr->padding2))
6023                 return False;
6024
6025
6026         if(!prs_uint8s(False, "password      ", ps, depth, usr->pass, sizeof(usr->pass)))
6027                 return False;
6028
6029         /* here begins pointed-to data */
6030
6031         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth))      /* username unicode string */
6032                 return False;
6033
6034         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))      /* user's full name unicode string */
6035                 return False;
6036
6037         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))        /* home directory unicode string */
6038                 return False;
6039
6040         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))      /* home directory drive unicode string */
6041                 return False;
6042
6043         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))        /* logon script unicode string */
6044                 return False;
6045
6046         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))        /* profile path unicode string */
6047                 return False;
6048
6049         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))      /* user desc unicode string */
6050                 return False;
6051
6052         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))        /* worksations user can log on from */
6053                 return False;
6054
6055         if(!smb_io_unistr2("uni_comment ", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth))      /* unknown string */
6056                 return False;
6057
6058         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
6059                 return False;
6060
6061         /* ok, this is only guess-work (as usual) */
6062         if (usr->ptr_logon_hrs) {
6063                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6064                         return False;
6065         }
6066
6067         return True;
6068 }
6069
6070 /*******************************************************************
6071  reads or writes a structure.
6072  NB. This structure is *definately* incorrect. It's my best guess
6073  currently for W2K SP2. The password field is encrypted in a different
6074  way than normal... And there are definately other problems. JRA.
6075 ********************************************************************/
6076
6077 static BOOL sam_io_user_info25(const char *desc, SAM_USER_INFO_25 * usr, prs_struct *ps, int depth)
6078 {
6079         if (usr == NULL)
6080                 return False;
6081
6082         prs_debug(ps, depth, desc, "sam_io_user_info25");
6083         depth++;
6084
6085         if(!prs_align(ps))
6086                 return False;
6087
6088         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
6089                 return False;
6090         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
6091                 return False;
6092         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
6093                 return False;
6094         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps, depth))
6095                 return False;
6096         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
6097                 return False;
6098         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
6099                 return False;
6100
6101         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth))  /* username unicode string header */
6102                 return False;
6103         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth))  /* user's full name unicode string header */
6104                 return False;
6105         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth))   /* home directory unicode string header */
6106                 return False;
6107         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth))  /* home directory drive */
6108                 return False;
6109         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth))       /* logon script unicode string header */
6110                 return False;
6111         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth))       /* profile path unicode string header */
6112                 return False;
6113         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth))  /* account desc */
6114                 return False;
6115         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth))       /* wkstas user can log on from */
6116                 return False;
6117         if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth))        /* unknown string */
6118                 return False;
6119         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
6120                 return False;
6121
6122         if(!prs_uint8s(False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6123                 return False;
6124         if(!prs_uint8s(False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6125                 return False;
6126
6127         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))    /* User ID */
6128                 return False;
6129         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))   /* Group ID */
6130                 return False;
6131         if(!prs_uint32("acb_info      ", ps, depth, &usr->acb_info))
6132                 return False;
6133         if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6134                 return False;
6135
6136         if(!prs_uint16("logon_divs    ", ps, depth, &usr->logon_divs))  /* logon divisions per week */
6137                 return False;
6138         if(!prs_align(ps))
6139                 return False;
6140         if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6141                 return False;
6142
6143         if(!prs_uint16("bad_password_count     ", ps, depth, &usr->bad_password_count))
6144                 return False;
6145         if(!prs_uint16("logon_count     ", ps, depth, &usr->logon_count))
6146                 return False;
6147
6148         if(!prs_uint8s(False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6149                 return False;
6150         if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6151                 return False;
6152         if(!prs_uint8("padding2       ", ps, depth, &usr->padding2))
6153                 return False;
6154
6155
6156         if(!prs_uint8s(False, "password      ", ps, depth, usr->pass, sizeof(usr->pass)))
6157                 return False;
6158
6159         /* here begins pointed-to data */
6160
6161         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth))      /* username unicode string */
6162                 return False;
6163
6164         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))      /* user's full name unicode string */
6165                 return False;
6166
6167         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))        /* home directory unicode string */
6168                 return False;
6169
6170         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))      /* home directory drive unicode string */
6171                 return False;
6172
6173         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))        /* logon script unicode string */
6174                 return False;
6175
6176         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))        /* profile path unicode string */
6177                 return False;
6178
6179         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))      /* user desc unicode string */
6180                 return False;
6181
6182         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))        /* worksations user can log on from */
6183                 return False;
6184
6185         if(!smb_io_unistr2("uni_comment ", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth))      /* unknown string */
6186                 return False;
6187
6188         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
6189                 return False;
6190
6191         /* ok, this is only guess-work (as usual) */
6192         if (usr->ptr_logon_hrs) {
6193                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6194                         return False;
6195         }
6196
6197         return True;
6198 }
6199
6200
6201 /*************************************************************************
6202  init_sam_user_info21W
6203
6204  unknown_6 = 0x0000 04ec
6205
6206  *************************************************************************/
6207
6208 void init_sam_user_info21W(SAM_USER_INFO_21 * usr,
6209                            NTTIME * logon_time,
6210                            NTTIME * logoff_time,
6211                            NTTIME * kickoff_time,
6212                            NTTIME * pass_last_set_time,
6213                            NTTIME * pass_can_change_time,
6214                            NTTIME * pass_must_change_time,
6215                            UNISTR2 *user_name,
6216                            UNISTR2 *full_name,
6217                            UNISTR2 *home_dir,
6218                            UNISTR2 *dir_drive,
6219                            UNISTR2 *log_scr,
6220                            UNISTR2 *prof_path,
6221                            UNISTR2 *desc,
6222                            UNISTR2 *wkstas,
6223                            UNISTR2 *unk_str,
6224                            UNISTR2 *mung_dial,
6225                            uchar lm_pwd[16],
6226                            uchar nt_pwd[16],
6227                            uint32 user_rid,
6228                            uint32 group_rid,
6229                            uint32 acb_info,
6230                            uint32 fields_present,
6231                            uint16 logon_divs,
6232                            LOGON_HRS * hrs,
6233                            uint16 bad_password_count,
6234                            uint16 logon_count)
6235 {
6236         usr->logon_time = *logon_time;
6237         usr->logoff_time = *logoff_time;
6238         usr->kickoff_time = *kickoff_time;
6239         usr->pass_last_set_time = *pass_last_set_time;
6240         usr->pass_can_change_time = *pass_can_change_time;
6241         usr->pass_must_change_time = *pass_must_change_time;
6242
6243         memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd));
6244         memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd));
6245
6246         usr->user_rid = user_rid;
6247         usr->group_rid = group_rid;
6248         usr->acb_info = acb_info;
6249         usr->fields_present = fields_present;   /* 0x00ff ffff */
6250
6251         usr->logon_divs = logon_divs;   /* should be 168 (hours/week) */
6252         usr->ptr_logon_hrs = hrs ? 1 : 0;
6253         usr->bad_password_count = bad_password_count;
6254         usr->logon_count = logon_count;
6255
6256         if (nt_time_is_zero(pass_must_change_time)) {
6257                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6258         } else {
6259                 usr->passmustchange=0;
6260         }
6261
6262         ZERO_STRUCT(usr->padding1);
6263         ZERO_STRUCT(usr->padding2);
6264
6265         copy_unistr2(&usr->uni_user_name, user_name);
6266         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6267
6268         copy_unistr2(&usr->uni_full_name, full_name);
6269         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6270
6271         copy_unistr2(&usr->uni_home_dir, home_dir);
6272         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6273
6274         copy_unistr2(&usr->uni_dir_drive, dir_drive);
6275         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6276
6277         copy_unistr2(&usr->uni_logon_script, log_scr);
6278         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6279
6280         copy_unistr2(&usr->uni_profile_path, prof_path);
6281         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6282
6283         copy_unistr2(&usr->uni_acct_desc, desc);
6284         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6285
6286         copy_unistr2(&usr->uni_workstations, wkstas);
6287         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6288
6289         copy_unistr2(&usr->uni_comment, unk_str);
6290         init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
6291
6292         copy_unistr2(&usr->uni_munged_dial, mung_dial);
6293         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6294
6295         if (hrs) {
6296                 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
6297         } else {
6298                 ZERO_STRUCT(usr->logon_hrs);
6299         }
6300 }
6301
6302 /*************************************************************************
6303  init_sam_user_info21
6304
6305  unknown_6 = 0x0000 04ec
6306
6307  *************************************************************************/
6308
6309 NTSTATUS init_sam_user_info21A(SAM_USER_INFO_21 *usr, struct samu *pw, DOM_SID *domain_sid)
6310 {
6311         NTTIME          logon_time, logoff_time, kickoff_time,
6312                         pass_last_set_time, pass_can_change_time,
6313                         pass_must_change_time;
6314
6315         time_t must_change_time;
6316         const char*             user_name = pdb_get_username(pw);
6317         const char*             full_name = pdb_get_fullname(pw);
6318         const char*             home_dir  = pdb_get_homedir(pw);
6319         const char*             dir_drive = pdb_get_dir_drive(pw);
6320         const char*             logon_script = pdb_get_logon_script(pw);
6321         const char*             profile_path = pdb_get_profile_path(pw);
6322         const char*             description = pdb_get_acct_desc(pw);
6323         const char*             workstations = pdb_get_workstations(pw);
6324         const char*             munged_dial = pdb_get_munged_dial(pw);
6325         DATA_BLOB               munged_dial_blob;
6326
6327         uint32 user_rid;
6328         const DOM_SID *user_sid;
6329
6330         uint32 group_rid;
6331         const DOM_SID *group_sid;
6332
6333         if (munged_dial) {
6334                 munged_dial_blob = base64_decode_data_blob(munged_dial);
6335         } else {
6336                 munged_dial_blob = data_blob_null;
6337         }
6338
6339         /* Create NTTIME structs */
6340         unix_to_nt_time (&logon_time,           pdb_get_logon_time(pw));
6341         unix_to_nt_time (&logoff_time,  pdb_get_logoff_time(pw));
6342         unix_to_nt_time (&kickoff_time,         pdb_get_kickoff_time(pw));
6343         unix_to_nt_time (&pass_last_set_time, pdb_get_pass_last_set_time(pw));
6344         unix_to_nt_time (&pass_can_change_time,pdb_get_pass_can_change_time(pw));
6345         must_change_time = pdb_get_pass_must_change_time(pw);
6346         if (must_change_time == get_time_t_max())
6347                 unix_to_nt_time_abs(&pass_must_change_time, must_change_time);
6348         else
6349                 unix_to_nt_time(&pass_must_change_time, must_change_time);
6350
6351         /* structure assignment */
6352         usr->logon_time            = logon_time;
6353         usr->logoff_time           = logoff_time;
6354         usr->kickoff_time          = kickoff_time;
6355         usr->pass_last_set_time    = pass_last_set_time;
6356         usr->pass_can_change_time  = pass_can_change_time;
6357         usr->pass_must_change_time = pass_must_change_time;
6358
6359         ZERO_STRUCT(usr->nt_pwd);
6360         ZERO_STRUCT(usr->lm_pwd);
6361
6362         user_sid = pdb_get_user_sid(pw);
6363
6364         if (!sid_peek_check_rid(domain_sid, user_sid, &user_rid)) {
6365                 fstring user_sid_string;
6366                 fstring domain_sid_string;
6367                 DEBUG(0, ("init_sam_user_info_21A: User %s has SID %s, \nwhich conflicts with "
6368                           "the domain sid %s.  Failing operation.\n",
6369                           user_name,
6370                           sid_to_string(user_sid_string, user_sid),
6371                           sid_to_string(domain_sid_string, domain_sid)));
6372                 data_blob_free(&munged_dial_blob);
6373                 return NT_STATUS_UNSUCCESSFUL;
6374         }
6375
6376         become_root();
6377         group_sid = pdb_get_group_sid(pw);
6378         unbecome_root();
6379
6380         if (!sid_peek_check_rid(domain_sid, group_sid, &group_rid)) {
6381                 fstring group_sid_string;
6382                 fstring domain_sid_string;
6383                 DEBUG(0, ("init_sam_user_info_21A: User %s has Primary Group SID %s, \n"
6384                           "which conflicts with the domain sid %s.  Failing operation.\n",
6385                           user_name,
6386                           sid_to_string(group_sid_string, group_sid),
6387                           sid_to_string(domain_sid_string, domain_sid)));
6388                 data_blob_free(&munged_dial_blob);
6389                 return NT_STATUS_UNSUCCESSFUL;
6390         }
6391
6392         usr->user_rid  = user_rid;
6393         usr->group_rid = group_rid;
6394         usr->acb_info  = pdb_get_acct_ctrl(pw);
6395
6396         /*
6397           Look at a user on a real NT4 PDC with usrmgr, press
6398           'ok'. Then you will see that fields_present is set to
6399           0x08f827fa. Look at the user immediately after that again,
6400           and you will see that 0x00fffff is returned. This solves
6401           the problem that you get access denied after having looked
6402           at the user.
6403           -- Volker
6404         */
6405         usr->fields_present = pdb_build_fields_present(pw);
6406
6407         usr->logon_divs = pdb_get_logon_divs(pw);
6408         usr->ptr_logon_hrs = pdb_get_hours(pw) ? 1 : 0;
6409         usr->bad_password_count = pdb_get_bad_password_count(pw);
6410         usr->logon_count = pdb_get_logon_count(pw);
6411
6412         if (pdb_get_pass_must_change_time(pw) == 0) {
6413                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6414         } else {
6415                 usr->passmustchange=0;
6416         }
6417
6418         ZERO_STRUCT(usr->padding1);
6419         ZERO_STRUCT(usr->padding2);
6420
6421         init_unistr2(&usr->uni_user_name, user_name, UNI_STR_TERMINATE);
6422         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6423
6424         init_unistr2(&usr->uni_full_name, full_name, UNI_STR_TERMINATE);
6425         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6426
6427         init_unistr2(&usr->uni_home_dir, home_dir, UNI_STR_TERMINATE);
6428         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6429
6430         init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_STR_TERMINATE);
6431         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6432
6433         init_unistr2(&usr->uni_logon_script, logon_script, UNI_STR_TERMINATE);
6434         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6435
6436         init_unistr2(&usr->uni_profile_path, profile_path, UNI_STR_TERMINATE);
6437         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6438
6439         init_unistr2(&usr->uni_acct_desc, description, UNI_STR_TERMINATE);
6440         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6441
6442         init_unistr2(&usr->uni_workstations, workstations, UNI_STR_TERMINATE);
6443         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6444
6445         init_unistr2(&usr->uni_comment, NULL, UNI_STR_TERMINATE);
6446         init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
6447
6448         init_unistr2_from_datablob(&usr->uni_munged_dial, &munged_dial_blob);
6449         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6450         data_blob_free(&munged_dial_blob);
6451
6452         if (pdb_get_hours(pw)) {
6453                 usr->logon_hrs.max_len = 1260;
6454                 usr->logon_hrs.offset = 0;
6455                 usr->logon_hrs.len = pdb_get_hours_len(pw);
6456                 memcpy(&usr->logon_hrs.hours, pdb_get_hours(pw), MAX_HOURS_LEN);
6457         } else {
6458                 usr->logon_hrs.max_len = 1260;
6459                 usr->logon_hrs.offset = 0;
6460                 usr->logon_hrs.len = 0;
6461                 memset(&usr->logon_hrs, 0xff, sizeof(usr->logon_hrs));
6462         }
6463
6464         return NT_STATUS_OK;
6465 }
6466
6467 /*******************************************************************
6468 reads or writes a structure.
6469 ********************************************************************/
6470
6471 static BOOL sam_io_user_info21(const char *desc, SAM_USER_INFO_21 * usr,
6472                         prs_struct *ps, int depth)
6473 {
6474         if (usr == NULL)
6475                 return False;
6476
6477         prs_debug(ps, depth, desc, "sam_io_user_info21");
6478         depth++;
6479
6480         if(!prs_align(ps))
6481                 return False;
6482
6483         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
6484                 return False;
6485         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
6486                 return False;
6487         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps,depth))
6488                 return False;
6489         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
6490                 return False;
6491         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps,depth))
6492                 return False;
6493         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time,  ps, depth))
6494                 return False;
6495
6496         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth))  /* username unicode string header */
6497                 return False;
6498         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth))  /* user's full name unicode string header */
6499                 return False;
6500         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth))   /* home directory unicode string header */
6501                 return False;
6502         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth))  /* home directory drive */
6503                 return False;
6504         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth))       /* logon script unicode string header */
6505                 return False;
6506         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth))       /* profile path unicode string header */
6507                 return False;
6508         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth))  /* account desc */
6509                 return False;
6510         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth))       /* wkstas user can log on from */
6511                 return False;
6512         if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth))        /* unknown string */
6513                 return False;
6514         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
6515                 return False;
6516
6517         if(!prs_uint8s(False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6518                 return False;
6519         if(!prs_uint8s(False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6520                 return False;
6521
6522         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))    /* User ID */
6523                 return False;
6524         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))   /* Group ID */
6525                 return False;
6526         if(!prs_uint32("acb_info      ", ps, depth, &usr->acb_info))
6527                 return False;
6528
6529         if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6530                 return False;
6531         if(!prs_uint16("logon_divs    ", ps, depth, &usr->logon_divs))  /* logon divisions per week */
6532                 return False;
6533         if(!prs_align(ps))
6534                 return False;
6535         if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6536                 return False;
6537
6538         if(!prs_uint16("bad_password_count     ", ps, depth, &usr->bad_password_count))
6539                 return False;
6540         if(!prs_uint16("logon_count     ", ps, depth, &usr->logon_count))
6541                 return False;
6542
6543         if(!prs_uint8s(False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6544                 return False;
6545         if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6546                 return False;
6547         if(!prs_uint8("padding2       ", ps, depth, &usr->padding2))
6548                 return False;
6549
6550         /* here begins pointed-to data */
6551
6552         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name,usr->hdr_user_name.buffer, ps, depth))
6553                 return False;
6554         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))
6555                 return False;
6556         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))
6557                 return False;
6558         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))
6559                 return False;
6560         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))
6561                 return False;
6562         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))
6563                 return False;
6564         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))
6565                 return False;
6566         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))
6567                 return False;
6568         if(!smb_io_unistr2("uni_comment", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth))
6569                 return False;
6570         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))
6571                 return False;
6572
6573         /* ok, this is only guess-work (as usual) */
6574         if (usr->ptr_logon_hrs) {
6575                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6576                         return False;
6577         }
6578
6579         return True;
6580 }
6581
6582 void init_sam_user_info20A(SAM_USER_INFO_20 *usr, struct samu *pw)
6583 {
6584         const char *munged_dial = pdb_get_munged_dial(pw);
6585         DATA_BLOB blob;
6586
6587         if (munged_dial) {
6588                 blob = base64_decode_data_blob(munged_dial);
6589         } else {
6590                 blob = data_blob_null;
6591         }
6592
6593         init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
6594         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6595         data_blob_free(&blob);
6596 }
6597
6598 /*******************************************************************
6599 reads or writes a structure.
6600 ********************************************************************/
6601
6602 static BOOL sam_io_user_info20(const char *desc, SAM_USER_INFO_20 *usr,
6603                         prs_struct *ps, int depth)
6604 {
6605         if (usr == NULL)
6606                 return False;
6607
6608         prs_debug(ps, depth, desc, "sam_io_user_info20");
6609         depth++;
6610
6611         if(!prs_align(ps))
6612                 return False;
6613
6614         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
6615                 return False;
6616
6617         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))   /* worksations user can log on from */
6618                 return False;
6619
6620         return True;
6621 }
6622
6623 /*******************************************************************
6624 inits a SAM_USERINFO_CTR structure.
6625 ********************************************************************/
6626
6627 NTSTATUS make_samr_userinfo_ctr_usr21(TALLOC_CTX *ctx, SAM_USERINFO_CTR * ctr,
6628                                     uint16 switch_value,
6629                                     SAM_USER_INFO_21 * usr)
6630 {
6631         DEBUG(5, ("make_samr_userinfo_ctr_usr21\n"));
6632
6633         ctr->switch_value = switch_value;
6634         ctr->info.id = NULL;
6635
6636         switch (switch_value) {
6637         case 16:
6638                 ctr->info.id16 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_16);
6639                 if (ctr->info.id16 == NULL)
6640                         return NT_STATUS_NO_MEMORY;
6641
6642                 init_sam_user_info16(ctr->info.id16, usr->acb_info);
6643                 break;
6644 #if 0
6645 /* whoops - got this wrong.  i think.  or don't understand what's happening. */
6646         case 17:
6647                 {
6648                         NTTIME expire;
6649                         info = (void *)&id11;
6650
6651                         expire.low = 0xffffffff;
6652                         expire.high = 0x7fffffff;
6653
6654                         ctr->info.id = TALLOC_ZERO_P(ctx,SAM_USER_INFO_17);
6655                         init_sam_user_info11(ctr->info.id17, &expire,
6656                                              "BROOKFIELDS$",    /* name */
6657                                              0x03ef,    /* user rid */
6658                                              0x201,     /* group rid */
6659                                              0x0080);   /* acb info */
6660
6661                         break;
6662                 }
6663 #endif
6664         case 18:
6665                 ctr->info.id18 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_18);
6666                 if (ctr->info.id18 == NULL)
6667                         return NT_STATUS_NO_MEMORY;
6668
6669                 init_sam_user_info18(ctr->info.id18, usr->lm_pwd, usr->nt_pwd);
6670                 break;
6671         case 21:
6672                 {
6673                         SAM_USER_INFO_21 *cusr;
6674                         cusr = TALLOC_ZERO_P(ctx,SAM_USER_INFO_21);
6675                         ctr->info.id21 = cusr;
6676                         if (ctr->info.id21 == NULL)
6677                                 return NT_STATUS_NO_MEMORY;
6678                         memcpy(cusr, usr, sizeof(*usr));
6679                         memset(cusr->lm_pwd, 0, sizeof(cusr->lm_pwd));
6680                         memset(cusr->nt_pwd, 0, sizeof(cusr->nt_pwd));
6681                         break;
6682                 }
6683         default:
6684                 DEBUG(4,("make_samr_userinfo_ctr: unsupported info\n"));
6685                 return NT_STATUS_INVALID_INFO_CLASS;
6686         }
6687
6688         return NT_STATUS_OK;
6689 }
6690
6691 /*******************************************************************
6692 inits a SAM_USERINFO_CTR structure.
6693 ********************************************************************/
6694
6695 static void init_samr_userinfo_ctr(SAM_USERINFO_CTR * ctr, DATA_BLOB *sess_key,
6696                                    uint16 switch_value, void *info)
6697 {
6698         DEBUG(5, ("init_samr_userinfo_ctr\n"));
6699
6700         ctr->switch_value = switch_value;
6701         ctr->info.id = info;
6702
6703         switch (switch_value) {
6704         case 0x18:
6705                 SamOEMhashBlob(ctr->info.id24->pass, 516, sess_key);
6706                 dump_data(100, sess_key->data, sess_key->length);
6707                 dump_data(100, ctr->info.id24->pass, 516);
6708                 break;
6709         case 0x17:
6710                 SamOEMhashBlob(ctr->info.id23->pass, 516, sess_key);
6711                 dump_data(100, sess_key->data, sess_key->length);
6712                 dump_data(100, ctr->info.id23->pass, 516);
6713                 break;
6714         case 0x07:
6715                 break;
6716         default:
6717                 DEBUG(4,("init_samr_userinfo_ctr: unsupported switch level: %d\n", switch_value));
6718         }
6719 }
6720
6721 /*******************************************************************
6722 reads or writes a structure.
6723 ********************************************************************/
6724
6725 static BOOL samr_io_userinfo_ctr(const char *desc, SAM_USERINFO_CTR **ppctr,
6726                                  prs_struct *ps, int depth)
6727 {
6728         BOOL ret;
6729         SAM_USERINFO_CTR *ctr;
6730
6731         prs_debug(ps, depth, desc, "samr_io_userinfo_ctr");
6732         depth++;
6733
6734         if (UNMARSHALLING(ps)) {
6735                 ctr = PRS_ALLOC_MEM(ps,SAM_USERINFO_CTR,1);
6736                 if (ctr == NULL)
6737                         return False;
6738                 *ppctr = ctr;
6739         } else {
6740                 ctr = *ppctr;
6741         }
6742
6743         /* lkclXXXX DO NOT ALIGN BEFORE READING SWITCH VALUE! */
6744
6745         if(!prs_uint16("switch_value", ps, depth, &ctr->switch_value))
6746                 return False;
6747         if(!prs_align(ps))
6748                 return False;
6749
6750         ret = False;
6751
6752         switch (ctr->switch_value) {
6753         case 7:
6754                 if (UNMARSHALLING(ps))
6755                         ctr->info.id7 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_7,1);
6756                 if (ctr->info.id7 == NULL) {
6757                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6758                         return False;
6759                 }
6760                 ret = sam_io_user_info7("", ctr->info.id7, ps, depth);
6761                 break;
6762         case 9:
6763                 if (UNMARSHALLING(ps))
6764                         ctr->info.id9 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_9,1);
6765                 if (ctr->info.id9 == NULL) {
6766                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6767                         return False;
6768                 }
6769                 ret = sam_io_user_info9("", ctr->info.id9, ps, depth);
6770                 break;
6771         case 16:
6772                 if (UNMARSHALLING(ps))
6773                         ctr->info.id16 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_16,1);
6774                 if (ctr->info.id16 == NULL) {
6775                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6776                         return False;
6777                 }
6778                 ret = sam_io_user_info16("", ctr->info.id16, ps, depth);
6779                 break;
6780         case 17:
6781                 if (UNMARSHALLING(ps))
6782                         ctr->info.id17 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_17,1);
6783
6784                 if (ctr->info.id17 == NULL) {
6785                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6786                         return False;
6787                 }
6788                 ret = sam_io_user_info17("", ctr->info.id17, ps, depth);
6789                 break;
6790         case 18:
6791                 if (UNMARSHALLING(ps))
6792                         ctr->info.id18 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_18,1);
6793
6794                 if (ctr->info.id18 == NULL) {
6795                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6796                         return False;
6797                 }
6798                 ret = sam_io_user_info18("", ctr->info.id18, ps, depth);
6799                 break;
6800         case 20:
6801                 if (UNMARSHALLING(ps))
6802                         ctr->info.id20 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_20,1);
6803
6804                 if (ctr->info.id20 == NULL) {
6805                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6806                         return False;
6807                 }
6808                 ret = sam_io_user_info20("", ctr->info.id20, ps, depth);
6809                 break;
6810         case 21:
6811                 if (UNMARSHALLING(ps))
6812                         ctr->info.id21 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_21,1);
6813
6814                 if (ctr->info.id21 == NULL) {
6815                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6816                         return False;
6817                 }
6818                 ret = sam_io_user_info21("", ctr->info.id21, ps, depth);
6819                 break;
6820         case 23:
6821                 if (UNMARSHALLING(ps))
6822                         ctr->info.id23 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_23,1);
6823
6824                 if (ctr->info.id23 == NULL) {
6825                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6826                         return False;
6827                 }
6828                 ret = sam_io_user_info23("", ctr->info.id23, ps, depth);
6829                 break;
6830         case 24:
6831                 if (UNMARSHALLING(ps))
6832                         ctr->info.id24 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_24,1);
6833
6834                 if (ctr->info.id24 == NULL) {
6835                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6836                         return False;
6837                 }
6838                 ret = sam_io_user_info24("", ctr->info.id24, ps,  depth);
6839                 break;
6840         case 25:
6841                 if (UNMARSHALLING(ps))
6842                         ctr->info.id25 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_25,1);
6843
6844                 if (ctr->info.id25 == NULL) {
6845                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6846                         return False;
6847                 }
6848                 ret = sam_io_user_info25("", ctr->info.id25, ps, depth);
6849                 break;
6850         case 26:
6851                 if (UNMARSHALLING(ps))
6852                         ctr->info.id26 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_26,1);
6853
6854                 if (ctr->info.id26 == NULL) {
6855                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6856                         return False;
6857                 }
6858                 ret = sam_io_user_info26("", ctr->info.id26, ps,  depth);
6859                 break;
6860         default:
6861                 DEBUG(2, ("samr_io_userinfo_ctr: unknown switch level 0x%x\n", ctr->switch_value));
6862                 ret = False;
6863                 break;
6864         }
6865
6866         return ret;
6867 }
6868
6869 /*******************************************************************
6870 inits a SAMR_R_QUERY_USERINFO structure.
6871 ********************************************************************/
6872
6873 void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO * r_u,
6874                                 SAM_USERINFO_CTR * ctr, NTSTATUS status)
6875 {
6876         DEBUG(5, ("init_samr_r_query_userinfo\n"));
6877
6878         r_u->ptr = 0;
6879         r_u->ctr = NULL;
6880
6881         if (NT_STATUS_IS_OK(status)) {
6882                 r_u->ptr = 1;
6883                 r_u->ctr = ctr;
6884         }
6885
6886         r_u->status = status;   /* return status */
6887 }
6888
6889 /*******************************************************************
6890 reads or writes a structure.
6891 ********************************************************************/
6892
6893 BOOL samr_io_r_query_userinfo(const char *desc, SAMR_R_QUERY_USERINFO * r_u,
6894                               prs_struct *ps, int depth)
6895 {
6896         if (r_u == NULL)
6897                 return False;
6898
6899         prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
6900         depth++;
6901
6902         if(!prs_align(ps))
6903                 return False;
6904
6905         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
6906                 return False;
6907
6908         if (r_u->ptr != 0) {
6909                 if(!samr_io_userinfo_ctr("ctr", &r_u->ctr, ps, depth))
6910                         return False;
6911         }
6912
6913         if(!prs_align(ps))
6914                 return False;
6915         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6916                 return False;
6917
6918         return True;
6919 }
6920
6921 /*******************************************************************
6922 inits a SAMR_Q_SET_USERINFO structure.
6923 ********************************************************************/
6924
6925 void init_samr_q_set_userinfo(SAMR_Q_SET_USERINFO * q_u,
6926                               const POLICY_HND *hnd, DATA_BLOB *sess_key,
6927                               uint16 switch_value, void *info)
6928 {
6929         DEBUG(5, ("init_samr_q_set_userinfo\n"));
6930
6931         q_u->pol = *hnd;
6932         q_u->switch_value = switch_value;
6933         init_samr_userinfo_ctr(q_u->ctr, sess_key, switch_value, info);
6934 }
6935
6936 /*******************************************************************
6937 reads or writes a structure.
6938 ********************************************************************/
6939
6940 BOOL samr_io_q_set_userinfo(const char *desc, SAMR_Q_SET_USERINFO * q_u,
6941                             prs_struct *ps, int depth)
6942 {
6943         if (q_u == NULL)
6944                 return False;
6945
6946         prs_debug(ps, depth, desc, "samr_io_q_set_userinfo");
6947         depth++;
6948
6949         if(!prs_align(ps))
6950                 return False;
6951
6952         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
6953
6954         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6955                 return False;
6956         if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6957                 return False;
6958
6959         return True;
6960 }
6961
6962 /*******************************************************************
6963 inits a SAMR_R_SET_USERINFO structure.
6964 ********************************************************************/
6965
6966 void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO * r_u, NTSTATUS status)
6967 {
6968         DEBUG(5, ("init_samr_r_set_userinfo\n"));
6969
6970         r_u->status = status;   /* return status */
6971 }
6972
6973 /*******************************************************************
6974 reads or writes a structure.
6975 ********************************************************************/
6976
6977 BOOL samr_io_r_set_userinfo(const char *desc, SAMR_R_SET_USERINFO * r_u,
6978                             prs_struct *ps, int depth)
6979 {
6980         if (r_u == NULL)
6981                 return False;
6982
6983         prs_debug(ps, depth, desc, "samr_io_r_set_userinfo");
6984         depth++;
6985
6986         if(!prs_align(ps))
6987                 return False;
6988
6989         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6990                 return False;
6991
6992         return True;
6993 }
6994
6995 /*******************************************************************
6996 inits a SAMR_Q_SET_USERINFO2 structure.
6997 ********************************************************************/
6998
6999 void init_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2 * q_u,
7000                                const POLICY_HND *hnd, DATA_BLOB *sess_key,
7001                                uint16 switch_value, SAM_USERINFO_CTR * ctr)
7002 {
7003         DEBUG(5, ("init_samr_q_set_userinfo2\n"));
7004
7005         q_u->pol = *hnd;
7006         q_u->switch_value = switch_value;
7007         q_u->ctr = ctr;
7008
7009         q_u->ctr->switch_value = switch_value;
7010
7011         switch (switch_value) {
7012         case 18:
7013                 SamOEMhashBlob(ctr->info.id18->lm_pwd, 16, sess_key);
7014                 SamOEMhashBlob(ctr->info.id18->nt_pwd, 16, sess_key);
7015                 dump_data(100, sess_key->data, sess_key->length);
7016                 dump_data(100, ctr->info.id18->lm_pwd, 16);
7017                 dump_data(100, ctr->info.id18->nt_pwd, 16);
7018                 break;
7019         }
7020 }
7021
7022 /*******************************************************************
7023 reads or writes a structure.
7024 ********************************************************************/
7025
7026 BOOL samr_io_q_set_userinfo2(const char *desc, SAMR_Q_SET_USERINFO2 * q_u,
7027                              prs_struct *ps, int depth)
7028 {
7029         if (q_u == NULL)
7030                 return False;
7031
7032         prs_debug(ps, depth, desc, "samr_io_q_set_userinfo2");
7033         depth++;
7034
7035         if(!prs_align(ps))
7036                 return False;
7037
7038         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
7039                 return False;
7040
7041         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7042                 return False;
7043         if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
7044                 return False;
7045
7046         return True;
7047 }
7048
7049 /*******************************************************************
7050 inits a SAMR_R_SET_USERINFO2 structure.
7051 ********************************************************************/
7052
7053 void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 * r_u, NTSTATUS status)
7054 {
7055         DEBUG(5, ("init_samr_r_set_userinfo2\n"));
7056
7057         r_u->status = status;   /* return status */
7058 }
7059
7060 /*******************************************************************
7061 reads or writes a structure.
7062 ********************************************************************/
7063
7064 BOOL samr_io_r_set_userinfo2(const char *desc, SAMR_R_SET_USERINFO2 * r_u,
7065                              prs_struct *ps, int depth)
7066 {
7067         if (r_u == NULL)
7068                 return False;
7069
7070         prs_debug(ps, depth, desc, "samr_io_r_set_userinfo2");
7071         depth++;
7072
7073         if(!prs_align(ps))
7074                 return False;
7075
7076         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7077                 return False;
7078
7079         return True;
7080 }
7081
7082 /*******************************************************************
7083 inits a SAMR_Q_CONNECT structure.
7084 ********************************************************************/
7085
7086 void init_samr_q_connect(SAMR_Q_CONNECT * q_u,
7087                          char *srv_name, uint32 access_mask)
7088 {
7089         DEBUG(5, ("init_samr_q_connect\n"));
7090
7091         /* make PDC server name \\server */
7092         q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7093         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7094
7095         /* example values: 0x0000 0002 */
7096         q_u->access_mask = access_mask;
7097 }
7098
7099 /*******************************************************************
7100 reads or writes a structure.
7101 ********************************************************************/
7102
7103 BOOL samr_io_q_connect(const char *desc, SAMR_Q_CONNECT * q_u,
7104                        prs_struct *ps, int depth)
7105 {
7106         if (q_u == NULL)
7107                 return False;
7108
7109         prs_debug(ps, depth, desc, "samr_io_q_connect");
7110         depth++;
7111
7112         if(!prs_align(ps))
7113                 return False;
7114
7115         if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7116                 return False;
7117         if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7118                 return False;
7119
7120         if(!prs_align(ps))
7121                 return False;
7122         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7123                 return False;
7124
7125         return True;
7126 }
7127
7128 /*******************************************************************
7129 reads or writes a structure.
7130 ********************************************************************/
7131
7132 BOOL samr_io_r_connect(const char *desc, SAMR_R_CONNECT * r_u,
7133                        prs_struct *ps, int depth)
7134 {
7135         if (r_u == NULL)
7136                 return False;
7137
7138         prs_debug(ps, depth, desc, "samr_io_r_connect");
7139         depth++;
7140
7141         if(!prs_align(ps))
7142                 return False;
7143
7144         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7145                 return False;
7146
7147         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7148                 return False;
7149
7150         return True;
7151 }
7152
7153 /*******************************************************************
7154 inits a SAMR_Q_CONNECT4 structure.
7155 ********************************************************************/
7156
7157 void init_samr_q_connect4(SAMR_Q_CONNECT4 * q_u,
7158                           char *srv_name, uint32 access_mask)
7159 {
7160         DEBUG(5, ("init_samr_q_connect4\n"));
7161
7162         /* make PDC server name \\server */
7163         q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7164         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7165
7166         /* Only value we've seen, possibly an address type ? */
7167         q_u->unk_0 = 2;
7168
7169         /* example values: 0x0000 0002 */
7170         q_u->access_mask = access_mask;
7171 }
7172
7173 /*******************************************************************
7174 reads or writes a structure.
7175 ********************************************************************/
7176
7177 BOOL samr_io_q_connect4(const char *desc, SAMR_Q_CONNECT4 * q_u,
7178                         prs_struct *ps, int depth)
7179 {
7180         if (q_u == NULL)
7181                 return False;
7182
7183         prs_debug(ps, depth, desc, "samr_io_q_connect4");
7184         depth++;
7185
7186         if(!prs_align(ps))
7187                 return False;
7188
7189         if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7190                 return False;
7191         if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7192                 return False;
7193
7194         if(!prs_align(ps))
7195                 return False;
7196         if(!prs_uint32("unk_0", ps, depth, &q_u->unk_0))
7197                 return False;
7198         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7199                 return False;
7200
7201         return True;
7202 }
7203
7204 /*******************************************************************
7205 reads or writes a structure.
7206 ********************************************************************/
7207
7208 BOOL samr_io_r_connect4(const char *desc, SAMR_R_CONNECT4 * r_u,
7209                         prs_struct *ps, int depth)
7210 {
7211         if (r_u == NULL)
7212                 return False;
7213
7214         prs_debug(ps, depth, desc, "samr_io_r_connect4");
7215         depth++;
7216
7217         if(!prs_align(ps))
7218                 return False;
7219
7220         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7221                 return False;
7222
7223         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7224                 return False;
7225
7226         return True;
7227 }
7228
7229 /*******************************************************************
7230 inits a SAMR_Q_CONNECT5 structure.
7231 ********************************************************************/
7232
7233 void init_samr_q_connect5(SAMR_Q_CONNECT5 * q_u,
7234                           char *srv_name, uint32 access_mask)
7235 {
7236         DEBUG(5, ("init_samr_q_connect5\n"));
7237
7238         /* make PDC server name \\server */
7239         q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7240         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7241
7242         /* example values: 0x0000 0002 */
7243         q_u->access_mask = access_mask;
7244
7245         q_u->level = 1;
7246         q_u->info1_unk1 = 3;
7247         q_u->info1_unk2 = 0;
7248 }
7249
7250 /*******************************************************************
7251 inits a SAMR_R_CONNECT5 structure.
7252 ********************************************************************/
7253
7254 void init_samr_r_connect5(SAMR_R_CONNECT5 * r_u, POLICY_HND *pol, NTSTATUS status)
7255 {
7256         DEBUG(5, ("init_samr_q_connect5\n"));
7257
7258         r_u->level = 1;
7259         r_u->info1_unk1 = 3;
7260         r_u->info1_unk2 = 0;
7261
7262         r_u->connect_pol = *pol;
7263         r_u->status = status;
7264 }
7265
7266 /*******************************************************************
7267 reads or writes a structure.
7268 ********************************************************************/
7269
7270 BOOL samr_io_q_connect5(const char *desc, SAMR_Q_CONNECT5 * q_u,
7271                         prs_struct *ps, int depth)
7272 {
7273         if (q_u == NULL)
7274                 return False;
7275
7276         prs_debug(ps, depth, desc, "samr_io_q_connect5");
7277         depth++;
7278
7279         if(!prs_align(ps))
7280                 return False;
7281
7282         if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7283                 return False;
7284         if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7285                 return False;
7286
7287         if(!prs_align(ps))
7288                 return False;
7289         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7290                 return False;
7291
7292         if(!prs_uint32("level", ps, depth, &q_u->level))
7293                 return False;
7294         if(!prs_uint32("level", ps, depth, &q_u->level))
7295                 return False;
7296
7297         if(!prs_uint32("info1_unk1", ps, depth, &q_u->info1_unk1))
7298                 return False;
7299         if(!prs_uint32("info1_unk2", ps, depth, &q_u->info1_unk2))
7300                 return False;
7301
7302         return True;
7303 }
7304
7305 /*******************************************************************
7306 reads or writes a structure.
7307 ********************************************************************/
7308
7309 BOOL samr_io_r_connect5(const char *desc, SAMR_R_CONNECT5 * r_u,
7310                         prs_struct *ps, int depth)
7311 {
7312         if (r_u == NULL)
7313                 return False;
7314
7315         prs_debug(ps, depth, desc, "samr_io_r_connect5");
7316         depth++;
7317
7318         if(!prs_align(ps))
7319                 return False;
7320
7321         if(!prs_uint32("level", ps, depth, &r_u->level))
7322                 return False;
7323         if(!prs_uint32("level", ps, depth, &r_u->level))
7324                 return False;
7325         if(!prs_uint32("info1_unk1", ps, depth, &r_u->info1_unk1))
7326                 return False;
7327         if(!prs_uint32("info1_unk2", ps, depth, &r_u->info1_unk2))
7328                 return False;
7329
7330         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7331                 return False;
7332
7333         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7334                 return False;
7335
7336         return True;
7337 }
7338
7339 /*******************************************************************
7340 inits a SAMR_Q_CONNECT_ANON structure.
7341 ********************************************************************/
7342
7343 void init_samr_q_connect_anon(SAMR_Q_CONNECT_ANON * q_u)
7344 {
7345         DEBUG(5, ("init_samr_q_connect_anon\n"));
7346
7347         q_u->ptr = 1;
7348         q_u->unknown_0 = 0x5c;  /* server name (?!!) */
7349         q_u->access_mask = MAXIMUM_ALLOWED_ACCESS;
7350 }
7351
7352 /*******************************************************************
7353 reads or writes a structure.
7354 ********************************************************************/
7355
7356 BOOL samr_io_q_connect_anon(const char *desc, SAMR_Q_CONNECT_ANON * q_u,
7357                             prs_struct *ps, int depth)
7358 {
7359         if (q_u == NULL)
7360                 return False;
7361
7362         prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
7363         depth++;
7364
7365         if(!prs_align(ps))
7366                 return False;
7367
7368         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
7369                 return False;
7370         if (q_u->ptr) {
7371                 if(!prs_uint16("unknown_0", ps, depth, &q_u->unknown_0))
7372                         return False;
7373         }
7374         if(!prs_align(ps))
7375                 return False;
7376         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7377                 return False;
7378
7379         return True;
7380 }
7381
7382 /*******************************************************************
7383 reads or writes a structure.
7384 ********************************************************************/
7385
7386 BOOL samr_io_r_connect_anon(const char *desc, SAMR_R_CONNECT_ANON * r_u,
7387                             prs_struct *ps, int depth)
7388 {
7389         if (r_u == NULL)
7390                 return False;
7391
7392         prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
7393         depth++;
7394
7395         if(!prs_align(ps))
7396                 return False;
7397
7398         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7399                 return False;
7400
7401         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7402                 return False;
7403
7404         return True;
7405 }
7406
7407 /*******************************************************************
7408 inits a SAMR_Q_GET_DOM_PWINFO structure.
7409 ********************************************************************/
7410
7411 void init_samr_q_get_dom_pwinfo(SAMR_Q_GET_DOM_PWINFO * q_u,
7412                                 char *srv_name)
7413 {
7414         DEBUG(5, ("init_samr_q_get_dom_pwinfo\n"));
7415
7416         q_u->ptr = 1;
7417         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_FLAGS_NONE);
7418         init_uni_hdr(&q_u->hdr_srv_name, &q_u->uni_srv_name);
7419 }
7420
7421 /*******************************************************************
7422 reads or writes a structure.
7423 ********************************************************************/
7424
7425 BOOL samr_io_q_get_dom_pwinfo(const char *desc, SAMR_Q_GET_DOM_PWINFO * q_u,
7426                               prs_struct *ps, int depth)
7427 {
7428         if (q_u == NULL)
7429                 return False;
7430
7431         prs_debug(ps, depth, desc, "samr_io_q_get_dom_pwinfo");
7432         depth++;
7433
7434         if(!prs_align(ps))
7435                 return False;
7436
7437         if(!prs_uint32("ptr", ps, depth, &q_u->ptr))
7438                 return False;
7439         if (q_u->ptr != 0) {
7440                 if(!smb_io_unihdr("", &q_u->hdr_srv_name, ps, depth))
7441                         return False;
7442                 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->hdr_srv_name.buffer, ps, depth))
7443                         return False;
7444         }
7445
7446         return True;
7447 }
7448
7449 /*******************************************************************
7450 reads or writes a structure.
7451 ********************************************************************/
7452
7453 BOOL samr_io_r_get_dom_pwinfo(const char *desc, SAMR_R_GET_DOM_PWINFO * r_u,
7454                               prs_struct *ps, int depth)
7455 {
7456         if (r_u == NULL)
7457                 return False;
7458
7459         prs_debug(ps, depth, desc, "samr_io_r_get_dom_pwinfo");
7460         depth++;
7461
7462         if(!prs_align(ps))
7463                 return False;
7464
7465         if(!prs_uint16("min_pwd_length", ps, depth, &r_u->min_pwd_length))
7466                 return False;
7467         if(!prs_align(ps))
7468                 return False;
7469         if(!prs_uint32("password_properties", ps, depth, &r_u->password_properties))
7470                 return False;
7471
7472         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7473                 return False;
7474
7475         return True;
7476 }
7477
7478 /*******************************************************************
7479 make a SAMR_ENC_PASSWD structure.
7480 ********************************************************************/
7481
7482 void init_enc_passwd(SAMR_ENC_PASSWD * pwd, const char pass[512])
7483 {
7484         ZERO_STRUCTP(pwd);
7485
7486         if (pass == NULL) {
7487                 pwd->ptr = 0;
7488         } else {
7489                 pwd->ptr = 1;
7490                 memcpy(pwd->pass, pass, sizeof(pwd->pass));
7491         }
7492 }
7493
7494 /*******************************************************************
7495 reads or writes a SAMR_ENC_PASSWD structure.
7496 ********************************************************************/
7497
7498 BOOL samr_io_enc_passwd(const char *desc, SAMR_ENC_PASSWD * pwd,
7499                         prs_struct *ps, int depth)
7500 {
7501         if (pwd == NULL)
7502                 return False;
7503
7504         prs_debug(ps, depth, desc, "samr_io_enc_passwd");
7505         depth++;
7506
7507         if(!prs_align(ps))
7508                 return False;
7509
7510         if(!prs_uint32("ptr", ps, depth, &pwd->ptr))
7511                 return False;
7512
7513         if (pwd->ptr != 0) {
7514                 if(!prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass)))
7515                         return False;
7516         }
7517
7518         return True;
7519 }
7520
7521 /*******************************************************************
7522 inits a SAMR_ENC_HASH structure.
7523 ********************************************************************/
7524
7525 void init_enc_hash(SAMR_ENC_HASH * hsh, const uchar hash[16])
7526 {
7527         ZERO_STRUCTP(hsh);
7528
7529         if (hash == NULL) {
7530                 hsh->ptr = 0;
7531         } else {
7532                 hsh->ptr = 1;
7533                 memcpy(hsh->hash, hash, sizeof(hsh->hash));
7534         }
7535 }
7536
7537 /*******************************************************************
7538 reads or writes a SAMR_ENC_HASH structure.
7539 ********************************************************************/
7540
7541 BOOL samr_io_enc_hash(const char *desc, SAMR_ENC_HASH * hsh,
7542                       prs_struct *ps, int depth)
7543 {
7544         if (hsh == NULL)
7545                 return False;
7546
7547         prs_debug(ps, depth, desc, "samr_io_enc_hash");
7548         depth++;
7549
7550         if(!prs_align(ps))
7551                 return False;
7552
7553         if(!prs_uint32("ptr ", ps, depth, &hsh->ptr))
7554                 return False;
7555         if (hsh->ptr != 0) {
7556                 if(!prs_uint8s(False, "hash", ps, depth, hsh->hash,sizeof(hsh->hash)))
7557                         return False;
7558         }
7559
7560         return True;
7561 }
7562
7563 /*******************************************************************
7564 inits a SAMR_Q_CHGPASSWD_USER structure.
7565 ********************************************************************/
7566
7567 void init_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER * q_u,
7568                                 const char *dest_host, const char *user_name,
7569                                 const uchar nt_newpass[516],
7570                                 const uchar nt_oldhash[16],
7571                                 const uchar lm_newpass[516],
7572                                 const uchar lm_oldhash[16])
7573 {
7574         DEBUG(5, ("init_samr_q_chgpasswd_user\n"));
7575
7576         q_u->ptr_0 = 1;
7577         init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7578         init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7579
7580         init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7581         init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7582
7583         init_enc_passwd(&q_u->nt_newpass, (const char *)nt_newpass);
7584         init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7585
7586         q_u->unknown = 0x01;
7587
7588         init_enc_passwd(&q_u->lm_newpass, (const char *)lm_newpass);
7589         init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7590 }
7591
7592 /*******************************************************************
7593 reads or writes a structure.
7594 ********************************************************************/
7595
7596 BOOL samr_io_q_chgpasswd_user(const char *desc, SAMR_Q_CHGPASSWD_USER * q_u,
7597                               prs_struct *ps, int depth)
7598 {
7599         if (q_u == NULL)
7600                 return False;
7601
7602         prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
7603         depth++;
7604
7605         if(!prs_align(ps))
7606                 return False;
7607
7608         if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7609                 return False;
7610
7611         if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7612                 return False;
7613         if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7614                 return False;
7615
7616         if(!prs_align(ps))
7617                 return False;
7618         if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7619                 return False;
7620         if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7621                 return False;
7622
7623         if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7624                 return False;
7625         if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7626                 return False;
7627
7628         if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
7629                 return False;
7630
7631         if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7632                 return False;
7633         if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7634                 return False;
7635
7636         return True;
7637 }
7638
7639 /*******************************************************************
7640 inits a SAMR_R_CHGPASSWD_USER structure.
7641 ********************************************************************/
7642
7643 void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER * r_u, NTSTATUS status)
7644 {
7645         DEBUG(5, ("init_samr_r_chgpasswd_user\n"));
7646
7647         r_u->status = status;
7648 }
7649
7650 /*******************************************************************
7651 reads or writes a structure.
7652 ********************************************************************/
7653
7654 BOOL samr_io_r_chgpasswd_user(const char *desc, SAMR_R_CHGPASSWD_USER * r_u,
7655                               prs_struct *ps, int depth)
7656 {
7657         if (r_u == NULL)
7658                 return False;
7659
7660         prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
7661         depth++;
7662
7663         if(!prs_align(ps))
7664                 return False;
7665
7666         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7667                 return False;
7668
7669         return True;
7670 }
7671
7672 /*******************************************************************
7673 inits a SAMR_Q_CHGPASSWD3 structure.
7674 ********************************************************************/
7675
7676 void init_samr_q_chgpasswd_user3(SAMR_Q_CHGPASSWD_USER3 * q_u,
7677                                  const char *dest_host, const char *user_name,
7678                                  const uchar nt_newpass[516],
7679                                  const uchar nt_oldhash[16],
7680                                  const uchar lm_newpass[516],
7681                                  const uchar lm_oldhash[16])
7682 {
7683         DEBUG(5, ("init_samr_q_chgpasswd_user3\n"));
7684
7685         q_u->ptr_0 = 1;
7686         init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7687         init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7688
7689         init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7690         init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7691
7692         init_enc_passwd(&q_u->nt_newpass, (const char *)nt_newpass);
7693         init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7694
7695         q_u->lm_change = 0x01;
7696
7697         init_enc_passwd(&q_u->lm_newpass, (const char *)lm_newpass);
7698         init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7699
7700         init_enc_passwd(&q_u->password3, NULL);
7701 }
7702
7703 /*******************************************************************
7704 reads or writes a structure.
7705 ********************************************************************/
7706
7707 BOOL samr_io_q_chgpasswd_user3(const char *desc, SAMR_Q_CHGPASSWD_USER3 * q_u,
7708                                prs_struct *ps, int depth)
7709 {
7710         if (q_u == NULL)
7711                 return False;
7712
7713         prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user3");
7714         depth++;
7715
7716         if(!prs_align(ps))
7717                 return False;
7718
7719         if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7720                 return False;
7721
7722         if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7723                 return False;
7724         if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7725                 return False;
7726
7727         if(!prs_align(ps))
7728                 return False;
7729         if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7730                 return False;
7731         if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7732                 return False;
7733
7734         if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7735                 return False;
7736         if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7737                 return False;
7738
7739         if(!prs_uint32("lm_change", ps, depth, &q_u->lm_change))
7740                 return False;
7741
7742         if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7743                 return False;
7744         if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7745                 return False;
7746
7747         if(!samr_io_enc_passwd("password3", &q_u->password3, ps, depth))
7748                 return False;
7749
7750         return True;
7751 }
7752
7753 /*******************************************************************
7754 inits a SAMR_R_CHGPASSWD_USER3 structure.
7755 ********************************************************************/
7756
7757 void init_samr_r_chgpasswd_user3(SAMR_R_CHGPASSWD_USER3 *r_u, NTSTATUS status,
7758                                  SAMR_CHANGE_REJECT *reject, SAM_UNK_INFO_1 *info)
7759 {
7760         DEBUG(5, ("init_samr_r_chgpasswd_user3\n"));
7761
7762         r_u->status = status;
7763         r_u->info = 0;
7764         r_u->ptr_info = 0;
7765         r_u->reject = 0;
7766         r_u->ptr_reject = 0;
7767
7768         if (info) {
7769                 r_u->info = info;
7770                 r_u->ptr_info = 1;
7771         }
7772         if (reject && (reject->reject_reason != Undefined)) {
7773                 r_u->reject = reject;
7774                 r_u->ptr_reject = 1;
7775         }
7776 }
7777
7778 /*******************************************************************
7779  Reads or writes an SAMR_CHANGE_REJECT structure.
7780 ********************************************************************/
7781
7782 BOOL samr_io_change_reject(const char *desc, SAMR_CHANGE_REJECT *reject, prs_struct *ps, int depth)
7783 {
7784         if (reject == NULL)
7785                 return False;
7786
7787         prs_debug(ps, depth, desc, "samr_io_change_reject");
7788         depth++;
7789
7790         if(!prs_align(ps))
7791                 return False;
7792
7793         if(UNMARSHALLING(ps))
7794                 ZERO_STRUCTP(reject);
7795
7796         if (!prs_uint32("reject_reason", ps, depth, &reject->reject_reason))
7797                 return False;
7798
7799         if (!prs_uint32("unknown1", ps, depth, &reject->unknown1))
7800                 return False;
7801
7802         if (!prs_uint32("unknown2", ps, depth, &reject->unknown2))
7803                 return False;
7804
7805         return True;
7806 }
7807
7808 /*******************************************************************
7809 reads or writes a structure.
7810 ********************************************************************/
7811
7812 BOOL samr_io_r_chgpasswd_user3(const char *desc, SAMR_R_CHGPASSWD_USER3 *r_u,
7813                                prs_struct *ps, int depth)
7814 {
7815         if (r_u == NULL)
7816                 return False;
7817
7818         prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user3");
7819         depth++;
7820
7821         if (!prs_align(ps))
7822                 return False;
7823
7824         if (!prs_uint32("ptr_info", ps, depth, &r_u->ptr_info))
7825                 return False;
7826
7827         /* special case: Windows 2000 can return stub data here saying
7828            NT_STATUS_NOT_SUPPORTED */
7829
7830         if ( NT_STATUS_EQUAL( NT_STATUS_NOT_SUPPORTED, NT_STATUS(r_u->ptr_info)) ) {
7831                 r_u->status = NT_STATUS_NOT_SUPPORTED;
7832                 return True;
7833         }
7834
7835         if (r_u->ptr_info && r_u->info != NULL) {
7836                 /* SAM_UNK_INFO_1 */
7837                 if (!sam_io_unk_info1("info", r_u->info, ps, depth))
7838                         return False;
7839         }
7840
7841         if (!prs_uint32("ptr_reject", ps, depth, &r_u->ptr_reject))
7842                 return False;
7843
7844         if (r_u->ptr_reject && r_u->reject != NULL) {
7845                 /* SAMR_CHANGE_REJECT */
7846                 if (!samr_io_change_reject("reject", r_u->reject, ps, depth))
7847                         return False;
7848         }
7849
7850         if (!prs_ntstatus("status", ps, depth, &r_u->status))
7851                 return False;
7852
7853         return True;
7854 }
7855
7856 /*******************************************************************
7857 reads or writes a structure.
7858 ********************************************************************/
7859
7860 void init_samr_q_query_domain_info2(SAMR_Q_QUERY_DOMAIN_INFO2 *q_u,
7861                                 POLICY_HND *domain_pol, uint16 switch_value)
7862 {
7863         DEBUG(5, ("init_samr_q_query_domain_info2\n"));
7864
7865         q_u->domain_pol = *domain_pol;
7866         q_u->switch_value = switch_value;
7867 }
7868
7869 /*******************************************************************
7870 reads or writes a structure.
7871 ********************************************************************/
7872
7873 BOOL samr_io_q_query_domain_info2(const char *desc, SAMR_Q_QUERY_DOMAIN_INFO2 *q_u,
7874                               prs_struct *ps, int depth)
7875 {
7876         if (q_u == NULL)
7877                 return False;
7878
7879         prs_debug(ps, depth, desc, "samr_io_q_query_domain_info2");
7880         depth++;
7881
7882         if(!prs_align(ps))
7883                 return False;
7884
7885         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7886                 return False;
7887
7888         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7889                 return False;
7890
7891         return True;
7892 }
7893
7894 /*******************************************************************
7895 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7896 ********************************************************************/
7897
7898 void init_samr_r_query_domain_info2(SAMR_R_QUERY_DOMAIN_INFO2 * r_u,
7899                                     uint16 switch_value, SAM_UNK_CTR * ctr,
7900                                     NTSTATUS status)
7901 {
7902         DEBUG(5, ("init_samr_r_query_domain_info2\n"));
7903
7904         r_u->ptr_0 = 0;
7905         r_u->switch_value = 0;
7906         r_u->status = status;   /* return status */
7907
7908         if (NT_STATUS_IS_OK(status)) {
7909                 r_u->switch_value = switch_value;
7910                 r_u->ptr_0 = 1;
7911                 r_u->ctr = ctr;
7912         }
7913 }
7914
7915 /*******************************************************************
7916 reads or writes a structure.
7917 ********************************************************************/
7918
7919 BOOL samr_io_r_query_domain_info2(const char *desc, SAMR_R_QUERY_DOMAIN_INFO2 * r_u,
7920                                   prs_struct *ps, int depth)
7921 {
7922         if (r_u == NULL)
7923                 return False;
7924
7925         prs_debug(ps, depth, desc, "samr_io_r_query_domain_info2");
7926         depth++;
7927
7928         if(!prs_align(ps))
7929                 return False;
7930
7931         if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
7932                 return False;
7933
7934         if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
7935                 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
7936                         return False;
7937                 if(!prs_align(ps))
7938                         return False;
7939
7940                 switch (r_u->switch_value) {
7941                 case 0x0d:
7942                         if(!sam_io_unk_info13("unk_inf13", &r_u->ctr->info.inf13, ps, depth))
7943                                 return False;
7944                         break;
7945                 case 0x0c:
7946                         if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
7947                                 return False;
7948                         break;
7949                 case 0x09:
7950                         if(!sam_io_unk_info9("unk_inf9",&r_u->ctr->info.inf9, ps,depth))
7951                                 return False;
7952                         break;
7953                 case 0x08:
7954                         if(!sam_io_unk_info8("unk_inf8",&r_u->ctr->info.inf8, ps,depth))
7955                                 return False;
7956                         break;
7957                 case 0x07:
7958                         if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
7959                                 return False;
7960                         break;
7961                 case 0x06:
7962                         if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
7963                                 return False;
7964                         break;
7965                 case 0x05:
7966                         if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
7967                                 return False;
7968                         break;
7969                 case 0x04:
7970                         if(!sam_io_unk_info4("unk_inf4",&r_u->ctr->info.inf4, ps,depth))
7971                                 return False;
7972                         break;
7973                 case 0x03:
7974                         if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
7975                                 return False;
7976                         break;
7977                 case 0x02:
7978                         if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
7979                                 return False;
7980                         break;
7981                 case 0x01:
7982                         if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
7983                                 return False;
7984                         break;
7985                 default:
7986                         DEBUG(0, ("samr_io_r_query_domain_info2: unknown switch level 0x%x\n",
7987                                 r_u->switch_value));
7988                         r_u->status = NT_STATUS_INVALID_INFO_CLASS;
7989                         return False;
7990                 }
7991         }
7992
7993         if(!prs_align(ps))
7994                 return False;
7995
7996         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7997                 return False;
7998
7999         return True;
8000 }
8001
8002
8003 /*******************************************************************
8004 reads or writes a structure.
8005 ********************************************************************/
8006
8007 void init_samr_q_set_domain_info(SAMR_Q_SET_DOMAIN_INFO *q_u,
8008                                 POLICY_HND *domain_pol, uint16 switch_value, SAM_UNK_CTR *ctr)
8009 {
8010         DEBUG(5, ("init_samr_q_set_domain_info\n"));
8011
8012         q_u->domain_pol = *domain_pol;
8013         q_u->switch_value0 = switch_value;
8014
8015         q_u->switch_value = switch_value;
8016         q_u->ctr = ctr;
8017
8018 }
8019
8020 /*******************************************************************
8021 reads or writes a structure.
8022 ********************************************************************/
8023
8024 BOOL samr_io_q_set_domain_info(const char *desc, SAMR_Q_SET_DOMAIN_INFO *q_u,
8025                               prs_struct *ps, int depth)
8026 {
8027         if (q_u == NULL)
8028                 return False;
8029
8030         prs_debug(ps, depth, desc, "samr_io_q_set_domain_info");
8031         depth++;
8032
8033         if(!prs_align(ps))
8034                 return False;
8035
8036         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
8037                 return False;
8038
8039         if(!prs_uint16("switch_value0", ps, depth, &q_u->switch_value0))
8040                 return False;
8041
8042         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
8043                 return False;
8044
8045         if(!prs_align(ps))
8046                 return False;
8047
8048         if (UNMARSHALLING(ps)) {
8049                 if ((q_u->ctr = PRS_ALLOC_MEM(ps, SAM_UNK_CTR, 1)) == NULL)
8050                         return False;
8051         }
8052
8053         switch (q_u->switch_value) {
8054
8055         case 0x0c:
8056                 if(!sam_io_unk_info12("unk_inf12", &q_u->ctr->info.inf12, ps, depth))
8057                         return False;
8058                 break;
8059         case 0x07:
8060                 if(!sam_io_unk_info7("unk_inf7",&q_u->ctr->info.inf7, ps,depth))
8061                         return False;
8062                 break;
8063         case 0x06:
8064                 if(!sam_io_unk_info6("unk_inf6",&q_u->ctr->info.inf6, ps,depth))
8065                         return False;
8066                 break;
8067         case 0x05:
8068                 if(!sam_io_unk_info5("unk_inf5",&q_u->ctr->info.inf5, ps,depth))
8069                         return False;
8070                 break;
8071         case 0x03:
8072                 if(!sam_io_unk_info3("unk_inf3",&q_u->ctr->info.inf3, ps,depth))
8073                         return False;
8074                 break;
8075         case 0x02:
8076                 if(!sam_io_unk_info2("unk_inf2",&q_u->ctr->info.inf2, ps,depth))
8077                         return False;
8078                 break;
8079         case 0x01:
8080                 if(!sam_io_unk_info1("unk_inf1",&q_u->ctr->info.inf1, ps,depth))
8081                         return False;
8082                 break;
8083         default:
8084                 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
8085                         q_u->switch_value));
8086                 return False;
8087         }
8088
8089         return True;
8090 }
8091
8092 /*******************************************************************
8093 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
8094 ********************************************************************/
8095
8096 void init_samr_r_set_domain_info(SAMR_R_SET_DOMAIN_INFO * r_u, NTSTATUS status)
8097 {
8098         DEBUG(5, ("init_samr_r_set_domain_info\n"));
8099
8100         r_u->status = status;   /* return status */
8101 }
8102
8103 /*******************************************************************
8104 reads or writes a structure.
8105 ********************************************************************/
8106
8107 BOOL samr_io_r_set_domain_info(const char *desc, SAMR_R_SET_DOMAIN_INFO * r_u,
8108                               prs_struct *ps, int depth)
8109 {
8110         if (r_u == NULL)
8111                 return False;
8112
8113         prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
8114         depth++;
8115
8116         if(!prs_align(ps))
8117                 return False;
8118
8119         if(!prs_ntstatus("status", ps, depth, &r_u->status))
8120                 return False;
8121
8122         return True;
8123 }