source/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                 prs_grow(ps);
1003                 sam_io_sam_entry2("", &(sam->sam[i]), ps, depth);
1004         }
1005
1006         for (i = 0; i < sam->num_entries; i++)
1007         {
1008                 prs_grow(ps);
1009                 sam_io_sam_str2 ("", &(sam->str[i]),
1010                                                          sam->sam[i].hdr_srv_name.buffer,
1011                                                          sam->sam[i].hdr_srv_desc.buffer,
1012                                                          ps, depth);
1013         }
1014 }
1015
1016
1017 /*******************************************************************
1018 makes a SAM_INFO_1 structure.
1019 ********************************************************************/
1020 void make_sam_info_1(SAM_INFO_1 *sam, uint32 acb_mask,
1021                 uint32 start_idx, uint32 num_sam_entries,
1022                 SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
1023 {
1024         int i;
1025         int entries_added;
1026
1027         if (sam == NULL) return;
1028
1029         DEBUG(5,("make_sam_info_1\n"));
1030
1031         if (num_sam_entries >= MAX_SAM_ENTRIES)
1032         {
1033                 num_sam_entries = MAX_SAM_ENTRIES;
1034                 DEBUG(5,("limiting number of entries to %d\n",
1035                          num_sam_entries));
1036         }
1037
1038         for (i = start_idx, entries_added = 0; i < num_sam_entries; i++)
1039         {
1040                 if (IS_BITS_SET_ALL(pass[i].acb_info, acb_mask))
1041                 {
1042                         make_sam_entry1(&(sam->sam[entries_added]),
1043                                                 start_idx + entries_added + 1,
1044                                                 pass[i].uni_user_name.uni_str_len,
1045                                                 pass[i].uni_full_name.uni_str_len,
1046                                                 pass[i].uni_acct_desc.uni_str_len,
1047                                                 pass[i].user_rid,
1048                                                 pass[i].acb_info);
1049
1050                         copy_unistr2(&(sam->str[entries_added].uni_acct_name), &(pass[i].uni_user_name));
1051                         copy_unistr2(&(sam->str[entries_added].uni_full_name), &(pass[i].uni_full_name));
1052                         copy_unistr2(&(sam->str[entries_added].uni_acct_desc), &(pass[i].uni_acct_desc));
1053
1054                         entries_added++;
1055                 }
1056         }
1057
1058         sam->num_entries   = entries_added;
1059         sam->ptr_entries   = 1;
1060         sam->num_entries2  = entries_added;
1061 }
1062
1063
1064 /*******************************************************************
1065 reads or writes a structure.
1066 ********************************************************************/
1067 static void sam_io_sam_info_1(char *desc,  SAM_INFO_1 *sam, prs_struct *ps, int depth)
1068 {
1069         int i;
1070
1071         if (sam == NULL) return;
1072
1073         prs_debug(ps, depth, desc, "sam_io_sam_info_1");
1074         depth++;
1075
1076         prs_align(ps);
1077
1078         prs_uint32("num_entries  ", ps, depth, &(sam->num_entries  ));
1079         prs_uint32("ptr_entries  ", ps, depth, &(sam->ptr_entries  ));
1080
1081         prs_uint32("num_entries2 ", ps, depth, &(sam->num_entries2 ));
1082
1083         SMB_ASSERT_ARRAY(sam->sam, sam->num_entries);
1084
1085         for (i = 0; i < sam->num_entries; i++)
1086         {
1087                 prs_grow(ps);
1088                 sam_io_sam_entry1("", &(sam->sam[i]), ps, depth);
1089         }
1090
1091         for (i = 0; i < sam->num_entries; i++)
1092         {
1093                 prs_grow(ps);
1094                 sam_io_sam_str1 ("", &(sam->str[i]),
1095                                                          sam->sam[i].hdr_acct_name.buffer,
1096                                                          sam->sam[i].hdr_user_name.buffer,
1097                                                          sam->sam[i].hdr_user_desc.buffer,
1098                                                          ps, depth);
1099         }
1100 }
1101
1102
1103 /*******************************************************************
1104 makes a SAMR_R_QUERY_DISPINFO structure.
1105 ********************************************************************/
1106 void make_samr_r_query_dispinfo(SAMR_R_QUERY_DISPINFO *r_u,
1107                 uint16 switch_level, SAM_INFO_CTR *ctr, uint32 status)
1108 {
1109         if (r_u == NULL) return;
1110
1111         DEBUG(5,("make_samr_r_query_dispinfo\n"));
1112
1113         if (status == 0x0)
1114         {
1115                 r_u->unknown_0 = 0x0000001;
1116                 r_u->unknown_1 = 0x0000001;
1117         }
1118         else
1119         {
1120                 r_u->unknown_0 = 0x0;
1121                 r_u->unknown_1 = 0x0;
1122         }
1123
1124         r_u->switch_level = switch_level;
1125         r_u->ctr = ctr;
1126         r_u->status = status;
1127 }
1128
1129
1130 /*******************************************************************
1131 reads or writes a structure.
1132 ********************************************************************/
1133 void samr_io_r_query_dispinfo(char *desc,  SAMR_R_QUERY_DISPINFO *r_u, prs_struct *ps, int depth)
1134 {
1135         if (r_u == NULL) return;
1136
1137         prs_debug(ps, depth, desc, "samr_io_r_query_dispinfo");
1138         depth++;
1139
1140         prs_align(ps);
1141
1142         prs_uint32("unknown_0    ", ps, depth, &(r_u->unknown_0    ));
1143         prs_uint32("unknown_1    ", ps, depth, &(r_u->unknown_1    ));
1144         prs_uint16("switch_level ", ps, depth, &(r_u->switch_level ));
1145
1146         prs_align(ps);
1147
1148         switch (r_u->switch_level)
1149         {
1150                 case 0x1:
1151                 {
1152                         sam_io_sam_info_1("users", r_u->ctr->sam.info1, ps, depth);
1153                         break;
1154                 }
1155                 case 0x2:
1156                 {
1157                         sam_io_sam_info_2("servers", r_u->ctr->sam.info2, ps, depth);
1158                         break;
1159                 }
1160                 default:
1161                 {
1162                         DEBUG(5,("samr_io_r_query_dispinfo: unknown switch value\n"));
1163                         break;
1164                 }
1165         }
1166
1167         prs_uint32("status", ps, depth, &(r_u->status));
1168 }
1169
1170
1171 /*******************************************************************
1172 makes a SAMR_Q_ENUM_DOM_GROUPS structure.
1173 ********************************************************************/
1174 void make_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS *q_e, POLICY_HND *pol,
1175                                 uint16 switch_level, uint32 start_idx, uint32 size)
1176 {
1177         if (q_e == NULL || pol == NULL) return;
1178
1179         DEBUG(5,("make_q_enum_dom_groups\n"));
1180
1181         memcpy(&(q_e->pol), pol, sizeof(*pol));
1182
1183         q_e->switch_level = switch_level;
1184
1185         q_e->unknown_0 = 0;
1186         q_e->start_idx = start_idx;
1187         q_e->unknown_1 = 0x000007d0;
1188         q_e->max_size  = size;
1189 }
1190
1191
1192 /*******************************************************************
1193 reads or writes a structure.
1194 ********************************************************************/
1195 void samr_io_q_enum_dom_groups(char *desc,  SAMR_Q_ENUM_DOM_GROUPS *q_e, prs_struct *ps, int depth)
1196 {
1197         if (q_e == NULL) return;
1198
1199         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_groups");
1200         depth++;
1201
1202         prs_align(ps);
1203
1204         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
1205         prs_align(ps);
1206
1207         prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
1208         prs_uint16("unknown_0   ", ps, depth, &(q_e->unknown_0   ));
1209         prs_uint32("start_idx   ", ps, depth, &(q_e->start_idx   ));
1210         prs_uint32("unknown_1   ", ps, depth, &(q_e->unknown_1   ));
1211         prs_uint32("max_size    ", ps, depth, &(q_e->max_size    ));
1212
1213         prs_align(ps);
1214 }
1215
1216
1217 /*******************************************************************
1218 makes a SAMR_R_ENUM_DOM_GROUPS structure.
1219 ********************************************************************/
1220 void make_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS *r_u,
1221                 uint32 start_idx, uint32 num_sam_entries,
1222                 SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES],
1223                 uint32 status)
1224 {
1225         int i;
1226         int entries_added;
1227
1228         if (r_u == NULL) return;
1229
1230         DEBUG(5,("make_samr_r_enum_dom_groups\n"));
1231
1232         if (num_sam_entries >= MAX_SAM_ENTRIES)
1233         {
1234                 num_sam_entries = MAX_SAM_ENTRIES;
1235                 DEBUG(5,("limiting number of entries to %d\n",
1236                          num_sam_entries));
1237         }
1238
1239         if (status == 0x0)
1240         {
1241                 for (i = start_idx, entries_added = 0; i < num_sam_entries; i++)
1242                 {
1243                         make_sam_entry3(&(r_u->sam[entries_added]),
1244                                         start_idx + entries_added + 1,
1245                                         pass[i].uni_user_name.uni_str_len,
1246                                         pass[i].uni_acct_desc.uni_str_len,
1247                                         pass[i].user_rid);
1248
1249                         copy_unistr2(&(r_u->str[entries_added].uni_grp_name), &(pass[i].uni_user_name));
1250                         copy_unistr2(&(r_u->str[entries_added].uni_grp_desc), &(pass[i].uni_acct_desc));
1251
1252                         entries_added++;
1253                 }
1254
1255                 if (entries_added > 0)
1256                 {
1257                         r_u->unknown_0 = 0x0000492;
1258                         r_u->unknown_1 = 0x000049a;
1259                 }
1260                 else
1261                 {
1262                         r_u->unknown_0 = 0x0;
1263                         r_u->unknown_1 = 0x0;
1264                 }
1265                 r_u->switch_level  = 3;
1266                 r_u->num_entries   = entries_added;
1267                 r_u->ptr_entries   = 1;
1268                 r_u->num_entries2  = entries_added;
1269         }
1270         else
1271         {
1272                 r_u->switch_level = 0;
1273         }
1274
1275         r_u->status = status;
1276 }
1277
1278 /*******************************************************************
1279 reads or writes a structure.
1280 ********************************************************************/
1281 void samr_io_r_enum_dom_groups(char *desc,  SAMR_R_ENUM_DOM_GROUPS *r_u, prs_struct *ps, int depth)
1282 {
1283         int i;
1284
1285         if (r_u == NULL) return;
1286
1287         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_groups");
1288         depth++;
1289
1290         prs_align(ps);
1291
1292         prs_uint32("unknown_0    ", ps, depth, &(r_u->unknown_0    ));
1293         prs_uint32("unknown_1    ", ps, depth, &(r_u->unknown_1    ));
1294         prs_uint32("switch_level ", ps, depth, &(r_u->switch_level ));
1295
1296         if (r_u->switch_level != 0)
1297         {
1298                 prs_uint32("num_entries  ", ps, depth, &(r_u->num_entries  ));
1299                 prs_uint32("ptr_entries  ", ps, depth, &(r_u->ptr_entries  ));
1300
1301                 prs_uint32("num_entries2 ", ps, depth, &(r_u->num_entries2 ));
1302
1303                 SMB_ASSERT_ARRAY(r_u->sam, r_u->num_entries);
1304
1305                 for (i = 0; i < r_u->num_entries; i++)
1306                 {
1307                         prs_grow(ps);
1308                         sam_io_sam_entry3("", &(r_u->sam[i]), ps, depth);
1309                 }
1310
1311                 for (i = 0; i < r_u->num_entries; i++)
1312                 {
1313                         prs_grow(ps);
1314                         sam_io_sam_str3 ("", &(r_u->str[i]),
1315                                              r_u->sam[i].hdr_grp_name.buffer,
1316                                              r_u->sam[i].hdr_grp_desc.buffer,
1317                                              ps, depth);
1318                 }
1319         }
1320
1321         prs_uint32("status", ps, depth, &(r_u->status));
1322 }
1323
1324
1325 /*******************************************************************
1326 makes a SAMR_Q_QUERY_ALIASINFO structure.
1327 ********************************************************************/
1328 void make_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO *q_e,
1329                                 POLICY_HND *pol,
1330                                 uint16 switch_level)
1331 {
1332         if (q_e == NULL || pol == NULL) return;
1333
1334         DEBUG(5,("make_q_query_aliasinfo\n"));
1335
1336         memcpy(&(q_e->pol), pol, sizeof(*pol));
1337
1338         q_e->switch_level = switch_level;
1339 }
1340
1341
1342 /*******************************************************************
1343 reads or writes a structure.
1344 ********************************************************************/
1345 void samr_io_q_query_aliasinfo(char *desc,  SAMR_Q_QUERY_ALIASINFO *q_e, prs_struct *ps, int depth)
1346 {
1347         if (q_e == NULL) return;
1348
1349         prs_debug(ps, depth, desc, "samr_io_q_query_aliasinfo");
1350         depth++;
1351
1352         prs_align(ps);
1353
1354         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
1355         prs_align(ps);
1356
1357         prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
1358 }
1359
1360
1361 /*******************************************************************
1362 makes a SAMR_R_QUERY_ALIASINFO structure.
1363 ********************************************************************/
1364 void make_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *r_u,
1365                 uint16 switch_value, char *acct_desc,
1366                 uint32 status)
1367 {
1368         if (r_u == NULL) return;
1369
1370         DEBUG(5,("make_samr_r_query_aliasinfo\n"));
1371
1372         r_u->ptr = 0;
1373
1374         if (status == 0)
1375         {
1376                 r_u->switch_value = switch_value;
1377
1378                 switch (switch_value)
1379                 {
1380                         case 3:
1381                         {
1382                                 int acct_len = acct_desc ? strlen(acct_desc) : 0;
1383
1384                                 r_u->ptr = 1;
1385
1386                                 make_uni_hdr(&(r_u->alias.info3.hdr_acct_desc), acct_len , acct_len, acct_desc ? 1 : 0);
1387                                 make_unistr2(&(r_u->alias.info3.uni_acct_desc), acct_desc, acct_len);
1388
1389                                 break;
1390                         }
1391
1392                         default:
1393                         {
1394                                 DEBUG(4,("make_samr_r_query_aliasinfo: unsupported switch level\n"));
1395                                 break;
1396                         }
1397                 }
1398         }
1399
1400         r_u->status = status;
1401 }
1402
1403
1404 /*******************************************************************
1405 reads or writes a structure.
1406 ********************************************************************/
1407 void samr_io_r_query_aliasinfo(char *desc,  SAMR_R_QUERY_ALIASINFO *r_u, prs_struct *ps, int depth)
1408 {
1409         if (r_u == NULL) return;
1410
1411         prs_debug(ps, depth, desc, "samr_io_r_query_aliasinfo");
1412         depth++;
1413
1414         prs_align(ps);
1415
1416         prs_uint32("ptr         ", ps, depth, &(r_u->ptr         ));
1417
1418         if (r_u->ptr != 0)
1419         {
1420                 prs_uint16("switch_value", ps, depth, &(r_u->switch_value));
1421                 prs_align(ps);
1422
1423                 if (r_u->switch_value != 0)
1424                 {
1425                         switch (r_u->switch_value)
1426                         {
1427                                 case 3:
1428                                 {
1429                                         smb_io_unihdr ("", &(r_u->alias.info3.hdr_acct_desc), ps, depth);
1430                                         smb_io_unistr2("", &(r_u->alias.info3.uni_acct_desc), r_u->alias.info3.hdr_acct_desc.buffer, ps, depth);
1431                                         break;
1432                                 }
1433                                 default:
1434                                 {
1435                                         DEBUG(4,("samr_io_r_query_aliasinfo: unsupported switch level\n"));
1436                                         break;
1437                                 }
1438                         }
1439                 }
1440         }
1441
1442         prs_align(ps);
1443
1444         prs_uint32("status", ps, depth, &(r_u->status));
1445 }
1446
1447 /*******************************************************************
1448 reads or writes a SAMR_Q_LOOKUP_IDS structure.
1449 ********************************************************************/
1450 void samr_io_q_lookup_ids(char *desc,  SAMR_Q_LOOKUP_IDS *q_u, prs_struct *ps, int depth)
1451 {
1452         fstring tmp;
1453         int i;
1454
1455         if (q_u == NULL) return;
1456
1457         prs_debug(ps, depth, desc, "samr_io_q_lookup_ids");
1458         depth++;
1459
1460         prs_align(ps);
1461
1462         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1463         prs_align(ps);
1464
1465         prs_uint32("num_sids1", ps, depth, &(q_u->num_sids1));
1466         prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
1467         prs_uint32("num_sids2", ps, depth, &(q_u->num_sids2));
1468
1469         SMB_ASSERT_ARRAY(q_u->ptr_sid, q_u->num_sids2);
1470
1471         for (i = 0; i < q_u->num_sids2; i++)
1472         {
1473                 slprintf(tmp, sizeof(tmp) - 1, "ptr[%02d]", i);
1474                 prs_uint32(tmp, ps, depth, &(q_u->ptr_sid[i]));
1475         }
1476
1477         for (i = 0; i < q_u->num_sids2; i++)
1478         {
1479                 if (q_u->ptr_sid[i] != 0)
1480                 {
1481                         prs_grow(ps);
1482                         slprintf(tmp, sizeof(tmp)-1, "sid[%02d]", i);
1483                         smb_io_dom_sid2(tmp, &(q_u->sid[i]), ps, depth);
1484                 }
1485         }
1486
1487         prs_align(ps);
1488 }
1489
1490
1491 /*******************************************************************
1492 makes a SAMR_R_LOOKUP_IDS structure.
1493 ********************************************************************/
1494 void make_samr_r_lookup_ids(SAMR_R_LOOKUP_IDS *r_u,
1495                 uint32 num_rids, uint32 *rid, uint32 status)
1496 {
1497         int i;
1498         if (r_u == NULL) return;
1499
1500         DEBUG(5,("make_samr_r_lookup_ids\n"));
1501
1502         if (status == 0x0)
1503         {
1504                 r_u->num_entries  = num_rids;
1505                 r_u->ptr = 1;
1506                 r_u->num_entries2 = num_rids;
1507
1508                 SMB_ASSERT_ARRAY(r_u->rid, num_rids);
1509
1510                 for (i = 0; i < num_rids; i++)
1511                 {
1512                         r_u->rid[i] = rid[i];
1513                 }
1514         }
1515         else
1516         {
1517                 r_u->num_entries  = 0;
1518                 r_u->ptr = 0;
1519                 r_u->num_entries2 = 0;
1520         }
1521
1522         r_u->status = status;
1523 }
1524
1525 /*******************************************************************
1526 reads or writes a structure.
1527 ********************************************************************/
1528 void samr_io_r_lookup_ids(char *desc,  SAMR_R_LOOKUP_IDS *r_u, prs_struct *ps, int depth)
1529 {
1530         fstring tmp;
1531         int i;
1532         if (r_u == NULL) return;
1533
1534         prs_debug(ps, depth, desc, "samr_io_r_lookup_ids");
1535         depth++;
1536
1537         prs_align(ps);
1538
1539         prs_uint32("num_entries", ps, depth, &(r_u->num_entries));
1540         prs_uint32("ptr        ", ps, depth, &(r_u->ptr        ));
1541         prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
1542
1543         if (r_u->num_entries != 0)
1544         {
1545                 SMB_ASSERT_ARRAY(r_u->rid, r_u->num_entries2);
1546
1547                 for (i = 0; i < r_u->num_entries2; i++)
1548                 {
1549                         slprintf(tmp, sizeof(tmp)-1, "rid[%02d]", i);
1550                         prs_uint32(tmp, ps, depth, &(r_u->rid[i]));
1551                 }
1552         }
1553
1554         prs_uint32("status", ps, depth, &(r_u->status));
1555 }
1556
1557 /*******************************************************************
1558 reads or writes a structure.
1559 ********************************************************************/
1560 void samr_io_q_lookup_names(char *desc,  SAMR_Q_LOOKUP_NAMES *q_u, prs_struct *ps, int depth)
1561 {
1562         int i;
1563
1564         if (q_u == NULL) return;
1565
1566         prs_debug(ps, depth, desc, "samr_io_q_lookup_names");
1567         depth++;
1568
1569         prs_align(ps);
1570
1571         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1572         prs_align(ps);
1573
1574         prs_uint32("num_rids1", ps, depth, &(q_u->num_rids1));
1575         prs_uint32("rid      ", ps, depth, &(q_u->rid      ));
1576         prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
1577         prs_uint32("num_rids2", ps, depth, &(q_u->num_rids2));
1578
1579         SMB_ASSERT_ARRAY(q_u->hdr_user_name, q_u->num_rids2);
1580
1581         for (i = 0; i < q_u->num_rids2; i++)
1582         {
1583                 prs_grow(ps);
1584                 smb_io_unihdr ("", &(q_u->hdr_user_name[i]), ps, depth);
1585         }
1586         for (i = 0; i < q_u->num_rids2; i++)
1587         {
1588                 prs_grow(ps);
1589                 smb_io_unistr2("", &(q_u->uni_user_name[i]), q_u->hdr_user_name[i].buffer, ps, depth);
1590         }
1591
1592         prs_align(ps);
1593 }
1594
1595
1596 /*******************************************************************
1597 makes a SAMR_R_LOOKUP_NAMES structure.
1598 ********************************************************************/
1599 void make_samr_r_lookup_names(SAMR_R_LOOKUP_NAMES *r_u,
1600                 uint32 num_rids, uint32 *rid, uint32 status)
1601 {
1602         int i;
1603         if (r_u == NULL) return;
1604
1605         DEBUG(5,("make_samr_r_lookup_names\n"));
1606
1607         if (status == 0x0)
1608         {
1609                 r_u->num_entries  = num_rids;
1610                 r_u->undoc_buffer = 1;
1611                 r_u->num_entries2 = num_rids;
1612
1613                 SMB_ASSERT_ARRAY(r_u->dom_rid, num_rids);
1614
1615                 for (i = 0; i < num_rids; i++)
1616                 {
1617                         make_dom_rid3(&(r_u->dom_rid[i]), rid[i]);
1618                 }
1619
1620                 r_u->num_entries3 = num_rids;
1621         }
1622         else
1623         {
1624                 r_u->num_entries  = 0;
1625                 r_u->undoc_buffer = 0;
1626                 r_u->num_entries2 = 0;
1627                 r_u->num_entries3 = 0;
1628         }
1629
1630         r_u->status = status;
1631 }
1632
1633 /*******************************************************************
1634 reads or writes a structure.
1635 ********************************************************************/
1636 void samr_io_r_lookup_names(char *desc,  SAMR_R_LOOKUP_NAMES *r_u, prs_struct *ps, int depth)
1637 {
1638         int i;
1639         if (r_u == NULL) return;
1640
1641         prs_debug(ps, depth, desc, "samr_io_r_lookup_names");
1642         depth++;
1643
1644         prs_align(ps);
1645
1646         prs_uint32("num_entries ", ps, depth, &(r_u->num_entries ));
1647         prs_uint32("undoc_buffer", ps, depth, &(r_u->undoc_buffer));
1648         prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
1649
1650         if (r_u->num_entries != 0)
1651         {
1652                 SMB_ASSERT_ARRAY(r_u->dom_rid, r_u->num_entries2);
1653
1654                 for (i = 0; i < r_u->num_entries2; i++)
1655                 {
1656                         prs_grow(ps);
1657                         smb_io_dom_rid3("", &(r_u->dom_rid[i]), ps, depth);
1658                 }
1659
1660         }
1661
1662         prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
1663
1664         prs_uint32("status", ps, depth, &(r_u->status));
1665 }
1666
1667 /*******************************************************************
1668 reads or writes a structure.
1669 ********************************************************************/
1670 void samr_io_q_unknown_12(char *desc,  SAMR_Q_UNKNOWN_12 *q_u, prs_struct *ps, int depth)
1671 {
1672         int i;
1673         fstring tmp;
1674
1675         if (q_u == NULL) return;
1676
1677         prs_debug(ps, depth, desc, "samr_io_q_unknown_12");
1678         depth++;
1679
1680         prs_align(ps);
1681
1682         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1683         prs_align(ps);
1684
1685         prs_uint32("num_gids1", ps, depth, &(q_u->num_gids1));
1686         prs_uint32("rid      ", ps, depth, &(q_u->rid      ));
1687         prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
1688         prs_uint32("num_gids2", ps, depth, &(q_u->num_gids2));
1689
1690         SMB_ASSERT_ARRAY(q_u->gid, q_u->num_gids2);
1691
1692         for (i = 0; i < q_u->num_gids2; i++)
1693         {
1694                 prs_grow(ps);
1695                 slprintf(tmp, sizeof(tmp) - 1, "gid[%02d]  ", i);
1696                 prs_uint32(tmp, ps, depth, &(q_u->gid[i]));
1697         }
1698
1699         prs_align(ps);
1700 }
1701
1702
1703 /*******************************************************************
1704 makes a SAMR_R_UNKNOWN_12 structure.
1705 ********************************************************************/
1706 void make_samr_r_unknown_12(SAMR_R_UNKNOWN_12 *r_u,
1707                 uint32 num_aliases, fstring *als_name, uint32 *num_als_usrs,
1708                 uint32 status)
1709 {
1710         int i;
1711         if (r_u == NULL || als_name == NULL || num_als_usrs == NULL) return;
1712
1713         DEBUG(5,("make_samr_r_unknown_12\n"));
1714
1715         if (status == 0x0)
1716         {
1717                 r_u->num_aliases1 = num_aliases;
1718                 r_u->ptr_aliases  = 1;
1719                 r_u->num_aliases2 = num_aliases;
1720
1721                 r_u->num_als_usrs1 = num_aliases;
1722                 r_u->ptr_als_usrs  = 1;
1723                 r_u->num_als_usrs2 = num_aliases;
1724
1725                 SMB_ASSERT_ARRAY(r_u->hdr_als_name, num_aliases);
1726
1727                 for (i = 0; i < num_aliases; i++)
1728                 {
1729                         int als_len = als_name[i] != NULL ? strlen(als_name[i]) : 0;
1730                         make_uni_hdr(&(r_u->hdr_als_name[i]), als_len    , als_len, als_name[i] ? 1 : 0);
1731                         make_unistr2(&(r_u->uni_als_name[i]), als_name[i], als_len);
1732                         r_u->num_als_usrs[i] = num_als_usrs[i];
1733                 }
1734         }
1735         else
1736         {
1737                 r_u->num_aliases1 = num_aliases;
1738                 r_u->ptr_aliases  = 0;
1739                 r_u->num_aliases2 = num_aliases;
1740
1741                 r_u->num_als_usrs1 = num_aliases;
1742                 r_u->ptr_als_usrs  = 0;
1743                 r_u->num_als_usrs2 = num_aliases;
1744         }
1745
1746         r_u->status = status;
1747 }
1748
1749 /*******************************************************************
1750 reads or writes a structure.
1751 ********************************************************************/
1752 void samr_io_r_unknown_12(char *desc,  SAMR_R_UNKNOWN_12 *r_u, prs_struct *ps, int depth)
1753 {
1754         int i;
1755         fstring tmp;
1756         if (r_u == NULL) return;
1757
1758         prs_debug(ps, depth, desc, "samr_io_r_unknown_12");
1759         depth++;
1760
1761         prs_align(ps);
1762
1763         prs_uint32("num_aliases1", ps, depth, &(r_u->num_aliases1));
1764         prs_uint32("ptr_aliases ", ps, depth, &(r_u->ptr_aliases ));
1765         prs_uint32("num_aliases2", ps, depth, &(r_u->num_aliases2));
1766
1767         if (r_u->ptr_aliases != 0 && r_u->num_aliases1 != 0)
1768         {
1769                 SMB_ASSERT_ARRAY(r_u->hdr_als_name, r_u->num_aliases2);
1770
1771                 for (i = 0; i < r_u->num_aliases2; i++)
1772                 {
1773                         prs_grow(ps);
1774                         slprintf(tmp, sizeof(tmp) - 1, "als_hdr[%02d]  ", i);
1775                         smb_io_unihdr ("", &(r_u->hdr_als_name[i]), ps, depth);
1776                 }
1777                 for (i = 0; i < r_u->num_aliases2; i++)
1778                 {
1779                         prs_grow(ps);
1780                         slprintf(tmp, sizeof(tmp) - 1, "als_str[%02d]  ", i);
1781                         smb_io_unistr2("", &(r_u->uni_als_name[i]), r_u->hdr_als_name[i].buffer, ps, depth);
1782                 }
1783         }
1784
1785         prs_align(ps);
1786
1787         prs_uint32("num_als_usrs1", ps, depth, &(r_u->num_als_usrs1));
1788         prs_uint32("ptr_als_usrs ", ps, depth, &(r_u->ptr_als_usrs ));
1789         prs_uint32("num_als_usrs2", ps, depth, &(r_u->num_als_usrs2));
1790
1791         if (r_u->ptr_als_usrs != 0 && r_u->num_als_usrs1 != 0)
1792         {
1793                 SMB_ASSERT_ARRAY(r_u->num_als_usrs, r_u->num_als_usrs2);
1794
1795                 for (i = 0; i < r_u->num_als_usrs2; i++)
1796                 {
1797                         prs_grow(ps);
1798                         slprintf(tmp, sizeof(tmp) - 1, "als_usrs[%02d]  ", i);
1799                         prs_uint32(tmp, ps, depth, &(r_u->num_als_usrs[i]));
1800                 }
1801         }
1802
1803         prs_uint32("status", ps, depth, &(r_u->status));
1804 }
1805
1806
1807 /*******************************************************************
1808 reads or writes a structure.
1809 ********************************************************************/
1810 void make_samr_q_open_user(SAMR_Q_OPEN_USER *q_u,
1811                                 POLICY_HND *pol,
1812                                 uint32 unk_0, uint32 rid)
1813 {
1814         if (q_u == NULL) return;
1815
1816         DEBUG(5,("samr_make_q_open_user\n"));
1817
1818         memcpy(&q_u->domain_pol, pol, sizeof(q_u->domain_pol));
1819
1820         q_u->unknown_0 = unk_0;
1821         q_u->user_rid  = rid;
1822 }
1823
1824 /*******************************************************************
1825 reads or writes a structure.
1826 ********************************************************************/
1827 void samr_io_q_open_user(char *desc,  SAMR_Q_OPEN_USER *q_u, prs_struct *ps, int depth)
1828 {
1829         if (q_u == NULL) return;
1830
1831         prs_debug(ps, depth, desc, "samr_io_q_open_user");
1832         depth++;
1833
1834         prs_align(ps);
1835
1836         smb_io_pol_hnd("domain_pol", &(q_u->domain_pol), ps, depth);
1837         prs_align(ps);
1838
1839         prs_uint32("unknown_0", ps, depth, &(q_u->unknown_0));
1840         prs_uint32("user_rid ", ps, depth, &(q_u->user_rid ));
1841
1842         prs_align(ps);
1843 }
1844
1845 /*******************************************************************
1846 reads or writes a structure.
1847 ********************************************************************/
1848 void samr_io_r_open_user(char *desc,  SAMR_R_OPEN_USER *r_u, prs_struct *ps, int depth)
1849 {
1850         if (r_u == NULL) return;
1851
1852         prs_debug(ps, depth, desc, "samr_io_r_open_user");
1853         depth++;
1854
1855         prs_align(ps);
1856
1857         smb_io_pol_hnd("user_pol", &(r_u->user_pol), ps, depth);
1858         prs_align(ps);
1859
1860         prs_uint32("status", ps, depth, &(r_u->status));
1861 }
1862
1863 /*******************************************************************
1864 makes a SAMR_Q_QUERY_USERGROUPS structure.
1865 ********************************************************************/
1866 void make_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS *q_u,
1867                                 POLICY_HND *hnd)
1868 {
1869         if (q_u == NULL || hnd == NULL) return;
1870
1871         DEBUG(5,("make_samr_q_query_usergroups\n"));
1872
1873         memcpy(&(q_u->pol), hnd, sizeof(q_u->pol));
1874 }
1875
1876
1877 /*******************************************************************
1878 reads or writes a structure.
1879 ********************************************************************/
1880 void samr_io_q_query_usergroups(char *desc,  SAMR_Q_QUERY_USERGROUPS *q_u, prs_struct *ps, int depth)
1881 {
1882         if (q_u == NULL) return;
1883
1884         prs_debug(ps, depth, desc, "samr_io_q_query_usergroups");
1885         depth++;
1886
1887         prs_align(ps);
1888
1889         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1890         prs_align(ps);
1891 }
1892
1893 /*******************************************************************
1894 makes a SAMR_R_QUERY_USERGROUPS structure.
1895 ********************************************************************/
1896 void make_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS *r_u,
1897                 uint32 num_gids, DOM_GID *gid, uint32 status)
1898 {
1899         if (r_u == NULL) return;
1900
1901         DEBUG(5,("make_samr_r_query_usergroups\n"));
1902
1903         if (status == 0x0)
1904         {
1905                 r_u->ptr_0        = 1;
1906                 r_u->num_entries  = num_gids;
1907                 r_u->ptr_1        = 1;
1908                 r_u->num_entries2 = num_gids;
1909
1910                 r_u->gid = gid;
1911         }
1912         else
1913         {
1914                 r_u->ptr_0       = 0;
1915                 r_u->num_entries = 0;
1916                 r_u->ptr_1       = 0;
1917         }
1918
1919         r_u->status = status;
1920 }
1921
1922 /*******************************************************************
1923 reads or writes a structure.
1924 ********************************************************************/
1925 void samr_io_r_query_usergroups(char *desc,  SAMR_R_QUERY_USERGROUPS *r_u, prs_struct *ps, int depth)
1926 {
1927         int i;
1928         if (r_u == NULL) return;
1929
1930         prs_debug(ps, depth, desc, "samr_io_r_query_usergroups");
1931         depth++;
1932
1933         prs_align(ps);
1934
1935         prs_uint32("ptr_0       ", ps, depth, &(r_u->ptr_0      ));
1936
1937         if (r_u->ptr_0 != 0)
1938         {
1939                 prs_uint32("num_entries ", ps, depth, &(r_u->num_entries));
1940                 prs_uint32("ptr_1       ", ps, depth, &(r_u->ptr_1      ));
1941
1942                 if (r_u->num_entries != 0)
1943                 {
1944                         prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
1945
1946                         for (i = 0; i < r_u->num_entries2; i++)
1947                         {
1948                                 prs_grow(ps);
1949                                 smb_io_gid("", &(r_u->gid[i]), ps, depth);
1950                         }
1951                 }
1952         }
1953         prs_uint32("status", ps, depth, &(r_u->status));
1954 }
1955
1956 /*******************************************************************
1957 makes a SAMR_Q_QUERY_USERINFO structure.
1958 ********************************************************************/
1959 void make_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO *q_u,
1960                                 POLICY_HND *hnd, uint16 switch_value)
1961 {
1962         if (q_u == NULL || hnd == NULL) return;
1963
1964         DEBUG(5,("make_samr_q_query_userinfo\n"));
1965
1966         memcpy(&(q_u->pol), hnd, sizeof(q_u->pol));
1967         q_u->switch_value = switch_value;
1968 }
1969
1970
1971 /*******************************************************************
1972 reads or writes a structure.
1973 ********************************************************************/
1974 void samr_io_q_query_userinfo(char *desc,  SAMR_Q_QUERY_USERINFO *q_u, prs_struct *ps, int depth)
1975 {
1976         if (q_u == NULL) return;
1977
1978         prs_debug(ps, depth, desc, "samr_io_q_query_userinfo");
1979         depth++;
1980
1981         prs_align(ps);
1982
1983         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
1984         prs_align(ps);
1985
1986         prs_uint16("switch_value", ps, depth, &(q_u->switch_value)); /* 0x0015 or 0x0011 */
1987
1988         prs_align(ps);
1989 }
1990
1991 /*******************************************************************
1992 reads or writes a LOGON_HRS structure.
1993 ********************************************************************/
1994 static void sam_io_logon_hrs(char *desc,  LOGON_HRS *hrs, prs_struct *ps, int depth)
1995 {
1996         if (hrs == NULL) return;
1997
1998         prs_debug(ps, depth, desc, "sam_io_logon_hrs");
1999         depth++;
2000
2001         prs_align(ps);
2002
2003         prs_uint32 (       "len  ", ps, depth, &(hrs->len ));
2004
2005         if (hrs->len > 64)
2006         {
2007                 DEBUG(5,("sam_io_logon_hrs: truncating length\n"));
2008                 hrs->len = 64;
2009         }
2010
2011         prs_uint8s (False, "hours", ps, depth, hrs->hours, hrs->len);
2012 }
2013
2014 /*************************************************************************
2015  make_sam_user_info21
2016
2017  unknown_3 = 0x00ff ffff
2018  unknown_5 = 0x0002 0000
2019  unknown_6 = 0x0000 04ec
2020
2021  *************************************************************************/
2022 void make_sam_user_info21(SAM_USER_INFO_21 *usr,
2023
2024         NTTIME *logon_time,
2025         NTTIME *logoff_time,
2026         NTTIME *kickoff_time,
2027         NTTIME *pass_last_set_time,
2028         NTTIME *pass_can_change_time,
2029         NTTIME *pass_must_change_time,
2030
2031         char *user_name,
2032         char *full_name,
2033         char *home_dir,
2034         char *dir_drive,
2035         char *logon_script,
2036         char *profile_path,
2037         char *description,
2038         char *workstations,
2039         char *unknown_str,
2040         char *munged_dial,
2041
2042         uint32 user_rid,
2043         uint32 group_rid,
2044         uint16 acb_info,
2045
2046         uint32 unknown_3,
2047         uint16 logon_divs,
2048         LOGON_HRS *hrs,
2049         uint32 unknown_5,
2050         uint32 unknown_6)
2051 {
2052         int len_user_name    = user_name    != NULL ? strlen(user_name   ) : 0;
2053         int len_full_name    = full_name    != NULL ? strlen(full_name   ) : 0;
2054         int len_home_dir     = home_dir     != NULL ? strlen(home_dir    ) : 0;
2055         int len_dir_drive    = dir_drive    != NULL ? strlen(dir_drive   ) : 0;
2056         int len_logon_script = logon_script != NULL ? strlen(logon_script) : 0;
2057         int len_profile_path = profile_path != NULL ? strlen(profile_path) : 0;
2058         int len_description  = description  != NULL ? strlen(description ) : 0;
2059         int len_workstations = workstations != NULL ? strlen(workstations) : 0;
2060         int len_unknown_str  = unknown_str  != NULL ? strlen(unknown_str ) : 0;
2061         int len_munged_dial  = munged_dial  != NULL ? strlen(munged_dial ) : 0;
2062
2063         usr->logon_time            = *logon_time;
2064         usr->logoff_time           = *logoff_time;
2065         usr->kickoff_time          = *kickoff_time;
2066         usr->pass_last_set_time    = *pass_last_set_time;
2067         usr->pass_can_change_time  = *pass_can_change_time;
2068         usr->pass_must_change_time = *pass_must_change_time;
2069
2070         make_uni_hdr(&(usr->hdr_user_name   ), len_user_name   , len_user_name   , len_user_name    != 0);
2071         make_uni_hdr(&(usr->hdr_full_name   ), len_full_name   , len_full_name   , len_full_name    != 0);
2072         make_uni_hdr(&(usr->hdr_home_dir    ), len_home_dir    , len_home_dir    , len_home_dir     != 0);
2073         make_uni_hdr(&(usr->hdr_dir_drive   ), len_dir_drive   , len_dir_drive   , len_dir_drive    != 0);
2074         make_uni_hdr(&(usr->hdr_logon_script), len_logon_script, len_logon_script, len_logon_script != 0);
2075         make_uni_hdr(&(usr->hdr_profile_path), len_profile_path, len_profile_path, len_profile_path != 0);
2076         make_uni_hdr(&(usr->hdr_acct_desc   ), len_description , len_description , len_description  != 0);
2077         make_uni_hdr(&(usr->hdr_workstations), len_workstations, len_workstations, len_workstations != 0);
2078         make_uni_hdr(&(usr->hdr_unknown_str ), len_unknown_str , len_unknown_str , len_workstations != 0);
2079         make_uni_hdr(&(usr->hdr_munged_dial ), len_munged_dial , len_munged_dial , len_workstations != 0);
2080
2081         bzero(usr->nt_pwd, sizeof(usr->nt_pwd));
2082         bzero(usr->lm_pwd, sizeof(usr->lm_pwd));
2083
2084         usr->user_rid  = user_rid;
2085         usr->group_rid = group_rid;
2086         usr->acb_info = acb_info;
2087         usr->unknown_3 = unknown_3; /* 0x00ff ffff */
2088
2089         usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
2090         usr->ptr_logon_hrs = hrs ? 1 : 0;
2091         usr->unknown_5 = unknown_5; /* 0x0002 0000 */
2092
2093         bzero(usr->padding1, sizeof(usr->padding1));
2094
2095         make_unistr2(&(usr->uni_user_name   ), user_name   , len_user_name   );
2096         make_unistr2(&(usr->uni_full_name   ), full_name   , len_full_name   );
2097         make_unistr2(&(usr->uni_home_dir    ), home_dir    , len_home_dir    );
2098         make_unistr2(&(usr->uni_dir_drive   ), dir_drive   , len_dir_drive   );
2099         make_unistr2(&(usr->uni_logon_script), logon_script, len_logon_script);
2100         make_unistr2(&(usr->uni_profile_path), profile_path, len_profile_path);
2101         make_unistr2(&(usr->uni_acct_desc ), description , len_description );
2102         make_unistr2(&(usr->uni_workstations), workstations, len_workstations);
2103         make_unistr2(&(usr->uni_unknown_str ), unknown_str , len_unknown_str );
2104         make_unistr2(&(usr->uni_munged_dial ), munged_dial , len_munged_dial );
2105
2106         usr->unknown_6 = unknown_6; /* 0x0000 04ec */
2107         usr->padding4 = 0;
2108
2109         if (hrs)
2110         {
2111                 memcpy(&(usr->logon_hrs), hrs, sizeof(usr->logon_hrs));
2112         }
2113         else
2114         {
2115                 memset(&(usr->logon_hrs), 0xff, sizeof(usr->logon_hrs));
2116         }
2117 }
2118
2119
2120 /*******************************************************************
2121 reads or writes a structure.
2122 ********************************************************************/
2123 static void sam_io_user_info21(char *desc,  SAM_USER_INFO_21 *usr, prs_struct *ps, int depth)
2124 {
2125         if (usr == NULL) return;
2126
2127         prs_debug(ps, depth, desc, "lsa_io_user_info");
2128         depth++;
2129
2130         prs_align(ps);
2131
2132         smb_io_time("logon_time           ", &(usr->logon_time)           , ps, depth);
2133         smb_io_time("logoff_time          ", &(usr->logoff_time)          , ps, depth);
2134         smb_io_time("kickoff_time         ", &(usr->kickoff_time)         , ps, depth);
2135         smb_io_time("pass_last_set_time   ", &(usr->pass_last_set_time)   , ps, depth);
2136         smb_io_time("pass_can_change_time ", &(usr->pass_can_change_time) , ps, depth);
2137         smb_io_time("pass_must_change_time", &(usr->pass_must_change_time), ps, depth);
2138
2139         smb_io_unihdr("hdr_user_name   ", &(usr->hdr_user_name)   , ps, depth); /* username unicode string header */
2140         smb_io_unihdr("hdr_full_name   ", &(usr->hdr_full_name)   , ps, depth); /* user's full name unicode string header */
2141         smb_io_unihdr("hdr_home_dir    ", &(usr->hdr_home_dir)    , ps, depth); /* home directory unicode string header */
2142         smb_io_unihdr("hdr_dir_drive   ", &(usr->hdr_dir_drive)   , ps, depth); /* home directory drive */
2143         smb_io_unihdr("hdr_logon_script", &(usr->hdr_logon_script), ps, depth); /* logon script unicode string header */
2144         smb_io_unihdr("hdr_profile_path", &(usr->hdr_profile_path), ps, depth); /* profile path unicode string header */
2145         smb_io_unihdr("hdr_acct_desc   ", &(usr->hdr_acct_desc  ) , ps, depth); /* account description */
2146         smb_io_unihdr("hdr_workstations", &(usr->hdr_workstations), ps, depth); /* workstations user can log on from */
2147         smb_io_unihdr("hdr_unknown_str ", &(usr->hdr_unknown_str ), ps, depth); /* unknown string */
2148         smb_io_unihdr("hdr_munged_dial ", &(usr->hdr_munged_dial ), ps, depth); /* workstations user can log on from */
2149
2150         prs_uint8s (False, "lm_pwd        ", ps, depth, usr->lm_pwd   , sizeof(usr->lm_pwd   ));
2151         prs_uint8s (False, "nt_pwd        ", ps, depth, usr->nt_pwd   , sizeof(usr->nt_pwd   ));
2152
2153         prs_uint32("user_rid      ", ps, depth, &(usr->user_rid     ));       /* User ID */
2154         prs_uint32("group_rid     ", ps, depth, &(usr->group_rid    ));      /* Group ID */
2155         prs_uint16("acb_info      ", ps, depth, &(usr->acb_info     ));      /* Group ID */
2156         prs_align(ps);
2157
2158         prs_uint32("unknown_3     ", ps, depth, &(usr->unknown_3    ));
2159         prs_uint16("logon_divs    ", ps, depth, &(usr->logon_divs   ));     /* logon divisions per week */
2160         prs_align(ps);
2161         prs_uint32("ptr_logon_hrs ", ps, depth, &(usr->ptr_logon_hrs));
2162         prs_uint32("unknown_5     ", ps, depth, &(usr->unknown_5    ));
2163
2164         prs_uint8s (False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1));
2165
2166         /* here begins pointed-to data */
2167
2168         smb_io_unistr2("uni_user_name   ", &(usr->uni_user_name)   , usr->hdr_user_name   .buffer, ps, depth); /* username unicode string */
2169         smb_io_unistr2("uni_full_name   ", &(usr->uni_full_name)   , usr->hdr_full_name   .buffer, ps, depth); /* user's full name unicode string */
2170         smb_io_unistr2("uni_home_dir    ", &(usr->uni_home_dir)    , usr->hdr_home_dir    .buffer, ps, depth); /* home directory unicode string */
2171         smb_io_unistr2("uni_dir_drive   ", &(usr->uni_dir_drive)   , usr->hdr_dir_drive   .buffer, ps, depth); /* home directory drive unicode string */
2172         smb_io_unistr2("uni_logon_script", &(usr->uni_logon_script), usr->hdr_logon_script.buffer, ps, depth); /* logon script unicode string */
2173         smb_io_unistr2("uni_profile_path", &(usr->uni_profile_path), usr->hdr_profile_path.buffer, ps, depth); /* profile path unicode string */
2174         smb_io_unistr2("uni_acct_desc   ", &(usr->uni_acct_desc   ), usr->hdr_acct_desc   .buffer, ps, depth); /* user description unicode string */
2175         smb_io_unistr2("uni_workstations", &(usr->uni_workstations), usr->hdr_workstations.buffer, ps, depth); /* worksations user can log on from */
2176         smb_io_unistr2("uni_unknown_str ", &(usr->uni_unknown_str ), usr->hdr_unknown_str .buffer, ps, depth); /* unknown string */
2177         smb_io_unistr2("uni_munged_dial ", &(usr->uni_munged_dial ), usr->hdr_munged_dial .buffer, ps, depth); /* worksations user can log on from */
2178
2179         prs_uint32("unknown_6     ", ps, depth, &(usr->unknown_6  ));
2180         prs_uint32("padding4      ", ps, depth, &(usr->padding4   ));
2181
2182         if (usr->ptr_logon_hrs)
2183         {
2184                 sam_io_logon_hrs("logon_hrs", &(usr->logon_hrs)   , ps, depth);
2185                 prs_align(ps);
2186         }
2187 }
2188
2189
2190 /*******************************************************************
2191 makes a SAMR_R_QUERY_USERINFO structure.
2192 ********************************************************************/
2193 void make_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO *r_u,
2194                                 uint16 switch_value, void *info, uint32 status)
2195
2196 {
2197         if (r_u == NULL || info == NULL) return;
2198
2199         DEBUG(5,("make_samr_r_query_userinfo\n"));
2200
2201         r_u->ptr = 0;
2202         r_u->switch_value = 0;
2203
2204         if (status == 0)
2205         {
2206                 r_u->switch_value = switch_value;
2207
2208                 switch (switch_value)
2209                 {
2210                         case 0x10:
2211                         {
2212                                 r_u->ptr = 1;
2213                                 r_u->info.id10 = (SAM_USER_INFO_10*)info;
2214
2215                                 break;
2216                         }
2217
2218                         case 0x11:
2219                         {
2220                                 r_u->ptr = 1;
2221                                 r_u->info.id11 = (SAM_USER_INFO_11*)info;
2222
2223                                 break;
2224                         }
2225
2226                         case 21:
2227                         {
2228                                 r_u->ptr = 1;
2229                                 r_u->info.id21 = (SAM_USER_INFO_21*)info;
2230
2231                                 break;
2232                         }
2233
2234                         default:
2235                         {
2236                                 DEBUG(4,("make_samr_r_query_aliasinfo: unsupported switch level\n"));
2237                                 break;
2238                         }
2239                 }
2240         }
2241
2242         r_u->status = status;         /* return status */
2243 }
2244
2245 /*******************************************************************
2246 reads or writes a structure.
2247 ********************************************************************/
2248 void samr_io_r_query_userinfo(char *desc,  SAMR_R_QUERY_USERINFO *r_u, prs_struct *ps, int depth)
2249 {
2250         if (r_u == NULL) return;
2251
2252         prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
2253         depth++;
2254
2255         prs_align(ps);
2256
2257         prs_uint32("ptr         ", ps, depth, &(r_u->ptr         ));
2258         prs_uint16("switch_value", ps, depth, &(r_u->switch_value));
2259         prs_align(ps);
2260
2261         if (r_u->ptr != 0 && r_u->switch_value != 0)
2262         {
2263                 switch (r_u->switch_value)
2264                 {
2265 /*
2266                         case 0x10:
2267                         {
2268                                 if (r_u->info.id10 != NULL)
2269                                 {
2270                                         sam_io_user_info10("", r_u->info.id10, ps, depth);
2271                                 }
2272                                 else
2273                                 {
2274                                         DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
2275                                         return NULL;
2276                                 }
2277                                 break;
2278                         }
2279                         case 0x11:
2280                         {
2281                                 if (r_u->info.id11 != NULL)
2282                                 {
2283                                         sam_io_user_info11("", r_u->info.id11, ps, depth);
2284                                 }
2285                                 else
2286                                 {
2287                                         DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
2288                                         return NULL;
2289                                 }
2290                                 break;
2291                         }
2292 */
2293                         case 21:
2294                         {
2295                                 if (r_u->info.id21 != NULL)
2296                                 {
2297                                         sam_io_user_info21("", r_u->info.id21, ps, depth);
2298                                 }
2299                                 else
2300                                 {
2301                                         DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
2302                                         return;
2303                                 }
2304                                 break;
2305                         }
2306                         default:
2307                         {
2308                                 DEBUG(2,("samr_io_r_query_userinfo: unknown switch level\n"));
2309                                 break;
2310                         }
2311
2312                 }
2313         }
2314
2315         prs_uint32("status", ps, depth, &(r_u->status));
2316 }
2317
2318 /*******************************************************************
2319 reads or writes a structure.
2320 ********************************************************************/
2321 void samr_io_q_unknown_32(char *desc,  SAMR_Q_UNKNOWN_32 *q_u, prs_struct *ps, int depth)
2322 {
2323         if (q_u == NULL) return;
2324
2325         prs_debug(ps, depth, desc, "samr_io_q_unknown_32");
2326         depth++;
2327
2328         prs_align(ps);
2329
2330         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
2331         prs_align(ps);
2332
2333         smb_io_unihdr ("", &(q_u->hdr_mach_acct), ps, depth);
2334         smb_io_unistr2("", &(q_u->uni_mach_acct), q_u->hdr_mach_acct.buffer, ps, depth);
2335
2336         prs_align(ps);
2337
2338         prs_uint32("acct_ctrl", ps, depth, &(q_u->acct_ctrl));
2339         prs_uint16("unknown_1", ps, depth, &(q_u->unknown_1));
2340         prs_uint16("unknown_2", ps, depth, &(q_u->unknown_2));
2341 }
2342
2343 /*******************************************************************
2344 reads or writes a structure.
2345 ********************************************************************/
2346 void samr_io_r_unknown_32(char *desc,  SAMR_R_UNKNOWN_32 *r_u, prs_struct *ps, int depth)
2347 {
2348         if (r_u == NULL) return;
2349
2350         prs_debug(ps, depth, desc, "samr_io_r_unknown_32");
2351         depth++;
2352
2353         prs_align(ps);
2354
2355         smb_io_pol_hnd("pol", &(r_u->pol), ps, depth);
2356         prs_align(ps);
2357
2358         prs_uint32("status", ps, depth, &(r_u->status));
2359 }
2360
2361
2362 /*******************************************************************
2363 makes a SAMR_Q_CONNECT structure.
2364 ********************************************************************/
2365 void make_samr_q_connect(SAMR_Q_CONNECT *q_u,
2366                                 char *srv_name, uint32 unknown_0)
2367 {
2368         int len_srv_name = strlen(srv_name);
2369
2370         if (q_u == NULL) return;
2371
2372         DEBUG(5,("make_q_connect\n"));
2373
2374         /* make PDC server name \\server */
2375         q_u->ptr_srv_name = len_srv_name > 0 ? 1 : 0;
2376         make_unistr2(&(q_u->uni_srv_name), srv_name, len_srv_name);
2377
2378         /* example values: 0x0000 0002 */
2379         q_u->unknown_0 = unknown_0;
2380 }
2381
2382
2383 /*******************************************************************
2384 reads or writes a structure.
2385 ********************************************************************/
2386 void samr_io_q_connect(char *desc,  SAMR_Q_CONNECT *q_u, prs_struct *ps, int depth)
2387 {
2388         if (q_u == NULL) return;
2389
2390         prs_debug(ps, depth, desc, "samr_io_q_connect");
2391         depth++;
2392
2393         prs_align(ps);
2394
2395         prs_uint32("ptr_srv_name", ps, depth, &(q_u->ptr_srv_name));
2396         smb_io_unistr2("", &(q_u->uni_srv_name), q_u->ptr_srv_name, ps, depth);
2397
2398         prs_align(ps);
2399
2400         prs_uint32("unknown_0   ", ps, depth, &(q_u->unknown_0   ));
2401 }
2402
2403 /*******************************************************************
2404 reads or writes a structure.
2405 ********************************************************************/
2406 void samr_io_r_connect(char *desc,  SAMR_R_CONNECT *r_u, prs_struct *ps, int depth)
2407 {
2408         if (r_u == NULL) return;
2409
2410         prs_debug(ps, depth, desc, "samr_io_r_connect");
2411         depth++;
2412
2413         prs_align(ps);
2414
2415         smb_io_pol_hnd("connect_pol", &(r_u->connect_pol), ps, depth);
2416         prs_align(ps);
2417
2418         prs_uint32("status", ps, depth, &(r_u->status));
2419 }
2420
2421 /*******************************************************************
2422 makes a SAMR_Q_CONNECT_ANON structure.
2423 ********************************************************************/
2424 void make_samr_q_connect_anon(SAMR_Q_CONNECT_ANON *q_u)
2425 {
2426         if (q_u == NULL) return;
2427
2428         DEBUG(5,("make_q_connect_anon\n"));
2429
2430         q_u->ptr       = 1;
2431         q_u->unknown_0 = 0x5c; /* server name (?!!) */
2432         q_u->unknown_1 = 0x01;
2433         q_u->unknown_2 = 0x20;
2434 }
2435
2436
2437 /*******************************************************************
2438 reads or writes a structure.
2439 ********************************************************************/
2440 void samr_io_q_connect_anon(char *desc,  SAMR_Q_CONNECT_ANON *q_u, prs_struct *ps, int depth)
2441 {
2442         if (q_u == NULL) return;
2443
2444         prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
2445         depth++;
2446
2447         prs_align(ps);
2448
2449         prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
2450         prs_uint16("unknown_0", ps, depth, &(q_u->unknown_0));
2451         prs_uint16("unknown_1", ps, depth, &(q_u->unknown_1));
2452         prs_uint32("unknown_2", ps, depth, &(q_u->unknown_2));
2453 }
2454
2455 /*******************************************************************
2456 reads or writes a structure.
2457 ********************************************************************/
2458 void samr_io_r_connect_anon(char *desc,  SAMR_R_CONNECT_ANON *r_u, prs_struct *ps, int depth)
2459 {
2460         if (r_u == NULL) return;
2461
2462         prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
2463         depth++;
2464
2465         prs_align(ps);
2466
2467         smb_io_pol_hnd("connect_pol", &(r_u->connect_pol), ps, depth);
2468         prs_align(ps);
2469
2470         prs_uint32("status", ps, depth, &(r_u->status));
2471 }
2472
2473 /*******************************************************************
2474 makes a SAMR_Q_OPEN_ALIAS structure.
2475 ********************************************************************/
2476 void make_samr_q_open_alias(SAMR_Q_OPEN_ALIAS *q_u,
2477                                 uint32 unknown_0, uint32 rid)
2478 {
2479         if (q_u == NULL) return;
2480
2481         DEBUG(5,("make_q_open_alias\n"));
2482
2483         /* example values: 0x0000 0008 */
2484         q_u->unknown_0 = unknown_0;
2485
2486         q_u->rid_alias = rid;
2487 }
2488
2489 /*******************************************************************
2490 reads or writes a structure.
2491 ********************************************************************/
2492 void samr_io_q_open_alias(char *desc,  SAMR_Q_OPEN_ALIAS *q_u, prs_struct *ps, int depth)
2493 {
2494         if (q_u == NULL) return;
2495
2496         prs_debug(ps, depth, desc, "samr_io_q_open_alias");
2497         depth++;
2498
2499         prs_align(ps);
2500
2501         prs_uint32("unknown_0", ps, depth, &(q_u->unknown_0));
2502         prs_uint32("rid_alias", ps, depth, &(q_u->rid_alias));
2503 }
2504
2505 /*******************************************************************
2506 reads or writes a structure.
2507 ********************************************************************/
2508 void samr_io_r_open_alias(char *desc,  SAMR_R_OPEN_ALIAS *r_u, prs_struct *ps, int depth)
2509 {
2510         if (r_u == NULL) return;
2511
2512         prs_debug(ps, depth, desc, "samr_io_r_open_alias");
2513         depth++;
2514
2515         prs_align(ps);
2516
2517         smb_io_pol_hnd("pol", &(r_u->pol), ps, depth);
2518         prs_align(ps);
2519
2520         prs_uint32("status", ps, depth, &(r_u->status));
2521 }
2522
2523 /*******************************************************************
2524 makes a SAMR_Q_UNKNOWN_12 structure.
2525 ********************************************************************/
2526 void make_samr_q_unknown_12(SAMR_Q_UNKNOWN_12 *q_u,
2527                 POLICY_HND *pol, uint32 rid,
2528                 uint32 num_gids, uint32 *gid)
2529 {
2530         int i;
2531         if (q_u == NULL) return;
2532
2533         DEBUG(5,("make_samr_r_unknwon_12\n"));
2534
2535         memcpy(&(q_u->pol), pol, sizeof(*pol));
2536
2537         q_u->num_gids1 = num_gids;
2538         q_u->rid       = rid;
2539         q_u->ptr       = 0;
2540         q_u->num_gids2 = num_gids;
2541
2542         for (i = 0; i < num_gids; i++)
2543         {
2544                 q_u->gid[i] = gid[i];
2545         }
2546 }
2547
2548
2549 /*******************************************************************
2550 makes a SAMR_Q_UNKNOWN_21 structure.
2551 ********************************************************************/
2552 void make_samr_q_unknown_21(SAMR_Q_UNKNOWN_21 *q_c,
2553                                 POLICY_HND *hnd, uint16 unk_1, uint16 unk_2)
2554 {
2555         if (q_c == NULL || hnd == NULL) return;
2556
2557         DEBUG(5,("make_samr_q_unknown_21\n"));
2558
2559         memcpy(&(q_c->group_pol), hnd, sizeof(q_c->group_pol));
2560         q_c->unknown_1 = unk_1;
2561         q_c->unknown_2 = unk_2;
2562 }
2563
2564
2565 /*******************************************************************
2566 makes a SAMR_Q_UNKNOWN_13 structure.
2567 ********************************************************************/
2568 void make_samr_q_unknown_13(SAMR_Q_UNKNOWN_13 *q_c,
2569                                 POLICY_HND *hnd, uint16 unk_1, uint16 unk_2)
2570 {
2571         if (q_c == NULL || hnd == NULL) return;
2572
2573         DEBUG(5,("make_samr_q_unknown_13\n"));
2574
2575         memcpy(&(q_c->alias_pol), hnd, sizeof(q_c->alias_pol));
2576         q_c->unknown_1 = unk_1;
2577         q_c->unknown_2 = unk_2;
2578 }
2579
2580
2581 /*******************************************************************
2582 makes a SAMR_Q_UNKNOWN_38 structure.
2583 ********************************************************************/
2584 void make_samr_q_unknown_38(SAMR_Q_UNKNOWN_38 *q_u, char *srv_name)
2585 {
2586         int len_srv_name = strlen(srv_name);
2587
2588         if (q_u == NULL) return;
2589
2590         DEBUG(5,("make_q_unknown_38\n"));
2591
2592         q_u->ptr = 1;
2593         make_uni_hdr(&(q_u->hdr_srv_name), len_srv_name, len_srv_name, len_srv_name != 0);
2594         make_unistr2(&(q_u->uni_srv_name), srv_name, len_srv_name);
2595
2596 }
2597
2598 /*******************************************************************
2599 reads or writes a structure.
2600 ********************************************************************/
2601 void samr_io_q_unknown_38(char *desc,  SAMR_Q_UNKNOWN_38 *q_u, prs_struct *ps, int depth)
2602 {
2603         if (q_u == NULL) return;
2604
2605         prs_debug(ps, depth, desc, "samr_io_q_unknown_38");
2606         depth++;
2607
2608         prs_align(ps);
2609
2610         prs_uint32("ptr", ps, depth, &(q_u->ptr));
2611         if (q_u->ptr != 0)
2612         {
2613                 smb_io_unihdr ("", &(q_u->hdr_srv_name), ps, depth);
2614                 smb_io_unistr2("", &(q_u->uni_srv_name), q_u->hdr_srv_name.buffer, ps, depth);
2615         }
2616 }
2617
2618 /*******************************************************************
2619 makes a SAMR_R_UNKNOWN_38 structure.
2620 ********************************************************************/
2621 void make_samr_r_unknown_38(SAMR_R_UNKNOWN_38 *r_u)
2622 {
2623         if (r_u == NULL) return;
2624
2625         DEBUG(5,("make_r_unknown_38\n"));
2626
2627         r_u->unk_0 = 0;
2628         r_u->unk_1 = 0;
2629         r_u->unk_2 = 0;
2630         r_u->unk_3 = 0;
2631 }
2632
2633 /*******************************************************************
2634 reads or writes a structure.
2635 ********************************************************************/
2636 void samr_io_r_unknown_38(char *desc,  SAMR_R_UNKNOWN_38 *r_u, prs_struct *ps, int depth)
2637 {
2638         if (r_u == NULL) return;
2639
2640         prs_debug(ps, depth, desc, "samr_io_r_unknown_38");
2641         depth++;
2642
2643         prs_align(ps);
2644
2645         prs_uint16("unk_0", ps, depth, &(r_u->unk_0));
2646         prs_align(ps);
2647         prs_uint16("unk_1", ps, depth, &(r_u->unk_1));
2648         prs_align(ps);
2649         prs_uint16("unk_2", ps, depth, &(r_u->unk_2));
2650         prs_align(ps);
2651         prs_uint16("unk_3", ps, depth, &(r_u->unk_3));
2652         prs_align(ps);
2653 }
2654
2655 /*******************************************************************
2656 make a SAMR_ENC_PASSWD structure.
2657 ********************************************************************/
2658 void make_enc_passwd(SAMR_ENC_PASSWD *pwd, char pass[512])
2659 {
2660         if (pwd == NULL) return;
2661
2662         pwd->ptr = 1;
2663         memcpy(&(pwd->pass), pass, sizeof(pwd->pass));
2664 }
2665
2666 /*******************************************************************
2667 reads or writes a SAMR_ENC_PASSWD structure.
2668 ********************************************************************/
2669 void samr_io_enc_passwd(char *desc, SAMR_ENC_PASSWD *pwd, prs_struct *ps, int depth)
2670 {
2671         if (pwd == NULL) return;
2672
2673         prs_debug(ps, depth, desc, "samr_io_enc_passwd");
2674         depth++;
2675
2676         prs_align(ps);
2677
2678         prs_uint32("ptr", ps, depth, &(pwd->ptr));
2679         prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass));
2680 }
2681
2682 /*******************************************************************
2683 makes a SAMR_ENC_HASH structure.
2684 ********************************************************************/
2685 void make_enc_hash(SAMR_ENC_HASH *hsh, char hash[16])
2686 {
2687         if (hsh == NULL) return;
2688
2689         hsh->ptr = 1;
2690         memcpy(&(hsh->hash), hash, sizeof(hsh->hash));
2691 }
2692
2693 /*******************************************************************
2694 reads or writes a SAMR_ENC_HASH structure.
2695 ********************************************************************/
2696 void samr_io_enc_hash(char *desc, SAMR_ENC_HASH *hsh, prs_struct *ps, int depth)
2697 {
2698         if (hsh == NULL) return;
2699
2700         prs_debug(ps, depth, desc, "samr_io_enc_hash");
2701         depth++;
2702
2703         prs_align(ps);
2704
2705         prs_uint32("ptr ", ps, depth, &(hsh->ptr));
2706         prs_uint8s(False, "hash", ps, depth, hsh->hash, sizeof(hsh->hash));
2707 }
2708
2709 /*******************************************************************
2710 makes a SAMR_R_UNKNOWN_38 structure.
2711 ********************************************************************/
2712 void make_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER *q_u,
2713                                 char *dest_host, char *user_name,
2714                                 char nt_newpass[516], char nt_oldhash[16],
2715                                 char lm_newpass[516], char lm_oldhash[16])
2716 {
2717         int len_dest_host = strlen(dest_host);
2718         int len_user_name = strlen(user_name);
2719
2720         if (q_u == NULL) return;
2721
2722         DEBUG(5,("make_samr_q_chgpasswd_user\n"));
2723
2724         q_u->ptr_0 = 1;
2725         make_uni_hdr(&(q_u->hdr_dest_host), len_dest_host, len_dest_host, len_dest_host != 0);
2726         make_unistr2(&(q_u->uni_dest_host), dest_host, len_dest_host);
2727         make_uni_hdr(&(q_u->hdr_user_name), len_user_name, len_user_name, len_user_name != 0);
2728         make_unistr2(&(q_u->uni_user_name), user_name, len_user_name);
2729
2730         make_enc_passwd(&(q_u->nt_newpass), nt_newpass);
2731         make_enc_hash  (&(q_u->nt_oldhash), nt_oldhash);
2732
2733         q_u->unknown = 0x01;
2734
2735         make_enc_passwd(&(q_u->lm_newpass), lm_newpass);
2736         make_enc_hash  (&(q_u->lm_oldhash), lm_oldhash);
2737 };
2738
2739 /*******************************************************************
2740 reads or writes a structure.
2741 ********************************************************************/
2742 void samr_io_q_chgpasswd_user(char *desc, SAMR_Q_CHGPASSWD_USER *q_u, prs_struct *ps, int depth)
2743 {
2744         if (q_u == NULL) return;
2745
2746         prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
2747         depth++;
2748
2749         prs_align(ps);
2750
2751         prs_uint32("ptr_0", ps, depth, &(q_u->ptr_0));
2752
2753         smb_io_unihdr ("", &(q_u->hdr_dest_host), ps, depth);
2754         smb_io_unistr2("", &(q_u->uni_dest_host), q_u->hdr_dest_host.buffer, ps, depth);
2755         smb_io_unihdr ("", &(q_u->hdr_user_name), ps, depth);
2756         smb_io_unistr2("", &(q_u->uni_user_name), q_u->hdr_user_name.buffer, ps, depth);
2757
2758         samr_io_enc_passwd("nt_newpass", &(q_u->nt_newpass), ps, depth);
2759         prs_grow(ps);
2760         samr_io_enc_hash  ("nt_oldhash", &(q_u->nt_oldhash), ps, depth);
2761
2762         prs_uint32("unknown", ps, depth, &(q_u->unknown));
2763
2764         samr_io_enc_passwd("lm_newpass", &(q_u->lm_newpass), ps, depth);
2765         prs_grow(ps);
2766         samr_io_enc_hash  ("lm_oldhash", &(q_u->lm_oldhash), ps, depth);
2767 }
2768
2769 /*******************************************************************
2770 makes a SAMR_R_CHGPASSWD_USER structure.
2771 ********************************************************************/
2772 void make_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER *r_u, uint32 status)
2773 {
2774         if (r_u == NULL) return;
2775
2776         DEBUG(5,("make_r_chgpasswd_user\n"));
2777
2778         r_u->status = status;
2779 }
2780
2781 /*******************************************************************
2782 reads or writes a structure.
2783 ********************************************************************/
2784 void samr_io_r_chgpasswd_user(char *desc, SAMR_R_CHGPASSWD_USER *r_u, prs_struct *ps, int depth)
2785 {
2786         if (r_u == NULL) return;
2787
2788         prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
2789         depth++;
2790
2791         prs_align(ps);
2792
2793         prs_uint32("status", ps, depth, &(r_u->status));
2794 }
2795
2796