source3/rpc_parse/parse_samr.c

   1 /*
   2  *  Unix SMB/Netbios implementation.
   3  *  Version 1.9.
   4  *  RPC Pipe client / server routines
   5  *  Copyright (C) Andrew Tridgell              1992-1997,
   6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   7  *  Copyright (C) Paul Ashton                       1997.
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24
  25 #include "includes.h"
  26
  27 extern int DEBUGLEVEL;
  28
  29
  30 /*******************************************************************
  31  Inits a SAMR_Q_CLOSE_HND structure.
  32 ********************************************************************/
  33
  34 void init_samr_q_close_hnd(SAMR_Q_CLOSE_HND *q_c, POLICY_HND *hnd)
  35 {
  36         DEBUG(5,("init_samr_q_close_hnd\n"));
  37
  38         memcpy(&q_c->pol, hnd, sizeof(q_c->pol));
  39 }
  40
  41 /*******************************************************************
  42  Reads or writes a structure.
  43 ********************************************************************/
  44
  45 BOOL samr_io_q_close_hnd(char *desc,  SAMR_Q_CLOSE_HND *q_u, prs_struct *ps, int depth)
  46 {
  47         if (q_u == NULL)
  48                 return False;
  49
  50         prs_debug(ps, depth, desc, "samr_io_q_close_hnd");
  51         depth++;
  52
  53         if(!prs_align(ps))
  54                 return False;
  55
  56         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
  57                 return False;
  58         if(!prs_align(ps))
  59                 return False;
  60
  61         return True;
  62 }
  63
  64 /*******************************************************************
  65  Reads or writes a structure.
  66 ********************************************************************/
  67
  68 BOOL samr_io_r_close_hnd(char *desc,  SAMR_R_CLOSE_HND *r_u, prs_struct *ps, int depth)
  69 {
  70         if (r_u == NULL)
  71                 return False;
  72
  73         prs_debug(ps, depth, desc, "samr_io_r_close_hnd");
  74         depth++;
  75
  76         if(!prs_align(ps))
  77                 return False;
  78
  79         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
  80                 return False;
  81         if(!prs_align(ps))
  82                 return False;
  83
  84         if(!prs_uint32("status", ps, depth, &r_u->status))
  85                 return False;
  86
  87         return True;
  88 }
  89
  90
  91 /*******************************************************************
  92  Reads or writes a structure.
  93 ********************************************************************/
  94
  95 void init_samr_q_open_domain(SAMR_Q_OPEN_DOMAIN *q_u,
  96                                 POLICY_HND *connect_pol, uint32 rid,
  97                                 DOM_SID *sid)
  98 {
  99         DEBUG(5,("samr_init_q_open_domain\n"));
 100
 101         memcpy(&q_u->connect_pol, connect_pol, sizeof(q_u->connect_pol));
 102         q_u->rid = rid;
 103         init_dom_sid2(&q_u->dom_sid, sid);
 104 }
 105
 106 /*******************************************************************
 107  Reads or writes a structure.
 108 ********************************************************************/
 109
 110 BOOL samr_io_q_open_domain(char *desc, SAMR_Q_OPEN_DOMAIN *q_u, prs_struct *ps, int depth)
 111 {
 112         if (q_u == NULL)
 113                 return False;
 114
 115         prs_debug(ps, depth, desc, "samr_io_q_open_domain");
 116         depth++;
 117
 118         if(!prs_align(ps))
 119                 return False;
 120
 121         if(!smb_io_pol_hnd("connect_pol", &q_u->connect_pol, ps, depth))
 122                 return False;
 123         if(!prs_align(ps))
 124                 return False;
 125
 126         if(!prs_uint32("rid", ps, depth, &q_u->rid))
 127                 return False;
 128
 129         if(!smb_io_dom_sid2("sid", &q_u->dom_sid, ps, depth))
 130                 return False;
 131         if(!prs_align(ps))
 132                 return False;
 133
 134         return True;
 135 }
 136
 137
 138 /*******************************************************************
 139  Reads or writes a structure.
 140 ********************************************************************/
 141
 142 BOOL samr_io_r_open_domain(char *desc, SAMR_R_OPEN_DOMAIN *r_u, prs_struct *ps, int depth)
 143 {
 144         if (r_u == NULL)
 145                 return False;
 146
 147         prs_debug(ps, depth, desc, "samr_io_r_open_domain");
 148         depth++;
 149
 150         if(!prs_align(ps))
 151                 return False;
 152
 153         if(!smb_io_pol_hnd("domain_pol", &r_u->domain_pol, ps, depth))
 154                 return False;
 155         if(!prs_align(ps))
 156                 return False;
 157
 158         if(!prs_uint32("status", ps, depth, &r_u->status))
 159                 return False;
 160
 161         return True;
 162 }
 163
 164 /*******************************************************************
 165  Reads or writes a structure.
 166 ********************************************************************/
 167
 168 void init_samr_q_unknown_2c(SAMR_Q_UNKNOWN_2C *q_u, POLICY_HND *user_pol)
 169 {
 170         DEBUG(5,("samr_init_q_unknown_2c\n"));
 171
 172         memcpy(&q_u->user_pol, user_pol, sizeof(q_u->user_pol));
 173 }
 174
 175
 176 /*******************************************************************
 177  Reads or writes a structure.
 178 ********************************************************************/
 179
 180 BOOL samr_io_q_unknown_2c(char *desc,  SAMR_Q_UNKNOWN_2C *q_u, prs_struct *ps, int depth)
 181 {
 182         if (q_u == NULL)
 183                 return False;
 184
 185         prs_debug(ps, depth, desc, "samr_io_q_unknown_2c");
 186         depth++;
 187
 188         if(!prs_align(ps))
 189                 return False;
 190
 191         if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
 192                 return False;
 193         if(!prs_align(ps))
 194                 return False;
 195
 196         return True;
 197 }
 198
 199 /*******************************************************************
 200  Inits a structure.
 201 ********************************************************************/
 202
 203 void init_samr_r_unknown_2c(SAMR_R_UNKNOWN_2C *q_u, uint32 status)
 204 {
 205         DEBUG(5,("samr_init_r_unknown_2c\n"));
 206
 207         q_u->unknown_0 = 0x00160000;
 208         q_u->unknown_1 = 0x00000000;
 209         q_u->status    = status;
 210 }
 211
 212
 213 /*******************************************************************
 214  Reads or writes a structure.
 215 ********************************************************************/
 216
 217 BOOL samr_io_r_unknown_2c(char *desc,  SAMR_R_UNKNOWN_2C *r_u, prs_struct *ps, int depth)
 218 {
 219         if (r_u == NULL)
 220                 return False;
 221
 222         prs_debug(ps, depth, desc, "samr_io_r_unknown_2c");
 223         depth++;
 224
 225         if(!prs_align(ps))
 226                 return False;
 227
 228         if(!prs_uint32("unknown_0", ps, depth, &r_u->unknown_0))
 229                 return False;
 230         if(!prs_uint32("unknown_1", ps, depth, &r_u->unknown_1))
 231                 return False;
 232         if(!prs_uint32("status   ", ps, depth, &r_u->status))
 233                 return False;
 234
 235         return True;
 236 }
 237
 238 /*******************************************************************
 239  Inits a SAMR_Q_UNKNOWN_3 structure.
 240 ********************************************************************/
 241
 242 void init_samr_q_unknown_3(SAMR_Q_UNKNOWN_3 *q_u,
 243                                 POLICY_HND *user_pol, uint16 switch_value)
 244 {
 245         DEBUG(5,("samr_init_q_unknown_3\n"));
 246
 247         memcpy(&q_u->user_pol, user_pol, sizeof(q_u->user_pol));
 248         q_u->switch_value = switch_value;
 249 }
 250
 251
 252 /*******************************************************************
 253  Reads or writes a structure.
 254 ********************************************************************/
 255
 256 BOOL samr_io_q_unknown_3(char *desc,  SAMR_Q_UNKNOWN_3 *q_u, prs_struct *ps, int depth)
 257 {
 258         if (q_u == NULL)
 259                 return False;
 260
 261         prs_debug(ps, depth, desc, "samr_io_q_unknown_3");
 262         depth++;
 263
 264         if(!prs_align(ps))
 265                 return False;
 266
 267         if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
 268                 return False;
 269
 270         if(!prs_align(ps))
 271                 return False;
 272
 273         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
 274                 return False;
 275         if(!prs_align(ps))
 276                 return False;
 277
 278         return True;
 279 }
 280
 281 /*******************************************************************
 282  Inits a SAMR_Q_QUERY_DOMAIN_INFO structure.
 283 ********************************************************************/
 284
 285 void init_samr_q_query_dom_info(SAMR_Q_QUERY_DOMAIN_INFO *q_u,
 286                                 POLICY_HND *domain_pol, uint16 switch_value)
 287 {
 288         DEBUG(5,("init_samr_q_query_dom_info\n"));
 289
 290         memcpy(&q_u->domain_pol, domain_pol, sizeof(q_u->domain_pol));
 291         q_u->switch_value = switch_value;
 292 }
 293
 294 /*******************************************************************
 295  Reads or writes a structure.
 296 ********************************************************************/
 297
 298 BOOL samr_io_q_query_dom_info(char *desc,  SAMR_Q_QUERY_DOMAIN_INFO *q_u, prs_struct *ps, int depth)
 299 {
 300         if (q_u == NULL)
 301                 return False;
 302
 303         prs_debug(ps, depth, desc, "samr_io_q_query_dom_info");
 304         depth++;
 305
 306         if(!prs_align(ps))
 307                 return False;
 308
 309         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
 310                 return False;
 311         if(!prs_align(ps))
 312                 return False;
 313
 314         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
 315                 return False;
 316         if(!prs_align(ps))
 317                 return False;
 318
 319
 320         return True;
 321 }
 322
 323 /*******************************************************************
 324  Inits a structure.
 325 ********************************************************************/
 326
 327 void init_unk_info2(SAM_UNK_INFO_2 *u_2, char *domain, char *server)
 328 {
 329         int len_domain = strlen(domain);
 330         int len_server = strlen(server);
 331
 332         u_2->unknown_0 = 0x00000000;
 333         u_2->unknown_1 = 0x80000000;
 334         u_2->unknown_2 = 0x00000000;
 335
 336         u_2->ptr_0 = 1;
 337         init_uni_hdr(&u_2->hdr_domain, len_domain);
 338         init_uni_hdr(&u_2->hdr_server, len_server);
 339
 340         u_2->seq_num = 0x10000000;
 341         u_2->unknown_3 = 0x00000000;
 342
 343         u_2->unknown_4  = 0x00000001;
 344         u_2->unknown_5  = 0x00000003;
 345         u_2->unknown_6  = 0x00000001;
 346         u_2->num_domain_usrs  = 0x00000008;
 347         u_2->num_domain_grps = 0x00000003;
 348         u_2->num_local_grps = 0x00000003;
 349
 350         memset(u_2->padding, 0, sizeof(u_2->padding)); /* 12 bytes zeros */
 351
 352         init_unistr2(&u_2->uni_domain, domain, len_domain);
 353         init_unistr2(&u_2->uni_server, server, len_server);
 354 }
 355
 356 /*******************************************************************
 357  Reads or writes a structure.
 358 ********************************************************************/
 359
 360 BOOL sam_io_unk_info2(char *desc, SAM_UNK_INFO_2 *u_2, prs_struct *ps, int depth)
 361 {
 362         if (u_2 == NULL)
 363                 return False;
 364
 365         prs_debug(ps, depth, desc, "sam_io_unk_info2");
 366         depth++;
 367
 368         if(!prs_uint32("unknown_0", ps, depth, &u_2->unknown_0)) /* 0x0000 0000 */
 369                 return False;
 370         if(!prs_uint32("unknown_1", ps, depth, &u_2->unknown_1)) /* 0x8000 0000 */
 371                 return False;
 372         if(!prs_uint32("unknown_2", ps, depth, &u_2->unknown_2)) /* 0x0000 0000 */
 373                 return False;
 374
 375         if(!prs_uint32("ptr_0", ps, depth, &u_2->ptr_0))     /* pointer to unknown structure */
 376                 return False;
 377         if(!smb_io_unihdr("hdr_domain", &u_2->hdr_domain, ps, depth)) /* domain name unicode header */
 378                 return False;
 379         if(!smb_io_unihdr("hdr_server", &u_2->hdr_server, ps, depth)) /* server name unicode header */
 380                 return False;
 381
 382         /* put all the data in here, at the moment, including what the above
 383            pointer is referring to
 384          */
 385
 386         if(!prs_uint32("seq_num ", ps, depth, &u_2->seq_num )) /* 0x0000 0099 or 0x1000 0000 */
 387                 return False;
 388         if(!prs_uint32("unknown_3 ", ps, depth, &u_2->unknown_3 )) /* 0x0000 0000 */
 389                 return False;
 390
 391         if(!prs_uint32("unknown_4 ", ps, depth, &u_2->unknown_4 )) /* 0x0000 0001 */
 392                 return False;
 393         if(!prs_uint32("unknown_5 ", ps, depth, &u_2->unknown_5 )) /* 0x0000 0003 */
 394                 return False;
 395         if(!prs_uint32("unknown_6 ", ps, depth, &u_2->unknown_6 )) /* 0x0000 0001 */
 396                 return False;
 397         if(!prs_uint32("num_domain_usrs ", ps, depth, &u_2->num_domain_usrs )) /* 0x0000 0008 */
 398                 return False;
 399         if(!prs_uint32("num_domain_grps", ps, depth, &u_2->num_domain_grps)) /* 0x0000 0003 */
 400                 return False;
 401         if(!prs_uint32("num_local_grps", ps, depth, &u_2->num_local_grps)) /* 0x0000 0003 */
 402                 return False;
 403
 404         if(!prs_uint8s(False, "padding", ps, depth, u_2->padding, sizeof(u_2->padding))) /* 12 bytes zeros */
 405                 return False;
 406
 407         if(!smb_io_unistr2( "uni_domain", &u_2->uni_domain, u_2->hdr_domain.buffer, ps, depth)) /* domain name unicode string */
 408                 return False;
 409         if(!smb_io_unistr2( "uni_server", &u_2->uni_server, u_2->hdr_server.buffer, ps, depth)) /* server name unicode string */
 410                 return False;
 411
 412         if(!prs_align(ps))
 413                 return False;
 414
 415         return True;
 416 }
 417
 418 /*******************************************************************
 419  Inits a SAMR_R_QUERY_DOMAIN_INFO structure.
 420 ********************************************************************/
 421
 422 void init_samr_r_query_dom_info(SAMR_R_QUERY_DOMAIN_INFO *r_u,
 423                                 uint16 switch_value, SAM_UNK_CTR *ctr,
 424                                 uint32 status)
 425 {
 426         DEBUG(5,("init_samr_r_query_dom_info\n"));
 427
 428         r_u->ptr_0 = 0;
 429         r_u->switch_value = 0;
 430         r_u->status = status; /* return status */
 431
 432         if (status == 0) {
 433                 r_u->switch_value = switch_value;
 434                 r_u->ptr_0 = 1;
 435                 r_u->ctr = ctr;
 436         }
 437 }
 438
 439 /*******************************************************************
 440  Reads or writes a structure.
 441 ********************************************************************/
 442
 443 BOOL samr_io_r_query_dom_info(char *desc, SAMR_R_QUERY_DOMAIN_INFO *r_u, prs_struct *ps, int depth)
 444 {
 445         if (r_u == NULL)
 446                 return False;
 447
 448         prs_debug(ps, depth, desc, "samr_io_r_query_dom_info");
 449         depth++;
 450
 451         if(!prs_align(ps))
 452                 return False;
 453
 454         if(!prs_uint32("ptr_0       ", ps, depth, &r_u->ptr_0))
 455                 return False;
 456         if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
 457                 return False;
 458         if(!prs_align(ps))
 459                 return False;
 460
 461         if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
 462                 switch (r_u->switch_value) {
 463                 case 0x02:
 464                         if(!sam_io_unk_info2("unk_inf2", &r_u->ctr->info.inf2, ps, depth))
 465                                 return False;
 466                         break;
 467                 default:
 468                         DEBUG(3,("samr_io_r_query_dom_info: unknown switch level 0x%x\n",
 469                                   r_u->switch_value));
 470                         return False;
 471                 }
 472         }
 473
 474         return True;
 475 }
 476
 477
 478 /*******************************************************************
 479  Inits a DOM_SID3 structure.
 480  Calculate length by adding up the size of the components.
 481  ********************************************************************/
 482
 483 void init_dom_sid3(DOM_SID3 *sid3, uint16 unk_0, uint16 unk_1, DOM_SID *sid)
 484 {
 485         sid3->sid = *sid;
 486         sid3->len = 2 + 8 + sid3->sid.num_auths * 4;
 487 }
 488
 489 /*******************************************************************
 490  Reads or writes a SAM_SID3 structure.
 491
 492  this one's odd, because the length (in bytes) is specified at the beginning.
 493  the length _includes_ the length of the length, too :-)
 494
 495 ********************************************************************/
 496
 497 static BOOL sam_io_dom_sid3(char *desc,  DOM_SID3 *sid3, prs_struct *ps, int depth)
 498 {
 499         if (sid3 == NULL)
 500                 return False;
 501
 502         prs_debug(ps, depth, desc, "sam_io_dom_sid3");
 503         depth++;
 504
 505         if(!prs_uint16("len", ps, depth, &sid3->len))
 506                 return False;
 507         if(!prs_align(ps))
 508                 return False;
 509         if(!smb_io_dom_sid("", &sid3->sid, ps, depth))
 510                 return False;
 511
 512         return True;
 513 }
 514
 515 /*******************************************************************
 516  Inits a SAMR_R_UNKNOWN3 structure.
 517
 518 unknown_2   : 0x0001
 519 unknown_3   : 0x8004
 520
 521 unknown_4,5 : 0x0000 0014
 522
 523 unknown_6   : 0x0002
 524 unknown_7   : 0x5800 or 0x0070
 525
 526 ********************************************************************/
 527
 528 static void init_sam_sid_stuff(SAM_SID_STUFF *stf,
 529                                 uint16 unknown_2, uint16 unknown_3,
 530                                 uint32 unknown_4, uint16 unknown_6, uint16 unknown_7,
 531                                 int num_sid3s, DOM_SID3 sid3[MAX_SAM_SIDS])
 532 {
 533         stf->unknown_2 = unknown_2;
 534         stf->unknown_3 = unknown_3;
 535
 536         memset((char *)stf->padding1, '\0', sizeof(stf->padding1));
 537
 538         stf->unknown_4 = unknown_4;
 539         stf->unknown_5 = unknown_4;
 540
 541         stf->unknown_6 = unknown_6;
 542         stf->unknown_7 = unknown_7;
 543
 544         stf->num_sids  = num_sid3s;
 545
 546         stf->padding2  = 0x0000;
 547
 548         memcpy(stf->sid, sid3, sizeof(DOM_SID3) * num_sid3s);
 549 }
 550
 551 /*******************************************************************
 552  Reads or writes a SAM_SID_STUFF structure.
 553 ********************************************************************/
 554
 555 static BOOL sam_io_sid_stuff(char *desc,  SAM_SID_STUFF *stf, prs_struct *ps, int depth)
 556 {
 557         int i;
 558
 559         if (stf == NULL)
 560                 return False;
 561
 562         DEBUG(5,("init_sam_sid_stuff\n"));
 563
 564         if(!prs_uint16("unknown_2", ps, depth, &stf->unknown_2))
 565                 return False;
 566         if(!prs_uint16("unknown_3", ps, depth, &stf->unknown_3))
 567                 return False;
 568
 569         if(!prs_uint8s(False, "padding1", ps, depth, stf->padding1, sizeof(stf->padding1)))
 570                 return False;
 571
 572         if(!prs_uint32("unknown_4", ps, depth, &stf->unknown_4))
 573                 return False;
 574         if(!prs_uint32("unknown_5", ps, depth, &stf->unknown_5))
 575                 return False;
 576         if(!prs_uint16("unknown_6", ps, depth, &stf->unknown_6))
 577                 return False;
 578         if(!prs_uint16("unknown_7", ps, depth, &stf->unknown_7))
 579                 return False;
 580
 581         if(!prs_uint32("num_sids ", ps, depth, &stf->num_sids ))
 582                 return False;
 583         if(!prs_uint16("padding2 ", ps, depth, &stf->padding2 ))
 584                 return False;
 585
 586         SMB_ASSERT_ARRAY(stf->sid, stf->num_sids);
 587
 588         for (i = 0; i < stf->num_sids; i++) {
 589                 if(!sam_io_dom_sid3("", &(stf->sid[i]), ps, depth))
 590                         return False;
 591         }
 592
 593         return True;
 594 }
 595
 596 /*******************************************************************
 597  Inits or writes a SAMR_R_UNKNOWN3 structure.
 598 ********************************************************************/
 599
 600 void init_samr_r_unknown_3(SAMR_R_UNKNOWN_3 *r_u,
 601                                 uint16 unknown_2, uint16 unknown_3,
 602                                 uint32 unknown_4, uint16 unknown_6, uint16 unknown_7,
 603                                 int num_sid3s, DOM_SID3 sid3[MAX_SAM_SIDS],
 604                                 uint32 status)
 605 {
 606         DEBUG(5,("samr_init_r_unknown_3\n"));
 607
 608         r_u->ptr_0 = 0;
 609         r_u->ptr_1 = 0;
 610
 611         if (status == 0x0) {
 612                 r_u->ptr_0 = 1;
 613                 r_u->ptr_1 = 1;
 614                 init_sam_sid_stuff(&(r_u->sid_stuff), unknown_2, unknown_3,
 615                        unknown_4, unknown_6, unknown_7,
 616                        num_sid3s, sid3);
 617         }
 618
 619         r_u->status = status;
 620 }
 621
 622 /*******************************************************************
 623  Reads or writes a SAMR_R_UNKNOWN_3 structure.
 624
 625 this one's odd, because the daft buggers use a different mechanism
 626 for writing out the array of sids. they put the number of sids in
 627 only one place: they've calculated the length of each sid and jumped
 628 by that amount.  then, retrospectively, the length of the whole buffer
 629 is put at the beginning of the data stream.
 630
 631 wierd.
 632
 633 ********************************************************************/
 634
 635 BOOL samr_io_r_unknown_3(char *desc,  SAMR_R_UNKNOWN_3 *r_u, prs_struct *ps, int depth)
 636 {
 637         int ptr_len0=0;
 638         int ptr_len1=0;
 639         int ptr_sid_stuff = 0;
 640
 641         if (r_u == NULL)
 642                 return False;
 643
 644         prs_debug(ps, depth, desc, "samr_io_r_unknown_3");
 645         depth++;
 646
 647         if(!prs_align(ps))
 648                 return False;
 649
 650         if(!prs_uint32("ptr_0         ", ps, depth, &r_u->ptr_0))
 651                 return False;
 652
 653         if (ps->io) {
 654                 /* reading.  do the length later */
 655                 if(!prs_uint32("sid_stuff_len0", ps, depth, &r_u->sid_stuff_len0))
 656                         return False;
 657         } else {
 658                 /* storing */
 659                 ptr_len0 = prs_offset(ps);
 660                 if(!prs_set_offset(ps, ptr_len0 + 4))
 661                         return False;
 662         }
 663
 664         if (r_u->ptr_0 != 0) {
 665                 if(!prs_uint32("ptr_1         ", ps, depth, &r_u->ptr_1))
 666                         return False;
 667                 if (ps->io) {
 668                         /* reading.  do the length later */
 669                         if(!prs_uint32("sid_stuff_len1", ps, depth, &r_u->sid_stuff_len1))
 670                                 return False;
 671                 } else {
 672                         /* storing */
 673                         ptr_len1 = prs_offset(ps);
 674                         if(!prs_set_offset(ps, ptr_len1 + 4))
 675                                 return False;
 676                 }
 677
 678                 if (r_u->ptr_1 != 0) {
 679                         ptr_sid_stuff = prs_offset(ps);
 680                         if(!sam_io_sid_stuff("", &r_u->sid_stuff, ps, depth))
 681                                 return False;
 682                 }
 683         }
 684
 685         if (!(ps->io)) {
 686                 /* storing not reading.  do the length, now. */
 687
 688                 if (ptr_sid_stuff != 0) {
 689                         int old_len = prs_offset(ps);
 690                         uint32 sid_stuff_len = old_len - ptr_sid_stuff;
 691
 692                         if(!prs_set_offset(ps, ptr_len0))
 693                                 return False;
 694                         if(!prs_uint32("sid_stuff_len0", ps, depth, &sid_stuff_len))
 695                                 return False;
 696
 697                         if(!prs_set_offset(ps, ptr_len1))
 698                                 return False;
 699                         if(!prs_uint32("sid_stuff_len1", ps, depth, &sid_stuff_len))
 700                                 return False;
 701
 702                         if(!prs_set_offset(ps, old_len))
 703                                 return False;
 704                 }
 705         }
 706
 707         if(!prs_uint32("status", ps, depth, &r_u->status))
 708                 return False;
 709
 710         return True;
 711 }
 712
 713 /*******************************************************************
 714  Reads or writes a SAM_STR1 structure.
 715 ********************************************************************/
 716
 717 static BOOL sam_io_sam_str1(char *desc, SAM_STR1 *sam, uint32 acct_buf,
 718                                 uint32 name_buf, uint32 desc_buf, prs_struct *ps, int depth)
 719 {
 720         if (sam == NULL)
 721                 return False;
 722
 723         prs_debug(ps, depth, desc, "sam_io_sam_str1");
 724         depth++;
 725
 726         if(!prs_align(ps))
 727                 return False;
 728
 729         if(!smb_io_unistr2("unistr2", &sam->uni_acct_name, acct_buf, ps, depth)) /* account name unicode string */
 730                 return False;
 731         if(!smb_io_unistr2("unistr2", &sam->uni_full_name, name_buf, ps, depth)) /* full name unicode string */
 732                 return False;
 733         if(!smb_io_unistr2("unistr2", &sam->uni_acct_desc, desc_buf, ps, depth)) /* account description unicode string */
 734                 return False;
 735
 736         return True;
 737 }
 738
 739 /*******************************************************************
 740  Inits a SAM_ENTRY1 structure.
 741 ********************************************************************/
 742
 743 static void init_sam_entry1(SAM_ENTRY1 *sam, uint32 user_idx,
 744                                 uint32 len_sam_name, uint32 len_sam_full, uint32 len_sam_desc,
 745                                 uint32 rid_user, uint16 acb_info)
 746 {
 747         DEBUG(5,("init_sam_entry1\n"));
 748
 749         sam->user_idx = user_idx;
 750         sam->rid_user = rid_user;
 751         sam->acb_info = acb_info;
 752         sam->pad      = 0;
 753
 754         init_uni_hdr(&sam->hdr_acct_name, len_sam_name);
 755         init_uni_hdr(&sam->hdr_user_name, len_sam_full);
 756         init_uni_hdr(&sam->hdr_user_desc, len_sam_desc);
 757 }
 758
 759 /*******************************************************************
 760  Reads or writes a SAM_ENTRY1 structure.
 761 ********************************************************************/
 762
 763 static BOOL sam_io_sam_entry1(char *desc,  SAM_ENTRY1 *sam, prs_struct *ps, int depth)
 764 {
 765         if (sam == NULL)
 766                 return False;
 767
 768         prs_debug(ps, depth, desc, "sam_io_sam_entry1");
 769         depth++;
 770
 771         if(!prs_align(ps))
 772                 return False;
 773
 774         if(!prs_uint32("user_idx ", ps, depth, &sam->user_idx))
 775                 return False;
 776
 777         if(!prs_uint32("rid_user ", ps, depth, &sam->rid_user))
 778                 return False;
 779         if(!prs_uint16("acb_info ", ps, depth, &sam->acb_info))
 780                 return False;
 781         if(!prs_uint16("pad      ", ps, depth, &sam->pad))
 782                 return False;
 783
 784         if(!smb_io_unihdr("unihdr", &sam->hdr_acct_name, ps, depth)) /* account name unicode string header */
 785                 return False;
 786         if(!smb_io_unihdr("unihdr", &sam->hdr_user_name, ps, depth)) /* account name unicode string header */
 787                 return False;
 788         if(!smb_io_unihdr("unihdr", &sam->hdr_user_desc, ps, depth)) /* account name unicode string header */
 789                 return False;
 790
 791         return True;
 792 }
 793
 794 /*******************************************************************
 795  Reads or writes a SAM_STR2 structure.
 796 ********************************************************************/
 797
 798 static BOOL sam_io_sam_str2(char *desc,  SAM_STR2 *sam, uint32 acct_buf, uint32 desc_buf, prs_struct *ps, int depth)
 799 {
 800         if (sam == NULL)
 801                 return False;
 802
 803         prs_debug(ps, depth, desc, "sam_io_sam_str2");
 804         depth++;
 805
 806         if(!prs_align(ps))
 807                 return False;
 808
 809         if(!smb_io_unistr2("unistr2", &sam->uni_srv_name, acct_buf, ps, depth)) /* account name unicode string */
 810                 return False;
 811         if(!smb_io_unistr2("unistr2", &sam->uni_srv_desc, desc_buf, ps, depth)) /* account description unicode string */
 812                 return False;
 813
 814         return True;
 815 }
 816
 817 /*******************************************************************
 818  Inits a SAM_ENTRY2 structure.
 819 ********************************************************************/
 820
 821 static void init_sam_entry2(SAM_ENTRY2 *sam, uint32 user_idx,
 822                                 uint32 len_sam_name, uint32 len_sam_desc,
 823                                 uint32 rid_user, uint16 acb_info)
 824 {
 825         DEBUG(5,("init_sam_entry2\n"));
 826
 827         sam->user_idx = user_idx;
 828         sam->rid_user = rid_user;
 829         sam->acb_info = acb_info;
 830         sam->pad      = 0;
 831
 832         init_uni_hdr(&sam->hdr_srv_name, len_sam_name);
 833         init_uni_hdr(&sam->hdr_srv_desc, len_sam_desc);
 834 }
 835
 836 /*******************************************************************
 837  Reads or writes a SAM_ENTRY2 structure.
 838 ********************************************************************/
 839
 840 static BOOL sam_io_sam_entry2(char *desc,  SAM_ENTRY2 *sam, prs_struct *ps, int depth)
 841 {
 842         if (sam == NULL)
 843                 return False;
 844
 845         prs_debug(ps, depth, desc, "sam_io_sam_entry2");
 846         depth++;
 847
 848         if(!prs_align(ps))
 849                 return False;
 850
 851         if(!prs_uint32("user_idx ", ps, depth, &sam->user_idx))
 852                 return False;
 853
 854         if(!prs_uint32("rid_user ", ps, depth, &sam->rid_user))
 855                 return False;
 856         if(!prs_uint16("acb_info ", ps, depth, &sam->acb_info))
 857                 return False;
 858         if(!prs_uint16("pad      ", ps, depth, &sam->pad))
 859                 return False;
 860
 861         if(!smb_io_unihdr("unihdr", &sam->hdr_srv_name, ps, depth)) /* account name unicode string header */
 862                 return False;
 863         if(!smb_io_unihdr("unihdr", &sam->hdr_srv_desc, ps, depth)) /* account name unicode string header */
 864                 return False;
 865
 866         return True;
 867 }
 868
 869 /*******************************************************************
 870  Reads or writes a SAM_STR3 structure.
 871 ********************************************************************/
 872
 873 static BOOL sam_io_sam_str3(char *desc,  SAM_STR3 *sam, uint32 acct_buf, uint32 desc_buf, prs_struct *ps, int depth)
 874 {
 875         if (sam == NULL)
 876                 return False;
 877
 878         prs_debug(ps, depth, desc, "sam_io_sam_str3");
 879         depth++;
 880
 881         if(!prs_align(ps))
 882                 return False;
 883
 884         if(!smb_io_unistr2("unistr2", &sam->uni_grp_name, acct_buf, ps, depth)) /* account name unicode string */
 885                 return False;
 886         if(!smb_io_unistr2("unistr2", &sam->uni_grp_desc, desc_buf, ps, depth)) /* account description unicode string */
 887                 return False;
 888
 889         return True;
 890 }
 891
 892 /*******************************************************************
 893  Inits a SAM_ENTRY3 structure.
 894 ********************************************************************/
 895
 896 static void init_sam_entry3(SAM_ENTRY3 *sam, uint32 grp_idx,
 897                                 uint32 len_grp_name, uint32 len_grp_desc, uint32 rid_grp)
 898 {
 899         DEBUG(5,("init_sam_entry3\n"));
 900
 901         sam->grp_idx = grp_idx;
 902         sam->rid_grp = rid_grp;
 903         sam->attr    = 0x07; /* group rid attributes - gets ignored by nt 4.0 */
 904
 905         init_uni_hdr(&sam->hdr_grp_name, len_grp_name);
 906         init_uni_hdr(&sam->hdr_grp_desc, len_grp_desc);
 907 }
 908
 909 /*******************************************************************
 910  Reads or writes a SAM_ENTRY3 structure.
 911 ********************************************************************/
 912
 913 static BOOL sam_io_sam_entry3(char *desc,  SAM_ENTRY3 *sam, prs_struct *ps, int depth)
 914 {
 915         if (sam == NULL)
 916                 return False;
 917
 918         prs_debug(ps, depth, desc, "sam_io_sam_entry3");
 919         depth++;
 920
 921         if(!prs_align(ps))
 922                 return False;
 923
 924         if(!prs_uint32("grp_idx", ps, depth, &sam->grp_idx))
 925                 return False;
 926
 927         if(!prs_uint32("rid_grp", ps, depth, &sam->rid_grp))
 928                 return False;
 929         if(!prs_uint32("attr   ", ps, depth, &sam->attr))
 930                 return False;
 931
 932         if(!smb_io_unihdr("unihdr", &sam->hdr_grp_name, ps, depth)) /* account name unicode string header */
 933                 return False;
 934         if(!smb_io_unihdr("unihdr", &sam->hdr_grp_desc, ps, depth)) /* account name unicode string header */
 935                 return False;
 936
 937         return True;
 938 }
 939
 940 /*******************************************************************
 941  Inits a SAM_ENTRY structure.
 942 ********************************************************************/
 943
 944 static void init_sam_entry(SAM_ENTRY *sam, uint32 len_sam_name, uint32 rid)
 945 {
 946         DEBUG(5,("init_sam_entry\n"));
 947
 948         sam->rid = rid;
 949         init_uni_hdr(&sam->hdr_name, len_sam_name);
 950 }
 951
 952 /*******************************************************************
 953  Reads or writes a SAM_ENTRY structure.
 954 ********************************************************************/
 955
 956 static BOOL sam_io_sam_entry(char *desc,  SAM_ENTRY *sam, prs_struct *ps, int depth)
 957 {
 958         if (sam == NULL)
 959                 return False;
 960
 961         prs_debug(ps, depth, desc, "sam_io_sam_entry");
 962         depth++;
 963
 964         if(!prs_align(ps))
 965                 return False;
 966         if(!prs_uint32("rid", ps, depth, &sam->rid))
 967                 return False;
 968         if(!smb_io_unihdr("unihdr", &sam->hdr_name, ps, depth)) /* account name unicode string header */
 969                 return False;
 970
 971         return True;
 972 }
 973
 974
 975 /*******************************************************************
 976  Inits a SAMR_Q_ENUM_DOM_USERS structure.
 977 ********************************************************************/
 978
 979 void init_samr_q_enum_dom_users(SAMR_Q_ENUM_DOM_USERS *q_e, POLICY_HND *pol,
 980                                 uint16 req_num_entries, uint16 unk_0,
 981                                 uint16 acb_mask, uint16 unk_1, uint32 size)
 982 {
 983         DEBUG(5,("init_q_enum_dom_users\n"));
 984
 985         memcpy(&q_e->pol, pol, sizeof(*pol));
 986
 987         q_e->req_num_entries = req_num_entries; /* zero indicates lots */
 988         q_e->unknown_0 = unk_0; /* this gets returned in the response */
 989         q_e->acb_mask  = acb_mask;
 990         q_e->unknown_1 = unk_1;
 991         q_e->max_size = size;
 992 }
 993
 994 /*******************************************************************
 995  Reads or writes a structure.
 996 ********************************************************************/
 997
 998 BOOL samr_io_q_enum_dom_users(char *desc,  SAMR_Q_ENUM_DOM_USERS *q_e, prs_struct *ps, int depth)
 999 {
1000         if (q_e == NULL)
1001                 return False;
1002
1003         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_users");
1004         depth++;
1005
1006         if(!prs_align(ps))
1007                 return False;
1008
1009         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
1010                 return False;
1011         if(!prs_align(ps))
1012                 return False;
1013
1014         if(!prs_uint16("req_num_entries", ps, depth, &q_e->req_num_entries))
1015                 return False;
1016         if(!prs_uint16("unknown_0      ", ps, depth, &q_e->unknown_0))
1017                 return False;
1018
1019         if(!prs_uint16("acb_mask       ", ps, depth, &q_e->acb_mask))
1020                 return False;
1021         if(!prs_uint16("unknown_1      ", ps, depth, &q_e->unknown_1))
1022                 return False;
1023
1024         if(!prs_uint32("max_size       ", ps, depth, &q_e->max_size))
1025                 return False;
1026
1027         if(!prs_align(ps))
1028                 return False;
1029
1030         return True;
1031 }
1032
1033
1034 /*******************************************************************
1035  Inits a SAMR_R_ENUM_DOM_USERS structure.
1036 ********************************************************************/
1037
1038 void init_samr_r_enum_dom_users(SAMR_R_ENUM_DOM_USERS *r_u,
1039                 uint16 total_num_entries, uint16 unk_0,
1040                 uint32 num_sam_entries, SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES], uint32 status)
1041 {
1042         int i;
1043
1044         DEBUG(5,("init_samr_r_enum_dom_users\n"));
1045
1046         if (num_sam_entries >= MAX_SAM_ENTRIES) {
1047                 num_sam_entries = MAX_SAM_ENTRIES;
1048                 DEBUG(5,("limiting number of entries to %d\n",
1049                          num_sam_entries));
1050         }
1051
1052         r_u->total_num_entries = total_num_entries;
1053         r_u->unknown_0         = unk_0;
1054
1055         if (total_num_entries > 0) {
1056                 r_u->ptr_entries1 = 1;
1057                 r_u->ptr_entries2 = 1;
1058                 r_u->num_entries2 = num_sam_entries;
1059                 r_u->num_entries3 = num_sam_entries;
1060
1061                 SMB_ASSERT_ARRAY(r_u->sam, num_sam_entries);
1062                 SMB_ASSERT_ARRAY(r_u->uni_acct_name, num_sam_entries);
1063
1064                 for (i = 0; i < num_sam_entries; i++) {
1065                         init_sam_entry(&(r_u->sam[i]),
1066                                        pass[i].uni_user_name.uni_str_len,
1067                                        pass[i].user_rid);
1068
1069                         copy_unistr2(&r_u->uni_acct_name[i], &(pass[i].uni_user_name));
1070                 }
1071
1072                 r_u->num_entries4 = num_sam_entries;
1073         } else {
1074                 r_u->ptr_entries1 = 0;
1075                 r_u->num_entries2 = num_sam_entries;
1076                 r_u->ptr_entries2 = 1;
1077         }
1078
1079         r_u->status = status;
1080 }
1081
1082 /*******************************************************************
1083  Reads or writes a structure.
1084 ********************************************************************/
1085
1086 BOOL samr_io_r_enum_dom_users(char *desc,  SAMR_R_ENUM_DOM_USERS *r_u, prs_struct *ps, int depth)
1087 {
1088         int i;
1089
1090         if (r_u == NULL)
1091                 return False;
1092
1093         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_users");
1094         depth++;
1095
1096         if(!prs_align(ps))
1097                 return False;
1098
1099         if(!prs_uint16("total_num_entries", ps, depth, &r_u->total_num_entries))
1100                 return False;
1101         if(!prs_uint16("unknown_0        ", ps, depth, &r_u->unknown_0))
1102                 return False;
1103         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
1104                 return False;
1105
1106         if (r_u->total_num_entries != 0 && r_u->ptr_entries1 != 0) {
1107                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
1108                         return False;
1109                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
1110                         return False;
1111                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
1112                         return False;
1113
1114                 SMB_ASSERT_ARRAY(r_u->sam, r_u->num_entries2);
1115
1116                 for (i = 0; i < r_u->num_entries2; i++) {
1117                         if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
1118                                 return False;
1119                 }
1120
1121                 SMB_ASSERT_ARRAY(r_u->uni_acct_name, r_u->num_entries2);
1122
1123                 for (i = 0; i < r_u->num_entries2; i++) {
1124                         if(!smb_io_unistr2("", &r_u->uni_acct_name[i],
1125                                         r_u->sam[i].hdr_name.buffer, ps, depth))
1126                                 return False;
1127                 }
1128
1129                 if(!prs_align(ps))
1130                         return False;
1131
1132                 if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
1133                         return False;
1134         }
1135
1136         if(!prs_uint32("status", ps, depth, &r_u->status))
1137                 return False;
1138
1139         return True;
1140 }
1141
1142 /*******************************************************************
1143  Inits a SAMR_Q_ENUM_DOM_ALIASES structure.
1144 ********************************************************************/
1145
1146 void init_samr_q_enum_dom_aliases(SAMR_Q_ENUM_DOM_ALIASES *q_e, POLICY_HND *pol, uint32 size)
1147 {
1148         DEBUG(5,("init_q_enum_dom_aliases\n"));
1149
1150         memcpy(&q_e->pol, pol, sizeof(*pol));
1151
1152         q_e->unknown_0 = 0;
1153         q_e->max_size = size;
1154 }
1155
1156
1157 /*******************************************************************
1158  Reads or writes a structure.
1159 ********************************************************************/
1160
1161 BOOL samr_io_q_enum_dom_aliases(char *desc,  SAMR_Q_ENUM_DOM_ALIASES *q_e, prs_struct *ps, int depth)
1162 {
1163         if (q_e == NULL)
1164                 return False;
1165
1166         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_aliases");
1167         depth++;
1168
1169         if(!prs_align(ps))
1170                 return False;
1171
1172         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
1173                 return False;
1174         if(!prs_align(ps))
1175                 return False;
1176
1177         if(!prs_uint32("unknown_0", ps, depth, &q_e->unknown_0))
1178                 return False;
1179         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size ))
1180                 return False;
1181
1182         if(!prs_align(ps))
1183                 return False;
1184
1185         return True;
1186 }
1187
1188
1189 /*******************************************************************
1190  Inits a SAMR_R_ENUM_DOM_ALIASES structure.
1191 ********************************************************************/
1192
1193 void init_samr_r_enum_dom_aliases(SAMR_R_ENUM_DOM_ALIASES *r_u,
1194                 uint32 num_sam_entries, SAM_USER_INFO_21 grps[MAX_SAM_ENTRIES],
1195                 uint32 status)
1196 {
1197         int i;
1198
1199         DEBUG(5,("init_samr_r_enum_dom_aliases\n"));
1200
1201         if (num_sam_entries >= MAX_SAM_ENTRIES) {
1202                 num_sam_entries = MAX_SAM_ENTRIES;
1203                 DEBUG(5,("limiting number of entries to %d\n",
1204                          num_sam_entries));
1205         }
1206
1207         r_u->num_entries  = num_sam_entries;
1208
1209         if (num_sam_entries > 0) {
1210                 r_u->ptr_entries  = 1;
1211                 r_u->num_entries2 = num_sam_entries;
1212                 r_u->ptr_entries2 = 1;
1213                 r_u->num_entries3 = num_sam_entries;
1214
1215                 SMB_ASSERT_ARRAY(r_u->sam, num_sam_entries);
1216
1217                 for (i = 0; i < num_sam_entries; i++) {
1218                         init_sam_entry(&r_u->sam[i],
1219                                        grps[i].uni_user_name.uni_str_len,
1220                                        grps[i].user_rid);
1221
1222                         copy_unistr2(&r_u->uni_grp_name[i], &(grps[i].uni_user_name));
1223                 }
1224
1225                 r_u->num_entries4 = num_sam_entries;
1226         } else {
1227                 r_u->ptr_entries = 0;
1228         }
1229
1230         r_u->status = status;
1231 }
1232
1233 /*******************************************************************
1234  Reads or writes a structure.
1235 ********************************************************************/
1236
1237 BOOL samr_io_r_enum_dom_aliases(char *desc,  SAMR_R_ENUM_DOM_ALIASES *r_u, prs_struct *ps, int depth)
1238 {
1239         int i;
1240
1241         if (r_u == NULL)
1242                 return False;
1243
1244         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_aliases");
1245         depth++;
1246
1247         if(!prs_align(ps))
1248                 return False;
1249
1250         if(!prs_uint32("num_entries", ps, depth, &r_u->num_entries))
1251                 return False;
1252         if(!prs_uint32("ptr_entries", ps, depth, &r_u->ptr_entries))
1253                 return False;
1254
1255         if (r_u->num_entries != 0 && r_u->ptr_entries != 0) {
1256                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
1257                         return False;
1258                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
1259                         return False;
1260                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
1261                         return False;
1262
1263                 SMB_ASSERT_ARRAY(r_u->sam, r_u->num_entries);
1264
1265                 for (i = 0; i < r_u->num_entries; i++) {
1266                         if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
1267                                 return False;
1268                 }
1269
1270                 for (i = 0; i < r_u->num_entries; i++) {
1271                         if(!smb_io_unistr2("", &r_u->uni_grp_name[i], r_u->sam[i].hdr_name.buffer, ps, depth))
1272                                 return False;
1273                 }
1274
1275                 if(!prs_align(ps))
1276                         return False;
1277
1278                 if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
1279                         return False;
1280         }
1281
1282         if(!prs_uint32("status", ps, depth, &r_u->status))
1283                 return False;
1284
1285         return True;
1286 }
1287
1288
1289 /*******************************************************************
1290  Inits a SAMR_Q_QUERY_DISPINFO structure.
1291 ********************************************************************/
1292
1293 void init_samr_q_query_dispinfo(SAMR_Q_QUERY_DISPINFO *q_e, POLICY_HND *pol,
1294                                 uint16 switch_level, uint32 start_idx, uint32 size)
1295 {
1296         DEBUG(5,("init_q_query_dispinfo\n"));
1297
1298         memcpy(&q_e->pol, pol, sizeof(*pol));
1299
1300         q_e->switch_level = switch_level;
1301
1302         q_e->unknown_0 = 0;
1303         q_e->start_idx = start_idx;
1304         q_e->unknown_1 = 0x000007d0;
1305         q_e->max_size  = size;
1306 }
1307
1308 /*******************************************************************
1309  Reads or writes a structure.
1310 ********************************************************************/
1311
1312 BOOL samr_io_q_query_dispinfo(char *desc,  SAMR_Q_QUERY_DISPINFO *q_e, prs_struct *ps, int depth)
1313 {
1314         if (q_e == NULL)
1315                 return False;
1316
1317         prs_debug(ps, depth, desc, "samr_io_q_query_dispinfo");
1318         depth++;
1319
1320         if(!prs_align(ps))
1321                 return False;
1322
1323         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
1324                 return False;
1325         if(!prs_align(ps))
1326                 return False;
1327
1328         if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
1329                 return False;
1330         if(!prs_uint16("unknown_0   ", ps, depth, &q_e->unknown_0))
1331                 return False;
1332         if(!prs_uint32("start_idx   ", ps, depth, &q_e->start_idx))
1333                 return False;
1334         if(!prs_uint32("unknown_1   ", ps, depth, &q_e->unknown_1))
1335                 return False;
1336         if(!prs_uint32("max_size    ", ps, depth, &q_e->max_size))
1337                 return False;
1338
1339         if(!prs_align(ps))
1340                 return False;
1341
1342         return True;
1343 }
1344
1345
1346 /*******************************************************************
1347  Inits a SAM_INFO_2 structure.
1348 ********************************************************************/
1349
1350 void init_sam_info_2(SAM_INFO_2 *sam, uint32 acb_mask,
1351                 uint32 start_idx, uint32 num_sam_entries,
1352                 SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
1353 {
1354         int i;
1355         int entries_added;
1356
1357         DEBUG(5,("init_sam_info_2\n"));
1358
1359         if (num_sam_entries >= MAX_SAM_ENTRIES) {
1360                 num_sam_entries = MAX_SAM_ENTRIES;
1361                 DEBUG(5,("limiting number of entries to %d\n",
1362                          num_sam_entries));
1363         }
1364
1365         for (i = start_idx, entries_added = 0; i < num_sam_entries; i++) {
1366                 if (IS_BITS_SET_ALL(pass[i].acb_info, acb_mask)) {
1367                         init_sam_entry2(&sam->sam[entries_added],
1368                                         start_idx + entries_added + 1,
1369                                         pass[i].uni_user_name.uni_str_len,
1370                                         pass[i].uni_acct_desc.uni_str_len,
1371                                         pass[i].user_rid,
1372                                         pass[i].acb_info);
1373
1374                         copy_unistr2(&sam->str[entries_added].uni_srv_name, &pass[i].uni_user_name);
1375                         copy_unistr2(&sam->str[entries_added].uni_srv_desc, &pass[i].uni_acct_desc);
1376
1377                         entries_added++;
1378                 }
1379
1380                 sam->num_entries   = entries_added;
1381                 sam->ptr_entries   = 1;
1382                 sam->num_entries2  = entries_added;
1383         }
1384 }
1385
1386 /*******************************************************************
1387  Reads or writes a structure.
1388 ********************************************************************/
1389
1390 static BOOL sam_io_sam_info_2(char *desc,  SAM_INFO_2 *sam, prs_struct *ps, int depth)
1391 {
1392         int i;
1393
1394         if (sam == NULL)
1395                 return False;
1396
1397         prs_debug(ps, depth, desc, "sam_io_sam_info_2");
1398         depth++;
1399
1400         if(!prs_align(ps))
1401                 return False;
1402
1403         if(!prs_uint32("num_entries  ", ps, depth, &sam->num_entries))
1404                 return False;
1405         if(!prs_uint32("ptr_entries  ", ps, depth, &sam->ptr_entries))
1406                 return False;
1407
1408         if(!prs_uint32("num_entries2 ", ps, depth, &sam->num_entries2))
1409                 return False;
1410
1411         SMB_ASSERT_ARRAY(sam->sam, sam->num_entries);
1412
1413         for (i = 0; i < sam->num_entries; i++) {
1414                 if(!sam_io_sam_entry2("", &sam->sam[i], ps, depth))
1415                         return False;
1416         }
1417
1418         for (i = 0; i < sam->num_entries; i++) {
1419                 if(!sam_io_sam_str2 ("", &sam->str[i],
1420                                  sam->sam[i].hdr_srv_name.buffer,
1421                                  sam->sam[i].hdr_srv_desc.buffer,
1422                                  ps, depth))
1423                         return False;
1424         }
1425
1426         return True;
1427 }
1428
1429 /*******************************************************************
1430  Inits a SAM_INFO_1 structure.
1431 ********************************************************************/
1432
1433 void init_sam_info_1(SAM_INFO_1 *sam, uint32 acb_mask,
1434                 uint32 start_idx, uint32 num_sam_entries,
1435                 SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
1436 {
1437         int i;
1438         int entries_added;
1439
1440         DEBUG(5,("init_sam_info_1\n"));
1441
1442         if (num_sam_entries >= MAX_SAM_ENTRIES) {
1443                 num_sam_entries = MAX_SAM_ENTRIES;
1444                 DEBUG(5,("limiting number of entries to %d\n",
1445                          num_sam_entries));
1446         }
1447
1448         for (i = start_idx, entries_added = 0; i < num_sam_entries; i++) {
1449                 if (IS_BITS_SET_ALL(pass[i].acb_info, acb_mask)) {
1450                         init_sam_entry1(&sam->sam[entries_added],
1451                                                 start_idx + entries_added + 1,
1452                                                 pass[i].uni_user_name.uni_str_len,
1453                                                 pass[i].uni_full_name.uni_str_len,
1454                                                 pass[i].uni_acct_desc.uni_str_len,
1455                                                 pass[i].user_rid,
1456                                                 pass[i].acb_info);
1457
1458                         copy_unistr2(&sam->str[entries_added].uni_acct_name, &pass[i].uni_user_name);
1459                         copy_unistr2(&sam->str[entries_added].uni_full_name, &pass[i].uni_full_name);
1460                         copy_unistr2(&sam->str[entries_added].uni_acct_desc, &pass[i].uni_acct_desc);
1461
1462                         entries_added++;
1463                 }
1464         }
1465
1466         sam->num_entries   = entries_added;
1467         sam->ptr_entries   = 1;
1468         sam->num_entries2  = entries_added;
1469 }
1470
1471 /*******************************************************************
1472  Reads or writes a structure.
1473 ********************************************************************/
1474
1475 static BOOL sam_io_sam_info_1(char *desc,  SAM_INFO_1 *sam, prs_struct *ps, int depth)
1476 {
1477         int i;
1478
1479         if (sam == NULL)
1480                 return False;
1481
1482         prs_debug(ps, depth, desc, "sam_io_sam_info_1");
1483         depth++;
1484
1485         if(!prs_align(ps))
1486                 return False;
1487
1488         if(!prs_uint32("num_entries  ", ps, depth, &sam->num_entries))
1489                 return False;
1490         if(!prs_uint32("ptr_entries  ", ps, depth, &sam->ptr_entries))
1491                 return False;
1492
1493         if(!prs_uint32("num_entries2 ", ps, depth, &sam->num_entries2))
1494                 return False;
1495
1496         SMB_ASSERT_ARRAY(sam->sam, sam->num_entries);
1497
1498         for (i = 0; i < sam->num_entries; i++) {
1499                 if(!sam_io_sam_entry1("", &sam->sam[i], ps, depth))
1500                         return False;
1501         }
1502
1503         for (i = 0; i < sam->num_entries; i++) {
1504                 if(!sam_io_sam_str1 ("", &sam->str[i],
1505                                                          sam->sam[i].hdr_acct_name.buffer,
1506                                                          sam->sam[i].hdr_user_name.buffer,
1507                                                          sam->sam[i].hdr_user_desc.buffer,
1508                                                          ps, depth))
1509                 return False;
1510         }
1511
1512         return True;
1513 }
1514
1515 /*******************************************************************
1516  Inits a SAMR_R_QUERY_DISPINFO structure.
1517 ********************************************************************/
1518
1519 void init_samr_r_query_dispinfo(SAMR_R_QUERY_DISPINFO *r_u,
1520                 uint16 switch_level, SAM_INFO_CTR *ctr, uint32 status)
1521 {
1522         DEBUG(5,("init_samr_r_query_dispinfo\n"));
1523
1524         if (status == 0x0) {
1525                 r_u->unknown_0 = 0x0000001;
1526                 r_u->unknown_1 = 0x0000001;
1527         } else {
1528                 r_u->unknown_0 = 0x0;
1529                 r_u->unknown_1 = 0x0;
1530         }
1531
1532         r_u->switch_level = switch_level;
1533         r_u->ctr = ctr;
1534         r_u->status = status;
1535 }
1536
1537 /*******************************************************************
1538  Reads or writes a structure.
1539 ********************************************************************/
1540
1541 BOOL samr_io_r_query_dispinfo(char *desc,  SAMR_R_QUERY_DISPINFO *r_u, prs_struct *ps, int depth)
1542 {
1543         if (r_u == NULL)
1544                 return False;
1545
1546         prs_debug(ps, depth, desc, "samr_io_r_query_dispinfo");
1547         depth++;
1548
1549         if(!prs_align(ps))
1550                 return False;
1551
1552         if(!prs_uint32("unknown_0    ", ps, depth, &r_u->unknown_0))
1553                 return False;
1554         if(!prs_uint32("unknown_1    ", ps, depth, &r_u->unknown_1))
1555                 return False;
1556         if(!prs_uint16("switch_level ", ps, depth, &r_u->switch_level))
1557                 return False;
1558
1559         if(!prs_align(ps))
1560                 return False;
1561
1562         switch (r_u->switch_level) {
1563         case 0x1:
1564                 if(!sam_io_sam_info_1("users", r_u->ctr->sam.info1, ps, depth))
1565                         return False;
1566                 break;
1567         case 0x2:
1568                 if(!sam_io_sam_info_2("servers", r_u->ctr->sam.info2, ps, depth))
1569                         return False;
1570                 break;
1571         default:
1572                 DEBUG(5,("samr_io_r_query_dispinfo: unknown switch value\n"));
1573                 break;
1574         }
1575
1576         if(!prs_uint32("status", ps, depth, &r_u->status))
1577                 return False;
1578
1579         return True;
1580 }
1581
1582 /*******************************************************************
1583  Inits a SAMR_Q_ENUM_DOM_GROUPS structure.
1584 ********************************************************************/
1585
1586 void init_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS *q_e, POLICY_HND *pol,
1587                                 uint16 switch_level, uint32 start_idx, uint32 size)
1588 {
1589         DEBUG(5,("init_q_enum_dom_groups\n"));
1590
1591         memcpy(&q_e->pol, pol, sizeof(*pol));
1592
1593         q_e->switch_level = switch_level;
1594
1595         q_e->unknown_0 = 0;
1596         q_e->start_idx = start_idx;
1597         q_e->unknown_1 = 0x000007d0;
1598         q_e->max_size  = size;
1599 }
1600
1601 /*******************************************************************
1602  Reads or writes a structure.
1603 ********************************************************************/
1604
1605 BOOL samr_io_q_enum_dom_groups(char *desc,  SAMR_Q_ENUM_DOM_GROUPS *q_e, prs_struct *ps, int depth)
1606 {
1607         if (q_e == NULL)
1608                 return False;
1609
1610         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_groups");
1611         depth++;
1612
1613         if(!prs_align(ps))
1614                 return False;
1615
1616         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
1617                 return False;
1618         if(!prs_align(ps))
1619                 return False;
1620
1621         if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
1622                 return False;
1623         if(!prs_uint16("unknown_0   ", ps, depth, &q_e->unknown_0))
1624                 return False;
1625         if(!prs_uint32("start_idx   ", ps, depth, &q_e->start_idx))
1626                 return False;
1627         if(!prs_uint32("unknown_1   ", ps, depth, &q_e->unknown_1))
1628                 return False;
1629         if(!prs_uint32("max_size    ", ps, depth, &q_e->max_size))
1630                 return False;
1631
1632         if(!prs_align(ps))
1633                 return False;
1634
1635         return True;
1636 }
1637
1638
1639 /*******************************************************************
1640  Inits a SAMR_R_ENUM_DOM_GROUPS structure.
1641 ********************************************************************/
1642
1643 void init_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS *r_u,
1644                 uint32 start_idx, uint32 num_sam_entries,
1645                 SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES],
1646                 uint32 status)
1647 {
1648         int i;
1649         int entries_added;
1650
1651         DEBUG(5,("init_samr_r_enum_dom_groups\n"));
1652
1653         if (num_sam_entries >= MAX_SAM_ENTRIES) {
1654                 num_sam_entries = MAX_SAM_ENTRIES;
1655                 DEBUG(5,("limiting number of entries to %d\n",
1656                          num_sam_entries));
1657         }
1658
1659         if (status == 0x0) {
1660                 for (i = start_idx, entries_added = 0; i < num_sam_entries; i++) {
1661                         init_sam_entry3(&r_u->sam[entries_added],
1662                                         start_idx + entries_added + 1,
1663                                         pass[i].uni_user_name.uni_str_len,
1664                                         pass[i].uni_acct_desc.uni_str_len,
1665                                         pass[i].user_rid);
1666
1667                         copy_unistr2(&r_u->str[entries_added].uni_grp_name,
1668                                                 &pass[i].uni_user_name);
1669                         copy_unistr2(&r_u->str[entries_added].uni_grp_desc,
1670                                                 &pass[i].uni_acct_desc);
1671
1672                         entries_added++;
1673                 }
1674
1675                 if (entries_added > 0) {
1676                         r_u->unknown_0 = 0x0000492;
1677                         r_u->unknown_1 = 0x000049a;
1678                 } else {
1679                         r_u->unknown_0 = 0x0;
1680                         r_u->unknown_1 = 0x0;
1681                 }
1682                 r_u->switch_level  = 3;
1683                 r_u->num_entries   = entries_added;
1684                 r_u->ptr_entries   = 1;
1685                 r_u->num_entries2  = entries_added;
1686         } else {
1687                 r_u->switch_level = 0;
1688         }
1689
1690         r_u->status = status;
1691 }
1692
1693 /*******************************************************************
1694  Reads or writes a structure.
1695 ********************************************************************/
1696
1697 BOOL samr_io_r_enum_dom_groups(char *desc,  SAMR_R_ENUM_DOM_GROUPS *r_u, prs_struct *ps, int depth)
1698 {
1699         int i;
1700
1701         if (r_u == NULL)
1702                 return False;
1703
1704         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_groups");
1705         depth++;
1706
1707         if(!prs_align(ps))
1708                 return False;
1709
1710         if(!prs_uint32("unknown_0    ", ps, depth, &r_u->unknown_0))
1711                 return False;
1712         if(!prs_uint32("unknown_1    ", ps, depth, &r_u->unknown_1))
1713                 return False;
1714         if(!prs_uint32("switch_level ", ps, depth, &r_u->switch_level))
1715                 return False;
1716
1717         if (r_u->switch_level != 0) {
1718                 if(!prs_uint32("num_entries  ", ps, depth, &r_u->num_entries))
1719                         return False;
1720                 if(!prs_uint32("ptr_entries  ", ps, depth, &r_u->ptr_entries))
1721                         return False;
1722
1723                 if(!prs_uint32("num_entries2 ", ps, depth, &r_u->num_entries2))
1724                         return False;
1725
1726                 SMB_ASSERT_ARRAY(r_u->sam, r_u->num_entries);
1727
1728                 for (i = 0; i < r_u->num_entries; i++) {
1729                         if(!sam_io_sam_entry3("", &r_u->sam[i], ps, depth))
1730                                 return False;
1731                 }
1732
1733                 for (i = 0; i < r_u->num_entries; i++) {
1734                         if(!sam_io_sam_str3 ("", &r_u->str[i],
1735                                              r_u->sam[i].hdr_grp_name.buffer,
1736                                              r_u->sam[i].hdr_grp_desc.buffer,
1737                                              ps, depth))
1738                                 return False;
1739                 }
1740         }
1741
1742         if(!prs_uint32("status", ps, depth, &r_u->status))
1743                 return False;
1744
1745         return True;
1746 }
1747
1748 /*******************************************************************
1749  Inits a SAMR_Q_QUERY_ALIASINFO structure.
1750 ********************************************************************/
1751
1752 void init_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO *q_e,
1753                                 POLICY_HND *pol,
1754                                 uint16 switch_level)
1755 {
1756         DEBUG(5,("init_q_query_aliasinfo\n"));
1757
1758         memcpy(&q_e->pol, pol, sizeof(*pol));
1759
1760         q_e->switch_level = switch_level;
1761 }
1762
1763 /*******************************************************************
1764  Reads or writes a structure.
1765 ********************************************************************/
1766
1767 BOOL samr_io_q_query_aliasinfo(char *desc,  SAMR_Q_QUERY_ALIASINFO *q_e, prs_struct *ps, int depth)
1768 {
1769         if (q_e == NULL)
1770                 return False;
1771
1772         prs_debug(ps, depth, desc, "samr_io_q_query_aliasinfo");
1773         depth++;
1774
1775         if(!prs_align(ps))
1776                 return False;
1777
1778         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
1779                 return False;
1780         if(!prs_align(ps))
1781                 return False;
1782
1783         if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
1784                 return False;
1785
1786         return True;
1787 }
1788
1789 /*******************************************************************
1790  Inits a SAMR_R_QUERY_ALIASINFO structure.
1791 ********************************************************************/
1792
1793 void init_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *r_u,
1794                 uint16 switch_value, char *acct_desc,
1795                 uint32 status)
1796 {
1797         DEBUG(5,("init_samr_r_query_aliasinfo\n"));
1798
1799         r_u->ptr = 0;
1800
1801         if (status == 0) {
1802                 r_u->switch_value = switch_value;
1803
1804                 switch (switch_value) {
1805                         case 3:
1806                         {
1807                                 int acct_len = acct_desc ? strlen(acct_desc) : 0;
1808
1809                                 r_u->ptr = 1;
1810
1811                                 init_uni_hdr(&r_u->alias.info3.hdr_acct_desc, acct_len);
1812                                 init_unistr2(&r_u->alias.info3.uni_acct_desc, acct_desc, acct_len);
1813
1814                                 break;
1815                         }
1816                         default:
1817                                 DEBUG(4,("init_samr_r_query_aliasinfo: unsupported switch level\n"));
1818                                 break;
1819                 }
1820         }
1821
1822         r_u->status = status;
1823 }
1824
1825 /*******************************************************************
1826  Reads or writes a structure.
1827 ********************************************************************/
1828
1829 BOOL samr_io_r_query_aliasinfo(char *desc,  SAMR_R_QUERY_ALIASINFO *r_u, prs_struct *ps, int depth)
1830 {
1831         if (r_u == NULL)
1832                 return False;
1833
1834         prs_debug(ps, depth, desc, "samr_io_r_query_aliasinfo");
1835         depth++;
1836
1837         if(!prs_align(ps))
1838                 return False;
1839
1840         if(!prs_uint32("ptr         ", ps, depth, &r_u->ptr))
1841                 return False;
1842
1843         if (r_u->ptr != 0) {
1844                 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
1845                         return False;
1846                 if(!prs_align(ps))
1847                         return False;
1848
1849                 if (r_u->switch_value != 0) {
1850                         switch (r_u->switch_value) {
1851                                 case 3:
1852                                         if(!smb_io_unihdr ("", &r_u->alias.info3.hdr_acct_desc, ps, depth))
1853                                                 return False;
1854                                         if(!smb_io_unistr2("", &r_u->alias.info3.uni_acct_desc,
1855                                                         r_u->alias.info3.hdr_acct_desc.buffer, ps, depth))
1856                                                 return False;
1857                                         break;
1858                                 default:
1859                                         DEBUG(4,("samr_io_r_query_aliasinfo: unsupported switch level\n"));
1860                                         break;
1861                         }
1862                 }
1863         }
1864
1865         if(!prs_align(ps))
1866                 return False;
1867
1868         if(!prs_uint32("status", ps, depth, &r_u->status))
1869                 return False;
1870
1871         return True;
1872 }
1873
1874 /*******************************************************************
1875  Reads or writes a SAMR_Q_LOOKUP_IDS structure.
1876 ********************************************************************/
1877
1878 BOOL samr_io_q_lookup_ids(char *desc,  SAMR_Q_LOOKUP_IDS *q_u, prs_struct *ps, int depth)
1879 {
1880         fstring tmp;
1881         int i;
1882
1883         if (q_u == NULL)
1884                 return False;
1885
1886         prs_debug(ps, depth, desc, "samr_io_q_lookup_ids");
1887         depth++;
1888
1889         if(!prs_align(ps))
1890                 return False;
1891
1892         if(!smb_io_pol_hnd("pol", &(q_u->pol), ps, depth))
1893                 return False;
1894         if(!prs_align(ps))
1895                 return False;
1896
1897         if(!prs_uint32("num_sids1", ps, depth, &q_u->num_sids1))
1898                 return False;
1899         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
1900                 return False;
1901         if(!prs_uint32("num_sids2", ps, depth, &q_u->num_sids2))
1902                 return False;
1903
1904         SMB_ASSERT_ARRAY(q_u->ptr_sid, q_u->num_sids2);
1905
1906         for (i = 0; i < q_u->num_sids2; i++) {
1907                 slprintf(tmp, sizeof(tmp) - 1, "ptr[%02d]", i);
1908                 if(!prs_uint32(tmp, ps, depth, &q_u->ptr_sid[i]))
1909                         return False;
1910         }
1911
1912         for (i = 0; i < q_u->num_sids2; i++) {
1913                 if (q_u->ptr_sid[i] != 0) {
1914                         slprintf(tmp, sizeof(tmp)-1, "sid[%02d]", i);
1915                         if(!smb_io_dom_sid2(tmp, &q_u->sid[i], ps, depth))
1916                                 return False;
1917                 }
1918         }
1919
1920         if(!prs_align(ps))
1921                 return False;
1922
1923         return True;
1924 }
1925
1926 /*******************************************************************
1927  Inits a SAMR_R_LOOKUP_IDS structure.
1928 ********************************************************************/
1929
1930 void init_samr_r_lookup_ids(SAMR_R_LOOKUP_IDS *r_u,
1931                 uint32 num_rids, uint32 *rid, uint32 status)
1932 {
1933         int i;
1934
1935         DEBUG(5,("init_samr_r_lookup_ids\n"));
1936
1937         if (status == 0x0) {
1938                 r_u->num_entries  = num_rids;
1939                 r_u->ptr = 1;
1940                 r_u->num_entries2 = num_rids;
1941
1942                 SMB_ASSERT_ARRAY(r_u->rid, num_rids);
1943
1944                 for (i = 0; i < num_rids; i++) {
1945                         r_u->rid[i] = rid[i];
1946                 }
1947         } else {
1948                 r_u->num_entries  = 0;
1949                 r_u->ptr = 0;
1950                 r_u->num_entries2 = 0;
1951         }
1952
1953         r_u->status = status;
1954 }
1955
1956 /*******************************************************************
1957  Reads or writes a structure.
1958 ********************************************************************/
1959
1960 BOOL samr_io_r_lookup_ids(char *desc,  SAMR_R_LOOKUP_IDS *r_u, prs_struct *ps, int depth)
1961 {
1962         fstring tmp;
1963         int i;
1964
1965         if (r_u == NULL)
1966                 return False;
1967
1968         prs_debug(ps, depth, desc, "samr_io_r_lookup_ids");
1969         depth++;
1970
1971         if(!prs_align(ps))
1972                 return False;
1973
1974         if(!prs_uint32("num_entries", ps, depth, &r_u->num_entries))
1975                 return False;
1976         if(!prs_uint32("ptr        ", ps, depth, &r_u->ptr))
1977                 return False;
1978         if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
1979                 return False;
1980
1981         if (r_u->num_entries != 0) {
1982                 SMB_ASSERT_ARRAY(r_u->rid, r_u->num_entries2);
1983
1984                 for (i = 0; i < r_u->num_entries2; i++) {
1985                         slprintf(tmp, sizeof(tmp)-1, "rid[%02d]", i);
1986                         if(!prs_uint32(tmp, ps, depth, &r_u->rid[i]))
1987                                 return False;
1988                 }
1989         }
1990
1991         if(!prs_uint32("status", ps, depth, &r_u->status))
1992                 return False;
1993
1994         return True;
1995 }
1996
1997 /*******************************************************************
1998  Reads or writes a structure.
1999 ********************************************************************/
2000
2001 BOOL samr_io_q_lookup_names(char *desc,  SAMR_Q_LOOKUP_NAMES *q_u, prs_struct *ps, int depth)
2002 {
2003         int i;
2004
2005         if (q_u == NULL)
2006                 return False;
2007
2008         prs_debug(ps, depth, desc, "samr_io_q_lookup_names");
2009         depth++;
2010
2011         prs_align(ps);
2012
2013         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
2014                 return False;
2015         if(!prs_align(ps))
2016                 return False;
2017
2018         if(!prs_uint32("num_names1", ps, depth, &q_u->num_names1))
2019                 return False;
2020         if(!prs_uint32("flags     ", ps, depth, &q_u->flags))
2021                 return False;
2022         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
2023                 return False;
2024         if(!prs_uint32("num_names2", ps, depth, &q_u->num_names2))
2025                 return False;
2026
2027         SMB_ASSERT_ARRAY(q_u->hdr_name, q_u->num_names2);
2028
2029         for (i = 0; i < q_u->num_names2; i++) {
2030                 if(!smb_io_unihdr ("", &q_u->hdr_name[i], ps, depth))
2031                         return False;
2032         }
2033         for (i = 0; i < q_u->num_names2; i++) {
2034                 if(!smb_io_unistr2("", &q_u->uni_name[i], q_u->hdr_name[i].buffer, ps, depth))
2035                         return False;
2036         }
2037
2038         return True;
2039 }
2040
2041
2042 /*******************************************************************
2043  Inits a SAMR_R_LOOKUP_NAMES structure.
2044 ********************************************************************/
2045
2046 void init_samr_r_lookup_names(SAMR_R_LOOKUP_NAMES *r_u,
2047                         uint32 num_rids, uint32 *rid, uint8 *type, uint32 status)
2048 {
2049         int i;
2050
2051         DEBUG(5,("init_samr_r_lookup_names\n"));
2052
2053         if (status == 0x0) {
2054                 r_u->num_types1 = num_rids;
2055                 r_u->ptr_types  = 1;
2056                 r_u->num_types2 = num_rids;
2057
2058                 r_u->num_rids1 = num_rids;
2059                 r_u->ptr_rids  = 1;
2060                 r_u->num_rids2 = num_rids;
2061
2062                 SMB_ASSERT_ARRAY(r_u->rid, num_rids);
2063
2064                 for (i = 0; i < num_rids; i++) {
2065                         r_u->rid [i] = rid [i];
2066                         r_u->type[i] = type[i];
2067                 }
2068         } else {
2069                 r_u->num_types1 = 0;
2070                 r_u->ptr_types  = 0;
2071                 r_u->num_types2 = 0;
2072
2073                 r_u->num_rids1 = 0;
2074                 r_u->ptr_rids  = 0;
2075                 r_u->num_rids2 = 0;
2076         }
2077
2078         r_u->status = status;
2079 }
2080
2081 /*******************************************************************
2082  Reads or writes a structure.
2083 ********************************************************************/
2084
2085 BOOL samr_io_r_lookup_names(char *desc,  SAMR_R_LOOKUP_NAMES *r_u, prs_struct *ps, int depth)
2086 {
2087         int i;
2088         fstring tmp;
2089
2090         if (r_u == NULL)
2091                 return False;
2092
2093         prs_debug(ps, depth, desc, "samr_io_r_lookup_names");
2094         depth++;
2095
2096         if(!prs_align(ps))
2097                 return False;
2098
2099         if(!prs_uint32("num_rids1", ps, depth, &r_u->num_rids1))
2100                 return False;
2101         if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids ))
2102                 return False;
2103
2104         if (r_u->ptr_rids != 0) {
2105                 if(!prs_uint32("num_rids2", ps, depth, &r_u->num_rids2))
2106                         return False;
2107
2108                 if (r_u->num_rids2 != r_u->num_rids1) {
2109                         /* RPC fault */
2110                         return False;
2111                 }
2112
2113                 for (i = 0; i < r_u->num_rids2; i++) {
2114                         slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]  ", i);
2115                         if(!prs_uint32(tmp, ps, depth, &r_u->rid[i]))
2116                                 return False;
2117                 }
2118         }
2119
2120         if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
2121                 return False;
2122         if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
2123                 return False;
2124
2125         if (r_u->ptr_types != 0) {
2126                 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
2127                         return False;
2128
2129                 if (r_u->num_types2 != r_u->num_types1) {
2130                         /* RPC fault */
2131                         return False;
2132                 }
2133
2134                 for (i = 0; i < r_u->num_types2; i++) {
2135                         slprintf(tmp, sizeof(tmp) - 1, "type[%02d]  ", i);
2136                         if(!prs_uint32(tmp, ps, depth, &r_u->type[i]))
2137                                 return False;
2138                 }
2139         }
2140
2141         if(!prs_uint32("status", ps, depth, &r_u->status))
2142                 return False;
2143
2144         return True;
2145 }
2146
2147 /*******************************************************************
2148  Reads or writes a structure.
2149 ********************************************************************/
2150
2151 BOOL samr_io_q_unknown_12(char *desc,  SAMR_Q_UNKNOWN_12 *q_u, prs_struct *ps, int depth)
2152 {
2153         int i;
2154         fstring tmp;
2155
2156         if (q_u == NULL)
2157                 return False;
2158
2159         prs_debug(ps, depth, desc, "samr_io_q_unknown_12");
2160         depth++;
2161
2162         if(!prs_align(ps))
2163                 return False;
2164
2165         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
2166                 return False;
2167         if(!prs_align(ps))
2168                 return False;
2169
2170         if(!prs_uint32("num_gids1", ps, depth, &q_u->num_gids1))
2171                 return False;
2172         if(!prs_uint32("rid      ", ps, depth, &q_u->rid))
2173                 return False;
2174         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
2175                 return False;
2176         if(!prs_uint32("num_gids2", ps, depth, &q_u->num_gids2))
2177                 return False;
2178
2179         SMB_ASSERT_ARRAY(q_u->gid, q_u->num_gids2);
2180
2181         for (i = 0; i < q_u->num_gids2; i++) {
2182                 slprintf(tmp, sizeof(tmp) - 1, "gid[%02d]  ", i);
2183                 if(!prs_uint32(tmp, ps, depth, &q_u->gid[i]))
2184                         return False;
2185         }
2186
2187         if(!prs_align(ps))
2188                 return False;
2189
2190         return True;
2191 }
2192
2193 /*******************************************************************
2194  Inits a SAMR_R_UNKNOWN_12 structure.
2195 ********************************************************************/
2196
2197 void init_samr_r_unknown_12(SAMR_R_UNKNOWN_12 *r_u,
2198                 uint32 num_aliases, fstring *als_name, uint32 *num_als_usrs,
2199                 uint32 status)
2200 {
2201         int i;
2202
2203         DEBUG(5,("init_samr_r_unknown_12\n"));
2204
2205         if (status == 0x0) {
2206                 r_u->num_aliases1 = num_aliases;
2207                 r_u->ptr_aliases  = 1;
2208                 r_u->num_aliases2 = num_aliases;
2209
2210                 r_u->num_als_usrs1 = num_aliases;
2211                 r_u->ptr_als_usrs  = 1;
2212                 r_u->num_als_usrs2 = num_aliases;
2213
2214                 SMB_ASSERT_ARRAY(r_u->hdr_als_name, num_aliases);
2215
2216                 for (i = 0; i < num_aliases; i++) {
2217                         int als_len = als_name[i] != NULL ? strlen(als_name[i]) : 0;
2218                         init_uni_hdr(&r_u->hdr_als_name[i], als_len);
2219                         init_unistr2(&r_u->uni_als_name[i], als_name[i], als_len);
2220                         r_u->num_als_usrs[i] = num_als_usrs[i];
2221                 }
2222         } else {
2223                 r_u->num_aliases1 = num_aliases;
2224                 r_u->ptr_aliases  = 0;
2225                 r_u->num_aliases2 = num_aliases;
2226
2227                 r_u->num_als_usrs1 = num_aliases;
2228                 r_u->ptr_als_usrs  = 0;
2229                 r_u->num_als_usrs2 = num_aliases;
2230         }
2231
2232         r_u->status = status;
2233 }
2234
2235 /*******************************************************************
2236  Reads or writes a structure.
2237 ********************************************************************/
2238
2239 BOOL samr_io_r_unknown_12(char *desc,  SAMR_R_UNKNOWN_12 *r_u, prs_struct *ps, int depth)
2240 {
2241         int i;
2242         fstring tmp;
2243
2244         if (r_u == NULL)
2245                 return False;
2246
2247         prs_debug(ps, depth, desc, "samr_io_r_unknown_12");
2248         depth++;
2249
2250         if(!prs_align(ps))
2251                 return False;
2252
2253         if(!prs_uint32("num_aliases1", ps, depth, &r_u->num_aliases1))
2254                 return False;
2255         if(!prs_uint32("ptr_aliases ", ps, depth, &r_u->ptr_aliases ))
2256                 return False;
2257         if(!prs_uint32("num_aliases2", ps, depth, &r_u->num_aliases2))
2258                 return False;
2259
2260         if (r_u->ptr_aliases != 0 && r_u->num_aliases1 != 0) {
2261                 SMB_ASSERT_ARRAY(r_u->hdr_als_name, r_u->num_aliases2);
2262
2263                 for (i = 0; i < r_u->num_aliases2; i++) {
2264                         slprintf(tmp, sizeof(tmp) - 1, "als_hdr[%02d]  ", i);
2265                         if(!smb_io_unihdr ("", &r_u->hdr_als_name[i], ps, depth))
2266                                 return False;
2267                 }
2268                 for (i = 0; i < r_u->num_aliases2; i++) {
2269                         slprintf(tmp, sizeof(tmp) - 1, "als_str[%02d]  ", i);
2270                         if(!smb_io_unistr2("", &r_u->uni_als_name[i], r_u->hdr_als_name[i].buffer, ps, depth))
2271                                 return False;
2272                 }
2273         }
2274
2275         if(!prs_align(ps))
2276                 return False;
2277
2278         if(!prs_uint32("num_als_usrs1", ps, depth, &r_u->num_als_usrs1))
2279                 return False;
2280         if(!prs_uint32("ptr_als_usrs ", ps, depth, &r_u->ptr_als_usrs))
2281                 return False;
2282         if(!prs_uint32("num_als_usrs2", ps, depth, &r_u->num_als_usrs2))
2283                 return False;
2284
2285         if (r_u->ptr_als_usrs != 0 && r_u->num_als_usrs1 != 0) {
2286                 SMB_ASSERT_ARRAY(r_u->num_als_usrs, r_u->num_als_usrs2);
2287
2288                 for (i = 0; i < r_u->num_als_usrs2; i++) {
2289                         slprintf(tmp, sizeof(tmp) - 1, "als_usrs[%02d]  ", i);
2290                         if(!prs_uint32(tmp, ps, depth, &r_u->num_als_usrs[i]))
2291                                 return False;
2292                 }
2293         }
2294
2295         if(!prs_uint32("status", ps, depth, &r_u->status))
2296                 return False;
2297
2298         return True;
2299 }
2300
2301
2302 /*******************************************************************
2303  Inits a SAMR_Q_OPEN_USER struct.
2304 ********************************************************************/
2305
2306 void init_samr_q_open_user(SAMR_Q_OPEN_USER *q_u,
2307                                 POLICY_HND *pol,
2308                                 uint32 unk_0, uint32 rid)
2309 {
2310         DEBUG(5,("samr_init_q_open_user\n"));
2311
2312         memcpy(&q_u->domain_pol, pol, sizeof(q_u->domain_pol));
2313
2314         q_u->unknown_0 = unk_0;
2315         q_u->user_rid  = rid;
2316 }
2317
2318 /*******************************************************************
2319  Reads or writes a structure.
2320 ********************************************************************/
2321
2322 BOOL samr_io_q_open_user(char *desc,  SAMR_Q_OPEN_USER *q_u, prs_struct *ps, int depth)
2323 {
2324         if (q_u == NULL)
2325                 return False;
2326
2327         prs_debug(ps, depth, desc, "samr_io_q_open_user");
2328         depth++;
2329
2330         if(!prs_align(ps))
2331                 return False;
2332
2333         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
2334                 return False;
2335         if(!prs_align(ps))
2336                 return False;
2337
2338         if(!prs_uint32("unknown_0", ps, depth, &q_u->unknown_0))
2339                 return False;
2340         if(!prs_uint32("user_rid ", ps, depth, &q_u->user_rid))
2341                 return False;
2342
2343         if(!prs_align(ps))
2344                 return False;
2345
2346         return True;
2347 }
2348
2349 /*******************************************************************
2350  Reads or writes a structure.
2351 ********************************************************************/
2352
2353 BOOL samr_io_r_open_user(char *desc,  SAMR_R_OPEN_USER *r_u, prs_struct *ps, int depth)
2354 {
2355         if (r_u == NULL)
2356                 return False;
2357
2358         prs_debug(ps, depth, desc, "samr_io_r_open_user");
2359         depth++;
2360
2361         if(!prs_align(ps))
2362                 return False;
2363
2364         if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
2365                 return False;
2366         if(!prs_align(ps))
2367                 return False;
2368
2369         if(!prs_uint32("status", ps, depth, &r_u->status))
2370                 return False;
2371
2372         return True;
2373 }
2374
2375 /*******************************************************************
2376  Inits a SAMR_Q_QUERY_USERGROUPS structure.
2377 ********************************************************************/
2378
2379 void init_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS *q_u,
2380                                 POLICY_HND *hnd)
2381 {
2382         DEBUG(5,("init_samr_q_query_usergroups\n"));
2383
2384         memcpy(&q_u->pol, hnd, sizeof(q_u->pol));
2385 }
2386
2387 /*******************************************************************
2388  Reads or writes a structure.
2389 ********************************************************************/
2390
2391 BOOL samr_io_q_query_usergroups(char *desc,  SAMR_Q_QUERY_USERGROUPS *q_u, prs_struct *ps, int depth)
2392 {
2393         if (q_u == NULL)
2394                 return False;
2395
2396         prs_debug(ps, depth, desc, "samr_io_q_query_usergroups");
2397         depth++;
2398
2399         if(!prs_align(ps))
2400                 return False;
2401
2402         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
2403                 return False;
2404         if(!prs_align(ps))
2405                 return False;
2406
2407         return True;
2408 }
2409
2410 /*******************************************************************
2411  Inits a SAMR_R_QUERY_USERGROUPS structure.
2412 ********************************************************************/
2413
2414 void init_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS *r_u,
2415                 uint32 num_gids, DOM_GID *gid, uint32 status)
2416 {
2417         DEBUG(5,("init_samr_r_query_usergroups\n"));
2418
2419         if (status == 0x0) {
2420                 r_u->ptr_0        = 1;
2421                 r_u->num_entries  = num_gids;
2422                 r_u->ptr_1        = 1;
2423                 r_u->num_entries2 = num_gids;
2424
2425                 r_u->gid = gid;
2426         } else {
2427                 r_u->ptr_0       = 0;
2428                 r_u->num_entries = 0;
2429                 r_u->ptr_1       = 0;
2430         }
2431
2432         r_u->status = status;
2433 }
2434
2435 /*******************************************************************
2436  Reads or writes a structure.
2437 ********************************************************************/
2438
2439 BOOL samr_io_r_query_usergroups(char *desc,  SAMR_R_QUERY_USERGROUPS *r_u, prs_struct *ps, int depth)
2440 {
2441         int i;
2442
2443         if (r_u == NULL)
2444                 return False;
2445
2446         prs_debug(ps, depth, desc, "samr_io_r_query_usergroups");
2447         depth++;
2448
2449         if(!prs_align(ps))
2450                 return False;
2451
2452         if(!prs_uint32("ptr_0       ", ps, depth, &r_u->ptr_0))
2453                 return False;
2454
2455         if (r_u->ptr_0 != 0) {
2456                 if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
2457                         return False;
2458                 if(!prs_uint32("ptr_1       ", ps, depth, &r_u->ptr_1))
2459                         return False;
2460
2461                 if (r_u->num_entries != 0) {
2462                         if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
2463                                 return False;
2464
2465                         for (i = 0; i < r_u->num_entries2; i++) {
2466                                 if(!smb_io_gid("", &r_u->gid[i], ps, depth))
2467                                         return False;
2468                         }
2469                 }
2470         }
2471
2472         if(!prs_uint32("status", ps, depth, &r_u->status))
2473                 return False;
2474
2475         return True;
2476 }
2477
2478 /*******************************************************************
2479  Inits a SAMR_Q_QUERY_USERINFO structure.
2480 ********************************************************************/
2481
2482 void init_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO *q_u,
2483                                 POLICY_HND *hnd, uint16 switch_value)
2484 {
2485         DEBUG(5,("init_samr_q_query_userinfo\n"));
2486
2487         memcpy(&q_u->pol, hnd, sizeof(q_u->pol));
2488         q_u->switch_value = switch_value;
2489 }
2490
2491 /*******************************************************************
2492  Reads or writes a structure.
2493 ********************************************************************/
2494
2495 BOOL samr_io_q_query_userinfo(char *desc,  SAMR_Q_QUERY_USERINFO *q_u, prs_struct *ps, int depth)
2496 {
2497         if (q_u == NULL)
2498                 return False;
2499
2500         prs_debug(ps, depth, desc, "samr_io_q_query_userinfo");
2501         depth++;
2502
2503         if(!prs_align(ps))
2504                 return False;
2505
2506         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
2507                 return False;
2508         if(!prs_align(ps))
2509                 return False;
2510
2511         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value)) /* 0x0015 or 0x0011 */
2512                 return False;
2513
2514         return True;
2515 }
2516
2517 /*******************************************************************
2518  Reads or writes a LOGON_HRS structure.
2519 ********************************************************************/
2520
2521 static BOOL sam_io_logon_hrs(char *desc,  LOGON_HRS *hrs, prs_struct *ps, int depth)
2522 {
2523         if (hrs == NULL)
2524                 return False;
2525
2526         prs_debug(ps, depth, desc, "sam_io_logon_hrs");
2527         depth++;
2528
2529         if(!prs_align(ps))
2530                 return False;
2531
2532         if(!prs_uint32 (       "len  ", ps, depth, &hrs->len))
2533                 return False;
2534
2535         if (hrs->len > 64) {
2536                 DEBUG(5,("sam_io_logon_hrs: truncating length\n"));
2537                 hrs->len = 64;
2538         }
2539
2540         if(!prs_uint8s (False, "hours", ps, depth, hrs->hours, hrs->len))
2541                 return False;
2542
2543         return True;
2544 }
2545
2546 /*******************************************************************
2547  Inits a SAM_USER_INFO_10 structure.
2548 ********************************************************************/
2549
2550 void init_sam_user_info10(SAM_USER_INFO_10 *usr,
2551                                 uint32 acb_info)
2552 {
2553         DEBUG(5,("init_sam_user_info10\n"));
2554
2555         usr->acb_info = acb_info;
2556 }
2557
2558 /*******************************************************************
2559  Reads or writes a structure.
2560 ********************************************************************/
2561
2562 BOOL sam_io_user_info10(char *desc,  SAM_USER_INFO_10 *usr, prs_struct *ps, int depth)
2563 {
2564         if (usr == NULL)
2565                 return False;
2566
2567         prs_debug(ps, depth, desc, "samr_io_r_user_info10");
2568         depth++;
2569
2570         if(!prs_align(ps))
2571                 return False;
2572
2573         if(!prs_uint32("acb_info", ps, depth, &usr->acb_info))
2574                 return False;
2575
2576         return True;
2577 }
2578
2579 /*******************************************************************
2580  Inits a SAM_USER_INFO_11 structure.
2581 ********************************************************************/
2582
2583 void init_sam_user_info11(SAM_USER_INFO_11 *usr,
2584                                 NTTIME *expiry,
2585                                 char *mach_acct,
2586                                 uint32 rid_user,
2587                                 uint32 rid_group,
2588                                 uint16 acct_ctrl)
2589
2590 {
2591         int len_mach_acct;
2592
2593         DEBUG(5,("init_sam_user_info11\n"));
2594
2595         len_mach_acct = strlen(mach_acct);
2596
2597         memcpy(&usr->expiry,expiry, sizeof(usr->expiry)); /* expiry time or something? */
2598         memset((char *)usr->padding_1, '\0', sizeof(usr->padding_1)); /* 0 - padding 24 bytes */
2599
2600         init_uni_hdr(&usr->hdr_mach_acct, len_mach_acct);  /* unicode header for machine account */
2601         usr->padding_2 = 0;               /* 0 - padding 4 bytes */
2602
2603         usr->ptr_1        = 1;            /* pointer */
2604         memset((char *)usr->padding_3, '\0', sizeof(usr->padding_3)); /* 0 - padding 32 bytes */
2605         usr->padding_4    = 0;            /* 0 - padding 4 bytes */
2606
2607         usr->ptr_2        = 1;            /* pointer */
2608         usr->padding_5    = 0;            /* 0 - padding 4 bytes */
2609
2610         usr->ptr_3        = 1;          /* pointer */
2611         memset((char *)usr->padding_6, '\0', sizeof(usr->padding_6)); /* 0 - padding 32 bytes */
2612
2613         usr->rid_user     = rid_user;
2614         usr->rid_group    = rid_group;
2615
2616         usr->acct_ctrl    = acct_ctrl;
2617         usr->unknown_3    = 0x0000;
2618
2619         usr->unknown_4    = 0x003f;       /* 0x003f      - 16 bit unknown */
2620         usr->unknown_5    = 0x003c;       /* 0x003c      - 16 bit unknown */
2621
2622         memset((char *)usr->padding_7, '\0', sizeof(usr->padding_7)); /* 0 - padding 16 bytes */
2623         usr->padding_8    = 0;            /* 0 - padding 4 bytes */
2624
2625         init_unistr2(&usr->uni_mach_acct, mach_acct, len_mach_acct);  /* unicode string for machine account */
2626
2627         memset((char *)usr->padding_9, '\0', sizeof(usr->padding_9)); /* 0 - padding 48 bytes */
2628 }
2629
2630 /*******************************************************************
2631  Reads or writes a structure.
2632 ********************************************************************/
2633
2634 BOOL sam_io_user_info11(char *desc,  SAM_USER_INFO_11 *usr, prs_struct *ps, int depth)
2635 {
2636         if (usr == NULL)
2637                 return False;
2638
2639         prs_debug(ps, depth, desc, "samr_io_r_unknown_24");
2640         depth++;
2641
2642         if(!prs_align(ps))
2643                 return False;
2644
2645         if(!prs_uint8s (False, "padding_0", ps, depth, usr->padding_0, sizeof(usr->padding_0)))
2646                 return False;
2647
2648         if(!smb_io_time("time", &(usr->expiry), ps, depth))
2649                 return False;
2650
2651         if(!prs_uint8s (False, "padding_1", ps, depth, usr->padding_1, sizeof(usr->padding_1)))
2652                 return False;
2653
2654         if(!smb_io_unihdr ("unihdr", &usr->hdr_mach_acct, ps, depth))
2655                 return False;
2656         if(!prs_uint32(        "padding_2", ps, depth, &usr->padding_2))
2657                 return False;
2658
2659         if(!prs_uint32(        "ptr_1    ", ps, depth, &usr->ptr_1))
2660                 return False;
2661         if(!prs_uint8s (False, "padding_3", ps, depth, usr->padding_3, sizeof(usr->padding_3)))
2662                 return False;
2663         if(!prs_uint32(        "padding_4", ps, depth, &usr->padding_4))
2664                 return False;
2665
2666         if(!prs_uint32(        "ptr_2    ", ps, depth, &usr->ptr_2))
2667                 return False;
2668         if(!prs_uint32(        "padding_5", ps, depth, &usr->padding_5))
2669                 return False;
2670
2671         if(!prs_uint32(        "ptr_3    ", ps, depth, &usr->ptr_3))
2672                 return False;
2673         if(!prs_uint8s(False, "padding_6", ps, depth, usr->padding_6, sizeof(usr->padding_6)))
2674                 return False;
2675
2676         if(!prs_uint32(        "rid_user ", ps, depth, &usr->rid_user))
2677                 return False;
2678         if(!prs_uint32(        "rid_group", ps, depth, &usr->rid_group))
2679                 return False;
2680         if(!prs_uint16(        "acct_ctrl", ps, depth, &usr->acct_ctrl))
2681                 return False;
2682         if(!prs_uint16(        "unknown_3", ps, depth, &usr->unknown_3))
2683                 return False;
2684         if(!prs_uint16(        "unknown_4", ps, depth, &usr->unknown_4))
2685                 return False;
2686         if(!prs_uint16(        "unknown_5", ps, depth, &usr->unknown_5))
2687                 return False;
2688
2689         if(!prs_uint8s (False, "padding_7", ps, depth, usr->padding_7, sizeof(usr->padding_7)))
2690                 return False;
2691         if(!prs_uint32(        "padding_8", ps, depth, &usr->padding_8))
2692                 return False;
2693
2694         if(!smb_io_unistr2("unistr2", &usr->uni_mach_acct, True, ps, depth))
2695                 return False;
2696         if(!prs_align(ps))
2697                 return False;
2698
2699         if(!prs_uint8s(False, "padding_9", ps, depth, usr->padding_9, sizeof(usr->padding_9)))
2700                 return False;
2701
2702         return True;
2703 }
2704
2705 /*************************************************************************
2706  init_sam_user_info21
2707
2708  unknown_3 = 0x00ff ffff
2709  unknown_5 = 0x0002 0000
2710  unknown_6 = 0x0000 04ec
2711
2712  *************************************************************************/
2713
2714 void init_sam_user_info21(SAM_USER_INFO_21 *usr,
2715         NTTIME *logon_time,
2716         NTTIME *logoff_time,
2717         NTTIME *kickoff_time,
2718         NTTIME *pass_last_set_time,
2719         NTTIME *pass_can_change_time,
2720         NTTIME *pass_must_change_time,
2721
2722         char *user_name,
2723         char *full_name,
2724         char *home_dir,
2725         char *dir_drive,
2726         char *logon_script,
2727         char *profile_path,
2728         char *description,
2729         char *workstations,
2730         char *unknown_str,
2731         char *munged_dial,
2732
2733         uint32 user_rid,
2734         uint32 group_rid,
2735         uint16 acb_info,
2736
2737         uint32 unknown_3,
2738         uint16 logon_divs,
2739         LOGON_HRS *hrs,
2740         uint32 unknown_5,
2741         uint32 unknown_6)
2742 {
2743         int len_user_name    = user_name    != NULL ? strlen(user_name   ) : 0;
2744         int len_full_name    = full_name    != NULL ? strlen(full_name   ) : 0;
2745         int len_home_dir     = home_dir     != NULL ? strlen(home_dir    ) : 0;
2746         int len_dir_drive    = dir_drive    != NULL ? strlen(dir_drive   ) : 0;
2747         int len_logon_script = logon_script != NULL ? strlen(logon_script) : 0;
2748         int len_profile_path = profile_path != NULL ? strlen(profile_path) : 0;
2749         int len_description  = description  != NULL ? strlen(description ) : 0;
2750         int len_workstations = workstations != NULL ? strlen(workstations) : 0;
2751         int len_unknown_str  = unknown_str  != NULL ? strlen(unknown_str ) : 0;
2752         int len_munged_dial  = munged_dial  != NULL ? strlen(munged_dial ) : 0;
2753
2754         usr->logon_time            = *logon_time;
2755         usr->logoff_time           = *logoff_time;
2756         usr->kickoff_time          = *kickoff_time;
2757         usr->pass_last_set_time    = *pass_last_set_time;
2758         usr->pass_can_change_time  = *pass_can_change_time;
2759         usr->pass_must_change_time = *pass_must_change_time;
2760
2761         init_uni_hdr(&usr->hdr_user_name, len_user_name);
2762         init_uni_hdr(&usr->hdr_full_name, len_full_name);
2763         init_uni_hdr(&usr->hdr_home_dir, len_home_dir);
2764         init_uni_hdr(&usr->hdr_dir_drive, len_dir_drive);
2765         init_uni_hdr(&usr->hdr_logon_script, len_logon_script);
2766         init_uni_hdr(&usr->hdr_profile_path, len_profile_path);
2767         init_uni_hdr(&usr->hdr_acct_desc, len_description);
2768         init_uni_hdr(&usr->hdr_workstations, len_workstations);
2769         init_uni_hdr(&usr->hdr_unknown_str, len_unknown_str);
2770         init_uni_hdr(&usr->hdr_munged_dial, len_munged_dial);
2771
2772         memset((char *)usr->nt_pwd, '\0', sizeof(usr->nt_pwd));
2773         memset((char *)usr->lm_pwd, '\0', sizeof(usr->lm_pwd));
2774
2775         usr->user_rid  = user_rid;
2776         usr->group_rid = group_rid;
2777         usr->acb_info = acb_info;
2778         usr->unknown_3 = unknown_3; /* 0x00ff ffff */
2779
2780         usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
2781         usr->ptr_logon_hrs = hrs ? 1 : 0;
2782         usr->unknown_5 = unknown_5; /* 0x0002 0000 */
2783
2784         memset((char *)usr->padding1, '\0', sizeof(usr->padding1));
2785
2786         init_unistr2(&usr->uni_user_name, user_name, len_user_name);
2787         init_unistr2(&usr->uni_full_name, full_name, len_full_name);
2788         init_unistr2(&usr->uni_home_dir, home_dir, len_home_dir);
2789         init_unistr2(&usr->uni_dir_drive, dir_drive, len_dir_drive);
2790         init_unistr2(&usr->uni_logon_script, logon_script, len_logon_script);
2791         init_unistr2(&usr->uni_profile_path, profile_path, len_profile_path);
2792         init_unistr2(&usr->uni_acct_desc, description, len_description);
2793         init_unistr2(&usr->uni_workstations, workstations, len_workstations);
2794         init_unistr2(&usr->uni_unknown_str, unknown_str, len_unknown_str);
2795         init_unistr2(&usr->uni_munged_dial, munged_dial, len_munged_dial);
2796
2797         usr->unknown_6 = unknown_6; /* 0x0000 04ec */
2798         usr->padding4 = 0;
2799
2800         if (hrs)
2801                 memcpy(&(usr->logon_hrs), hrs, sizeof(usr->logon_hrs));
2802         else
2803                 memset(&(usr->logon_hrs), 0xff, sizeof(usr->logon_hrs));
2804 }
2805
2806
2807 /*******************************************************************
2808  Reads or writes a structure.
2809 ********************************************************************/
2810
2811 static BOOL sam_io_user_info21(char *desc,  SAM_USER_INFO_21 *usr, prs_struct *ps, int depth)
2812 {
2813         if (usr == NULL)
2814                 return False;
2815
2816         prs_debug(ps, depth, desc, "lsa_io_user_info");
2817         depth++;
2818
2819         if(!prs_align(ps))
2820                 return False;
2821
2822         if(!smb_io_time("logon_time           ", &usr->logon_time, ps, depth))
2823                 return False;
2824         if(!smb_io_time("logoff_time          ", &usr->logoff_time, ps, depth))
2825                 return False;
2826         if(!smb_io_time("kickoff_time         ", &usr->kickoff_time, ps, depth))
2827                 return False;
2828         if(!smb_io_time("pass_last_set_time   ", &usr->pass_last_set_time, ps, depth))
2829                 return False;
2830         if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
2831                 return False;
2832         if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
2833                 return False;
2834
2835         if(!smb_io_unihdr("hdr_user_name   ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
2836                 return False;
2837         if(!smb_io_unihdr("hdr_full_name   ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
2838                 return False;
2839         if(!smb_io_unihdr("hdr_home_dir    ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
2840                 return False;
2841         if(!smb_io_unihdr("hdr_dir_drive   ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
2842                 return False;
2843         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
2844                 return False;
2845         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
2846                 return False;
2847         if(!smb_io_unihdr("hdr_acct_desc   ", &usr->hdr_acct_desc, ps, depth)) /* account description */
2848                 return False;
2849         if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* workstations user can log on from */
2850                 return False;
2851         if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth)) /* unknown string */
2852                 return False;
2853         if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* workstations user can log on from */
2854                 return False;
2855
2856         if(!prs_uint8s (False, "lm_pwd        ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
2857                 return False;
2858         if(!prs_uint8s (False, "nt_pwd        ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
2859                 return False;
2860
2861         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))       /* User ID */
2862                 return False;
2863         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))      /* Group ID */
2864                 return False;
2865         if(!prs_uint16("acb_info      ", ps, depth, &usr->acb_info))      /* Group ID */
2866                 return False;
2867         if(!prs_align(ps))
2868                 return False;
2869
2870         if(!prs_uint32("unknown_3     ", ps, depth, &usr->unknown_3))
2871                 return False;
2872         if(!prs_uint16("logon_divs    ", ps, depth, &usr->logon_divs))     /* logon divisions per week */
2873                 return False;
2874         if(!prs_align(ps))
2875                 return False;
2876         if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
2877                 return False;
2878         if(!prs_uint32("unknown_5     ", ps, depth, &usr->unknown_5))
2879                 return False;
2880
2881         if(!prs_uint8s (False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1)))
2882                 return False;
2883
2884         /* here begins pointed-to data */
2885
2886         if(!smb_io_unistr2("uni_user_name   ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
2887                 return False;
2888         if(!smb_io_unistr2("uni_full_name   ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
2889                 return False;
2890         if(!smb_io_unistr2("uni_home_dir    ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
2891                 return False;
2892         if(!smb_io_unistr2("uni_dir_drive   ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
2893                 return False;
2894         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
2895                 return False;
2896         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
2897                 return False;
2898         if(!smb_io_unistr2("uni_acct_desc   ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user description unicode string */
2899                 return False;
2900         if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
2901                 return False;
2902         if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str .buffer, ps, depth)) /* unknown string */
2903                 return False;
2904         if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial .buffer, ps, depth)) /* worksations user can log on from */
2905                 return False;
2906
2907         if(!prs_uint32("unknown_6     ", ps, depth, &usr->unknown_6))
2908                 return False;
2909         if(!prs_uint32("padding4      ", ps, depth, &usr->padding4))
2910                 return False;
2911
2912         if (usr->ptr_logon_hrs) {
2913                 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
2914                         return False;
2915                 if(!prs_align(ps))
2916                         return False;
2917         }
2918
2919         return True;
2920 }
2921
2922 /*******************************************************************
2923  Inits a SAMR_R_QUERY_USERINFO structure.
2924 ********************************************************************/
2925
2926 void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO *r_u,
2927                                 uint16 switch_value, void *info, uint32 status)
2928 {
2929         DEBUG(5,("init_samr_r_query_userinfo\n"));
2930
2931         r_u->ptr = 0;
2932         r_u->switch_value = 0;
2933
2934         if (status == 0) {
2935                 r_u->switch_value = switch_value;
2936
2937                 switch (switch_value) {
2938                 case 0x10:
2939                         r_u->ptr = 1;
2940                         r_u->info.id10 = (SAM_USER_INFO_10*)info;
2941                         break;
2942
2943                 case 0x11:
2944                         r_u->ptr = 1;
2945                         r_u->info.id11 = (SAM_USER_INFO_11*)info;
2946                         break;
2947
2948                 case 21:
2949                         r_u->ptr = 1;
2950                         r_u->info.id21 = (SAM_USER_INFO_21*)info;
2951                         break;
2952
2953                 default:
2954                         DEBUG(4,("init_samr_r_query_aliasinfo: unsupported switch level\n"));
2955                         break;
2956                 }
2957         }
2958
2959         r_u->status = status;         /* return status */
2960 }
2961
2962 /*******************************************************************
2963  Reads or writes a structure.
2964 ********************************************************************/
2965
2966 BOOL samr_io_r_query_userinfo(char *desc,  SAMR_R_QUERY_USERINFO *r_u, prs_struct *ps, int depth)
2967 {
2968         if (r_u == NULL)
2969                 return False;
2970
2971         prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
2972         depth++;
2973
2974         if(!prs_align(ps))
2975                 return False;
2976
2977         if(!prs_uint32("ptr         ", ps, depth, &r_u->ptr))
2978                 return False;
2979         if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
2980                 return False;
2981         if(!prs_align(ps))
2982                 return False;
2983
2984         if (r_u->ptr != 0 && r_u->switch_value != 0) {
2985                 switch (r_u->switch_value) {
2986                 case 0x10:
2987                         if (r_u->info.id10 != NULL) {
2988                                 if(!sam_io_user_info10("", r_u->info.id10, ps, depth))
2989                                         return False;
2990                         } else {
2991                                 DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
2992                                 return False;
2993                         }
2994                         break;
2995 /*
2996                 case 0x11:
2997                         if (r_u->info.id11 != NULL) {
2998                                 if(!sam_io_user_info11("", r_u->info.id11, ps, depth))
2999                                         return False;
3000                         } else {
3001                                 DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
3002                                 return False;
3003                         }
3004                         break;
3005 */
3006                 case 21:
3007                         if (r_u->info.id21 != NULL) {
3008                                 if(!sam_io_user_info21("", r_u->info.id21, ps, depth))
3009                                         return False;
3010                         } else {
3011                                 DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
3012                                 return False;
3013                         }
3014                         break;
3015                 default:
3016                         DEBUG(2,("samr_io_r_query_userinfo: unknown switch level\n"));
3017                         break;
3018                 }
3019         }
3020
3021         if(!prs_uint32("status", ps, depth, &r_u->status))
3022                 return False;
3023
3024         return True;
3025 }
3026
3027 /*******************************************************************
3028  Reads or writes a structure.
3029 ********************************************************************/
3030
3031 BOOL samr_io_q_unknown_32(char *desc,  SAMR_Q_UNKNOWN_32 *q_u, prs_struct *ps, int depth)
3032 {
3033         if (q_u == NULL)
3034                 return False;
3035
3036         prs_debug(ps, depth, desc, "samr_io_q_unknown_32");
3037         depth++;
3038
3039         if(!prs_align(ps))
3040                 return False;
3041
3042         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
3043                 return False;
3044         if(!prs_align(ps))
3045                 return False;
3046
3047         if(!smb_io_unihdr ("", &q_u->hdr_mach_acct, ps, depth))
3048                 return False;
3049         if(!smb_io_unistr2("", &q_u->uni_mach_acct, q_u->hdr_mach_acct.buffer, ps, depth))
3050                 return False;
3051
3052         if(!prs_align(ps))
3053                 return False;
3054
3055         if(!prs_uint32("acct_ctrl", ps, depth, &q_u->acct_ctrl))
3056                 return False;
3057         if(!prs_uint16("unknown_1", ps, depth, &q_u->unknown_1))
3058                 return False;
3059         if(!prs_uint16("unknown_2", ps, depth, &q_u->unknown_2))
3060                 return False;
3061
3062         return True;
3063 }
3064
3065 /*******************************************************************
3066  Reads or writes a structure.
3067 ********************************************************************/
3068
3069 BOOL samr_io_r_unknown_32(char *desc,  SAMR_R_UNKNOWN_32 *r_u, prs_struct *ps, int depth)
3070 {
3071         if (r_u == NULL)
3072                 return False;
3073
3074         prs_debug(ps, depth, desc, "samr_io_r_unknown_32");
3075         depth++;
3076
3077         if(!prs_align(ps))
3078                 return False;
3079
3080         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
3081                 return False;
3082         if(!prs_align(ps))
3083                 return False;
3084
3085         if(!prs_uint32("status", ps, depth, &r_u->status))
3086                 return False;
3087
3088         return True;
3089 }
3090
3091 /*******************************************************************
3092  Inits a SAMR_Q_CONNECT structure.
3093 ********************************************************************/
3094
3095 void init_samr_q_connect(SAMR_Q_CONNECT *q_u,
3096                                 char *srv_name, uint32 unknown_0)
3097 {
3098         int len_srv_name = strlen(srv_name);
3099
3100         DEBUG(5,("init_q_connect\n"));
3101
3102         /* make PDC server name \\server */
3103         q_u->ptr_srv_name = len_srv_name > 0 ? 1 : 0;
3104         init_unistr2(&q_u->uni_srv_name, srv_name, len_srv_name+1);
3105
3106         /* example values: 0x0000 0002 */
3107         q_u->unknown_0 = unknown_0;
3108 }
3109
3110 /*******************************************************************
3111  Reads or writes a structure.
3112 ********************************************************************/
3113
3114 BOOL samr_io_q_connect(char *desc,  SAMR_Q_CONNECT *q_u, prs_struct *ps, int depth)
3115 {
3116         if (q_u == NULL)
3117                 return False;
3118
3119         prs_debug(ps, depth, desc, "samr_io_q_connect");
3120         depth++;
3121
3122         if(!prs_align(ps))
3123                 return False;
3124
3125         if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
3126                 return False;
3127         if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
3128                 return False;
3129
3130         if(!prs_align(ps))
3131                 return False;
3132
3133         if(!prs_uint32("unknown_0   ", ps, depth, &q_u->unknown_0))
3134                 return False;
3135
3136         return True;
3137 }
3138
3139 /*******************************************************************
3140  Reads or writes a structure.
3141 ********************************************************************/
3142
3143 BOOL samr_io_r_connect(char *desc,  SAMR_R_CONNECT *r_u, prs_struct *ps, int depth)
3144 {
3145         if (r_u == NULL)
3146                 return False;
3147
3148         prs_debug(ps, depth, desc, "samr_io_r_connect");
3149         depth++;
3150
3151         if(!prs_align(ps))
3152                 return False;
3153
3154         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
3155                 return False;
3156         if(!prs_align(ps))
3157                 return False;
3158
3159         if(!prs_uint32("status", ps, depth, &r_u->status))
3160                 return False;
3161
3162         return True;
3163 }
3164
3165 /*******************************************************************
3166  Inits a SAMR_Q_CONNECT_ANON structure.
3167 ********************************************************************/
3168
3169 void init_samr_q_connect_anon(SAMR_Q_CONNECT_ANON *q_u)
3170 {
3171         DEBUG(5,("init_q_connect_anon\n"));
3172
3173         q_u->ptr       = 1;
3174         q_u->unknown_0 = 0x5c; /* server name (?!!) */
3175         q_u->unknown_1 = 0x01;
3176         q_u->unknown_2 = 0x20;
3177 }
3178
3179
3180 /*******************************************************************
3181  Reads or writes a structure.
3182 ********************************************************************/
3183
3184 BOOL samr_io_q_connect_anon(char *desc,  SAMR_Q_CONNECT_ANON *q_u, prs_struct *ps, int depth)
3185 {
3186         if (q_u == NULL)
3187                 return False;
3188
3189         prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
3190         depth++;
3191
3192         if(!prs_align(ps))
3193                 return False;
3194
3195         if(!prs_uint32("ptr      ", ps, depth, &q_u->ptr))
3196                 return False;
3197         if(!prs_uint16("unknown_0", ps, depth, &q_u->unknown_0))
3198                 return False;
3199         if(!prs_uint16("unknown_1", ps, depth, &q_u->unknown_1))
3200                 return False;
3201         if(!prs_uint32("unknown_2", ps, depth, &q_u->unknown_2))
3202                 return False;
3203
3204         return True;
3205 }
3206
3207 /*******************************************************************
3208  Reads or writes a structure.
3209 ********************************************************************/
3210
3211 BOOL samr_io_r_connect_anon(char *desc,  SAMR_R_CONNECT_ANON *r_u, prs_struct *ps, int depth)
3212 {
3213         if (r_u == NULL)
3214                 return False;
3215
3216         prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
3217         depth++;
3218
3219         if(!prs_align(ps))
3220                 return False;
3221
3222         if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
3223                 return False;
3224         if(!prs_align(ps))
3225                 return False;
3226
3227         if(!prs_uint32("status", ps, depth, &r_u->status))
3228                 return False;
3229
3230         return True;
3231 }
3232
3233 /*******************************************************************
3234  Inits a SAMR_Q_OPEN_ALIAS structure.
3235 ********************************************************************/
3236 void init_samr_q_open_alias(SAMR_Q_OPEN_ALIAS *q_u,
3237                                 uint32 unknown_0, uint32 rid)
3238 {
3239         DEBUG(5,("init_q_open_alias\n"));
3240
3241         /* example values: 0x0000 0008 */
3242         q_u->unknown_0 = unknown_0;
3243
3244         q_u->rid_alias = rid;
3245 }
3246
3247 /*******************************************************************
3248  Reads or writes a structure.
3249 ********************************************************************/
3250
3251 BOOL samr_io_q_open_alias(char *desc,  SAMR_Q_OPEN_ALIAS *q_u, prs_struct *ps, int depth)
3252 {
3253         if (q_u == NULL)
3254                 return False;
3255
3256         prs_debug(ps, depth, desc, "samr_io_q_open_alias");
3257         depth++;
3258
3259         if(!prs_align(ps))
3260                 return False;
3261
3262         if(!prs_uint32("unknown_0", ps, depth, &q_u->unknown_0))
3263                 return False;
3264         if(!prs_uint32("rid_alias", ps, depth, &q_u->rid_alias))
3265                 return False;
3266
3267         return True;
3268 }
3269
3270 /*******************************************************************
3271  Reads or writes a structure.
3272 ********************************************************************/
3273
3274 BOOL samr_io_r_open_alias(char *desc,  SAMR_R_OPEN_ALIAS *r_u, prs_struct *ps, int depth)
3275 {
3276         if (r_u == NULL)
3277                 return False;
3278
3279         prs_debug(ps, depth, desc, "samr_io_r_open_alias");
3280         depth++;
3281
3282         if(!prs_align(ps))
3283                 return False;
3284
3285         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
3286                 return False;
3287         if(!prs_align(ps))
3288                 return False;
3289
3290         if(!prs_uint32("status", ps, depth, &r_u->status))
3291                 return False;
3292
3293         return True;
3294 }
3295
3296 /*******************************************************************
3297  Inits a SAMR_Q_UNKNOWN_12 structure.
3298 ********************************************************************/
3299
3300 void init_samr_q_unknown_12(SAMR_Q_UNKNOWN_12 *q_u,
3301                 POLICY_HND *pol, uint32 rid,
3302                 uint32 num_gids, uint32 *gid)
3303 {
3304         int i;
3305
3306         DEBUG(5,("init_samr_r_unknwon_12\n"));
3307
3308         memcpy(&q_u->pol, pol, sizeof(*pol));
3309
3310         q_u->num_gids1 = num_gids;
3311         q_u->rid       = rid;
3312         q_u->ptr       = 0;
3313         q_u->num_gids2 = num_gids;
3314
3315         for (i = 0; i < num_gids; i++) {
3316                 q_u->gid[i] = gid[i];
3317         }
3318 }
3319
3320 /*******************************************************************
3321  Inits a SAMR_Q_UNKNOWN_21 structure.
3322 ********************************************************************/
3323
3324 void init_samr_q_unknown_21(SAMR_Q_UNKNOWN_21 *q_c,
3325                                 POLICY_HND *hnd, uint16 unk_1, uint16 unk_2)
3326 {
3327         DEBUG(5,("init_samr_q_unknown_21\n"));
3328
3329         memcpy(&q_c->group_pol, hnd, sizeof(q_c->group_pol));
3330         q_c->unknown_1 = unk_1;
3331         q_c->unknown_2 = unk_2;
3332 }
3333
3334
3335 /*******************************************************************
3336  Inits a SAMR_Q_UNKNOWN_13 structure.
3337 ********************************************************************/
3338
3339 void init_samr_q_unknown_13(SAMR_Q_UNKNOWN_13 *q_c,
3340                                 POLICY_HND *hnd, uint16 unk_1, uint16 unk_2)
3341 {
3342         DEBUG(5,("init_samr_q_unknown_13\n"));
3343
3344         memcpy(&q_c->alias_pol, hnd, sizeof(q_c->alias_pol));
3345         q_c->unknown_1 = unk_1;
3346         q_c->unknown_2 = unk_2;
3347 }
3348
3349 /*******************************************************************
3350  Inits a SAMR_Q_UNKNOWN_38 structure.
3351 ********************************************************************/
3352 void init_samr_q_unknown_38(SAMR_Q_UNKNOWN_38 *q_u, char *srv_name)
3353 {
3354         int len_srv_name = strlen(srv_name);
3355
3356         DEBUG(5,("init_q_unknown_38\n"));
3357
3358         q_u->ptr = 1;
3359         init_uni_hdr(&q_u->hdr_srv_name, len_srv_name);
3360         init_unistr2(&q_u->uni_srv_name, srv_name, len_srv_name);
3361
3362 }
3363
3364 /*******************************************************************
3365  Reads or writes a structure.
3366 ********************************************************************/
3367
3368 BOOL samr_io_q_unknown_38(char *desc,  SAMR_Q_UNKNOWN_38 *q_u, prs_struct *ps, int depth)
3369 {
3370         if (q_u == NULL)
3371                 return False;
3372
3373         prs_debug(ps, depth, desc, "samr_io_q_unknown_38");
3374         depth++;
3375
3376         if(!prs_align(ps))
3377                 return False;
3378
3379         if(!prs_uint32("ptr", ps, depth, &q_u->ptr))
3380                 return False;
3381
3382         if (q_u->ptr != 0) {
3383                 if(!smb_io_unihdr ("", &q_u->hdr_srv_name, ps, depth))
3384                         return False;
3385                 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->hdr_srv_name.buffer, ps, depth))
3386                         return False;
3387         }
3388
3389         return True;
3390 }
3391
3392 /*******************************************************************
3393  Inits a SAMR_R_UNKNOWN_38 structure.
3394 ********************************************************************/
3395
3396 void init_samr_r_unknown_38(SAMR_R_UNKNOWN_38 *r_u)
3397 {
3398         DEBUG(5,("init_r_unknown_38\n"));
3399
3400         r_u->unk_0 = 0;
3401         r_u->unk_1 = 0;
3402         r_u->unk_2 = 0;
3403         r_u->unk_3 = 0;
3404 }
3405
3406 /*******************************************************************
3407  Reads or writes a structure.
3408 ********************************************************************/
3409
3410 BOOL samr_io_r_unknown_38(char *desc,  SAMR_R_UNKNOWN_38 *r_u, prs_struct *ps, int depth)
3411 {
3412         if (r_u == NULL)
3413                 return False;
3414
3415         prs_debug(ps, depth, desc, "samr_io_r_unknown_38");
3416         depth++;
3417
3418         if(!prs_align(ps))
3419                 return False;
3420
3421         if(!prs_uint16("unk_0", ps, depth, &r_u->unk_0))
3422                 return False;
3423         if(!prs_align(ps))
3424                 return False;
3425         if(!prs_uint16("unk_1", ps, depth, &r_u->unk_1))
3426                 return False;
3427         if(!prs_align(ps))
3428                 return False;
3429         if(!prs_uint16("unk_2", ps, depth, &r_u->unk_2))
3430                 return False;
3431         if(!prs_align(ps))
3432                 return False;
3433         if(!prs_uint16("unk_3", ps, depth, &r_u->unk_3))
3434                 return False;
3435         if(!prs_align(ps))
3436                 return False;
3437
3438         return True;
3439 }
3440
3441 /*******************************************************************
3442 make a SAMR_ENC_PASSWD structure.
3443 ********************************************************************/
3444
3445 void init_enc_passwd(SAMR_ENC_PASSWD *pwd, char pass[512])
3446 {
3447         pwd->ptr = 1;
3448         memcpy(pwd->pass, pass, sizeof(pwd->pass));
3449 }
3450
3451 /*******************************************************************
3452  Reads or writes a SAMR_ENC_PASSWD structure.
3453 ********************************************************************/
3454
3455 BOOL samr_io_enc_passwd(char *desc, SAMR_ENC_PASSWD *pwd, prs_struct *ps, int depth)
3456 {
3457         if (pwd == NULL)
3458                 return False;
3459
3460         prs_debug(ps, depth, desc, "samr_io_enc_passwd");
3461         depth++;
3462
3463         if(!prs_align(ps))
3464                 return False;
3465
3466         if(!prs_uint32("ptr", ps, depth, &pwd->ptr))
3467                 return False;
3468         if(!prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass)))
3469                 return False;
3470
3471         return True;
3472 }
3473
3474 /*******************************************************************
3475  Inits a SAMR_ENC_HASH structure.
3476 ********************************************************************/
3477
3478 void init_enc_hash(SAMR_ENC_HASH *hsh, uchar hash[16])
3479 {
3480         hsh->ptr = 1;
3481         memcpy(hsh->hash, hash, sizeof(hsh->hash));
3482 }
3483
3484 /*******************************************************************
3485  Reads or writes a SAMR_ENC_HASH structure.
3486 ********************************************************************/
3487
3488 BOOL samr_io_enc_hash(char *desc, SAMR_ENC_HASH *hsh, prs_struct *ps, int depth)
3489 {
3490         if (hsh == NULL)
3491                 return False;
3492
3493         prs_debug(ps, depth, desc, "samr_io_enc_hash");
3494         depth++;
3495
3496         if(!prs_align(ps))
3497                 return False;
3498
3499         if(!prs_uint32("ptr ", ps, depth, &hsh->ptr))
3500                 return False;
3501         if(!prs_uint8s(False, "hash", ps, depth, hsh->hash, sizeof(hsh->hash)))
3502                 return False;
3503
3504         return True;
3505 }
3506
3507 /*******************************************************************
3508  Inits a SAMR_R_UNKNOWN_38 structure.
3509 ********************************************************************/
3510
3511 void init_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER *q_u,
3512                                 char *dest_host, char *user_name,
3513                                 char nt_newpass[516], uchar nt_oldhash[16],
3514                                 char lm_newpass[516], uchar lm_oldhash[16])
3515 {
3516         int len_dest_host = strlen(dest_host);
3517         int len_user_name = strlen(user_name);
3518
3519         DEBUG(5,("init_samr_q_chgpasswd_user\n"));
3520
3521         q_u->ptr_0 = 1;
3522         init_uni_hdr(&q_u->hdr_dest_host, len_dest_host);
3523         init_unistr2(&q_u->uni_dest_host, dest_host, len_dest_host);
3524         init_uni_hdr(&q_u->hdr_user_name, len_user_name);
3525         init_unistr2(&q_u->uni_user_name, user_name, len_user_name);
3526
3527         init_enc_passwd(&q_u->nt_newpass, nt_newpass);
3528         init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
3529
3530         q_u->unknown = 0x01;
3531
3532         init_enc_passwd(&q_u->lm_newpass, lm_newpass);
3533         init_enc_hash  (&q_u->lm_oldhash, lm_oldhash);
3534 }
3535
3536 /*******************************************************************
3537  Reads or writes a structure.
3538 ********************************************************************/
3539
3540 BOOL samr_io_q_chgpasswd_user(char *desc, SAMR_Q_CHGPASSWD_USER *q_u, prs_struct *ps, int depth)
3541 {
3542         if (q_u == NULL)
3543                 return False;
3544
3545         prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
3546         depth++;
3547
3548         if(!prs_align(ps))
3549                 return False;
3550
3551         if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
3552                 return False;
3553
3554         if(!smb_io_unihdr ("", &q_u->hdr_dest_host, ps, depth))
3555                 return False;
3556         if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
3557                 return False;
3558         if(!smb_io_unihdr ("", &q_u->hdr_user_name, ps, depth))
3559                 return False;
3560         if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer, ps, depth))
3561                 return False;
3562
3563         if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
3564                 return False;
3565         if(!samr_io_enc_hash  ("nt_oldhash", &q_u->nt_oldhash, ps, depth))
3566                 return False;
3567
3568         if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
3569                 return False;
3570
3571         if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
3572                 return False;
3573         if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
3574                 return False;
3575
3576         return True;
3577 }
3578
3579 /*******************************************************************
3580  Inits a SAMR_R_CHGPASSWD_USER structure.
3581 ********************************************************************/
3582
3583 void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER *r_u, uint32 status)
3584 {
3585         DEBUG(5,("init_r_chgpasswd_user\n"));
3586
3587         r_u->status = status;
3588 }
3589
3590 /*******************************************************************
3591  Reads or writes a structure.
3592 ********************************************************************/
3593
3594 BOOL samr_io_r_chgpasswd_user(char *desc, SAMR_R_CHGPASSWD_USER *r_u, prs_struct *ps, int depth)
3595 {
3596         if (r_u == NULL)
3597                 return False;
3598
3599         prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
3600         depth++;
3601
3602         if(!prs_align(ps))
3603                 return False;
3604
3605         if(!prs_uint32("status", ps, depth, &r_u->status))
3606                 return False;
3607
3608         return True;
3609 }