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         if (num_rids) {
4249                 q_u->rid = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids );
4250         } else {
4251                 q_u->rid = NULL;
4252         }
4253         if (q_u->rid == NULL) {
4254                 q_u->num_rids1 = 0;
4255                 q_u->num_rids2 = 0;
4256         } else {
4257                 memcpy(q_u->rid, rid, num_rids * sizeof(q_u->rid[0]));
4258         }
4259 }
4260
4261 /*******************************************************************
4262 reads or writes a structure.
4263 ********************************************************************/
4264
4265 BOOL samr_io_q_lookup_rids(const char *desc, SAMR_Q_LOOKUP_RIDS * q_u,
4266                            prs_struct *ps, int depth)
4267 {
4268         uint32 i;
4269         fstring tmp;
4270
4271         if (q_u == NULL)
4272                 return False;
4273
4274         prs_debug(ps, depth, desc, "samr_io_q_lookup_rids");
4275         depth++;
4276
4277         if (UNMARSHALLING(ps))
4278                 ZERO_STRUCTP(q_u);
4279
4280         if(!prs_align(ps))
4281                 return False;
4282
4283         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4284                 return False;
4285
4286         if(!prs_uint32("num_rids1", ps, depth, &q_u->num_rids1))
4287                 return False;
4288         if(!prs_uint32("flags    ", ps, depth, &q_u->flags))
4289                 return False;
4290         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
4291                 return False;
4292         if(!prs_uint32("num_rids2", ps, depth, &q_u->num_rids2))
4293                 return False;
4294
4295         if (UNMARSHALLING(ps) && (q_u->num_rids2 != 0)) {
4296                 q_u->rid = PRS_ALLOC_MEM(ps, uint32, q_u->num_rids2);
4297                 if (q_u->rid == NULL)
4298                         return False;
4299         }
4300
4301         for (i = 0; i < q_u->num_rids2; i++) {
4302                 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]  ", i);
4303                 if(!prs_uint32(tmp, ps, depth, &q_u->rid[i]))
4304                         return False;
4305         }
4306
4307         return True;
4308 }
4309
4310 /*******************************************************************
4311 inits a SAMR_R_LOOKUP_RIDS structure.
4312 ********************************************************************/
4313
4314 void init_samr_r_lookup_rids(SAMR_R_LOOKUP_RIDS * r_u,
4315                              uint32 num_names, UNIHDR * hdr_name,
4316                              UNISTR2 *uni_name, uint32 *type)
4317 {
4318         DEBUG(5, ("init_samr_r_lookup_rids\n"));
4319
4320         r_u->hdr_name = NULL;
4321         r_u->uni_name = NULL;
4322         r_u->type = NULL;
4323
4324         if (num_names != 0) {
4325                 r_u->num_names1 = num_names;
4326                 r_u->ptr_names = 1;
4327                 r_u->num_names2 = num_names;
4328
4329                 r_u->num_types1 = num_names;
4330                 r_u->ptr_types = 1;
4331                 r_u->num_types2 = num_names;
4332
4333                 r_u->hdr_name = hdr_name;
4334                 r_u->uni_name = uni_name;
4335                 r_u->type = type;
4336         } else {
4337                 r_u->num_names1 = num_names;
4338                 r_u->ptr_names = 0;
4339                 r_u->num_names2 = num_names;
4340
4341                 r_u->num_types1 = num_names;
4342                 r_u->ptr_types = 0;
4343                 r_u->num_types2 = num_names;
4344         }
4345 }
4346
4347 /*******************************************************************
4348 reads or writes a structure.
4349 ********************************************************************/
4350
4351 BOOL samr_io_r_lookup_rids(const char *desc, SAMR_R_LOOKUP_RIDS * r_u,
4352                            prs_struct *ps, int depth)
4353 {
4354         uint32 i;
4355         fstring tmp;
4356         if (r_u == NULL)
4357                 return False;
4358
4359         prs_debug(ps, depth, desc, "samr_io_r_lookup_rids");
4360         depth++;
4361
4362         if(!prs_align(ps))
4363                 return False;
4364
4365         if(!prs_uint32("num_names1", ps, depth, &r_u->num_names1))
4366                 return False;
4367         if(!prs_uint32("ptr_names ", ps, depth, &r_u->ptr_names))
4368                 return False;
4369
4370         if (r_u->ptr_names != 0) {
4371
4372                 if(!prs_uint32("num_names2", ps, depth, &r_u->num_names2))
4373                         return False;
4374
4375
4376                 if (UNMARSHALLING(ps) && (r_u->num_names2 != 0)) {
4377                         r_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, r_u->num_names2);
4378                         if (r_u->hdr_name == NULL)
4379                                 return False;
4380
4381                         r_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, r_u->num_names2);
4382                         if (r_u->uni_name == NULL)
4383                                 return False;
4384                 }
4385
4386                 for (i = 0; i < r_u->num_names2; i++) {
4387                         slprintf(tmp, sizeof(tmp) - 1, "hdr[%02d]  ", i);
4388                         if(!smb_io_unihdr("", &r_u->hdr_name[i], ps, depth))
4389                                 return False;
4390                 }
4391                 for (i = 0; i < r_u->num_names2; i++) {
4392                         slprintf(tmp, sizeof(tmp) - 1, "str[%02d]  ", i);
4393                         if(!smb_io_unistr2("", &r_u->uni_name[i], r_u->hdr_name[i].buffer, ps, depth))
4394                                 return False;
4395                 }
4396
4397         }
4398
4399         if(!prs_align(ps))
4400                 return False;
4401         if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
4402                 return False;
4403         if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
4404                 return False;
4405
4406         if (r_u->ptr_types != 0) {
4407
4408                 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
4409                         return False;
4410
4411                 if (UNMARSHALLING(ps) && (r_u->num_types2 != 0)) {
4412                         r_u->type = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
4413                         if (r_u->type == NULL)
4414                                 return False;
4415                 }
4416
4417                 for (i = 0; i < r_u->num_types2; i++) {
4418                         slprintf(tmp, sizeof(tmp) - 1, "type[%02d]  ", i);
4419                         if(!prs_uint32(tmp, ps, depth, &r_u->type[i]))
4420                                 return False;
4421                 }
4422         }
4423
4424         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4425                 return False;
4426
4427         return True;
4428 }
4429
4430 /*******************************************************************
4431 inits a SAMR_Q_OPEN_ALIAS structure.
4432 ********************************************************************/
4433
4434 void init_samr_q_delete_alias(SAMR_Q_DELETE_DOM_ALIAS * q_u, POLICY_HND *hnd)
4435 {
4436         DEBUG(5, ("init_samr_q_delete_alias\n"));
4437
4438         q_u->alias_pol = *hnd;
4439 }
4440
4441 /*******************************************************************
4442 reads or writes a structure.
4443 ********************************************************************/
4444
4445 BOOL samr_io_q_delete_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4446                             prs_struct *ps, int depth)
4447 {
4448         if (q_u == NULL)
4449                 return False;
4450
4451         prs_debug(ps, depth, desc, "samr_io_q_delete_alias");
4452         depth++;
4453
4454         if(!prs_align(ps))
4455                 return False;
4456
4457         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4458                 return False;
4459
4460         return True;
4461 }
4462
4463 /*******************************************************************
4464 reads or writes a structure.
4465 ********************************************************************/
4466
4467 BOOL samr_io_r_delete_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4468                             prs_struct *ps, int depth)
4469 {
4470         if (r_u == NULL)
4471                 return False;
4472
4473         prs_debug(ps, depth, desc, "samr_io_r_delete_alias");
4474         depth++;
4475
4476         if(!prs_align(ps))
4477                 return False;
4478
4479         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4480                 return False;
4481         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4482                 return False;
4483
4484         return True;
4485 }
4486
4487 /*******************************************************************
4488 inits a SAMR_Q_CREATE_DOM_ALIAS structure.
4489 ********************************************************************/
4490
4491 void init_samr_q_create_dom_alias(SAMR_Q_CREATE_DOM_ALIAS * q_u,
4492                                   POLICY_HND *hnd, const char *acct_desc)
4493 {
4494         DEBUG(5, ("init_samr_q_create_dom_alias\n"));
4495
4496         q_u->dom_pol = *hnd;
4497
4498         init_unistr2(&q_u->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
4499         init_uni_hdr(&q_u->hdr_acct_desc, &q_u->uni_acct_desc);
4500
4501         q_u->access_mask = MAXIMUM_ALLOWED_ACCESS;
4502 }
4503
4504 /*******************************************************************
4505 reads or writes a structure.
4506 ********************************************************************/
4507
4508 BOOL samr_io_q_create_dom_alias(const char *desc, SAMR_Q_CREATE_DOM_ALIAS * q_u,
4509                                 prs_struct *ps, int depth)
4510 {
4511         if (q_u == NULL)
4512                 return False;
4513
4514         prs_debug(ps, depth, desc, "samr_io_q_create_dom_alias");
4515         depth++;
4516
4517         if(!prs_align(ps))
4518                 return False;
4519
4520         if(!smb_io_pol_hnd("dom_pol", &q_u->dom_pol, ps, depth))
4521                 return False;
4522
4523         if(!smb_io_unihdr("hdr_acct_desc", &q_u->hdr_acct_desc, ps, depth))
4524                 return False;
4525         if(!smb_io_unistr2("uni_acct_desc", &q_u->uni_acct_desc,
4526                        q_u->hdr_acct_desc.buffer, ps, depth))
4527                 return False;
4528
4529         if(!prs_align(ps))
4530                 return False;
4531         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
4532                 return False;
4533
4534         return True;
4535 }
4536
4537 /*******************************************************************
4538 reads or writes a structure.
4539 ********************************************************************/
4540
4541 BOOL samr_io_r_create_dom_alias(const char *desc, SAMR_R_CREATE_DOM_ALIAS * r_u,
4542                                 prs_struct *ps, int depth)
4543 {
4544         if (r_u == NULL)
4545                 return False;
4546
4547         prs_debug(ps, depth, desc, "samr_io_r_create_dom_alias");
4548         depth++;
4549
4550         if(!prs_align(ps))
4551                 return False;
4552
4553         if(!smb_io_pol_hnd("alias_pol", &r_u->alias_pol, ps, depth))
4554                 return False;
4555
4556         if(!prs_uint32("rid", ps, depth, &r_u->rid))
4557                 return False;
4558
4559         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4560                 return False;
4561
4562         return True;
4563 }
4564
4565 /*******************************************************************
4566 inits a SAMR_Q_ADD_ALIASMEM structure.
4567 ********************************************************************/
4568
4569 void init_samr_q_add_aliasmem(SAMR_Q_ADD_ALIASMEM * q_u, POLICY_HND *hnd,
4570                               DOM_SID *sid)
4571 {
4572         DEBUG(5, ("init_samr_q_add_aliasmem\n"));
4573
4574         q_u->alias_pol = *hnd;
4575         init_dom_sid2(&q_u->sid, sid);
4576 }
4577
4578 /*******************************************************************
4579 reads or writes a structure.
4580 ********************************************************************/
4581
4582 BOOL samr_io_q_add_aliasmem(const char *desc, SAMR_Q_ADD_ALIASMEM * q_u,
4583                             prs_struct *ps, int depth)
4584 {
4585         if (q_u == NULL)
4586                 return False;
4587
4588         prs_debug(ps, depth, desc, "samr_io_q_add_aliasmem");
4589         depth++;
4590
4591         if(!prs_align(ps))
4592                 return False;
4593
4594         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4595                 return False;
4596         if(!smb_io_dom_sid2("sid      ", &q_u->sid, ps, depth))
4597                 return False;
4598
4599         return True;
4600 }
4601
4602 /*******************************************************************
4603 reads or writes a structure.
4604 ********************************************************************/
4605
4606 BOOL samr_io_r_add_aliasmem(const char *desc, SAMR_R_ADD_ALIASMEM * r_u,
4607                             prs_struct *ps, int depth)
4608 {
4609         if (r_u == NULL)
4610                 return False;
4611
4612         prs_debug(ps, depth, desc, "samr_io_r_add_aliasmem");
4613         depth++;
4614
4615         if(!prs_align(ps))
4616                 return False;
4617
4618         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4619                 return False;
4620
4621         return True;
4622 }
4623
4624 /*******************************************************************
4625 inits a SAMR_Q_DEL_ALIASMEM structure.
4626 ********************************************************************/
4627
4628 void init_samr_q_del_aliasmem(SAMR_Q_DEL_ALIASMEM * q_u, POLICY_HND *hnd,
4629                               DOM_SID *sid)
4630 {
4631         DEBUG(5, ("init_samr_q_del_aliasmem\n"));
4632
4633         q_u->alias_pol = *hnd;
4634         init_dom_sid2(&q_u->sid, sid);
4635 }
4636
4637 /*******************************************************************
4638 reads or writes a structure.
4639 ********************************************************************/
4640
4641 BOOL samr_io_q_del_aliasmem(const char *desc, SAMR_Q_DEL_ALIASMEM * q_u,
4642                             prs_struct *ps, int depth)
4643 {
4644         if (q_u == NULL)
4645                 return False;
4646
4647         prs_debug(ps, depth, desc, "samr_io_q_del_aliasmem");
4648         depth++;
4649
4650         if(!prs_align(ps))
4651                 return False;
4652
4653         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4654                 return False;
4655         if(!smb_io_dom_sid2("sid      ", &q_u->sid, ps, depth))
4656                 return False;
4657
4658         return True;
4659 }
4660
4661 /*******************************************************************
4662 reads or writes a structure.
4663 ********************************************************************/
4664
4665 BOOL samr_io_r_del_aliasmem(const char *desc, SAMR_R_DEL_ALIASMEM * r_u,
4666                             prs_struct *ps, int depth)
4667 {
4668         if (r_u == NULL)
4669                 return False;
4670
4671         prs_debug(ps, depth, desc, "samr_io_r_del_aliasmem");
4672         depth++;
4673
4674         if(!prs_align(ps))
4675                 return False;
4676
4677         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4678                 return False;
4679
4680         return True;
4681 }
4682
4683 /*******************************************************************
4684 inits a SAMR_Q_DELETE_DOM_ALIAS structure.
4685 ********************************************************************/
4686
4687 void init_samr_q_delete_dom_alias(SAMR_Q_DELETE_DOM_ALIAS * q_c,
4688                                   POLICY_HND *hnd)
4689 {
4690         DEBUG(5, ("init_samr_q_delete_dom_alias\n"));
4691
4692         q_c->alias_pol = *hnd;
4693 }
4694
4695 /*******************************************************************
4696 reads or writes a structure.
4697 ********************************************************************/
4698
4699 BOOL samr_io_q_delete_dom_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4700                                 prs_struct *ps, int depth)
4701 {
4702         if (q_u == NULL)
4703                 return False;
4704
4705         prs_debug(ps, depth, desc, "samr_io_q_delete_dom_alias");
4706         depth++;
4707
4708         if(!prs_align(ps))
4709                 return False;
4710
4711         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4712                 return False;
4713
4714         return True;
4715 }
4716
4717 /*******************************************************************
4718 inits a SAMR_R_DELETE_DOM_ALIAS structure.
4719 ********************************************************************/
4720
4721 void init_samr_r_delete_dom_alias(SAMR_R_DELETE_DOM_ALIAS * r_u,
4722                                   NTSTATUS status)
4723 {
4724         DEBUG(5, ("init_samr_r_delete_dom_alias\n"));
4725
4726         r_u->status = status;
4727 }
4728
4729 /*******************************************************************
4730 reads or writes a structure.
4731 ********************************************************************/
4732
4733 BOOL samr_io_r_delete_dom_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4734                                 prs_struct *ps, int depth)
4735 {
4736         if (r_u == NULL)
4737                 return False;
4738
4739         prs_debug(ps, depth, desc, "samr_io_r_delete_dom_alias");
4740         depth++;
4741
4742         if(!prs_align(ps))
4743                 return False;
4744
4745         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4746                 return False;
4747
4748         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4749                 return False;
4750
4751         return True;
4752 }
4753
4754 /*******************************************************************
4755 inits a SAMR_Q_QUERY_ALIASMEM structure.
4756 ********************************************************************/
4757
4758 void init_samr_q_query_aliasmem(SAMR_Q_QUERY_ALIASMEM * q_c,
4759                                 POLICY_HND *hnd)
4760 {
4761         DEBUG(5, ("init_samr_q_query_aliasmem\n"));
4762
4763         q_c->alias_pol = *hnd;
4764 }
4765
4766 /*******************************************************************
4767 reads or writes a structure.
4768 ********************************************************************/
4769
4770 BOOL samr_io_q_query_aliasmem(const char *desc, SAMR_Q_QUERY_ALIASMEM * q_u,
4771                               prs_struct *ps, int depth)
4772 {
4773         if (q_u == NULL)
4774                 return False;
4775
4776         prs_debug(ps, depth, desc, "samr_io_q_query_aliasmem");
4777         depth++;
4778
4779         if(!prs_align(ps))
4780                 return False;
4781
4782         if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4783                 return False;
4784
4785         return True;
4786 }
4787
4788 /*******************************************************************
4789 inits a SAMR_R_QUERY_ALIASMEM structure.
4790 ********************************************************************/
4791
4792 void init_samr_r_query_aliasmem(SAMR_R_QUERY_ALIASMEM * r_u,
4793                                 uint32 num_sids, DOM_SID2 * sid,
4794                                 NTSTATUS status)
4795 {
4796         DEBUG(5, ("init_samr_r_query_aliasmem\n"));
4797
4798         if (NT_STATUS_IS_OK(status)) {
4799                 r_u->num_sids = num_sids;
4800                 r_u->ptr = (num_sids != 0) ? 1 : 0;
4801                 r_u->num_sids1 = num_sids;
4802
4803                 r_u->sid = sid;
4804         } else {
4805                 r_u->ptr = 0;
4806                 r_u->num_sids = 0;
4807         }
4808
4809         r_u->status = status;
4810 }
4811
4812 /*******************************************************************
4813 reads or writes a structure.
4814 ********************************************************************/
4815
4816 BOOL samr_io_r_query_aliasmem(const char *desc, SAMR_R_QUERY_ALIASMEM * r_u,
4817                               prs_struct *ps, int depth)
4818 {
4819         uint32 i;
4820
4821         if (r_u == NULL)
4822                 return False;
4823
4824         prs_debug(ps, depth, desc, "samr_io_r_query_aliasmem");
4825         depth++;
4826
4827         if(!prs_align(ps))
4828                 return False;
4829
4830         if(!prs_uint32("num_sids ", ps, depth, &r_u->num_sids))
4831                 return False;
4832         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
4833                 return False;
4834
4835         if (r_u->ptr != 0 && r_u->num_sids != 0) {
4836                 uint32 *ptr_sid = NULL;
4837
4838                 if(!prs_uint32("num_sids1", ps, depth, &r_u->num_sids1))
4839                         return False;
4840
4841                 ptr_sid = TALLOC_ARRAY(ps->mem_ctx, uint32, r_u->num_sids1);
4842                 if (!ptr_sid) {
4843                         return False;
4844                 }
4845
4846                 for (i = 0; i < r_u->num_sids1; i++) {
4847                         ptr_sid[i] = 1;
4848                         if(!prs_uint32("ptr_sid", ps, depth, &ptr_sid[i]))
4849                                 return False;
4850                 }
4851
4852                 if (UNMARSHALLING(ps)) {
4853                         r_u->sid = TALLOC_ARRAY(ps->mem_ctx, DOM_SID2, r_u->num_sids1);
4854                 }
4855
4856                 for (i = 0; i < r_u->num_sids1; i++) {
4857                         if (ptr_sid[i] != 0) {
4858                                 if(!smb_io_dom_sid2("sid", &r_u->sid[i], ps, depth))
4859                                         return False;
4860                         }
4861                 }
4862         }
4863
4864         if(!prs_align(ps))
4865                 return False;
4866         if(!prs_ntstatus("status", ps, depth, &r_u->status))
4867                 return False;
4868
4869         return True;
4870 }
4871
4872 /*******************************************************************
4873 inits a SAMR_Q_LOOKUP_NAMES structure.
4874 ********************************************************************/
4875
4876 NTSTATUS init_samr_q_lookup_names(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_NAMES * q_u,
4877                               POLICY_HND *pol, uint32 flags,
4878                               uint32 num_names, const char **name)
4879 {
4880         uint32 i;
4881
4882         DEBUG(5, ("init_samr_q_lookup_names\n"));
4883
4884         q_u->pol = *pol;
4885
4886         q_u->num_names1 = num_names;
4887         q_u->flags = flags;
4888         q_u->ptr = 0;
4889         q_u->num_names2 = num_names;
4890
4891         if (num_names) {
4892                 if (!(q_u->hdr_name = TALLOC_ZERO_ARRAY(ctx, UNIHDR, num_names)))
4893                         return NT_STATUS_NO_MEMORY;
4894
4895                 if (!(q_u->uni_name = TALLOC_ZERO_ARRAY(ctx, UNISTR2, num_names)))
4896                         return NT_STATUS_NO_MEMORY;
4897         } else {
4898                 q_u->hdr_name = NULL;
4899                 q_u->uni_name = NULL;
4900         }
4901
4902         for (i = 0; i < num_names; i++) {
4903                 init_unistr2(&q_u->uni_name[i], name[i], UNI_FLAGS_NONE);       /* unicode string for machine account */
4904                 init_uni_hdr(&q_u->hdr_name[i], &q_u->uni_name[i]);     /* unicode header for user_name */
4905         }
4906
4907         return NT_STATUS_OK;
4908 }
4909
4910 /*******************************************************************
4911 reads or writes a structure.
4912 ********************************************************************/
4913
4914 BOOL samr_io_q_lookup_names(const char *desc, SAMR_Q_LOOKUP_NAMES * q_u,
4915                             prs_struct *ps, int depth)
4916 {
4917         uint32 i;
4918
4919         if (q_u == NULL)
4920                 return False;
4921
4922         prs_debug(ps, depth, desc, "samr_io_q_lookup_names");
4923         depth++;
4924
4925         if (UNMARSHALLING(ps))
4926                 ZERO_STRUCTP(q_u);
4927
4928         if(!prs_align(ps))
4929                 return False;
4930
4931         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4932                 return False;
4933
4934         if(!prs_uint32("num_names1", ps, depth, &q_u->num_names1))
4935                 return False;
4936         if(!prs_uint32("flags     ", ps, depth, &q_u->flags))
4937                 return False;
4938         if(!prs_uint32("ptr       ", ps, depth, &q_u->ptr))
4939                 return False;
4940         if(!prs_uint32("num_names2", ps, depth, &q_u->num_names2))
4941                 return False;
4942
4943         if (UNMARSHALLING(ps) && (q_u->num_names2 != 0)) {
4944                 q_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_u->num_names2);
4945                 q_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_u->num_names2);
4946                 if (!q_u->hdr_name || !q_u->uni_name)
4947                         return False;
4948         }
4949
4950         for (i = 0; i < q_u->num_names2; i++) {
4951                 if(!smb_io_unihdr("", &q_u->hdr_name[i], ps, depth))
4952                         return False;
4953         }
4954
4955         for (i = 0; i < q_u->num_names2; i++) {
4956                 if(!smb_io_unistr2("", &q_u->uni_name[i], q_u->hdr_name[i].buffer, ps, depth))
4957                         return False;
4958         }
4959
4960         return True;
4961 }
4962
4963 /*******************************************************************
4964 inits a SAMR_R_LOOKUP_NAMES structure.
4965 ********************************************************************/
4966
4967 NTSTATUS init_samr_r_lookup_names(TALLOC_CTX *ctx, SAMR_R_LOOKUP_NAMES * r_u,
4968                               uint32 num_rids,
4969                               uint32 *rid, enum lsa_SidType *type,
4970                               NTSTATUS status)
4971 {
4972         DEBUG(5, ("init_samr_r_lookup_names\n"));
4973
4974         if (NT_STATUS_IS_OK(status) && (num_rids != 0)) {
4975                 uint32 i;
4976
4977                 r_u->num_types1 = num_rids;
4978                 r_u->ptr_types = 1;
4979                 r_u->num_types2 = num_rids;
4980
4981                 r_u->num_rids1 = num_rids;
4982                 r_u->ptr_rids = 1;
4983                 r_u->num_rids2 = num_rids;
4984
4985                 if (num_rids) {
4986                         if (!(r_u->rids = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
4987                                 return NT_STATUS_NO_MEMORY;
4988                         if (!(r_u->types = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
4989                                 return NT_STATUS_NO_MEMORY;
4990                 } else {
4991                         r_u->rids = NULL;
4992                         r_u->types = NULL;
4993                 }
4994
4995                 if (!r_u->rids || !r_u->types)
4996                         goto empty;
4997
4998                 for (i = 0; i < num_rids; i++) {
4999                         r_u->rids[i] = rid[i];
5000                         r_u->types[i] = type[i];
5001                 }
5002         } else {
5003
5004   empty:
5005                 r_u->num_types1 = 0;
5006                 r_u->ptr_types = 0;
5007                 r_u->num_types2 = 0;
5008
5009                 r_u->num_rids1 = 0;
5010                 r_u->ptr_rids = 0;
5011                 r_u->num_rids2 = 0;
5012
5013                 r_u->rids = NULL;
5014                 r_u->types = NULL;
5015         }
5016
5017         r_u->status = status;
5018
5019         return NT_STATUS_OK;
5020 }
5021
5022 /*******************************************************************
5023 reads or writes a structure.
5024 ********************************************************************/
5025
5026 BOOL samr_io_r_lookup_names(const char *desc, SAMR_R_LOOKUP_NAMES * r_u,
5027                             prs_struct *ps, int depth)
5028 {
5029         uint32 i;
5030         fstring tmp;
5031
5032         if (r_u == NULL)
5033                 return False;
5034
5035         prs_debug(ps, depth, desc, "samr_io_r_lookup_names");
5036         depth++;
5037
5038         if (UNMARSHALLING(ps))
5039                 ZERO_STRUCTP(r_u);
5040
5041         if(!prs_align(ps))
5042                 return False;
5043
5044         if(!prs_uint32("num_rids1", ps, depth, &r_u->num_rids1))
5045                 return False;
5046         if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
5047                 return False;
5048
5049         if (r_u->ptr_rids != 0) {
5050                 if(!prs_uint32("num_rids2", ps, depth, &r_u->num_rids2))
5051                         return False;
5052
5053                 if (r_u->num_rids2 != r_u->num_rids1) {
5054                         /* RPC fault */
5055                         return False;
5056                 }
5057
5058                 if (UNMARSHALLING(ps))
5059                         r_u->rids = PRS_ALLOC_MEM(ps, uint32, r_u->num_rids2);
5060
5061                 if (!r_u->rids) {
5062                         DEBUG(0, ("NULL rids in samr_io_r_lookup_names\n"));
5063                         return False;
5064                 }
5065
5066                 for (i = 0; i < r_u->num_rids2; i++) {
5067                         slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]  ", i);
5068                         if(!prs_uint32(tmp, ps, depth, &r_u->rids[i]))
5069                                 return False;
5070                 }
5071         }
5072
5073         if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
5074                 return False;
5075         if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
5076                 return False;
5077
5078         if (r_u->ptr_types != 0) {
5079                 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
5080                         return False;
5081
5082                 if (r_u->num_types2 != r_u->num_types1) {
5083                         /* RPC fault */
5084                         return False;
5085                 }
5086
5087                 if (UNMARSHALLING(ps))
5088                         r_u->types = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
5089
5090                 if (!r_u->types) {
5091                         DEBUG(0, ("NULL types in samr_io_r_lookup_names\n"));
5092                         return False;
5093                 }
5094
5095                 for (i = 0; i < r_u->num_types2; i++) {
5096                         slprintf(tmp, sizeof(tmp) - 1, "type[%02d]  ", i);
5097                         if(!prs_uint32(tmp, ps, depth, &r_u->types[i]))
5098                                 return False;
5099                 }
5100         }
5101
5102         if(!prs_ntstatus("status", ps, depth, &r_u->status))
5103                 return False;
5104
5105         return True;
5106 }
5107
5108 /*******************************************************************
5109 inits a SAMR_Q_DELETE_DOM_USER structure.
5110 ********************************************************************/
5111
5112 void init_samr_q_delete_dom_user(SAMR_Q_DELETE_DOM_USER * q_c,
5113                                  POLICY_HND *hnd)
5114 {
5115         DEBUG(5, ("init_samr_q_delete_dom_user\n"));
5116
5117         q_c->user_pol = *hnd;
5118 }
5119
5120 /*******************************************************************
5121 reads or writes a structure.
5122 ********************************************************************/
5123
5124 BOOL samr_io_q_delete_dom_user(const char *desc, SAMR_Q_DELETE_DOM_USER * q_u,
5125                                prs_struct *ps, int depth)
5126 {
5127         if (q_u == NULL)
5128                 return False;
5129
5130         prs_debug(ps, depth, desc, "samr_io_q_delete_dom_user");
5131         depth++;
5132
5133         if(!prs_align(ps))
5134                 return False;
5135
5136         if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
5137                 return False;
5138
5139         return True;
5140 }
5141
5142 /*******************************************************************
5143 reads or writes a structure.
5144 ********************************************************************/
5145
5146 BOOL samr_io_r_delete_dom_user(const char *desc, SAMR_R_DELETE_DOM_USER * r_u,
5147                                prs_struct *ps, int depth)
5148 {
5149         if (r_u == NULL)
5150                 return False;
5151
5152         prs_debug(ps, depth, desc, "samr_io_r_delete_dom_user");
5153         depth++;
5154
5155         if(!prs_align(ps))
5156                 return False;
5157
5158         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
5159                 return False;
5160         if(!prs_ntstatus("status", ps, depth, &r_u->status))
5161                 return False;
5162
5163         return True;
5164 }
5165
5166 /*******************************************************************
5167 reads or writes a structure.
5168 ********************************************************************/
5169
5170 void init_samr_q_open_user(SAMR_Q_OPEN_USER * q_u,
5171                            POLICY_HND *pol,
5172                            uint32 access_mask, uint32 rid)
5173 {
5174         DEBUG(5, ("samr_init_samr_q_open_user\n"));
5175
5176         q_u->domain_pol = *pol;
5177         q_u->access_mask = access_mask;
5178         q_u->user_rid = rid;
5179 }
5180
5181 /*******************************************************************
5182 reads or writes a structure.
5183 ********************************************************************/
5184
5185 BOOL samr_io_q_open_user(const char *desc, SAMR_Q_OPEN_USER * q_u,
5186                          prs_struct *ps, int depth)
5187 {
5188         if (q_u == NULL)
5189                 return False;
5190
5191         prs_debug(ps, depth, desc, "samr_io_q_open_user");
5192         depth++;
5193
5194         if(!prs_align(ps))
5195                 return False;
5196
5197         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
5198                 return False;
5199
5200         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
5201                 return False;
5202         if(!prs_uint32("user_rid ", ps, depth, &q_u->user_rid))
5203                 return False;
5204
5205         return True;
5206 }
5207
5208 /*******************************************************************
5209 reads or writes a structure.
5210 ********************************************************************/
5211
5212 BOOL samr_io_r_open_user(const char *desc, SAMR_R_OPEN_USER * r_u,
5213                          prs_struct *ps, int depth)
5214 {
5215         if (r_u == NULL)
5216                 return False;
5217
5218         prs_debug(ps, depth, desc, "samr_io_r_open_user");
5219         depth++;
5220
5221         if(!prs_align(ps))
5222                 return False;
5223
5224         if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
5225                 return False;
5226
5227         if(!prs_ntstatus("status", ps, depth, &r_u->status))
5228                 return False;
5229
5230         return True;
5231 }
5232
5233
5234 /*******************************************************************
5235 reads or writes a structure.
5236 ********************************************************************/
5237
5238 void init_samr_q_create_user(SAMR_Q_CREATE_USER * q_u,
5239                              POLICY_HND *pol,
5240                              const char *name,
5241                              uint32 acb_info, uint32 access_mask)
5242 {
5243         DEBUG(5, ("samr_init_samr_q_create_user\n"));
5244
5245         q_u->domain_pol = *pol;
5246
5247         init_unistr2(&q_u->uni_name, name, UNI_FLAGS_NONE);
5248         init_uni_hdr(&q_u->hdr_name, &q_u->uni_name);
5249
5250         q_u->acb_info = acb_info;
5251         q_u->access_mask = access_mask;
5252 }
5253
5254 /*******************************************************************
5255 reads or writes a structure.
5256 ********************************************************************/
5257
5258 BOOL samr_io_q_create_user(const char *desc, SAMR_Q_CREATE_USER * q_u,
5259                            prs_struct *ps, int depth)
5260 {
5261         if (q_u == NULL)
5262                 return False;
5263
5264         prs_debug(ps, depth, desc, "samr_io_q_create_user");
5265         depth++;
5266
5267         if(!prs_align(ps))
5268                 return False;
5269
5270         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
5271                 return False;
5272
5273         if(!smb_io_unihdr("hdr_name", &q_u->hdr_name, ps, depth))
5274                 return False;
5275         if(!smb_io_unistr2("uni_name", &q_u->uni_name, q_u->hdr_name.buffer, ps, depth))
5276                 return False;
5277
5278         if(!prs_align(ps))
5279                 return False;
5280         if(!prs_uint32("acb_info   ", ps, depth, &q_u->acb_info))
5281                 return False;
5282         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
5283                 return False;
5284
5285         return True;
5286 }
5287
5288 /*******************************************************************
5289 reads or writes a structure.
5290 ********************************************************************/
5291
5292 BOOL samr_io_r_create_user(const char *desc, SAMR_R_CREATE_USER * r_u,
5293                            prs_struct *ps, int depth)
5294 {
5295         if (r_u == NULL)
5296                 return False;
5297
5298         prs_debug(ps, depth, desc, "samr_io_r_create_user");
5299         depth++;
5300
5301         if(!prs_align(ps))
5302                 return False;
5303
5304         if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
5305                 return False;
5306
5307         if(!prs_uint32("access_granted", ps, depth, &r_u->access_granted))
5308                 return False;
5309         if(!prs_uint32("user_rid ", ps, depth, &r_u->user_rid))
5310                 return False;
5311         if(!prs_ntstatus("status", ps, depth, &r_u->status))
5312                 return False;
5313
5314         return True;
5315 }
5316
5317 /*******************************************************************
5318 inits a SAMR_Q_QUERY_USERINFO structure.
5319 ********************************************************************/
5320
5321 void init_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO * q_u,
5322                                 const POLICY_HND *hnd, uint16 switch_value)
5323 {
5324         DEBUG(5, ("init_samr_q_query_userinfo\n"));
5325
5326         q_u->pol = *hnd;
5327         q_u->switch_value = switch_value;
5328 }
5329
5330 /*******************************************************************
5331 reads or writes a structure.
5332 ********************************************************************/
5333
5334 BOOL samr_io_q_query_userinfo(const char *desc, SAMR_Q_QUERY_USERINFO * q_u,
5335                               prs_struct *ps, int depth)
5336 {
5337         if (q_u == NULL)
5338                 return False;
5339
5340         prs_debug(ps, depth, desc, "samr_io_q_query_userinfo");
5341         depth++;
5342
5343         if(!prs_align(ps))
5344                 return False;
5345
5346         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
5347                 return False;
5348
5349         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value)) /* 0x0015 or 0x0011 */
5350                 return False;
5351
5352         return True;
5353 }
5354
5355 /*******************************************************************
5356 reads or writes a LOGON_HRS structure.
5357 ********************************************************************/
5358
5359 static BOOL sam_io_logon_hrs(const char *desc, LOGON_HRS * hrs,
5360                              prs_struct *ps, int depth)
5361 {
5362         if (hrs == NULL)
5363                 return False;
5364
5365         prs_debug(ps, depth, desc, "sam_io_logon_hrs");
5366         depth++;
5367
5368         if(!prs_align(ps))
5369                 return False;
5370
5371         if(!prs_uint32("maxlen", ps, depth, &hrs->max_len))
5372                 return False;
5373
5374         if(!prs_uint32("offset", ps, depth, &hrs->offset))
5375                 return False;
5376
5377         if(!prs_uint32("len  ", ps, depth, &hrs->len))
5378                 return False;
5379
5380         if (hrs->len > sizeof(hrs->hours)) {
5381                 DEBUG(3, ("sam_io_logon_hrs: truncating length from %d\n", hrs->len));
5382                 hrs->len = sizeof(hrs->hours);
5383         }
5384
5385         if(!prs_uint8s(False, "hours", ps, depth, hrs->hours, hrs->len))
5386                 return False;
5387
5388         return True;
5389 }
5390
5391 /*******************************************************************
5392 inits a SAM_USER_INFO_18 structure.
5393 ********************************************************************/
5394
5395 void init_sam_user_info18(SAM_USER_INFO_18 * usr,
5396                           const uint8 lm_pwd[16], const uint8 nt_pwd[16])
5397 {
5398         DEBUG(5, ("init_sam_user_info18\n"));
5399
5400         usr->lm_pwd_active =
5401                 memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd)) ? 1 : 0;
5402         usr->nt_pwd_active =
5403                 memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd)) ? 1 : 0;
5404 }
5405
5406 /*******************************************************************
5407 reads or writes a structure.
5408 ********************************************************************/
5409
5410 static BOOL sam_io_user_info18(const char *desc, SAM_USER_INFO_18 * u,
5411                         prs_struct *ps, int depth)
5412 {
5413         if (u == NULL)
5414                 return False;
5415
5416         prs_debug(ps, depth, desc, "samr_io_r_user_info18");
5417         depth++;
5418
5419         if(!prs_align(ps))
5420                 return False;
5421
5422         if(!prs_uint8s(False, "lm_pwd", ps, depth, u->lm_pwd, sizeof(u->lm_pwd)))
5423                 return False;
5424         if(!prs_uint8s(False, "nt_pwd", ps, depth, u->nt_pwd, sizeof(u->nt_pwd)))
5425                 return False;
5426
5427         if(!prs_uint8("lm_pwd_active", ps, depth, &u->lm_pwd_active))
5428                 return False;
5429         if(!prs_uint8("nt_pwd_active", ps, depth, &u->nt_pwd_active))
5430                 return False;
5431
5432         return True;
5433 }
5434
5435 /*******************************************************************
5436 inits a SAM_USER_INFO_7 structure.
5437 ********************************************************************/
5438
5439 void init_sam_user_info7(SAM_USER_INFO_7 * usr, const char *name)
5440 {
5441         DEBUG(5, ("init_sam_user_info7\n"));
5442
5443         init_unistr2(&usr->uni_name, name, UNI_FLAGS_NONE);     /* unicode string for name */
5444         init_uni_hdr(&usr->hdr_name, &usr->uni_name);           /* unicode header for name */
5445
5446 }
5447
5448 /*******************************************************************
5449 reads or writes a structure.
5450 ********************************************************************/
5451
5452 static BOOL sam_io_user_info7(const char *desc, SAM_USER_INFO_7 * usr,
5453                         prs_struct *ps, int depth)
5454 {
5455         if (usr == NULL)
5456                 return False;
5457
5458         prs_debug(ps, depth, desc, "samr_io_r_user_info7");
5459         depth++;
5460
5461         if(!prs_align(ps))
5462                 return False;
5463
5464         if(!smb_io_unihdr("unihdr", &usr->hdr_name, ps, depth))
5465                 return False;
5466
5467         if(!smb_io_unistr2("unistr2", &usr->uni_name, True, ps, depth))
5468                 return False;
5469
5470         return True;
5471 }
5472
5473 /*******************************************************************
5474 inits a SAM_USER_INFO_9 structure.
5475 ********************************************************************/
5476
5477 void init_sam_user_info9(SAM_USER_INFO_9 * usr, uint32 rid_group)
5478 {
5479         DEBUG(5, ("init_sam_user_info9\n"));
5480
5481         usr->rid_group = rid_group;
5482 }
5483
5484 /*******************************************************************
5485 reads or writes a structure.
5486 ********************************************************************/
5487
5488 static BOOL sam_io_user_info9(const char *desc, SAM_USER_INFO_9 * usr,
5489                         prs_struct *ps, int depth)
5490 {
5491         if (usr == NULL)
5492                 return False;
5493
5494         prs_debug(ps, depth, desc, "samr_io_r_user_info9");
5495         depth++;
5496
5497         if(!prs_align(ps))
5498                 return False;
5499
5500         if(!prs_uint32("rid_group", ps, depth, &usr->rid_group))
5501                 return False;
5502
5503         return True;
5504 }
5505
5506 /*******************************************************************
5507 inits a SAM_USER_INFO_16 structure.
5508 ********************************************************************/
5509
5510 void init_sam_user_info16(SAM_USER_INFO_16 * usr, uint32 acb_info)
5511 {
5512         DEBUG(5, ("init_sam_user_info16\n"));
5513
5514         usr->acb_info = acb_info;
5515 }
5516
5517 /*******************************************************************
5518 reads or writes a structure.
5519 ********************************************************************/
5520
5521 static BOOL sam_io_user_info16(const char *desc, SAM_USER_INFO_16 * usr,
5522                         prs_struct *ps, int depth)
5523 {
5524         if (usr == NULL)
5525                 return False;
5526
5527         prs_debug(ps, depth, desc, "samr_io_r_user_info16");
5528         depth++;
5529
5530         if(!prs_align(ps))
5531                 return False;
5532
5533         if(!prs_uint32("acb_info", ps, depth, &usr->acb_info))
5534                 return False;
5535
5536         return True;
5537 }
5538
5539 /*******************************************************************
5540 inits a SAM_USER_INFO_17 structure.
5541 ********************************************************************/
5542
5543 void init_sam_user_info17(SAM_USER_INFO_17 * usr,
5544                           NTTIME * expiry,
5545                           char *mach_acct,
5546                           uint32 rid_user, uint32 rid_group, uint16 acct_ctrl)
5547 {
5548         DEBUG(5, ("init_sam_user_info17\n"));
5549
5550         memcpy(&usr->expiry, expiry, sizeof(usr->expiry));      /* expiry time or something? */
5551         ZERO_STRUCT(usr->padding_1);    /* 0 - padding 24 bytes */
5552
5553         usr->padding_2 = 0;     /* 0 - padding 4 bytes */
5554
5555         usr->ptr_1 = 1;         /* pointer */
5556         ZERO_STRUCT(usr->padding_3);    /* 0 - padding 32 bytes */
5557         usr->padding_4 = 0;     /* 0 - padding 4 bytes */
5558
5559         usr->ptr_2 = 1;         /* pointer */
5560         usr->padding_5 = 0;     /* 0 - padding 4 bytes */
5561
5562         usr->ptr_3 = 1;         /* pointer */
5563         ZERO_STRUCT(usr->padding_6);    /* 0 - padding 32 bytes */
5564
5565         usr->rid_user = rid_user;
5566         usr->rid_group = rid_group;
5567
5568         usr->acct_ctrl = acct_ctrl;
5569         usr->unknown_3 = 0x0000;
5570
5571         usr->unknown_4 = 0x003f;        /* 0x003f      - 16 bit unknown */
5572         usr->unknown_5 = 0x003c;        /* 0x003c      - 16 bit unknown */
5573
5574         ZERO_STRUCT(usr->padding_7);    /* 0 - padding 16 bytes */
5575         usr->padding_8 = 0;     /* 0 - padding 4 bytes */
5576
5577         init_unistr2(&usr->uni_mach_acct, mach_acct, UNI_FLAGS_NONE);   /* unicode string for machine account */
5578         init_uni_hdr(&usr->hdr_mach_acct, &usr->uni_mach_acct); /* unicode header for machine account */
5579 }
5580
5581 /*******************************************************************
5582 reads or writes a structure.
5583 ********************************************************************/
5584
5585 static BOOL sam_io_user_info17(const char *desc, SAM_USER_INFO_17 * usr,
5586                         prs_struct *ps, int depth)
5587 {
5588         if (usr == NULL)
5589                 return False;
5590
5591         prs_debug(ps, depth, desc, "samr_io_r_unknown_17");
5592         depth++;
5593
5594         if(!prs_align(ps))
5595                 return False;
5596
5597         if(!prs_uint8s(False, "padding_0", ps, depth, usr->padding_0, sizeof(usr->padding_0)))
5598                 return False;
5599
5600         if(!smb_io_time("time", &usr->expiry, ps, depth))
5601                 return False;
5602
5603         if(!prs_uint8s(False, "padding_1", ps, depth, usr->padding_1, sizeof(usr->padding_1)))
5604                 return False;
5605
5606         if(!smb_io_unihdr("unihdr", &usr->hdr_mach_acct, ps, depth))
5607                 return False;
5608
5609         if(!prs_uint32("padding_2", ps, depth, &usr->padding_2))
5610                 return False;
5611
5612         if(!prs_uint32("ptr_1    ", ps, depth, &usr->ptr_1))
5613                 return False;
5614         if(!prs_uint8s(False, "padding_3", ps, depth, usr->padding_3, sizeof(usr->padding_3)))
5615                 return False;
5616
5617         if(!prs_uint32("padding_4", ps, depth, &usr->padding_4))
5618                 return False;
5619
5620         if(!prs_uint32("ptr_2    ", ps, depth, &usr->ptr_2))
5621                 return False;
5622         if(!prs_uint32("padding_5", ps, depth, &usr->padding_5))
5623                 return False;
5624
5625         if(!prs_uint32("ptr_3    ", ps, depth, &usr->ptr_3))
5626                 return False;
5627         if(!prs_uint8s(False, "padding_6", ps, depth, usr->padding_6,sizeof(usr->padding_6)))
5628                 return False;
5629
5630         if(!prs_uint32("rid_user ", ps, depth, &usr->rid_user))
5631                 return False;
5632         if(!prs_uint32("rid_group", ps, depth, &usr->rid_group))
5633                 return False;
5634         if(!prs_uint16("acct_ctrl", ps, depth, &usr->acct_ctrl))
5635                 return False;
5636         if(!prs_uint16("unknown_3", ps, depth, &usr->unknown_3))
5637                 return False;
5638         if(!prs_uint16("unknown_4", ps, depth, &usr->unknown_4))
5639                 return False;
5640         if(!prs_uint16("unknown_5", ps, depth, &usr->unknown_5))
5641                 return False;
5642
5643         if(!prs_uint8s(False, "padding_7", ps, depth, usr->padding_7, sizeof(usr->padding_7)))
5644                 return False;
5645
5646         if(!prs_uint32("padding_8", ps, depth, &(usr->padding_8)))
5647                 return False;
5648
5649         if(!smb_io_unistr2("unistr2", &usr->uni_mach_acct, True, ps, depth))
5650                 return False;
5651
5652         if(!prs_align(ps))
5653                 return False;
5654
5655         if(!prs_uint8s(False, "padding_9", ps, depth, usr->padding_9, sizeof(usr->padding_9)))
5656                 return False;
5657
5658         return True;
5659 }
5660
5661 /*************************************************************************
5662  init_sam_user_infoa
5663  *************************************************************************/
5664
5665 void init_sam_user_info24(SAM_USER_INFO_24 * usr, char newpass[516],
5666                           uint8 pw_len)
5667 {
5668         DEBUG(10, ("init_sam_user_info24:\n"));
5669         memcpy(usr->pass, newpass, sizeof(usr->pass));
5670         usr->pw_len = pw_len;
5671 }
5672
5673 /*******************************************************************
5674 reads or writes a structure.
5675 ********************************************************************/
5676
5677 static BOOL sam_io_user_info24(const char *desc, SAM_USER_INFO_24 * usr,
5678                                prs_struct *ps, int depth)
5679 {
5680         if (usr == NULL)
5681                 return False;
5682
5683         prs_debug(ps, depth, desc, "sam_io_user_info24");
5684         depth++;
5685
5686         if(!prs_align(ps))
5687                 return False;
5688
5689         if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5690                        sizeof(usr->pass)))
5691                 return False;
5692
5693         if (MARSHALLING(ps) && (usr->pw_len != 0)) {
5694                 if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5695                         return False;
5696         } else if (UNMARSHALLING(ps)) {
5697                 if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5698                         return False;
5699         }
5700
5701         return True;
5702 }
5703
5704 /*******************************************************************
5705 reads or writes a structure.
5706 ********************************************************************/
5707
5708 static BOOL sam_io_user_info26(const char *desc, SAM_USER_INFO_26 * usr,
5709                                prs_struct *ps, int depth)
5710 {
5711         if (usr == NULL)
5712                 return False;
5713
5714         prs_debug(ps, depth, desc, "sam_io_user_info26");
5715         depth++;
5716
5717         if(!prs_align(ps))
5718                 return False;
5719
5720         if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5721                        sizeof(usr->pass)))
5722                 return False;
5723
5724         if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5725                 return False;
5726
5727         return True;
5728 }
5729
5730
5731 /*************************************************************************
5732  init_sam_user_info23
5733
5734  unknown_6 = 0x0000 04ec
5735
5736  *************************************************************************/
5737
5738 void init_sam_user_info23W(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5739                         NTTIME * logoff_time,   /* all zeros */
5740                         NTTIME * kickoff_time,  /* all zeros */
5741                         NTTIME * pass_last_set_time,    /* all zeros */
5742                         NTTIME * pass_can_change_time,  /* all zeros */
5743                         NTTIME * pass_must_change_time, /* all zeros */
5744                         UNISTR2 *user_name,
5745                         UNISTR2 *full_name,
5746                         UNISTR2 *home_dir,
5747                         UNISTR2 *dir_drive,
5748                         UNISTR2 *log_scr,
5749                         UNISTR2 *prof_path,
5750                         UNISTR2 *desc,
5751                         UNISTR2 *wkstas,
5752                         UNISTR2 *unk_str,
5753                         UNISTR2 *mung_dial,
5754                         uint32 user_rid,        /* 0x0000 0000 */
5755                         uint32 group_rid,
5756                         uint32 acb_info,
5757                         uint32 fields_present,
5758                         uint16 logon_divs,
5759                         LOGON_HRS * hrs,
5760                         uint16 bad_password_count,
5761                         uint16 logon_count,
5762                         char newpass[516])
5763 {
5764         usr->logon_time = *logon_time;  /* all zeros */
5765         usr->logoff_time = *logoff_time;        /* all zeros */
5766         usr->kickoff_time = *kickoff_time;      /* all zeros */
5767         usr->pass_last_set_time = *pass_last_set_time;  /* all zeros */
5768         usr->pass_can_change_time = *pass_can_change_time;      /* all zeros */
5769         usr->pass_must_change_time = *pass_must_change_time;    /* all zeros */
5770
5771         ZERO_STRUCT(usr->nt_pwd);
5772         ZERO_STRUCT(usr->lm_pwd);
5773
5774         usr->user_rid = user_rid;       /* 0x0000 0000 */
5775         usr->group_rid = group_rid;
5776         usr->acb_info = acb_info;
5777         usr->fields_present = fields_present;   /* 09f8 27fa */
5778
5779         usr->logon_divs = logon_divs;   /* should be 168 (hours/week) */
5780         usr->ptr_logon_hrs = hrs ? 1 : 0;
5781
5782         if (nt_time_is_zero(pass_must_change_time)) {
5783                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5784         } else {
5785                 usr->passmustchange=0;
5786         }
5787
5788         ZERO_STRUCT(usr->padding1);
5789         ZERO_STRUCT(usr->padding2);
5790
5791         usr->bad_password_count = bad_password_count;
5792         usr->logon_count = logon_count;
5793
5794         memcpy(usr->pass, newpass, sizeof(usr->pass));
5795
5796         copy_unistr2(&usr->uni_user_name, user_name);
5797         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5798
5799         copy_unistr2(&usr->uni_full_name, full_name);
5800         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5801
5802         copy_unistr2(&usr->uni_home_dir, home_dir);
5803         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5804
5805         copy_unistr2(&usr->uni_dir_drive, dir_drive);
5806         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5807
5808         copy_unistr2(&usr->uni_logon_script, log_scr);
5809         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5810
5811         copy_unistr2(&usr->uni_profile_path, prof_path);
5812         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5813
5814         copy_unistr2(&usr->uni_acct_desc, desc);
5815         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5816
5817         copy_unistr2(&usr->uni_workstations, wkstas);
5818         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5819
5820         copy_unistr2(&usr->uni_comment, unk_str);
5821         init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
5822
5823         copy_unistr2(&usr->uni_munged_dial, mung_dial);
5824         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5825
5826         if (hrs) {
5827                 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5828         } else {
5829                 ZERO_STRUCT(usr->logon_hrs);
5830         }
5831 }
5832
5833 /*************************************************************************
5834  init_sam_user_info23
5835
5836  unknown_6 = 0x0000 04ec
5837
5838  *************************************************************************/
5839
5840 void init_sam_user_info23A(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5841                            NTTIME * logoff_time,        /* all zeros */
5842                            NTTIME * kickoff_time,       /* all zeros */
5843                            NTTIME * pass_last_set_time, /* all zeros */
5844                            NTTIME * pass_can_change_time,       /* all zeros */
5845                            NTTIME * pass_must_change_time,      /* all zeros */
5846                            char *user_name,     /* NULL */
5847                            char *full_name,
5848                            char *home_dir, char *dir_drive, char *log_scr,
5849                            char *prof_path, const char *desc, char *wkstas,
5850                            char *unk_str, char *mung_dial, uint32 user_rid,     /* 0x0000 0000 */
5851                            uint32 group_rid, uint32 acb_info,
5852                            uint32 fields_present, uint16 logon_divs,
5853                            LOGON_HRS * hrs, uint16 bad_password_count, uint16 logon_count,
5854                            char newpass[516])
5855 {
5856         DATA_BLOB blob = base64_decode_data_blob(mung_dial);
5857
5858         usr->logon_time = *logon_time;  /* all zeros */
5859         usr->logoff_time = *logoff_time;        /* all zeros */
5860         usr->kickoff_time = *kickoff_time;      /* all zeros */
5861         usr->pass_last_set_time = *pass_last_set_time;  /* all zeros */
5862         usr->pass_can_change_time = *pass_can_change_time;      /* all zeros */
5863         usr->pass_must_change_time = *pass_must_change_time;    /* all zeros */
5864
5865         ZERO_STRUCT(usr->nt_pwd);
5866         ZERO_STRUCT(usr->lm_pwd);
5867
5868         usr->user_rid = user_rid;       /* 0x0000 0000 */
5869         usr->group_rid = group_rid;
5870         usr->acb_info = acb_info;
5871         usr->fields_present = fields_present;   /* 09f8 27fa */
5872
5873         usr->logon_divs = logon_divs;   /* should be 168 (hours/week) */
5874         usr->ptr_logon_hrs = hrs ? 1 : 0;
5875
5876         if (nt_time_is_zero(pass_must_change_time)) {
5877                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5878         } else {
5879                 usr->passmustchange=0;
5880         }
5881
5882         ZERO_STRUCT(usr->padding1);
5883         ZERO_STRUCT(usr->padding2);
5884
5885         usr->bad_password_count = bad_password_count;
5886         usr->logon_count = logon_count;
5887
5888         memcpy(usr->pass, newpass, sizeof(usr->pass));
5889
5890         init_unistr2(&usr->uni_user_name, user_name, UNI_FLAGS_NONE);
5891         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5892
5893         init_unistr2(&usr->uni_full_name, full_name, UNI_FLAGS_NONE);
5894         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5895
5896         init_unistr2(&usr->uni_home_dir, home_dir, UNI_FLAGS_NONE);
5897         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5898
5899         init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_FLAGS_NONE);
5900         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5901
5902         init_unistr2(&usr->uni_logon_script, log_scr, UNI_FLAGS_NONE);
5903         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5904
5905         init_unistr2(&usr->uni_profile_path, prof_path, UNI_FLAGS_NONE);
5906         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5907
5908         init_unistr2(&usr->uni_acct_desc, desc, UNI_FLAGS_NONE);
5909         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5910
5911         init_unistr2(&usr->uni_workstations, wkstas, UNI_FLAGS_NONE);
5912         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5913
5914         init_unistr2(&usr->uni_comment, unk_str, UNI_FLAGS_NONE);
5915         init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
5916
5917         init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
5918         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5919
5920         data_blob_free(&blob);
5921
5922         if (hrs) {
5923                 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5924         } else {
5925                 ZERO_STRUCT(usr->logon_hrs);
5926         }
5927 }
5928
5929 /*******************************************************************
5930 reads or writes a structure.
5931 ********************************************************************/
5932
5933 static BOOL sam_io_user_info23(const char *desc, SAM_USER_INFO_23 * usr,
5934                                prs_struct *ps, int depth)
5935 {
5936         if (usr == NULL)
5937                 return False;
5938
5939         prs_debug(ps, depth, desc, "sam_io_user_info23");
5940         depth++;
5941
5942         if(!prs_align(ps))
5943                 return False;
5944
5945         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
5946                 return False;
5947         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
5948                 return False;
5949         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
5950                 return False;
5951         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps, depth))
5952                 return False;
5953         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
5954                 return False;
5955         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
5956                 return False;
5957
5958         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth))  /* username unicode string header */
5959                 return False;
5960         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth))  /* user's full name unicode string header */
5961                 return False;
5962         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth))   /* home directory unicode string header */
5963                 return False;
5964         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth))  /* home directory drive */
5965                 return False;
5966         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth))       /* logon script unicode string header */
5967                 return False;
5968         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth))       /* profile path unicode string header */
5969                 return False;
5970         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth))  /* account desc */
5971                 return False;
5972         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth))       /* wkstas user can log on from */
5973                 return False;
5974         if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth))        /* unknown string */
5975                 return False;
5976         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
5977                 return False;
5978
5979         if(!prs_uint8s(False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
5980                 return False;
5981         if(!prs_uint8s(False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
5982                 return False;
5983
5984         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))    /* User ID */
5985                 return False;
5986         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))   /* Group ID */
5987                 return False;
5988         if(!prs_uint32("acb_info      ", ps, depth, &usr->acb_info))
5989                 return False;
5990
5991         if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
5992                 return False;
5993         if(!prs_uint16("logon_divs    ", ps, depth, &usr->logon_divs))  /* logon divisions per week */
5994                 return False;
5995         if(!prs_align(ps))
5996                 return False;
5997         if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
5998                 return False;
5999
6000         if(!prs_uint16("bad_password_count     ", ps, depth, &usr->bad_password_count))
6001                 return False;
6002         if(!prs_uint16("logon_count     ", ps, depth, &usr->logon_count))
6003                 return False;
6004
6005         if(!prs_uint8s(False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6006                 return False;
6007         if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6008                 return False;
6009         if(!prs_uint8("padding2       ", ps, depth, &usr->padding2))
6010                 return False;
6011
6012
6013         if(!prs_uint8s(False, "password      ", ps, depth, usr->pass, sizeof(usr->pass)))
6014                 return False;
6015
6016         /* here begins pointed-to data */
6017
6018         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth))      /* username unicode string */
6019                 return False;
6020
6021         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))      /* user's full name unicode string */
6022                 return False;
6023
6024         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))        /* home directory unicode string */
6025                 return False;
6026
6027         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))      /* home directory drive unicode string */
6028                 return False;
6029
6030         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))        /* logon script unicode string */
6031                 return False;
6032
6033         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))        /* profile path unicode string */
6034                 return False;
6035
6036         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))      /* user desc unicode string */
6037                 return False;
6038
6039         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))        /* worksations user can log on from */
6040                 return False;
6041
6042         if(!smb_io_unistr2("uni_comment ", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth))      /* unknown string */
6043                 return False;
6044
6045         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
6046                 return False;
6047
6048         /* ok, this is only guess-work (as usual) */
6049         if (usr->ptr_logon_hrs) {
6050                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6051                         return False;
6052         }
6053
6054         return True;
6055 }
6056
6057 /*******************************************************************
6058  reads or writes a structure.
6059  NB. This structure is *definately* incorrect. It's my best guess
6060  currently for W2K SP2. The password field is encrypted in a different
6061  way than normal... And there are definately other problems. JRA.
6062 ********************************************************************/
6063
6064 static BOOL sam_io_user_info25(const char *desc, SAM_USER_INFO_25 * usr, prs_struct *ps, int depth)
6065 {
6066         if (usr == NULL)
6067                 return False;
6068
6069         prs_debug(ps, depth, desc, "sam_io_user_info25");
6070         depth++;
6071
6072         if(!prs_align(ps))
6073                 return False;
6074
6075         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
6076                 return False;
6077         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
6078                 return False;
6079         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
6080                 return False;
6081         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps, depth))
6082                 return False;
6083         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
6084                 return False;
6085         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
6086                 return False;
6087
6088         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth))  /* username unicode string header */
6089                 return False;
6090         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth))  /* user's full name unicode string header */
6091                 return False;
6092         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth))   /* home directory unicode string header */
6093                 return False;
6094         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth))  /* home directory drive */
6095                 return False;
6096         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth))       /* logon script unicode string header */
6097                 return False;
6098         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth))       /* profile path unicode string header */
6099                 return False;
6100         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth))  /* account desc */
6101                 return False;
6102         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth))       /* wkstas user can log on from */
6103                 return False;
6104         if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth))        /* unknown string */
6105                 return False;
6106         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
6107                 return False;
6108
6109         if(!prs_uint8s(False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6110                 return False;
6111         if(!prs_uint8s(False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6112                 return False;
6113
6114         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))    /* User ID */
6115                 return False;
6116         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))   /* Group ID */
6117                 return False;
6118         if(!prs_uint32("acb_info      ", ps, depth, &usr->acb_info))
6119                 return False;
6120         if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6121                 return False;
6122
6123         if(!prs_uint32s(False, "unknown_5      ", ps, depth, usr->unknown_5, 5))
6124                 return False;
6125
6126         if(!prs_uint8s(False, "password      ", ps, depth, usr->pass, sizeof(usr->pass)))
6127                 return False;
6128
6129         /* here begins pointed-to data */
6130
6131         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth))      /* username unicode string */
6132                 return False;
6133
6134         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))      /* user's full name unicode string */
6135                 return False;
6136
6137         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))        /* home directory unicode string */
6138                 return False;
6139
6140         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))      /* home directory drive unicode string */
6141                 return False;
6142
6143         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))        /* logon script unicode string */
6144                 return False;
6145
6146         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))        /* profile path unicode string */
6147                 return False;
6148
6149         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))      /* user desc unicode string */
6150                 return False;
6151
6152         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))        /* worksations user can log on from */
6153                 return False;
6154
6155         if(!smb_io_unistr2("uni_comment ", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth))      /* unknown string */
6156                 return False;
6157
6158         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
6159                 return False;
6160
6161 #if 0 /* JRA - unknown... */
6162         /* ok, this is only guess-work (as usual) */
6163         if (usr->ptr_logon_hrs) {
6164                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6165                         return False;
6166         }
6167 #endif
6168
6169         return True;
6170 }
6171
6172
6173 /*************************************************************************
6174  init_sam_user_info21W
6175
6176  unknown_6 = 0x0000 04ec
6177
6178  *************************************************************************/
6179
6180 void init_sam_user_info21W(SAM_USER_INFO_21 * usr,
6181                            NTTIME * logon_time,
6182                            NTTIME * logoff_time,
6183                            NTTIME * kickoff_time,
6184                            NTTIME * pass_last_set_time,
6185                            NTTIME * pass_can_change_time,
6186                            NTTIME * pass_must_change_time,
6187                            UNISTR2 *user_name,
6188                            UNISTR2 *full_name,
6189                            UNISTR2 *home_dir,
6190                            UNISTR2 *dir_drive,
6191                            UNISTR2 *log_scr,
6192                            UNISTR2 *prof_path,
6193                            UNISTR2 *desc,
6194                            UNISTR2 *wkstas,
6195                            UNISTR2 *unk_str,
6196                            UNISTR2 *mung_dial,
6197                            uchar lm_pwd[16],
6198                            uchar nt_pwd[16],
6199                            uint32 user_rid,
6200                            uint32 group_rid,
6201                            uint32 acb_info,
6202                            uint32 fields_present,
6203                            uint16 logon_divs,
6204                            LOGON_HRS * hrs,
6205                            uint16 bad_password_count,
6206                            uint16 logon_count)
6207 {
6208         usr->logon_time = *logon_time;
6209         usr->logoff_time = *logoff_time;
6210         usr->kickoff_time = *kickoff_time;
6211         usr->pass_last_set_time = *pass_last_set_time;
6212         usr->pass_can_change_time = *pass_can_change_time;
6213         usr->pass_must_change_time = *pass_must_change_time;
6214
6215         memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd));
6216         memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd));
6217
6218         usr->user_rid = user_rid;
6219         usr->group_rid = group_rid;
6220         usr->acb_info = acb_info;
6221         usr->fields_present = fields_present;   /* 0x00ff ffff */
6222
6223         usr->logon_divs = logon_divs;   /* should be 168 (hours/week) */
6224         usr->ptr_logon_hrs = hrs ? 1 : 0;
6225         usr->bad_password_count = bad_password_count;
6226         usr->logon_count = logon_count;
6227
6228         if (nt_time_is_zero(pass_must_change_time)) {
6229                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6230         } else {
6231                 usr->passmustchange=0;
6232         }
6233
6234         ZERO_STRUCT(usr->padding1);
6235         ZERO_STRUCT(usr->padding2);
6236
6237         copy_unistr2(&usr->uni_user_name, user_name);
6238         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6239
6240         copy_unistr2(&usr->uni_full_name, full_name);
6241         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6242
6243         copy_unistr2(&usr->uni_home_dir, home_dir);
6244         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6245
6246         copy_unistr2(&usr->uni_dir_drive, dir_drive);
6247         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6248
6249         copy_unistr2(&usr->uni_logon_script, log_scr);
6250         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6251
6252         copy_unistr2(&usr->uni_profile_path, prof_path);
6253         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6254
6255         copy_unistr2(&usr->uni_acct_desc, desc);
6256         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6257
6258         copy_unistr2(&usr->uni_workstations, wkstas);
6259         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6260
6261         copy_unistr2(&usr->uni_comment, unk_str);
6262         init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
6263
6264         copy_unistr2(&usr->uni_munged_dial, mung_dial);
6265         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6266
6267         if (hrs) {
6268                 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
6269         } else {
6270                 ZERO_STRUCT(usr->logon_hrs);
6271         }
6272 }
6273
6274 /*************************************************************************
6275  init_sam_user_info21
6276
6277  unknown_6 = 0x0000 04ec
6278
6279  *************************************************************************/
6280
6281 NTSTATUS init_sam_user_info21A(SAM_USER_INFO_21 *usr, struct samu *pw, DOM_SID *domain_sid)
6282 {
6283         NTTIME          logon_time, logoff_time, kickoff_time,
6284                         pass_last_set_time, pass_can_change_time,
6285                         pass_must_change_time;
6286
6287         time_t must_change_time;
6288         const char*             user_name = pdb_get_username(pw);
6289         const char*             full_name = pdb_get_fullname(pw);
6290         const char*             home_dir  = pdb_get_homedir(pw);
6291         const char*             dir_drive = pdb_get_dir_drive(pw);
6292         const char*             logon_script = pdb_get_logon_script(pw);
6293         const char*             profile_path = pdb_get_profile_path(pw);
6294         const char*             description = pdb_get_acct_desc(pw);
6295         const char*             workstations = pdb_get_workstations(pw);
6296         const char*             munged_dial = pdb_get_munged_dial(pw);
6297         DATA_BLOB               munged_dial_blob;
6298
6299         uint32 user_rid;
6300         const DOM_SID *user_sid;
6301
6302         uint32 group_rid;
6303         const DOM_SID *group_sid;
6304
6305         if (munged_dial) {
6306                 munged_dial_blob = base64_decode_data_blob(munged_dial);
6307         } else {
6308                 munged_dial_blob = data_blob(NULL, 0);
6309         }
6310
6311         /* Create NTTIME structs */
6312         unix_to_nt_time (&logon_time,           pdb_get_logon_time(pw));
6313         unix_to_nt_time (&logoff_time,  pdb_get_logoff_time(pw));
6314         unix_to_nt_time (&kickoff_time,         pdb_get_kickoff_time(pw));
6315         unix_to_nt_time (&pass_last_set_time, pdb_get_pass_last_set_time(pw));
6316         unix_to_nt_time (&pass_can_change_time,pdb_get_pass_can_change_time(pw));
6317         must_change_time = pdb_get_pass_must_change_time(pw);
6318         if (must_change_time == get_time_t_max())
6319                 unix_to_nt_time_abs(&pass_must_change_time, must_change_time);
6320         else
6321                 unix_to_nt_time(&pass_must_change_time, must_change_time);
6322
6323         /* structure assignment */
6324         usr->logon_time            = logon_time;
6325         usr->logoff_time           = logoff_time;
6326         usr->kickoff_time          = kickoff_time;
6327         usr->pass_last_set_time    = pass_last_set_time;
6328         usr->pass_can_change_time  = pass_can_change_time;
6329         usr->pass_must_change_time = pass_must_change_time;
6330
6331         ZERO_STRUCT(usr->nt_pwd);
6332         ZERO_STRUCT(usr->lm_pwd);
6333
6334         user_sid = pdb_get_user_sid(pw);
6335
6336         if (!sid_peek_check_rid(domain_sid, user_sid, &user_rid)) {
6337                 fstring user_sid_string;
6338                 fstring domain_sid_string;
6339                 DEBUG(0, ("init_sam_user_info_21A: User %s has SID %s, \nwhich conflicts with "
6340                           "the domain sid %s.  Failing operation.\n",
6341                           user_name,
6342                           sid_to_string(user_sid_string, user_sid),
6343                           sid_to_string(domain_sid_string, domain_sid)));
6344                 data_blob_free(&munged_dial_blob);
6345                 return NT_STATUS_UNSUCCESSFUL;
6346         }
6347
6348         become_root();
6349         group_sid = pdb_get_group_sid(pw);
6350         unbecome_root();
6351
6352         if (!sid_peek_check_rid(domain_sid, group_sid, &group_rid)) {
6353                 fstring group_sid_string;
6354                 fstring domain_sid_string;
6355                 DEBUG(0, ("init_sam_user_info_21A: User %s has Primary Group SID %s, \n"
6356                           "which conflicts with the domain sid %s.  Failing operation.\n",
6357                           user_name,
6358                           sid_to_string(group_sid_string, group_sid),
6359                           sid_to_string(domain_sid_string, domain_sid)));
6360                 data_blob_free(&munged_dial_blob);
6361                 return NT_STATUS_UNSUCCESSFUL;
6362         }
6363
6364         usr->user_rid  = user_rid;
6365         usr->group_rid = group_rid;
6366         usr->acb_info  = pdb_get_acct_ctrl(pw);
6367
6368         /*
6369           Look at a user on a real NT4 PDC with usrmgr, press
6370           'ok'. Then you will see that fields_present is set to
6371           0x08f827fa. Look at the user immediately after that again,
6372           and you will see that 0x00fffff is returned. This solves
6373           the problem that you get access denied after having looked
6374           at the user.
6375           -- Volker
6376         */
6377         usr->fields_present = pdb_build_fields_present(pw);
6378
6379         usr->logon_divs = pdb_get_logon_divs(pw);
6380         usr->ptr_logon_hrs = pdb_get_hours(pw) ? 1 : 0;
6381         usr->bad_password_count = pdb_get_bad_password_count(pw);
6382         usr->logon_count = pdb_get_logon_count(pw);
6383
6384         if (pdb_get_pass_must_change_time(pw) == 0) {
6385                 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6386         } else {
6387                 usr->passmustchange=0;
6388         }
6389
6390         ZERO_STRUCT(usr->padding1);
6391         ZERO_STRUCT(usr->padding2);
6392
6393         init_unistr2(&usr->uni_user_name, user_name, UNI_STR_TERMINATE);
6394         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6395
6396         init_unistr2(&usr->uni_full_name, full_name, UNI_STR_TERMINATE);
6397         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6398
6399         init_unistr2(&usr->uni_home_dir, home_dir, UNI_STR_TERMINATE);
6400         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6401
6402         init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_STR_TERMINATE);
6403         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6404
6405         init_unistr2(&usr->uni_logon_script, logon_script, UNI_STR_TERMINATE);
6406         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6407
6408         init_unistr2(&usr->uni_profile_path, profile_path, UNI_STR_TERMINATE);
6409         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6410
6411         init_unistr2(&usr->uni_acct_desc, description, UNI_STR_TERMINATE);
6412         init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6413
6414         init_unistr2(&usr->uni_workstations, workstations, UNI_STR_TERMINATE);
6415         init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6416
6417         init_unistr2(&usr->uni_comment, NULL, UNI_STR_TERMINATE);
6418         init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
6419
6420         init_unistr2_from_datablob(&usr->uni_munged_dial, &munged_dial_blob);
6421         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6422         data_blob_free(&munged_dial_blob);
6423
6424         if (pdb_get_hours(pw)) {
6425                 usr->logon_hrs.max_len = 1260;
6426                 usr->logon_hrs.offset = 0;
6427                 usr->logon_hrs.len = pdb_get_hours_len(pw);
6428                 memcpy(&usr->logon_hrs.hours, pdb_get_hours(pw), MAX_HOURS_LEN);
6429         } else {
6430                 usr->logon_hrs.max_len = 1260;
6431                 usr->logon_hrs.offset = 0;
6432                 usr->logon_hrs.len = 0;
6433                 memset(&usr->logon_hrs, 0xff, sizeof(usr->logon_hrs));
6434         }
6435
6436         return NT_STATUS_OK;
6437 }
6438
6439 /*******************************************************************
6440 reads or writes a structure.
6441 ********************************************************************/
6442
6443 static BOOL sam_io_user_info21(const char *desc, SAM_USER_INFO_21 * usr,
6444                         prs_struct *ps, int depth)
6445 {
6446         if (usr == NULL)
6447                 return False;
6448
6449         prs_debug(ps, depth, desc, "sam_io_user_info21");
6450         depth++;
6451
6452         if(!prs_align(ps))
6453                 return False;
6454
6455         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
6456                 return False;
6457         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
6458                 return False;
6459         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps,depth))
6460                 return False;
6461         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
6462                 return False;
6463         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps,depth))
6464                 return False;
6465         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time,  ps, depth))
6466                 return False;
6467
6468         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth))  /* username unicode string header */
6469                 return False;
6470         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth))  /* user's full name unicode string header */
6471                 return False;
6472         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth))   /* home directory unicode string header */
6473                 return False;
6474         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth))  /* home directory drive */
6475                 return False;
6476         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth))       /* logon script unicode string header */
6477                 return False;
6478         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth))       /* profile path unicode string header */
6479                 return False;
6480         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth))  /* account desc */
6481                 return False;
6482         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth))       /* wkstas user can log on from */
6483                 return False;
6484         if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth))        /* unknown string */
6485                 return False;
6486         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
6487                 return False;
6488
6489         if(!prs_uint8s(False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6490                 return False;
6491         if(!prs_uint8s(False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6492                 return False;
6493
6494         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))    /* User ID */
6495                 return False;
6496         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))   /* Group ID */
6497                 return False;
6498         if(!prs_uint32("acb_info      ", ps, depth, &usr->acb_info))
6499                 return False;
6500
6501         if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6502                 return False;
6503         if(!prs_uint16("logon_divs    ", ps, depth, &usr->logon_divs))  /* logon divisions per week */
6504                 return False;
6505         if(!prs_align(ps))
6506                 return False;
6507         if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6508                 return False;
6509
6510         if(!prs_uint16("bad_password_count     ", ps, depth, &usr->bad_password_count))
6511                 return False;
6512         if(!prs_uint16("logon_count     ", ps, depth, &usr->logon_count))
6513                 return False;
6514
6515         if(!prs_uint8s(False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6516                 return False;
6517         if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6518                 return False;
6519         if(!prs_uint8("padding2       ", ps, depth, &usr->padding2))
6520                 return False;
6521
6522         /* here begins pointed-to data */
6523
6524         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name,usr->hdr_user_name.buffer, ps, depth))
6525                 return False;
6526         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))
6527                 return False;
6528         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))
6529                 return False;
6530         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))
6531                 return False;
6532         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))
6533                 return False;
6534         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))
6535                 return False;
6536         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))
6537                 return False;
6538         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))
6539                 return False;
6540         if(!smb_io_unistr2("uni_comment", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth))
6541                 return False;
6542         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))
6543                 return False;
6544
6545         /* ok, this is only guess-work (as usual) */
6546         if (usr->ptr_logon_hrs) {
6547                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6548                         return False;
6549         }
6550
6551         return True;
6552 }
6553
6554 void init_sam_user_info20A(SAM_USER_INFO_20 *usr, struct samu *pw)
6555 {
6556         const char *munged_dial = pdb_get_munged_dial(pw);
6557         DATA_BLOB blob;
6558
6559         if (munged_dial) {
6560                 blob = base64_decode_data_blob(munged_dial);
6561         } else {
6562                 blob = data_blob(NULL, 0);
6563         }
6564
6565         init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
6566         init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6567         data_blob_free(&blob);
6568 }
6569
6570 /*******************************************************************
6571 reads or writes a structure.
6572 ********************************************************************/
6573
6574 static BOOL sam_io_user_info20(const char *desc, SAM_USER_INFO_20 *usr,
6575                         prs_struct *ps, int depth)
6576 {
6577         if (usr == NULL)
6578                 return False;
6579
6580         prs_debug(ps, depth, desc, "sam_io_user_info20");
6581         depth++;
6582
6583         if(!prs_align(ps))
6584                 return False;
6585
6586         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth))        /* wkstas user can log on from */
6587                 return False;
6588
6589         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))   /* worksations user can log on from */
6590                 return False;
6591
6592         return True;
6593 }
6594
6595 /*******************************************************************
6596 inits a SAM_USERINFO_CTR structure.
6597 ********************************************************************/
6598
6599 NTSTATUS make_samr_userinfo_ctr_usr21(TALLOC_CTX *ctx, SAM_USERINFO_CTR * ctr,
6600                                     uint16 switch_value,
6601                                     SAM_USER_INFO_21 * usr)
6602 {
6603         DEBUG(5, ("make_samr_userinfo_ctr_usr21\n"));
6604
6605         ctr->switch_value = switch_value;
6606         ctr->info.id = NULL;
6607
6608         switch (switch_value) {
6609         case 16:
6610                 ctr->info.id16 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_16);
6611                 if (ctr->info.id16 == NULL)
6612                         return NT_STATUS_NO_MEMORY;
6613
6614                 init_sam_user_info16(ctr->info.id16, usr->acb_info);
6615                 break;
6616 #if 0
6617 /* whoops - got this wrong.  i think.  or don't understand what's happening. */
6618         case 17:
6619                 {
6620                         NTTIME expire;
6621                         info = (void *)&id11;
6622
6623                         expire.low = 0xffffffff;
6624                         expire.high = 0x7fffffff;
6625
6626                         ctr->info.id = TALLOC_ZERO_P(ctx,SAM_USER_INFO_17);
6627                         init_sam_user_info11(ctr->info.id17, &expire,
6628                                              "BROOKFIELDS$",    /* name */
6629                                              0x03ef,    /* user rid */
6630                                              0x201,     /* group rid */
6631                                              0x0080);   /* acb info */
6632
6633                         break;
6634                 }
6635 #endif
6636         case 18:
6637                 ctr->info.id18 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_18);
6638                 if (ctr->info.id18 == NULL)
6639                         return NT_STATUS_NO_MEMORY;
6640
6641                 init_sam_user_info18(ctr->info.id18, usr->lm_pwd, usr->nt_pwd);
6642                 break;
6643         case 21:
6644                 {
6645                         SAM_USER_INFO_21 *cusr;
6646                         cusr = TALLOC_ZERO_P(ctx,SAM_USER_INFO_21);
6647                         ctr->info.id21 = cusr;
6648                         if (ctr->info.id21 == NULL)
6649                                 return NT_STATUS_NO_MEMORY;
6650                         memcpy(cusr, usr, sizeof(*usr));
6651                         memset(cusr->lm_pwd, 0, sizeof(cusr->lm_pwd));
6652                         memset(cusr->nt_pwd, 0, sizeof(cusr->nt_pwd));
6653                         break;
6654                 }
6655         default:
6656                 DEBUG(4,("make_samr_userinfo_ctr: unsupported info\n"));
6657                 return NT_STATUS_INVALID_INFO_CLASS;
6658         }
6659
6660         return NT_STATUS_OK;
6661 }
6662
6663 /*******************************************************************
6664 inits a SAM_USERINFO_CTR structure.
6665 ********************************************************************/
6666
6667 static void init_samr_userinfo_ctr(SAM_USERINFO_CTR * ctr, DATA_BLOB *sess_key,
6668                                    uint16 switch_value, void *info)
6669 {
6670         DEBUG(5, ("init_samr_userinfo_ctr\n"));
6671
6672         ctr->switch_value = switch_value;
6673         ctr->info.id = info;
6674
6675         switch (switch_value) {
6676         case 0x18:
6677                 SamOEMhashBlob(ctr->info.id24->pass, 516, sess_key);
6678                 dump_data(100, sess_key->data, sess_key->length);
6679                 dump_data(100, ctr->info.id24->pass, 516);
6680                 break;
6681         case 0x17:
6682                 SamOEMhashBlob(ctr->info.id23->pass, 516, sess_key);
6683                 dump_data(100, sess_key->data, sess_key->length);
6684                 dump_data(100, ctr->info.id23->pass, 516);
6685                 break;
6686         case 0x07:
6687                 break;
6688         default:
6689                 DEBUG(4,("init_samr_userinfo_ctr: unsupported switch level: %d\n", switch_value));
6690         }
6691 }
6692
6693 /*******************************************************************
6694 reads or writes a structure.
6695 ********************************************************************/
6696
6697 static BOOL samr_io_userinfo_ctr(const char *desc, SAM_USERINFO_CTR **ppctr,
6698                                  prs_struct *ps, int depth)
6699 {
6700         BOOL ret;
6701         SAM_USERINFO_CTR *ctr;
6702
6703         prs_debug(ps, depth, desc, "samr_io_userinfo_ctr");
6704         depth++;
6705
6706         if (UNMARSHALLING(ps)) {
6707                 ctr = PRS_ALLOC_MEM(ps,SAM_USERINFO_CTR,1);
6708                 if (ctr == NULL)
6709                         return False;
6710                 *ppctr = ctr;
6711         } else {
6712                 ctr = *ppctr;
6713         }
6714
6715         /* lkclXXXX DO NOT ALIGN BEFORE READING SWITCH VALUE! */
6716
6717         if(!prs_uint16("switch_value", ps, depth, &ctr->switch_value))
6718                 return False;
6719         if(!prs_align(ps))
6720                 return False;
6721
6722         ret = False;
6723
6724         switch (ctr->switch_value) {
6725         case 7:
6726                 if (UNMARSHALLING(ps))
6727                         ctr->info.id7 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_7,1);
6728                 if (ctr->info.id7 == NULL) {
6729                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6730                         return False;
6731                 }
6732                 ret = sam_io_user_info7("", ctr->info.id7, ps, depth);
6733                 break;
6734         case 9:
6735                 if (UNMARSHALLING(ps))
6736                         ctr->info.id9 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_9,1);
6737                 if (ctr->info.id9 == NULL) {
6738                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6739                         return False;
6740                 }
6741                 ret = sam_io_user_info9("", ctr->info.id9, ps, depth);
6742                 break;
6743         case 16:
6744                 if (UNMARSHALLING(ps))
6745                         ctr->info.id16 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_16,1);
6746                 if (ctr->info.id16 == NULL) {
6747                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6748                         return False;
6749                 }
6750                 ret = sam_io_user_info16("", ctr->info.id16, ps, depth);
6751                 break;
6752         case 17:
6753                 if (UNMARSHALLING(ps))
6754                         ctr->info.id17 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_17,1);
6755
6756                 if (ctr->info.id17 == NULL) {
6757                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6758                         return False;
6759                 }
6760                 ret = sam_io_user_info17("", ctr->info.id17, ps, depth);
6761                 break;
6762         case 18:
6763                 if (UNMARSHALLING(ps))
6764                         ctr->info.id18 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_18,1);
6765
6766                 if (ctr->info.id18 == NULL) {
6767                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6768                         return False;
6769                 }
6770                 ret = sam_io_user_info18("", ctr->info.id18, ps, depth);
6771                 break;
6772         case 20:
6773                 if (UNMARSHALLING(ps))
6774                         ctr->info.id20 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_20,1);
6775
6776                 if (ctr->info.id20 == NULL) {
6777                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6778                         return False;
6779                 }
6780                 ret = sam_io_user_info20("", ctr->info.id20, ps, depth);
6781                 break;
6782         case 21:
6783                 if (UNMARSHALLING(ps))
6784                         ctr->info.id21 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_21,1);
6785
6786                 if (ctr->info.id21 == NULL) {
6787                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6788                         return False;
6789                 }
6790                 ret = sam_io_user_info21("", ctr->info.id21, ps, depth);
6791                 break;
6792         case 23:
6793                 if (UNMARSHALLING(ps))
6794                         ctr->info.id23 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_23,1);
6795
6796                 if (ctr->info.id23 == NULL) {
6797                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6798                         return False;
6799                 }
6800                 ret = sam_io_user_info23("", ctr->info.id23, ps, depth);
6801                 break;
6802         case 24:
6803                 if (UNMARSHALLING(ps))
6804                         ctr->info.id24 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_24,1);
6805
6806                 if (ctr->info.id24 == NULL) {
6807                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6808                         return False;
6809                 }
6810                 ret = sam_io_user_info24("", ctr->info.id24, ps,  depth);
6811                 break;
6812         case 25:
6813                 if (UNMARSHALLING(ps))
6814                         ctr->info.id25 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_25,1);
6815
6816                 if (ctr->info.id25 == NULL) {
6817                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6818                         return False;
6819                 }
6820                 ret = sam_io_user_info25("", ctr->info.id25, ps, depth);
6821                 break;
6822         case 26:
6823                 if (UNMARSHALLING(ps))
6824                         ctr->info.id26 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_26,1);
6825
6826                 if (ctr->info.id26 == NULL) {
6827                         DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6828                         return False;
6829                 }
6830                 ret = sam_io_user_info26("", ctr->info.id26, ps,  depth);
6831                 break;
6832         default:
6833                 DEBUG(2, ("samr_io_userinfo_ctr: unknown switch level 0x%x\n", ctr->switch_value));
6834                 ret = False;
6835                 break;
6836         }
6837
6838         return ret;
6839 }
6840
6841 /*******************************************************************
6842 inits a SAMR_R_QUERY_USERINFO structure.
6843 ********************************************************************/
6844
6845 void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO * r_u,
6846                                 SAM_USERINFO_CTR * ctr, NTSTATUS status)
6847 {
6848         DEBUG(5, ("init_samr_r_query_userinfo\n"));
6849
6850         r_u->ptr = 0;
6851         r_u->ctr = NULL;
6852
6853         if (NT_STATUS_IS_OK(status)) {
6854                 r_u->ptr = 1;
6855                 r_u->ctr = ctr;
6856         }
6857
6858         r_u->status = status;   /* return status */
6859 }
6860
6861 /*******************************************************************
6862 reads or writes a structure.
6863 ********************************************************************/
6864
6865 BOOL samr_io_r_query_userinfo(const char *desc, SAMR_R_QUERY_USERINFO * r_u,
6866                               prs_struct *ps, int depth)
6867 {
6868         if (r_u == NULL)
6869                 return False;
6870
6871         prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
6872         depth++;
6873
6874         if(!prs_align(ps))
6875                 return False;
6876
6877         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
6878                 return False;
6879
6880         if (r_u->ptr != 0) {
6881                 if(!samr_io_userinfo_ctr("ctr", &r_u->ctr, ps, depth))
6882                         return False;
6883         }
6884
6885         if(!prs_align(ps))
6886                 return False;
6887         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6888                 return False;
6889
6890         return True;
6891 }
6892
6893 /*******************************************************************
6894 inits a SAMR_Q_SET_USERINFO structure.
6895 ********************************************************************/
6896
6897 void init_samr_q_set_userinfo(SAMR_Q_SET_USERINFO * q_u,
6898                               const POLICY_HND *hnd, DATA_BLOB *sess_key,
6899                               uint16 switch_value, void *info)
6900 {
6901         DEBUG(5, ("init_samr_q_set_userinfo\n"));
6902
6903         q_u->pol = *hnd;
6904         q_u->switch_value = switch_value;
6905         init_samr_userinfo_ctr(q_u->ctr, sess_key, switch_value, info);
6906 }
6907
6908 /*******************************************************************
6909 reads or writes a structure.
6910 ********************************************************************/
6911
6912 BOOL samr_io_q_set_userinfo(const char *desc, SAMR_Q_SET_USERINFO * q_u,
6913                             prs_struct *ps, int depth)
6914 {
6915         if (q_u == NULL)
6916                 return False;
6917
6918         prs_debug(ps, depth, desc, "samr_io_q_set_userinfo");
6919         depth++;
6920
6921         if(!prs_align(ps))
6922                 return False;
6923
6924         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
6925
6926         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6927                 return False;
6928         if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6929                 return False;
6930
6931         return True;
6932 }
6933
6934 /*******************************************************************
6935 inits a SAMR_R_SET_USERINFO structure.
6936 ********************************************************************/
6937
6938 void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO * r_u, NTSTATUS status)
6939 {
6940         DEBUG(5, ("init_samr_r_set_userinfo\n"));
6941
6942         r_u->status = status;   /* return status */
6943 }
6944
6945 /*******************************************************************
6946 reads or writes a structure.
6947 ********************************************************************/
6948
6949 BOOL samr_io_r_set_userinfo(const char *desc, SAMR_R_SET_USERINFO * r_u,
6950                             prs_struct *ps, int depth)
6951 {
6952         if (r_u == NULL)
6953                 return False;
6954
6955         prs_debug(ps, depth, desc, "samr_io_r_set_userinfo");
6956         depth++;
6957
6958         if(!prs_align(ps))
6959                 return False;
6960
6961         if(!prs_ntstatus("status", ps, depth, &r_u->status))
6962                 return False;
6963
6964         return True;
6965 }
6966
6967 /*******************************************************************
6968 inits a SAMR_Q_SET_USERINFO2 structure.
6969 ********************************************************************/
6970
6971 void init_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2 * q_u,
6972                                const POLICY_HND *hnd, DATA_BLOB *sess_key,
6973                                uint16 switch_value, SAM_USERINFO_CTR * ctr)
6974 {
6975         DEBUG(5, ("init_samr_q_set_userinfo2\n"));
6976
6977         q_u->pol = *hnd;
6978         q_u->switch_value = switch_value;
6979         q_u->ctr = ctr;
6980
6981         q_u->ctr->switch_value = switch_value;
6982
6983         switch (switch_value) {
6984         case 18:
6985                 SamOEMhashBlob(ctr->info.id18->lm_pwd, 16, sess_key);
6986                 SamOEMhashBlob(ctr->info.id18->nt_pwd, 16, sess_key);
6987                 dump_data(100, sess_key->data, sess_key->length);
6988                 dump_data(100, ctr->info.id18->lm_pwd, 16);
6989                 dump_data(100, ctr->info.id18->nt_pwd, 16);
6990                 break;
6991         }
6992 }
6993
6994 /*******************************************************************
6995 reads or writes a structure.
6996 ********************************************************************/
6997
6998 BOOL samr_io_q_set_userinfo2(const char *desc, SAMR_Q_SET_USERINFO2 * q_u,
6999                              prs_struct *ps, int depth)
7000 {
7001         if (q_u == NULL)
7002                 return False;
7003
7004         prs_debug(ps, depth, desc, "samr_io_q_set_userinfo2");
7005         depth++;
7006
7007         if(!prs_align(ps))
7008                 return False;
7009
7010         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
7011                 return False;
7012
7013         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7014                 return False;
7015         if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
7016                 return False;
7017
7018         return True;
7019 }
7020
7021 /*******************************************************************
7022 inits a SAMR_R_SET_USERINFO2 structure.
7023 ********************************************************************/
7024
7025 void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 * r_u, NTSTATUS status)
7026 {
7027         DEBUG(5, ("init_samr_r_set_userinfo2\n"));
7028
7029         r_u->status = status;   /* return status */
7030 }
7031
7032 /*******************************************************************
7033 reads or writes a structure.
7034 ********************************************************************/
7035
7036 BOOL samr_io_r_set_userinfo2(const char *desc, SAMR_R_SET_USERINFO2 * r_u,
7037                              prs_struct *ps, int depth)
7038 {
7039         if (r_u == NULL)
7040                 return False;
7041
7042         prs_debug(ps, depth, desc, "samr_io_r_set_userinfo2");
7043         depth++;
7044
7045         if(!prs_align(ps))
7046                 return False;
7047
7048         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7049                 return False;
7050
7051         return True;
7052 }
7053
7054 /*******************************************************************
7055 inits a SAMR_Q_CONNECT structure.
7056 ********************************************************************/
7057
7058 void init_samr_q_connect(SAMR_Q_CONNECT * q_u,
7059                          char *srv_name, uint32 access_mask)
7060 {
7061         DEBUG(5, ("init_samr_q_connect\n"));
7062
7063         /* make PDC server name \\server */
7064         q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7065         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7066
7067         /* example values: 0x0000 0002 */
7068         q_u->access_mask = access_mask;
7069 }
7070
7071 /*******************************************************************
7072 reads or writes a structure.
7073 ********************************************************************/
7074
7075 BOOL samr_io_q_connect(const char *desc, SAMR_Q_CONNECT * q_u,
7076                        prs_struct *ps, int depth)
7077 {
7078         if (q_u == NULL)
7079                 return False;
7080
7081         prs_debug(ps, depth, desc, "samr_io_q_connect");
7082         depth++;
7083
7084         if(!prs_align(ps))
7085                 return False;
7086
7087         if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7088                 return False;
7089         if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7090                 return False;
7091
7092         if(!prs_align(ps))
7093                 return False;
7094         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7095                 return False;
7096
7097         return True;
7098 }
7099
7100 /*******************************************************************
7101 reads or writes a structure.
7102 ********************************************************************/
7103
7104 BOOL samr_io_r_connect(const char *desc, SAMR_R_CONNECT * r_u,
7105                        prs_struct *ps, int depth)
7106 {
7107         if (r_u == NULL)
7108                 return False;
7109
7110         prs_debug(ps, depth, desc, "samr_io_r_connect");
7111         depth++;
7112
7113         if(!prs_align(ps))
7114                 return False;
7115
7116         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7117                 return False;
7118
7119         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7120                 return False;
7121
7122         return True;
7123 }
7124
7125 /*******************************************************************
7126 inits a SAMR_Q_CONNECT4 structure.
7127 ********************************************************************/
7128
7129 void init_samr_q_connect4(SAMR_Q_CONNECT4 * q_u,
7130                           char *srv_name, uint32 access_mask)
7131 {
7132         DEBUG(5, ("init_samr_q_connect4\n"));
7133
7134         /* make PDC server name \\server */
7135         q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7136         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7137
7138         /* Only value we've seen, possibly an address type ? */
7139         q_u->unk_0 = 2;
7140
7141         /* example values: 0x0000 0002 */
7142         q_u->access_mask = access_mask;
7143 }
7144
7145 /*******************************************************************
7146 reads or writes a structure.
7147 ********************************************************************/
7148
7149 BOOL samr_io_q_connect4(const char *desc, SAMR_Q_CONNECT4 * q_u,
7150                         prs_struct *ps, int depth)
7151 {
7152         if (q_u == NULL)
7153                 return False;
7154
7155         prs_debug(ps, depth, desc, "samr_io_q_connect4");
7156         depth++;
7157
7158         if(!prs_align(ps))
7159                 return False;
7160
7161         if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7162                 return False;
7163         if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7164                 return False;
7165
7166         if(!prs_align(ps))
7167                 return False;
7168         if(!prs_uint32("unk_0", ps, depth, &q_u->unk_0))
7169                 return False;
7170         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7171                 return False;
7172
7173         return True;
7174 }
7175
7176 /*******************************************************************
7177 reads or writes a structure.
7178 ********************************************************************/
7179
7180 BOOL samr_io_r_connect4(const char *desc, SAMR_R_CONNECT4 * r_u,
7181                         prs_struct *ps, int depth)
7182 {
7183         if (r_u == NULL)
7184                 return False;
7185
7186         prs_debug(ps, depth, desc, "samr_io_r_connect4");
7187         depth++;
7188
7189         if(!prs_align(ps))
7190                 return False;
7191
7192         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7193                 return False;
7194
7195         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7196                 return False;
7197
7198         return True;
7199 }
7200
7201 /*******************************************************************
7202 inits a SAMR_Q_CONNECT5 structure.
7203 ********************************************************************/
7204
7205 void init_samr_q_connect5(SAMR_Q_CONNECT5 * q_u,
7206                           char *srv_name, uint32 access_mask)
7207 {
7208         DEBUG(5, ("init_samr_q_connect5\n"));
7209
7210         /* make PDC server name \\server */
7211         q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7212         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7213
7214         /* example values: 0x0000 0002 */
7215         q_u->access_mask = access_mask;
7216
7217         q_u->level = 1;
7218         q_u->info1_unk1 = 3;
7219         q_u->info1_unk2 = 0;
7220 }
7221
7222 /*******************************************************************
7223 inits a SAMR_R_CONNECT5 structure.
7224 ********************************************************************/
7225
7226 void init_samr_r_connect5(SAMR_R_CONNECT5 * r_u, POLICY_HND *pol, NTSTATUS status)
7227 {
7228         DEBUG(5, ("init_samr_q_connect5\n"));
7229
7230         r_u->level = 1;
7231         r_u->info1_unk1 = 3;
7232         r_u->info1_unk2 = 0;
7233
7234         r_u->connect_pol = *pol;
7235         r_u->status = status;
7236 }
7237
7238 /*******************************************************************
7239 reads or writes a structure.
7240 ********************************************************************/
7241
7242 BOOL samr_io_q_connect5(const char *desc, SAMR_Q_CONNECT5 * q_u,
7243                         prs_struct *ps, int depth)
7244 {
7245         if (q_u == NULL)
7246                 return False;
7247
7248         prs_debug(ps, depth, desc, "samr_io_q_connect5");
7249         depth++;
7250
7251         if(!prs_align(ps))
7252                 return False;
7253
7254         if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7255                 return False;
7256         if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7257                 return False;
7258
7259         if(!prs_align(ps))
7260                 return False;
7261         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7262                 return False;
7263
7264         if(!prs_uint32("level", ps, depth, &q_u->level))
7265                 return False;
7266         if(!prs_uint32("level", ps, depth, &q_u->level))
7267                 return False;
7268
7269         if(!prs_uint32("info1_unk1", ps, depth, &q_u->info1_unk1))
7270                 return False;
7271         if(!prs_uint32("info1_unk2", ps, depth, &q_u->info1_unk2))
7272                 return False;
7273
7274         return True;
7275 }
7276
7277 /*******************************************************************
7278 reads or writes a structure.
7279 ********************************************************************/
7280
7281 BOOL samr_io_r_connect5(const char *desc, SAMR_R_CONNECT5 * r_u,
7282                         prs_struct *ps, int depth)
7283 {
7284         if (r_u == NULL)
7285                 return False;
7286
7287         prs_debug(ps, depth, desc, "samr_io_r_connect5");
7288         depth++;
7289
7290         if(!prs_align(ps))
7291                 return False;
7292
7293         if(!prs_uint32("level", ps, depth, &r_u->level))
7294                 return False;
7295         if(!prs_uint32("level", ps, depth, &r_u->level))
7296                 return False;
7297         if(!prs_uint32("info1_unk1", ps, depth, &r_u->info1_unk1))
7298                 return False;
7299         if(!prs_uint32("info1_unk2", ps, depth, &r_u->info1_unk2))
7300                 return False;
7301
7302         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7303                 return False;
7304
7305         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7306                 return False;
7307
7308         return True;
7309 }
7310
7311 /*******************************************************************
7312 inits a SAMR_Q_CONNECT_ANON structure.
7313 ********************************************************************/
7314
7315 void init_samr_q_connect_anon(SAMR_Q_CONNECT_ANON * q_u)
7316 {
7317         DEBUG(5, ("init_samr_q_connect_anon\n"));
7318
7319         q_u->ptr = 1;
7320         q_u->unknown_0 = 0x5c;  /* server name (?!!) */
7321         q_u->access_mask = MAXIMUM_ALLOWED_ACCESS;
7322 }
7323
7324 /*******************************************************************
7325 reads or writes a structure.
7326 ********************************************************************/
7327
7328 BOOL samr_io_q_connect_anon(const char *desc, SAMR_Q_CONNECT_ANON * q_u,
7329                             prs_struct *ps, int depth)
7330 {
7331         if (q_u == NULL)
7332                 return False;
7333
7334         prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
7335         depth++;
7336
7337         if(!prs_align(ps))
7338                 return False;
7339
7340         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
7341                 return False;
7342         if (q_u->ptr) {
7343                 if(!prs_uint16("unknown_0", ps, depth, &q_u->unknown_0))
7344                         return False;
7345         }
7346         if(!prs_align(ps))
7347                 return False;
7348         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7349                 return False;
7350
7351         return True;
7352 }
7353
7354 /*******************************************************************
7355 reads or writes a structure.
7356 ********************************************************************/
7357
7358 BOOL samr_io_r_connect_anon(const char *desc, SAMR_R_CONNECT_ANON * r_u,
7359                             prs_struct *ps, int depth)
7360 {
7361         if (r_u == NULL)
7362                 return False;
7363
7364         prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
7365         depth++;
7366
7367         if(!prs_align(ps))
7368                 return False;
7369
7370         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7371                 return False;
7372
7373         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7374                 return False;
7375
7376         return True;
7377 }
7378
7379 /*******************************************************************
7380 inits a SAMR_Q_GET_DOM_PWINFO structure.
7381 ********************************************************************/
7382
7383 void init_samr_q_get_dom_pwinfo(SAMR_Q_GET_DOM_PWINFO * q_u,
7384                                 char *srv_name)
7385 {
7386         DEBUG(5, ("init_samr_q_get_dom_pwinfo\n"));
7387
7388         q_u->ptr = 1;
7389         init_unistr2(&q_u->uni_srv_name, srv_name, UNI_FLAGS_NONE);
7390         init_uni_hdr(&q_u->hdr_srv_name, &q_u->uni_srv_name);
7391 }
7392
7393 /*******************************************************************
7394 reads or writes a structure.
7395 ********************************************************************/
7396
7397 BOOL samr_io_q_get_dom_pwinfo(const char *desc, SAMR_Q_GET_DOM_PWINFO * q_u,
7398                               prs_struct *ps, int depth)
7399 {
7400         if (q_u == NULL)
7401                 return False;
7402
7403         prs_debug(ps, depth, desc, "samr_io_q_get_dom_pwinfo");
7404         depth++;
7405
7406         if(!prs_align(ps))
7407                 return False;
7408
7409         if(!prs_uint32("ptr", ps, depth, &q_u->ptr))
7410                 return False;
7411         if (q_u->ptr != 0) {
7412                 if(!smb_io_unihdr("", &q_u->hdr_srv_name, ps, depth))
7413                         return False;
7414                 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->hdr_srv_name.buffer, ps, depth))
7415                         return False;
7416         }
7417
7418         return True;
7419 }
7420
7421 /*******************************************************************
7422 reads or writes a structure.
7423 ********************************************************************/
7424
7425 BOOL samr_io_r_get_dom_pwinfo(const char *desc, SAMR_R_GET_DOM_PWINFO * r_u,
7426                               prs_struct *ps, int depth)
7427 {
7428         if (r_u == NULL)
7429                 return False;
7430
7431         prs_debug(ps, depth, desc, "samr_io_r_get_dom_pwinfo");
7432         depth++;
7433
7434         if(!prs_align(ps))
7435                 return False;
7436
7437         if(!prs_uint16("min_pwd_length", ps, depth, &r_u->min_pwd_length))
7438                 return False;
7439         if(!prs_align(ps))
7440                 return False;
7441         if(!prs_uint32("password_properties", ps, depth, &r_u->password_properties))
7442                 return False;
7443
7444         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7445                 return False;
7446
7447         return True;
7448 }
7449
7450 /*******************************************************************
7451 make a SAMR_ENC_PASSWD structure.
7452 ********************************************************************/
7453
7454 void init_enc_passwd(SAMR_ENC_PASSWD * pwd, const char pass[512])
7455 {
7456         ZERO_STRUCTP(pwd);
7457
7458         if (pass == NULL) {
7459                 pwd->ptr = 0;
7460         } else {
7461                 pwd->ptr = 1;
7462                 memcpy(pwd->pass, pass, sizeof(pwd->pass));
7463         }
7464 }
7465
7466 /*******************************************************************
7467 reads or writes a SAMR_ENC_PASSWD structure.
7468 ********************************************************************/
7469
7470 BOOL samr_io_enc_passwd(const char *desc, SAMR_ENC_PASSWD * pwd,
7471                         prs_struct *ps, int depth)
7472 {
7473         if (pwd == NULL)
7474                 return False;
7475
7476         prs_debug(ps, depth, desc, "samr_io_enc_passwd");
7477         depth++;
7478
7479         if(!prs_align(ps))
7480                 return False;
7481
7482         if(!prs_uint32("ptr", ps, depth, &pwd->ptr))
7483                 return False;
7484
7485         if (pwd->ptr != 0) {
7486                 if(!prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass)))
7487                         return False;
7488         }
7489
7490         return True;
7491 }
7492
7493 /*******************************************************************
7494 inits a SAMR_ENC_HASH structure.
7495 ********************************************************************/
7496
7497 void init_enc_hash(SAMR_ENC_HASH * hsh, const uchar hash[16])
7498 {
7499         ZERO_STRUCTP(hsh);
7500
7501         if (hash == NULL) {
7502                 hsh->ptr = 0;
7503         } else {
7504                 hsh->ptr = 1;
7505                 memcpy(hsh->hash, hash, sizeof(hsh->hash));
7506         }
7507 }
7508
7509 /*******************************************************************
7510 reads or writes a SAMR_ENC_HASH structure.
7511 ********************************************************************/
7512
7513 BOOL samr_io_enc_hash(const char *desc, SAMR_ENC_HASH * hsh,
7514                       prs_struct *ps, int depth)
7515 {
7516         if (hsh == NULL)
7517                 return False;
7518
7519         prs_debug(ps, depth, desc, "samr_io_enc_hash");
7520         depth++;
7521
7522         if(!prs_align(ps))
7523                 return False;
7524
7525         if(!prs_uint32("ptr ", ps, depth, &hsh->ptr))
7526                 return False;
7527         if (hsh->ptr != 0) {
7528                 if(!prs_uint8s(False, "hash", ps, depth, hsh->hash,sizeof(hsh->hash)))
7529                         return False;
7530         }
7531
7532         return True;
7533 }
7534
7535 /*******************************************************************
7536 inits a SAMR_Q_CHGPASSWD_USER structure.
7537 ********************************************************************/
7538
7539 void init_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER * q_u,
7540                                 const char *dest_host, const char *user_name,
7541                                 const uchar nt_newpass[516],
7542                                 const uchar nt_oldhash[16],
7543                                 const uchar lm_newpass[516],
7544                                 const uchar lm_oldhash[16])
7545 {
7546         DEBUG(5, ("init_samr_q_chgpasswd_user\n"));
7547
7548         q_u->ptr_0 = 1;
7549         init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7550         init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7551
7552         init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7553         init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7554
7555         init_enc_passwd(&q_u->nt_newpass, (const char *)nt_newpass);
7556         init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7557
7558         q_u->unknown = 0x01;
7559
7560         init_enc_passwd(&q_u->lm_newpass, (const char *)lm_newpass);
7561         init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7562 }
7563
7564 /*******************************************************************
7565 reads or writes a structure.
7566 ********************************************************************/
7567
7568 BOOL samr_io_q_chgpasswd_user(const char *desc, SAMR_Q_CHGPASSWD_USER * q_u,
7569                               prs_struct *ps, int depth)
7570 {
7571         if (q_u == NULL)
7572                 return False;
7573
7574         prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
7575         depth++;
7576
7577         if(!prs_align(ps))
7578                 return False;
7579
7580         if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7581                 return False;
7582
7583         if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7584                 return False;
7585         if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7586                 return False;
7587
7588         if(!prs_align(ps))
7589                 return False;
7590         if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7591                 return False;
7592         if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7593                 return False;
7594
7595         if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7596                 return False;
7597         if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7598                 return False;
7599
7600         if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
7601                 return False;
7602
7603         if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7604                 return False;
7605         if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7606                 return False;
7607
7608         return True;
7609 }
7610
7611 /*******************************************************************
7612 inits a SAMR_R_CHGPASSWD_USER structure.
7613 ********************************************************************/
7614
7615 void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER * r_u, NTSTATUS status)
7616 {
7617         DEBUG(5, ("init_samr_r_chgpasswd_user\n"));
7618
7619         r_u->status = status;
7620 }
7621
7622 /*******************************************************************
7623 reads or writes a structure.
7624 ********************************************************************/
7625
7626 BOOL samr_io_r_chgpasswd_user(const char *desc, SAMR_R_CHGPASSWD_USER * r_u,
7627                               prs_struct *ps, int depth)
7628 {
7629         if (r_u == NULL)
7630                 return False;
7631
7632         prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
7633         depth++;
7634
7635         if(!prs_align(ps))
7636                 return False;
7637
7638         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7639                 return False;
7640
7641         return True;
7642 }
7643
7644 /*******************************************************************
7645 inits a SAMR_Q_CHGPASSWD3 structure.
7646 ********************************************************************/
7647
7648 void init_samr_q_chgpasswd_user3(SAMR_Q_CHGPASSWD_USER3 * q_u,
7649                                  const char *dest_host, const char *user_name,
7650                                  const uchar nt_newpass[516],
7651                                  const uchar nt_oldhash[16],
7652                                  const uchar lm_newpass[516],
7653                                  const uchar lm_oldhash[16])
7654 {
7655         DEBUG(5, ("init_samr_q_chgpasswd_user3\n"));
7656
7657         q_u->ptr_0 = 1;
7658         init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7659         init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7660
7661         init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7662         init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7663
7664         init_enc_passwd(&q_u->nt_newpass, (const char *)nt_newpass);
7665         init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7666
7667         q_u->lm_change = 0x01;
7668
7669         init_enc_passwd(&q_u->lm_newpass, (const char *)lm_newpass);
7670         init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7671
7672         init_enc_passwd(&q_u->password3, NULL);
7673 }
7674
7675 /*******************************************************************
7676 reads or writes a structure.
7677 ********************************************************************/
7678
7679 BOOL samr_io_q_chgpasswd_user3(const char *desc, SAMR_Q_CHGPASSWD_USER3 * q_u,
7680                                prs_struct *ps, int depth)
7681 {
7682         if (q_u == NULL)
7683                 return False;
7684
7685         prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user3");
7686         depth++;
7687
7688         if(!prs_align(ps))
7689                 return False;
7690
7691         if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7692                 return False;
7693
7694         if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7695                 return False;
7696         if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7697                 return False;
7698
7699         if(!prs_align(ps))
7700                 return False;
7701         if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7702                 return False;
7703         if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7704                 return False;
7705
7706         if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7707                 return False;
7708         if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7709                 return False;
7710
7711         if(!prs_uint32("lm_change", ps, depth, &q_u->lm_change))
7712                 return False;
7713
7714         if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7715                 return False;
7716         if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7717                 return False;
7718
7719         if(!samr_io_enc_passwd("password3", &q_u->password3, ps, depth))
7720                 return False;
7721
7722         return True;
7723 }
7724
7725 /*******************************************************************
7726 inits a SAMR_R_CHGPASSWD_USER3 structure.
7727 ********************************************************************/
7728
7729 void init_samr_r_chgpasswd_user3(SAMR_R_CHGPASSWD_USER3 *r_u, NTSTATUS status,
7730                                  SAMR_CHANGE_REJECT *reject, SAM_UNK_INFO_1 *info)
7731 {
7732         DEBUG(5, ("init_samr_r_chgpasswd_user3\n"));
7733
7734         r_u->status = status;
7735         r_u->info = 0;
7736         r_u->ptr_info = 0;
7737         r_u->reject = 0;
7738         r_u->ptr_reject = 0;
7739
7740         if (info) {
7741                 r_u->info = info;
7742                 r_u->ptr_info = 1;
7743         }
7744         if (reject && (reject->reject_reason != Undefined)) {
7745                 r_u->reject = reject;
7746                 r_u->ptr_reject = 1;
7747         }
7748 }
7749
7750 /*******************************************************************
7751  Reads or writes an SAMR_CHANGE_REJECT structure.
7752 ********************************************************************/
7753
7754 BOOL samr_io_change_reject(const char *desc, SAMR_CHANGE_REJECT *reject, prs_struct *ps, int depth)
7755 {
7756         if (reject == NULL)
7757                 return False;
7758
7759         prs_debug(ps, depth, desc, "samr_io_change_reject");
7760         depth++;
7761
7762         if(!prs_align(ps))
7763                 return False;
7764
7765         if(UNMARSHALLING(ps))
7766                 ZERO_STRUCTP(reject);
7767
7768         if (!prs_uint32("reject_reason", ps, depth, &reject->reject_reason))
7769                 return False;
7770
7771         if (!prs_uint32("unknown1", ps, depth, &reject->unknown1))
7772                 return False;
7773
7774         if (!prs_uint32("unknown2", ps, depth, &reject->unknown2))
7775                 return False;
7776
7777         return True;
7778 }
7779
7780 /*******************************************************************
7781 reads or writes a structure.
7782 ********************************************************************/
7783
7784 BOOL samr_io_r_chgpasswd_user3(const char *desc, SAMR_R_CHGPASSWD_USER3 *r_u,
7785                                prs_struct *ps, int depth)
7786 {
7787         if (r_u == NULL)
7788                 return False;
7789
7790         prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user3");
7791         depth++;
7792
7793         if (!prs_align(ps))
7794                 return False;
7795
7796         if (!prs_uint32("ptr_info", ps, depth, &r_u->ptr_info))
7797                 return False;
7798
7799         /* special case: Windows 2000 can return stub data here saying
7800            NT_STATUS_NOT_SUPPORTED */
7801
7802         if ( NT_STATUS_EQUAL( NT_STATUS_NOT_SUPPORTED, NT_STATUS(r_u->ptr_info)) ) {
7803                 r_u->status = NT_STATUS_NOT_SUPPORTED;
7804                 return True;
7805         }
7806
7807         if (r_u->ptr_info && r_u->info != NULL) {
7808                 /* SAM_UNK_INFO_1 */
7809                 if (!sam_io_unk_info1("info", r_u->info, ps, depth))
7810                         return False;
7811         }
7812
7813         if (!prs_uint32("ptr_reject", ps, depth, &r_u->ptr_reject))
7814                 return False;
7815
7816         if (r_u->ptr_reject && r_u->reject != NULL) {
7817                 /* SAMR_CHANGE_REJECT */
7818                 if (!samr_io_change_reject("reject", r_u->reject, ps, depth))
7819                         return False;
7820         }
7821
7822         if (!prs_ntstatus("status", ps, depth, &r_u->status))
7823                 return False;
7824
7825         return True;
7826 }
7827
7828 /*******************************************************************
7829 reads or writes a structure.
7830 ********************************************************************/
7831
7832 void init_samr_q_query_domain_info2(SAMR_Q_QUERY_DOMAIN_INFO2 *q_u,
7833                                 POLICY_HND *domain_pol, uint16 switch_value)
7834 {
7835         DEBUG(5, ("init_samr_q_query_domain_info2\n"));
7836
7837         q_u->domain_pol = *domain_pol;
7838         q_u->switch_value = switch_value;
7839 }
7840
7841 /*******************************************************************
7842 reads or writes a structure.
7843 ********************************************************************/
7844
7845 BOOL samr_io_q_query_domain_info2(const char *desc, SAMR_Q_QUERY_DOMAIN_INFO2 *q_u,
7846                               prs_struct *ps, int depth)
7847 {
7848         if (q_u == NULL)
7849                 return False;
7850
7851         prs_debug(ps, depth, desc, "samr_io_q_query_domain_info2");
7852         depth++;
7853
7854         if(!prs_align(ps))
7855                 return False;
7856
7857         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7858                 return False;
7859
7860         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7861                 return False;
7862
7863         return True;
7864 }
7865
7866 /*******************************************************************
7867 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7868 ********************************************************************/
7869
7870 void init_samr_r_query_domain_info2(SAMR_R_QUERY_DOMAIN_INFO2 * r_u,
7871                                     uint16 switch_value, SAM_UNK_CTR * ctr,
7872                                     NTSTATUS status)
7873 {
7874         DEBUG(5, ("init_samr_r_query_domain_info2\n"));
7875
7876         r_u->ptr_0 = 0;
7877         r_u->switch_value = 0;
7878         r_u->status = status;   /* return status */
7879
7880         if (NT_STATUS_IS_OK(status)) {
7881                 r_u->switch_value = switch_value;
7882                 r_u->ptr_0 = 1;
7883                 r_u->ctr = ctr;
7884         }
7885 }
7886
7887 /*******************************************************************
7888 reads or writes a structure.
7889 ********************************************************************/
7890
7891 BOOL samr_io_r_query_domain_info2(const char *desc, SAMR_R_QUERY_DOMAIN_INFO2 * r_u,
7892                                   prs_struct *ps, int depth)
7893 {
7894         if (r_u == NULL)
7895                 return False;
7896
7897         prs_debug(ps, depth, desc, "samr_io_r_query_domain_info2");
7898         depth++;
7899
7900         if(!prs_align(ps))
7901                 return False;
7902
7903         if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
7904                 return False;
7905
7906         if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
7907                 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
7908                         return False;
7909                 if(!prs_align(ps))
7910                         return False;
7911
7912                 switch (r_u->switch_value) {
7913                 case 0x0d:
7914                         if(!sam_io_unk_info13("unk_inf13", &r_u->ctr->info.inf13, ps, depth))
7915                                 return False;
7916                         break;
7917                 case 0x0c:
7918                         if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
7919                                 return False;
7920                         break;
7921                 case 0x09:
7922                         if(!sam_io_unk_info9("unk_inf9",&r_u->ctr->info.inf9, ps,depth))
7923                                 return False;
7924                         break;
7925                 case 0x08:
7926                         if(!sam_io_unk_info8("unk_inf8",&r_u->ctr->info.inf8, ps,depth))
7927                                 return False;
7928                         break;
7929                 case 0x07:
7930                         if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
7931                                 return False;
7932                         break;
7933                 case 0x06:
7934                         if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
7935                                 return False;
7936                         break;
7937                 case 0x05:
7938                         if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
7939                                 return False;
7940                         break;
7941                 case 0x04:
7942                         if(!sam_io_unk_info4("unk_inf4",&r_u->ctr->info.inf4, ps,depth))
7943                                 return False;
7944                         break;
7945                 case 0x03:
7946                         if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
7947                                 return False;
7948                         break;
7949                 case 0x02:
7950                         if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
7951                                 return False;
7952                         break;
7953                 case 0x01:
7954                         if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
7955                                 return False;
7956                         break;
7957                 default:
7958                         DEBUG(0, ("samr_io_r_query_domain_info2: unknown switch level 0x%x\n",
7959                                 r_u->switch_value));
7960                         r_u->status = NT_STATUS_INVALID_INFO_CLASS;
7961                         return False;
7962                 }
7963         }
7964
7965         if(!prs_align(ps))
7966                 return False;
7967
7968         if(!prs_ntstatus("status", ps, depth, &r_u->status))
7969                 return False;
7970
7971         return True;
7972 }
7973
7974
7975 /*******************************************************************
7976 reads or writes a structure.
7977 ********************************************************************/
7978
7979 void init_samr_q_set_domain_info(SAMR_Q_SET_DOMAIN_INFO *q_u,
7980                                 POLICY_HND *domain_pol, uint16 switch_value, SAM_UNK_CTR *ctr)
7981 {
7982         DEBUG(5, ("init_samr_q_set_domain_info\n"));
7983
7984         q_u->domain_pol = *domain_pol;
7985         q_u->switch_value0 = switch_value;
7986
7987         q_u->switch_value = switch_value;
7988         q_u->ctr = ctr;
7989
7990 }
7991
7992 /*******************************************************************
7993 reads or writes a structure.
7994 ********************************************************************/
7995
7996 BOOL samr_io_q_set_domain_info(const char *desc, SAMR_Q_SET_DOMAIN_INFO *q_u,
7997                               prs_struct *ps, int depth)
7998 {
7999         if (q_u == NULL)
8000                 return False;
8001
8002         prs_debug(ps, depth, desc, "samr_io_q_set_domain_info");
8003         depth++;
8004
8005         if(!prs_align(ps))
8006                 return False;
8007
8008         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
8009                 return False;
8010
8011         if(!prs_uint16("switch_value0", ps, depth, &q_u->switch_value0))
8012                 return False;
8013
8014         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
8015                 return False;
8016
8017         if(!prs_align(ps))
8018                 return False;
8019
8020         if (UNMARSHALLING(ps)) {
8021                 if ((q_u->ctr = PRS_ALLOC_MEM(ps, SAM_UNK_CTR, 1)) == NULL)
8022                         return False;
8023         }
8024
8025         switch (q_u->switch_value) {
8026
8027         case 0x0c:
8028                 if(!sam_io_unk_info12("unk_inf12", &q_u->ctr->info.inf12, ps, depth))
8029                         return False;
8030                 break;
8031         case 0x07:
8032                 if(!sam_io_unk_info7("unk_inf7",&q_u->ctr->info.inf7, ps,depth))
8033                         return False;
8034                 break;
8035         case 0x06:
8036                 if(!sam_io_unk_info6("unk_inf6",&q_u->ctr->info.inf6, ps,depth))
8037                         return False;
8038                 break;
8039         case 0x05:
8040                 if(!sam_io_unk_info5("unk_inf5",&q_u->ctr->info.inf5, ps,depth))
8041                         return False;
8042                 break;
8043         case 0x03:
8044                 if(!sam_io_unk_info3("unk_inf3",&q_u->ctr->info.inf3, ps,depth))
8045                         return False;
8046                 break;
8047         case 0x02:
8048                 if(!sam_io_unk_info2("unk_inf2",&q_u->ctr->info.inf2, ps,depth))
8049                         return False;
8050                 break;
8051         case 0x01:
8052                 if(!sam_io_unk_info1("unk_inf1",&q_u->ctr->info.inf1, ps,depth))
8053                         return False;
8054                 break;
8055         default:
8056                 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
8057                         q_u->switch_value));
8058                 return False;
8059         }
8060
8061         return True;
8062 }
8063
8064 /*******************************************************************
8065 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
8066 ********************************************************************/
8067
8068 void init_samr_r_set_domain_info(SAMR_R_SET_DOMAIN_INFO * r_u, NTSTATUS status)
8069 {
8070         DEBUG(5, ("init_samr_r_set_domain_info\n"));
8071
8072         r_u->status = status;   /* return status */
8073 }
8074
8075 /*******************************************************************
8076 reads or writes a structure.
8077 ********************************************************************/
8078
8079 BOOL samr_io_r_set_domain_info(const char *desc, SAMR_R_SET_DOMAIN_INFO * r_u,
8080                               prs_struct *ps, int depth)
8081 {
8082         if (r_u == NULL)
8083                 return False;
8084
8085         prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
8086         depth++;
8087
8088         if(!prs_align(ps))
8089                 return False;
8090
8091         if(!prs_ntstatus("status", ps, depth, &r_u->status))
8092                 return False;
8093
8094         return True;
8095 }