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-1999,
   6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1999,
   7  *  Copyright (C) Paul Ashton                  1997-1999.
   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 BOOL make_samr_q_close_hnd(SAMR_Q_CLOSE_HND *q_c, POLICY_HND *hnd)
  34 {
  35         if (q_c == NULL || hnd == NULL) return False;
  36
  37         DEBUG(5,("make_samr_q_close_hnd\n"));
  38
  39         memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
  40
  41         return True;
  42 }
  43
  44 /*******************************************************************
  45 reads or writes a structure.
  46 ********************************************************************/
  47 BOOL samr_io_q_close_hnd(char *desc,  SAMR_Q_CLOSE_HND *q_u, prs_struct *ps, int depth)
  48 {
  49         if (q_u == NULL) return False;
  50
  51         prs_debug(ps, depth, desc, "samr_io_q_close_hnd");
  52         depth++;
  53
  54         prs_align(ps);
  55
  56         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
  57         prs_align(ps);
  58
  59         return True;
  60 }
  61
  62 /*******************************************************************
  63 reads or writes a structure.
  64 ********************************************************************/
  65 BOOL samr_io_r_close_hnd(char *desc,  SAMR_R_CLOSE_HND *r_u, prs_struct *ps, int depth)
  66 {
  67         if (r_u == NULL) return False;
  68
  69         prs_debug(ps, depth, desc, "samr_io_r_close_hnd");
  70         depth++;
  71
  72         prs_align(ps);
  73
  74         smb_io_pol_hnd("pol", &(r_u->pol), ps, depth);
  75         prs_align(ps);
  76
  77         prs_uint32("status", ps, depth, &(r_u->status));
  78
  79         return True;
  80 }
  81
  82 /*******************************************************************
  83 makes a SAMR_Q_LOOKUP_DOMAIN structure.
  84 ********************************************************************/
  85 BOOL make_samr_q_lookup_domain(SAMR_Q_LOOKUP_DOMAIN *q_u,
  86                 POLICY_HND *pol, const char *dom_name)
  87 {
  88         int len_name = strlen(dom_name);
  89
  90         if (q_u == NULL) return False;
  91
  92         DEBUG(5,("make_samr_q_lookup_domain\n"));
  93
  94         memcpy(&(q_u->connect_pol), pol, sizeof(*pol));
  95
  96         make_uni_hdr(&(q_u->hdr_domain), len_name);
  97         make_unistr2(&(q_u->uni_domain), dom_name, len_name);
  98
  99         return True;
 100 }
 101
 102 /*******************************************************************
 103 reads or writes a structure.
 104 ********************************************************************/
 105 BOOL samr_io_q_lookup_domain(char *desc, SAMR_Q_LOOKUP_DOMAIN *q_u, prs_struct *ps, int depth)
 106 {
 107         if (q_u == NULL) return False;
 108
 109         prs_debug(ps, depth, desc, "samr_io_q_lookup_domain");
 110         depth++;
 111
 112         prs_align(ps);
 113
 114         smb_io_pol_hnd("connect_pol", &(q_u->connect_pol), ps, depth);
 115         prs_align(ps);
 116
 117         smb_io_unihdr("hdr_domain", &(q_u->hdr_domain), ps, depth);
 118         smb_io_unistr2("uni_domain", &(q_u->uni_domain),
 119                        q_u->hdr_domain.buffer, ps, depth);
 120         prs_align(ps);
 121
 122         return True;
 123 }
 124
 125 /*******************************************************************
 126 reads or writes a structure.
 127 ********************************************************************/
 128 BOOL samr_io_r_lookup_domain(char *desc, SAMR_R_LOOKUP_DOMAIN *r_u, prs_struct *ps, int depth)
 129 {
 130         if (r_u == NULL) return False;
 131
 132         prs_debug(ps, depth, desc, "samr_io_r_lookup_domain");
 133         depth++;
 134
 135         prs_align(ps);
 136
 137         prs_uint32("ptr", ps, depth, &(r_u->ptr_sid));
 138
 139         if (r_u->ptr_sid != 0)
 140         {
 141                 smb_io_dom_sid2("sid", &(r_u->dom_sid), ps, depth);
 142                 prs_align(ps);
 143         }
 144
 145         prs_uint32("status", ps, depth, &(r_u->status));
 146
 147         return True;
 148 }
 149
 150 /*******************************************************************
 151 reads or writes a structure.
 152 ********************************************************************/
 153 BOOL make_samr_q_open_domain(SAMR_Q_OPEN_DOMAIN *q_u,
 154                                 const POLICY_HND *connect_pol, uint32 flags,
 155                                 const DOM_SID *sid)
 156 {
 157         if (q_u == NULL) return False;
 158
 159         DEBUG(5,("samr_make_samr_q_open_domain\n"));
 160
 161         memcpy(&q_u->connect_pol, connect_pol, sizeof(q_u->connect_pol));
 162         q_u->flags = flags;
 163         make_dom_sid2(&(q_u->dom_sid), sid);
 164
 165         return True;
 166 }
 167
 168 /*******************************************************************
 169 reads or writes a structure.
 170 ********************************************************************/
 171 BOOL samr_io_q_open_domain(char *desc,  SAMR_Q_OPEN_DOMAIN *q_u, prs_struct *ps, int depth)
 172 {
 173         if (q_u == NULL) return False;
 174
 175         prs_debug(ps, depth, desc, "samr_io_q_open_domain");
 176         depth++;
 177
 178         prs_align(ps);
 179
 180         smb_io_pol_hnd("connect_pol", &(q_u->connect_pol), ps, depth);
 181         prs_align(ps);
 182
 183         prs_uint32("flags", ps, depth, &(q_u->flags));
 184
 185         smb_io_dom_sid2("sid", &(q_u->dom_sid), ps, depth);
 186         prs_align(ps);
 187
 188         return True;
 189 }
 190
 191
 192 /*******************************************************************
 193 reads or writes a structure.
 194 ********************************************************************/
 195 BOOL samr_io_r_open_domain(char *desc,  SAMR_R_OPEN_DOMAIN *r_u, prs_struct *ps, int depth)
 196 {
 197         if (r_u == NULL) return False;
 198
 199         prs_debug(ps, depth, desc, "samr_io_r_open_domain");
 200         depth++;
 201
 202         prs_align(ps);
 203
 204         smb_io_pol_hnd("domain_pol", &(r_u->domain_pol), ps, depth);
 205         prs_align(ps);
 206
 207         prs_uint32("status", ps, depth, &(r_u->status));
 208
 209         return True;
 210 }
 211
 212 /*******************************************************************
 213 reads or writes a structure.
 214 ********************************************************************/
 215 BOOL make_samr_q_unknown_2c(SAMR_Q_UNKNOWN_2C *q_u, POLICY_HND *user_pol)
 216 {
 217         if (q_u == NULL) return False;
 218
 219         DEBUG(5,("samr_make_samr_q_unknown_2c\n"));
 220
 221         memcpy(&q_u->user_pol, user_pol, sizeof(q_u->user_pol));
 222
 223         return True;
 224 }
 225
 226
 227 /*******************************************************************
 228 reads or writes a structure.
 229 ********************************************************************/
 230 BOOL samr_io_q_unknown_2c(char *desc,  SAMR_Q_UNKNOWN_2C *q_u, prs_struct *ps, int depth)
 231 {
 232         if (q_u == NULL) return False;
 233
 234         prs_debug(ps, depth, desc, "samr_io_q_unknown_2c");
 235         depth++;
 236
 237         prs_align(ps);
 238
 239         smb_io_pol_hnd("user_pol", &(q_u->user_pol), ps, depth);
 240         prs_align(ps);
 241
 242         return True;
 243 }
 244
 245 /*******************************************************************
 246 makes a structure.
 247 ********************************************************************/
 248 BOOL make_samr_r_unknown_2c(SAMR_R_UNKNOWN_2C *q_u, uint32 status)
 249 {
 250         if (q_u == NULL) return False;
 251
 252         DEBUG(5,("samr_make_r_unknown_2c\n"));
 253
 254         q_u->unknown_0 = 0x00150000;
 255         q_u->unknown_1 = 0x00000000;
 256         q_u->status    = status;
 257
 258         return True;
 259 }
 260
 261
 262 /*******************************************************************
 263 reads or writes a structure.
 264 ********************************************************************/
 265 BOOL samr_io_r_unknown_2c(char *desc,  SAMR_R_UNKNOWN_2C *r_u, prs_struct *ps, int depth)
 266 {
 267         if (r_u == NULL) return False;
 268
 269         prs_debug(ps, depth, desc, "samr_io_r_unknown_2c");
 270         depth++;
 271
 272         prs_align(ps);
 273
 274         prs_uint32("unknown_0", ps, depth, &(r_u->unknown_0));
 275         prs_uint32("unknown_1", ps, depth, &(r_u->unknown_1));
 276         prs_uint32("status   ", ps, depth, &(r_u->status   ));
 277
 278         return True;
 279 }
 280
 281 /*******************************************************************
 282 reads or writes a structure.
 283 ********************************************************************/
 284 BOOL make_samr_q_unknown_3(SAMR_Q_UNKNOWN_3 *q_u,
 285                                 POLICY_HND *user_pol, uint16 switch_value)
 286 {
 287         if (q_u == NULL) return False;
 288
 289         DEBUG(5,("samr_make_samr_q_unknown_3\n"));
 290
 291         memcpy(&q_u->user_pol, user_pol, sizeof(q_u->user_pol));
 292         q_u->switch_value = switch_value;
 293
 294         return True;
 295 }
 296
 297
 298 /*******************************************************************
 299 reads or writes a structure.
 300 ********************************************************************/
 301 BOOL samr_io_q_unknown_3(char *desc,  SAMR_Q_UNKNOWN_3 *q_u, prs_struct *ps, int depth)
 302 {
 303         if (q_u == NULL) return False;
 304
 305         prs_debug(ps, depth, desc, "samr_io_q_unknown_3");
 306         depth++;
 307
 308         prs_align(ps);
 309
 310         smb_io_pol_hnd("user_pol", &(q_u->user_pol), ps, depth);
 311         prs_align(ps);
 312
 313         prs_uint16("switch_value", ps, depth, &(q_u->switch_value));
 314         prs_align(ps);
 315
 316         return True;
 317 }
 318
 319 /*******************************************************************
 320 reads or writes a structure.
 321 ********************************************************************/
 322 BOOL make_samr_q_query_dom_info(SAMR_Q_QUERY_DOMAIN_INFO *q_u,
 323                                 POLICY_HND *domain_pol, uint16 switch_value)
 324 {
 325         if (q_u == NULL) return False;
 326
 327         DEBUG(5,("samr_make_samr_q_query_dom_info\n"));
 328
 329         memcpy(&q_u->domain_pol, domain_pol, sizeof(q_u->domain_pol));
 330         q_u->switch_value = switch_value;
 331
 332         return True;
 333 }
 334
 335 /*******************************************************************
 336 reads or writes a structure.
 337 ********************************************************************/
 338 BOOL samr_io_q_query_dom_info(char *desc,  SAMR_Q_QUERY_DOMAIN_INFO *q_u, prs_struct *ps, int depth)
 339 {
 340         if (q_u == NULL) return False;
 341
 342         prs_debug(ps, depth, desc, "samr_io_q_query_dom_info");
 343         depth++;
 344
 345         prs_align(ps);
 346
 347         smb_io_pol_hnd("domain_pol", &(q_u->domain_pol), ps, depth);
 348         prs_align(ps);
 349
 350         prs_uint16("switch_value", ps, depth, &(q_u->switch_value));
 351         prs_align(ps);
 352
 353         return True;
 354 }
 355
 356
 357 /*******************************************************************
 358 makes a structure.
 359 ********************************************************************/
 360 BOOL make_unk_info3(SAM_UNK_INFO_3 *u_3)
 361 {
 362         if (u_3 == NULL) return False;
 363
 364         u_3->unknown_0 = 0x00000000;
 365         u_3->unknown_1 = 0x80000000;
 366
 367         return True;
 368 }
 369
 370 /*******************************************************************
 371 reads or writes a structure.
 372 ********************************************************************/
 373 BOOL sam_io_unk_info3(char *desc, SAM_UNK_INFO_3 *u_3, prs_struct *ps, int depth)
 374 {
 375         if (u_3 == NULL) return False;
 376
 377         prs_debug(ps, depth, desc, "sam_io_unk_info3");
 378         depth++;
 379
 380         prs_uint32("unknown_0", ps, depth, &u_3->unknown_0); /* 0x0000 0000 */
 381         prs_uint32("unknown_1", ps, depth, &u_3->unknown_1); /* 0x8000 0000 */
 382
 383         prs_align(ps);
 384
 385
 386         return True;
 387 }
 388
 389 /*******************************************************************
 390 makes a structure.
 391 ********************************************************************/
 392 BOOL make_unk_info6(SAM_UNK_INFO_6 *u_6)
 393 {
 394         if (u_6 == NULL) return False;
 395
 396         u_6->unknown_0 = 0x00000000;
 397         u_6->ptr_0 = 1;
 398         memset(u_6->padding, 0, sizeof(u_6->padding)); /* 12 bytes zeros */
 399
 400         return True;
 401 }
 402
 403 /*******************************************************************
 404 reads or writes a structure.
 405 ********************************************************************/
 406 BOOL sam_io_unk_info6(char *desc, SAM_UNK_INFO_6 *u_6, prs_struct *ps, int depth)
 407 {
 408         if (u_6 == NULL) return False;
 409
 410         prs_debug(ps, depth, desc, "sam_io_unk_info6");
 411         depth++;
 412
 413         prs_uint32("unknown_0", ps, depth, &u_6->unknown_0); /* 0x0000 0000 */
 414         prs_uint32("ptr_0", ps, depth, &u_6->ptr_0);     /* pointer to unknown structure */
 415         prs_uint8s(False, "padding", ps, depth, u_6->padding, sizeof(u_6->padding)); /* 12 bytes zeros */
 416
 417         prs_align(ps);
 418
 419
 420         return True;
 421 }
 422
 423 /*******************************************************************
 424 makes a structure.
 425 ********************************************************************/
 426 BOOL make_unk_info7(SAM_UNK_INFO_7 *u_7)
 427 {
 428         if (u_7 == NULL) return False;
 429
 430         u_7->unknown_0 = 0x0003;
 431
 432         return True;
 433 }
 434
 435 /*******************************************************************
 436 reads or writes a structure.
 437 ********************************************************************/
 438 BOOL sam_io_unk_info7(char *desc, SAM_UNK_INFO_7 *u_7, prs_struct *ps, int depth)
 439 {
 440         if (u_7 == NULL) return False;
 441
 442         prs_debug(ps, depth, desc, "sam_io_unk_info7");
 443         depth++;
 444
 445         prs_uint16("unknown_0", ps, depth, &u_7->unknown_0); /* 0x0003 */
 446         prs_align(ps);
 447
 448
 449         return True;
 450 }
 451
 452 /*******************************************************************
 453 makes a structure.
 454 ********************************************************************/
 455 BOOL make_unk_info2(SAM_UNK_INFO_2 *u_2, char *domain, char *server)
 456 {
 457         int len_domain = strlen(domain);
 458         int len_server = strlen(server);
 459
 460         if (u_2 == NULL) return False;
 461
 462         u_2->unknown_0 = 0x00000000;
 463         u_2->unknown_1 = 0x80000000;
 464         u_2->unknown_2 = 0x00000000;
 465
 466         u_2->ptr_0 = 1;
 467         make_uni_hdr(&(u_2->hdr_domain), len_domain);
 468         make_uni_hdr(&(u_2->hdr_server), len_server);
 469
 470         u_2->seq_num = 0x10000000;
 471         u_2->unknown_3 = 0x00000000;
 472
 473         u_2->unknown_4  = 0x00000001;
 474         u_2->unknown_5  = 0x00000003;
 475         u_2->unknown_6  = 0x00000001;
 476         u_2->num_domain_usrs  = MAX_SAM_ENTRIES;
 477         u_2->num_domain_grps = MAX_SAM_ENTRIES;
 478         u_2->num_local_grps = MAX_SAM_ENTRIES;
 479
 480         memset(u_2->padding, 0, sizeof(u_2->padding)); /* 12 bytes zeros */
 481
 482         make_unistr2(&u_2->uni_domain, domain, len_domain);
 483         make_unistr2(&u_2->uni_server, server, len_server);
 484
 485         return True;
 486 }
 487
 488 /*******************************************************************
 489 reads or writes a structure.
 490 ********************************************************************/
 491 BOOL sam_io_unk_info2(char *desc, SAM_UNK_INFO_2 *u_2, prs_struct *ps, int depth)
 492 {
 493         if (u_2 == NULL) return False;
 494
 495         prs_debug(ps, depth, desc, "sam_io_unk_info2");
 496         depth++;
 497
 498         prs_uint32("unknown_0", ps, depth, &u_2->unknown_0); /* 0x0000 0000 */
 499         prs_uint32("unknown_1", ps, depth, &u_2->unknown_1); /* 0x8000 0000 */
 500         prs_uint32("unknown_2", ps, depth, &u_2->unknown_2); /* 0x0000 0000 */
 501
 502         prs_uint32("ptr_0", ps, depth, &u_2->ptr_0);     /* pointer to unknown structure */
 503         smb_io_unihdr("hdr_domain", &u_2->hdr_domain, ps, depth); /* domain name unicode header */
 504         smb_io_unihdr("hdr_server", &u_2->hdr_server, ps, depth); /* server name unicode header */
 505
 506         /* put all the data in here, at the moment, including what the above
 507            pointer is referring to
 508          */
 509
 510         prs_uint32("seq_num ", ps, depth, &u_2->seq_num ); /* 0x0000 0099 or 0x1000 0000 */
 511         prs_uint32("unknown_3 ", ps, depth, &u_2->unknown_3 ); /* 0x0000 0000 */
 512
 513         prs_uint32("unknown_4 ", ps, depth, &u_2->unknown_4 ); /* 0x0000 0001 */
 514         prs_uint32("unknown_5 ", ps, depth, &u_2->unknown_5 ); /* 0x0000 0003 */
 515         prs_uint32("unknown_6 ", ps, depth, &u_2->unknown_6 ); /* 0x0000 0001 */
 516         prs_uint32("num_domain_usrs ", ps, depth, &u_2->num_domain_usrs ); /* 0x0000 0008 */
 517         prs_uint32("num_domain_grps", ps, depth, &u_2->num_domain_grps); /* 0x0000 0003 */
 518         prs_uint32("num_local_grps", ps, depth, &u_2->num_local_grps); /* 0x0000 0003 */
 519
 520         prs_uint8s(False, "padding", ps, depth, u_2->padding, sizeof(u_2->padding)); /* 12 bytes zeros */
 521
 522         smb_io_unistr2( "uni_domain", &u_2->uni_domain, u_2->hdr_domain.buffer, ps, depth); /* domain name unicode string */
 523         prs_align(ps);
 524         smb_io_unistr2( "uni_server", &u_2->uni_server, u_2->hdr_server.buffer, ps, depth); /* server name unicode string */
 525
 526         prs_align(ps);
 527
 528
 529         return True;
 530 }
 531
 532 /*******************************************************************
 533 makes a structure.
 534 ********************************************************************/
 535 BOOL make_unk_info1(SAM_UNK_INFO_1 *u_1)
 536 {
 537         if (u_1 == NULL) return False;
 538
 539         memset(u_1->padding, 0, sizeof(u_1->padding)); /* 12 bytes zeros */
 540         u_1->unknown_1 = 0x80000000;
 541         u_1->unknown_2 = 0x00000000;
 542
 543         return True;
 544 }
 545
 546 /*******************************************************************
 547 reads or writes a structure.
 548 ********************************************************************/
 549 BOOL sam_io_unk_info1(char *desc, SAM_UNK_INFO_1 *u_1, prs_struct *ps, int depth)
 550 {
 551         if (u_1 == NULL) return False;
 552
 553         prs_debug(ps, depth, desc, "sam_io_unk_info1");
 554         depth++;
 555
 556         prs_uint8s(False, "padding", ps, depth, u_1->padding, sizeof(u_1->padding)); /* 12 bytes zeros */
 557
 558         prs_uint32("unknown_1", ps, depth, &u_1->unknown_1); /* 0x8000 0000 */
 559         prs_uint32("unknown_2", ps, depth, &u_1->unknown_2); /* 0x0000 0000 */
 560
 561         prs_align(ps);
 562
 563         return True;
 564 }
 565
 566 /*******************************************************************
 567 makes a SAMR_R_QUERY_DOMAIN_INFO structure.
 568 ********************************************************************/
 569 BOOL make_samr_r_query_dom_info(SAMR_R_QUERY_DOMAIN_INFO *r_u,
 570                                 uint16 switch_value, SAM_UNK_CTR *ctr,
 571                                 uint32 status)
 572 {
 573         if (r_u == NULL || ctr == NULL) return False;
 574
 575         DEBUG(5,("make_samr_r_query_dom_info\n"));
 576
 577         r_u->ptr_0 = 0;
 578         r_u->switch_value = 0;
 579         r_u->status = status; /* return status */
 580
 581         if (status == 0)
 582         {
 583                 r_u->switch_value = switch_value;
 584                 r_u->ptr_0 = 1;
 585                 r_u->ctr = ctr;
 586         }
 587
 588         return True;
 589 }
 590
 591 /*******************************************************************
 592 reads or writes a structure.
 593 ********************************************************************/
 594 BOOL samr_io_r_query_dom_info(char *desc, SAMR_R_QUERY_DOMAIN_INFO *r_u, prs_struct *ps, int depth)
 595 {
 596         if (r_u == NULL) return False;
 597
 598         prs_debug(ps, depth, desc, "samr_io_r_query_dom_info");
 599         depth++;
 600
 601         prs_align(ps);
 602
 603         prs_uint32("ptr_0       ", ps, depth, &(r_u->ptr_0));
 604
 605         if (r_u->ptr_0 != 0 && r_u->ctr != NULL)
 606         {
 607                 prs_uint16("switch_value", ps, depth, &(r_u->switch_value));
 608                 prs_align(ps);
 609
 610                 switch (r_u->switch_value)
 611                 {
 612                         case 0x07:
 613                         {
 614                                 sam_io_unk_info7("unk_inf7", &r_u->ctr->info.inf7, ps, depth);
 615                                 break;
 616                         }
 617                         case 0x06:
 618                         {
 619                                 sam_io_unk_info6("unk_inf6", &r_u->ctr->info.inf6, ps, depth);
 620                                 break;
 621                         }
 622                         case 0x03:
 623                         {
 624                                 sam_io_unk_info3("unk_inf3", &r_u->ctr->info.inf3, ps, depth);
 625                                 break;
 626                         }
 627                         case 0x02:
 628                         {
 629                                 sam_io_unk_info2("unk_inf2", &r_u->ctr->info.inf2, ps, depth);
 630                                 break;
 631                         }
 632                         case 0x01:
 633                         {
 634                                 sam_io_unk_info1("unk_inf1", &r_u->ctr->info.inf1, ps, depth);
 635                                 break;
 636                         }
 637                         default:
 638                         {
 639                                 DEBUG(3,("samr_io_r_query_dom_info: unknown switch level 0x%x\n",
 640                                           r_u->switch_value));
 641                                 r_u->status = 0xC0000000|NT_STATUS_INVALID_INFO_CLASS;
 642                                 return False;
 643                         }
 644                 }
 645         }
 646
 647         prs_uint32("status      ", ps, depth, &(r_u->status));
 648
 649         return True;
 650 }
 651
 652
 653 /*******************************************************************
 654  makes a DOM_SID3 structure.
 655
 656  calculate length by adding up the size of the components.
 657  ********************************************************************/
 658 BOOL make_dom_sid3(DOM_SID3 *sid3, uint16 unk_0, uint16 unk_1, DOM_SID *sid)
 659 {
 660         if (sid3 == NULL) return False;
 661
 662     sid3->sid = *sid;
 663         sid3->len = 2 + 8 + sid3->sid.num_auths * 4;
 664
 665         return True;
 666 }
 667
 668 /*******************************************************************
 669 reads or writes a SAM_SID3 structure.
 670
 671 this one's odd, because the length (in bytes) is specified at the beginning.
 672 the length _includes_ the length of the length, too :-)
 673
 674 ********************************************************************/
 675 static BOOL sam_io_dom_sid3(char *desc,  DOM_SID3 *sid3, prs_struct *ps, int depth)
 676 {
 677         if (sid3 == NULL) return False;
 678
 679         prs_debug(ps, depth, desc, "sam_io_dom_sid3");
 680         depth++;
 681
 682         prs_uint16("len", ps, depth, &(sid3->len));
 683         prs_align(ps);
 684         smb_io_dom_sid("", &(sid3->sid), ps, depth);
 685
 686         return True;
 687 }
 688
 689 /*******************************************************************
 690 makes a SAMR_R_UNKNOWN3 structure.
 691
 692 unknown_2   : 0x0001
 693 unknown_3   : 0x8004
 694
 695 unknown_4,5 : 0x0000 0014
 696
 697 unknown_6   : 0x0002
 698 unknown_7   : 0x5800 or 0x0070
 699
 700 ********************************************************************/
 701 static BOOL make_sam_sid_stuff(SAM_SID_STUFF *stf,
 702                                 uint16 unknown_2, uint16 unknown_3,
 703                                 uint32 unknown_4, uint16 unknown_6, uint16 unknown_7,
 704                                 int num_sid3s, DOM_SID3 sid3[MAX_SAM_SIDS])
 705 {
 706         stf->unknown_2 = unknown_2;
 707         stf->unknown_3 = unknown_3;
 708
 709         bzero(stf->padding1, sizeof(stf->padding1));
 710
 711         stf->unknown_4 = unknown_4;
 712         stf->unknown_5 = unknown_4;
 713
 714         stf->unknown_6 = unknown_6;
 715         stf->unknown_7 = unknown_7;
 716
 717         stf->num_sids  = num_sid3s;
 718
 719         stf->padding2  = 0x0000;
 720
 721         memcpy(stf->sid, sid3, sizeof(DOM_SID3) * num_sid3s);
 722
 723         return True;
 724 }
 725
 726 /*******************************************************************
 727 reads or writes a SAM_SID_STUFF structure.
 728 ********************************************************************/
 729 static BOOL sam_io_sid_stuff(char *desc,  SAM_SID_STUFF *stf, prs_struct *ps, int depth)
 730 {
 731         uint32 i;
 732
 733         if (stf == NULL) return False;
 734
 735         DEBUG(5,("make_sam_sid_stuff\n"));
 736
 737         prs_uint16("unknown_2", ps, depth, &(stf->unknown_2));
 738         prs_uint16("unknown_3", ps, depth, &(stf->unknown_3));
 739
 740         prs_uint8s(False, "padding1", ps, depth, stf->padding1, sizeof(stf->padding1));
 741
 742         prs_uint32("unknown_4", ps, depth, &(stf->unknown_4));
 743         prs_uint32("unknown_5", ps, depth, &(stf->unknown_5));
 744         prs_uint16("unknown_6", ps, depth, &(stf->unknown_6));
 745         prs_uint16("unknown_7", ps, depth, &(stf->unknown_7));
 746
 747         prs_uint32("num_sids ", ps, depth, &(stf->num_sids ));
 748         prs_uint16("padding2 ", ps, depth, &(stf->padding2 ));
 749
 750         SMB_ASSERT_ARRAY(stf->sid, stf->num_sids);
 751
 752         for (i = 0; i < stf->num_sids; i++)
 753         {
 754                 sam_io_dom_sid3("", &(stf->sid[i]), ps, depth);
 755         }
 756
 757         return True;
 758 }
 759
 760 /*******************************************************************
 761 reads or writes a SAMR_R_UNKNOWN3 structure.
 762 ********************************************************************/
 763 BOOL make_samr_r_unknown_3(SAMR_R_UNKNOWN_3 *r_u,
 764                                 uint16 unknown_2, uint16 unknown_3,
 765                                 uint32 unknown_4, uint16 unknown_6, uint16 unknown_7,
 766                                 int num_sid3s, DOM_SID3 sid3[MAX_SAM_SIDS],
 767                                 uint32 status)
 768 {
 769         if (r_u == NULL) return False;
 770
 771         DEBUG(5,("samr_make_r_unknown_3\n"));
 772
 773         r_u->ptr_0 = 0;
 774         r_u->ptr_1 = 0;
 775
 776         if (status == 0x0)
 777         {
 778                 r_u->ptr_0 = 1;
 779                 r_u->ptr_1 = 1;
 780                 make_sam_sid_stuff(&(r_u->sid_stuff), unknown_2, unknown_3,
 781                        unknown_4, unknown_6, unknown_7,
 782                        num_sid3s, sid3);
 783         }
 784
 785         r_u->status = status;
 786
 787         return True;
 788 }
 789
 790
 791 /*******************************************************************
 792 reads or writes a SAMR_R_UNKNOWN_3 structure.
 793
 794 this one's odd, because the daft buggers use a different mechanism
 795 for writing out the array of sids. they put the number of sids in
 796 only one place: they've calculated the length of each sid and jumped
 797 by that amount.  then, retrospectively, the length of the whole buffer
 798 is put at the beginning of the data stream.
 799
 800 wierd.
 801
 802 ********************************************************************/
 803 BOOL samr_io_r_unknown_3(char *desc,  SAMR_R_UNKNOWN_3 *r_u, prs_struct *ps, int depth)
 804 {
 805         int ptr_len0=0;
 806         int ptr_len1=0;
 807         int ptr_sid_stuff = 0;
 808
 809         if (r_u == NULL) return False;
 810
 811         prs_debug(ps, depth, desc, "samr_io_r_unknown_3");
 812         depth++;
 813
 814         prs_align(ps);
 815
 816         prs_uint32("ptr_0         ", ps, depth, &(r_u->ptr_0         ));
 817
 818         if (ps->io)
 819         {
 820                 /* reading.  do the length later */
 821                 prs_uint32("sid_stuff_len0", ps, depth, &(r_u->sid_stuff_len0));
 822         }
 823         else
 824         {
 825                 /* storing */
 826                 ptr_len0 = ps->offset; ps->offset += 4;
 827         }
 828
 829         if (r_u->ptr_0 != 0)
 830         {
 831                 prs_uint32("ptr_1         ", ps, depth, &(r_u->ptr_1         ));
 832                 if (ps->io)
 833                 {
 834                         /* reading.  do the length later */
 835                         prs_uint32("sid_stuff_len1", ps, depth, &(r_u->sid_stuff_len1));
 836                 }
 837                 else
 838                 {
 839                         /* storing */
 840                         ptr_len1 = ps->offset; ps->offset += 4;
 841                 }
 842
 843                 if (r_u->ptr_1 != 0)
 844                 {
 845                         ptr_sid_stuff = ps->offset;
 846                         sam_io_sid_stuff("", &(r_u->sid_stuff), ps, depth);
 847                 }
 848         }
 849
 850         if (!(ps->io)) /* storing not reading.  do the length, now. */
 851         {
 852                 if (ptr_sid_stuff != 0)
 853                 {
 854                         uint32 sid_stuff_len = ps->offset - ptr_sid_stuff;
 855                         int old_len = ps->offset;
 856
 857                         ps->offset = ptr_len0;
 858                         prs_uint32("sid_stuff_len0", ps, depth, &sid_stuff_len);
 859
 860                         ps->offset = ptr_len1;
 861                         prs_uint32("sid_stuff_len1", ps, depth, &sid_stuff_len);
 862
 863                         ps->offset = old_len;
 864                 }
 865         }
 866
 867         prs_uint32("status", ps, depth, &(r_u->status));
 868
 869         return True;
 870 }
 871
 872 /*******************************************************************
 873 reads or writes a SAM_STR1 structure.
 874 ********************************************************************/
 875 static BOOL sam_io_sam_str1(char *desc,  SAM_STR1 *sam, uint32 acct_buf, uint32 name_buf, uint32 desc_buf, prs_struct *ps, int depth)
 876 {
 877         if (sam == NULL) return False;
 878
 879         prs_debug(ps, depth, desc, "sam_io_sam_str1");
 880         depth++;
 881
 882         prs_align(ps);
 883
 884         smb_io_unistr2("unistr2", &(sam->uni_acct_name), acct_buf, ps, depth); /* account name unicode string */
 885         prs_align(ps);
 886         smb_io_unistr2("unistr2", &(sam->uni_full_name), name_buf, ps, depth); /* full name unicode string */
 887         prs_align(ps);
 888         smb_io_unistr2("unistr2", &(sam->uni_acct_desc), desc_buf, ps, depth); /* account desc unicode string */
 889         prs_align(ps);
 890
 891         return True;
 892 }
 893
 894 /*******************************************************************
 895 makes a SAM_ENTRY1 structure.
 896 ********************************************************************/
 897 static BOOL make_sam_entry1(SAM_ENTRY1 *sam, uint32 user_idx,
 898                                 uint32 len_sam_name, uint32 len_sam_full, uint32 len_sam_desc,
 899                                 uint32 rid_user, uint16 acb_info)
 900 {
 901         if (sam == NULL) return False;
 902
 903         DEBUG(5,("make_sam_entry1\n"));
 904
 905         sam->user_idx = user_idx;
 906         sam->rid_user = rid_user;
 907         sam->acb_info = acb_info;
 908         sam->pad      = 0;
 909
 910         make_uni_hdr(&(sam->hdr_acct_name), len_sam_name);
 911         make_uni_hdr(&(sam->hdr_user_name), len_sam_full);
 912         make_uni_hdr(&(sam->hdr_user_desc), len_sam_desc);
 913
 914         return True;
 915 }
 916
 917 /*******************************************************************
 918 reads or writes a SAM_ENTRY1 structure.
 919 ********************************************************************/
 920 static BOOL sam_io_sam_entry1(char *desc,  SAM_ENTRY1 *sam, prs_struct *ps, int depth)
 921 {
 922         if (sam == NULL) return False;
 923
 924         prs_debug(ps, depth, desc, "sam_io_sam_entry1");
 925         depth++;
 926
 927         prs_align(ps);
 928
 929         prs_uint32("user_idx ", ps, depth, &(sam->user_idx ));
 930
 931         prs_uint32("rid_user ", ps, depth, &(sam->rid_user ));
 932         prs_uint16("acb_info ", ps, depth, &(sam->acb_info ));
 933         prs_uint16("pad      ", ps, depth, &(sam->pad      ));
 934
 935         smb_io_unihdr("unihdr", &(sam->hdr_acct_name), ps, depth); /* account name unicode string header */
 936         smb_io_unihdr("unihdr", &(sam->hdr_user_name), ps, depth); /* account name unicode string header */
 937         smb_io_unihdr("unihdr", &(sam->hdr_user_desc), ps, depth); /* account name unicode string header */
 938
 939         return True;
 940 }
 941
 942 /*******************************************************************
 943 reads or writes a SAM_STR2 structure.
 944 ********************************************************************/
 945 static BOOL sam_io_sam_str2(char *desc,  SAM_STR2 *sam, uint32 acct_buf, uint32 desc_buf, prs_struct *ps, int depth)
 946 {
 947         if (sam == NULL) return False;
 948
 949         prs_debug(ps, depth, desc, "sam_io_sam_str2");
 950         depth++;
 951
 952         prs_align(ps);
 953
 954         smb_io_unistr2("unistr2", &(sam->uni_srv_name), acct_buf, ps, depth); /* account name unicode string */
 955         prs_align(ps);
 956         smb_io_unistr2("unistr2", &(sam->uni_srv_desc), desc_buf, ps, depth); /* account desc unicode string */
 957         prs_align(ps);
 958
 959         return True;
 960 }
 961
 962 /*******************************************************************
 963 makes a SAM_ENTRY2 structure.
 964 ********************************************************************/
 965 static BOOL make_sam_entry2(SAM_ENTRY2 *sam, uint32 user_idx,
 966                                 uint32 len_sam_name, uint32 len_sam_desc,
 967                                 uint32 rid_user, uint16 acb_info)
 968 {
 969         if (sam == NULL) return False;
 970
 971         DEBUG(5,("make_sam_entry2\n"));
 972
 973         sam->user_idx = user_idx;
 974         sam->rid_user = rid_user;
 975         sam->acb_info = acb_info;
 976         sam->pad      = 0;
 977
 978         make_uni_hdr(&(sam->hdr_srv_name), len_sam_name);
 979         make_uni_hdr(&(sam->hdr_srv_desc), len_sam_desc);
 980
 981         return True;
 982 }
 983
 984 /*******************************************************************
 985 reads or writes a SAM_ENTRY2 structure.
 986 ********************************************************************/
 987 static BOOL sam_io_sam_entry2(char *desc,  SAM_ENTRY2 *sam, prs_struct *ps, int depth)
 988 {
 989         if (sam == NULL) return False;
 990
 991         prs_debug(ps, depth, desc, "sam_io_sam_entry2");
 992         depth++;
 993
 994         prs_align(ps);
 995
 996         prs_uint32("user_idx ", ps, depth, &(sam->user_idx ));
 997
 998         prs_uint32("rid_user ", ps, depth, &(sam->rid_user ));
 999         prs_uint16("acb_info ", ps, depth, &(sam->acb_info ));
1000         prs_uint16("pad      ", ps, depth, &(sam->pad      ));
1001
1002         smb_io_unihdr("unihdr", &(sam->hdr_srv_name), ps, depth); /* account name unicode string header */
1003         smb_io_unihdr("unihdr", &(sam->hdr_srv_desc), ps, depth); /* account name unicode string header */
1004
1005         return True;
1006 }
1007
1008 /*******************************************************************
1009 reads or writes a SAM_STR3 structure.
1010 ********************************************************************/
1011 static BOOL sam_io_sam_str3(char *desc,  SAM_STR3 *sam, uint32 acct_buf, uint32 desc_buf, prs_struct *ps, int depth)
1012 {
1013         if (sam == NULL) return False;
1014
1015         prs_debug(ps, depth, desc, "sam_io_sam_str3");
1016         depth++;
1017
1018         prs_align(ps);
1019
1020         smb_io_unistr2("unistr2", &(sam->uni_grp_name), acct_buf, ps, depth); /* account name unicode string */
1021         prs_align(ps);
1022         smb_io_unistr2("unistr2", &(sam->uni_grp_desc), desc_buf, ps, depth); /* account desc unicode string */
1023         prs_align(ps);
1024
1025         return True;
1026 }
1027
1028 /*******************************************************************
1029 makes a SAM_ENTRY3 structure.
1030 ********************************************************************/
1031 static BOOL make_sam_entry3(SAM_ENTRY3 *sam, uint32 grp_idx,
1032                                 uint32 len_grp_name, uint32 len_grp_desc, uint32 rid_grp)
1033 {
1034         if (sam == NULL) return False;
1035
1036         DEBUG(5,("make_sam_entry3\n"));
1037
1038         sam->grp_idx = grp_idx;
1039         sam->rid_grp = rid_grp;
1040         sam->attr    = 0x07; /* group rid attributes - gets ignored by nt 4.0 */
1041
1042         make_uni_hdr(&(sam->hdr_grp_name), len_grp_name);
1043         make_uni_hdr(&(sam->hdr_grp_desc), len_grp_desc);
1044
1045         return True;
1046 }
1047
1048 /*******************************************************************
1049 reads or writes a SAM_ENTRY3 structure.
1050 ********************************************************************/
1051 static BOOL sam_io_sam_entry3(char *desc,  SAM_ENTRY3 *sam, prs_struct *ps, int depth)
1052 {
1053         if (sam == NULL) return False;
1054
1055         prs_debug(ps, depth, desc, "sam_io_sam_entry3");
1056         depth++;
1057
1058         prs_align(ps);
1059
1060         prs_uint32("grp_idx", ps, depth, &(sam->grp_idx));
1061
1062         prs_uint32("rid_grp", ps, depth, &(sam->rid_grp));
1063         prs_uint32("attr   ", ps, depth, &(sam->attr   ));
1064
1065         smb_io_unihdr("unihdr", &(sam->hdr_grp_name), ps, depth); /* account name unicode string header */
1066         smb_io_unihdr("unihdr", &(sam->hdr_grp_desc), ps, depth); /* account name unicode string header */
1067
1068         return True;
1069 }
1070
1071 /*******************************************************************
1072 makes a SAM_ENTRY4 structure.
1073 ********************************************************************/
1074 static BOOL make_sam_entry4(SAM_ENTRY4 *sam, uint32 user_idx,
1075                                 uint32 len_acct_name)
1076 {
1077         if (sam == NULL) return False;
1078
1079         DEBUG(5,("make_sam_entry4\n"));
1080
1081         sam->user_idx = user_idx;
1082         make_str_hdr(&(sam->hdr_acct_name), len_acct_name, len_acct_name,
1083                      len_acct_name != 0);
1084
1085         return True;
1086 }
1087
1088 /*******************************************************************
1089 reads or writes a SAM_ENTRY4 structure.
1090 ********************************************************************/
1091 static BOOL sam_io_sam_entry4(char *desc, SAM_ENTRY4 *sam, prs_struct *ps, int depth)
1092 {
1093         if (sam == NULL) return False;
1094
1095         prs_debug(ps, depth, desc, "sam_io_sam_entry4");
1096         depth++;
1097
1098         prs_align(ps);
1099
1100         prs_uint32("user_idx", ps, depth, &(sam->user_idx));
1101         smb_io_strhdr("strhdr", &(sam->hdr_acct_name), ps, depth);
1102
1103         return True;
1104 }
1105
1106 /*******************************************************************
1107 makes a SAM_ENTRY5 structure.
1108 ********************************************************************/
1109 static BOOL make_sam_entry5(SAM_ENTRY5 *sam, uint32 grp_idx,
1110                                 uint32 len_grp_name)
1111 {
1112         if (sam == NULL) return False;
1113
1114         DEBUG(5,("make_sam_entry5\n"));
1115
1116         sam->grp_idx = grp_idx;
1117         make_str_hdr(&(sam->hdr_grp_name), len_grp_name, len_grp_name,
1118                      len_grp_name != 0);
1119
1120         return True;
1121 }
1122
1123 /*******************************************************************
1124 reads or writes a SAM_ENTRY5 structure.
1125 ********************************************************************/
1126 static BOOL sam_io_sam_entry5(char *desc, SAM_ENTRY5 *sam, prs_struct *ps, int depth)
1127 {
1128         if (sam == NULL) return False;
1129
1130         prs_debug(ps, depth, desc, "sam_io_sam_entry5");
1131         depth++;
1132
1133         prs_align(ps);
1134
1135         prs_uint32("grp_idx", ps, depth, &(sam->grp_idx));
1136         smb_io_strhdr("strhdr", &(sam->hdr_grp_name), ps, depth);
1137
1138         return True;
1139 }
1140
1141 /*******************************************************************
1142 makes a SAM_ENTRY structure.
1143 ********************************************************************/
1144 static BOOL make_sam_entry(SAM_ENTRY *sam, uint32 len_sam_name, uint32 rid)
1145 {
1146         if (sam == NULL) return False;
1147
1148         DEBUG(10,("make_sam_entry: %d %d\n", len_sam_name, rid));
1149
1150         sam->rid = rid;
1151         make_uni_hdr(&(sam->hdr_name), len_sam_name);
1152
1153         return True;
1154 }
1155
1156 /*******************************************************************
1157 reads or writes a SAM_ENTRY structure.
1158 ********************************************************************/
1159 static BOOL sam_io_sam_entry(char *desc,  SAM_ENTRY *sam, prs_struct *ps, int depth)
1160 {
1161         if (sam == NULL) return False;
1162
1163         prs_debug(ps, depth, desc, "sam_io_sam_entry");
1164         depth++;
1165
1166         prs_align(ps);
1167         prs_uint32("rid", ps, depth, &(sam->rid ));
1168         smb_io_unihdr("unihdr", &(sam->hdr_name), ps, depth); /* account name unicode string header */
1169
1170         return True;
1171 }
1172
1173
1174 /*******************************************************************
1175 makes a SAMR_Q_ENUM_DOM_USERS structure.
1176 ********************************************************************/
1177 BOOL make_samr_q_enum_dom_users(SAMR_Q_ENUM_DOM_USERS *q_e, POLICY_HND *pol,
1178                                 uint32 start_idx,
1179                                 uint16 acb_mask, uint16 unk_1, uint32 size)
1180 {
1181         if (q_e == NULL || pol == NULL) return False;
1182
1183         DEBUG(5,("make_samr_q_enum_dom_users\n"));
1184
1185         memcpy(&(q_e->pol), pol, sizeof(*pol));
1186
1187         q_e->start_idx = start_idx; /* zero indicates lots */
1188         q_e->acb_mask  = acb_mask;
1189         q_e->unknown_1 = unk_1;
1190         q_e->max_size = size;
1191
1192         return True;
1193 }
1194
1195 /*******************************************************************
1196 reads or writes a structure.
1197 ********************************************************************/
1198 BOOL samr_io_q_enum_dom_users(char *desc,  SAMR_Q_ENUM_DOM_USERS *q_e, prs_struct *ps, int depth)
1199 {
1200         if (q_e == NULL) return False;
1201
1202         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_users");
1203         depth++;
1204
1205         prs_align(ps);
1206
1207         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
1208         prs_align(ps);
1209
1210         prs_uint32("start_idx", ps, depth, &(q_e->start_idx));
1211         prs_uint16("acb_mask ", ps, depth, &(q_e->acb_mask ));
1212         prs_uint16("unknown_1", ps, depth, &(q_e->unknown_1));
1213
1214         prs_uint32("max_size ", ps, depth, &(q_e->max_size ));
1215
1216         prs_align(ps);
1217
1218         return True;
1219 }
1220
1221
1222 /*******************************************************************
1223 makes a SAMR_R_ENUM_DOM_USERS structure.
1224 ********************************************************************/
1225 BOOL make_samr_r_enum_dom_users(SAMR_R_ENUM_DOM_USERS *r_u,
1226                 uint32 next_idx,
1227                 uint32 num_sam_entries, SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES], uint32 status)
1228 {
1229         uint32 i;
1230
1231         if (r_u == NULL) return False;
1232
1233         DEBUG(5,("make_samr_r_enum_dom_users\n"));
1234
1235         r_u->next_idx = next_idx;
1236         r_u->sam = NULL;
1237         r_u->uni_acct_name = NULL;
1238
1239         if (num_sam_entries != 0)
1240         {
1241                 r_u->ptr_entries1 = 1;
1242                 r_u->ptr_entries2 = 1;
1243                 r_u->num_entries2 = num_sam_entries;
1244                 r_u->num_entries3 = num_sam_entries;
1245
1246                 r_u->sam = (SAM_ENTRY*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->sam[0]));
1247                 r_u->uni_acct_name = (UNISTR2*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->uni_acct_name[0]));
1248
1249                 if (r_u->sam == NULL || r_u->uni_acct_name == NULL)
1250                 {
1251                         DEBUG(0,("NULL pointers in SAMR_R_QUERY_DISPINFO\n"));
1252                         return False;
1253                 }
1254
1255                 for (i = 0; i < num_sam_entries; i++)
1256                 {
1257                         make_sam_entry(&(r_u->sam[i]),
1258                                        pass[i].uni_user_name.uni_str_len,
1259                                        pass[i].user_rid);
1260
1261                         copy_unistr2(&(r_u->uni_acct_name[i]), &(pass[i].uni_user_name));
1262                 }
1263
1264                 r_u->num_entries4 = num_sam_entries;
1265         }
1266         else
1267         {
1268                 r_u->ptr_entries1 = 0;
1269                 r_u->num_entries2 = num_sam_entries;
1270                 r_u->ptr_entries2 = 1;
1271         }
1272
1273         r_u->status = status;
1274
1275         return True;
1276 }
1277
1278 /*******************************************************************
1279 reads or writes a structure.
1280 ********************************************************************/
1281 BOOL samr_io_r_enum_dom_users(char *desc, SAMR_R_ENUM_DOM_USERS *r_u, prs_struct *ps, int depth)
1282 {
1283         uint32 i;
1284
1285         if (r_u == NULL) return False;
1286
1287         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_users");
1288         depth++;
1289
1290         prs_align(ps);
1291
1292         prs_uint32("next_idx    ", ps, depth, &(r_u->next_idx    ));
1293         prs_uint32("ptr_entries1", ps, depth, &(r_u->ptr_entries1));
1294
1295         if (r_u->ptr_entries1 != 0)
1296         {
1297                 prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
1298                 prs_uint32("ptr_entries2", ps, depth, &(r_u->ptr_entries2));
1299                 prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
1300
1301                 if (ps->io)
1302                 {
1303                         r_u->sam = (SAM_ENTRY*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->sam[0]));
1304                         r_u->uni_acct_name = (UNISTR2*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->uni_acct_name[0]));
1305                 }
1306
1307                 if ((r_u->sam == NULL || r_u->uni_acct_name == NULL) && r_u->num_entries2 != 0)
1308                 {
1309                         DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_USERS\n"));
1310                         r_u->num_entries4 = 0;
1311                         r_u->status = 0xC0000000|NT_STATUS_MEMORY_NOT_ALLOCATED;
1312                         return False;
1313                 }
1314
1315                 for (i = 0; i < r_u->num_entries2; i++)
1316                 {
1317                         sam_io_sam_entry("", &(r_u->sam[i]), ps, depth);
1318                 }
1319
1320                 for (i = 0; i < r_u->num_entries2; i++)
1321                 {
1322                         smb_io_unistr2("", &(r_u->uni_acct_name[i]), r_u->sam[i].hdr_name.buffer, ps, depth);
1323                         prs_align(ps);
1324                 }
1325
1326                 prs_align(ps);
1327
1328         }
1329
1330         prs_uint32("num_entries4", ps, depth, &(r_u->num_entries4));
1331         prs_uint32("status", ps, depth, &(r_u->status));
1332
1333         return True;
1334 }
1335
1336 /*******************************************************************
1337 makes a SAMR_Q_QUERY_DISPINFO structure.
1338 ********************************************************************/
1339 BOOL make_samr_q_query_dispinfo(SAMR_Q_QUERY_DISPINFO *q_e, POLICY_HND *pol,
1340                                 uint16 switch_level, uint32 start_idx,
1341                                 uint32 max_entries)
1342 {
1343         if (q_e == NULL || pol == NULL) return False;
1344
1345         DEBUG(5,("make_samr_q_query_dispinfo\n"));
1346
1347         memcpy(&(q_e->domain_pol), pol, sizeof(*pol));
1348
1349         q_e->switch_level = switch_level;
1350
1351         q_e->start_idx = start_idx;
1352         q_e->max_entries = max_entries;
1353         q_e->max_size = 0xffff; /* Not especially useful */
1354
1355         return True;
1356 }
1357
1358 /*******************************************************************
1359 reads or writes a structure.
1360 ********************************************************************/
1361 BOOL samr_io_q_query_dispinfo(char *desc,  SAMR_Q_QUERY_DISPINFO *q_e, prs_struct *ps, int depth)
1362 {
1363         if (q_e == NULL) return False;
1364
1365         prs_debug(ps, depth, desc, "samr_io_q_query_dispinfo");
1366         depth++;
1367
1368         prs_align(ps);
1369
1370         smb_io_pol_hnd("domain_pol", &(q_e->domain_pol), ps, depth);
1371         prs_align(ps);
1372
1373         prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
1374         prs_align(ps);
1375
1376         prs_uint32("start_idx   ", ps, depth, &(q_e->start_idx   ));
1377         prs_uint32("max_entries ", ps, depth, &(q_e->max_entries ));
1378         prs_uint32("max_size    ", ps, depth, &(q_e->max_size    ));
1379
1380         return True;
1381 }
1382
1383
1384 /*******************************************************************
1385 makes a SAM_DISPINFO_1 structure.
1386 ********************************************************************/
1387 BOOL make_sam_dispinfo_1(SAM_DISPINFO_1 *sam, uint32 *num_entries,
1388                          uint32 *data_size, uint32 start_idx,
1389                          SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
1390 {
1391         uint32 len_sam_name, len_sam_full, len_sam_desc;
1392         uint32 max_entries, max_data_size;
1393         uint32 dsize = 0;
1394         uint32 i;
1395
1396         if (sam == NULL || num_entries == NULL || data_size == NULL) return False;
1397
1398         DEBUG(5,("make_sam_dispinfo_1\n"));
1399
1400         max_entries = *num_entries;
1401         max_data_size = *data_size;
1402
1403         for (i = 0; (i < max_entries) && (dsize < max_data_size); i++)
1404         {
1405                 len_sam_name = pass[i].uni_user_name.uni_str_len;
1406                 len_sam_full = pass[i].uni_full_name.uni_str_len;
1407                 len_sam_desc = pass[i].uni_acct_desc.uni_str_len;
1408
1409                 make_sam_entry1(&(sam->sam[i]), start_idx + i + 1,
1410                                 len_sam_name, len_sam_full, len_sam_desc,
1411                                 pass[i].user_rid, pass[i].acb_info);
1412
1413                 copy_unistr2(&(sam->str[i].uni_acct_name), &(pass[i].uni_user_name));
1414                 copy_unistr2(&(sam->str[i].uni_full_name), &(pass[i].uni_full_name));
1415                 copy_unistr2(&(sam->str[i].uni_acct_desc), &(pass[i].uni_acct_desc));
1416
1417                 dsize += sizeof(SAM_ENTRY1);
1418                 dsize += len_sam_name + len_sam_full + len_sam_desc;
1419         }
1420
1421         *num_entries = i;
1422         *data_size = dsize;
1423
1424         return True;
1425 }
1426
1427 /*******************************************************************
1428 reads or writes a structure.
1429 ********************************************************************/
1430 static BOOL sam_io_sam_dispinfo_1(char *desc, SAM_DISPINFO_1 *sam, uint32 num_entries, prs_struct *ps, int depth)
1431 {
1432         uint32 i;
1433
1434         if (sam == NULL) return False;
1435
1436         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_1");
1437         depth++;
1438
1439         prs_align(ps);
1440
1441         SMB_ASSERT_ARRAY(sam->sam, num_entries);
1442
1443         for (i = 0; i < num_entries; i++)
1444         {
1445                 sam_io_sam_entry1("", &(sam->sam[i]), ps, depth);
1446         }
1447
1448         for (i = 0; i < num_entries; i++)
1449         {
1450                 sam_io_sam_str1 ("", &(sam->str[i]),
1451                                  sam->sam[i].hdr_acct_name.buffer,
1452                                  sam->sam[i].hdr_user_name.buffer,
1453                                  sam->sam[i].hdr_user_desc.buffer,
1454                                  ps, depth);
1455         }
1456
1457         return True;
1458 }
1459
1460
1461 /*******************************************************************
1462 makes a SAM_DISPINFO_2 structure.
1463 ********************************************************************/
1464 BOOL make_sam_dispinfo_2(SAM_DISPINFO_2 *sam, uint32 *num_entries,
1465                          uint32 *data_size, uint32 start_idx,
1466                          SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
1467 {
1468         uint32 len_sam_name, len_sam_desc;
1469         uint32 max_entries, max_data_size;
1470         uint32 dsize = 0;
1471         uint32 i;
1472
1473         if (sam == NULL || num_entries == NULL || data_size == NULL) return False;
1474
1475         DEBUG(5,("make_sam_dispinfo_2\n"));
1476
1477         max_entries = *num_entries;
1478         max_data_size = *data_size;
1479
1480         for (i = 0; (i < max_entries) && (dsize < max_data_size); i++)
1481         {
1482                 len_sam_name = pass[i].uni_user_name.uni_str_len;
1483                 len_sam_desc = pass[i].uni_acct_desc.uni_str_len;
1484
1485                 make_sam_entry2(&(sam->sam[i]), start_idx + i + 1,
1486                                 len_sam_name, len_sam_desc,
1487                                 pass[i].user_rid, pass[i].acb_info);
1488
1489                 copy_unistr2(&(sam->str[i].uni_srv_name), &(pass[i].uni_user_name));
1490                 copy_unistr2(&(sam->str[i].uni_srv_desc), &(pass[i].uni_acct_desc));
1491
1492                 dsize += sizeof(SAM_ENTRY2);
1493                 dsize += len_sam_name + len_sam_desc;
1494         }
1495
1496         *num_entries = i;
1497         *data_size = dsize;
1498
1499         return True;
1500 }
1501
1502 /*******************************************************************
1503 reads or writes a structure.
1504 ********************************************************************/
1505 static BOOL sam_io_sam_dispinfo_2(char *desc, SAM_DISPINFO_2 *sam, uint32 num_entries, prs_struct *ps, int depth)
1506 {
1507         uint32 i;
1508
1509         if (sam == NULL) return False;
1510
1511         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_2");
1512         depth++;
1513
1514         prs_align(ps);
1515
1516         SMB_ASSERT_ARRAY(sam->sam, num_entries);
1517
1518         for (i = 0; i < num_entries; i++)
1519         {
1520                 sam_io_sam_entry2("", &(sam->sam[i]), ps, depth);
1521         }
1522
1523         for (i = 0; i < num_entries; i++)
1524         {
1525                 sam_io_sam_str2 ("", &(sam->str[i]),
1526                                  sam->sam[i].hdr_srv_name.buffer,
1527                                  sam->sam[i].hdr_srv_desc.buffer,
1528                                  ps, depth);
1529         }
1530
1531         return True;
1532 }
1533
1534
1535 /*******************************************************************
1536 makes a SAM_DISPINFO_3 structure.
1537 ********************************************************************/
1538 BOOL make_sam_dispinfo_3(SAM_DISPINFO_3 *sam, uint32 *num_entries,
1539                          uint32 *data_size, uint32 start_idx,
1540                          DOMAIN_GRP *grp)
1541 {
1542         uint32 len_sam_name, len_sam_desc;
1543         uint32 max_entries, max_data_size;
1544         uint32 dsize = 0;
1545         uint32 i;
1546
1547         if (sam == NULL || num_entries == NULL || data_size == NULL) return False;
1548
1549         DEBUG(5,("make_sam_dispinfo_3\n"));
1550
1551         max_entries = *num_entries;
1552         max_data_size = *data_size;
1553
1554         for (i = 0; (i < max_entries) && (dsize < max_data_size); i++)
1555         {
1556                 len_sam_name = strlen(grp[i].name);
1557                 len_sam_desc = strlen(grp[i].comment);
1558
1559                 make_sam_entry3(&(sam->sam[i]), start_idx + i + 1,
1560                                 len_sam_name, len_sam_desc,
1561                                 grp[i].rid);
1562
1563                 make_unistr2(&(sam->str[i].uni_grp_name), grp[i].name   , len_sam_name);
1564                 make_unistr2(&(sam->str[i].uni_grp_desc), grp[i].comment, len_sam_desc);
1565
1566                 dsize += sizeof(SAM_ENTRY3);
1567                 dsize += (len_sam_name + len_sam_desc) * 2;
1568         }
1569
1570         *num_entries = i;
1571         *data_size = dsize;
1572
1573         return True;
1574 }
1575
1576 /*******************************************************************
1577 reads or writes a structure.
1578 ********************************************************************/
1579 static BOOL sam_io_sam_dispinfo_3(char *desc, SAM_DISPINFO_3 *sam, uint32 num_entries, prs_struct *ps, int depth)
1580 {
1581         uint32 i;
1582
1583         if (sam == NULL) return False;
1584
1585         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_3");
1586         depth++;
1587
1588         prs_align(ps);
1589
1590         SMB_ASSERT_ARRAY(sam->sam, num_entries);
1591
1592         for (i = 0; i < num_entries; i++)
1593         {
1594                 sam_io_sam_entry3("", &(sam->sam[i]), ps, depth);
1595         }
1596
1597         for (i = 0; i < num_entries; i++)
1598         {
1599                 sam_io_sam_str3 ("", &(sam->str[i]),
1600                                  sam->sam[i].hdr_grp_name.buffer,
1601                                  sam->sam[i].hdr_grp_desc.buffer,
1602                                  ps, depth);
1603         }
1604
1605         return True;
1606 }
1607
1608
1609 /*******************************************************************
1610 makes a SAM_DISPINFO_4 structure.
1611 ********************************************************************/
1612 BOOL make_sam_dispinfo_4(SAM_DISPINFO_4 *sam, uint32 *num_entries,
1613                          uint32 *data_size, uint32 start_idx,
1614                          SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
1615 {
1616         fstring sam_name;
1617         uint32 len_sam_name;
1618         uint32 max_entries, max_data_size;
1619         uint32 dsize = 0;
1620         uint32 i;
1621
1622         if (sam == NULL || num_entries == NULL || data_size == NULL) return False;
1623
1624         DEBUG(5,("make_sam_dispinfo_4\n"));
1625
1626         max_entries = *num_entries;
1627         max_data_size = *data_size;
1628
1629         for (i = 0; (i < max_entries) && (dsize < max_data_size); i++)
1630         {
1631                 len_sam_name = pass[i].uni_user_name.uni_str_len;
1632
1633                 make_sam_entry4(&(sam->sam[i]), start_idx + i + 1,
1634                                 len_sam_name);
1635
1636                 unistr2_to_ascii(sam_name, &(pass[i].uni_user_name), sizeof(sam_name));
1637                 make_string2(&(sam->str[i].acct_name), sam_name, len_sam_name);
1638
1639                 dsize += sizeof(SAM_ENTRY4);
1640                 dsize += len_sam_name;
1641         }
1642
1643         *num_entries = i;
1644         *data_size = dsize;
1645
1646         return True;
1647 }
1648
1649 /*******************************************************************
1650 reads or writes a structure.
1651 ********************************************************************/
1652 static BOOL sam_io_sam_dispinfo_4(char *desc, SAM_DISPINFO_4 *sam, uint32 num_entries, prs_struct *ps, int depth)
1653 {
1654         uint32 i;
1655
1656         if (sam == NULL) return False;
1657
1658         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_4");
1659         depth++;
1660
1661         prs_align(ps);
1662
1663         SMB_ASSERT_ARRAY(sam->sam, num_entries);
1664
1665         for (i = 0; i < num_entries; i++)
1666         {
1667                 sam_io_sam_entry4("", &(sam->sam[i]), ps, depth);
1668         }
1669
1670         for (i = 0; i < num_entries; i++)
1671         {
1672                 smb_io_string2("acct_name", &(sam->str[i].acct_name),
1673                                sam->sam[i].hdr_acct_name.buffer, ps, depth);
1674         }
1675
1676         return True;
1677 }
1678
1679
1680 /*******************************************************************
1681 makes a SAM_DISPINFO_5 structure.
1682 ********************************************************************/
1683 BOOL make_sam_dispinfo_5(SAM_DISPINFO_5 *sam, uint32 *num_entries,
1684                          uint32 *data_size, uint32 start_idx,
1685                          DOMAIN_GRP *grp)
1686 {
1687         uint32 len_sam_name;
1688         uint32 max_entries, max_data_size;
1689         uint32 dsize = 0;
1690         uint32 i;
1691
1692         if (sam == NULL || num_entries == NULL || data_size == NULL) return False;
1693
1694         DEBUG(5,("make_sam_dispinfo_5\n"));
1695
1696         max_entries = *num_entries;
1697         max_data_size = *data_size;
1698
1699         for (i = 0; (i < max_entries) && (dsize < max_data_size); i++)
1700         {
1701                 len_sam_name = strlen(grp[i].name);
1702
1703                 make_sam_entry5(&(sam->sam[i]), start_idx + i + 1,
1704                                 len_sam_name);
1705
1706                 make_string2(&(sam->str[i].grp_name), grp[i].name,
1707                              len_sam_name);
1708
1709                 dsize += sizeof(SAM_ENTRY5);
1710                 dsize += len_sam_name;
1711         }
1712
1713         *num_entries = i;
1714         *data_size = dsize;
1715
1716         return True;
1717 }
1718
1719 /*******************************************************************
1720 reads or writes a structure.
1721 ********************************************************************/
1722 static BOOL sam_io_sam_dispinfo_5(char *desc, SAM_DISPINFO_5 *sam, uint32 num_entries, prs_struct *ps, int depth)
1723 {
1724         uint32 i;
1725
1726         if (sam == NULL) return False;
1727
1728         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_5");
1729         depth++;
1730
1731         prs_align(ps);
1732
1733         SMB_ASSERT_ARRAY(sam->sam, num_entries);
1734
1735         for (i = 0; i < num_entries; i++)
1736         {
1737                 sam_io_sam_entry5("", &(sam->sam[i]), ps, depth);
1738         }
1739
1740         for (i = 0; i < num_entries; i++)
1741         {
1742                 smb_io_string2("grp_name", &(sam->str[i].grp_name),
1743                                sam->sam[i].hdr_grp_name.buffer, ps, depth);
1744         }
1745
1746         return True;
1747 }
1748
1749
1750 /*******************************************************************
1751 makes a SAMR_R_QUERY_DISPINFO structure.
1752 ********************************************************************/
1753 BOOL make_samr_r_query_dispinfo(SAMR_R_QUERY_DISPINFO *r_u,
1754                                 uint32 num_entries, uint32 data_size,
1755                                 uint16 switch_level, SAM_DISPINFO_CTR *ctr,
1756                                 uint32 status)
1757 {
1758         if (r_u == NULL) return False;
1759
1760         DEBUG(5,("make_samr_r_query_dispinfo: level %d\n", switch_level));
1761
1762         r_u->total_size = 0; /* not calculated */
1763         r_u->data_size = data_size;
1764
1765         r_u->switch_level = switch_level;
1766         r_u->num_entries = num_entries;
1767         r_u->ptr_entries = 1;
1768         r_u->num_entries2 = num_entries;
1769         r_u->ctr = ctr;
1770
1771         r_u->status = status;
1772
1773         return True;
1774 }
1775
1776
1777 /*******************************************************************
1778 reads or writes a structure.
1779 ********************************************************************/
1780 BOOL samr_io_r_query_dispinfo(char *desc, SAMR_R_QUERY_DISPINFO *r_u, prs_struct *ps, int depth)
1781 {
1782         if (r_u == NULL) return False;
1783
1784         prs_debug(ps, depth, desc, "samr_io_r_query_dispinfo");
1785         depth++;
1786
1787         prs_align(ps);
1788
1789         prs_uint32("total_size  ", ps, depth, &(r_u->total_size  ));
1790         prs_uint32("data_size   ", ps, depth, &(r_u->data_size   ));
1791         prs_uint16("switch_level", ps, depth, &(r_u->switch_level));
1792         prs_align(ps);
1793
1794         prs_uint32("num_entries ", ps, depth, &(r_u->num_entries ));
1795         prs_uint32("ptr_entries ", ps, depth, &(r_u->ptr_entries ));
1796         prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
1797
1798         switch (r_u->switch_level)
1799         {
1800                 case 0x1:
1801                 {
1802                         sam_io_sam_dispinfo_1("users", r_u->ctr->sam.info1, r_u->num_entries, ps, depth);
1803                         break;
1804                 }
1805                 case 0x2:
1806                 {
1807                         sam_io_sam_dispinfo_2("servers", r_u->ctr->sam.info2, r_u->num_entries, ps, depth);
1808                         break;
1809                 }
1810                 case 0x3:
1811                 {
1812                         sam_io_sam_dispinfo_3("groups", r_u->ctr->sam.info3, r_u->num_entries, ps, depth);
1813                         break;
1814                 }
1815                 case 0x4:
1816                 {
1817                         sam_io_sam_dispinfo_4("user list", r_u->ctr->sam.info4,r_u->num_entries, ps, depth);
1818                         break;
1819                 }
1820                 case 0x5:
1821                 {
1822                         sam_io_sam_dispinfo_5("group list", r_u->ctr->sam.info5, r_u->num_entries, ps, depth);
1823                         break;
1824                 }
1825                 default:
1826                 {
1827                         DEBUG(5,("samr_io_r_query_dispinfo: unknown switch value\n"));
1828                         break;
1829                 }
1830         }
1831
1832         prs_align(ps);
1833         prs_align(ps);
1834         prs_uint32("status", ps, depth, &(r_u->status));
1835
1836         return True;
1837 }
1838
1839
1840 /*******************************************************************
1841 makes a SAMR_Q_OPEN_GROUP structure.
1842 ********************************************************************/
1843 BOOL make_samr_q_open_group(SAMR_Q_OPEN_GROUP *q_c,
1844                                 const POLICY_HND *hnd, uint32 unk, uint32 rid)
1845 {
1846         if (q_c == NULL || hnd == NULL) return False;
1847
1848         DEBUG(5,("make_samr_q_open_group\n"));
1849
1850         memcpy(&(q_c->domain_pol), hnd, sizeof(q_c->domain_pol));
1851         q_c->unknown = unk;
1852         q_c->rid_group = rid;
1853
1854         return True;
1855 }
1856
1857 /*******************************************************************
1858 reads or writes a structure.
1859 ********************************************************************/
1860 BOOL samr_io_q_open_group(char *desc,  SAMR_Q_OPEN_GROUP *q_u, prs_struct *ps, int depth)
1861 {
1862         if (q_u == NULL) return False;
1863
1864         prs_debug(ps, depth, desc, "samr_io_q_open_group");
1865         depth++;
1866
1867         prs_align(ps);
1868
1869         smb_io_pol_hnd("domain_pol", &(q_u->domain_pol), ps, depth);
1870
1871         prs_uint32("unknown  ", ps, depth, &(q_u->unknown  ));
1872         prs_uint32("rid_group", ps, depth, &(q_u->rid_group));
1873
1874         return True;
1875 }
1876
1877 /*******************************************************************
1878 reads or writes a structure.
1879 ********************************************************************/
1880 BOOL samr_io_r_open_group(char *desc,  SAMR_R_OPEN_GROUP *r_u, prs_struct *ps, int depth)
1881 {
1882         if (r_u == NULL) return False;
1883
1884         prs_debug(ps, depth, desc, "samr_io_r_open_group");
1885         depth++;
1886
1887         prs_align(ps);
1888
1889         smb_io_pol_hnd("pol", &(r_u->pol), ps, depth);
1890         prs_align(ps);
1891
1892         prs_uint32("status", ps, depth, &(r_u->status));
1893
1894         return True;
1895 }
1896
1897
1898 /*******************************************************************
1899 makes a GROUP_INFO1 structure.
1900 ********************************************************************/
1901 BOOL make_samr_group_info1(GROUP_INFO1 *gr1,
1902                                 char *acct_name, char *acct_desc,
1903                                 uint32 num_members)
1904 {
1905         int desc_len = acct_desc != NULL ? strlen(acct_desc) : 0;
1906         int acct_len = acct_name != NULL ? strlen(acct_name) : 0;
1907         if (gr1 == NULL) return False;
1908
1909         DEBUG(5,("make_samr_group_info1\n"));
1910
1911         make_uni_hdr(&(gr1->hdr_acct_name), acct_len);
1912
1913         gr1->unknown_1 = 0x3;
1914         gr1->num_members = num_members;
1915
1916         make_uni_hdr(&(gr1->hdr_acct_desc), desc_len);
1917
1918         make_unistr2(&(gr1->uni_acct_name), acct_name, acct_len);
1919         make_unistr2(&(gr1->uni_acct_desc), acct_desc, desc_len);
1920
1921         return True;
1922 }
1923
1924
1925 /*******************************************************************
1926 reads or writes a structure.
1927 ********************************************************************/
1928 BOOL samr_io_group_info1(char *desc,  GROUP_INFO1 *gr1, prs_struct *ps, int depth)
1929 {
1930         if (gr1 == NULL) return False;
1931
1932         prs_debug(ps, depth, desc, "samr_io_group_info1");
1933         depth++;
1934
1935         prs_align(ps);
1936
1937         smb_io_unihdr ("hdr_acct_name", &(gr1->hdr_acct_name) , ps, depth);
1938
1939         prs_uint32("unknown_1", ps, depth, &(gr1->unknown_1));
1940         prs_uint32("num_members", ps, depth, &(gr1->num_members));
1941
1942         smb_io_unihdr ("hdr_acct_desc", &(gr1->hdr_acct_desc) , ps, depth);
1943
1944         smb_io_unistr2("uni_acct_name", &(gr1->uni_acct_name), gr1->hdr_acct_name.buffer, ps, depth);
1945         prs_align(ps);
1946
1947         smb_io_unistr2("uni_acct_desc", &(gr1->uni_acct_desc), gr1->hdr_acct_desc.buffer, ps, depth);
1948         prs_align(ps);
1949
1950         return True;
1951 }
1952
1953 /*******************************************************************
1954 makes a GROUP_INFO4 structure.
1955 ********************************************************************/
1956 BOOL make_samr_group_info4(GROUP_INFO4 *gr4, const char *acct_desc)
1957 {
1958         int acct_len = acct_desc != NULL ? strlen(acct_desc) : 0;
1959         if (gr4 == NULL) return False;
1960
1961         DEBUG(5,("make_samr_group_info4\n"));
1962
1963         make_uni_hdr(&(gr4->hdr_acct_desc), acct_len);
1964         make_unistr2(&(gr4->uni_acct_desc), acct_desc, acct_len);
1965
1966         return True;
1967 }
1968
1969
1970 /*******************************************************************
1971 reads or writes a structure.
1972 ********************************************************************/
1973 BOOL samr_io_group_info4(char *desc,  GROUP_INFO4 *gr4, prs_struct *ps, int depth)
1974 {
1975         if (gr4 == NULL) return False;
1976
1977         prs_debug(ps, depth, desc, "samr_io_group_info4");
1978         depth++;
1979
1980         prs_align(ps);
1981
1982         smb_io_unihdr ("hdr_acct_desc", &(gr4->hdr_acct_desc) , ps, depth);
1983         smb_io_unistr2("uni_acct_desc", &(gr4->uni_acct_desc), gr4->hdr_acct_desc.buffer, ps, depth);
1984         prs_align(ps);
1985
1986         return True;
1987 }
1988
1989 /*******************************************************************
1990 reads or writes a structure.
1991 ********************************************************************/
1992 BOOL samr_group_info_ctr(char *desc,  GROUP_INFO_CTR *ctr, prs_struct *ps, int depth)
1993 {
1994         if (ctr == NULL) return False;
1995
1996         prs_debug(ps, depth, desc, "samr_group_info_ctr");
1997         depth++;
1998
1999         prs_uint16("switch_value1", ps, depth, &(ctr->switch_value1));
2000         prs_uint16("switch_value2", ps, depth, &(ctr->switch_value2));
2001
2002         switch (ctr->switch_value1)
2003         {
2004                 case 1:
2005                 {
2006                         samr_io_group_info1("group_info1", &(ctr->group.info1), ps, depth);
2007                         break;
2008                 }
2009                 case 4:
2010                 {
2011                         samr_io_group_info4("group_info4", &(ctr->group.info4), ps, depth);
2012                         break;
2013                 }
2014                 default:
2015                 {
2016                         DEBUG(4,("samr_group_info_ctr: unsupported switch level\n"));
2017                         break;
2018                 }
2019         }
2020
2021         prs_align(ps);
2022
2023         return True;
2024 }
2025
2026
2027 /*******************************************************************
2028 makes a SAMR_Q_CREATE_DOM_GROUP structure.
2029 ********************************************************************/
2030 BOOL make_samr_q_create_dom_group(SAMR_Q_CREATE_DOM_GROUP *q_e,
2031                                 POLICY_HND *pol,
2032                                 const char *acct_desc)
2033 {
2034         int acct_len = acct_desc != NULL ? strlen(acct_desc) : 0;
2035         if (q_e == NULL || pol == NULL) return False;
2036
2037         DEBUG(5,("make_samr_q_create_dom_group\n"));
2038
2039         memcpy(&(q_e->pol), pol, sizeof(*pol));
2040
2041         make_uni_hdr(&(q_e->hdr_acct_desc), acct_len);
2042         make_unistr2(&(q_e->uni_acct_desc), acct_desc, acct_len);
2043
2044         q_e->unknown_1 = 0x0002;
2045         q_e->unknown_2 = 0x0001;
2046
2047         return True;
2048 }
2049
2050
2051 /*******************************************************************
2052 reads or writes a structure.
2053 ********************************************************************/
2054 BOOL samr_io_q_create_dom_group(char *desc,  SAMR_Q_CREATE_DOM_GROUP *q_e, prs_struct *ps, int depth)
2055 {
2056         if (q_e == NULL) return False;
2057
2058         prs_debug(ps, depth, desc, "samr_io_q_create_dom_group");
2059         depth++;
2060
2061         prs_align(ps);
2062
2063         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
2064         prs_align(ps);
2065
2066         smb_io_unihdr ("hdr_acct_desc", &(q_e->hdr_acct_desc), ps, depth);
2067         smb_io_unistr2("uni_acct_desc", &(q_e->uni_acct_desc), q_e->hdr_acct_desc.buffer, ps, depth);
2068         prs_align(ps);
2069
2070         prs_uint16("unknown_1", ps, depth, &(q_e->unknown_1));
2071         prs_uint16("unknown_2", ps, depth, &(q_e->unknown_2));
2072
2073         return True;
2074 }
2075
2076
2077 /*******************************************************************
2078 makes a SAMR_R_CREATE_DOM_GROUP structure.
2079 ********************************************************************/
2080 BOOL make_samr_r_create_dom_group(SAMR_R_CREATE_DOM_GROUP *r_u, POLICY_HND *pol,
2081                 uint32 rid, uint32 status)
2082 {
2083         if (r_u == NULL) return False;
2084
2085         DEBUG(5,("make_samr_r_create_dom_group\n"));
2086
2087         memcpy(&(r_u->pol), pol, sizeof(*pol));
2088
2089         r_u->rid    = rid   ;
2090         r_u->status = status;
2091
2092         return True;
2093 }
2094
2095
2096 /*******************************************************************
2097 reads or writes a structure.
2098 ********************************************************************/
2099 BOOL samr_io_r_create_dom_group(char *desc,  SAMR_R_CREATE_DOM_GROUP *r_u, prs_struct *ps, int depth)
2100 {
2101         if (r_u == NULL) return False;
2102
2103         prs_debug(ps, depth, desc, "samr_io_r_create_dom_group");
2104         depth++;
2105
2106         prs_align(ps);
2107
2108         smb_io_pol_hnd("pol", &(r_u->pol), ps, depth);
2109         prs_align(ps);
2110
2111         prs_uint32("rid   ", ps, depth, &(r_u->rid   ));
2112         prs_uint32("status", ps, depth, &(r_u->status));
2113
2114         return True;
2115 }
2116
2117 /*******************************************************************
2118 makes a SAMR_Q_DELETE_DOM_GROUP structure.
2119 ********************************************************************/
2120 BOOL make_samr_q_delete_dom_group(SAMR_Q_DELETE_DOM_GROUP *q_c, POLICY_HND *hnd)
2121 {
2122         if (q_c == NULL || hnd == NULL) return False;
2123
2124         DEBUG(5,("make_samr_q_delete_dom_group\n"));
2125
2126         memcpy(&(q_c->group_pol), hnd, sizeof(q_c->group_pol));
2127
2128         return True;
2129 }
2130
2131 /*******************************************************************
2132 reads or writes a structure.
2133 ********************************************************************/
2134 BOOL samr_io_q_delete_dom_group(char *desc,  SAMR_Q_DELETE_DOM_GROUP *q_u, prs_struct *ps, int depth)
2135 {
2136         if (q_u == NULL) return False;
2137
2138         prs_debug(ps, depth, desc, "samr_io_q_delete_dom_group");
2139         depth++;
2140
2141         prs_align(ps);
2142
2143         smb_io_pol_hnd("group_pol", &(q_u->group_pol), ps, depth);
2144
2145         return True;
2146 }
2147
2148 /*******************************************************************
2149 makes a SAMR_R_DELETE_DOM_GROUP structure.
2150 ********************************************************************/
2151 BOOL make_samr_r_delete_dom_group(SAMR_R_DELETE_DOM_GROUP *r_u,
2152                 uint32 status)
2153 {
2154         if (r_u == NULL) return False;
2155
2156         DEBUG(5,("make_samr_r_delete_dom_group\n"));
2157
2158         r_u->status = status;
2159
2160         return True;
2161 }
2162
2163 /*******************************************************************
2164 reads or writes a structure.
2165 ********************************************************************/
2166 BOOL samr_io_r_delete_dom_group(char *desc,  SAMR_R_DELETE_DOM_GROUP *r_u, prs_struct *ps, int depth)
2167 {
2168         if (r_u == NULL) return False;
2169
2170         prs_debug(ps, depth, desc, "samr_io_r_delete_dom_group");
2171         depth++;
2172
2173         prs_align(ps);
2174
2175         prs_uint32("status", ps, depth, &(r_u->status));
2176
2177         return True;
2178 }
2179
2180
2181
2182 /*******************************************************************
2183 makes a SAMR_Q_DEL_GROUPMEM structure.
2184 ********************************************************************/
2185 BOOL make_samr_q_del_groupmem(SAMR_Q_DEL_GROUPMEM *q_e,
2186                                 POLICY_HND *pol,
2187                                 uint32 rid)
2188 {
2189         if (q_e == NULL || pol == NULL) return False;
2190
2191         DEBUG(5,("make_samr_q_del_groupmem\n"));
2192
2193         memcpy(&(q_e->pol), pol, sizeof(*pol));
2194
2195         q_e->rid = rid;
2196
2197         return True;
2198 }
2199
2200
2201 /*******************************************************************
2202 reads or writes a structure.
2203 ********************************************************************/
2204 BOOL samr_io_q_del_groupmem(char *desc,  SAMR_Q_DEL_GROUPMEM *q_e, prs_struct *ps, int depth)
2205 {
2206         if (q_e == NULL) return False;
2207
2208         prs_debug(ps, depth, desc, "samr_io_q_del_groupmem");
2209         depth++;
2210
2211         prs_align(ps);
2212
2213         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
2214         prs_align(ps);
2215
2216         prs_uint32("rid    ", ps, depth, &(q_e->rid));
2217
2218         return True;
2219 }
2220
2221
2222 /*******************************************************************
2223 makes a SAMR_R_DEL_GROUPMEM structure.
2224 ********************************************************************/
2225 BOOL make_samr_r_del_groupmem(SAMR_R_DEL_GROUPMEM *r_u, POLICY_HND *pol,
2226                 uint32 status)
2227 {
2228         if (r_u == NULL) return False;
2229
2230         DEBUG(5,("make_samr_r_del_groupmem\n"));
2231
2232         r_u->status = status;
2233
2234         return True;
2235 }
2236
2237
2238 /*******************************************************************
2239 reads or writes a structure.
2240 ********************************************************************/
2241 BOOL samr_io_r_del_groupmem(char *desc,  SAMR_R_DEL_GROUPMEM *r_u, prs_struct *ps, int depth)
2242 {
2243         if (r_u == NULL) return False;
2244
2245         prs_debug(ps, depth, desc, "samr_io_r_del_groupmem");
2246         depth++;
2247
2248         prs_align(ps);
2249
2250         prs_uint32("status", ps, depth, &(r_u->status));
2251
2252         return True;
2253 }
2254
2255
2256 /*******************************************************************
2257 makes a SAMR_Q_ADD_GROUPMEM structure.
2258 ********************************************************************/
2259 BOOL make_samr_q_add_groupmem(SAMR_Q_ADD_GROUPMEM *q_e,
2260                                 POLICY_HND *pol,
2261                                 uint32 rid)
2262 {
2263         if (q_e == NULL || pol == NULL) return False;
2264
2265         DEBUG(5,("make_samr_q_add_groupmem\n"));
2266
2267         memcpy(&(q_e->pol), pol, sizeof(*pol));
2268
2269         q_e->rid = rid;
2270         q_e->unknown = 0x0005;
2271
2272         return True;
2273 }
2274
2275
2276 /*******************************************************************
2277 reads or writes a structure.
2278 ********************************************************************/
2279 BOOL samr_io_q_add_groupmem(char *desc,  SAMR_Q_ADD_GROUPMEM *q_e, prs_struct *ps, int depth)
2280 {
2281         if (q_e == NULL) return False;
2282
2283         prs_debug(ps, depth, desc, "samr_io_q_add_groupmem");
2284         depth++;
2285
2286         prs_align(ps);
2287
2288         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
2289         prs_align(ps);
2290
2291         prs_uint32("rid    ", ps, depth, &(q_e->rid));
2292         prs_uint32("unknown", ps, depth, &(q_e->unknown));
2293
2294         return True;
2295 }
2296
2297
2298 /*******************************************************************
2299 makes a SAMR_R_ADD_GROUPMEM structure.
2300 ********************************************************************/
2301 BOOL make_samr_r_add_groupmem(SAMR_R_ADD_GROUPMEM *r_u, POLICY_HND *pol,
2302                 uint32 status)
2303 {
2304         if (r_u == NULL) return False;
2305
2306         DEBUG(5,("make_samr_r_add_groupmem\n"));
2307
2308         r_u->status = status;
2309
2310         return True;
2311 }
2312
2313
2314 /*******************************************************************
2315 reads or writes a structure.
2316 ********************************************************************/
2317 BOOL samr_io_r_add_groupmem(char *desc,  SAMR_R_ADD_GROUPMEM *r_u, prs_struct *ps, int depth)
2318 {
2319         if (r_u == NULL) return False;
2320
2321         prs_debug(ps, depth, desc, "samr_io_r_add_groupmem");
2322         depth++;
2323
2324         prs_align(ps);
2325
2326         prs_uint32("status", ps, depth, &(r_u->status));
2327
2328         return True;
2329 }
2330
2331
2332 /*******************************************************************
2333 makes a SAMR_Q_SET_GROUPINFO structure.
2334 ********************************************************************/
2335 BOOL make_samr_q_set_groupinfo(SAMR_Q_SET_GROUPINFO *q_e,
2336                                 POLICY_HND *pol, GROUP_INFO_CTR *ctr)
2337 {
2338         if (q_e == NULL || pol == NULL) return False;
2339
2340         DEBUG(5,("make_samr_q_set_groupinfo\n"));
2341
2342         memcpy(&(q_e->pol), pol, sizeof(*pol));
2343         q_e->ctr = ctr;
2344
2345         return True;
2346 }
2347
2348
2349 /*******************************************************************
2350 reads or writes a structure.
2351 ********************************************************************/
2352 BOOL samr_io_q_set_groupinfo(char *desc,  SAMR_Q_SET_GROUPINFO *q_e, prs_struct *ps, int depth)
2353 {
2354         if (q_e == NULL) return False;
2355
2356         prs_debug(ps, depth, desc, "samr_io_q_set_groupinfo");
2357         depth++;
2358
2359         prs_align(ps);
2360
2361         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
2362         prs_align(ps);
2363
2364         samr_group_info_ctr("ctr", q_e->ctr, ps, depth);
2365
2366         return True;
2367 }
2368
2369
2370 /*******************************************************************
2371 makes a SAMR_R_SET_GROUPINFO structure.
2372 ********************************************************************/
2373 BOOL make_samr_r_set_groupinfo(SAMR_R_SET_GROUPINFO *r_u,
2374                 uint32 status)
2375 {
2376         if (r_u == NULL) return False;
2377
2378         DEBUG(5,("make_samr_r_set_groupinfo\n"));
2379
2380         r_u->status = status;
2381
2382         return True;
2383 }
2384
2385
2386 /*******************************************************************
2387 reads or writes a structure.
2388 ********************************************************************/
2389 BOOL samr_io_r_set_groupinfo(char *desc,  SAMR_R_SET_GROUPINFO *r_u, prs_struct *ps, int depth)
2390 {
2391         if (r_u == NULL) return False;
2392
2393         prs_debug(ps, depth, desc, "samr_io_r_set_groupinfo");
2394         depth++;
2395
2396         prs_align(ps);
2397
2398         prs_uint32("status", ps, depth, &(r_u->status));
2399
2400         return True;
2401 }
2402
2403 /*******************************************************************
2404 makes a SAMR_Q_QUERY_GROUPINFO structure.
2405 ********************************************************************/
2406 BOOL make_samr_q_query_groupinfo(SAMR_Q_QUERY_GROUPINFO *q_e,
2407                                 POLICY_HND *pol,
2408                                 uint16 switch_level)
2409 {
2410         if (q_e == NULL || pol == NULL) return False;
2411
2412         DEBUG(5,("make_samr_q_query_groupinfo\n"));
2413
2414         memcpy(&(q_e->pol), pol, sizeof(*pol));
2415
2416         q_e->switch_level = switch_level;
2417
2418         return True;
2419 }
2420
2421
2422 /*******************************************************************
2423 reads or writes a structure.
2424 ********************************************************************/
2425 BOOL samr_io_q_query_groupinfo(char *desc,  SAMR_Q_QUERY_GROUPINFO *q_e, prs_struct *ps, int depth)
2426 {
2427         if (q_e == NULL) return False;
2428
2429         prs_debug(ps, depth, desc, "samr_io_q_query_groupinfo");
2430         depth++;
2431
2432         prs_align(ps);
2433
2434         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
2435         prs_align(ps);
2436
2437         prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
2438
2439         return True;
2440 }
2441
2442
2443 /*******************************************************************
2444 makes a SAMR_R_QUERY_GROUPINFO structure.
2445 ********************************************************************/
2446 BOOL make_samr_r_query_groupinfo(SAMR_R_QUERY_GROUPINFO *r_u, GROUP_INFO_CTR *ctr,
2447                 uint32 status)
2448 {
2449         if (r_u == NULL) return False;
2450
2451         DEBUG(5,("make_samr_r_query_groupinfo\n"));
2452
2453         r_u->ptr = (status == 0x0 && ctr != NULL) ? 1 : 0;
2454         r_u->ctr = ctr;
2455         r_u->status = status;
2456
2457         return True;
2458 }
2459
2460
2461 /*******************************************************************
2462 reads or writes a structure.
2463 ********************************************************************/
2464 BOOL samr_io_r_query_groupinfo(char *desc,  SAMR_R_QUERY_GROUPINFO *r_u, prs_struct *ps, int depth)
2465 {
2466         if (r_u == NULL) return False;
2467
2468         prs_debug(ps, depth, desc, "samr_io_r_query_groupinfo");
2469         depth++;
2470
2471         prs_align(ps);
2472
2473         prs_uint32("ptr", ps, depth, &(r_u->ptr));
2474
2475         if (r_u->ptr != 0)
2476         {
2477                 samr_group_info_ctr("ctr", r_u->ctr, ps, depth);
2478         }
2479
2480         prs_uint32("status", ps, depth, &(r_u->status));
2481
2482         return True;
2483 }
2484
2485
2486 /*******************************************************************
2487 makes a SAMR_Q_QUERY_GROUPMEM structure.
2488 ********************************************************************/
2489 BOOL make_samr_q_query_groupmem(SAMR_Q_QUERY_GROUPMEM *q_c, POLICY_HND *hnd)
2490 {
2491         if (q_c == NULL || hnd == NULL) return False;
2492
2493         DEBUG(5,("make_samr_q_query_groupmem\n"));
2494
2495         memcpy(&(q_c->group_pol), hnd, sizeof(q_c->group_pol));
2496
2497         return True;
2498 }
2499
2500 /*******************************************************************
2501 reads or writes a structure.
2502 ********************************************************************/
2503 BOOL samr_io_q_query_groupmem(char *desc,  SAMR_Q_QUERY_GROUPMEM *q_u, prs_struct *ps, int depth)
2504 {
2505         if (q_u == NULL) return False;
2506
2507         prs_debug(ps, depth, desc, "samr_io_q_query_groupmem");
2508         depth++;
2509
2510         prs_align(ps);
2511
2512         smb_io_pol_hnd("group_pol", &(q_u->group_pol), ps, depth);
2513
2514         return True;
2515 }
2516
2517 /*******************************************************************
2518 makes a SAMR_R_QUERY_GROUPMEM structure.
2519 ********************************************************************/
2520 BOOL make_samr_r_query_groupmem(SAMR_R_QUERY_GROUPMEM *r_u,
2521                 uint32 num_entries, uint32 *rid, uint32 *attr, uint32 status)
2522 {
2523         if (r_u == NULL) return False;
2524
2525         DEBUG(5,("make_samr_r_query_groupmem\n"));
2526
2527         if (status == 0x0)
2528         {
2529                 r_u->ptr         = 1;
2530                 r_u->num_entries = num_entries;
2531
2532                 r_u->ptr_attrs = attr != NULL ? 1 : 0;
2533                 r_u->ptr_rids = rid != NULL ? 1 : 0;
2534
2535                 r_u->num_rids = num_entries;
2536                 r_u->rid  = rid;
2537
2538                 r_u->num_attrs = num_entries;
2539                 r_u->attr = attr;
2540         }
2541         else
2542         {
2543                 r_u->ptr         = 0;
2544                 r_u->num_entries = 0;
2545         }
2546
2547         r_u->status = status;
2548
2549         return True;
2550 }
2551
2552 /*******************************************************************
2553 reads or writes a structure.
2554 ********************************************************************/
2555 BOOL samr_io_r_query_groupmem(char *desc,  SAMR_R_QUERY_GROUPMEM *r_u, prs_struct *ps, int depth)
2556 {
2557         uint32 i;
2558
2559         if (r_u == NULL) return False;
2560
2561         prs_debug(ps, depth, desc, "samr_io_r_query_groupmem");
2562         depth++;
2563
2564         prs_align(ps);
2565
2566         prs_uint32("ptr", ps, depth, &(r_u->ptr));
2567         prs_uint32("num_entries ", ps, depth, &(r_u->num_entries));
2568
2569         if (r_u->ptr != 0)
2570         {
2571                 prs_uint32("ptr_rids ", ps, depth, &(r_u->ptr_rids ));
2572                 prs_uint32("ptr_attrs", ps, depth, &(r_u->ptr_attrs));
2573
2574                 if (r_u->ptr_rids != 0)
2575                 {
2576                         prs_uint32("num_rids", ps, depth, &(r_u->num_rids));
2577                         if (r_u->num_rids != 0)
2578                         {
2579                                 r_u->rid = (uint32*)Realloc(r_u->rid,
2580                                                        sizeof(r_u->rid[0]) *
2581                                                        r_u->num_rids);
2582                                 if (r_u->rid == NULL)
2583                                 {
2584                                         samr_free_r_query_groupmem(r_u);
2585                                         return False;
2586                                 }
2587                         }
2588                         for (i = 0; i < r_u->num_rids; i++)
2589                         {
2590                                 prs_uint32("", ps, depth, &(r_u->rid[i]));
2591                         }
2592                 }
2593
2594                 if (r_u->ptr_attrs != 0)
2595                 {
2596                         prs_uint32("num_attrs", ps, depth, &(r_u->num_attrs));
2597
2598                         if (r_u->num_attrs != 0)
2599                         {
2600                                 r_u->attr = (uint32*)Realloc(r_u->attr,
2601                                                        sizeof(r_u->attr[0]) *
2602                                                        r_u->num_attrs);
2603                                 if (r_u->attr == NULL)
2604                                 {
2605                                         samr_free_r_query_groupmem(r_u);
2606                                         return False;
2607                                 }
2608                         }
2609                         for (i = 0; i < r_u->num_attrs; i++)
2610                         {
2611                                 prs_uint32("", ps, depth, &(r_u->attr[i]));
2612                         }
2613                 }
2614         }
2615
2616         prs_uint32("status", ps, depth, &(r_u->status));
2617
2618         if (!ps->io)
2619         {
2620                 /* storing.  memory no longer needed */
2621                 samr_free_r_query_groupmem(r_u);
2622         }
2623
2624         return True;
2625 }
2626
2627
2628 /*******************************************************************
2629 frees a structure.
2630 ********************************************************************/
2631 void samr_free_r_query_groupmem(SAMR_R_QUERY_GROUPMEM *r_u)
2632 {
2633         if (r_u->rid != NULL)
2634         {
2635                 free(r_u->rid);
2636                 r_u->rid = NULL;
2637         }
2638         if (r_u->attr != NULL)
2639         {
2640                 free(r_u->attr);
2641                 r_u->attr = NULL;
2642         }
2643 }
2644
2645 /*******************************************************************
2646 makes a SAMR_Q_QUERY_USERGROUPS structure.
2647 ********************************************************************/
2648 BOOL make_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS *q_u,
2649                                 POLICY_HND *hnd)
2650 {
2651         if (q_u == NULL || hnd == NULL) return False;
2652
2653         DEBUG(5,("make_samr_q_query_usergroups\n"));
2654
2655         memcpy(&(q_u->pol), hnd, sizeof(q_u->pol));
2656
2657         return True;
2658 }
2659
2660
2661 /*******************************************************************
2662 reads or writes a structure.
2663 ********************************************************************/
2664 BOOL samr_io_q_query_usergroups(char *desc,  SAMR_Q_QUERY_USERGROUPS *q_u, prs_struct *ps, int depth)
2665 {
2666         if (q_u == NULL) return False;
2667
2668         prs_debug(ps, depth, desc, "samr_io_q_query_usergroups");
2669         depth++;
2670
2671         prs_align(ps);
2672
2673         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
2674         prs_align(ps);
2675
2676         return True;
2677 }
2678
2679 /*******************************************************************
2680 makes a SAMR_R_QUERY_USERGROUPS structure.
2681 ********************************************************************/
2682 BOOL make_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS *r_u,
2683                 uint32 num_gids, DOM_GID *gid, uint32 status)
2684 {
2685         if (r_u == NULL) return False;
2686
2687         DEBUG(5,("make_samr_r_query_usergroups\n"));
2688
2689         if (status == 0x0)
2690         {
2691                 r_u->ptr_0        = 1;
2692                 r_u->num_entries  = num_gids;
2693                 r_u->ptr_1        = (num_gids != 0) ? 1 : 0;
2694                 r_u->num_entries2 = num_gids;
2695
2696                 r_u->gid = gid;
2697         }
2698         else
2699         {
2700                 r_u->ptr_0       = 0;
2701                 r_u->num_entries = 0;
2702                 r_u->ptr_1       = 0;
2703         }
2704
2705         r_u->status = status;
2706
2707         return True;
2708 }
2709
2710 /*******************************************************************
2711 reads or writes a structure.
2712 ********************************************************************/
2713 BOOL samr_io_r_query_usergroups(char *desc,  SAMR_R_QUERY_USERGROUPS *r_u, prs_struct *ps, int depth)
2714 {
2715         uint32 i;
2716         if (r_u == NULL) return False;
2717
2718         prs_debug(ps, depth, desc, "samr_io_r_query_usergroups");
2719         depth++;
2720
2721         prs_align(ps);
2722
2723         prs_uint32("ptr_0       ", ps, depth, &(r_u->ptr_0      ));
2724
2725         if (r_u->ptr_0 != 0)
2726         {
2727                 prs_uint32("num_entries ", ps, depth, &(r_u->num_entries));
2728                 prs_uint32("ptr_1       ", ps, depth, &(r_u->ptr_1      ));
2729
2730                 if (r_u->num_entries != 0)
2731                 {
2732                         prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
2733
2734                         r_u->gid = (DOM_GID*)malloc(r_u->num_entries2 * sizeof(r_u->gid[0]));
2735                         if (r_u->gid == NULL)
2736                         {
2737                                 return False;
2738                         }
2739
2740                         for (i = 0; i < r_u->num_entries2; i++)
2741                         {
2742                                 smb_io_gid("", &(r_u->gid[i]), ps, depth);
2743                         }
2744                 }
2745         }
2746         prs_uint32("status", ps, depth, &(r_u->status));
2747
2748         return True;
2749 }
2750
2751
2752 /*******************************************************************
2753 makes a SAMR_Q_ENUM_DOMAINS structure.
2754 ********************************************************************/
2755 BOOL make_samr_q_enum_domains(SAMR_Q_ENUM_DOMAINS *q_e, POLICY_HND *pol,
2756                                 uint32 start_idx, uint32 size)
2757 {
2758         if (q_e == NULL || pol == NULL) return False;
2759
2760         DEBUG(5,("make_samr_q_enum_domains\n"));
2761
2762         memcpy(&(q_e->pol), pol, sizeof(*pol));
2763
2764         q_e->start_idx = start_idx;
2765         q_e->max_size = size;
2766
2767         return True;
2768 }
2769
2770
2771 /*******************************************************************
2772 reads or writes a structure.
2773 ********************************************************************/
2774 BOOL samr_io_q_enum_domains(char *desc, SAMR_Q_ENUM_DOMAINS *q_e, prs_struct *ps, int depth)
2775 {
2776         if (q_e == NULL) return False;
2777
2778         prs_debug(ps, depth, desc, "samr_io_q_enum_domains");
2779         depth++;
2780
2781         prs_align(ps);
2782
2783         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
2784         prs_align(ps);
2785
2786         prs_uint32("start_idx", ps, depth, &(q_e->start_idx));
2787         prs_uint32("max_size ", ps, depth, &(q_e->max_size ));
2788
2789         prs_align(ps);
2790
2791         return True;
2792 }
2793
2794
2795 /*******************************************************************
2796 makes a SAMR_R_ENUM_DOMAINS structure.
2797 ********************************************************************/
2798 BOOL make_samr_r_enum_domains(SAMR_R_ENUM_DOMAINS *r_u,
2799                 uint32 next_idx,
2800                 uint32 num_sam_entries, char **doms, uint32 status)
2801 {
2802         uint32 i;
2803
2804         if (r_u == NULL) return False;
2805
2806         DEBUG(5,("make_samr_r_enum_domains\n"));
2807
2808         r_u->next_idx = next_idx;
2809         r_u->sam = NULL;
2810         r_u->uni_dom_name = NULL;
2811
2812         if (num_sam_entries != 0)
2813         {
2814                 r_u->ptr_entries1 = 1;
2815                 r_u->ptr_entries2 = 1;
2816                 r_u->num_entries2 = num_sam_entries;
2817                 r_u->num_entries3 = num_sam_entries;
2818
2819                 r_u->sam = (SAM_ENTRY*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->sam[0]));
2820                 r_u->uni_dom_name = (UNISTR2*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->uni_dom_name[0]));
2821
2822                 if (r_u->sam == NULL || r_u->uni_dom_name == NULL)
2823                 {
2824                         DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOMAINS\n"));
2825                         return False;
2826                 }
2827
2828                 for (i = 0; i < num_sam_entries; i++)
2829                 {
2830                         int acct_name_len = doms[i] != NULL ? strlen(doms[i]) : 0;
2831
2832                         make_sam_entry(&(r_u->sam[i]), acct_name_len, 0);
2833                         make_unistr2(&(r_u->uni_dom_name[i]), doms[i], acct_name_len);
2834                 }
2835
2836                 r_u->num_entries4 = num_sam_entries;
2837         }
2838         else
2839         {
2840                 r_u->ptr_entries1 = 0;
2841                 r_u->num_entries2 = num_sam_entries;
2842                 r_u->ptr_entries2 = 1;
2843         }
2844
2845         r_u->status = status;
2846
2847         return True;
2848 }
2849
2850 /*******************************************************************
2851 reads or writes a structure.
2852 ********************************************************************/
2853 BOOL samr_io_r_enum_domains(char *desc, SAMR_R_ENUM_DOMAINS *r_u, prs_struct *ps, int depth)
2854 {
2855         uint32 i;
2856
2857         if (r_u == NULL) return False;
2858
2859         prs_debug(ps, depth, desc, "samr_io_r_enum_domains");
2860         depth++;
2861
2862         prs_align(ps);
2863
2864         prs_uint32("next_idx    ", ps, depth, &(r_u->next_idx    ));
2865         prs_uint32("ptr_entries1", ps, depth, &(r_u->ptr_entries1));
2866
2867         if (r_u->ptr_entries1 != 0)
2868         {
2869                 prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
2870                 prs_uint32("ptr_entries2", ps, depth, &(r_u->ptr_entries2));
2871                 prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
2872
2873                 if (ps->io)
2874                 {
2875                         r_u->sam = (SAM_ENTRY*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->sam[0]));
2876                         r_u->uni_dom_name = (UNISTR2*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->uni_dom_name[0]));
2877                 }
2878
2879                 if ((r_u->sam == NULL || r_u->uni_dom_name == NULL) && r_u->num_entries2 != 0)
2880                 {
2881                         DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOMAINS\n"));
2882                         r_u->num_entries4 = 0;
2883                         r_u->status = 0xC0000000|NT_STATUS_MEMORY_NOT_ALLOCATED;
2884                         return False;
2885                 }
2886
2887                 for (i = 0; i < r_u->num_entries2; i++)
2888                 {
2889                         fstring tmp;
2890                         slprintf(tmp, sizeof(tmp)-1, "dom[%d]", i);
2891                         sam_io_sam_entry(tmp, &(r_u->sam[i]), ps, depth);
2892                 }
2893
2894                 for (i = 0; i < r_u->num_entries2; i++)
2895                 {
2896                         fstring tmp;
2897                         slprintf(tmp, sizeof(tmp)-1, "dom[%d]", i);
2898                         smb_io_unistr2(tmp, &(r_u->uni_dom_name[i]), r_u->sam[i].hdr_name.buffer, ps, depth);
2899                         prs_align(ps);
2900                 }
2901
2902                 prs_align(ps);
2903
2904         }
2905
2906         prs_uint32("num_entries4", ps, depth, &(r_u->num_entries4));
2907         prs_uint32("status", ps, depth, &(r_u->status));
2908
2909         return True;
2910 }
2911
2912 /*******************************************************************
2913 makes a SAMR_Q_ENUM_DOM_GROUPS structure.
2914 ********************************************************************/
2915 BOOL make_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS *q_e, POLICY_HND *pol,
2916                                 uint32 start_idx, uint32 size)
2917 {
2918         if (q_e == NULL || pol == NULL) return False;
2919
2920         DEBUG(5,("make_samr_q_enum_dom_groups\n"));
2921
2922         memcpy(&(q_e->pol), pol, sizeof(*pol));
2923
2924         q_e->start_idx = start_idx;
2925         q_e->max_size = size;
2926
2927         return True;
2928 }
2929
2930
2931 /*******************************************************************
2932 reads or writes a structure.
2933 ********************************************************************/
2934 BOOL samr_io_q_enum_dom_groups(char *desc, SAMR_Q_ENUM_DOM_GROUPS *q_e, prs_struct *ps, int depth)
2935 {
2936         if (q_e == NULL) return False;
2937
2938         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_groups");
2939         depth++;
2940
2941         prs_align(ps);
2942
2943         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
2944         prs_align(ps);
2945
2946         prs_uint32("start_idx", ps, depth, &(q_e->start_idx));
2947         prs_uint32("max_size ", ps, depth, &(q_e->max_size ));
2948
2949         prs_align(ps);
2950
2951         return True;
2952 }
2953
2954
2955 /*******************************************************************
2956 makes a SAMR_R_ENUM_DOM_GROUPS structure.
2957 ********************************************************************/
2958 BOOL make_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS *r_u,
2959                 uint32 next_idx,
2960                 uint32 num_sam_entries, DOMAIN_GRP *grps, uint32 status)
2961 {
2962         uint32 i;
2963
2964         if (r_u == NULL) return False;
2965
2966         DEBUG(5,("make_samr_r_enum_dom_groups\n"));
2967
2968         r_u->next_idx = next_idx;
2969         r_u->sam = NULL;
2970         r_u->uni_grp_name = NULL;
2971
2972         if (num_sam_entries != 0)
2973         {
2974                 r_u->ptr_entries1 = 1;
2975                 r_u->ptr_entries2 = 1;
2976                 r_u->num_entries2 = num_sam_entries;
2977                 r_u->num_entries3 = num_sam_entries;
2978
2979                 r_u->sam = (SAM_ENTRY*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->sam[0]));
2980                 r_u->uni_grp_name = (UNISTR2*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->uni_grp_name[0]));
2981
2982                 if (r_u->sam == NULL || r_u->uni_grp_name == NULL)
2983                 {
2984                         DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_GROUPS\n"));
2985                         return False;
2986                 }
2987
2988                 for (i = 0; i < num_sam_entries; i++)
2989                 {
2990                         int acct_name_len = strlen(grps[i].name);
2991
2992                         make_sam_entry(&(r_u->sam[i]),
2993                                         acct_name_len,
2994                                         grps[i].rid);
2995
2996                         make_unistr2(&(r_u->uni_grp_name[i]), grps[i].name, acct_name_len);
2997                 }
2998
2999                 r_u->num_entries4 = num_sam_entries;
3000         }
3001         else
3002         {
3003                 r_u->ptr_entries1 = 0;
3004                 r_u->num_entries2 = num_sam_entries;
3005                 r_u->ptr_entries2 = 1;
3006         }
3007
3008         r_u->status = status;
3009
3010         return True;
3011 }
3012
3013 /*******************************************************************
3014 reads or writes a structure.
3015 ********************************************************************/
3016 BOOL samr_io_r_enum_dom_groups(char *desc, SAMR_R_ENUM_DOM_GROUPS *r_u, prs_struct *ps, int depth)
3017 {
3018         uint32 i;
3019
3020         if (r_u == NULL) return False;
3021
3022         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_groups");
3023         depth++;
3024
3025         prs_align(ps);
3026
3027         prs_uint32("next_idx    ", ps, depth, &(r_u->next_idx    ));
3028         prs_uint32("ptr_entries1", ps, depth, &(r_u->ptr_entries1));
3029
3030         if (r_u->ptr_entries1 != 0)
3031         {
3032                 prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
3033                 prs_uint32("ptr_entries2", ps, depth, &(r_u->ptr_entries2));
3034                 prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
3035
3036                 if (ps->io)
3037                 {
3038                         r_u->sam = (SAM_ENTRY*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->sam[0]));
3039                         r_u->uni_grp_name = (UNISTR2*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->uni_grp_name[0]));
3040                 }
3041
3042                 if ((r_u->sam == NULL || r_u->uni_grp_name == NULL) && r_u->num_entries2 != 0)
3043                 {
3044                         DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_GROUPS\n"));
3045                         r_u->num_entries4 = 0;
3046                         r_u->status = 0xC0000000|NT_STATUS_MEMORY_NOT_ALLOCATED;
3047                         return False;
3048                 }
3049
3050                 for (i = 0; i < r_u->num_entries2; i++)
3051                 {
3052                         sam_io_sam_entry("", &(r_u->sam[i]), ps, depth);
3053                 }
3054
3055                 for (i = 0; i < r_u->num_entries2; i++)
3056                 {
3057                         smb_io_unistr2("", &(r_u->uni_grp_name[i]), r_u->sam[i].hdr_name.buffer, ps, depth);
3058                         prs_align(ps);
3059                 }
3060
3061                 prs_align(ps);
3062
3063         }
3064
3065         prs_uint32("num_entries4", ps, depth, &(r_u->num_entries4));
3066         prs_uint32("status", ps, depth, &(r_u->status));
3067
3068         return True;
3069 }
3070
3071 /*******************************************************************
3072 makes a SAMR_Q_ENUM_DOM_ALIASES structure.
3073 ********************************************************************/
3074 BOOL make_samr_q_enum_dom_aliases(SAMR_Q_ENUM_DOM_ALIASES *q_e, POLICY_HND *pol,
3075                                 uint32 start_idx, uint32 size)
3076 {
3077         if (q_e == NULL || pol == NULL) return False;
3078
3079         DEBUG(5,("make_samr_q_enum_dom_aliases\n"));
3080
3081         memcpy(&(q_e->pol), pol, sizeof(*pol));
3082
3083         q_e->start_idx = start_idx;
3084         q_e->max_size = size;
3085
3086         return True;
3087 }
3088
3089
3090 /*******************************************************************
3091 reads or writes a structure.
3092 ********************************************************************/
3093 BOOL samr_io_q_enum_dom_aliases(char *desc,  SAMR_Q_ENUM_DOM_ALIASES *q_e, prs_struct *ps, int depth)
3094 {
3095         if (q_e == NULL) return False;
3096
3097         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_aliases");
3098         depth++;
3099
3100         prs_align(ps);
3101
3102         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
3103         prs_align(ps);
3104
3105         prs_uint32("start_idx", ps, depth, &(q_e->start_idx));
3106         prs_uint32("max_size ", ps, depth, &(q_e->max_size ));
3107
3108         prs_align(ps);
3109
3110         return True;
3111 }
3112
3113
3114 /*******************************************************************
3115 makes a SAMR_R_ENUM_DOM_ALIASES structure.
3116 ********************************************************************/
3117 BOOL make_samr_r_enum_dom_aliases(SAMR_R_ENUM_DOM_ALIASES *r_u,
3118                 uint32 next_idx,
3119                 uint32 num_sam_entries, LOCAL_GRP *alss, uint32 status)
3120 {
3121         uint32 i;
3122
3123         if (r_u == NULL) return False;
3124
3125         DEBUG(5,("make_samr_r_enum_dom_aliases\n"));
3126
3127         r_u->next_idx = next_idx;
3128         r_u->sam = NULL;
3129         r_u->uni_grp_name = NULL;
3130
3131         if (num_sam_entries != 0)
3132         {
3133                 r_u->ptr_entries1 = 1;
3134                 r_u->ptr_entries2 = 1;
3135                 r_u->num_entries2 = num_sam_entries;
3136                 r_u->num_entries3 = num_sam_entries;
3137
3138                 r_u->sam = (SAM_ENTRY*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->sam[0]));
3139                 r_u->uni_grp_name = (UNISTR2*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->uni_grp_name[0]));
3140
3141                 if (r_u->sam == NULL || r_u->uni_grp_name == NULL)
3142                 {
3143                         DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_ALIASES\n"));
3144                         return False;
3145                 }
3146
3147                 for (i = 0; i < num_sam_entries; i++)
3148                 {
3149                         int acct_name_len = strlen(alss[i].name);
3150
3151                         make_sam_entry(&(r_u->sam[i]),
3152                                         acct_name_len,
3153                                         alss[i].rid);
3154
3155                         make_unistr2(&(r_u->uni_grp_name[i]), alss[i].name, acct_name_len);
3156                 }
3157
3158                 r_u->num_entries4 = num_sam_entries;
3159         }
3160         else
3161         {
3162                 r_u->ptr_entries1 = 0;
3163                 r_u->num_entries2 = num_sam_entries;
3164                 r_u->ptr_entries2 = 1;
3165         }
3166
3167         r_u->status = status;
3168
3169         return True;
3170 }
3171
3172 /*******************************************************************
3173 reads or writes a structure.
3174 ********************************************************************/
3175 BOOL samr_io_r_enum_dom_aliases(char *desc, SAMR_R_ENUM_DOM_ALIASES *r_u, prs_struct *ps, int depth)
3176 {
3177         uint32 i;
3178
3179         if (r_u == NULL) return False;
3180
3181         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_aliases");
3182         depth++;
3183
3184         prs_align(ps);
3185
3186         prs_uint32("next_idx    ", ps, depth, &(r_u->next_idx    ));
3187         prs_uint32("ptr_entries1", ps, depth, &(r_u->ptr_entries1));
3188
3189         if (r_u->ptr_entries1 != 0)
3190         {
3191                 prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
3192                 prs_uint32("ptr_entries2", ps, depth, &(r_u->ptr_entries2));
3193                 prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
3194
3195                 if (ps->io)
3196                 {
3197                         r_u->sam = (SAM_ENTRY*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->sam[0]));
3198                         r_u->uni_grp_name = (UNISTR2*)Realloc(NULL, r_u->num_entries2 * sizeof(r_u->uni_grp_name[0]));
3199                 }
3200
3201                 if ((r_u->sam == NULL || r_u->uni_grp_name == NULL) && r_u->num_entries2 != 0)
3202                 {
3203                         DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_ALIASES\n"));
3204                         r_u->num_entries4 = 0;
3205                         r_u->status = 0xC0000000|NT_STATUS_MEMORY_NOT_ALLOCATED;
3206                         return False;
3207                 }
3208
3209                 for (i = 0; i < r_u->num_entries2; i++)
3210                 {
3211                         sam_io_sam_entry("", &(r_u->sam[i]), ps, depth);
3212                 }
3213
3214                 for (i = 0; i < r_u->num_entries2; i++)
3215                 {
3216                         smb_io_unistr2("", &(r_u->uni_grp_name[i]), r_u->sam[i].hdr_name.buffer, ps, depth);
3217                         prs_align(ps);
3218                 }
3219
3220                 prs_align(ps);
3221
3222         }
3223
3224         prs_uint32("num_entries4", ps, depth, &(r_u->num_entries4));
3225         prs_uint32("status", ps, depth, &(r_u->status));
3226
3227         return True;
3228 }
3229
3230
3231 /*******************************************************************
3232 makes a ALIAS_INFO3 structure.
3233 ********************************************************************/
3234 BOOL make_samr_alias_info3(ALIAS_INFO3 *al3, const char *acct_desc)
3235 {
3236         int acct_len = acct_desc != NULL ? strlen(acct_desc) : 0;
3237         if (al3 == NULL) return False;
3238
3239         DEBUG(5,("make_samr_alias_info3\n"));
3240
3241         make_uni_hdr(&(al3->hdr_acct_desc), acct_len);
3242         make_unistr2(&(al3->uni_acct_desc), acct_desc, acct_len);
3243
3244         return True;
3245 }
3246
3247
3248 /*******************************************************************
3249 reads or writes a structure.
3250 ********************************************************************/
3251 BOOL samr_io_alias_info3(char *desc,  ALIAS_INFO3 *al3, prs_struct *ps, int depth)
3252 {
3253         if (al3 == NULL) return False;
3254
3255         prs_debug(ps, depth, desc, "samr_io_alias_info3");
3256         depth++;
3257
3258         prs_align(ps);
3259
3260         smb_io_unihdr ("hdr_acct_desc", &(al3->hdr_acct_desc) , ps, depth);
3261         smb_io_unistr2("uni_acct_desc", &(al3->uni_acct_desc), al3->hdr_acct_desc.buffer, ps, depth);
3262         prs_align(ps);
3263
3264         return True;
3265 }
3266
3267 /*******************************************************************
3268 reads or writes a structure.
3269 ********************************************************************/
3270 BOOL samr_alias_info_ctr(char *desc,  ALIAS_INFO_CTR *ctr, prs_struct *ps, int depth)
3271 {
3272         if (ctr == NULL) return False;
3273
3274         prs_debug(ps, depth, desc, "samr_alias_info_ctr");
3275         depth++;
3276
3277         prs_uint16("switch_value1", ps, depth, &(ctr->switch_value1));
3278         prs_uint16("switch_value2", ps, depth, &(ctr->switch_value2));
3279
3280         switch (ctr->switch_value1)
3281         {
3282                 case 3:
3283                 {
3284                         samr_io_alias_info3("alias_info3", &(ctr->alias.info3), ps, depth);
3285                         break;
3286                 }
3287                 default:
3288                 {
3289                         DEBUG(4,("samr_alias_info_ctr: unsupported switch level\n"));
3290                         break;
3291                 }
3292         }
3293
3294         prs_align(ps);
3295
3296         return True;
3297 }
3298
3299
3300 /*******************************************************************
3301 makes a SAMR_Q_QUERY_ALIASINFO structure.
3302 ********************************************************************/
3303 BOOL make_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO *q_e,
3304                                 POLICY_HND *pol,
3305                                 uint16 switch_level)
3306 {
3307         if (q_e == NULL || pol == NULL) return False;
3308
3309         DEBUG(5,("make_samr_q_query_aliasinfo\n"));
3310
3311         memcpy(&(q_e->pol), pol, sizeof(*pol));
3312
3313         q_e->switch_level = switch_level;
3314
3315         return True;
3316 }
3317
3318
3319 /*******************************************************************
3320 reads or writes a structure.
3321 ********************************************************************/
3322 BOOL samr_io_q_query_aliasinfo(char *desc,  SAMR_Q_QUERY_ALIASINFO *q_e, prs_struct *ps, int depth)
3323 {
3324         if (q_e == NULL) return False;
3325
3326         prs_debug(ps, depth, desc, "samr_io_q_query_aliasinfo");
3327         depth++;
3328
3329         prs_align(ps);
3330
3331         smb_io_pol_hnd("pol", &(q_e->pol), ps, depth);
3332         prs_align(ps);
3333
3334         prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
3335
3336         return True;
3337 }
3338
3339
3340 /*******************************************************************
3341 makes a SAMR_R_QUERY_ALIASINFO structure.
3342 ********************************************************************/
3343 BOOL make_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *r_u, ALIAS_INFO_CTR *ctr,
3344                 uint32 status)
3345 {
3346         if (r_u == NULL) return False;
3347
3348         DEBUG(5,("make_samr_r_query_aliasinfo\n"));
3349
3350         r_u->ptr = (status == 0x0 && ctr != NULL) ? 1 : 0;
3351         r_u->ctr = ctr;
3352         r_u->status = status;
3353
3354         return True;
3355 }
3356
3357
3358 /*******************************************************************
3359 reads or writes a structure.
3360 ********************************************************************/
3361 BOOL samr_io_r_query_aliasinfo(char *desc,  SAMR_R_QUERY_ALIASINFO *r_u, prs_struct *ps, int depth)
3362 {
3363         if (r_u == NULL) return False;
3364
3365         prs_debug(ps, depth, desc, "samr_io_r_query_aliasinfo");
3366         depth++;
3367
3368         prs_align(ps);
3369
3370         prs_uint32("ptr", ps, depth, &(r_u->ptr));
3371
3372         if (r_u->ptr != 0)
3373         {
3374                 samr_alias_info_ctr("ctr", r_u->ctr, ps, depth);
3375         }
3376
3377         prs_uint32("status", ps, depth, &(r_u->status));
3378
3379         return True;
3380 }
3381
3382
3383 /*******************************************************************
3384 makes a SAMR_Q_SET_ALIASINFO structure.
3385 ********************************************************************/
3386 BOOL make_samr_q_set_aliasinfo(SAMR_Q_SET_ALIASINFO *q_u, POLICY_HND *hnd,
3387                                 ALIAS_INFO_CTR *ctr)
3388 {
3389         if (q_u == NULL) return False;
3390
3391         DEBUG(5,("make_samr_q_set_aliasinfo\n"));
3392
3393         memcpy(&(q_u->alias_pol), hnd, sizeof(q_u->alias_pol));
3394         q_u->ctr = ctr;
3395
3396         return True;
3397 }
3398
3399
3400 /*******************************************************************
3401 reads or writes a structure.
3402 ********************************************************************/
3403 BOOL samr_io_q_set_aliasinfo(char *desc,  SAMR_Q_SET_ALIASINFO *q_u, prs_struct *ps, int depth)
3404 {
3405         if (q_u == NULL) return False;
3406
3407         prs_debug(ps, depth, desc, "samr_io_q_set_aliasinfo");
3408         depth++;
3409
3410         prs_align(ps);
3411
3412         smb_io_pol_hnd("alias_pol", &(q_u->alias_pol), ps, depth);
3413         samr_alias_info_ctr("ctr", q_u->ctr, ps, depth);
3414
3415         return True;
3416 }
3417
3418 /*******************************************************************
3419 reads or writes a structure.
3420 ********************************************************************/
3421 BOOL samr_io_r_set_aliasinfo(char *desc,  SAMR_R_SET_ALIASINFO *r_u, prs_struct *ps, int depth)
3422 {
3423         if (r_u == NULL) return False;
3424
3425         prs_debug(ps, depth, desc, "samr_io_r_set_aliasinfo");
3426         depth++;
3427
3428         prs_align(ps);
3429         prs_uint32("status", ps, depth, &(r_u->status));
3430
3431         return True;
3432 }
3433
3434
3435
3436 /*******************************************************************
3437 makes a SAMR_Q_QUERY_USERALIASES structure.
3438 ********************************************************************/
3439 BOOL make_samr_q_query_useraliases(SAMR_Q_QUERY_USERALIASES *q_u,
3440                                 const POLICY_HND *hnd,
3441                                 uint32 *ptr_sid, DOM_SID2 *sid)
3442 {
3443         if (q_u == NULL || hnd == NULL) return False;
3444
3445         DEBUG(5,("make_samr_q_query_useraliases\n"));
3446
3447         memcpy(&(q_u->pol), hnd, sizeof(q_u->pol));
3448
3449         q_u->num_sids1 = 1;
3450         q_u->ptr = 1;
3451         q_u->num_sids2 = 1;
3452
3453         q_u->ptr_sid = ptr_sid;
3454         q_u->sid = sid;
3455
3456         return True;
3457 }
3458
3459 /*******************************************************************
3460 reads or writes a SAMR_Q_QUERY_USERALIASES structure.
3461 ********************************************************************/
3462 BOOL samr_io_q_query_useraliases(char *desc,  SAMR_Q_QUERY_USERALIASES *q_u, prs_struct *ps, int depth)
3463 {
3464         fstring tmp;
3465         uint32 i;
3466
3467         if (q_u == NULL) return False;
3468
3469         prs_debug(ps, depth, desc, "samr_io_q_query_useraliases");
3470         depth++;
3471
3472         prs_align(ps);
3473
3474         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
3475         prs_align(ps);
3476
3477         prs_uint32("num_sids1", ps, depth, &(q_u->num_sids1));
3478         prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
3479         prs_uint32("num_sids2", ps, depth, &(q_u->num_sids2));
3480
3481         if (q_u->num_sids2 != 0)
3482         {
3483                 q_u->ptr_sid = (uint32*)Realloc(q_u->ptr_sid,
3484                                     sizeof(q_u->ptr_sid[0]) * q_u->num_sids2);
3485                 if (q_u->ptr_sid == NULL)
3486                 {
3487                         samr_free_q_query_useraliases(q_u);
3488                         return False;
3489                 }
3490
3491                 q_u->sid = (DOM_SID2*)Realloc(q_u->sid,
3492                                        sizeof(q_u->sid[0]) * q_u->num_sids2);
3493                 if (q_u->sid == NULL)
3494                 {
3495                         samr_free_q_query_useraliases(q_u);
3496                         return False;
3497                 }
3498         }
3499
3500         for (i = 0; i < q_u->num_sids2; i++)
3501         {
3502                 slprintf(tmp, sizeof(tmp) - 1, "ptr[%02d]", i);
3503                 prs_uint32(tmp, ps, depth, &(q_u->ptr_sid[i]));
3504         }
3505
3506         for (i = 0; i < q_u->num_sids2; i++)
3507         {
3508                 if (q_u->ptr_sid[i] != 0)
3509                 {
3510                         slprintf(tmp, sizeof(tmp)-1, "sid[%02d]", i);
3511                         smb_io_dom_sid2(tmp, &(q_u->sid[i]), ps, depth);
3512                 }
3513         }
3514
3515         prs_align(ps);
3516
3517         if (!ps->io)
3518         {
3519                 /* storing.  memory no longer needed */
3520                 samr_free_q_query_useraliases(q_u);
3521         }
3522         return True;
3523 }
3524
3525 /*******************************************************************
3526 frees memory in a SAMR_Q_QUERY_USERALIASES structure.
3527 ********************************************************************/
3528 void samr_free_q_query_useraliases(SAMR_Q_QUERY_USERALIASES *q_u)
3529 {
3530         if (q_u->ptr_sid == NULL)
3531         {
3532                 free(q_u->ptr_sid);
3533                 q_u->ptr_sid = NULL;
3534         }
3535
3536         if (q_u->sid == NULL)
3537         {
3538                 free(q_u->sid);
3539                 q_u->sid = NULL;
3540         }
3541 }
3542
3543 /*******************************************************************
3544 makes a SAMR_R_QUERY_USERALIASES structure.
3545 ********************************************************************/
3546 BOOL make_samr_r_query_useraliases(SAMR_R_QUERY_USERALIASES *r_u,
3547                 uint32 num_rids, uint32 *rid, uint32 status)
3548 {
3549         if (r_u == NULL) return False;
3550
3551         DEBUG(5,("make_samr_r_query_useraliases\n"));
3552
3553         if (status == 0x0)
3554         {
3555                 r_u->num_entries  = num_rids;
3556                 r_u->ptr = 1;
3557                 r_u->num_entries2 = num_rids;
3558
3559                 r_u->rid = rid;
3560         }
3561         else
3562         {
3563                 r_u->num_entries  = 0;
3564                 r_u->ptr = 0;
3565                 r_u->num_entries2 = 0;
3566         }
3567
3568         r_u->status = status;
3569
3570         return True;
3571 }
3572
3573 /*******************************************************************
3574 reads or writes a structure.
3575 ********************************************************************/
3576 BOOL samr_io_r_query_useraliases(char *desc,  SAMR_R_QUERY_USERALIASES *r_u, prs_struct *ps, int depth)
3577 {
3578         fstring tmp;
3579         uint32 i;
3580         if (r_u == NULL) return False;
3581
3582         prs_debug(ps, depth, desc, "samr_io_r_query_useraliases");
3583         depth++;
3584
3585         prs_align(ps);
3586
3587         prs_uint32("num_entries", ps, depth, &(r_u->num_entries));
3588         prs_uint32("ptr        ", ps, depth, &(r_u->ptr        ));
3589         prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
3590
3591         if (r_u->num_entries != 0)
3592         {
3593                 r_u->rid = (uint32*)Realloc(r_u->rid,
3594                                        sizeof(r_u->rid[0]) * r_u->num_entries);
3595                 if (r_u->rid == NULL)
3596                 {
3597                         samr_free_r_query_useraliases(r_u);
3598                         return False;
3599                 }
3600
3601                 for (i = 0; i < r_u->num_entries2; i++)
3602                 {
3603                         slprintf(tmp, sizeof(tmp)-1, "rid[%02d]", i);
3604                         prs_uint32(tmp, ps, depth, &(r_u->rid[i]));
3605                 }
3606         }
3607
3608         prs_uint32("status", ps, depth, &(r_u->status));
3609
3610         if (!ps->io)
3611         {
3612                 /* storing.  memory no longer needed */
3613                 samr_free_r_query_useraliases(r_u);
3614         }
3615         return True;
3616 }
3617
3618 /*******************************************************************
3619 frees memory in a SAMR_R_QUERY_USERALIASES structure.
3620 ********************************************************************/
3621 void samr_free_r_query_useraliases(SAMR_R_QUERY_USERALIASES *r_u)
3622 {
3623         if (r_u->rid == NULL)
3624         {
3625                 free(r_u->rid);
3626                 r_u->rid = NULL;
3627         }
3628 }
3629
3630 /*******************************************************************
3631 makes a SAMR_Q_OPEN_ALIAS structure.
3632 ********************************************************************/
3633 BOOL make_samr_q_open_alias(SAMR_Q_OPEN_ALIAS *q_u, const POLICY_HND *pol,
3634                                 uint32 unknown_0, uint32 rid)
3635 {
3636         if (q_u == NULL) return False;
3637
3638         DEBUG(5,("make_samr_q_open_alias\n"));
3639
3640         memcpy(&(q_u->dom_pol), pol, sizeof(q_u->dom_pol));
3641
3642         /* example values: 0x0000 0008 */
3643         q_u->unknown_0 = unknown_0;
3644
3645         q_u->rid_alias = rid;
3646
3647         return True;
3648 }
3649
3650 /*******************************************************************
3651 reads or writes a structure.
3652 ********************************************************************/
3653 BOOL samr_io_q_open_alias(char *desc,  SAMR_Q_OPEN_ALIAS *q_u, prs_struct *ps, int depth)
3654 {
3655         if (q_u == NULL) return False;
3656
3657         prs_debug(ps, depth, desc, "samr_io_q_open_alias");
3658         depth++;
3659
3660         prs_align(ps);
3661
3662         smb_io_pol_hnd("dom_pol", &(q_u->dom_pol), ps, depth);
3663
3664         prs_uint32("unknown_0", ps, depth, &(q_u->unknown_0));
3665         prs_uint32("rid_alias", ps, depth, &(q_u->rid_alias));
3666
3667         return True;
3668 }
3669
3670 /*******************************************************************
3671 reads or writes a structure.
3672 ********************************************************************/
3673 BOOL samr_io_r_open_alias(char *desc,  SAMR_R_OPEN_ALIAS *r_u, prs_struct *ps, int depth)
3674 {
3675         if (r_u == NULL) return False;
3676
3677         prs_debug(ps, depth, desc, "samr_io_r_open_alias");
3678         depth++;
3679
3680         prs_align(ps);
3681
3682         smb_io_pol_hnd("pol", &(r_u->pol), ps, depth);
3683         prs_align(ps);
3684
3685         prs_uint32("status", ps, depth, &(r_u->status));
3686
3687         return True;
3688 }
3689
3690 /*******************************************************************
3691 makes a SAMR_Q_LOOKUP_RIDS structure.
3692 ********************************************************************/
3693 BOOL make_samr_q_lookup_rids(SAMR_Q_LOOKUP_RIDS *q_u,
3694                 const POLICY_HND *pol, uint32 flags,
3695                 uint32 num_rids, uint32 *rid)
3696 {
3697         if (q_u == NULL) return False;
3698
3699         DEBUG(5,("make_samr_r_unknwon_12\n"));
3700
3701         memcpy(&(q_u->pol), pol, sizeof(*pol));
3702
3703         q_u->num_rids1 = num_rids;
3704         q_u->flags     = flags;
3705         q_u->ptr       = 0;
3706         q_u->num_rids2 = num_rids;
3707         q_u->rid = rid;
3708
3709         return True;
3710 }
3711
3712 /*******************************************************************
3713 reads or writes a structure.
3714 ********************************************************************/
3715 BOOL samr_io_q_lookup_rids(char *desc,  SAMR_Q_LOOKUP_RIDS *q_u, prs_struct *ps, int depth)
3716 {
3717         uint32 i;
3718         fstring tmp;
3719
3720         if (q_u == NULL) return False;
3721
3722         prs_debug(ps, depth, desc, "samr_io_q_lookup_rids");
3723         depth++;
3724
3725         prs_align(ps);
3726
3727         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
3728         prs_align(ps);
3729
3730         prs_uint32("num_rids1", ps, depth, &(q_u->num_rids1));
3731         prs_uint32("flags    ", ps, depth, &(q_u->flags    ));
3732         prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
3733         prs_uint32("num_rids2", ps, depth, &(q_u->num_rids2));
3734
3735         if (q_u->num_rids2 != 0)
3736         {
3737                 q_u->rid = (uint32*)Realloc(q_u->rid, sizeof(q_u->rid[0]) *
3738                                    q_u->num_rids2);
3739                 if (q_u->rid == NULL)
3740                 {
3741                         samr_free_q_lookup_rids(q_u);
3742                         return False;
3743                 }
3744         }
3745
3746         for (i = 0; i < q_u->num_rids2; i++)
3747         {
3748                 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]  ", i);
3749                 prs_uint32(tmp, ps, depth, &(q_u->rid[i]));
3750         }
3751
3752         prs_align(ps);
3753
3754         if (!ps->io)
3755         {
3756                 /* storing.  don't need memory any more */
3757                 samr_free_q_lookup_rids(q_u);
3758         }
3759
3760         return True;
3761 }
3762
3763 /*******************************************************************
3764 frees a structure.
3765 ********************************************************************/
3766 void samr_free_q_lookup_rids(SAMR_Q_LOOKUP_RIDS *q_u)
3767 {
3768         if (q_u->rid != NULL)
3769         {
3770                 free(q_u->rid);
3771                 q_u->rid = NULL;
3772         }
3773 }
3774
3775
3776 /*******************************************************************
3777 makes a SAMR_R_LOOKUP_RIDS structure.
3778 ********************************************************************/
3779 BOOL make_samr_r_lookup_rids(SAMR_R_LOOKUP_RIDS *r_u,
3780                 uint32 num_names, fstring *name, uint8 *type,
3781                 uint32 status)
3782 {
3783         uint32 i;
3784         if (r_u == NULL || name == NULL || type == NULL) return False;
3785
3786         DEBUG(5,("make_samr_r_lookup_rids\n"));
3787
3788         if (status == 0x0)
3789         {
3790                 r_u->num_names1 = num_names;
3791                 r_u->ptr_names  = 1;
3792                 r_u->num_names2 = num_names;
3793
3794                 r_u->num_types1 = num_names;
3795                 r_u->ptr_types  = 1;
3796                 r_u->num_types2 = num_names;
3797
3798                 if (num_names != 0)
3799                 {
3800                         r_u->hdr_name = (UNIHDR*)malloc(num_names * sizeof(r_u->hdr_name[0]));
3801                         if (r_u->hdr_name == NULL)
3802                         {
3803                                 samr_free_r_lookup_rids(r_u);
3804                                 return False;
3805                         }
3806                         r_u->uni_name = (UNISTR2*)malloc(num_names * sizeof(r_u->uni_name[0]));
3807                         if (r_u->uni_name == NULL)
3808                         {
3809                                 samr_free_r_lookup_rids(r_u);
3810                                 return False;
3811                         }
3812                         r_u->type = (uint32*)malloc(r_u->num_types2 * sizeof(r_u->type[0]));
3813                         if (r_u->type == NULL)
3814                         {
3815                                 samr_free_r_lookup_rids(r_u);
3816                                 return False;
3817                         }
3818                 }
3819
3820                 for (i = 0; i < num_names; i++)
3821                 {
3822                         int len = name[i] != NULL ? strlen(name[i]) : 0;
3823                         DEBUG(10,("name[%d]:%s\ttype:%d\n",
3824                                    i, name[i], type[i]));
3825                         make_uni_hdr(&(r_u->hdr_name[i]), len);
3826                         make_unistr2(&(r_u->uni_name[i]), name[i], len);
3827                         r_u->type[i] = type[i];
3828                 }
3829         }
3830         else
3831         {
3832                 r_u->num_names1 = num_names;
3833                 r_u->ptr_names  = 0;
3834                 r_u->num_names2 = num_names;
3835
3836                 r_u->num_types1 = num_names;
3837                 r_u->ptr_types  = 0;
3838                 r_u->num_types2 = num_names;
3839         }
3840
3841         r_u->status = status;
3842
3843         return True;
3844 }
3845
3846 /*******************************************************************
3847 reads or writes a structure.
3848 ********************************************************************/
3849 BOOL samr_io_r_lookup_rids(char *desc, SAMR_R_LOOKUP_RIDS *r_u, prs_struct *ps, int depth)
3850 {
3851         uint32 i;
3852         fstring tmp;
3853         if (r_u == NULL) return False;
3854
3855         prs_debug(ps, depth, desc, "samr_io_r_lookup_rids");
3856         depth++;
3857
3858         prs_align(ps);
3859
3860         prs_uint32("num_names1", ps, depth, &(r_u->num_names1));
3861         prs_uint32("ptr_names ", ps, depth, &(r_u->ptr_names ));
3862         prs_uint32("num_names2", ps, depth, &(r_u->num_names2));
3863
3864         if (r_u->ptr_names != 0 && r_u->num_names1 != 0)
3865         {
3866                 r_u->hdr_name = (UNIHDR*)Realloc(r_u->hdr_name,
3867                                    r_u->num_names2 * sizeof(r_u->hdr_name[0]));
3868                 if (r_u->hdr_name == NULL)
3869                 {
3870                         return False;
3871                 }
3872
3873                 r_u->uni_name = (UNISTR2*)Realloc(r_u->uni_name,
3874                                     r_u->num_names2 * sizeof(r_u->uni_name[0]));
3875                 if (r_u->uni_name == NULL)
3876                 {
3877                         free(r_u->hdr_name);
3878                         return False;
3879                 }
3880                 for (i = 0; i < r_u->num_names2; i++)
3881                 {
3882                         slprintf(tmp, sizeof(tmp) - 1, "hdr[%02d]  ", i);
3883                         smb_io_unihdr ("", &(r_u->hdr_name[i]), ps, depth);
3884                 }
3885                 for (i = 0; i < r_u->num_names2; i++)
3886                 {
3887                         slprintf(tmp, sizeof(tmp) - 1, "str[%02d]  ", i);
3888                         smb_io_unistr2("", &(r_u->uni_name[i]), r_u->hdr_name[i].buffer, ps, depth);
3889                         prs_align(ps);
3890                 }
3891         }
3892
3893         prs_align(ps);
3894
3895         prs_uint32("num_types1", ps, depth, &(r_u->num_types1));
3896         prs_uint32("ptr_types ", ps, depth, &(r_u->ptr_types ));
3897         prs_uint32("num_types2", ps, depth, &(r_u->num_types2));
3898
3899         if (r_u->ptr_types != 0 && r_u->num_types1 != 0)
3900         {
3901                 r_u->type = (uint32*)Realloc(r_u->type, r_u->num_types2 *
3902                                     sizeof(r_u->type[0]));
3903                 if (r_u->type == NULL)
3904                 {
3905                         if (r_u->uni_name != NULL)
3906                         {
3907                                 free(r_u->uni_name);
3908                         }
3909                         if (r_u->hdr_name != NULL)
3910                         {
3911                                 free(r_u->hdr_name);
3912                         }
3913                         return False;
3914                 }
3915
3916                 for (i = 0; i < r_u->num_types2; i++)
3917                 {
3918                         slprintf(tmp, sizeof(tmp) - 1, "type[%02d]  ", i);
3919                         prs_uint32(tmp, ps, depth, &(r_u->type[i]));
3920                 }
3921         }
3922
3923         prs_uint32("status", ps, depth, &(r_u->status));
3924
3925         if (!ps->io)
3926         {
3927                 /* storing.  don't need memory any more */
3928                 samr_free_r_lookup_rids(r_u);
3929         }
3930
3931         return True;
3932 }
3933
3934 /*******************************************************************
3935 frees a structure.
3936 ********************************************************************/
3937 void samr_free_r_lookup_rids(SAMR_R_LOOKUP_RIDS *r_u)
3938 {
3939         if (r_u->uni_name != NULL)
3940         {
3941                 free(r_u->uni_name);
3942                 r_u->uni_name = NULL;
3943         }
3944         if (r_u->hdr_name != NULL)
3945         {
3946                 free(r_u->hdr_name);
3947                 r_u->hdr_name = NULL;
3948         }
3949         if (r_u->type != NULL)
3950         {
3951                 free(r_u->type);
3952                 r_u->type = NULL;
3953         }
3954 }
3955
3956 /*******************************************************************
3957 makes a SAMR_Q_OPEN_ALIAS structure.
3958 ********************************************************************/
3959 BOOL make_samr_q_delete_alias(SAMR_Q_DELETE_DOM_ALIAS *q_u, POLICY_HND *hnd)
3960 {
3961         if (q_u == NULL) return False;
3962
3963         DEBUG(5,("make_samr_q_delete_alias\n"));
3964
3965         memcpy(&(q_u->alias_pol), hnd, sizeof(q_u->alias_pol));
3966
3967         return True;
3968 }
3969
3970
3971 /*******************************************************************
3972 reads or writes a structure.
3973 ********************************************************************/
3974 BOOL samr_io_q_delete_alias(char *desc,  SAMR_Q_DELETE_DOM_ALIAS *q_u, prs_struct *ps, int depth)
3975 {
3976         if (q_u == NULL) return False;
3977
3978         prs_debug(ps, depth, desc, "samr_io_q_delete_alias");
3979         depth++;
3980
3981         prs_align(ps);
3982
3983         smb_io_pol_hnd("alias_pol", &(q_u->alias_pol), ps, depth);
3984
3985         return True;
3986 }
3987
3988 /*******************************************************************
3989 reads or writes a structure.
3990 ********************************************************************/
3991 BOOL samr_io_r_delete_alias(char *desc,  SAMR_R_DELETE_DOM_ALIAS *r_u, prs_struct *ps, int depth)
3992 {
3993         if (r_u == NULL) return False;
3994
3995         prs_debug(ps, depth, desc, "samr_io_r_delete_alias");
3996         depth++;
3997
3998         prs_align(ps);
3999
4000         smb_io_pol_hnd("pol", &(r_u->pol), ps, depth);
4001         prs_uint32("status", ps, depth, &(r_u->status));
4002
4003         return True;
4004 }
4005
4006
4007 /*******************************************************************
4008 makes a SAMR_Q_CREATE_DOM_ALIAS structure.
4009 ********************************************************************/
4010 BOOL make_samr_q_create_dom_alias(SAMR_Q_CREATE_DOM_ALIAS *q_u, POLICY_HND *hnd,
4011                                 const char *acct_desc)
4012 {
4013         int acct_len = acct_desc != NULL ? strlen(acct_desc) : 0;
4014         if (q_u == NULL) return False;
4015
4016         DEBUG(5,("make_samr_q_create_dom_alias\n"));
4017
4018         memcpy(&(q_u->dom_pol), hnd, sizeof(q_u->dom_pol));
4019
4020         make_uni_hdr(&(q_u->hdr_acct_desc), acct_len);
4021         make_unistr2(&(q_u->uni_acct_desc), acct_desc, acct_len);
4022
4023         q_u->unknown_1 = 0x001f;
4024         q_u->unknown_2 = 0x000f;
4025
4026         return True;
4027 }
4028
4029
4030 /*******************************************************************
4031 reads or writes a structure.
4032 ********************************************************************/
4033 BOOL samr_io_q_create_dom_alias(char *desc,  SAMR_Q_CREATE_DOM_ALIAS *q_u, prs_struct *ps, int depth)
4034 {
4035         if (q_u == NULL) return False;
4036
4037         prs_debug(ps, depth, desc, "samr_io_q_create_dom_alias");
4038         depth++;
4039
4040         prs_align(ps);
4041
4042         smb_io_pol_hnd("dom_pol", &(q_u->dom_pol), ps, depth);
4043
4044         smb_io_unihdr ("hdr_acct_desc", &(q_u->hdr_acct_desc) , ps, depth);
4045         smb_io_unistr2("uni_acct_desc", &(q_u->uni_acct_desc), q_u->hdr_acct_desc.buffer, ps, depth);
4046         prs_align(ps);
4047
4048         prs_uint16("unknown_1", ps, depth, &(q_u->unknown_1));
4049         prs_uint16("unknown_2", ps, depth, &(q_u->unknown_2));
4050
4051         return True;
4052 }
4053
4054 /*******************************************************************
4055 makes a SAMR_R_CREATE_DOM_ALIAS structure.
4056 ********************************************************************/
4057 BOOL make_samr_r_create_dom_alias(SAMR_R_CREATE_DOM_ALIAS *r_u, POLICY_HND *pol,
4058                 uint32 rid, uint32 status)
4059 {
4060         if (r_u == NULL) return False;
4061
4062         DEBUG(5,("make_samr_r_create_dom_alias\n"));
4063
4064         memcpy(&(r_u->alias_pol), pol, sizeof(*pol));
4065         r_u->rid    = rid   ;
4066         r_u->status = status;
4067
4068         return True;
4069 }
4070
4071
4072 /*******************************************************************
4073 reads or writes a structure.
4074 ********************************************************************/
4075 BOOL samr_io_r_create_dom_alias(char *desc,  SAMR_R_CREATE_DOM_ALIAS *r_u, prs_struct *ps, int depth)
4076 {
4077         if (r_u == NULL) return False;
4078
4079         prs_debug(ps, depth, desc, "samr_io_r_create_dom_alias");
4080         depth++;
4081
4082         prs_align(ps);
4083
4084         smb_io_pol_hnd("alias_pol", &(r_u->alias_pol), ps, depth);
4085         prs_uint32("rid", ps, depth, &(r_u->rid));
4086
4087         prs_uint32("status", ps, depth, &(r_u->status));
4088
4089         return True;
4090 }
4091
4092
4093
4094 /*******************************************************************
4095 makes a SAMR_Q_ADD_ALIASMEM structure.
4096 ********************************************************************/
4097 BOOL make_samr_q_add_aliasmem(SAMR_Q_ADD_ALIASMEM *q_u, POLICY_HND *hnd,
4098                                 DOM_SID *sid)
4099 {
4100         if (q_u == NULL) return False;
4101
4102         DEBUG(5,("make_samr_q_add_aliasmem\n"));
4103
4104         memcpy(&(q_u->alias_pol), hnd, sizeof(q_u->alias_pol));
4105         make_dom_sid2(&q_u->sid, sid);
4106
4107         return True;
4108 }
4109
4110
4111 /*******************************************************************
4112 reads or writes a structure.
4113 ********************************************************************/
4114 BOOL samr_io_q_add_aliasmem(char *desc,  SAMR_Q_ADD_ALIASMEM *q_u, prs_struct *ps, int depth)
4115 {
4116         if (q_u == NULL) return False;
4117
4118         prs_debug(ps, depth, desc, "samr_io_q_add_aliasmem");
4119         depth++;
4120
4121         prs_align(ps);
4122
4123         smb_io_pol_hnd ("alias_pol", &(q_u->alias_pol), ps, depth);
4124         smb_io_dom_sid2("sid      ", &(q_u->sid      ), ps, depth);
4125
4126         return True;
4127 }
4128
4129 /*******************************************************************
4130 reads or writes a structure.
4131 ********************************************************************/
4132 BOOL samr_io_r_add_aliasmem(char *desc,  SAMR_R_ADD_ALIASMEM *r_u, prs_struct *ps, int depth)
4133 {
4134         if (r_u == NULL) return False;
4135
4136         prs_debug(ps, depth, desc, "samr_io_r_add_aliasmem");
4137         depth++;
4138
4139         prs_align(ps);
4140
4141         prs_uint32("status", ps, depth, &(r_u->status));
4142
4143         return True;
4144 }
4145
4146
4147 /*******************************************************************
4148 makes a SAMR_Q_DEL_ALIASMEM structure.
4149 ********************************************************************/
4150 BOOL make_samr_q_del_aliasmem(SAMR_Q_DEL_ALIASMEM *q_u, POLICY_HND *hnd,
4151                                 DOM_SID *sid)
4152 {
4153         if (q_u == NULL) return False;
4154
4155         DEBUG(5,("make_samr_q_del_aliasmem\n"));
4156
4157         memcpy(&(q_u->alias_pol), hnd, sizeof(q_u->alias_pol));
4158         make_dom_sid2(&q_u->sid, sid);
4159
4160         return True;
4161 }
4162
4163
4164 /*******************************************************************
4165 reads or writes a structure.
4166 ********************************************************************/
4167 BOOL samr_io_q_del_aliasmem(char *desc,  SAMR_Q_DEL_ALIASMEM *q_u, prs_struct *ps, int depth)
4168 {
4169         if (q_u == NULL) return False;
4170
4171         prs_debug(ps, depth, desc, "samr_io_q_del_aliasmem");
4172         depth++;
4173
4174         prs_align(ps);
4175
4176         smb_io_pol_hnd("alias_pol", &(q_u->alias_pol), ps, depth);
4177         smb_io_dom_sid2("sid      ", &(q_u->sid      ), ps, depth);
4178
4179         return True;
4180 }
4181
4182 /*******************************************************************
4183 reads or writes a structure.
4184 ********************************************************************/
4185 BOOL samr_io_r_del_aliasmem(char *desc,  SAMR_R_DEL_ALIASMEM *r_u, prs_struct *ps, int depth)
4186 {
4187         if (r_u == NULL) return False;
4188
4189         prs_debug(ps, depth, desc, "samr_io_r_del_aliasmem");
4190         depth++;
4191
4192         prs_align(ps);
4193
4194         prs_uint32("status", ps, depth, &(r_u->status));
4195
4196         return True;
4197 }
4198
4199 /*******************************************************************
4200 makes a SAMR_Q_DELETE_DOM_ALIAS structure.
4201 ********************************************************************/
4202 BOOL make_samr_q_delete_dom_alias(SAMR_Q_DELETE_DOM_ALIAS *q_c, POLICY_HND *hnd)
4203 {
4204         if (q_c == NULL || hnd == NULL) return False;
4205
4206         DEBUG(5,("make_samr_q_delete_dom_alias\n"));
4207
4208         memcpy(&(q_c->alias_pol), hnd, sizeof(q_c->alias_pol));
4209
4210         return True;
4211 }
4212
4213 /*******************************************************************
4214 reads or writes a structure.
4215 ********************************************************************/
4216 BOOL samr_io_q_delete_dom_alias(char *desc,  SAMR_Q_DELETE_DOM_ALIAS *q_u, prs_struct *ps, int depth)
4217 {
4218         if (q_u == NULL) return False;
4219
4220         prs_debug(ps, depth, desc, "samr_io_q_delete_dom_alias");
4221         depth++;
4222
4223         prs_align(ps);
4224
4225         smb_io_pol_hnd("alias_pol", &(q_u->alias_pol), ps, depth);
4226
4227         return True;
4228 }
4229
4230 /*******************************************************************
4231 makes a SAMR_R_DELETE_DOM_ALIAS structure.
4232 ********************************************************************/
4233 BOOL make_samr_r_delete_dom_alias(SAMR_R_DELETE_DOM_ALIAS *r_u,
4234                 uint32 status)
4235 {
4236         if (r_u == NULL) return False;
4237
4238         DEBUG(5,("make_samr_r_delete_dom_alias\n"));
4239
4240         r_u->status = status;
4241
4242         return True;
4243 }
4244
4245 /*******************************************************************
4246 reads or writes a structure.
4247 ********************************************************************/
4248 BOOL samr_io_r_delete_dom_alias(char *desc,  SAMR_R_DELETE_DOM_ALIAS *r_u, prs_struct *ps, int depth)
4249 {
4250         if (r_u == NULL) return False;
4251
4252         prs_debug(ps, depth, desc, "samr_io_r_delete_dom_alias");
4253         depth++;
4254
4255         prs_align(ps);
4256
4257         prs_uint32("status", ps, depth, &(r_u->status));
4258
4259         return True;
4260 }
4261
4262
4263 /*******************************************************************
4264 makes a SAMR_Q_QUERY_ALIASMEM structure.
4265 ********************************************************************/
4266 BOOL make_samr_q_query_aliasmem(SAMR_Q_QUERY_ALIASMEM *q_c,
4267                                 const POLICY_HND *hnd)
4268 {
4269         if (q_c == NULL || hnd == NULL) return False;
4270
4271         DEBUG(5,("make_samr_q_query_aliasmem\n"));
4272
4273         memcpy(&(q_c->alias_pol), hnd, sizeof(q_c->alias_pol));
4274
4275         return True;
4276 }
4277
4278 /*******************************************************************
4279 reads or writes a structure.
4280 ********************************************************************/
4281 BOOL samr_io_q_query_aliasmem(char *desc,  SAMR_Q_QUERY_ALIASMEM *q_u, prs_struct *ps, int depth)
4282 {
4283         if (q_u == NULL) return False;
4284
4285         prs_debug(ps, depth, desc, "samr_io_q_query_aliasmem");
4286         depth++;
4287
4288         prs_align(ps);
4289
4290         smb_io_pol_hnd("alias_pol", &(q_u->alias_pol), ps, depth);
4291
4292         return True;
4293 }
4294
4295 /*******************************************************************
4296 makes a SAMR_R_QUERY_ALIASMEM structure.
4297 ********************************************************************/
4298 BOOL make_samr_r_query_aliasmem(SAMR_R_QUERY_ALIASMEM *r_u,
4299                 uint32 num_sids, DOM_SID2 *sid, uint32 status)
4300 {
4301         if (r_u == NULL) return False;
4302
4303         DEBUG(5,("make_samr_r_query_aliasmem\n"));
4304
4305         if (status == 0x0)
4306         {
4307                 r_u->num_sids  = num_sids;
4308                 r_u->ptr       = (num_sids != 0) ? 1 : 0;
4309                 r_u->num_sids1 = num_sids;
4310
4311                 r_u->sid = sid;
4312         }
4313         else
4314         {
4315                 r_u->ptr      = 0;
4316                 r_u->num_sids = 0;
4317         }
4318
4319         r_u->status = status;
4320
4321         return True;
4322 }
4323
4324 /*******************************************************************
4325 reads or writes a structure.
4326 ********************************************************************/
4327 BOOL samr_io_r_query_aliasmem(char *desc,  SAMR_R_QUERY_ALIASMEM *r_u, prs_struct *ps, int depth)
4328 {
4329         uint32 i;
4330         uint32 ptr_sid[MAX_LOOKUP_SIDS];
4331
4332         if (r_u == NULL) return False;
4333
4334         prs_debug(ps, depth, desc, "samr_io_r_query_aliasmem");
4335         depth++;
4336
4337         prs_align(ps);
4338
4339         prs_uint32("num_sids ", ps, depth, &(r_u->num_sids));
4340         prs_uint32("ptr", ps, depth, &(r_u->ptr));
4341
4342         if (r_u->ptr != 0)
4343         {
4344                 SMB_ASSERT_ARRAY(ptr_sid, r_u->num_sids);
4345
4346                 if (r_u->num_sids != 0)
4347                 {
4348                         prs_uint32("num_sids1", ps, depth, &(r_u->num_sids1));
4349
4350                         for (i = 0; i < r_u->num_sids1; i++)
4351                         {
4352                                 ptr_sid[i] = 1;
4353                                 prs_uint32("", ps, depth, &(ptr_sid[i]));
4354                         }
4355                         for (i = 0; i < r_u->num_sids1; i++)
4356                         {
4357                                 if (ptr_sid[i] != 0)
4358                                 {
4359                                         smb_io_dom_sid2("", &(r_u->sid[i]), ps, depth);
4360                                 }
4361                         }
4362                 }
4363         }
4364         prs_uint32("status", ps, depth, &(r_u->status));
4365
4366         return True;
4367 }
4368
4369 /*******************************************************************
4370 makes a SAMR_Q_LOOKUP_NAMES structure.
4371 ********************************************************************/
4372 BOOL make_samr_q_lookup_names(SAMR_Q_LOOKUP_NAMES *q_u,
4373                 POLICY_HND *pol, uint32 flags,
4374                 uint32 num_names, char **name)
4375 {
4376         uint32 i;
4377         if (q_u == NULL) return False;
4378
4379         DEBUG(5,("make_samr_q_lookup_names\n"));
4380
4381         memcpy(&(q_u->pol), pol, sizeof(*pol));
4382
4383         q_u->num_names1 = num_names;
4384         q_u->flags     = flags;
4385         q_u->ptr       = 0;
4386         q_u->num_names2 = num_names;
4387
4388         for (i = 0; i < num_names; i++)
4389         {
4390                 int len_name = name[i] != NULL ? strlen(name[i]) : 0;
4391                 make_uni_hdr(&(q_u->hdr_name[i]), len_name);  /* unicode header for user_name */
4392                 make_unistr2(&(q_u->uni_name[i]), name[i], len_name);  /* unicode string for machine account */
4393         }
4394
4395         return True;
4396 }
4397
4398
4399 /*******************************************************************
4400 reads or writes a structure.
4401 ********************************************************************/
4402 BOOL samr_io_q_lookup_names(char *desc,  SAMR_Q_LOOKUP_NAMES *q_u, prs_struct *ps, int depth)
4403 {
4404         uint32 i;
4405
4406         if (q_u == NULL) return False;
4407
4408         prs_debug(ps, depth, desc, "samr_io_q_lookup_names");
4409         depth++;
4410
4411         prs_align(ps);
4412
4413         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
4414         prs_align(ps);
4415
4416         prs_uint32("num_names1", ps, depth, &(q_u->num_names1));
4417         prs_uint32("flags     ", ps, depth, &(q_u->flags     ));
4418         prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
4419         prs_uint32("num_names2", ps, depth, &(q_u->num_names2));
4420
4421         SMB_ASSERT_ARRAY(q_u->hdr_name, q_u->num_names2);
4422
4423         for (i = 0; i < q_u->num_names2; i++)
4424         {
4425                 smb_io_unihdr ("", &(q_u->hdr_name[i]), ps, depth);
4426         }
4427         for (i = 0; i < q_u->num_names2; i++)
4428         {
4429                 smb_io_unistr2("", &(q_u->uni_name[i]), q_u->hdr_name[i].buffer, ps, depth);
4430                 prs_align(ps);
4431         }
4432
4433         prs_align(ps);
4434
4435         return True;
4436 }
4437
4438
4439 /*******************************************************************
4440 makes a SAMR_R_LOOKUP_NAMES structure.
4441 ********************************************************************/
4442 BOOL make_samr_r_lookup_names(SAMR_R_LOOKUP_NAMES *r_u,
4443                 uint32 num_rids, uint32 *rid, uint8 *type, uint32 status)
4444 {
4445         uint32 i;
4446         if (r_u == NULL) return False;
4447
4448         DEBUG(5,("make_samr_r_lookup_names\n"));
4449
4450         if (status == 0x0)
4451         {
4452                 r_u->num_types1 = num_rids;
4453                 r_u->ptr_types  = 1;
4454                 r_u->num_types2 = num_rids;
4455
4456                 r_u->num_rids1 = num_rids;
4457                 r_u->ptr_rids  = 1;
4458                 r_u->num_rids2 = num_rids;
4459
4460                 SMB_ASSERT_ARRAY(r_u->rid, num_rids);
4461
4462                 for (i = 0; i < num_rids; i++)
4463                 {
4464                         r_u->rid [i] = rid [i];
4465                         r_u->type[i] = type[i];
4466                 }
4467         }
4468         else
4469         {
4470                 r_u->num_types1 = 0;
4471                 r_u->ptr_types  = 0;
4472                 r_u->num_types2 = 0;
4473
4474                 r_u->num_rids1 = 0;
4475                 r_u->ptr_rids  = 0;
4476                 r_u->num_rids2 = 0;
4477         }
4478
4479         r_u->status = status;
4480
4481         return True;
4482 }
4483
4484 /*******************************************************************
4485 reads or writes a structure.
4486 ********************************************************************/
4487 BOOL samr_io_r_lookup_names(char *desc,  SAMR_R_LOOKUP_NAMES *r_u, prs_struct *ps, int depth)
4488 {
4489         uint32 i;
4490         fstring tmp;
4491
4492         if (r_u == NULL) return False;
4493
4494         prs_debug(ps, depth, desc, "samr_io_r_lookup_names");
4495         depth++;
4496
4497         prs_align(ps);
4498
4499         prs_uint32("num_rids1", ps, depth, &(r_u->num_rids1));
4500         prs_uint32("ptr_rids ", ps, depth, &(r_u->ptr_rids ));
4501
4502         if (r_u->ptr_rids != 0)
4503         {
4504                 prs_uint32("num_rids2", ps, depth, &(r_u->num_rids2));
4505
4506                 if (r_u->num_rids2 != r_u->num_rids1)
4507                 {
4508                         /* RPC fault */
4509                         return False;
4510                 }
4511
4512                 for (i = 0; i < r_u->num_rids2; i++)
4513                 {
4514                         slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]  ", i);
4515                         prs_uint32(tmp, ps, depth, &(r_u->rid[i]));
4516                 }
4517         }
4518
4519         prs_uint32("num_types1", ps, depth, &(r_u->num_types1));
4520         prs_uint32("ptr_types ", ps, depth, &(r_u->ptr_types ));
4521
4522         if (r_u->ptr_types != 0)
4523         {
4524                 prs_uint32("num_types2", ps, depth, &(r_u->num_types2));
4525
4526                 if (r_u->num_types2 != r_u->num_types1)
4527                 {
4528                         /* RPC fault */
4529                         return False;
4530                 }
4531
4532                 for (i = 0; i < r_u->num_types2; i++)
4533                 {
4534                         slprintf(tmp, sizeof(tmp) - 1, "type[%02d]  ", i);
4535                         prs_uint32(tmp, ps, depth, &(r_u->type[i]));
4536                 }
4537         }
4538
4539         prs_uint32("status", ps, depth, &(r_u->status));
4540
4541         return True;
4542 }
4543
4544
4545 /*******************************************************************
4546 reads or writes a structure.
4547 ********************************************************************/
4548 BOOL make_samr_q_open_user(SAMR_Q_OPEN_USER *q_u,
4549                                 const POLICY_HND *pol,
4550                                 uint32 unk_0, uint32 rid)
4551 {
4552         if (q_u == NULL) return False;
4553
4554         DEBUG(5,("samr_make_samr_q_open_user\n"));
4555
4556         memcpy(&q_u->domain_pol, pol, sizeof(q_u->domain_pol));
4557
4558         q_u->unknown_0 = unk_0;
4559         q_u->user_rid  = rid;
4560
4561         return True;
4562 }
4563
4564 /*******************************************************************
4565 reads or writes a structure.
4566 ********************************************************************/
4567 BOOL samr_io_q_open_user(char *desc,  SAMR_Q_OPEN_USER *q_u, prs_struct *ps, int depth)
4568 {
4569         if (q_u == NULL) return False;
4570
4571         prs_debug(ps, depth, desc, "samr_io_q_open_user");
4572         depth++;
4573
4574         prs_align(ps);
4575
4576         smb_io_pol_hnd("domain_pol", &(q_u->domain_pol), ps, depth);
4577         prs_align(ps);
4578
4579         prs_uint32("unknown_0", ps, depth, &(q_u->unknown_0));
4580         prs_uint32("user_rid ", ps, depth, &(q_u->user_rid ));
4581
4582         prs_align(ps);
4583
4584         return True;
4585 }
4586
4587 /*******************************************************************
4588 reads or writes a structure.
4589 ********************************************************************/
4590 BOOL samr_io_r_open_user(char *desc,  SAMR_R_OPEN_USER *r_u, prs_struct *ps, int depth)
4591 {
4592         if (r_u == NULL) return False;
4593
4594         prs_debug(ps, depth, desc, "samr_io_r_open_user");
4595         depth++;
4596
4597         prs_align(ps);
4598
4599         smb_io_pol_hnd("user_pol", &(r_u->user_pol), ps, depth);
4600         prs_align(ps);
4601
4602         prs_uint32("status", ps, depth, &(r_u->status));
4603
4604         return True;
4605 }
4606
4607 /*******************************************************************
4608 reads or writes a structure.
4609 ********************************************************************/
4610 BOOL make_samr_q_create_user(SAMR_Q_CREATE_USER *q_u,
4611                                 POLICY_HND *pol,
4612                                 const char *name,
4613                                 uint16 acb_info, uint32 unk_1)
4614 {
4615         int len_name;
4616         if (q_u == NULL) return False;
4617         len_name = strlen(name);
4618
4619         DEBUG(5,("samr_make_samr_q_create_user\n"));
4620
4621         memcpy(&q_u->domain_pol, pol, sizeof(q_u->domain_pol));
4622
4623         make_uni_hdr(&(q_u->hdr_name), len_name);
4624         make_unistr2(&(q_u->uni_name), name, len_name);
4625
4626         q_u->acb_info = acb_info;
4627         q_u->unknown_1 = unk_1;
4628
4629         return True;
4630 }
4631
4632 /*******************************************************************
4633 reads or writes a structure.
4634 ********************************************************************/
4635 BOOL samr_io_q_create_user(char *desc,  SAMR_Q_CREATE_USER *q_u, prs_struct *ps, int depth)
4636 {
4637         if (q_u == NULL) return False;
4638
4639         prs_debug(ps, depth, desc, "samr_io_q_create_user");
4640         depth++;
4641
4642         prs_align(ps);
4643
4644         smb_io_pol_hnd("domain_pol", &(q_u->domain_pol), ps, depth);
4645         prs_align(ps);
4646
4647         smb_io_unihdr ("unihdr", &(q_u->hdr_name), ps, depth);
4648         smb_io_unistr2("unistr2", &(q_u->uni_name), q_u->hdr_name.buffer, ps, depth);
4649         prs_align(ps);
4650
4651         prs_uint16("acb_info", ps, depth, &(q_u->acb_info));
4652         prs_align(ps);
4653         prs_uint32("unknown_1", ps, depth, &(q_u->unknown_1));
4654
4655         prs_align(ps);
4656
4657         return True;
4658 }
4659
4660 /*******************************************************************
4661 reads or writes a structure.
4662 ********************************************************************/
4663 BOOL make_samr_r_create_user(SAMR_R_CREATE_USER *r_u,
4664                                 POLICY_HND *user_pol,
4665                                 uint32 unk_0, uint32 user_rid,
4666                                 uint32 status)
4667 {
4668         if (r_u == NULL) return False;
4669
4670         DEBUG(5,("samr_make_samr_r_create_user\n"));
4671
4672         memcpy(&r_u->user_pol, user_pol, sizeof(r_u->user_pol));
4673
4674         r_u->unknown_0 = unk_0;
4675         r_u->user_rid = user_rid;
4676         r_u->status = status;
4677
4678         return True;
4679 }
4680
4681 /*******************************************************************
4682 reads or writes a structure.
4683 ********************************************************************/
4684 BOOL samr_io_r_create_user(char *desc,  SAMR_R_CREATE_USER *r_u, prs_struct *ps, int depth)
4685 {
4686         if (r_u == NULL) return False;
4687
4688         prs_debug(ps, depth, desc, "samr_io_r_create_user");
4689         depth++;
4690
4691         prs_align(ps);
4692
4693         smb_io_pol_hnd("user_pol", &(r_u->user_pol), ps, depth);
4694         prs_align(ps);
4695
4696         prs_uint32("unknown_0", ps, depth, &(r_u->unknown_0));
4697         prs_uint32("user_rid ", ps, depth, &(r_u->user_rid ));
4698         prs_uint32("status", ps, depth, &(r_u->status));
4699
4700         return True;
4701 }
4702
4703 /*******************************************************************
4704 makes a SAMR_Q_QUERY_USERINFO structure.
4705 ********************************************************************/
4706 BOOL make_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO *q_u,
4707                                 POLICY_HND *hnd, uint16 switch_value)
4708 {
4709         if (q_u == NULL || hnd == NULL) return False;
4710
4711         DEBUG(5,("make_samr_q_query_userinfo\n"));
4712
4713         memcpy(&(q_u->pol), hnd, sizeof(q_u->pol));
4714         q_u->switch_value = switch_value;
4715
4716         return True;
4717 }
4718
4719
4720 /*******************************************************************
4721 reads or writes a structure.
4722 ********************************************************************/
4723 BOOL samr_io_q_query_userinfo(char *desc,  SAMR_Q_QUERY_USERINFO *q_u, prs_struct *ps, int depth)
4724 {
4725         if (q_u == NULL) return False;
4726
4727         prs_debug(ps, depth, desc, "samr_io_q_query_userinfo");
4728         depth++;
4729
4730         prs_align(ps);
4731
4732         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
4733         prs_align(ps);
4734
4735         prs_uint16("switch_value", ps, depth, &(q_u->switch_value)); /* 0x0015 or 0x0011 */
4736
4737         prs_align(ps);
4738
4739         return True;
4740 }
4741
4742 /*******************************************************************
4743 reads or writes a LOGON_HRS structure.
4744 ********************************************************************/
4745 static BOOL sam_io_logon_hrs(char *desc,  LOGON_HRS *hrs, prs_struct *ps, int depth)
4746 {
4747         if (hrs == NULL) return False;
4748
4749         prs_debug(ps, depth, desc, "sam_io_logon_hrs");
4750         depth++;
4751
4752         prs_align(ps);
4753
4754         prs_uint32 (       "len  ", ps, depth, &(hrs->len ));
4755
4756         if (hrs->len > 64)
4757         {
4758                 DEBUG(5,("sam_io_logon_hrs: truncating length\n"));
4759                 hrs->len = 64;
4760         }
4761
4762         prs_uint8s (False, "hours", ps, depth, hrs->hours, hrs->len);
4763
4764         return True;
4765 }
4766
4767 /*******************************************************************
4768 makes a SAM_USER_INFO_10 structure.
4769 ********************************************************************/
4770 BOOL make_sam_user_info10(SAM_USER_INFO_10 *usr,
4771                                 uint32 acb_info)
4772 {
4773         if (usr == NULL) return False;
4774
4775         DEBUG(5,("make_sam_user_info10\n"));
4776
4777         usr->acb_info = acb_info;
4778
4779         return True;
4780 }
4781
4782 /*******************************************************************
4783 reads or writes a structure.
4784 ********************************************************************/
4785 BOOL sam_io_user_info10(char *desc,  SAM_USER_INFO_10 *usr, prs_struct *ps, int depth)
4786 {
4787         if (usr == NULL) return False;
4788
4789         prs_debug(ps, depth, desc, "samr_io_r_user_info10");
4790         depth++;
4791
4792         prs_align(ps);
4793
4794         prs_uint32("acb_info", ps, depth, &(usr->acb_info));
4795
4796         return True;
4797 }
4798
4799 /*******************************************************************
4800 makes a SAM_USER_INFO_11 structure.
4801 ********************************************************************/
4802 BOOL make_sam_user_info11(SAM_USER_INFO_11 *usr,
4803                                 NTTIME *expiry,
4804                                 char *mach_acct,
4805                                 uint32 rid_user,
4806                                 uint32 rid_group,
4807                                 uint16 acct_ctrl)
4808
4809 {
4810         int len_mach_acct;
4811         if (usr == NULL || expiry == NULL || mach_acct == NULL) return False;
4812
4813         DEBUG(5,("make_sam_user_info11\n"));
4814
4815         len_mach_acct = strlen(mach_acct);
4816
4817         memcpy(&(usr->expiry),expiry, sizeof(usr->expiry)); /* expiry time or something? */
4818         bzero(usr->padding_1, sizeof(usr->padding_1)); /* 0 - padding 24 bytes */
4819
4820         make_uni_hdr(&(usr->hdr_mach_acct), len_mach_acct);  /* unicode header for machine account */
4821         usr->padding_2 = 0;               /* 0 - padding 4 bytes */
4822
4823         usr->ptr_1        = 1;            /* pointer */
4824         bzero(usr->padding_3, sizeof(usr->padding_3)); /* 0 - padding 32 bytes */
4825         usr->padding_4    = 0;            /* 0 - padding 4 bytes */
4826
4827         usr->ptr_2        = 1;            /* pointer */
4828         usr->padding_5    = 0;            /* 0 - padding 4 bytes */
4829
4830         usr->ptr_3        = 1;          /* pointer */
4831         bzero(usr->padding_6, sizeof(usr->padding_6)); /* 0 - padding 32 bytes */
4832
4833         usr->rid_user     = rid_user;
4834         usr->rid_group    = rid_group;
4835
4836         usr->acct_ctrl    = acct_ctrl;
4837         usr->unknown_3    = 0x0000;
4838
4839         usr->unknown_4    = 0x003f;       /* 0x003f      - 16 bit unknown */
4840         usr->unknown_5    = 0x003c;       /* 0x003c      - 16 bit unknown */
4841
4842         bzero(usr->padding_7, sizeof(usr->padding_7)); /* 0 - padding 16 bytes */
4843         usr->padding_8    = 0;            /* 0 - padding 4 bytes */
4844
4845         make_unistr2(&(usr->uni_mach_acct), mach_acct, len_mach_acct);  /* unicode string for machine account */
4846
4847         return True;
4848 }
4849
4850 /*******************************************************************
4851 reads or writes a structure.
4852 ********************************************************************/
4853 BOOL sam_io_user_info11(char *desc,  SAM_USER_INFO_11 *usr, prs_struct *ps, int depth)
4854 {
4855         if (usr == NULL) return False;
4856
4857         prs_debug(ps, depth, desc, "samr_io_r_unknown_11");
4858         depth++;
4859
4860         prs_align(ps);
4861
4862         prs_uint8s (False, "padding_0", ps, depth, usr->padding_0, sizeof(usr->padding_0));
4863
4864         smb_io_time("time", &(usr->expiry), ps, depth);
4865
4866         prs_uint8s (False, "padding_1", ps, depth, usr->padding_1, sizeof(usr->padding_1));
4867
4868         smb_io_unihdr ("unihdr", &(usr->hdr_mach_acct), ps, depth);
4869         prs_uint32(        "padding_2", ps, depth, &(usr->padding_2));
4870
4871         prs_uint32(        "ptr_1    ", ps, depth, &(usr->ptr_1    ));
4872         prs_uint8s (False, "padding_3", ps, depth, usr->padding_3, sizeof(usr->padding_3));
4873         prs_uint32(        "padding_4", ps, depth, &(usr->padding_4));
4874
4875         prs_uint32(        "ptr_2    ", ps, depth, &(usr->ptr_2    ));
4876         prs_uint32(        "padding_5", ps, depth, &(usr->padding_5));
4877
4878         prs_uint32(        "ptr_3    ", ps, depth, &(usr->ptr_3    ));
4879         prs_uint8s (False, "padding_6", ps, depth, usr->padding_6, sizeof(usr->padding_6));
4880
4881         prs_uint32(        "rid_user ", ps, depth, &(usr->rid_user ));
4882         prs_uint32(        "rid_group", ps, depth, &(usr->rid_group));
4883         prs_uint16(        "acct_ctrl", ps, depth, &(usr->acct_ctrl));
4884         prs_uint16(        "unknown_3", ps, depth, &(usr->unknown_3));
4885         prs_uint16(        "unknown_4", ps, depth, &(usr->unknown_4));
4886         prs_uint16(        "unknown_5", ps, depth, &(usr->unknown_5));
4887
4888         prs_uint8s (False, "padding_7", ps, depth, usr->padding_7, sizeof(usr->padding_7));
4889         prs_uint32(        "padding_8", ps, depth, &(usr->padding_8));
4890
4891         smb_io_unistr2("unistr2", &(usr->uni_mach_acct), True, ps, depth);
4892         prs_align(ps);
4893
4894         prs_uint8s (False, "padding_9", ps, depth, usr->padding_9, sizeof(usr->padding_9));
4895
4896         return True;
4897 }
4898
4899 /*************************************************************************
4900  make_sam_user_infoa
4901
4902  unknown_3 = 0x09f8 27fa
4903  unknown_5 = 0x0001 0000
4904  unknown_6 = 0x0000 04ec
4905
4906  *************************************************************************/
4907 BOOL make_sam_user_info24(SAM_USER_INFO_24 *usr,
4908         char newpass[516], uint16 passlen)
4909 {
4910         memcpy(usr->pass, newpass, sizeof(usr->pass));
4911         usr->unk_0 = passlen;
4912
4913         return True;
4914 }
4915
4916 /*******************************************************************
4917 reads or writes a structure.
4918 ********************************************************************/
4919 static BOOL sam_io_user_info24(char *desc, SAM_USER_INFO_24 *usr, prs_struct *ps, int depth)
4920 {
4921         if (usr == NULL) return False;
4922
4923         prs_debug(ps, depth, desc, "sam_io_user_info24");
4924         depth++;
4925
4926         prs_align(ps);
4927
4928         prs_uint8s (False, "password", ps, depth, usr->pass, sizeof(usr->pass));
4929         prs_uint16("unk_0", ps, depth, &(usr->unk_0));      /* unknown */
4930         prs_align(ps);
4931
4932         return True;
4933 }
4934
4935
4936 /*************************************************************************
4937  make_sam_user_info23
4938
4939  unknown_3 = 0x09f8 27fa
4940  unknown_5 = 0x0001 0000
4941  unknown_6 = 0x0000 04ec
4942
4943  *************************************************************************/
4944 BOOL make_sam_user_info23W(SAM_USER_INFO_23 *usr,
4945
4946         NTTIME *logon_time, /* all zeros */
4947         NTTIME *logoff_time, /* all zeros */
4948         NTTIME *kickoff_time, /* all zeros */
4949         NTTIME *pass_last_set_time, /* all zeros */
4950         NTTIME *pass_can_change_time, /* all zeros */
4951         NTTIME *pass_must_change_time, /* all zeros */
4952
4953         UNISTR2 *user_name, /* NULL */
4954         UNISTR2 *full_name,
4955         UNISTR2 *home_dir,
4956         UNISTR2 *dir_drive,
4957         UNISTR2 *log_scr,
4958         UNISTR2 *prof_path,
4959         UNISTR2 *desc,
4960         UNISTR2 *wkstas,
4961         UNISTR2 *unk_str,
4962         UNISTR2 *mung_dial,
4963
4964         uint32 user_rid, /* 0x0000 0000 */
4965         uint32 group_rid,
4966         uint16 acb_info,
4967
4968         uint32 unknown_3,
4969         uint16 logon_divs,
4970         LOGON_HRS *hrs,
4971         uint32 unknown_5,
4972         char newpass[516],
4973         uint32 unknown_6)
4974 {
4975         int len_user_name    = user_name != NULL ? user_name->uni_str_len : 0;
4976         int len_full_name    = full_name != NULL ? full_name->uni_str_len : 0;
4977         int len_home_dir     = home_dir  != NULL ? home_dir ->uni_str_len : 0;
4978         int len_dir_drive    = dir_drive != NULL ? dir_drive->uni_str_len : 0;
4979         int len_logon_script = log_scr   != NULL ? log_scr  ->uni_str_len : 0;
4980         int len_profile_path = prof_path != NULL ? prof_path->uni_str_len : 0;
4981         int len_description  = desc      != NULL ? desc     ->uni_str_len : 0;
4982         int len_workstations = wkstas    != NULL ? wkstas   ->uni_str_len : 0;
4983         int len_unknown_str  = unk_str   != NULL ? unk_str  ->uni_str_len : 0;
4984         int len_munged_dial  = mung_dial != NULL ? mung_dial->uni_str_len : 0;
4985
4986         usr->logon_time            = *logon_time; /* all zeros */
4987         usr->logoff_time           = *logoff_time; /* all zeros */
4988         usr->kickoff_time          = *kickoff_time; /* all zeros */
4989         usr->pass_last_set_time    = *pass_last_set_time; /* all zeros */
4990         usr->pass_can_change_time  = *pass_can_change_time; /* all zeros */
4991         usr->pass_must_change_time = *pass_must_change_time; /* all zeros */
4992
4993         make_uni_hdr(&(usr->hdr_user_name   ), len_user_name   ); /* NULL */
4994         make_uni_hdr(&(usr->hdr_full_name   ), len_full_name   );
4995         make_uni_hdr(&(usr->hdr_home_dir    ), len_home_dir    );
4996         make_uni_hdr(&(usr->hdr_dir_drive   ), len_dir_drive   );
4997         make_uni_hdr(&(usr->hdr_logon_script), len_logon_script);
4998         make_uni_hdr(&(usr->hdr_profile_path), len_profile_path);
4999         make_uni_hdr(&(usr->hdr_acct_desc   ), len_description );
5000         make_uni_hdr(&(usr->hdr_workstations), len_workstations);
5001         make_uni_hdr(&(usr->hdr_unknown_str ), len_unknown_str );
5002         make_uni_hdr(&(usr->hdr_munged_dial ), len_munged_dial );
5003
5004         bzero(usr->nt_pwd, sizeof(usr->nt_pwd));
5005         bzero(usr->lm_pwd, sizeof(usr->lm_pwd));
5006
5007         usr->user_rid  = user_rid; /* 0x0000 0000 */
5008         usr->group_rid = group_rid;
5009         usr->acb_info = acb_info;
5010         usr->unknown_3 = unknown_3; /* 09f8 27fa */
5011
5012         usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5013         usr->ptr_logon_hrs = hrs ? 1 : 0;
5014
5015         bzero(usr->padding1, sizeof(usr->padding1));
5016
5017         usr->unknown_5 = unknown_5; /* 0x0001 0000 */
5018
5019         memcpy(usr->pass, newpass, sizeof(usr->pass));
5020
5021         copy_unistr2(&(usr->uni_user_name   ), user_name);
5022         copy_unistr2(&(usr->uni_full_name   ), full_name);
5023         copy_unistr2(&(usr->uni_home_dir    ), home_dir );
5024         copy_unistr2(&(usr->uni_dir_drive   ), dir_drive);
5025         copy_unistr2(&(usr->uni_logon_script), log_scr  );
5026         copy_unistr2(&(usr->uni_profile_path), prof_path);
5027         copy_unistr2(&(usr->uni_acct_desc   ), desc     );
5028         copy_unistr2(&(usr->uni_workstations), wkstas   );
5029         copy_unistr2(&(usr->uni_unknown_str ), unk_str  );
5030         copy_unistr2(&(usr->uni_munged_dial ), mung_dial);
5031
5032         usr->unknown_6 = unknown_6; /* 0x0000 04ec */
5033         usr->padding4 = 0;
5034
5035         if (hrs)
5036         {
5037                 memcpy(&(usr->logon_hrs), hrs, sizeof(usr->logon_hrs));
5038         }
5039         else
5040         {
5041                 memset(&(usr->logon_hrs), 0xff, sizeof(usr->logon_hrs));
5042         }
5043
5044         return True;
5045 }
5046
5047 /*************************************************************************
5048  make_sam_user_info23
5049
5050  unknown_3 = 0x09f8 27fa
5051  unknown_5 = 0x0001 0000
5052  unknown_6 = 0x0000 04ec
5053
5054  *************************************************************************/
5055 BOOL make_sam_user_info23A(SAM_USER_INFO_23 *usr,
5056
5057         NTTIME *logon_time, /* all zeros */
5058         NTTIME *logoff_time, /* all zeros */
5059         NTTIME *kickoff_time, /* all zeros */
5060         NTTIME *pass_last_set_time, /* all zeros */
5061         NTTIME *pass_can_change_time, /* all zeros */
5062         NTTIME *pass_must_change_time, /* all zeros */
5063
5064         char *user_name, /* NULL */
5065         char *full_name,
5066         char *home_dir,
5067         char *dir_drive,
5068         char *log_scr,
5069         char *prof_path,
5070         char *desc,
5071         char *wkstas,
5072         char *unk_str,
5073         char *mung_dial,
5074
5075         uint32 user_rid, /* 0x0000 0000 */
5076         uint32 group_rid,
5077         uint16 acb_info,
5078
5079         uint32 unknown_3,
5080         uint16 logon_divs,
5081         LOGON_HRS *hrs,
5082         uint32 unknown_5,
5083         char newpass[516],
5084         uint32 unknown_6)
5085 {
5086         int len_user_name    = user_name != NULL ? strlen(user_name) : 0;
5087         int len_full_name    = full_name != NULL ? strlen(full_name) : 0;
5088         int len_home_dir     = home_dir  != NULL ? strlen(home_dir ) : 0;
5089         int len_dir_drive    = dir_drive != NULL ? strlen(dir_drive) : 0;
5090         int len_logon_script = log_scr   != NULL ? strlen(log_scr  ) : 0;
5091         int len_profile_path = prof_path != NULL ? strlen(prof_path) : 0;
5092         int len_description  = desc      != NULL ? strlen(desc     ) : 0;
5093         int len_workstations = wkstas    != NULL ? strlen(wkstas   ) : 0;
5094         int len_unknown_str  = unk_str   != NULL ? strlen(unk_str  ) : 0;
5095         int len_munged_dial  = mung_dial != NULL ? strlen(mung_dial) : 0;
5096
5097         usr->logon_time            = *logon_time; /* all zeros */
5098         usr->logoff_time           = *logoff_time; /* all zeros */
5099         usr->kickoff_time          = *kickoff_time; /* all zeros */
5100         usr->pass_last_set_time    = *pass_last_set_time; /* all zeros */
5101         usr->pass_can_change_time  = *pass_can_change_time; /* all zeros */
5102         usr->pass_must_change_time = *pass_must_change_time; /* all zeros */
5103
5104         make_uni_hdr(&(usr->hdr_user_name   ), len_user_name   ); /* NULL */
5105         make_uni_hdr(&(usr->hdr_full_name   ), len_full_name   );
5106         make_uni_hdr(&(usr->hdr_home_dir    ), len_home_dir    );
5107         make_uni_hdr(&(usr->hdr_dir_drive   ), len_dir_drive   );
5108         make_uni_hdr(&(usr->hdr_logon_script), len_logon_script);
5109         make_uni_hdr(&(usr->hdr_profile_path), len_profile_path);
5110         make_uni_hdr(&(usr->hdr_acct_desc   ), len_description );
5111         make_uni_hdr(&(usr->hdr_workstations), len_workstations);
5112         make_uni_hdr(&(usr->hdr_unknown_str ), len_unknown_str );
5113         make_uni_hdr(&(usr->hdr_munged_dial ), len_munged_dial );
5114
5115         bzero(usr->nt_pwd, sizeof(usr->nt_pwd));
5116         bzero(usr->lm_pwd, sizeof(usr->lm_pwd));
5117
5118         usr->user_rid  = user_rid; /* 0x0000 0000 */
5119         usr->group_rid = group_rid;
5120         usr->acb_info = acb_info;
5121         usr->unknown_3 = unknown_3; /* 09f8 27fa */
5122
5123         usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5124         usr->ptr_logon_hrs = hrs ? 1 : 0;
5125
5126         bzero(usr->padding1, sizeof(usr->padding1));
5127
5128         usr->unknown_5 = unknown_5; /* 0x0001 0000 */
5129
5130         memcpy(usr->pass, newpass, sizeof(usr->pass));
5131
5132         make_unistr2(&(usr->uni_user_name   ), user_name   , len_user_name   ); /* NULL */
5133         make_unistr2(&(usr->uni_full_name   ), full_name   , len_full_name   );
5134         make_unistr2(&(usr->uni_home_dir    ), home_dir    , len_home_dir    );
5135         make_unistr2(&(usr->uni_dir_drive   ), dir_drive   , len_dir_drive   );
5136         make_unistr2(&(usr->uni_logon_script), log_scr, len_logon_script);
5137         make_unistr2(&(usr->uni_profile_path), prof_path, len_profile_path);
5138         make_unistr2(&(usr->uni_acct_desc ), desc , len_description );
5139         make_unistr2(&(usr->uni_workstations), wkstas, len_workstations);
5140         make_unistr2(&(usr->uni_unknown_str ), unk_str , len_unknown_str );
5141         make_unistr2(&(usr->uni_munged_dial ), mung_dial , len_munged_dial );
5142
5143         usr->unknown_6 = unknown_6; /* 0x0000 04ec */
5144         usr->padding4 = 0;
5145
5146         if (hrs)
5147         {
5148                 memcpy(&(usr->logon_hrs), hrs, sizeof(usr->logon_hrs));
5149         }
5150         else
5151         {
5152                 memset(&(usr->logon_hrs), 0xff, sizeof(usr->logon_hrs));
5153         }
5154
5155         return True;
5156 }
5157
5158 /*******************************************************************
5159 reads or writes a structure.
5160 ********************************************************************/
5161 static BOOL sam_io_user_info16(char *desc,  SAM_USER_INFO_16 *usr, prs_struct *ps, int depth)
5162 {
5163         if (usr == NULL) return False;
5164
5165         prs_debug(ps, depth, desc, "sam_io_user_info16");
5166         depth++;
5167
5168         prs_align(ps);
5169
5170         prs_uint16("acb_info", ps, depth, &(usr->acb_info));
5171         prs_align(ps);
5172
5173         return True;
5174 }
5175
5176 /*******************************************************************
5177 reads or writes a structure.
5178 ********************************************************************/
5179 static BOOL sam_io_user_info23(char *desc,  SAM_USER_INFO_23 *usr, prs_struct *ps, int depth)
5180 {
5181         if (usr == NULL) return False;
5182
5183         prs_debug(ps, depth, desc, "sam_io_user_info23");
5184         depth++;
5185
5186         prs_align(ps);
5187
5188         smb_io_time("logon_time           ", &(usr->logon_time)           , ps, depth);
5189         smb_io_time("logoff_time          ", &(usr->logoff_time)          , ps, depth);
5190         smb_io_time("kickoff_time         ", &(usr->kickoff_time)         , ps, depth);
5191         smb_io_time("pass_last_set_time   ", &(usr->pass_last_set_time)   , ps, depth);
5192         smb_io_time("pass_can_change_time ", &(usr->pass_can_change_time) , ps, depth);
5193         smb_io_time("pass_must_change_time", &(usr->pass_must_change_time), ps, depth);
5194
5195         smb_io_unihdr("hdr_user_name   ", &(usr->hdr_user_name)   , ps, depth); /* username unicode string header */
5196         smb_io_unihdr("hdr_full_name   ", &(usr->hdr_full_name)   , ps, depth); /* user's full name unicode string header */
5197         smb_io_unihdr("hdr_home_dir    ", &(usr->hdr_home_dir)    , ps, depth); /* home directory unicode string header */
5198         smb_io_unihdr("hdr_dir_drive   ", &(usr->hdr_dir_drive)   , ps, depth); /* home directory drive */
5199         smb_io_unihdr("hdr_logon_script", &(usr->hdr_logon_script), ps, depth); /* logon script unicode string header */
5200         smb_io_unihdr("hdr_profile_path", &(usr->hdr_profile_path), ps, depth); /* profile path unicode string header */
5201         smb_io_unihdr("hdr_acct_desc   ", &(usr->hdr_acct_desc  ) , ps, depth); /* account desc */
5202         smb_io_unihdr("hdr_workstations", &(usr->hdr_workstations), ps, depth); /* wkstas user can log on from */
5203         smb_io_unihdr("hdr_unknown_str ", &(usr->hdr_unknown_str ), ps, depth); /* unknown string */
5204         smb_io_unihdr("hdr_munged_dial ", &(usr->hdr_munged_dial ), ps, depth); /* wkstas user can log on from */
5205
5206         prs_uint8s (False, "lm_pwd        ", ps, depth, usr->lm_pwd   , sizeof(usr->lm_pwd   ));
5207         prs_uint8s (False, "nt_pwd        ", ps, depth, usr->nt_pwd   , sizeof(usr->nt_pwd   ));
5208
5209         prs_uint32("user_rid      ", ps, depth, &(usr->user_rid     ));       /* User ID */
5210         prs_uint32("group_rid     ", ps, depth, &(usr->group_rid    ));      /* Group ID */
5211         prs_uint16("acb_info      ", ps, depth, &(usr->acb_info     ));      /* Group ID */
5212         prs_align(ps);
5213
5214         prs_uint32("unknown_3     ", ps, depth, &(usr->unknown_3    ));
5215         prs_uint16("logon_divs    ", ps, depth, &(usr->logon_divs   ));     /* logon divisions per week */
5216         prs_align(ps);
5217         prs_uint32("ptr_logon_hrs ", ps, depth, &(usr->ptr_logon_hrs));
5218         prs_uint8s (False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1));
5219         prs_uint32("unknown_5     ", ps, depth, &(usr->unknown_5    ));
5220
5221         prs_uint8s (False, "password      ", ps, depth, usr->pass, sizeof(usr->pass));
5222
5223         /* here begins pointed-to data */
5224
5225         smb_io_unistr2("uni_user_name   ", &(usr->uni_user_name)   , usr->hdr_user_name   .buffer, ps, depth); /* username unicode string */
5226         prs_align(ps);
5227         smb_io_unistr2("uni_full_name   ", &(usr->uni_full_name)   , usr->hdr_full_name   .buffer, ps, depth); /* user's full name unicode string */
5228         prs_align(ps);
5229         smb_io_unistr2("uni_home_dir    ", &(usr->uni_home_dir)    , usr->hdr_home_dir    .buffer, ps, depth); /* home directory unicode string */
5230         prs_align(ps);
5231         smb_io_unistr2("uni_dir_drive   ", &(usr->uni_dir_drive)   , usr->hdr_dir_drive   .buffer, ps, depth); /* home directory drive unicode string */
5232         prs_align(ps);
5233         smb_io_unistr2("uni_logon_script", &(usr->uni_logon_script), usr->hdr_logon_script.buffer, ps, depth); /* logon script unicode string */
5234         prs_align(ps);
5235         smb_io_unistr2("uni_profile_path", &(usr->uni_profile_path), usr->hdr_profile_path.buffer, ps, depth); /* profile path unicode string */
5236         prs_align(ps);
5237         smb_io_unistr2("uni_acct_desc   ", &(usr->uni_acct_desc   ), usr->hdr_acct_desc   .buffer, ps, depth); /* user desc unicode string */
5238         prs_align(ps);
5239         smb_io_unistr2("uni_workstations", &(usr->uni_workstations), usr->hdr_workstations.buffer, ps, depth); /* worksations user can log on from */
5240         prs_align(ps);
5241         smb_io_unistr2("uni_unknown_str ", &(usr->uni_unknown_str ), usr->hdr_unknown_str .buffer, ps, depth); /* unknown string */
5242         prs_align(ps);
5243         smb_io_unistr2("uni_munged_dial ", &(usr->uni_munged_dial ), usr->hdr_munged_dial .buffer, ps, depth); /* worksations user can log on from */
5244         prs_align(ps);
5245
5246         prs_uint32("unknown_6     ", ps, depth, &(usr->unknown_6  ));
5247         prs_uint32("padding4      ", ps, depth, &(usr->padding4   ));
5248
5249         if (usr->ptr_logon_hrs)
5250         {
5251                 sam_io_logon_hrs("logon_hrs", &(usr->logon_hrs)   , ps, depth);
5252                 prs_align(ps);
5253         }
5254
5255         return True;
5256 }
5257
5258
5259 /*************************************************************************
5260  make_sam_user_info21
5261
5262  unknown_3 = 0x00ff ffff
5263  unknown_5 = 0x0002 0000
5264  unknown_6 = 0x0000 04ec
5265
5266  *************************************************************************/
5267 BOOL make_sam_user_info21(SAM_USER_INFO_21 *usr,
5268
5269         NTTIME *logon_time,
5270         NTTIME *logoff_time,
5271         NTTIME *kickoff_time,
5272         NTTIME *pass_last_set_time,
5273         NTTIME *pass_can_change_time,
5274         NTTIME *pass_must_change_time,
5275
5276         char *user_name,
5277         char *full_name,
5278         char *home_dir,
5279         char *dir_drive,
5280         char *log_scr,
5281         char *prof_path,
5282         char *desc,
5283         char *wkstas,
5284         char *unk_str,
5285         char *mung_dial,
5286
5287         uint32 user_rid,
5288         uint32 group_rid,
5289         uint16 acb_info,
5290
5291         uint32 unknown_3,
5292         uint16 logon_divs,
5293         LOGON_HRS *hrs,
5294         uint32 unknown_5,
5295         uint32 unknown_6)
5296 {
5297         int len_user_name    = user_name != NULL ? strlen(user_name) : 0;
5298         int len_full_name    = full_name != NULL ? strlen(full_name) : 0;
5299         int len_home_dir     = home_dir  != NULL ? strlen(home_dir ) : 0;
5300         int len_dir_drive    = dir_drive != NULL ? strlen(dir_drive) : 0;
5301         int len_logon_script = log_scr   != NULL ? strlen(log_scr  ) : 0;
5302         int len_profile_path = prof_path != NULL ? strlen(prof_path) : 0;
5303         int len_description  = desc      != NULL ? strlen(desc     ) : 0;
5304         int len_workstations = wkstas    != NULL ? strlen(wkstas   ) : 0;
5305         int len_unknown_str  = unk_str   != NULL ? strlen(unk_str  ) : 0;
5306         int len_munged_dial  = mung_dial != NULL ? strlen(mung_dial) : 0;
5307
5308         usr->logon_time            = *logon_time;
5309         usr->logoff_time           = *logoff_time;
5310         usr->kickoff_time          = *kickoff_time;
5311         usr->pass_last_set_time    = *pass_last_set_time;
5312         usr->pass_can_change_time  = *pass_can_change_time;
5313         usr->pass_must_change_time = *pass_must_change_time;
5314
5315         make_uni_hdr(&(usr->hdr_user_name   ), len_user_name   );
5316         make_uni_hdr(&(usr->hdr_full_name   ), len_full_name   );
5317         make_uni_hdr(&(usr->hdr_home_dir    ), len_home_dir    );
5318         make_uni_hdr(&(usr->hdr_dir_drive   ), len_dir_drive   );
5319         make_uni_hdr(&(usr->hdr_logon_script), len_logon_script);
5320         make_uni_hdr(&(usr->hdr_profile_path), len_profile_path);
5321         make_uni_hdr(&(usr->hdr_acct_desc   ), len_description );
5322         make_uni_hdr(&(usr->hdr_workstations), len_workstations);
5323         make_uni_hdr(&(usr->hdr_unknown_str ), len_unknown_str );
5324         make_uni_hdr(&(usr->hdr_munged_dial ), len_munged_dial );
5325
5326         bzero(usr->nt_pwd, sizeof(usr->nt_pwd));
5327         bzero(usr->lm_pwd, sizeof(usr->lm_pwd));
5328
5329         usr->user_rid  = user_rid;
5330         usr->group_rid = group_rid;
5331         usr->acb_info = acb_info;
5332         usr->unknown_3 = unknown_3; /* 0x00ff ffff */
5333
5334         usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5335         usr->ptr_logon_hrs = hrs ? 1 : 0;
5336         usr->unknown_5 = unknown_5; /* 0x0002 0000 */
5337
5338         bzero(usr->padding1, sizeof(usr->padding1));
5339
5340         make_unistr2(&(usr->uni_user_name   ), user_name   , len_user_name   );
5341         make_unistr2(&(usr->uni_full_name   ), full_name   , len_full_name   );
5342         make_unistr2(&(usr->uni_home_dir    ), home_dir    , len_home_dir    );
5343         make_unistr2(&(usr->uni_dir_drive   ), dir_drive   , len_dir_drive   );
5344         make_unistr2(&(usr->uni_logon_script), log_scr, len_logon_script);
5345         make_unistr2(&(usr->uni_profile_path), prof_path, len_profile_path);
5346         make_unistr2(&(usr->uni_acct_desc ), desc , len_description );
5347         make_unistr2(&(usr->uni_workstations), wkstas, len_workstations);
5348         make_unistr2(&(usr->uni_unknown_str ), unk_str , len_unknown_str );
5349         make_unistr2(&(usr->uni_munged_dial ), mung_dial , len_munged_dial );
5350
5351         usr->unknown_6 = unknown_6; /* 0x0000 04ec */
5352         usr->padding4 = 0;
5353
5354         if (hrs)
5355         {
5356                 memcpy(&(usr->logon_hrs), hrs, sizeof(usr->logon_hrs));
5357         }
5358         else
5359         {
5360                 memset(&(usr->logon_hrs), 0xff, sizeof(usr->logon_hrs));
5361         }
5362
5363         return True;
5364 }
5365
5366
5367 /*******************************************************************
5368 reads or writes a structure.
5369 ********************************************************************/
5370 static BOOL sam_io_user_info21(char *desc,  SAM_USER_INFO_21 *usr, prs_struct *ps, int depth)
5371 {
5372         if (usr == NULL) return False;
5373
5374         prs_debug(ps, depth, desc, "sam_io_user_info21");
5375         depth++;
5376
5377         prs_align(ps);
5378
5379         smb_io_time("logon_time           ", &(usr->logon_time)           , ps, depth);
5380         smb_io_time("logoff_time          ", &(usr->logoff_time)          , ps, depth);
5381         smb_io_time("kickoff_time         ", &(usr->kickoff_time)         , ps, depth);
5382         smb_io_time("pass_last_set_time   ", &(usr->pass_last_set_time)   , ps, depth);
5383         smb_io_time("pass_can_change_time ", &(usr->pass_can_change_time) , ps, depth);
5384         smb_io_time("pass_must_change_time", &(usr->pass_must_change_time), ps, depth);
5385
5386         smb_io_unihdr("hdr_user_name   ", &(usr->hdr_user_name)   , ps, depth); /* username unicode string header */
5387         smb_io_unihdr("hdr_full_name   ", &(usr->hdr_full_name)   , ps, depth); /* user's full name unicode string header */
5388         smb_io_unihdr("hdr_home_dir    ", &(usr->hdr_home_dir)    , ps, depth); /* home directory unicode string header */
5389         smb_io_unihdr("hdr_dir_drive   ", &(usr->hdr_dir_drive)   , ps, depth); /* home directory drive */
5390         smb_io_unihdr("hdr_logon_script", &(usr->hdr_logon_script), ps, depth); /* logon script unicode string header */
5391         smb_io_unihdr("hdr_profile_path", &(usr->hdr_profile_path), ps, depth); /* profile path unicode string header */
5392         smb_io_unihdr("hdr_acct_desc   ", &(usr->hdr_acct_desc  ) , ps, depth); /* account desc */
5393         smb_io_unihdr("hdr_workstations", &(usr->hdr_workstations), ps, depth); /* wkstas user can log on from */
5394         smb_io_unihdr("hdr_unknown_str ", &(usr->hdr_unknown_str ), ps, depth); /* unknown string */
5395         smb_io_unihdr("hdr_munged_dial ", &(usr->hdr_munged_dial ), ps, depth); /* wkstas user can log on from */
5396
5397         prs_uint8s (False, "lm_pwd        ", ps, depth, usr->lm_pwd   , sizeof(usr->lm_pwd   ));
5398         prs_uint8s (False, "nt_pwd        ", ps, depth, usr->nt_pwd   , sizeof(usr->nt_pwd   ));
5399
5400         prs_uint32("user_rid      ", ps, depth, &(usr->user_rid     ));       /* User ID */
5401         prs_uint32("group_rid     ", ps, depth, &(usr->group_rid    ));      /* Group ID */
5402         prs_uint16("acb_info      ", ps, depth, &(usr->acb_info     ));      /* Group ID */
5403         prs_align(ps);
5404
5405         prs_uint32("unknown_3     ", ps, depth, &(usr->unknown_3    ));
5406         prs_uint16("logon_divs    ", ps, depth, &(usr->logon_divs   ));     /* logon divisions per week */
5407         prs_align(ps);
5408         prs_uint32("ptr_logon_hrs ", ps, depth, &(usr->ptr_logon_hrs));
5409         prs_uint32("unknown_5     ", ps, depth, &(usr->unknown_5    ));
5410
5411         prs_uint8s (False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1));
5412
5413         /* here begins pointed-to data */
5414
5415         smb_io_unistr2("uni_user_name   ", &(usr->uni_user_name)   , usr->hdr_user_name   .buffer, ps, depth); /* username unicode string */
5416         prs_align(ps);
5417         smb_io_unistr2("uni_full_name   ", &(usr->uni_full_name)   , usr->hdr_full_name   .buffer, ps, depth); /* user's full name unicode string */
5418         prs_align(ps);
5419         smb_io_unistr2("uni_home_dir    ", &(usr->uni_home_dir)    , usr->hdr_home_dir    .buffer, ps, depth); /* home directory unicode string */
5420         prs_align(ps);
5421         smb_io_unistr2("uni_dir_drive   ", &(usr->uni_dir_drive)   , usr->hdr_dir_drive   .buffer, ps, depth); /* home directory drive unicode string */
5422         prs_align(ps);
5423         smb_io_unistr2("uni_logon_script", &(usr->uni_logon_script), usr->hdr_logon_script.buffer, ps, depth); /* logon script unicode string */
5424         prs_align(ps);
5425         smb_io_unistr2("uni_profile_path", &(usr->uni_profile_path), usr->hdr_profile_path.buffer, ps, depth); /* profile path unicode string */
5426         prs_align(ps);
5427         smb_io_unistr2("uni_acct_desc   ", &(usr->uni_acct_desc   ), usr->hdr_acct_desc   .buffer, ps, depth); /* user desc unicode string */
5428         prs_align(ps);
5429         smb_io_unistr2("uni_workstations", &(usr->uni_workstations), usr->hdr_workstations.buffer, ps, depth); /* worksations user can log on from */
5430         prs_align(ps);
5431         smb_io_unistr2("uni_unknown_str ", &(usr->uni_unknown_str ), usr->hdr_unknown_str .buffer, ps, depth); /* unknown string */
5432         prs_align(ps);
5433         smb_io_unistr2("uni_munged_dial ", &(usr->uni_munged_dial ), usr->hdr_munged_dial .buffer, ps, depth); /* worksations user can log on from */
5434         prs_align(ps);
5435
5436         prs_uint32("unknown_6     ", ps, depth, &(usr->unknown_6  ));
5437         prs_uint32("padding4      ", ps, depth, &(usr->padding4   ));
5438
5439         if (usr->ptr_logon_hrs)
5440         {
5441                 sam_io_logon_hrs("logon_hrs", &(usr->logon_hrs)   , ps, depth);
5442                 prs_align(ps);
5443         }
5444
5445         return True;
5446 }
5447
5448
5449 /*******************************************************************
5450 makes a SAMR_R_QUERY_USERINFO structure.
5451 ********************************************************************/
5452 BOOL make_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO *r_u,
5453                                 uint16 switch_value, void *info, uint32 status)
5454
5455 {
5456         if (r_u == NULL || info == NULL) return False;
5457
5458         DEBUG(5,("make_samr_r_query_userinfo\n"));
5459
5460         r_u->ptr = 0;
5461         r_u->switch_value = 0;
5462
5463         if (status == 0)
5464         {
5465                 r_u->switch_value = switch_value;
5466
5467                 switch (switch_value)
5468                 {
5469                         case 0x10:
5470                         {
5471                                 r_u->ptr = 1;
5472                                 r_u->info.id10 = (SAM_USER_INFO_10*)info;
5473
5474                                 break;
5475                         }
5476
5477                         case 0x11:
5478                         {
5479                                 r_u->ptr = 1;
5480                                 r_u->info.id11 = (SAM_USER_INFO_11*)info;
5481
5482                                 break;
5483                         }
5484
5485                         case 21:
5486                         {
5487                                 r_u->ptr = 1;
5488                                 r_u->info.id21 = (SAM_USER_INFO_21*)info;
5489
5490                                 break;
5491                         }
5492
5493                         case 23:
5494                         {
5495                                 r_u->ptr = 1;
5496                                 r_u->info.id23 = (SAM_USER_INFO_23*)info;
5497
5498                                 break;
5499                         }
5500
5501                         case 24:
5502                         {
5503                                 r_u->ptr = 1;
5504                                 r_u->info.id24 = (SAM_USER_INFO_24*)info;
5505
5506                                 break;
5507                         }
5508
5509                         default:
5510                         {
5511                                 DEBUG(4,("make_samr_r_query_userinfo: unsupported switch level\n"));
5512                                 break;
5513                         }
5514                 }
5515         }
5516
5517         r_u->status = status;         /* return status */
5518
5519         return True;
5520 }
5521
5522 /*******************************************************************
5523 reads or writes a structure.
5524 ********************************************************************/
5525 BOOL samr_io_r_query_userinfo(char *desc,  SAMR_R_QUERY_USERINFO *r_u, prs_struct *ps, int depth)
5526 {
5527         if (r_u == NULL) return False;
5528
5529         prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
5530         depth++;
5531
5532         prs_align(ps);
5533
5534         prs_uint32("ptr         ", ps, depth, &(r_u->ptr         ));
5535         prs_uint16("switch_value", ps, depth, &(r_u->switch_value));
5536         prs_align(ps);
5537
5538         if (r_u->ptr != 0 && r_u->switch_value != 0 && r_u->info.id != NULL)
5539         {
5540                 switch (r_u->switch_value)
5541                 {
5542                         case 0x10:
5543                         {
5544                                 if (r_u->info.id10 != NULL)
5545                                 {
5546                                         sam_io_user_info10("", r_u->info.id10, ps, depth);
5547                                 }
5548                                 else
5549                                 {
5550                                         DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
5551                                         return False;
5552                                 }
5553                                 break;
5554                         }
5555 /*
5556                         case 0x11:
5557                         {
5558                                 if (r_u->info.id11 != NULL)
5559                                 {
5560                                         sam_io_user_info11("", r_u->info.id11, ps, depth);
5561                                 }
5562                                 else
5563                                 {
5564                                         DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
5565                                         return False;
5566                                 }
5567                                 break;
5568                         }
5569 */
5570                         case 21:
5571                         {
5572                                 if (r_u->info.id21 != NULL)
5573                                 {
5574                                         sam_io_user_info21("", r_u->info.id21, ps, depth);
5575                                 }
5576                                 else
5577                                 {
5578                                         DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
5579                                         return False;
5580                                 }
5581                                 break;
5582                         }
5583                         case 23:
5584                         {
5585                                 if (r_u->info.id23 != NULL)
5586                                 {
5587                                         sam_io_user_info23("", r_u->info.id23, ps, depth);
5588                                 }
5589                                 else
5590                                 {
5591                                         DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
5592                                         return False;
5593                                 }
5594                                 break;
5595                         }
5596                         case 24:
5597                         {
5598                                 if (r_u->info.id24 != NULL)
5599                                 {
5600                                         sam_io_user_info24("", r_u->info.id24, ps, depth);
5601                                 }
5602                                 else
5603                                 {
5604                                         DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
5605                                         return False;
5606                                 }
5607                                 break;
5608                         }
5609                         default:
5610                         {
5611                                 DEBUG(2,("samr_io_r_query_userinfo: unknown switch level\n"));
5612                                 break;
5613                         }
5614
5615                 }
5616         }
5617
5618         prs_uint32("status", ps, depth, &(r_u->status));
5619
5620         return True;
5621 }
5622
5623 /*******************************************************************
5624 makes a SAMR_Q_SET_USERINFO structure.
5625 ********************************************************************/
5626 BOOL make_samr_q_set_userinfo(SAMR_Q_SET_USERINFO *q_u,
5627                                 POLICY_HND *hnd,
5628                                 uint16 switch_value, void *info)
5629 {
5630         if (q_u == NULL || hnd == NULL) return False;
5631
5632         DEBUG(5,("make_samr_q_set_userinfo\n"));
5633
5634         memcpy(&(q_u->pol), hnd, sizeof(q_u->pol));
5635         q_u->switch_value  = switch_value;
5636         q_u->switch_value2 = switch_value;
5637         q_u->info.id = info;
5638
5639         switch (switch_value)
5640         {
5641                 case 0x18:
5642                 {
5643                         uchar sess_key[16];
5644                         if (!cli_get_usr_sesskey(hnd, sess_key))
5645                         {
5646                                 return False;
5647                         }
5648                         SamOEMhash(q_u->info.id24->pass, sess_key, 1);
5649 #ifdef DEBUG_PASSWORD
5650                         dump_data(100, sess_key, 16);
5651                         dump_data(100, q_u->info.id24->pass, 516);
5652 #endif
5653                         break;
5654                 }
5655                 case 0x17:
5656                 {
5657                         uchar sess_key[16];
5658                         if (!cli_get_usr_sesskey(hnd, sess_key))
5659                         {
5660                                 return False;
5661                         }
5662                         SamOEMhash(q_u->info.id23->pass, sess_key, 1);
5663 #ifdef DEBUG_PASSWORD
5664                         dump_data(100, sess_key, 16);
5665                         dump_data(100, q_u->info.id23->pass, 516);
5666 #endif
5667                         break;
5668                 }
5669                 default:
5670                 {
5671                         DEBUG(4,("make_samr_q_set_userinfo: unsupported switch level\n"));
5672                         return False;
5673                 }
5674         }
5675
5676         return True;
5677 }
5678
5679
5680 /*******************************************************************
5681 reads or writes a structure.
5682 ********************************************************************/
5683 BOOL samr_io_q_set_userinfo(char *desc, SAMR_Q_SET_USERINFO *q_u, prs_struct *ps, int depth)
5684 {
5685         if (q_u == NULL) return False;
5686
5687         prs_debug(ps, depth, desc, "samr_io_q_set_userinfo");
5688         depth++;
5689
5690         prs_align(ps);
5691
5692         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
5693         prs_align(ps);
5694
5695         prs_uint16("switch_value ", ps, depth, &(q_u->switch_value ));
5696         prs_uint16("switch_value2", ps, depth, &(q_u->switch_value2));
5697
5698         prs_align(ps);
5699
5700         switch (q_u->switch_value)
5701         {
5702                 case 0:
5703                 {
5704                         break;
5705                 }
5706                 case 24:
5707                 {
5708                         if (ps->io)
5709                         {
5710                                 /* reading */
5711                                 q_u->info.id = (SAM_USER_INFO_24*)Realloc(NULL,
5712                                                  sizeof(*q_u->info.id24));
5713                         }
5714                         if (q_u->info.id == NULL)
5715                         {
5716                                 DEBUG(2,("samr_io_q_query_userinfo: info pointer not initialised\n"));
5717                                 return False;
5718                         }
5719                         sam_io_user_info24("", q_u->info.id24, ps, depth);
5720                         break;
5721                 }
5722                 case 23:
5723                 {
5724                         if (ps->io)
5725                         {
5726                                 /* reading */
5727                                 q_u->info.id = (SAM_USER_INFO_23*)Realloc(NULL,
5728                                                  sizeof(*q_u->info.id23));
5729                         }
5730                         if (q_u->info.id == NULL)
5731                         {
5732                                 DEBUG(2,("samr_io_q_query_userinfo: info pointer not initialised\n"));
5733                                 return False;
5734                         }
5735                         sam_io_user_info23("", q_u->info.id23, ps, depth);
5736                         break;
5737                 }
5738                 default:
5739                 {
5740                         DEBUG(2,("samr_io_q_query_userinfo: unknown switch level\n"));
5741                         break;
5742                 }
5743
5744         }
5745         prs_align(ps);
5746
5747         if (!ps->io)
5748         {
5749                 /* writing */
5750                 free_samr_q_set_userinfo(q_u);
5751         }
5752
5753         return True;
5754 }
5755
5756 /*******************************************************************
5757 frees a structure.
5758 ********************************************************************/
5759 void free_samr_q_set_userinfo(SAMR_Q_SET_USERINFO *q_u)
5760 {
5761         if (q_u->info.id == NULL)
5762         {
5763                 free(q_u->info.id);
5764         }
5765         q_u->info.id = NULL;
5766 }
5767
5768 /*******************************************************************
5769 makes a SAMR_R_SET_USERINFO structure.
5770 ********************************************************************/
5771 BOOL make_samr_r_set_userinfo(SAMR_R_SET_USERINFO *r_u, uint32 status)
5772
5773 {
5774         if (r_u == NULL) return False;
5775
5776         DEBUG(5,("make_samr_r_set_userinfo\n"));
5777
5778         r_u->status = status;         /* return status */
5779
5780         return True;
5781 }
5782
5783 /*******************************************************************
5784 reads or writes a structure.
5785 ********************************************************************/
5786 BOOL samr_io_r_set_userinfo(char *desc,  SAMR_R_SET_USERINFO *r_u, prs_struct *ps, int depth)
5787 {
5788         if (r_u == NULL) return False;
5789
5790         prs_debug(ps, depth, desc, "samr_io_r_set_userinfo");
5791         depth++;
5792
5793         prs_align(ps);
5794
5795         prs_uint32("status", ps, depth, &(r_u->status));
5796
5797         return True;
5798 }
5799
5800 /*******************************************************************
5801 makes a SAMR_Q_SET_USERINFO2 structure.
5802 ********************************************************************/
5803 BOOL make_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2 *q_u,
5804                                 POLICY_HND *hnd,
5805                                 uint16 switch_value, void *info)
5806 {
5807         if (q_u == NULL || hnd == NULL) return False;
5808
5809         DEBUG(5,("make_samr_q_set_userinfo2\n"));
5810
5811         memcpy(&(q_u->pol), hnd, sizeof(q_u->pol));
5812         q_u->switch_value  = switch_value;
5813         q_u->switch_value2 = switch_value;
5814         q_u->info.id = info;
5815
5816         switch (switch_value)
5817         {
5818                 case 0x10:
5819                 {
5820                         break;
5821                 }
5822                 default:
5823                 {
5824                         DEBUG(4,("make_samr_q_set_userinfo2: unsupported switch level\n"));
5825                         return False;
5826                 }
5827         }
5828
5829         return True;
5830 }
5831
5832
5833 /*******************************************************************
5834 reads or writes a structure.
5835 ********************************************************************/
5836 BOOL samr_io_q_set_userinfo2(char *desc, SAMR_Q_SET_USERINFO2 *q_u, prs_struct *ps, int depth)
5837 {
5838         if (q_u == NULL) return False;
5839
5840         prs_debug(ps, depth, desc, "samr_io_q_set_userinfo2");
5841         depth++;
5842
5843         prs_align(ps);
5844
5845         smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
5846         prs_align(ps);
5847
5848         prs_uint16("switch_value ", ps, depth, &(q_u->switch_value ));
5849         prs_uint16("switch_value2", ps, depth, &(q_u->switch_value2));
5850
5851         prs_align(ps);
5852
5853         switch (q_u->switch_value)
5854         {
5855                 case 0:
5856                 {
5857                         break;
5858                 }
5859                 case 16:
5860                 {
5861                         if (ps->io)
5862                         {
5863                                 /* reading */
5864                                 q_u->info.id = (SAM_USER_INFO_16*)Realloc(NULL,
5865                                                  sizeof(*q_u->info.id16));
5866                         }
5867                         if (q_u->info.id == NULL)
5868                         {
5869                                 DEBUG(2,("samr_io_q_query_userinfo2: info pointer not initialised\n"));
5870                                 return False;
5871                         }
5872                         sam_io_user_info16("", q_u->info.id16, ps, depth);
5873                         break;
5874                 }
5875                 default:
5876                 {
5877                         DEBUG(2,("samr_io_q_query_userinfo2: unknown switch level\n"));
5878                         break;
5879                 }
5880
5881         }
5882         prs_align(ps);
5883
5884         if (!ps->io)
5885         {
5886                 /* writing */
5887                 free_samr_q_set_userinfo2(q_u);
5888         }
5889
5890         return True;
5891 }
5892
5893 /*******************************************************************
5894 frees a structure.
5895 ********************************************************************/
5896 void free_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2 *q_u)
5897 {
5898         if (q_u->info.id == NULL)
5899         {
5900                 free(q_u->info.id);
5901         }
5902         q_u->info.id = NULL;
5903 }
5904
5905 /*******************************************************************
5906 makes a SAMR_R_SET_USERINFO2 structure.
5907 ********************************************************************/
5908 BOOL make_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 *r_u,
5909                                 uint32 status)
5910 {
5911         if (r_u == NULL) return False;
5912
5913         DEBUG(5,("make_samr_r_set_userinfo2\n"));
5914
5915         r_u->status = status;         /* return status */
5916
5917         return True;
5918 }
5919
5920 /*******************************************************************
5921 reads or writes a structure.
5922 ********************************************************************/
5923 BOOL samr_io_r_set_userinfo2(char *desc,  SAMR_R_SET_USERINFO2 *r_u, prs_struct *ps, int depth)
5924 {
5925         if (r_u == NULL) return False;
5926
5927         prs_debug(ps, depth, desc, "samr_io_r_set_userinfo2");
5928         depth++;
5929
5930         prs_align(ps);
5931
5932         prs_uint32("status", ps, depth, &(r_u->status));
5933
5934         return True;
5935 }
5936
5937 /*******************************************************************
5938 makes a SAMR_Q_CONNECT structure.
5939 ********************************************************************/
5940 BOOL make_samr_q_connect(SAMR_Q_CONNECT *q_u,
5941                                 const char *srv_name, uint32 unknown_0)
5942 {
5943         int len_srv_name = strlen(srv_name);
5944
5945         if (q_u == NULL) return False;
5946
5947         DEBUG(5,("make_samr_q_connect\n"));
5948
5949         /* make PDC server name \\server */
5950         q_u->ptr_srv_name = len_srv_name > 0 ? 1 : 0;
5951         make_unistr2(&(q_u->uni_srv_name), srv_name, len_srv_name+1);
5952
5953         /* example values: 0x0000 0002 */
5954         q_u->unknown_0 = unknown_0;
5955
5956         return True;
5957 }
5958
5959
5960 /*******************************************************************
5961 reads or writes a structure.
5962 ********************************************************************/
5963 BOOL samr_io_q_connect(char *desc,  SAMR_Q_CONNECT *q_u, prs_struct *ps, int depth)
5964 {
5965         if (q_u == NULL) return False;
5966
5967         prs_debug(ps, depth, desc, "samr_io_q_connect");
5968         depth++;
5969
5970         prs_align(ps);
5971
5972         prs_uint32("ptr_srv_name", ps, depth, &(q_u->ptr_srv_name));
5973         smb_io_unistr2("", &(q_u->uni_srv_name), q_u->ptr_srv_name, ps, depth);
5974
5975         prs_align(ps);
5976
5977         prs_uint32("unknown_0   ", ps, depth, &(q_u->unknown_0   ));
5978
5979         return True;
5980 }
5981
5982 /*******************************************************************
5983 reads or writes a structure.
5984 ********************************************************************/
5985 BOOL samr_io_r_connect(char *desc,  SAMR_R_CONNECT *r_u, prs_struct *ps, int depth)
5986 {
5987         if (r_u == NULL) return False;
5988
5989         prs_debug(ps, depth, desc, "samr_io_r_connect");
5990         depth++;
5991
5992         prs_align(ps);
5993
5994         smb_io_pol_hnd("connect_pol", &(r_u->connect_pol), ps, depth);
5995         prs_align(ps);
5996
5997         prs_uint32("status", ps, depth, &(r_u->status));
5998
5999         return True;
6000 }
6001
6002 /*******************************************************************
6003 makes a SAMR_Q_CONNECT_ANON structure.
6004 ********************************************************************/
6005 BOOL make_samr_q_connect_anon(SAMR_Q_CONNECT_ANON *q_u)
6006 {
6007         if (q_u == NULL) return False;
6008
6009         DEBUG(5,("make_samr_q_connect_anon\n"));
6010
6011         q_u->ptr       = 1;
6012         q_u->unknown_0 = 0x5c; /* server name (?!!) */
6013         q_u->unknown_1 = 0x01;
6014         q_u->unknown_2 = 0x20;
6015
6016         return True;
6017 }
6018
6019
6020 /*******************************************************************
6021 reads or writes a structure.
6022 ********************************************************************/
6023 BOOL samr_io_q_connect_anon(char *desc,  SAMR_Q_CONNECT_ANON *q_u, prs_struct *ps, int depth)
6024 {
6025         if (q_u == NULL) return False;
6026
6027         prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
6028         depth++;
6029
6030         prs_align(ps);
6031
6032         prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
6033         prs_uint16("unknown_0", ps, depth, &(q_u->unknown_0));
6034         prs_uint16("unknown_1", ps, depth, &(q_u->unknown_1));
6035         prs_uint32("unknown_2", ps, depth, &(q_u->unknown_2));
6036
6037         return True;
6038 }
6039
6040 /*******************************************************************
6041 reads or writes a structure.
6042 ********************************************************************/
6043 BOOL samr_io_r_connect_anon(char *desc,  SAMR_R_CONNECT_ANON *r_u, prs_struct *ps, int depth)
6044 {
6045         if (r_u == NULL) return False;
6046
6047         prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
6048         depth++;
6049
6050         prs_align(ps);
6051
6052         smb_io_pol_hnd("connect_pol", &(r_u->connect_pol), ps, depth);
6053         prs_align(ps);
6054
6055         prs_uint32("status", ps, depth, &(r_u->status));
6056
6057         return True;
6058 }
6059
6060 /*******************************************************************
6061 makes a SAMR_Q_UNKNOWN_38 structure.
6062 ********************************************************************/
6063 BOOL make_samr_q_unknown_38(SAMR_Q_UNKNOWN_38 *q_u, char *srv_name)
6064 {
6065         int len_srv_name = strlen(srv_name);
6066
6067         if (q_u == NULL) return False;
6068
6069         DEBUG(5,("make_samr_q_unknown_38\n"));
6070
6071         q_u->ptr = 1;
6072         make_uni_hdr(&(q_u->hdr_srv_name), len_srv_name);
6073         make_unistr2(&(q_u->uni_srv_name), srv_name, len_srv_name);
6074
6075
6076         return True;
6077 }
6078
6079 /*******************************************************************
6080 reads or writes a structure.
6081 ********************************************************************/
6082 BOOL samr_io_q_unknown_38(char *desc,  SAMR_Q_UNKNOWN_38 *q_u, prs_struct *ps, int depth)
6083 {
6084         if (q_u == NULL) return False;
6085
6086         prs_debug(ps, depth, desc, "samr_io_q_unknown_38");
6087         depth++;
6088
6089         prs_align(ps);
6090
6091         prs_uint32("ptr", ps, depth, &(q_u->ptr));
6092         if (q_u->ptr != 0)
6093         {
6094                 smb_io_unihdr ("", &(q_u->hdr_srv_name), ps, depth);
6095                 smb_io_unistr2("", &(q_u->uni_srv_name), q_u->hdr_srv_name.buffer, ps, depth);
6096                 prs_align(ps);
6097         }
6098
6099         return True;
6100 }
6101
6102 /*******************************************************************
6103 makes a SAMR_R_UNKNOWN_38 structure.
6104 ********************************************************************/
6105 BOOL make_samr_r_unknown_38(SAMR_R_UNKNOWN_38 *r_u)
6106 {
6107         if (r_u == NULL) return False;
6108
6109         DEBUG(5,("make_r_unknown_38\n"));
6110
6111         r_u->unk_0 = 0;
6112         r_u->unk_1 = 0;
6113         r_u->unk_2 = 0;
6114         r_u->unk_3 = 0;
6115
6116         return True;
6117 }
6118
6119 /*******************************************************************
6120 reads or writes a structure.
6121 ********************************************************************/
6122 BOOL samr_io_r_unknown_38(char *desc,  SAMR_R_UNKNOWN_38 *r_u, prs_struct *ps, int depth)
6123 {
6124         if (r_u == NULL) return False;
6125
6126         prs_debug(ps, depth, desc, "samr_io_r_unknown_38");
6127         depth++;
6128
6129         prs_align(ps);
6130
6131         prs_uint16("unk_0", ps, depth, &(r_u->unk_0));
6132         prs_align(ps);
6133         prs_uint16("unk_1", ps, depth, &(r_u->unk_1));
6134         prs_align(ps);
6135         prs_uint16("unk_2", ps, depth, &(r_u->unk_2));
6136         prs_align(ps);
6137         prs_uint16("unk_3", ps, depth, &(r_u->unk_3));
6138         prs_align(ps);
6139
6140         return True;
6141 }
6142
6143 /*******************************************************************
6144 make a SAMR_ENC_PASSWD structure.
6145 ********************************************************************/
6146 BOOL make_enc_passwd(SAMR_ENC_PASSWD *pwd, char pass[512])
6147 {
6148         if (pwd == NULL) return False;
6149
6150         pwd->ptr = 1;
6151         memcpy(pwd->pass, pass, sizeof(pwd->pass));
6152
6153         return True;
6154 }
6155
6156 /*******************************************************************
6157 reads or writes a SAMR_ENC_PASSWD structure.
6158 ********************************************************************/
6159 BOOL samr_io_enc_passwd(char *desc, SAMR_ENC_PASSWD *pwd, prs_struct *ps, int depth)
6160 {
6161         if (pwd == NULL) return False;
6162
6163         prs_debug(ps, depth, desc, "samr_io_enc_passwd");
6164         depth++;
6165
6166         prs_align(ps);
6167
6168         prs_uint32("ptr", ps, depth, &(pwd->ptr));
6169         prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass));
6170
6171         return True;
6172 }
6173
6174 /*******************************************************************
6175 makes a SAMR_ENC_HASH structure.
6176 ********************************************************************/
6177 BOOL make_enc_hash(SAMR_ENC_HASH *hsh, uchar hash[16])
6178 {
6179         if (hsh == NULL) return False;
6180
6181         hsh->ptr = 1;
6182         memcpy(hsh->hash, hash, sizeof(hsh->hash));
6183
6184         return True;
6185 }
6186
6187 /*******************************************************************
6188 reads or writes a SAMR_ENC_HASH structure.
6189 ********************************************************************/
6190 BOOL samr_io_enc_hash(char *desc, SAMR_ENC_HASH *hsh, prs_struct *ps, int depth)
6191 {
6192         if (hsh == NULL) return False;
6193
6194         prs_debug(ps, depth, desc, "samr_io_enc_hash");
6195         depth++;
6196
6197         prs_align(ps);
6198
6199         prs_uint32("ptr ", ps, depth, &(hsh->ptr));
6200         prs_uint8s(False, "hash", ps, depth, hsh->hash, sizeof(hsh->hash));
6201
6202         return True;
6203 }
6204
6205 /*******************************************************************
6206 makes a SAMR_R_UNKNOWN_38 structure.
6207 ********************************************************************/
6208 BOOL make_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER *q_u,
6209                                 char *dest_host, char *user_name,
6210                                 char nt_newpass[516], uchar nt_oldhash[16],
6211                                 char lm_newpass[516], uchar lm_oldhash[16])
6212 {
6213         int len_dest_host = strlen(dest_host);
6214         int len_user_name = strlen(user_name);
6215
6216         if (q_u == NULL) return False;
6217
6218         DEBUG(5,("make_samr_q_chgpasswd_user\n"));
6219
6220         q_u->ptr_0 = 1;
6221         make_uni_hdr(&(q_u->hdr_dest_host), len_dest_host);
6222         make_unistr2(&(q_u->uni_dest_host), dest_host, len_dest_host);
6223         make_uni_hdr(&(q_u->hdr_user_name), len_user_name);
6224         make_unistr2(&(q_u->uni_user_name), user_name, len_user_name);
6225
6226         make_enc_passwd(&(q_u->nt_newpass), nt_newpass);
6227         make_enc_hash  (&(q_u->nt_oldhash), nt_oldhash);
6228
6229         q_u->unknown = 0x01;
6230
6231         make_enc_passwd(&(q_u->lm_newpass), lm_newpass);
6232         make_enc_hash  (&(q_u->lm_oldhash), lm_oldhash);
6233
6234         return True;
6235 }
6236
6237 /*******************************************************************
6238 reads or writes a structure.
6239 ********************************************************************/
6240 BOOL samr_io_q_chgpasswd_user(char *desc, SAMR_Q_CHGPASSWD_USER *q_u, prs_struct *ps, int depth)
6241 {
6242         if (q_u == NULL) return False;
6243
6244         prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
6245         depth++;
6246
6247         prs_align(ps);
6248
6249         prs_uint32("ptr_0", ps, depth, &(q_u->ptr_0));
6250
6251         smb_io_unihdr ("", &(q_u->hdr_dest_host), ps, depth);
6252         smb_io_unistr2("", &(q_u->uni_dest_host), q_u->hdr_dest_host.buffer, ps, depth);
6253         prs_align(ps);
6254
6255         smb_io_unihdr ("", &(q_u->hdr_user_name), ps, depth);
6256         smb_io_unistr2("", &(q_u->uni_user_name), q_u->hdr_user_name.buffer, ps, depth);
6257         prs_align(ps);
6258
6259         samr_io_enc_passwd("nt_newpass", &(q_u->nt_newpass), ps, depth);
6260         samr_io_enc_hash  ("nt_oldhash", &(q_u->nt_oldhash), ps, depth);
6261
6262         prs_uint32("unknown", ps, depth, &(q_u->unknown));
6263
6264         samr_io_enc_passwd("lm_newpass", &(q_u->lm_newpass), ps, depth);
6265         samr_io_enc_hash  ("lm_oldhash", &(q_u->lm_oldhash), ps, depth);
6266
6267         return True;
6268 }
6269
6270 /*******************************************************************
6271 makes a SAMR_R_CHGPASSWD_USER structure.
6272 ********************************************************************/
6273 BOOL make_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER *r_u, uint32 status)
6274 {
6275         if (r_u == NULL) return False;
6276
6277         DEBUG(5,("make_r_chgpasswd_user\n"));
6278
6279         r_u->status = status;
6280
6281         return True;
6282 }
6283
6284 /*******************************************************************
6285 reads or writes a structure.
6286 ********************************************************************/
6287 BOOL samr_io_r_chgpasswd_user(char *desc, SAMR_R_CHGPASSWD_USER *r_u, prs_struct *ps, int depth)
6288 {
6289         if (r_u == NULL) return False;
6290
6291         prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
6292         depth++;
6293
6294         prs_align(ps);
6295
6296         prs_uint32("status", ps, depth, &(r_u->status));
6297
6298         return True;
6299 }
6300
6301