source3/rpc_parse/parse_samr.c

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