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 makes a SAMR_Q_CLOSE_HND structure.
  32 ********************************************************************/
  33 void make_samr_q_close_hnd(SAMR_Q_CLOSE_HND *q_c, POLICY_HND *hnd)
  34 {
  35         if (q_c == NULL || hnd == NULL) return;
  36
  37         DEBUG(5,("make_samr_q_close_hnd\n"));
  38
  39         memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
  40 }
  41
  42 /*******************************************************************
  43 reads or writes a structure.
  44 ********************************************************************/
  45 void samr_io_q_close_hnd(char *desc,  SAMR_Q_CLOSE_HND *q_u, prs_struct *ps, int depth)
  46 {
  47         if (q_u == NULL) return;
  48
  49         prs_debug(ps, depth, desc, "samr_io_q_close_hnd");
  50         depth++;
  51
  52         prs_align(ps);
  53
  54         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
  55         prs_align(ps);
  56 }
  57
  58 /*******************************************************************
  59 reads or writes a structure.
  60 ********************************************************************/
  61 void samr_io_r_close_hnd(char *desc,  SAMR_R_CLOSE_HND *r_u, prs_struct *ps, int depth)
  62 {
  63         if (r_u == NULL) return;
  64
  65         prs_debug(ps, depth, desc, "samr_io_r_close_hnd");
  66         depth++;
  67
  68         prs_align(ps);
  69
  70         smb_io_pol_hnd("pol", &(r_u->pol), ps, depth);
  71         prs_align(ps);
  72
  73         prs_uint32("status", ps, depth, &(r_u->status));
  74 }
  75
  76
  77 /*******************************************************************
  78 reads or writes a structure.
  79 ********************************************************************/
  80 void make_samr_q_open_domain(SAMR_Q_OPEN_DOMAIN *q_u,
  81                                 POLICY_HND *connect_pol, uint32 rid,
  82                                 DOM_SID *sid)
  83 {
  84         if (q_u == NULL) return;
  85
  86         DEBUG(5,("samr_make_q_open_domain\n"));
  87
  88         memcpy(&q_u->connect_pol, connect_pol, sizeof(q_u->connect_pol));
  89         q_u->rid = rid;
  90         make_dom_sid2(&(q_u->dom_sid), sid);
  91 }
  92
  93 /*******************************************************************
  94 reads or writes a structure.
  95 ********************************************************************/
  96 void samr_io_q_open_domain(char *desc,  SAMR_Q_OPEN_DOMAIN *q_u, prs_struct *ps, int depth)
  97 {
  98         if (q_u == NULL) return;
  99
 100         prs_debug(ps, depth, desc, "samr_io_q_open_domain");
 101         depth++;
 102
 103         prs_align(ps);
 104
 105         smb_io_pol_hnd("connect_pol", &(q_u->connect_pol), ps, depth);
 106         prs_align(ps);
 107
 108         prs_uint32("rid", ps, depth, &(q_u->rid));
 109
 110         smb_io_dom_sid2("sid", &(q_u->dom_sid), ps, depth);
 111         prs_align(ps);
 112 }
 113
 114
 115 /*******************************************************************
 116 reads or writes a structure.
 117 ********************************************************************/
 118 void samr_io_r_open_domain(char *desc,  SAMR_R_OPEN_DOMAIN *r_u, prs_struct *ps, int depth)
 119 {
 120         if (r_u == NULL) return;
 121
 122         prs_debug(ps, depth, desc, "samr_io_r_open_domain");
 123         depth++;
 124
 125         prs_align(ps);
 126
 127         smb_io_pol_hnd("domain_pol", &(r_u->domain_pol), ps, depth);
 128         prs_align(ps);
 129
 130         prs_uint32("status", ps, depth, &(r_u->status));
 131 }
 132
 133 /*******************************************************************
 134 reads or writes a structure.
 135 ********************************************************************/
 136 void make_samr_q_unknown_3(SAMR_Q_UNKNOWN_3 *q_u,
 137                                 POLICY_HND *user_pol, uint16 switch_value)
 138 {
 139         if (q_u == NULL) return;
 140
 141         DEBUG(5,("samr_make_q_unknown_3\n"));
 142
 143         memcpy(&q_u->user_pol, user_pol, sizeof(q_u->user_pol));
 144         q_u->switch_value = switch_value;
 145 }
 146
 147
 148 /*******************************************************************
 149 reads or writes a structure.
 150 ********************************************************************/
 151 void samr_io_q_unknown_3(char *desc,  SAMR_Q_UNKNOWN_3 *q_u, prs_struct *ps, int depth)
 152 {
 153         if (q_u == NULL) return;
 154
 155         prs_debug(ps, depth, desc, "samr_io_q_unknown_3");
 156         depth++;
 157
 158         prs_align(ps);
 159
 160         smb_io_pol_hnd("user_pol", &(q_u->user_pol), ps, depth);
 161         prs_align(ps);
 162
 163         prs_uint16("switch_value", ps, depth, &(q_u->switch_value));
 164         prs_align(ps);
 165 }
 166
 167 /*******************************************************************
 168 reads or writes a structure.
 169 ********************************************************************/
 170 void make_samr_q_unknown_8(SAMR_Q_UNKNOWN_8 *q_u,
 171                                 POLICY_HND *domain_pol, uint16 switch_value)
 172 {
 173         if (q_u == NULL) return;
 174
 175         DEBUG(5,("samr_make_q_unknown_8\n"));
 176
 177         memcpy(&q_u->domain_pol, domain_pol, sizeof(q_u->domain_pol));
 178         q_u->switch_value = switch_value;
 179 }
 180
 181 /*******************************************************************
 182 reads or writes a structure.
 183 ********************************************************************/
 184 void samr_io_q_unknown_8(char *desc,  SAMR_Q_UNKNOWN_8 *q_u, prs_struct *ps, int depth)
 185 {
 186         if (q_u == NULL) return;
 187
 188         prs_debug(ps, depth, desc, "samr_io_q_unknown_8");
 189         depth++;
 190
 191         prs_align(ps);
 192
 193         smb_io_pol_hnd("domain_pol", &(q_u->domain_pol), ps, depth);
 194         prs_align(ps);
 195
 196         prs_uint16("switch_value", ps, depth, &(q_u->switch_value));
 197         prs_align(ps);
 198 }
 199 /*******************************************************************
 200  makes a DOM_SID3 structure.
 201
 202  calculate length by adding up the size of the components.
 203  ********************************************************************/
 204 void make_dom_sid3(DOM_SID3 *sid3, uint16 unk_0, uint16 unk_1, DOM_SID *sid)
 205 {
 206         if (sid3 == NULL) return;
 207
 208     sid3->sid = *sid;
 209         sid3->len = 2 + 8 + sid3->sid.num_auths * 4;
 210 }
 211
 212 /*******************************************************************
 213 reads or writes a SAM_SID3 structure.
 214
 215 this one's odd, because the length (in bytes) is specified at the beginning.
 216 the length _includes_ the length of the length, too :-)
 217
 218 ********************************************************************/
 219 static void sam_io_dom_sid3(char *desc,  DOM_SID3 *sid3, prs_struct *ps, int depth)
 220 {
 221         if (sid3 == NULL) return;
 222
 223         prs_debug(ps, depth, desc, "sam_io_dom_sid3");
 224         depth++;
 225
 226         prs_uint16("len", ps, depth, &(sid3->len));
 227         prs_align(ps);
 228         smb_io_dom_sid("", &(sid3->sid), ps, depth);
 229 }
 230
 231 /*******************************************************************
 232 makes a SAMR_R_UNKNOWN3 structure.
 233
 234 unknown_2   : 0x0001
 235 unknown_3   : 0x8004
 236
 237 unknown_4,5 : 0x0000 0014
 238
 239 unknown_6   : 0x0002
 240 unknown_7   : 0x5800 or 0x0070
 241
 242 ********************************************************************/
 243 static void make_sam_sid_stuff(SAM_SID_STUFF *stf,
 244                                 uint16 unknown_2, uint16 unknown_3,
 245                                 uint32 unknown_4, uint16 unknown_6, uint16 unknown_7,
 246                                 int num_sid3s, DOM_SID3 sid3[MAX_SAM_SIDS])
 247 {
 248         stf->unknown_2 = unknown_2;
 249         stf->unknown_3 = unknown_3;
 250
 251         bzero(stf->padding1, sizeof(stf->padding1));
 252
 253         stf->unknown_4 = unknown_4;
 254         stf->unknown_5 = unknown_4;
 255
 256         stf->unknown_6 = unknown_6;
 257         stf->unknown_7 = unknown_7;
 258
 259         stf->num_sids  = num_sid3s;
 260
 261         stf->padding2  = 0x0000;
 262
 263         memcpy(stf->sid, sid3, sizeof(DOM_SID3) * num_sid3s);
 264 }
 265
 266 /*******************************************************************
 267 reads or writes a SAM_SID_STUFF structure.
 268 ********************************************************************/
 269 static void sam_io_sid_stuff(char *desc,  SAM_SID_STUFF *stf, prs_struct *ps, int depth)
 270 {
 271         int i;
 272
 273         if (stf == NULL) return;
 274
 275         DEBUG(5,("make_sam_sid_stuff\n"));
 276
 277         prs_uint16("unknown_2", ps, depth, &(stf->unknown_2));
 278         prs_uint16("unknown_3", ps, depth, &(stf->unknown_3));
 279
 280         prs_uint8s(False, "padding1", ps, depth, stf->padding1, sizeof(stf->padding1));
 281
 282         prs_uint32("unknown_4", ps, depth, &(stf->unknown_4));
 283         prs_uint32("unknown_5", ps, depth, &(stf->unknown_5));
 284         prs_uint16("unknown_6", ps, depth, &(stf->unknown_6));
 285         prs_uint16("unknown_7", ps, depth, &(stf->unknown_7));
 286
 287         prs_uint32("num_sids ", ps, depth, &(stf->num_sids ));
 288         prs_uint16("padding2 ", ps, depth, &(stf->padding2 ));
 289
 290         SMB_ASSERT_ARRAY(stf->sid, stf->num_sids);
 291
 292         for (i = 0; i < stf->num_sids; i++)
 293         {
 294                 sam_io_dom_sid3("", &(stf->sid[i]), ps, depth);
 295         }
 296 }
 297
 298 /*******************************************************************
 299 reads or writes a SAMR_R_UNKNOWN3 structure.
 300 ********************************************************************/
 301 void make_samr_r_unknown_3(SAMR_R_UNKNOWN_3 *r_u,
 302                                 uint16 unknown_2, uint16 unknown_3,
 303                                 uint32 unknown_4, uint16 unknown_6, uint16 unknown_7,
 304                                 int num_sid3s, DOM_SID3 sid3[MAX_SAM_SIDS],
 305                                 uint32 status)
 306 {
 307         if (r_u == NULL) return;
 308
 309         DEBUG(5,("samr_make_r_unknown_3\n"));
 310
 311         r_u->ptr_0 = 0;
 312         r_u->ptr_1 = 0;
 313
 314         if (status == 0x0)
 315         {
 316                 r_u->ptr_0 = 1;
 317                 r_u->ptr_1 = 1;
 318                 make_sam_sid_stuff(&(r_u->sid_stuff), unknown_2, unknown_3,
 319                        unknown_4, unknown_6, unknown_7,
 320                        num_sid3s, sid3);
 321         }
 322
 323         r_u->status = status;
 324 }
 325
 326
 327 /*******************************************************************
 328 reads or writes a SAMR_R_UNKNOWN_3 structure.
 329
 330 this one's odd, because the daft buggers use a different mechanism
 331 for writing out the array of sids. they put the number of sids in
 332 only one place: they've calculated the length of each sid and jumped
 333 by that amount.  then, retrospectively, the length of the whole buffer
 334 is put at the beginning of the data stream.
 335
 336 wierd.
 337
 338 ********************************************************************/
 339 void samr_io_r_unknown_3(char *desc,  SAMR_R_UNKNOWN_3 *r_u, prs_struct *ps, int depth)
 340 {
 341         int ptr_len0=0;
 342         int ptr_len1=0;
 343         int ptr_sid_stuff = 0;
 344
 345         if (r_u == NULL) return;
 346
 347         prs_debug(ps, depth, desc, "samr_io_r_unknown_3");
 348         depth++;
 349
 350         prs_align(ps);
 351
 352         prs_uint32("ptr_0         ", ps, depth, &(r_u->ptr_0         ));
 353
 354         if (ps->io)
 355         {
 356                 /* reading.  do the length later */
 357                 prs_uint32("sid_stuff_len0", ps, depth, &(r_u->sid_stuff_len0));
 358         }
 359         else
 360         {
 361                 /* storing */
 362                 ptr_len0 = ps->offset; ps->offset += 4;
 363         }
 364
 365         if (r_u->ptr_0 != 0)
 366         {
 367                 prs_uint32("ptr_1         ", ps, depth, &(r_u->ptr_1         ));
 368                 if (ps->io)
 369                 {
 370                         /* reading.  do the length later */
 371                         prs_uint32("sid_stuff_len1", ps, depth, &(r_u->sid_stuff_len1));
 372                 }
 373                 else
 374                 {
 375                         /* storing */
 376                         ptr_len1 = ps->offset; ps->offset += 4;
 377                 }
 378
 379                 if (r_u->ptr_1 != 0)
 380                 {
 381                         ptr_sid_stuff = ps->offset;
 382                         sam_io_sid_stuff("", &(r_u->sid_stuff), ps, depth);
 383                 }
 384         }
 385
 386         if (!(ps->io)) /* storing not reading.  do the length, now. */
 387         {
 388                 if (ptr_sid_stuff != 0)
 389                 {
 390                         uint32 sid_stuff_len = ps->offset - ptr_sid_stuff;
 391                         int old_len = ps->offset;
 392
 393                         ps->offset = ptr_len0;
 394                         prs_uint32("sid_stuff_len0", ps, depth, &sid_stuff_len);
 395
 396                         ps->offset = ptr_len1;
 397                         prs_uint32("sid_stuff_len1", ps, depth, &sid_stuff_len);
 398
 399                         ps->offset = old_len;
 400                 }
 401         }
 402
 403         prs_uint32("status", ps, depth, &(r_u->status));
 404 }
 405
 406 /*******************************************************************
 407 reads or writes a SAM_STR1 structure.
 408 ********************************************************************/
 409 static void sam_io_sam_str1(char *desc,  SAM_STR1 *sam, uint32 acct_buf, uint32 name_buf, uint32 desc_buf, prs_struct *ps, int depth)
 410 {
 411         if (sam == NULL) return;
 412
 413         prs_debug(ps, depth, desc, "sam_io_sam_str1");
 414         depth++;
 415
 416         prs_align(ps);
 417
 418         smb_io_unistr2("unistr2", &(sam->uni_acct_name), acct_buf, ps, depth); /* account name unicode string */
 419         smb_io_unistr2("unistr2", &(sam->uni_full_name), name_buf, ps, depth); /* full name unicode string */
 420         smb_io_unistr2("unistr2", &(sam->uni_acct_desc), desc_buf, ps, depth); /* account description unicode string */
 421 }
 422
 423 /*******************************************************************
 424 makes a SAM_ENTRY1 structure.
 425 ********************************************************************/
 426 static void make_sam_entry1(SAM_ENTRY1 *sam, uint32 user_idx,
 427                                 uint32 len_sam_name, uint32 len_sam_full, uint32 len_sam_desc,
 428                                 uint32 rid_user, uint16 acb_info)
 429 {
 430         if (sam == NULL) return;
 431
 432         DEBUG(5,("make_sam_entry1\n"));
 433
 434         sam->user_idx = user_idx;
 435         sam->rid_user = rid_user;
 436         sam->acb_info = acb_info;
 437         sam->pad      = 0;
 438
 439         make_uni_hdr(&(sam->hdr_acct_name), len_sam_name, len_sam_name, len_sam_name != 0);
 440         make_uni_hdr(&(sam->hdr_user_name), len_sam_full, len_sam_full, len_sam_full != 0);
 441         make_uni_hdr(&(sam->hdr_user_desc), len_sam_desc, len_sam_desc, len_sam_desc != 0);
 442 }
 443
 444 /*******************************************************************
 445 reads or writes a SAM_ENTRY1 structure.
 446 ********************************************************************/
 447 static void sam_io_sam_entry1(char *desc,  SAM_ENTRY1 *sam, prs_struct *ps, int depth)
 448 {
 449         if (sam == NULL) return;
 450
 451         prs_debug(ps, depth, desc, "sam_io_sam_entry1");
 452         depth++;
 453
 454         prs_align(ps);
 455
 456         prs_uint32("user_idx ", ps, depth, &(sam->user_idx ));
 457
 458         prs_uint32("rid_user ", ps, depth, &(sam->rid_user ));
 459         prs_uint16("acb_info ", ps, depth, &(sam->acb_info ));
 460         prs_uint16("pad      ", ps, depth, &(sam->pad      ));
 461
 462         smb_io_unihdr("unihdr", &(sam->hdr_acct_name), ps, depth); /* account name unicode string header */
 463         smb_io_unihdr("unihdr", &(sam->hdr_user_name), ps, depth); /* account name unicode string header */
 464         smb_io_unihdr("unihdr", &(sam->hdr_user_desc), ps, depth); /* account name unicode string header */
 465 }
 466
 467 /*******************************************************************
 468 reads or writes a SAM_STR2 structure.
 469 ********************************************************************/
 470 static void sam_io_sam_str2(char *desc,  SAM_STR2 *sam, uint32 acct_buf, uint32 desc_buf, prs_struct *ps, int depth)
 471 {
 472         if (sam == NULL) return;
 473
 474         prs_debug(ps, depth, desc, "sam_io_sam_str2");
 475         depth++;
 476
 477         prs_align(ps);
 478
 479         smb_io_unistr2("unistr2", &(sam->uni_srv_name), acct_buf, ps, depth); /* account name unicode string */
 480         smb_io_unistr2("unistr2", &(sam->uni_srv_desc), desc_buf, ps, depth); /* account description unicode string */
 481 }
 482
 483 /*******************************************************************
 484 makes a SAM_ENTRY2 structure.
 485 ********************************************************************/
 486 static void make_sam_entry2(SAM_ENTRY2 *sam, uint32 user_idx,
 487                                 uint32 len_sam_name, uint32 len_sam_desc,
 488                                 uint32 rid_user, uint16 acb_info)
 489 {
 490         if (sam == NULL) return;
 491
 492         DEBUG(5,("make_sam_entry2\n"));
 493
 494         sam->user_idx = user_idx;
 495         sam->rid_user = rid_user;
 496         sam->acb_info = acb_info;
 497         sam->pad      = 0;
 498
 499         make_uni_hdr(&(sam->hdr_srv_name), len_sam_name, len_sam_name, len_sam_name != 0);
 500         make_uni_hdr(&(sam->hdr_srv_desc), len_sam_desc, len_sam_desc, len_sam_desc != 0);
 501 }
 502
 503 /*******************************************************************
 504 reads or writes a SAM_ENTRY2 structure.
 505 ********************************************************************/
 506 static void sam_io_sam_entry2(char *desc,  SAM_ENTRY2 *sam, prs_struct *ps, int depth)
 507 {
 508         if (sam == NULL) return;
 509
 510         prs_debug(ps, depth, desc, "sam_io_sam_entry2");
 511         depth++;
 512
 513         prs_align(ps);
 514
 515         prs_uint32("user_idx ", ps, depth, &(sam->user_idx ));
 516
 517         prs_uint32("rid_user ", ps, depth, &(sam->rid_user ));
 518         prs_uint16("acb_info ", ps, depth, &(sam->acb_info ));
 519         prs_uint16("pad      ", ps, depth, &(sam->pad      ));
 520
 521         smb_io_unihdr("unihdr", &(sam->hdr_srv_name), ps, depth); /* account name unicode string header */
 522         smb_io_unihdr("unihdr", &(sam->hdr_srv_desc), ps, depth); /* account name unicode string header */
 523 }
 524
 525 /*******************************************************************
 526 reads or writes a SAM_STR3 structure.
 527 ********************************************************************/
 528 static void sam_io_sam_str3(char *desc,  SAM_STR3 *sam, uint32 acct_buf, uint32 desc_buf, prs_struct *ps, int depth)
 529 {
 530         if (sam == NULL) return;
 531
 532         prs_debug(ps, depth, desc, "sam_io_sam_str3");
 533         depth++;
 534
 535         prs_align(ps);
 536
 537         smb_io_unistr2("unistr2", &(sam->uni_grp_name), acct_buf, ps, depth); /* account name unicode string */
 538         smb_io_unistr2("unistr2", &(sam->uni_grp_desc), desc_buf, ps, depth); /* account description unicode string */
 539 }
 540
 541 /*******************************************************************
 542 makes a SAM_ENTRY3 structure.
 543 ********************************************************************/
 544 static void make_sam_entry3(SAM_ENTRY3 *sam, uint32 grp_idx,
 545                                 uint32 len_grp_name, uint32 len_grp_desc, uint32 rid_grp)
 546 {
 547         if (sam == NULL) return;
 548
 549         DEBUG(5,("make_sam_entry3\n"));
 550
 551         sam->grp_idx = grp_idx;
 552         sam->rid_grp = rid_grp;
 553         sam->attr    = 0x07; /* group rid attributes - gets ignored by nt 4.0 */
 554
 555         make_uni_hdr(&(sam->hdr_grp_name), len_grp_name, len_grp_name, len_grp_name != 0);
 556         make_uni_hdr(&(sam->hdr_grp_desc), len_grp_desc, len_grp_desc, len_grp_desc != 0);
 557 }
 558
 559 /*******************************************************************
 560 reads or writes a SAM_ENTRY3 structure.
 561 ********************************************************************/
 562 static void sam_io_sam_entry3(char *desc,  SAM_ENTRY3 *sam, prs_struct *ps, int depth)
 563 {
 564         if (sam == NULL) return;
 565
 566         prs_debug(ps, depth, desc, "sam_io_sam_entry3");
 567         depth++;
 568
 569         prs_align(ps);
 570
 571         prs_uint32("grp_idx", ps, depth, &(sam->grp_idx));
 572
 573         prs_uint32("rid_grp", ps, depth, &(sam->rid_grp));
 574         prs_uint32("attr   ", ps, depth, &(sam->attr   ));
 575
 576         smb_io_unihdr("unihdr", &(sam->hdr_grp_name), ps, depth); /* account name unicode string header */
 577         smb_io_unihdr("unihdr", &(sam->hdr_grp_desc), ps, depth); /* account name unicode string header */
 578 }
 579
 580 /*******************************************************************
 581 makes a SAM_ENTRY structure.
 582 ********************************************************************/
 583 static void make_sam_entry(SAM_ENTRY *sam, uint32 len_sam_name, uint32 rid)
 584 {
 585         if (sam == NULL) return;
 586
 587         DEBUG(5,("make_sam_entry\n"));
 588
 589         sam->rid = rid;
 590         make_uni_hdr(&(sam->hdr_name), len_sam_name, len_sam_name, len_sam_name != 0);
 591 }
 592
 593 /*******************************************************************
 594 reads or writes a SAM_ENTRY structure.
 595 ********************************************************************/
 596 static void sam_io_sam_entry(char *desc,  SAM_ENTRY *sam, prs_struct *ps, int depth)
 597 {
 598         if (sam == NULL) return;
 599
 600         prs_debug(ps, depth, desc, "sam_io_sam_entry");
 601         depth++;
 602
 603         prs_align(ps);
 604         prs_uint32("rid", ps, depth, &(sam->rid ));
 605         smb_io_unihdr("unihdr", &(sam->hdr_name), ps, depth); /* account name unicode string header */
 606 }
 607
 608
 609 /*******************************************************************
 610 makes a SAMR_Q_ENUM_DOM_USERS structure.
 611 ********************************************************************/
 612 void make_samr_q_enum_dom_users(SAMR_Q_ENUM_DOM_USERS *q_e, POLICY_HND *pol,
 613                                 uint16 req_num_entries, uint16 unk_0,
 614                                 uint16 acb_mask, uint16 unk_1, uint32 size)
 615 {
 616         if (q_e == NULL || pol == NULL) return;
 617
 618         DEBUG(5,("make_q_enum_dom_users\n"));
 619
 620         memcpy(&(q_e->pol), pol, sizeof(*pol));
 621
 622         q_e->req_num_entries = req_num_entries; /* zero indicates lots */
 623         q_e->unknown_0 = unk_0; /* this gets returned in the response */
 624         q_e->acb_mask  = acb_mask;
 625         q_e->unknown_1 = unk_1;
 626         q_e->max_size = size;
 627 }
 628
 629 /*******************************************************************
 630 reads or writes a structure.
 631 ********************************************************************/
 632 void samr_io_q_enum_dom_users(char *desc,  SAMR_Q_ENUM_DOM_USERS *q_e, prs_struct *ps, int depth)
 633 {
 634         if (q_e == NULL) return;
 635
 636         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_users");
 637         depth++;
 638
 639         prs_align(ps);
 640
 641         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
 642         prs_align(ps);
 643
 644         prs_uint16("req_num_entries", ps, depth, &(q_e->req_num_entries));
 645         prs_uint16("unknown_0      ", ps, depth, &(q_e->unknown_0      ));
 646
 647         prs_uint16("acb_mask       ", ps, depth, &(q_e->acb_mask       ));
 648         prs_uint16("unknown_1      ", ps, depth, &(q_e->unknown_1      ));
 649
 650         prs_uint32("max_size       ", ps, depth, &(q_e->max_size       ));
 651
 652         prs_align(ps);
 653 }
 654
 655
 656 /*******************************************************************
 657 makes a SAMR_R_ENUM_DOM_USERS structure.
 658 ********************************************************************/
 659 void make_samr_r_enum_dom_users(SAMR_R_ENUM_DOM_USERS *r_u,
 660                 uint16 total_num_entries, uint16 unk_0,
 661                 uint32 num_sam_entries, SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES], uint32 status)
 662 {
 663         int i;
 664
 665         if (r_u == NULL) return;
 666
 667         DEBUG(5,("make_samr_r_enum_dom_users\n"));
 668
 669         if (num_sam_entries >= MAX_SAM_ENTRIES)
 670         {
 671                 num_sam_entries = MAX_SAM_ENTRIES;
 672                 DEBUG(5,("limiting number of entries to %d\n",
 673                          num_sam_entries));
 674         }
 675
 676         r_u->total_num_entries = total_num_entries;
 677         r_u->unknown_0         = unk_0;
 678
 679         if (total_num_entries > 0)
 680         {
 681                 r_u->ptr_entries1 = 1;
 682                 r_u->ptr_entries2 = 1;
 683                 r_u->num_entries2 = num_sam_entries;
 684                 r_u->num_entries3 = num_sam_entries;
 685
 686                 SMB_ASSERT_ARRAY(r_u->sam, num_sam_entries);
 687                 SMB_ASSERT_ARRAY(r_u->uni_acct_name, num_sam_entries);
 688
 689                 for (i = 0; i < num_sam_entries; i++)
 690                 {
 691                         make_sam_entry(&(r_u->sam[i]),
 692                                        pass[i].uni_user_name.uni_str_len,
 693                                        pass[i].user_rid);
 694
 695                         copy_unistr2(&(r_u->uni_acct_name[i]), &(pass[i].uni_user_name));
 696                 }
 697
 698                 r_u->num_entries4 = num_sam_entries;
 699         }
 700         else
 701         {
 702                 r_u->ptr_entries1 = 0;
 703                 r_u->num_entries2 = num_sam_entries;
 704                 r_u->ptr_entries2 = 1;
 705         }
 706
 707         r_u->status = status;
 708 }
 709
 710 /*******************************************************************
 711 reads or writes a structure.
 712 ********************************************************************/
 713 void samr_io_r_enum_dom_users(char *desc,  SAMR_R_ENUM_DOM_USERS *r_u, prs_struct *ps, int depth)
 714 {
 715         int i;
 716
 717         if (r_u == NULL) return;
 718
 719         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_users");
 720         depth++;
 721
 722         prs_align(ps);
 723
 724         prs_uint16("total_num_entries", ps, depth, &(r_u->total_num_entries));
 725         prs_uint16("unknown_0        ", ps, depth, &(r_u->unknown_0        ));
 726         prs_uint32("ptr_entries1", ps, depth, &(r_u->ptr_entries1));
 727
 728         if (r_u->total_num_entries != 0 && r_u->ptr_entries1 != 0)
 729         {
 730                 prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
 731                 prs_uint32("ptr_entries2", ps, depth, &(r_u->ptr_entries2));
 732                 prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
 733
 734                 SMB_ASSERT_ARRAY(r_u->sam, r_u->num_entries2);
 735
 736                 for (i = 0; i < r_u->num_entries2; i++)
 737                 {
 738                         prs_grow(ps);
 739                         sam_io_sam_entry("", &(r_u->sam[i]), ps, depth);
 740                 }
 741
 742                 SMB_ASSERT_ARRAY(r_u->uni_acct_name, r_u->num_entries2);
 743
 744                 for (i = 0; i < r_u->num_entries2; i++)
 745                 {
 746                         prs_grow(ps);
 747                         smb_io_unistr2("", &(r_u->uni_acct_name[i]), r_u->sam[i].hdr_name.buffer, ps, depth);
 748                 }
 749
 750                 prs_align(ps);
 751
 752                 prs_uint32("num_entries4", ps, depth, &(r_u->num_entries4));
 753         }
 754
 755         prs_uint32("status", ps, depth, &(r_u->status));
 756 }
 757
 758 /*******************************************************************
 759 makes a SAMR_Q_ENUM_DOM_ALIASES structure.
 760 ********************************************************************/
 761 void make_samr_q_enum_dom_aliases(SAMR_Q_ENUM_DOM_ALIASES *q_e, POLICY_HND *pol, uint32 size)
 762 {
 763         if (q_e == NULL || pol == NULL) return;
 764
 765         DEBUG(5,("make_q_enum_dom_aliases\n"));
 766
 767         memcpy(&(q_e->pol), pol, sizeof(*pol));
 768
 769         q_e->unknown_0 = 0;
 770         q_e->max_size = size;
 771 }
 772
 773
 774 /*******************************************************************
 775 reads or writes a structure.
 776 ********************************************************************/
 777 void samr_io_q_enum_dom_aliases(char *desc,  SAMR_Q_ENUM_DOM_ALIASES *q_e, prs_struct *ps, int depth)
 778 {
 779         if (q_e == NULL) return;
 780
 781         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_aliases");
 782         depth++;
 783
 784         prs_align(ps);
 785
 786         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
 787         prs_align(ps);
 788
 789         prs_uint32("unknown_0", ps, depth, &(q_e->unknown_0));
 790         prs_uint32("max_size ", ps, depth, &(q_e->max_size ));
 791
 792         prs_align(ps);
 793 }
 794
 795
 796 /*******************************************************************
 797 makes a SAMR_R_ENUM_DOM_ALIASES structure.
 798 ********************************************************************/
 799 void make_samr_r_enum_dom_aliases(SAMR_R_ENUM_DOM_ALIASES *r_u,
 800                 uint32 num_sam_entries, SAM_USER_INFO_21 grps[MAX_SAM_ENTRIES],
 801                 uint32 status)
 802 {
 803         int i;
 804
 805         if (r_u == NULL) return;
 806
 807         DEBUG(5,("make_samr_r_enum_dom_aliases\n"));
 808
 809         if (num_sam_entries >= MAX_SAM_ENTRIES)
 810         {
 811                 num_sam_entries = MAX_SAM_ENTRIES;
 812                 DEBUG(5,("limiting number of entries to %d\n",
 813                          num_sam_entries));
 814         }
 815
 816         r_u->num_entries  = num_sam_entries;
 817
 818         if (num_sam_entries > 0)
 819         {
 820                 r_u->ptr_entries  = 1;
 821                 r_u->num_entries2 = num_sam_entries;
 822                 r_u->ptr_entries2 = 1;
 823                 r_u->num_entries3 = num_sam_entries;
 824
 825                 SMB_ASSERT_ARRAY(r_u->sam, num_sam_entries);
 826
 827                 for (i = 0; i < num_sam_entries; i++)
 828                 {
 829                         make_sam_entry(&(r_u->sam[i]),
 830                                        grps[i].uni_user_name.uni_str_len,
 831                                        grps[i].user_rid);
 832
 833                         copy_unistr2(&(r_u->uni_grp_name[i]), &(grps[i].uni_user_name));
 834                 }
 835
 836                 r_u->num_entries4 = num_sam_entries;
 837         }
 838         else
 839         {
 840                 r_u->ptr_entries = 0;
 841         }
 842
 843         r_u->status = status;
 844 }
 845
 846 /*******************************************************************
 847 reads or writes a structure.
 848 ********************************************************************/
 849 void samr_io_r_enum_dom_aliases(char *desc,  SAMR_R_ENUM_DOM_ALIASES *r_u, prs_struct *ps, int depth)
 850 {
 851         int i;
 852
 853         if (r_u == NULL) return;
 854
 855         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_aliases");
 856         depth++;
 857
 858         prs_align(ps);
 859
 860         prs_uint32("num_entries", ps, depth, &(r_u->num_entries));
 861         prs_uint32("ptr_entries", ps, depth, &(r_u->ptr_entries));
 862
 863         if (r_u->num_entries != 0 && r_u->ptr_entries != 0)
 864         {
 865                 prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
 866                 prs_uint32("ptr_entries2", ps, depth, &(r_u->ptr_entries2));
 867                 prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
 868
 869                 SMB_ASSERT_ARRAY(r_u->sam, r_u->num_entries);
 870
 871                 for (i = 0; i < r_u->num_entries; i++)
 872                 {
 873                         sam_io_sam_entry("", &(r_u->sam[i]), ps, depth);
 874                 }
 875
 876                 for (i = 0; i < r_u->num_entries; i++)
 877                 {
 878                         smb_io_unistr2("", &(r_u->uni_grp_name[i]), r_u->sam[i].hdr_name.buffer, ps, depth);
 879                 }
 880
 881                 prs_align(ps);
 882
 883                 prs_uint32("num_entries4", ps, depth, &(r_u->num_entries4));
 884         }
 885
 886         prs_uint32("status", ps, depth, &(r_u->status));
 887 }
 888
 889
 890 /*******************************************************************
 891 makes a SAMR_Q_QUERY_DISPINFO structure.
 892 ********************************************************************/
 893 void make_samr_q_query_dispinfo(SAMR_Q_QUERY_DISPINFO *q_e, POLICY_HND *pol,
 894                                 uint16 switch_level, uint32 start_idx, uint32 size)
 895 {
 896         if (q_e == NULL || pol == NULL) return;
 897
 898         DEBUG(5,("make_q_query_dispinfo\n"));
 899
 900         memcpy(&(q_e->pol), pol, sizeof(*pol));
 901
 902         q_e->switch_level = switch_level;
 903
 904         q_e->unknown_0 = 0;
 905         q_e->start_idx = start_idx;
 906         q_e->unknown_1 = 0x000007d0;
 907         q_e->max_size  = size;
 908 }
 909
 910 /*******************************************************************
 911 reads or writes a structure.
 912 ********************************************************************/
 913 void samr_io_q_query_dispinfo(char *desc,  SAMR_Q_QUERY_DISPINFO *q_e, prs_struct *ps, int depth)
 914 {
 915         if (q_e == NULL) return;
 916
 917         prs_debug(ps, depth, desc, "samr_io_q_query_dispinfo");
 918         depth++;
 919
 920         prs_align(ps);
 921
 922         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
 923         prs_align(ps);
 924
 925         prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
 926         prs_uint16("unknown_0   ", ps, depth, &(q_e->unknown_0   ));
 927         prs_uint32("start_idx   ", ps, depth, &(q_e->start_idx   ));
 928         prs_uint32("unknown_1   ", ps, depth, &(q_e->unknown_1   ));
 929         prs_uint32("max_size    ", ps, depth, &(q_e->max_size    ));
 930
 931         prs_align(ps);
 932 }
 933
 934
 935 /*******************************************************************
 936 makes a SAM_INFO_2 structure.
 937 ********************************************************************/
 938 void make_sam_info_2(SAM_INFO_2 *sam, uint32 acb_mask,
 939                 uint32 start_idx, uint32 num_sam_entries,
 940                 SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
 941 {
 942         int i;
 943         int entries_added;
 944
 945         if (sam == NULL) return;
 946
 947         DEBUG(5,("make_sam_info_2\n"));
 948
 949         if (num_sam_entries >= MAX_SAM_ENTRIES)
 950         {
 951                 num_sam_entries = MAX_SAM_ENTRIES;
 952                 DEBUG(5,("limiting number of entries to %d\n",
 953                          num_sam_entries));
 954         }
 955
 956         for (i = start_idx, entries_added = 0; i < num_sam_entries; i++)
 957         {
 958                 if (IS_BITS_SET_ALL(pass[i].acb_info, acb_mask))
 959                 {
 960                         make_sam_entry2(&(sam->sam[entries_added]),
 961                                         start_idx + entries_added + 1,
 962                                         pass[i].uni_user_name.uni_str_len,
 963                                         pass[i].uni_acct_desc.uni_str_len,
 964                                         pass[i].user_rid,
 965                                         pass[i].acb_info);
 966
 967                         copy_unistr2(&(sam->str[entries_added].uni_srv_name), &(pass[i].uni_user_name));
 968                         copy_unistr2(&(sam->str[entries_added].uni_srv_desc), &(pass[i].uni_acct_desc));
 969
 970                         entries_added++;
 971                 }
 972
 973                 sam->num_entries   = entries_added;
 974                 sam->ptr_entries   = 1;
 975                 sam->num_entries2  = entries_added;
 976         }
 977 }
 978
 979 /*******************************************************************
 980 reads or writes a structure.
 981 ********************************************************************/
 982 static void sam_io_sam_info_2(char *desc,  SAM_INFO_2 *sam, prs_struct *ps, int depth)
 983 {
 984         int i;
 985
 986         if (sam == NULL) return;
 987
 988         prs_debug(ps, depth, desc, "sam_io_sam_info_2");
 989         depth++;
 990
 991         prs_align(ps);
 992
 993         prs_uint32("num_entries  ", ps, depth, &(sam->num_entries  ));
 994         prs_uint32("ptr_entries  ", ps, depth, &(sam->ptr_entries  ));
 995
 996         prs_uint32("num_entries2 ", ps, depth, &(sam->num_entries2 ));
 997
 998         SMB_ASSERT_ARRAY(sam->sam, sam->num_entries);
 999
1000         for (i = 0; i < sam->num_entries; i++)
1001         {
1002                 sam_io_sam_entry2("", &(sam->sam[i]), ps, depth);
1003         }
1004
1005         for (i = 0; i < sam->num_entries; i++)
1006         {
1007                 sam_io_sam_str2 ("", &(sam->str[i]),
1008                                                          sam->sam[i].hdr_srv_name.buffer,
1009                                                          sam->sam[i].hdr_srv_desc.buffer,
1010                                                          ps, depth);
1011         }
1012 }
1013
1014
1015 /*******************************************************************
1016 makes a SAM_INFO_1 structure.
1017 ********************************************************************/
1018 void make_sam_info_1(SAM_INFO_1 *sam, uint32 acb_mask,
1019                 uint32 start_idx, uint32 num_sam_entries,
1020                 SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
1021 {
1022         int i;
1023         int entries_added;
1024
1025         if (sam == NULL) return;
1026
1027         DEBUG(5,("make_sam_info_1\n"));
1028
1029         if (num_sam_entries >= MAX_SAM_ENTRIES)
1030         {
1031                 num_sam_entries = MAX_SAM_ENTRIES;
1032                 DEBUG(5,("limiting number of entries to %d\n",
1033                          num_sam_entries));
1034         }
1035
1036         for (i = start_idx, entries_added = 0; i < num_sam_entries; i++)
1037         {
1038                 if (IS_BITS_SET_ALL(pass[i].acb_info, acb_mask))
1039                 {
1040                         make_sam_entry1(&(sam->sam[entries_added]),
1041                                                 start_idx + entries_added + 1,
1042                                                 pass[i].uni_user_name.uni_str_len,
1043                                                 pass[i].uni_full_name.uni_str_len,
1044                                                 pass[i].uni_acct_desc.uni_str_len,
1045                                                 pass[i].user_rid,
1046                                                 pass[i].acb_info);
1047
1048                         copy_unistr2(&(sam->str[entries_added].uni_acct_name), &(pass[i].uni_user_name));
1049                         copy_unistr2(&(sam->str[entries_added].uni_full_name), &(pass[i].uni_full_name));
1050                         copy_unistr2(&(sam->str[entries_added].uni_acct_desc), &(pass[i].uni_acct_desc));
1051
1052                         entries_added++;
1053                 }
1054         }
1055
1056         sam->num_entries   = entries_added;
1057         sam->ptr_entries   = 1;
1058         sam->num_entries2  = entries_added;
1059 }
1060
1061
1062 /*******************************************************************
1063 reads or writes a structure.
1064 ********************************************************************/
1065 static void sam_io_sam_info_1(char *desc,  SAM_INFO_1 *sam, prs_struct *ps, int depth)
1066 {
1067         int i;
1068
1069         if (sam == NULL) return;
1070
1071         prs_debug(ps, depth, desc, "sam_io_sam_info_1");
1072         depth++;
1073
1074         prs_align(ps);
1075
1076         prs_uint32("num_entries  ", ps, depth, &(sam->num_entries  ));
1077         prs_uint32("ptr_entries  ", ps, depth, &(sam->ptr_entries  ));
1078
1079         prs_uint32("num_entries2 ", ps, depth, &(sam->num_entries2 ));
1080
1081         SMB_ASSERT_ARRAY(sam->sam, sam->num_entries);
1082
1083         for (i = 0; i < sam->num_entries; i++)
1084         {
1085                 sam_io_sam_entry1("", &(sam->sam[i]), ps, depth);
1086         }
1087
1088         for (i = 0; i < sam->num_entries; i++)
1089         {
1090                 sam_io_sam_str1 ("", &(sam->str[i]),
1091                                                          sam->sam[i].hdr_acct_name.buffer,
1092                                                          sam->sam[i].hdr_user_name.buffer,
1093                                                          sam->sam[i].hdr_user_desc.buffer,
1094                                                          ps, depth);
1095         }
1096 }
1097
1098
1099 /*******************************************************************
1100 makes a SAMR_R_QUERY_DISPINFO structure.
1101 ********************************************************************/
1102 void make_samr_r_query_dispinfo(SAMR_R_QUERY_DISPINFO *r_u,
1103                 uint16 switch_level, SAM_INFO_CTR *ctr, uint32 status)
1104 {
1105         if (r_u == NULL) return;
1106
1107         DEBUG(5,("make_samr_r_query_dispinfo\n"));
1108
1109         if (status == 0x0)
1110         {
1111                 r_u->unknown_0 = 0x0000001;
1112                 r_u->unknown_1 = 0x0000001;
1113         }
1114         else
1115         {
1116                 r_u->unknown_0 = 0x0;
1117                 r_u->unknown_1 = 0x0;
1118         }
1119
1120         r_u->switch_level = switch_level;
1121         r_u->ctr = ctr;
1122         r_u->status = status;
1123 }
1124
1125
1126 /*******************************************************************
1127 reads or writes a structure.
1128 ********************************************************************/
1129 void samr_io_r_query_dispinfo(char *desc,  SAMR_R_QUERY_DISPINFO *r_u, prs_struct *ps, int depth)
1130 {
1131         if (r_u == NULL) return;
1132
1133         prs_debug(ps, depth, desc, "samr_io_r_query_dispinfo");
1134         depth++;
1135
1136         prs_align(ps);
1137
1138         prs_uint32("unknown_0    ", ps, depth, &(r_u->unknown_0    ));
1139         prs_uint32("unknown_1    ", ps, depth, &(r_u->unknown_1    ));
1140         prs_uint16("switch_level ", ps, depth, &(r_u->switch_level ));
1141
1142         prs_align(ps);
1143
1144         switch (r_u->switch_level)
1145         {
1146                 case 0x1:
1147                 {
1148                         sam_io_sam_info_1("users", r_u->ctr->sam.info1, ps, depth);
1149                         break;
1150                 }
1151                 case 0x2:
1152                 {
1153                         sam_io_sam_info_2("servers", r_u->ctr->sam.info2, ps, depth);
1154                         break;
1155                 }
1156                 default:
1157                 {
1158                         DEBUG(5,("samr_io_r_query_dispinfo: unknown switch value\n"));
1159                         break;
1160                 }
1161         }
1162
1163         prs_uint32("status", ps, depth, &(r_u->status));
1164 }
1165
1166
1167 /*******************************************************************
1168 makes a SAMR_Q_ENUM_DOM_GROUPS structure.
1169 ********************************************************************/
1170 void make_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS *q_e, POLICY_HND *pol,
1171                                 uint16 switch_level, uint32 start_idx, uint32 size)
1172 {
1173         if (q_e == NULL || pol == NULL) return;
1174
1175         DEBUG(5,("make_q_enum_dom_groups\n"));
1176
1177         memcpy(&(q_e->pol), pol, sizeof(*pol));
1178
1179         q_e->switch_level = switch_level;
1180
1181         q_e->unknown_0 = 0;
1182         q_e->start_idx = start_idx;
1183         q_e->unknown_1 = 0x000007d0;
1184         q_e->max_size  = size;
1185 }
1186
1187
1188 /*******************************************************************
1189 reads or writes a structure.
1190 ********************************************************************/
1191 void samr_io_q_enum_dom_groups(char *desc,  SAMR_Q_ENUM_DOM_GROUPS *q_e, prs_struct *ps, int depth)
1192 {
1193         if (q_e == NULL) return;
1194
1195         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_groups");
1196         depth++;
1197
1198         prs_align(ps);
1199
1200         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
1201         prs_align(ps);
1202
1203         prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
1204         prs_uint16("unknown_0   ", ps, depth, &(q_e->unknown_0   ));
1205         prs_uint32("start_idx   ", ps, depth, &(q_e->start_idx   ));
1206         prs_uint32("unknown_1   ", ps, depth, &(q_e->unknown_1   ));
1207         prs_uint32("max_size    ", ps, depth, &(q_e->max_size    ));
1208
1209         prs_align(ps);
1210 }
1211
1212
1213 /*******************************************************************
1214 makes a SAMR_R_ENUM_DOM_GROUPS structure.
1215 ********************************************************************/
1216 void make_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS *r_u,
1217                 uint32 start_idx, uint32 num_sam_entries,
1218                 SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES],
1219                 uint32 status)
1220 {
1221         int i;
1222         int entries_added;
1223
1224         if (r_u == NULL) return;
1225
1226         DEBUG(5,("make_samr_r_enum_dom_groups\n"));
1227
1228         if (num_sam_entries >= MAX_SAM_ENTRIES)
1229         {
1230                 num_sam_entries = MAX_SAM_ENTRIES;
1231                 DEBUG(5,("limiting number of entries to %d\n",
1232                          num_sam_entries));
1233         }
1234
1235         if (status == 0x0)
1236         {
1237                 for (i = start_idx, entries_added = 0; i < num_sam_entries; i++)
1238                 {
1239                         make_sam_entry3(&(r_u->sam[entries_added]),
1240                                         start_idx + entries_added + 1,
1241                                         pass[i].uni_user_name.uni_str_len,
1242                                         pass[i].uni_acct_desc.uni_str_len,
1243                                         pass[i].user_rid);
1244
1245                         copy_unistr2(&(r_u->str[entries_added].uni_grp_name), &(pass[i].uni_user_name));
1246                         copy_unistr2(&(r_u->str[entries_added].uni_grp_desc), &(pass[i].uni_acct_desc));
1247
1248                         entries_added++;
1249                 }
1250
1251                 if (entries_added > 0)
1252                 {
1253                         r_u->unknown_0 = 0x0000492;
1254                         r_u->unknown_1 = 0x000049a;
1255                 }
1256                 else
1257                 {
1258                         r_u->unknown_0 = 0x0;
1259                         r_u->unknown_1 = 0x0;
1260                 }
1261                 r_u->switch_level  = 3;
1262                 r_u->num_entries   = entries_added;
1263                 r_u->ptr_entries   = 1;
1264                 r_u->num_entries2  = entries_added;
1265         }
1266         else
1267         {
1268                 r_u->switch_level = 0;
1269         }
1270
1271         r_u->status = status;
1272 }
1273
1274 /*******************************************************************
1275 reads or writes a structure.
1276 ********************************************************************/
1277 void samr_io_r_enum_dom_groups(char *desc,  SAMR_R_ENUM_DOM_GROUPS *r_u, prs_struct *ps, int depth)
1278 {
1279         int i;
1280
1281         if (r_u == NULL) return;
1282
1283         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_groups");
1284         depth++;
1285
1286         prs_align(ps);
1287
1288         prs_uint32("unknown_0    ", ps, depth, &(r_u->unknown_0    ));
1289         prs_uint32("unknown_1    ", ps, depth, &(r_u->unknown_1    ));
1290         prs_uint32("switch_level ", ps, depth, &(r_u->switch_level ));
1291
1292         if (r_u->switch_level != 0)
1293         {
1294                 prs_uint32("num_entries  ", ps, depth, &(r_u->num_entries  ));
1295                 prs_uint32("ptr_entries  ", ps, depth, &(r_u->ptr_entries  ));
1296
1297                 prs_uint32("num_entries2 ", ps, depth, &(r_u->num_entries2 ));
1298
1299                 SMB_ASSERT_ARRAY(r_u->sam, r_u->num_entries);
1300
1301                 for (i = 0; i < r_u->num_entries; i++)
1302                 {
1303                         sam_io_sam_entry3("", &(r_u->sam[i]), ps, depth);
1304                 }
1305
1306                 for (i = 0; i < r_u->num_entries; i++)
1307                 {
1308                         sam_io_sam_str3 ("", &(r_u->str[i]),
1309                                              r_u->sam[i].hdr_grp_name.buffer,
1310                                              r_u->sam[i].hdr_grp_desc.buffer,
1311                                              ps, depth);
1312                 }
1313         }
1314
1315         prs_uint32("status", ps, depth, &(r_u->status));
1316 }
1317
1318
1319 /*******************************************************************
1320 makes a SAMR_Q_QUERY_ALIASINFO structure.
1321 ********************************************************************/
1322 void make_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO *q_e,
1323                                 POLICY_HND *pol,
1324                                 uint16 switch_level)
1325 {
1326         if (q_e == NULL || pol == NULL) return;
1327
1328         DEBUG(5,("make_q_query_aliasinfo\n"));
1329
1330         memcpy(&(q_e->pol), pol, sizeof(*pol));
1331
1332         q_e->switch_level = switch_level;
1333 }
1334
1335
1336 /*******************************************************************
1337 reads or writes a structure.
1338 ********************************************************************/
1339 void samr_io_q_query_aliasinfo(char *desc,  SAMR_Q_QUERY_ALIASINFO *q_e, prs_struct *ps, int depth)
1340 {
1341         if (q_e == NULL) return;
1342
1343         prs_debug(ps, depth, desc, "samr_io_q_query_aliasinfo");
1344         depth++;
1345
1346         prs_align(ps);
1347
1348         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
1349         prs_align(ps);
1350
1351         prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
1352 }
1353
1354
1355 /*******************************************************************
1356 makes a SAMR_R_QUERY_ALIASINFO structure.
1357 ********************************************************************/
1358 void make_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *r_u,
1359                 uint16 switch_value, char *acct_desc,
1360                 uint32 status)
1361 {
1362         if (r_u == NULL) return;
1363
1364         DEBUG(5,("make_samr_r_query_aliasinfo\n"));
1365
1366         r_u->ptr = 0;
1367
1368         if (status == 0)
1369         {
1370                 r_u->switch_value = switch_value;
1371
1372                 switch (switch_value)
1373                 {
1374                         case 3:
1375                         {
1376                                 int acct_len = acct_desc ? strlen(acct_desc) : 0;
1377
1378                                 r_u->ptr = 1;
1379
1380                                 make_uni_hdr(&(r_u->alias.info3.hdr_acct_desc), acct_len , acct_len, acct_desc ? 1 : 0);
1381                                 make_unistr2(&(r_u->alias.info3.uni_acct_desc), acct_desc, acct_len);
1382
1383                                 break;
1384                         }
1385
1386                         default:
1387                         {
1388                                 DEBUG(4,("make_samr_r_query_aliasinfo: unsupported switch level\n"));
1389                                 break;
1390                         }
1391                 }
1392         }
1393
1394         r_u->status = status;
1395 }
1396
1397
1398 /*******************************************************************
1399 reads or writes a structure.
1400 ********************************************************************/
1401 void samr_io_r_query_aliasinfo(char *desc,  SAMR_R_QUERY_ALIASINFO *r_u, prs_struct *ps, int depth)
1402 {
1403         if (r_u == NULL) return;
1404
1405         prs_debug(ps, depth, desc, "samr_io_r_query_aliasinfo");
1406         depth++;
1407
1408         prs_align(ps);
1409
1410         prs_uint32("ptr         ", ps, depth, &(r_u->ptr         ));
1411
1412         if (r_u->ptr != 0)
1413         {
1414                 prs_uint16("switch_value", ps, depth, &(r_u->switch_value));
1415                 prs_align(ps);
1416
1417                 if (r_u->switch_value != 0)
1418                 {
1419                         switch (r_u->switch_value)
1420                         {
1421                                 case 3:
1422                                 {
1423                                         smb_io_unihdr ("", &(r_u->alias.info3.hdr_acct_desc), ps, depth);
1424                                         smb_io_unistr2("", &(r_u->alias.info3.uni_acct_desc), r_u->alias.info3.hdr_acct_desc.buffer, ps, depth);
1425                                         break;
1426                                 }
1427                                 default:
1428                                 {
1429                                         DEBUG(4,("samr_io_r_query_aliasinfo: unsupported switch level\n"));
1430                                         break;
1431                                 }
1432                         }
1433                 }
1434         }
1435
1436         prs_align(ps);
1437
1438         prs_uint32("status", ps, depth, &(r_u->status));
1439 }
1440
1441 /*******************************************************************
1442 reads or writes a SAMR_Q_LOOKUP_IDS structure.
1443 ********************************************************************/
1444 void samr_io_q_lookup_ids(char *desc,  SAMR_Q_LOOKUP_IDS *q_u, prs_struct *ps, int depth)
1445 {
1446         fstring tmp;
1447         int i;
1448
1449         if (q_u == NULL) return;
1450
1451         prs_debug(ps, depth, desc, "samr_io_q_lookup_ids");
1452         depth++;
1453
1454         prs_align(ps);
1455
1456         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1457         prs_align(ps);
1458
1459         prs_uint32("num_sids1", ps, depth, &(q_u->num_sids1));
1460         prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
1461         prs_uint32("num_sids2", ps, depth, &(q_u->num_sids2));
1462
1463         SMB_ASSERT_ARRAY(q_u->ptr_sid, q_u->num_sids2);
1464
1465         for (i = 0; i < q_u->num_sids2; i++)
1466         {
1467                 slprintf(tmp, sizeof(tmp) - 1, "ptr[%02d]", i);
1468                 prs_uint32(tmp, ps, depth, &(q_u->ptr_sid[i]));
1469         }
1470
1471         for (i = 0; i < q_u->num_sids2; i++)
1472         {
1473                 if (q_u->ptr_sid[i] != 0)
1474                 {
1475                         slprintf(tmp, sizeof(tmp)-1, "sid[%02d]", i);
1476                         smb_io_dom_sid2(tmp, &(q_u->sid[i]), ps, depth);
1477                 }
1478         }
1479
1480         prs_align(ps);
1481 }
1482
1483
1484 /*******************************************************************
1485 makes a SAMR_R_LOOKUP_IDS structure.
1486 ********************************************************************/
1487 void make_samr_r_lookup_ids(SAMR_R_LOOKUP_IDS *r_u,
1488                 uint32 num_rids, uint32 *rid, uint32 status)
1489 {
1490         int i;
1491         if (r_u == NULL) return;
1492
1493         DEBUG(5,("make_samr_r_lookup_ids\n"));
1494
1495         if (status == 0x0)
1496         {
1497                 r_u->num_entries  = num_rids;
1498                 r_u->ptr = 1;
1499                 r_u->num_entries2 = num_rids;
1500
1501                 SMB_ASSERT_ARRAY(r_u->rid, num_rids);
1502
1503                 for (i = 0; i < num_rids; i++)
1504                 {
1505                         r_u->rid[i] = rid[i];
1506                 }
1507         }
1508         else
1509         {
1510                 r_u->num_entries  = 0;
1511                 r_u->ptr = 0;
1512                 r_u->num_entries2 = 0;
1513         }
1514
1515         r_u->status = status;
1516 }
1517
1518 /*******************************************************************
1519 reads or writes a structure.
1520 ********************************************************************/
1521 void samr_io_r_lookup_ids(char *desc,  SAMR_R_LOOKUP_IDS *r_u, prs_struct *ps, int depth)
1522 {
1523         fstring tmp;
1524         int i;
1525         if (r_u == NULL) return;
1526
1527         prs_debug(ps, depth, desc, "samr_io_r_lookup_ids");
1528         depth++;
1529
1530         prs_align(ps);
1531
1532         prs_uint32("num_entries", ps, depth, &(r_u->num_entries));
1533         prs_uint32("ptr        ", ps, depth, &(r_u->ptr        ));
1534         prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
1535
1536         if (r_u->num_entries != 0)
1537         {
1538                 SMB_ASSERT_ARRAY(r_u->rid, r_u->num_entries2);
1539
1540                 for (i = 0; i < r_u->num_entries2; i++)
1541                 {
1542                         slprintf(tmp, sizeof(tmp)-1, "rid[%02d]", i);
1543                         prs_uint32(tmp, ps, depth, &(r_u->rid[i]));
1544                 }
1545         }
1546
1547         prs_uint32("status", ps, depth, &(r_u->status));
1548 }
1549
1550 /*******************************************************************
1551 reads or writes a structure.
1552 ********************************************************************/
1553 void samr_io_q_lookup_names(char *desc,  SAMR_Q_LOOKUP_NAMES *q_u, prs_struct *ps, int depth)
1554 {
1555         int i;
1556
1557         if (q_u == NULL) return;
1558
1559         prs_debug(ps, depth, desc, "samr_io_q_lookup_names");
1560         depth++;
1561
1562         prs_align(ps);
1563
1564         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1565         prs_align(ps);
1566
1567         prs_uint32("num_rids1", ps, depth, &(q_u->num_rids1));
1568         prs_uint32("rid      ", ps, depth, &(q_u->rid      ));
1569         prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
1570         prs_uint32("num_rids2", ps, depth, &(q_u->num_rids2));
1571
1572         SMB_ASSERT_ARRAY(q_u->hdr_user_name, q_u->num_rids2);
1573
1574         for (i = 0; i < q_u->num_rids2; i++)
1575         {
1576                 smb_io_unihdr ("", &(q_u->hdr_user_name[i]), ps, depth);
1577         }
1578         for (i = 0; i < q_u->num_rids2; i++)
1579         {
1580                 smb_io_unistr2("", &(q_u->uni_user_name[i]), q_u->hdr_user_name[i].buffer, ps, depth);
1581         }
1582
1583         prs_align(ps);
1584 }
1585
1586
1587 /*******************************************************************
1588 makes a SAMR_R_LOOKUP_NAMES structure.
1589 ********************************************************************/
1590 void make_samr_r_lookup_names(SAMR_R_LOOKUP_NAMES *r_u,
1591                 uint32 num_rids, uint32 *rid, uint32 status)
1592 {
1593         int i;
1594         if (r_u == NULL) return;
1595
1596         DEBUG(5,("make_samr_r_lookup_names\n"));
1597
1598         if (status == 0x0)
1599         {
1600                 r_u->num_entries  = num_rids;
1601                 r_u->undoc_buffer = 1;
1602                 r_u->num_entries2 = num_rids;
1603
1604                 SMB_ASSERT_ARRAY(r_u->dom_rid, num_rids);
1605
1606                 for (i = 0; i < num_rids; i++)
1607                 {
1608                         make_dom_rid3(&(r_u->dom_rid[i]), rid[i]);
1609                 }
1610
1611                 r_u->num_entries3 = num_rids;
1612         }
1613         else
1614         {
1615                 r_u->num_entries  = 0;
1616                 r_u->undoc_buffer = 0;
1617                 r_u->num_entries2 = 0;
1618                 r_u->num_entries3 = 0;
1619         }
1620
1621         r_u->status = status;
1622 }
1623
1624 /*******************************************************************
1625 reads or writes a structure.
1626 ********************************************************************/
1627 void samr_io_r_lookup_names(char *desc,  SAMR_R_LOOKUP_NAMES *r_u, prs_struct *ps, int depth)
1628 {
1629         int i;
1630         if (r_u == NULL) return;
1631
1632         prs_debug(ps, depth, desc, "samr_io_r_lookup_names");
1633         depth++;
1634
1635         prs_align(ps);
1636
1637         prs_uint32("num_entries ", ps, depth, &(r_u->num_entries ));
1638         prs_uint32("undoc_buffer", ps, depth, &(r_u->undoc_buffer));
1639         prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
1640
1641         if (r_u->num_entries != 0)
1642         {
1643                 SMB_ASSERT_ARRAY(r_u->dom_rid, r_u->num_entries2);
1644
1645                 for (i = 0; i < r_u->num_entries2; i++)
1646                 {
1647                         smb_io_dom_rid3("", &(r_u->dom_rid[i]), ps, depth);
1648                 }
1649
1650         }
1651
1652         prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
1653
1654         prs_uint32("status", ps, depth, &(r_u->status));
1655 }
1656
1657 /*******************************************************************
1658 reads or writes a structure.
1659 ********************************************************************/
1660 void samr_io_q_unknown_12(char *desc,  SAMR_Q_UNKNOWN_12 *q_u, prs_struct *ps, int depth)
1661 {
1662         int i;
1663         fstring tmp;
1664
1665         if (q_u == NULL) return;
1666
1667         prs_debug(ps, depth, desc, "samr_io_q_unknown_12");
1668         depth++;
1669
1670         prs_align(ps);
1671
1672         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1673         prs_align(ps);
1674
1675         prs_uint32("num_gids1", ps, depth, &(q_u->num_gids1));
1676         prs_uint32("rid      ", ps, depth, &(q_u->rid      ));
1677         prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
1678         prs_uint32("num_gids2", ps, depth, &(q_u->num_gids2));
1679
1680         SMB_ASSERT_ARRAY(q_u->gid, q_u->num_gids2);
1681
1682         for (i = 0; i < q_u->num_gids2; i++)
1683         {
1684                 slprintf(tmp, sizeof(tmp) - 1, "gid[%02d]  ", i);
1685                 prs_uint32(tmp, ps, depth, &(q_u->gid[i]));
1686         }
1687
1688         prs_align(ps);
1689 }
1690
1691
1692 /*******************************************************************
1693 makes a SAMR_R_UNKNOWN_12 structure.
1694 ********************************************************************/
1695 void make_samr_r_unknown_12(SAMR_R_UNKNOWN_12 *r_u,
1696                 uint32 num_aliases, fstring *als_name, uint32 *num_als_usrs,
1697                 uint32 status)
1698 {
1699         int i;
1700         if (r_u == NULL || als_name == NULL || num_als_usrs == NULL) return;
1701
1702         DEBUG(5,("make_samr_r_unknown_12\n"));
1703
1704         if (status == 0x0)
1705         {
1706                 r_u->num_aliases1 = num_aliases;
1707                 r_u->ptr_aliases  = 1;
1708                 r_u->num_aliases2 = num_aliases;
1709
1710                 r_u->num_als_usrs1 = num_aliases;
1711                 r_u->ptr_als_usrs  = 1;
1712                 r_u->num_als_usrs2 = num_aliases;
1713
1714                 SMB_ASSERT_ARRAY(r_u->hdr_als_name, num_aliases);
1715
1716                 for (i = 0; i < num_aliases; i++)
1717                 {
1718                         int als_len = als_name[i] != NULL ? strlen(als_name[i]) : 0;
1719                         make_uni_hdr(&(r_u->hdr_als_name[i]), als_len    , als_len, als_name[i] ? 1 : 0);
1720                         make_unistr2(&(r_u->uni_als_name[i]), als_name[i], als_len);
1721                         r_u->num_als_usrs[i] = num_als_usrs[i];
1722                 }
1723         }
1724         else
1725         {
1726                 r_u->num_aliases1 = num_aliases;
1727                 r_u->ptr_aliases  = 0;
1728                 r_u->num_aliases2 = num_aliases;
1729
1730                 r_u->num_als_usrs1 = num_aliases;
1731                 r_u->ptr_als_usrs  = 0;
1732                 r_u->num_als_usrs2 = num_aliases;
1733         }
1734
1735         r_u->status = status;
1736 }
1737
1738 /*******************************************************************
1739 reads or writes a structure.
1740 ********************************************************************/
1741 void samr_io_r_unknown_12(char *desc,  SAMR_R_UNKNOWN_12 *r_u, prs_struct *ps, int depth)
1742 {
1743         int i;
1744         fstring tmp;
1745         if (r_u == NULL) return;
1746
1747         prs_debug(ps, depth, desc, "samr_io_r_unknown_12");
1748         depth++;
1749
1750         prs_align(ps);
1751
1752         prs_uint32("num_aliases1", ps, depth, &(r_u->num_aliases1));
1753         prs_uint32("ptr_aliases ", ps, depth, &(r_u->ptr_aliases ));
1754         prs_uint32("num_aliases2", ps, depth, &(r_u->num_aliases2));
1755
1756         if (r_u->ptr_aliases != 0 && r_u->num_aliases1 != 0)
1757         {
1758                 SMB_ASSERT_ARRAY(r_u->hdr_als_name, r_u->num_aliases2);
1759
1760                 for (i = 0; i < r_u->num_aliases2; i++)
1761                 {
1762                         slprintf(tmp, sizeof(tmp) - 1, "als_hdr[%02d]  ", i);
1763                         smb_io_unihdr ("", &(r_u->hdr_als_name[i]), ps, depth);
1764                 }
1765                 for (i = 0; i < r_u->num_aliases2; i++)
1766                 {
1767                         slprintf(tmp, sizeof(tmp) - 1, "als_str[%02d]  ", i);
1768                         smb_io_unistr2("", &(r_u->uni_als_name[i]), r_u->hdr_als_name[i].buffer, ps, depth);
1769                 }
1770         }
1771
1772         prs_align(ps);
1773
1774         prs_uint32("num_als_usrs1", ps, depth, &(r_u->num_als_usrs1));
1775         prs_uint32("ptr_als_usrs ", ps, depth, &(r_u->ptr_als_usrs ));
1776         prs_uint32("num_als_usrs2", ps, depth, &(r_u->num_als_usrs2));
1777
1778         if (r_u->ptr_als_usrs != 0 && r_u->num_als_usrs1 != 0)
1779         {
1780                 SMB_ASSERT_ARRAY(r_u->num_als_usrs, r_u->num_als_usrs2);
1781
1782                 for (i = 0; i < r_u->num_als_usrs2; i++)
1783                 {
1784                         slprintf(tmp, sizeof(tmp) - 1, "als_usrs[%02d]  ", i);
1785                         prs_uint32(tmp, ps, depth, &(r_u->num_als_usrs[i]));
1786                 }
1787         }
1788
1789         prs_uint32("status", ps, depth, &(r_u->status));
1790 }
1791
1792
1793 /*******************************************************************
1794 reads or writes a structure.
1795 ********************************************************************/
1796 void make_samr_q_open_user(SAMR_Q_OPEN_USER *q_u,
1797                                 POLICY_HND *pol,
1798                                 uint32 unk_0, uint32 rid)
1799 {
1800         if (q_u == NULL) return;
1801
1802         DEBUG(5,("samr_make_q_open_user\n"));
1803
1804         memcpy(&q_u->domain_pol, pol, sizeof(q_u->domain_pol));
1805
1806         q_u->unknown_0 = unk_0;
1807         q_u->user_rid  = rid;
1808 }
1809
1810 /*******************************************************************
1811 reads or writes a structure.
1812 ********************************************************************/
1813 void samr_io_q_open_user(char *desc,  SAMR_Q_OPEN_USER *q_u, prs_struct *ps, int depth)
1814 {
1815         if (q_u == NULL) return;
1816
1817         prs_debug(ps, depth, desc, "samr_io_q_open_user");
1818         depth++;
1819
1820         prs_align(ps);
1821
1822         smb_io_pol_hnd("domain_pol", &(q_u->domain_pol), ps, depth);
1823         prs_align(ps);
1824
1825         prs_uint32("unknown_0", ps, depth, &(q_u->unknown_0));
1826         prs_uint32("user_rid ", ps, depth, &(q_u->user_rid ));
1827
1828         prs_align(ps);
1829 }
1830
1831 /*******************************************************************
1832 reads or writes a structure.
1833 ********************************************************************/
1834 void samr_io_r_open_user(char *desc,  SAMR_R_OPEN_USER *r_u, prs_struct *ps, int depth)
1835 {
1836         if (r_u == NULL) return;
1837
1838         prs_debug(ps, depth, desc, "samr_io_r_open_user");
1839         depth++;
1840
1841         prs_align(ps);
1842
1843         smb_io_pol_hnd("user_pol", &(r_u->user_pol), ps, depth);
1844         prs_align(ps);
1845
1846         prs_uint32("status", ps, depth, &(r_u->status));
1847 }
1848
1849 /*******************************************************************
1850 makes a SAMR_Q_QUERY_USERGROUPS structure.
1851 ********************************************************************/
1852 void make_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS *q_u,
1853                                 POLICY_HND *hnd)
1854 {
1855         if (q_u == NULL || hnd == NULL) return;
1856
1857         DEBUG(5,("make_samr_q_query_usergroups\n"));
1858
1859         memcpy(&(q_u->pol), hnd, sizeof(q_u->pol));
1860 }
1861
1862
1863 /*******************************************************************
1864 reads or writes a structure.
1865 ********************************************************************/
1866 void samr_io_q_query_usergroups(char *desc,  SAMR_Q_QUERY_USERGROUPS *q_u, prs_struct *ps, int depth)
1867 {
1868         if (q_u == NULL) return;
1869
1870         prs_debug(ps, depth, desc, "samr_io_q_query_usergroups");
1871         depth++;
1872
1873         prs_align(ps);
1874
1875         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1876         prs_align(ps);
1877 }
1878
1879 /*******************************************************************
1880 makes a SAMR_R_QUERY_USERGROUPS structure.
1881 ********************************************************************/
1882 void make_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS *r_u,
1883                 uint32 num_gids, DOM_GID *gid, uint32 status)
1884 {
1885         if (r_u == NULL) return;
1886
1887         DEBUG(5,("make_samr_r_query_usergroups\n"));
1888
1889         if (status == 0x0)
1890         {
1891                 r_u->ptr_0        = 1;
1892                 r_u->num_entries  = num_gids;
1893                 r_u->ptr_1        = 1;
1894                 r_u->num_entries2 = num_gids;
1895
1896                 r_u->gid = gid;
1897         }
1898         else
1899         {
1900                 r_u->ptr_0       = 0;
1901                 r_u->num_entries = 0;
1902                 r_u->ptr_1       = 0;
1903         }
1904
1905         r_u->status = status;
1906 }
1907
1908 /*******************************************************************
1909 reads or writes a structure.
1910 ********************************************************************/
1911 void samr_io_r_query_usergroups(char *desc,  SAMR_R_QUERY_USERGROUPS *r_u, prs_struct *ps, int depth)
1912 {
1913         int i;
1914         if (r_u == NULL) return;
1915
1916         prs_debug(ps, depth, desc, "samr_io_r_query_usergroups");
1917         depth++;
1918
1919         prs_align(ps);
1920
1921         prs_uint32("ptr_0       ", ps, depth, &(r_u->ptr_0      ));
1922
1923         if (r_u->ptr_0 != 0)
1924         {
1925                 prs_uint32("num_entries ", ps, depth, &(r_u->num_entries));
1926                 prs_uint32("ptr_1       ", ps, depth, &(r_u->ptr_1      ));
1927
1928                 if (r_u->num_entries != 0)
1929                 {
1930                         prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
1931
1932                         for (i = 0; i < r_u->num_entries2; i++)
1933                         {
1934                                 smb_io_gid("", &(r_u->gid[i]), ps, depth);
1935                         }
1936                 }
1937         }
1938         prs_uint32("status", ps, depth, &(r_u->status));
1939 }
1940
1941 /*******************************************************************
1942 makes a SAMR_Q_QUERY_USERINFO structure.
1943 ********************************************************************/
1944 void make_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO *q_u,
1945                                 POLICY_HND *hnd, uint16 switch_value)
1946 {
1947         if (q_u == NULL || hnd == NULL) return;
1948
1949         DEBUG(5,("make_samr_q_query_userinfo\n"));
1950
1951         memcpy(&(q_u->pol), hnd, sizeof(q_u->pol));
1952         q_u->switch_value = switch_value;
1953 }
1954
1955
1956 /*******************************************************************
1957 reads or writes a structure.
1958 ********************************************************************/
1959 void samr_io_q_query_userinfo(char *desc,  SAMR_Q_QUERY_USERINFO *q_u, prs_struct *ps, int depth)
1960 {
1961         if (q_u == NULL) return;
1962
1963         prs_debug(ps, depth, desc, "samr_io_q_query_userinfo");
1964         depth++;
1965
1966         prs_align(ps);
1967
1968         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1969         prs_align(ps);
1970
1971         prs_uint16("switch_value", ps, depth, &(q_u->switch_value)); /* 0x0015 or 0x0011 */
1972
1973         prs_align(ps);
1974 }
1975
1976 /*******************************************************************
1977 reads or writes a LOGON_HRS structure.
1978 ********************************************************************/
1979 static void sam_io_logon_hrs(char *desc,  LOGON_HRS *hrs, prs_struct *ps, int depth)
1980 {
1981         if (hrs == NULL) return;
1982
1983         prs_debug(ps, depth, desc, "sam_io_logon_hrs");
1984         depth++;
1985
1986         prs_align(ps);
1987
1988         prs_uint32 (       "len  ", ps, depth, &(hrs->len ));
1989
1990         if (hrs->len > 64)
1991         {
1992                 DEBUG(5,("sam_io_logon_hrs: truncating length\n"));
1993                 hrs->len = 64;
1994         }
1995
1996         prs_uint8s (False, "hours", ps, depth, hrs->hours, hrs->len);
1997 }
1998
1999 /*************************************************************************
2000  make_sam_user_info21
2001
2002  unknown_3 = 0x00ff ffff
2003  unknown_5 = 0x0002 0000
2004  unknown_6 = 0x0000 04ec
2005
2006  *************************************************************************/
2007 void make_sam_user_info21(SAM_USER_INFO_21 *usr,
2008
2009         NTTIME *logon_time,
2010         NTTIME *logoff_time,
2011         NTTIME *kickoff_time,
2012         NTTIME *pass_last_set_time,
2013         NTTIME *pass_can_change_time,
2014         NTTIME *pass_must_change_time,
2015
2016         char *user_name,
2017         char *full_name,
2018         char *home_dir,
2019         char *dir_drive,
2020         char *logon_script,
2021         char *profile_path,
2022         char *description,
2023         char *workstations,
2024         char *unknown_str,
2025         char *munged_dial,
2026
2027         uint32 user_rid,
2028         uint32 group_rid,
2029         uint16 acb_info,
2030
2031         uint32 unknown_3,
2032         uint16 logon_divs,
2033         LOGON_HRS *hrs,
2034         uint32 unknown_5,
2035         uint32 unknown_6)
2036 {
2037         int len_user_name    = user_name    != NULL ? strlen(user_name   ) : 0;
2038         int len_full_name    = full_name    != NULL ? strlen(full_name   ) : 0;
2039         int len_home_dir     = home_dir     != NULL ? strlen(home_dir    ) : 0;
2040         int len_dir_drive    = dir_drive    != NULL ? strlen(dir_drive   ) : 0;
2041         int len_logon_script = logon_script != NULL ? strlen(logon_script) : 0;
2042         int len_profile_path = profile_path != NULL ? strlen(profile_path) : 0;
2043         int len_description  = description  != NULL ? strlen(description ) : 0;
2044         int len_workstations = workstations != NULL ? strlen(workstations) : 0;
2045         int len_unknown_str  = unknown_str  != NULL ? strlen(unknown_str ) : 0;
2046         int len_munged_dial  = munged_dial  != NULL ? strlen(munged_dial ) : 0;
2047
2048         usr->logon_time            = *logon_time;
2049         usr->logoff_time           = *logoff_time;
2050         usr->kickoff_time          = *kickoff_time;
2051         usr->pass_last_set_time    = *pass_last_set_time;
2052         usr->pass_can_change_time  = *pass_can_change_time;
2053         usr->pass_must_change_time = *pass_must_change_time;
2054
2055         make_uni_hdr(&(usr->hdr_user_name   ), len_user_name   , len_user_name   , len_user_name    != 0);
2056         make_uni_hdr(&(usr->hdr_full_name   ), len_full_name   , len_full_name   , len_full_name    != 0);
2057         make_uni_hdr(&(usr->hdr_home_dir    ), len_home_dir    , len_home_dir    , len_home_dir     != 0);
2058         make_uni_hdr(&(usr->hdr_dir_drive   ), len_dir_drive   , len_dir_drive   , len_dir_drive    != 0);
2059         make_uni_hdr(&(usr->hdr_logon_script), len_logon_script, len_logon_script, len_logon_script != 0);
2060         make_uni_hdr(&(usr->hdr_profile_path), len_profile_path, len_profile_path, len_profile_path != 0);
2061         make_uni_hdr(&(usr->hdr_acct_desc   ), len_description , len_description , len_description  != 0);
2062         make_uni_hdr(&(usr->hdr_workstations), len_workstations, len_workstations, len_workstations != 0);
2063         make_uni_hdr(&(usr->hdr_unknown_str ), len_unknown_str , len_unknown_str , len_workstations != 0);
2064         make_uni_hdr(&(usr->hdr_munged_dial ), len_munged_dial , len_munged_dial , len_workstations != 0);
2065
2066         bzero(usr->nt_pwd, sizeof(usr->nt_pwd));
2067         bzero(usr->lm_pwd, sizeof(usr->lm_pwd));
2068
2069         usr->user_rid  = user_rid;
2070         usr->group_rid = group_rid;
2071         usr->acb_info = acb_info;
2072         usr->unknown_3 = unknown_3; /* 0x00ff ffff */
2073
2074         usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
2075         usr->ptr_logon_hrs = hrs ? 1 : 0;
2076         usr->unknown_5 = unknown_5; /* 0x0002 0000 */
2077
2078         bzero(usr->padding1, sizeof(usr->padding1));
2079
2080         make_unistr2(&(usr->uni_user_name   ), user_name   , len_user_name   );
2081         make_unistr2(&(usr->uni_full_name   ), full_name   , len_full_name   );
2082         make_unistr2(&(usr->uni_home_dir    ), home_dir    , len_home_dir    );
2083         make_unistr2(&(usr->uni_dir_drive   ), dir_drive   , len_dir_drive   );
2084         make_unistr2(&(usr->uni_logon_script), logon_script, len_logon_script);
2085         make_unistr2(&(usr->uni_profile_path), profile_path, len_profile_path);
2086         make_unistr2(&(usr->uni_acct_desc ), description , len_description );
2087         make_unistr2(&(usr->uni_workstations), workstations, len_workstations);
2088         make_unistr2(&(usr->uni_unknown_str ), unknown_str , len_unknown_str );
2089         make_unistr2(&(usr->uni_munged_dial ), munged_dial , len_munged_dial );
2090
2091         usr->unknown_6 = unknown_6; /* 0x0000 04ec */
2092         usr->padding4 = 0;
2093
2094         if (hrs)
2095         {
2096                 memcpy(&(usr->logon_hrs), hrs, sizeof(usr->logon_hrs));
2097         }
2098         else
2099         {
2100                 memset(&(usr->logon_hrs), 0xff, sizeof(usr->logon_hrs));
2101         }
2102 }
2103
2104
2105 /*******************************************************************
2106 reads or writes a structure.
2107 ********************************************************************/
2108 static void sam_io_user_info21(char *desc,  SAM_USER_INFO_21 *usr, prs_struct *ps, int depth)
2109 {
2110         if (usr == NULL) return;
2111
2112         prs_debug(ps, depth, desc, "lsa_io_user_info");
2113         depth++;
2114
2115         prs_align(ps);
2116
2117         smb_io_time("logon_time           ", &(usr->logon_time)           , ps, depth);
2118         smb_io_time("logoff_time          ", &(usr->logoff_time)          , ps, depth);
2119         smb_io_time("kickoff_time         ", &(usr->kickoff_time)         , ps, depth);
2120         smb_io_time("pass_last_set_time   ", &(usr->pass_last_set_time)   , ps, depth);
2121         smb_io_time("pass_can_change_time ", &(usr->pass_can_change_time) , ps, depth);
2122         smb_io_time("pass_must_change_time", &(usr->pass_must_change_time), ps, depth);
2123
2124         smb_io_unihdr("hdr_user_name   ", &(usr->hdr_user_name)   , ps, depth); /* username unicode string header */
2125         smb_io_unihdr("hdr_full_name   ", &(usr->hdr_full_name)   , ps, depth); /* user's full name unicode string header */
2126         smb_io_unihdr("hdr_home_dir    ", &(usr->hdr_home_dir)    , ps, depth); /* home directory unicode string header */
2127         smb_io_unihdr("hdr_dir_drive   ", &(usr->hdr_dir_drive)   , ps, depth); /* home directory drive */
2128         smb_io_unihdr("hdr_logon_script", &(usr->hdr_logon_script), ps, depth); /* logon script unicode string header */
2129         smb_io_unihdr("hdr_profile_path", &(usr->hdr_profile_path), ps, depth); /* profile path unicode string header */
2130         smb_io_unihdr("hdr_acct_desc   ", &(usr->hdr_acct_desc  ) , ps, depth); /* account description */
2131         smb_io_unihdr("hdr_workstations", &(usr->hdr_workstations), ps, depth); /* workstations user can log on from */
2132         smb_io_unihdr("hdr_unknown_str ", &(usr->hdr_unknown_str ), ps, depth); /* unknown string */
2133         smb_io_unihdr("hdr_munged_dial ", &(usr->hdr_munged_dial ), ps, depth); /* workstations user can log on from */
2134
2135         prs_uint8s (False, "lm_pwd        ", ps, depth, usr->lm_pwd   , sizeof(usr->lm_pwd   ));
2136         prs_uint8s (False, "nt_pwd        ", ps, depth, usr->nt_pwd   , sizeof(usr->nt_pwd   ));
2137
2138         prs_uint32("user_rid      ", ps, depth, &(usr->user_rid     ));       /* User ID */
2139         prs_uint32("group_rid     ", ps, depth, &(usr->group_rid    ));      /* Group ID */
2140         prs_uint16("acb_info      ", ps, depth, &(usr->acb_info     ));      /* Group ID */
2141         prs_align(ps);
2142
2143         prs_uint32("unknown_3     ", ps, depth, &(usr->unknown_3    ));
2144         prs_uint16("logon_divs    ", ps, depth, &(usr->logon_divs   ));     /* logon divisions per week */
2145         prs_align(ps);
2146         prs_uint32("ptr_logon_hrs ", ps, depth, &(usr->ptr_logon_hrs));
2147         prs_uint32("unknown_5     ", ps, depth, &(usr->unknown_5    ));
2148
2149         prs_uint8s (False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1));
2150
2151         /* here begins pointed-to data */
2152
2153         smb_io_unistr2("uni_user_name   ", &(usr->uni_user_name)   , usr->hdr_user_name   .buffer, ps, depth); /* username unicode string */
2154         smb_io_unistr2("uni_full_name   ", &(usr->uni_full_name)   , usr->hdr_full_name   .buffer, ps, depth); /* user's full name unicode string */
2155         smb_io_unistr2("uni_home_dir    ", &(usr->uni_home_dir)    , usr->hdr_home_dir    .buffer, ps, depth); /* home directory unicode string */
2156         smb_io_unistr2("uni_dir_drive   ", &(usr->uni_dir_drive)   , usr->hdr_dir_drive   .buffer, ps, depth); /* home directory drive unicode string */
2157         smb_io_unistr2("uni_logon_script", &(usr->uni_logon_script), usr->hdr_logon_script.buffer, ps, depth); /* logon script unicode string */
2158         smb_io_unistr2("uni_profile_path", &(usr->uni_profile_path), usr->hdr_profile_path.buffer, ps, depth); /* profile path unicode string */
2159         smb_io_unistr2("uni_acct_desc   ", &(usr->uni_acct_desc   ), usr->hdr_acct_desc   .buffer, ps, depth); /* user description unicode string */
2160         smb_io_unistr2("uni_workstations", &(usr->uni_workstations), usr->hdr_workstations.buffer, ps, depth); /* worksations user can log on from */
2161         smb_io_unistr2("uni_unknown_str ", &(usr->uni_unknown_str ), usr->hdr_unknown_str .buffer, ps, depth); /* unknown string */
2162         smb_io_unistr2("uni_munged_dial ", &(usr->uni_munged_dial ), usr->hdr_munged_dial .buffer, ps, depth); /* worksations user can log on from */
2163
2164         prs_uint32("unknown_6     ", ps, depth, &(usr->unknown_6  ));
2165         prs_uint32("padding4      ", ps, depth, &(usr->padding4   ));
2166
2167         if (usr->ptr_logon_hrs)
2168         {
2169                 sam_io_logon_hrs("logon_hrs", &(usr->logon_hrs)   , ps, depth);
2170                 prs_align(ps);
2171         }
2172 }
2173
2174
2175 /*******************************************************************
2176 makes a SAMR_R_QUERY_USERINFO structure.
2177 ********************************************************************/
2178 void make_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO *r_u,
2179                                 uint16 switch_value, void *info, uint32 status)
2180
2181 {
2182         if (r_u == NULL || info == NULL) return;
2183
2184         DEBUG(5,("make_samr_r_query_userinfo\n"));
2185
2186         r_u->ptr = 0;
2187         r_u->switch_value = 0;
2188
2189         if (status == 0)
2190         {
2191                 r_u->switch_value = switch_value;
2192
2193                 switch (switch_value)
2194                 {
2195                         case 0x10:
2196                         {
2197                                 r_u->ptr = 1;
2198                                 r_u->info.id10 = (SAM_USER_INFO_10*)info;
2199
2200                                 break;
2201                         }
2202
2203                         case 0x11:
2204                         {
2205                                 r_u->ptr = 1;
2206                                 r_u->info.id11 = (SAM_USER_INFO_11*)info;
2207
2208                                 break;
2209                         }
2210
2211                         case 21:
2212                         {
2213                                 r_u->ptr = 1;
2214                                 r_u->info.id21 = (SAM_USER_INFO_21*)info;
2215
2216                                 break;
2217                         }
2218
2219                         default:
2220                         {
2221                                 DEBUG(4,("make_samr_r_query_aliasinfo: unsupported switch level\n"));
2222                                 break;
2223                         }
2224                 }
2225         }
2226
2227         r_u->status = status;         /* return status */
2228 }
2229
2230 /*******************************************************************
2231 reads or writes a structure.
2232 ********************************************************************/
2233 void samr_io_r_query_userinfo(char *desc,  SAMR_R_QUERY_USERINFO *r_u, prs_struct *ps, int depth)
2234 {
2235         if (r_u == NULL) return;
2236
2237         prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
2238         depth++;
2239
2240         prs_align(ps);
2241
2242         prs_uint32("ptr         ", ps, depth, &(r_u->ptr         ));
2243         prs_uint16("switch_value", ps, depth, &(r_u->switch_value));
2244         prs_align(ps);
2245
2246         if (r_u->ptr != 0 && r_u->switch_value != 0)
2247         {
2248                 switch (r_u->switch_value)
2249                 {
2250 /*
2251                         case 0x10:
2252                         {
2253                                 if (r_u->info.id10 != NULL)
2254                                 {
2255                                         sam_io_user_info10("", r_u->info.id10, ps, depth);
2256                                 }
2257                                 else
2258                                 {
2259                                         DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
2260                                         return NULL;
2261                                 }
2262                                 break;
2263                         }
2264                         case 0x11:
2265                         {
2266                                 if (r_u->info.id11 != NULL)
2267                                 {
2268                                         sam_io_user_info11("", r_u->info.id11, ps, depth);
2269                                 }
2270                                 else
2271                                 {
2272                                         DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
2273                                         return NULL;
2274                                 }
2275                                 break;
2276                         }
2277 */
2278                         case 21:
2279                         {
2280                                 if (r_u->info.id21 != NULL)
2281                                 {
2282                                         sam_io_user_info21("", r_u->info.id21, ps, depth);
2283                                 }
2284                                 else
2285                                 {
2286                                         DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
2287                                         return;
2288                                 }
2289                                 break;
2290                         }
2291                         default:
2292                         {
2293                                 DEBUG(2,("samr_io_r_query_userinfo: unknown switch level\n"));
2294                                 break;
2295                         }
2296
2297                 }
2298         }
2299
2300         prs_uint32("status", ps, depth, &(r_u->status));
2301 }
2302
2303 /*******************************************************************
2304 reads or writes a structure.
2305 ********************************************************************/
2306 void samr_io_q_unknown_32(char *desc,  SAMR_Q_UNKNOWN_32 *q_u, prs_struct *ps, int depth)
2307 {
2308         if (q_u == NULL) return;
2309
2310         prs_debug(ps, depth, desc, "samr_io_q_unknown_32");
2311         depth++;
2312
2313         prs_align(ps);
2314
2315         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
2316         prs_align(ps);
2317
2318         smb_io_unihdr ("", &(q_u->hdr_mach_acct), ps, depth);
2319         smb_io_unistr2("", &(q_u->uni_mach_acct), q_u->hdr_mach_acct.buffer, ps, depth);
2320
2321         prs_align(ps);
2322
2323         prs_uint32("acct_ctrl", ps, depth, &(q_u->acct_ctrl));
2324         prs_uint16("unknown_1", ps, depth, &(q_u->unknown_1));
2325         prs_uint16("unknown_2", ps, depth, &(q_u->unknown_2));
2326 }
2327
2328 /*******************************************************************
2329 reads or writes a structure.
2330 ********************************************************************/
2331 void samr_io_r_unknown_32(char *desc,  SAMR_R_UNKNOWN_32 *r_u, prs_struct *ps, int depth)
2332 {
2333         if (r_u == NULL) return;
2334
2335         prs_debug(ps, depth, desc, "samr_io_r_unknown_32");
2336         depth++;
2337
2338         prs_align(ps);
2339
2340         smb_io_pol_hnd("pol", &(r_u->pol), ps, depth);
2341         prs_align(ps);
2342
2343         prs_uint32("status", ps, depth, &(r_u->status));
2344 }
2345
2346
2347 /*******************************************************************
2348 makes a SAMR_Q_CONNECT structure.
2349 ********************************************************************/
2350 void make_samr_q_connect(SAMR_Q_CONNECT *q_u,
2351                                 char *srv_name, uint32 unknown_0)
2352 {
2353         int len_srv_name = strlen(srv_name);
2354
2355         if (q_u == NULL) return;
2356
2357         DEBUG(5,("make_q_connect\n"));
2358
2359         /* make PDC server name \\server */
2360         make_unistr2(&(q_u->uni_srv_name), srv_name, len_srv_name);
2361
2362         /* example values: 0x0000 0002 */
2363         q_u->unknown_0 = unknown_0;
2364 }
2365
2366
2367 /*******************************************************************
2368 reads or writes a structure.
2369 ********************************************************************/
2370 void samr_io_q_connect(char *desc,  SAMR_Q_CONNECT *q_u, prs_struct *ps, int depth)
2371 {
2372         if (q_u == NULL) return;
2373
2374         prs_debug(ps, depth, desc, "samr_io_q_connect");
2375         depth++;
2376
2377         prs_align(ps);
2378
2379         prs_uint32("ptr_srv_name", ps, depth, &(q_u->ptr_srv_name));
2380         smb_io_unistr2("", &(q_u->uni_srv_name), q_u->ptr_srv_name, ps, depth);
2381
2382         prs_align(ps);
2383
2384         prs_uint32("unknown_0   ", ps, depth, &(q_u->unknown_0   ));
2385 }
2386
2387 /*******************************************************************
2388 reads or writes a structure.
2389 ********************************************************************/
2390 void samr_io_r_connect(char *desc,  SAMR_R_CONNECT *r_u, prs_struct *ps, int depth)
2391 {
2392         if (r_u == NULL) return;
2393
2394         prs_debug(ps, depth, desc, "samr_io_r_connect");
2395         depth++;
2396
2397         prs_align(ps);
2398
2399         smb_io_pol_hnd("connect_pol", &(r_u->connect_pol), ps, depth);
2400         prs_align(ps);
2401
2402         prs_uint32("status", ps, depth, &(r_u->status));
2403 }
2404
2405 /*******************************************************************
2406 makes a SAMR_Q_CONNECT_ANON structure.
2407 ********************************************************************/
2408 void make_samr_q_connect_anon(SAMR_Q_CONNECT_ANON *q_u)
2409 {
2410         if (q_u == NULL) return;
2411
2412         DEBUG(5,("make_q_connect_anon\n"));
2413
2414         q_u->ptr       = 1;
2415         q_u->unknown_0 = 0x5c;
2416         q_u->unknown_1 = 0x01;
2417         q_u->unknown_2 = 0x20;
2418 }
2419
2420
2421 /*******************************************************************
2422 reads or writes a structure.
2423 ********************************************************************/
2424 void samr_io_q_connect_anon(char *desc,  SAMR_Q_CONNECT_ANON *q_u, prs_struct *ps, int depth)
2425 {
2426         if (q_u == NULL) return;
2427
2428         prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
2429         depth++;
2430
2431         prs_align(ps);
2432
2433         prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
2434         prs_uint16("unknown_0", ps, depth, &(q_u->unknown_0));
2435         prs_uint16("unknown_1", ps, depth, &(q_u->unknown_1));
2436         prs_uint32("unknown_2", ps, depth, &(q_u->unknown_2));
2437 }
2438
2439 /*******************************************************************
2440 reads or writes a structure.
2441 ********************************************************************/
2442 void samr_io_r_connect_anon(char *desc,  SAMR_R_CONNECT_ANON *r_u, prs_struct *ps, int depth)
2443 {
2444         if (r_u == NULL) return;
2445
2446         prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
2447         depth++;
2448
2449         prs_align(ps);
2450
2451         smb_io_pol_hnd("connect_pol", &(r_u->connect_pol), ps, depth);
2452         prs_align(ps);
2453
2454         prs_uint32("status", ps, depth, &(r_u->status));
2455 }
2456
2457 /*******************************************************************
2458 makes a SAMR_Q_OPEN_ALIAS structure.
2459 ********************************************************************/
2460 void make_samr_q_open_alias(SAMR_Q_OPEN_ALIAS *q_u,
2461                                 uint32 unknown_0, uint32 rid)
2462 {
2463         if (q_u == NULL) return;
2464
2465         DEBUG(5,("make_q_open_alias\n"));
2466
2467         /* example values: 0x0000 0008 */
2468         q_u->unknown_0 = unknown_0;
2469
2470         q_u->rid_alias = rid;
2471 }
2472
2473 /*******************************************************************
2474 reads or writes a structure.
2475 ********************************************************************/
2476 void samr_io_q_open_alias(char *desc,  SAMR_Q_OPEN_ALIAS *q_u, prs_struct *ps, int depth)
2477 {
2478         if (q_u == NULL) return;
2479
2480         prs_debug(ps, depth, desc, "samr_io_q_open_alias");
2481         depth++;
2482
2483         prs_align(ps);
2484
2485         prs_uint32("unknown_0", ps, depth, &(q_u->unknown_0));
2486         prs_uint32("rid_alias", ps, depth, &(q_u->rid_alias));
2487 }
2488
2489 /*******************************************************************
2490 reads or writes a structure.
2491 ********************************************************************/
2492 void samr_io_r_open_alias(char *desc,  SAMR_R_OPEN_ALIAS *r_u, prs_struct *ps, int depth)
2493 {
2494         if (r_u == NULL) return;
2495
2496         prs_debug(ps, depth, desc, "samr_io_r_open_alias");
2497         depth++;
2498
2499         prs_align(ps);
2500
2501         smb_io_pol_hnd("pol", &(r_u->pol), ps, depth);
2502         prs_align(ps);
2503
2504         prs_uint32("status", ps, depth, &(r_u->status));
2505 }
2506
2507 /*******************************************************************
2508 makes a SAMR_Q_UNKNOWN_12 structure.
2509 ********************************************************************/
2510 void make_samr_q_unknown_12(SAMR_Q_UNKNOWN_12 *q_u,
2511                 POLICY_HND *pol, uint32 rid,
2512                 uint32 num_gids, uint32 *gid)
2513 {
2514         int i;
2515         if (q_u == NULL) return;
2516
2517         DEBUG(5,("make_samr_r_unknwon_12\n"));
2518
2519         memcpy(&(q_u->pol), pol, sizeof(*pol));
2520
2521         q_u->num_gids1 = num_gids;
2522         q_u->rid       = rid;
2523         q_u->ptr       = 0;
2524         q_u->num_gids2 = num_gids;
2525
2526         for (i = 0; i < num_gids; i++)
2527         {
2528                 q_u->gid[i] = gid[i];
2529         }
2530 }
2531
2532
2533
2534
2535 /*******************************************************************
2536 makes a SAMR_Q_UNKNOWN_21 structure.
2537 ********************************************************************/
2538 void make_samr_q_unknown_21(SAMR_Q_UNKNOWN_21 *q_c,
2539                                 POLICY_HND *hnd, uint16 unk_1, uint16 unk_2)
2540 {
2541         if (q_c == NULL || hnd == NULL) return;
2542
2543         DEBUG(5,("make_samr_q_unknown_21\n"));
2544
2545         memcpy(&(q_c->group_pol), hnd, sizeof(q_c->group_pol));
2546         q_c->unknown_1 = unk_1;
2547         q_c->unknown_2 = unk_2;
2548 }
2549
2550
2551 /*******************************************************************
2552 makes a SAMR_Q_UNKNOWN_13 structure.
2553 ********************************************************************/
2554 void make_samr_q_unknown_13(SAMR_Q_UNKNOWN_13 *q_c,
2555                                 POLICY_HND *hnd, uint16 unk_1, uint16 unk_2)
2556 {
2557         if (q_c == NULL || hnd == NULL) return;
2558
2559         DEBUG(5,("make_samr_q_unknown_13\n"));
2560
2561         memcpy(&(q_c->alias_pol), hnd, sizeof(q_c->alias_pol));
2562         q_c->unknown_1 = unk_1;
2563         q_c->unknown_2 = unk_2;
2564 }
2565
2566
2567 /*******************************************************************
2568 makes a SAMR_Q_UNKNOWN_38 structure.
2569 ********************************************************************/
2570 void make_samr_q_unknown_38(SAMR_Q_UNKNOWN_38 *q_u, char *srv_name)
2571 {
2572         int len_srv_name = strlen(srv_name);
2573
2574         if (q_u == NULL) return;
2575
2576         DEBUG(5,("make_q_unknown_38\n"));
2577
2578         q_u->ptr = 1;
2579         make_uni_hdr(&(q_u->hdr_srv_name), len_srv_name, len_srv_name, len_srv_name != 0);
2580         make_unistr2(&(q_u->uni_srv_name), srv_name, len_srv_name);
2581
2582 }
2583
2584 /*******************************************************************
2585 reads or writes a structure.
2586 ********************************************************************/
2587 void samr_io_q_unknown_38(char *desc,  SAMR_Q_UNKNOWN_38 *q_u, prs_struct *ps, int depth)
2588 {
2589         if (q_u == NULL) return;
2590
2591         prs_debug(ps, depth, desc, "samr_io_q_unknown_38");
2592         depth++;
2593
2594         prs_align(ps);
2595
2596         prs_uint32("ptr", ps, depth, &(q_u->ptr));
2597         if (q_u->ptr != 0)
2598         {
2599                 smb_io_unihdr ("", &(q_u->hdr_srv_name), ps, depth);
2600                 smb_io_unistr2("", &(q_u->uni_srv_name), q_u->hdr_srv_name.buffer, ps, depth);
2601         }
2602 }
2603
2604 /*******************************************************************
2605 makes a SAMR_R_UNKNOWN_38 structure.
2606 ********************************************************************/
2607 void make_samr_r_unknown_38(SAMR_R_UNKNOWN_38 *r_u)
2608 {
2609         if (r_u == NULL) return;
2610
2611         DEBUG(5,("make_r_unknown_38\n"));
2612
2613         r_u->unk_0 = 0;
2614         r_u->unk_1 = 0;
2615         r_u->unk_2 = 0;
2616         r_u->unk_3 = 0;
2617 }
2618
2619 /*******************************************************************
2620 reads or writes a structure.
2621 ********************************************************************/
2622 void samr_io_r_unknown_38(char *desc,  SAMR_R_UNKNOWN_38 *r_u, prs_struct *ps, int depth)
2623 {
2624         if (r_u == NULL) return;
2625
2626         prs_debug(ps, depth, desc, "samr_io_r_unknown_38");
2627         depth++;
2628
2629         prs_align(ps);
2630
2631         prs_uint16("unk_0", ps, depth, &(r_u->unk_0));
2632         prs_align(ps);
2633         prs_uint16("unk_1", ps, depth, &(r_u->unk_1));
2634         prs_align(ps);
2635         prs_uint16("unk_2", ps, depth, &(r_u->unk_2));
2636         prs_align(ps);
2637         prs_uint16("unk_3", ps, depth, &(r_u->unk_3));
2638         prs_align(ps);
2639 }
2640
2641 /*******************************************************************
2642 make a SAMR_ENC_PASSWD structure.
2643 ********************************************************************/
2644 void make_enc_passwd(SAMR_ENC_PASSWD *pwd, char pass[512])
2645 {
2646         if (pwd == NULL) return;
2647
2648         pwd->ptr = 1;
2649         memcpy(&(pwd->pass), pass, sizeof(pwd->pass));
2650 }
2651
2652 /*******************************************************************
2653 reads or writes a SAMR_ENC_PASSWD structure.
2654 ********************************************************************/
2655 void samr_io_enc_passwd(char *desc, SAMR_ENC_PASSWD *pwd, prs_struct *ps, int depth)
2656 {
2657         if (pwd == NULL) return;
2658
2659         prs_debug(ps, depth, desc, "samr_io_enc_passwd");
2660         depth++;
2661
2662         prs_align(ps);
2663
2664         prs_uint32("ptr", ps, depth, &(pwd->ptr));
2665         prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass));
2666 }
2667
2668 /*******************************************************************
2669 makes a SAMR_ENC_HASH structure.
2670 ********************************************************************/
2671 void make_enc_hash(SAMR_ENC_HASH *hsh, char hash[16])
2672 {
2673         if (hsh == NULL) return;
2674
2675         hsh->ptr = 1;
2676         memcpy(&(hsh->hash), hash, sizeof(hsh->hash));
2677 }
2678
2679 /*******************************************************************
2680 reads or writes a SAMR_ENC_HASH structure.
2681 ********************************************************************/
2682 void samr_io_enc_hash(char *desc, SAMR_ENC_HASH *hsh, prs_struct *ps, int depth)
2683 {
2684         if (hsh == NULL) return;
2685
2686         prs_debug(ps, depth, desc, "samr_io_enc_hash");
2687         depth++;
2688
2689         prs_align(ps);
2690
2691         prs_uint32("ptr ", ps, depth, &(hsh->ptr));
2692         prs_uint8s(False, "hash", ps, depth, hsh->hash, sizeof(hsh->hash));
2693 }
2694
2695 /*******************************************************************
2696 makes a SAMR_R_UNKNOWN_38 structure.
2697 ********************************************************************/
2698 void make_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER *q_u,
2699                                 char *dest_host, char *user_name,
2700                                 char nt_newpass[516], char nt_oldhash[16],
2701                                 char lm_newpass[516], char lm_oldhash[16])
2702 {
2703         int len_dest_host = strlen(dest_host);
2704         int len_user_name = strlen(user_name);
2705
2706         if (q_u == NULL) return;
2707
2708         DEBUG(5,("make_samr_q_chgpasswd_user\n"));
2709
2710         q_u->ptr_0 = 1;
2711         make_uni_hdr(&(q_u->hdr_dest_host), len_dest_host, len_dest_host, len_dest_host != 0);
2712         make_unistr2(&(q_u->uni_dest_host), dest_host, len_dest_host);
2713         make_uni_hdr(&(q_u->hdr_user_name), len_user_name, len_user_name, len_user_name != 0);
2714         make_unistr2(&(q_u->uni_user_name), user_name, len_user_name);
2715
2716         make_enc_passwd(&(q_u->nt_newpass), nt_newpass);
2717         make_enc_hash  (&(q_u->nt_oldhash), nt_oldhash);
2718
2719         q_u->unknown = 0x01;
2720
2721         make_enc_passwd(&(q_u->lm_newpass), lm_newpass);
2722         make_enc_hash  (&(q_u->lm_oldhash), lm_oldhash);
2723 };
2724
2725 /*******************************************************************
2726 reads or writes a structure.
2727 ********************************************************************/
2728 void samr_io_q_chgpasswd_user(char *desc, SAMR_Q_CHGPASSWD_USER *q_u, prs_struct *ps, int depth)
2729 {
2730         if (q_u == NULL) return;
2731
2732         prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
2733         depth++;
2734
2735         prs_align(ps);
2736
2737         prs_uint32("ptr_0", ps, depth, &(q_u->ptr_0));
2738
2739         smb_io_unihdr ("", &(q_u->hdr_dest_host), ps, depth);
2740         smb_io_unistr2("", &(q_u->uni_dest_host), q_u->hdr_dest_host.buffer, ps, depth);
2741         smb_io_unihdr ("", &(q_u->hdr_user_name), ps, depth);
2742         smb_io_unistr2("", &(q_u->uni_user_name), q_u->hdr_user_name.buffer, ps, depth);
2743
2744         samr_io_enc_passwd("nt_newpass", &(q_u->nt_newpass), ps, depth);
2745         samr_io_enc_hash  ("nt_oldhash", &(q_u->nt_oldhash), ps, depth);
2746
2747         prs_uint32("unknown", ps, depth, &(q_u->unknown));
2748
2749         samr_io_enc_passwd("lm_newpass", &(q_u->lm_newpass), ps, depth);
2750         samr_io_enc_hash  ("lm_oldhash", &(q_u->lm_oldhash), ps, depth);
2751 }
2752
2753 /*******************************************************************
2754 reads or writes a structure.
2755 ********************************************************************/
2756 void samr_io_r_chgpasswd_user(char *desc, SAMR_R_CHGPASSWD_USER *r_u, prs_struct *ps, int depth)
2757 {
2758         if (r_u == NULL) return;
2759
2760         prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
2761         depth++;
2762
2763         prs_align(ps);
2764
2765         prs_uint32("status", ps, depth, &(r_u->status));
2766 }
2767
2768