source/rpc_parse/parse_samr.c

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