source/rpc_parse/parse_net.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-1997,
   5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   6  *  Copyright (C) Paul Ashton                       1997.
   7  *  Copyright (C) Jean François Micouleau           2002.
   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 #include "includes.h"
  25
  26 #undef DBGC_CLASS
  27 #define DBGC_CLASS DBGC_RPC_PARSE
  28
  29 /*******************************************************************
  30  Reads or writes a structure.
  31 ********************************************************************/
  32
  33 static BOOL net_io_neg_flags(const char *desc, NEG_FLAGS *neg, prs_struct *ps, int depth)
  34 {
  35         if (neg == NULL)
  36                 return False;
  37
  38         prs_debug(ps, depth, desc, "net_io_neg_flags");
  39         depth++;
  40
  41         if(!prs_align(ps))
  42                 return False;
  43
  44         if(!prs_uint32("neg_flags", ps, depth, &neg->neg_flags))
  45                 return False;
  46
  47         return True;
  48 }
  49
  50 /*******************************************************************
  51  Inits a NETLOGON_INFO_3 structure.
  52 ********************************************************************/
  53
  54 static void init_netinfo_3(NETLOGON_INFO_3 *info, uint32 flags, uint32 logon_attempts)
  55 {
  56         info->flags          = flags;
  57         info->logon_attempts = logon_attempts;
  58         info->reserved_1     = 0x0;
  59         info->reserved_2     = 0x0;
  60         info->reserved_3     = 0x0;
  61         info->reserved_4     = 0x0;
  62         info->reserved_5     = 0x0;
  63 }
  64
  65 /*******************************************************************
  66  Reads or writes a NETLOGON_INFO_3 structure.
  67 ********************************************************************/
  68
  69 static BOOL net_io_netinfo_3(const char *desc,  NETLOGON_INFO_3 *info, prs_struct *ps, int depth)
  70 {
  71         if (info == NULL)
  72                 return False;
  73
  74         prs_debug(ps, depth, desc, "net_io_netinfo_3");
  75         depth++;
  76
  77         if(!prs_align(ps))
  78                 return False;
  79
  80         if(!prs_uint32("flags         ", ps, depth, &info->flags))
  81                 return False;
  82         if(!prs_uint32("logon_attempts", ps, depth, &info->logon_attempts))
  83                 return False;
  84         if(!prs_uint32("reserved_1    ", ps, depth, &info->reserved_1))
  85                 return False;
  86         if(!prs_uint32("reserved_2    ", ps, depth, &info->reserved_2))
  87                 return False;
  88         if(!prs_uint32("reserved_3    ", ps, depth, &info->reserved_3))
  89                 return False;
  90         if(!prs_uint32("reserved_4    ", ps, depth, &info->reserved_4))
  91                 return False;
  92         if(!prs_uint32("reserved_5    ", ps, depth, &info->reserved_5))
  93                 return False;
  94
  95         return True;
  96 }
  97
  98
  99 /*******************************************************************
 100  Inits a NETLOGON_INFO_1 structure.
 101 ********************************************************************/
 102
 103 static void init_netinfo_1(NETLOGON_INFO_1 *info, uint32 flags, uint32 pdc_status)
 104 {
 105         info->flags      = flags;
 106         info->pdc_status = pdc_status;
 107 }
 108
 109 /*******************************************************************
 110  Reads or writes a NETLOGON_INFO_1 structure.
 111 ********************************************************************/
 112
 113 static BOOL net_io_netinfo_1(const char *desc, NETLOGON_INFO_1 *info, prs_struct *ps, int depth)
 114 {
 115         if (info == NULL)
 116                 return False;
 117
 118         prs_debug(ps, depth, desc, "net_io_netinfo_1");
 119         depth++;
 120
 121         if(!prs_align(ps))
 122                 return False;
 123
 124         if(!prs_uint32("flags     ", ps, depth, &info->flags))
 125                 return False;
 126         if(!prs_uint32("pdc_status", ps, depth, &info->pdc_status))
 127                 return False;
 128
 129         return True;
 130 }
 131
 132 /*******************************************************************
 133  Inits a NETLOGON_INFO_2 structure.
 134 ********************************************************************/
 135
 136 static void init_netinfo_2(NETLOGON_INFO_2 *info, uint32 flags, uint32 pdc_status,
 137                                 uint32 tc_status, const char *trusted_dc_name)
 138 {
 139         int len_dc_name = strlen(trusted_dc_name);
 140         info->flags      = flags;
 141         info->pdc_status = pdc_status;
 142         info->ptr_trusted_dc_name = 1;
 143         info->tc_status  = tc_status;
 144
 145         if (trusted_dc_name != NULL)
 146                 init_unistr2(&info->uni_trusted_dc_name, trusted_dc_name, len_dc_name+1);
 147         else
 148                 init_unistr2(&info->uni_trusted_dc_name, "", 1);
 149 }
 150
 151 /*******************************************************************
 152  Reads or writes a NETLOGON_INFO_2 structure.
 153 ********************************************************************/
 154
 155 static BOOL net_io_netinfo_2(const char *desc, NETLOGON_INFO_2 *info, prs_struct *ps, int depth)
 156 {
 157         if (info == NULL)
 158                 return False;
 159
 160         prs_debug(ps, depth, desc, "net_io_netinfo_2");
 161         depth++;
 162
 163         if(!prs_align(ps))
 164                 return False;
 165
 166         if(!prs_uint32("flags              ", ps, depth, &info->flags))
 167                 return False;
 168         if(!prs_uint32("pdc_status         ", ps, depth, &info->pdc_status))
 169                 return False;
 170         if(!prs_uint32("ptr_trusted_dc_name", ps, depth, &info->ptr_trusted_dc_name))
 171                 return False;
 172         if(!prs_uint32("tc_status          ", ps, depth, &info->tc_status))
 173                 return False;
 174
 175         if (info->ptr_trusted_dc_name != 0) {
 176                 if(!smb_io_unistr2("unistr2", &info->uni_trusted_dc_name, info->ptr_trusted_dc_name, ps, depth))
 177                         return False;
 178         }
 179
 180         if(!prs_align(ps))
 181                 return False;
 182
 183         return True;
 184 }
 185
 186 /*******************************************************************
 187  Reads or writes an NET_Q_LOGON_CTRL2 structure.
 188 ********************************************************************/
 189
 190 BOOL net_io_q_logon_ctrl2(const char *desc, NET_Q_LOGON_CTRL2 *q_l, prs_struct *ps, int depth)
 191 {
 192         if (q_l == NULL)
 193                 return False;
 194
 195         prs_debug(ps, depth, desc, "net_io_q_logon_ctrl2");
 196         depth++;
 197
 198         if(!prs_align(ps))
 199                 return False;
 200
 201         if(!prs_uint32("ptr          ", ps, depth, &q_l->ptr))
 202                 return False;
 203
 204         if(!smb_io_unistr2 ("", &q_l->uni_server_name, q_l->ptr, ps, depth))
 205                 return False;
 206
 207         if(!prs_align(ps))
 208                 return False;
 209
 210         if(!prs_uint32("function_code", ps, depth, &q_l->function_code))
 211                 return False;
 212         if(!prs_uint32("query_level  ", ps, depth, &q_l->query_level))
 213                 return False;
 214         if(!prs_uint32("switch_value ", ps, depth, &q_l->switch_value))
 215                 return False;
 216
 217         return True;
 218 }
 219
 220 /*******************************************************************
 221  Inits an NET_Q_LOGON_CTRL2 structure.
 222 ********************************************************************/
 223
 224 void init_net_q_logon_ctrl2(NET_Q_LOGON_CTRL2 *q_l, const char *srv_name,
 225                             uint32 query_level)
 226 {
 227         DEBUG(5,("init_q_logon_ctrl2\n"));
 228
 229         q_l->function_code = 0x01;
 230         q_l->query_level = query_level;
 231         q_l->switch_value  = 0x01;
 232
 233         init_unistr2(&q_l->uni_server_name, srv_name, strlen(srv_name) + 1);
 234 }
 235
 236 /*******************************************************************
 237  Inits an NET_R_LOGON_CTRL2 structure.
 238 ********************************************************************/
 239
 240 void init_net_r_logon_ctrl2(NET_R_LOGON_CTRL2 *r_l, uint32 query_level,
 241                             uint32 flags, uint32 pdc_status,
 242                             uint32 logon_attempts, uint32 tc_status,
 243                             const char *trusted_domain_name)
 244 {
 245         DEBUG(5,("init_r_logon_ctrl2\n"));
 246
 247         r_l->switch_value  = query_level; /* should only be 0x1 */
 248
 249         switch (query_level) {
 250         case 1:
 251                 r_l->ptr = 1; /* undocumented pointer */
 252                 init_netinfo_1(&r_l->logon.info1, flags, pdc_status);
 253                 r_l->status = NT_STATUS_OK;
 254                 break;
 255         case 2:
 256                 r_l->ptr = 1; /* undocumented pointer */
 257                 init_netinfo_2(&r_l->logon.info2, flags, pdc_status,
 258                                tc_status, trusted_domain_name);
 259                 r_l->status = NT_STATUS_OK;
 260                 break;
 261         case 3:
 262                 r_l->ptr = 1; /* undocumented pointer */
 263                 init_netinfo_3(&r_l->logon.info3, flags, logon_attempts);
 264                 r_l->status = NT_STATUS_OK;
 265                 break;
 266         default:
 267                 DEBUG(2,("init_r_logon_ctrl2: unsupported switch value %d\n",
 268                         r_l->switch_value));
 269                 r_l->ptr = 0; /* undocumented pointer */
 270
 271                 /* take a guess at an error code... */
 272                 r_l->status = NT_STATUS_INVALID_INFO_CLASS;
 273                 break;
 274         }
 275 }
 276
 277 /*******************************************************************
 278  Reads or writes an NET_R_LOGON_CTRL2 structure.
 279 ********************************************************************/
 280
 281 BOOL net_io_r_logon_ctrl2(const char *desc, NET_R_LOGON_CTRL2 *r_l, prs_struct *ps, int depth)
 282 {
 283         if (r_l == NULL)
 284                 return False;
 285
 286         prs_debug(ps, depth, desc, "net_io_r_logon_ctrl2");
 287         depth++;
 288
 289         if(!prs_uint32("switch_value ", ps, depth, &r_l->switch_value))
 290                 return False;
 291         if(!prs_uint32("ptr          ", ps, depth, &r_l->ptr))
 292                 return False;
 293
 294         if (r_l->ptr != 0) {
 295                 switch (r_l->switch_value) {
 296                 case 1:
 297                         if(!net_io_netinfo_1("", &r_l->logon.info1, ps, depth))
 298                                 return False;
 299                         break;
 300                 case 2:
 301                         if(!net_io_netinfo_2("", &r_l->logon.info2, ps, depth))
 302                                 return False;
 303                         break;
 304                 case 3:
 305                         if(!net_io_netinfo_3("", &r_l->logon.info3, ps, depth))
 306                                 return False;
 307                         break;
 308                 default:
 309                         DEBUG(2,("net_io_r_logon_ctrl2: unsupported switch value %d\n",
 310                                 r_l->switch_value));
 311                         break;
 312                 }
 313         }
 314
 315         if(!prs_ntstatus("status       ", ps, depth, &r_l->status))
 316                 return False;
 317
 318         return True;
 319 }
 320
 321 /*******************************************************************
 322  Reads or writes an NET_Q_LOGON_CTRL structure.
 323 ********************************************************************/
 324
 325 BOOL net_io_q_logon_ctrl(const char *desc, NET_Q_LOGON_CTRL *q_l, prs_struct *ps,
 326                          int depth)
 327 {
 328         prs_debug(ps, depth, desc, "net_io_q_logon_ctrl");
 329         depth++;
 330
 331         if(!prs_align(ps))
 332                 return False;
 333
 334         if(!prs_uint32("ptr          ", ps, depth, &q_l->ptr))
 335                 return False;
 336
 337         if(!smb_io_unistr2 ("", &q_l->uni_server_name, q_l->ptr, ps, depth))
 338                 return False;
 339
 340         if(!prs_align(ps))
 341                 return False;
 342
 343         if(!prs_uint32("function_code", ps, depth, &q_l->function_code))
 344                 return False;
 345         if(!prs_uint32("query_level  ", ps, depth, &q_l->query_level))
 346                 return False;
 347
 348         return True;
 349 }
 350
 351 /*******************************************************************
 352  Inits an NET_Q_LOGON_CTRL structure.
 353 ********************************************************************/
 354
 355 void init_net_q_logon_ctrl(NET_Q_LOGON_CTRL *q_l, const char *srv_name,
 356                            uint32 query_level)
 357 {
 358         DEBUG(5,("init_q_logon_ctrl\n"));
 359
 360         q_l->function_code = 0x01; /* ??? */
 361         q_l->query_level = query_level;
 362
 363         init_unistr2(&q_l->uni_server_name, srv_name, strlen(srv_name) + 1);
 364 }
 365
 366 /*******************************************************************
 367  Inits an NET_R_LOGON_CTRL structure.
 368 ********************************************************************/
 369
 370 void init_net_r_logon_ctrl(NET_R_LOGON_CTRL *r_l, uint32 query_level,
 371                            uint32 flags, uint32 pdc_status)
 372 {
 373         DEBUG(5,("init_r_logon_ctrl\n"));
 374
 375         r_l->switch_value  = query_level; /* should only be 0x1 */
 376
 377         switch (query_level) {
 378         case 1:
 379                 r_l->ptr = 1; /* undocumented pointer */
 380                 init_netinfo_1(&r_l->logon.info1, flags, pdc_status);
 381                 r_l->status = NT_STATUS_OK;
 382                 break;
 383         default:
 384                 DEBUG(2,("init_r_logon_ctrl: unsupported switch value %d\n",
 385                         r_l->switch_value));
 386                 r_l->ptr = 0; /* undocumented pointer */
 387
 388                 /* take a guess at an error code... */
 389                 r_l->status = NT_STATUS_INVALID_INFO_CLASS;
 390                 break;
 391         }
 392 }
 393
 394 /*******************************************************************
 395  Reads or writes an NET_R_LOGON_CTRL structure.
 396 ********************************************************************/
 397
 398 BOOL net_io_r_logon_ctrl(const char *desc, NET_R_LOGON_CTRL *r_l, prs_struct *ps,
 399                          int depth)
 400 {
 401         prs_debug(ps, depth, desc, "net_io_r_logon_ctrl");
 402         depth++;
 403
 404         if(!prs_uint32("switch_value ", ps, depth, &r_l->switch_value))
 405                 return False;
 406         if(!prs_uint32("ptr          ", ps, depth, &r_l->ptr))
 407                 return False;
 408
 409         if (r_l->ptr != 0) {
 410                 switch (r_l->switch_value) {
 411                 case 1:
 412                         if(!net_io_netinfo_1("", &r_l->logon.info1, ps, depth))
 413                                 return False;
 414                         break;
 415                 default:
 416                         DEBUG(2,("net_io_r_logon_ctrl: unsupported switch value %d\n",
 417                                 r_l->switch_value));
 418                         break;
 419                 }
 420         }
 421
 422         if(!prs_ntstatus("status       ", ps, depth, &r_l->status))
 423                 return False;
 424
 425         return True;
 426 }
 427
 428 /*******************************************************************
 429  Inits an NET_R_TRUST_DOM_LIST structure.
 430 ********************************************************************/
 431
 432 void init_r_trust_dom(NET_R_TRUST_DOM_LIST *r_t,
 433                         uint32 num_doms, const char *dom_name)
 434 {
 435         unsigned int i = 0;
 436
 437         DEBUG(5,("init_r_trust_dom\n"));
 438
 439         for (i = 0; i < MAX_TRUST_DOMS; i++) {
 440                 r_t->uni_trust_dom_name[i].uni_str_len = 0;
 441                 r_t->uni_trust_dom_name[i].uni_max_len = 0;
 442         }
 443         if (num_doms > MAX_TRUST_DOMS)
 444                 num_doms = MAX_TRUST_DOMS;
 445
 446         for (i = 0; i < num_doms; i++) {
 447                 fstring domain_name;
 448                 fstrcpy(domain_name, dom_name);
 449                 strupper_m(domain_name);
 450                 init_unistr2(&r_t->uni_trust_dom_name[i], domain_name, strlen(domain_name)+1);
 451                 /* the use of UNISTR2 here is non-standard. */
 452                 r_t->uni_trust_dom_name[i].undoc = 0x1;
 453         }
 454
 455         r_t->status = NT_STATUS_OK;
 456 }
 457
 458 /*******************************************************************
 459  Reads or writes an NET_R_TRUST_DOM_LIST structure.
 460 ********************************************************************/
 461
 462 BOOL net_io_r_trust_dom(const char *desc, NET_R_TRUST_DOM_LIST *r_t, prs_struct *ps, int depth)
 463 {
 464         uint32 value;
 465
 466         if (r_t == NULL)
 467                  return False;
 468
 469         prs_debug(ps, depth, desc, "net_io_r_trust_dom");
 470         depth++;
 471
 472         /* temporary code to give a valid response */
 473         value=2;
 474         if(!prs_uint32("status", ps, depth, &value))
 475                  return False;
 476
 477         value=1;
 478         if(!prs_uint32("status", ps, depth, &value))
 479                  return False;
 480         value=2;
 481         if(!prs_uint32("status", ps, depth, &value))
 482                  return False;
 483
 484         value=0;
 485         if(!prs_uint32("status", ps, depth, &value))
 486                  return False;
 487
 488         value=0;
 489         if(!prs_uint32("status", ps, depth, &value))
 490                  return False;
 491
 492 /* old non working code */
 493 #if 0
 494         int i;
 495
 496         for (i = 0; i < MAX_TRUST_DOMS; i++) {
 497                 if (r_t->uni_trust_dom_name[i].uni_str_len == 0)
 498                         break;
 499                 if(!smb_io_unistr2("", &r_t->uni_trust_dom_name[i], True, ps, depth))
 500                          return False;
 501         }
 502
 503         if(!prs_ntstatus("status", ps, depth, &r_t->status))
 504                  return False;
 505 #endif
 506         return True;
 507 }
 508
 509
 510 /*******************************************************************
 511  Reads or writes an NET_Q_TRUST_DOM_LIST structure.
 512 ********************************************************************/
 513
 514 BOOL net_io_q_trust_dom(const char *desc, NET_Q_TRUST_DOM_LIST *q_l, prs_struct *ps, int depth)
 515 {
 516         if (q_l == NULL)
 517                  return False;
 518
 519         prs_debug(ps, depth, desc, "net_io_q_trust_dom");
 520         depth++;
 521
 522         if(!prs_uint32("ptr          ", ps, depth, &q_l->ptr))
 523                  return False;
 524         if(!smb_io_unistr2 ("", &q_l->uni_server_name, q_l->ptr, ps, depth))
 525                  return False;
 526
 527         return True;
 528 }
 529
 530 /*******************************************************************
 531  Inits an NET_Q_REQ_CHAL structure.
 532 ********************************************************************/
 533
 534 void init_q_req_chal(NET_Q_REQ_CHAL *q_c,
 535                      const char *logon_srv, const char *logon_clnt,
 536                      DOM_CHAL *clnt_chal)
 537 {
 538         DEBUG(5,("init_q_req_chal: %d\n", __LINE__));
 539
 540         q_c->undoc_buffer = 1; /* don't know what this buffer is */
 541
 542         init_unistr2(&q_c->uni_logon_srv, logon_srv , strlen(logon_srv )+1);
 543         init_unistr2(&q_c->uni_logon_clnt, logon_clnt, strlen(logon_clnt)+1);
 544
 545         memcpy(q_c->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
 546
 547         DEBUG(5,("init_q_req_chal: %d\n", __LINE__));
 548 }
 549
 550 /*******************************************************************
 551  Reads or writes an NET_Q_REQ_CHAL structure.
 552 ********************************************************************/
 553
 554 BOOL net_io_q_req_chal(const char *desc,  NET_Q_REQ_CHAL *q_c, prs_struct *ps, int depth)
 555 {
 556         if (q_c == NULL)
 557                 return False;
 558
 559         prs_debug(ps, depth, desc, "net_io_q_req_chal");
 560         depth++;
 561
 562         if(!prs_align(ps))
 563                 return False;
 564
 565         if(!prs_uint32("undoc_buffer", ps, depth, &q_c->undoc_buffer))
 566                 return False;
 567
 568         if(!smb_io_unistr2("", &q_c->uni_logon_srv, True, ps, depth)) /* logon server unicode string */
 569                 return False;
 570         if(!smb_io_unistr2("", &q_c->uni_logon_clnt, True, ps, depth)) /* logon client unicode string */
 571                 return False;
 572
 573         if(!smb_io_chal("", &q_c->clnt_chal, ps, depth))
 574                 return False;
 575
 576         return True;
 577 }
 578
 579 /*******************************************************************
 580  Reads or writes a structure.
 581 ********************************************************************/
 582
 583 BOOL net_io_r_req_chal(const char *desc, NET_R_REQ_CHAL *r_c, prs_struct *ps, int depth)
 584 {
 585         if (r_c == NULL)
 586                 return False;
 587
 588         prs_debug(ps, depth, desc, "net_io_r_req_chal");
 589         depth++;
 590
 591         if(!prs_align(ps))
 592                 return False;
 593
 594         if(!smb_io_chal("", &r_c->srv_chal, ps, depth)) /* server challenge */
 595                 return False;
 596
 597         if(!prs_ntstatus("status", ps, depth, &r_c->status))
 598                 return False;
 599
 600         return True;
 601 }
 602
 603
 604 /*******************************************************************
 605  Reads or writes a structure.
 606 ********************************************************************/
 607
 608 BOOL net_io_q_auth(const char *desc, NET_Q_AUTH *q_a, prs_struct *ps, int depth)
 609 {
 610         if (q_a == NULL)
 611                 return False;
 612
 613         prs_debug(ps, depth, desc, "net_io_q_auth");
 614         depth++;
 615
 616         if(!prs_align(ps))
 617                 return False;
 618
 619         if(!smb_io_log_info ("", &q_a->clnt_id, ps, depth)) /* client identification info */
 620                 return False;
 621         if(!smb_io_chal("", &q_a->clnt_chal, ps, depth))
 622                 return False;
 623
 624         return True;
 625 }
 626
 627 /*******************************************************************
 628  Reads or writes a structure.
 629 ********************************************************************/
 630
 631 BOOL net_io_r_auth(const char *desc, NET_R_AUTH *r_a, prs_struct *ps, int depth)
 632 {
 633         if (r_a == NULL)
 634                 return False;
 635
 636         prs_debug(ps, depth, desc, "net_io_r_auth");
 637         depth++;
 638
 639         if(!prs_align(ps))
 640                 return False;
 641
 642         if(!smb_io_chal("", &r_a->srv_chal, ps, depth)) /* server challenge */
 643                 return False;
 644
 645         if(!prs_ntstatus("status", ps, depth, &r_a->status))
 646                 return False;
 647
 648         return True;
 649 }
 650
 651 /*******************************************************************
 652  Inits a NET_Q_AUTH_2 struct.
 653 ********************************************************************/
 654
 655 void init_q_auth_2(NET_Q_AUTH_2 *q_a,
 656                 const char *logon_srv, const char *acct_name, uint16 sec_chan, const char *comp_name,
 657                 DOM_CHAL *clnt_chal, uint32 clnt_flgs)
 658 {
 659         DEBUG(5,("init_q_auth_2: %d\n", __LINE__));
 660
 661         init_log_info(&q_a->clnt_id, logon_srv, acct_name, sec_chan, comp_name);
 662         memcpy(q_a->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
 663         q_a->clnt_flgs.neg_flags = clnt_flgs;
 664
 665         DEBUG(5,("init_q_auth_2: %d\n", __LINE__));
 666 }
 667
 668 /*******************************************************************
 669  Reads or writes a structure.
 670 ********************************************************************/
 671
 672 BOOL net_io_q_auth_2(const char *desc, NET_Q_AUTH_2 *q_a, prs_struct *ps, int depth)
 673 {
 674         if (q_a == NULL)
 675                 return False;
 676
 677         prs_debug(ps, depth, desc, "net_io_q_auth_2");
 678         depth++;
 679
 680         if(!prs_align(ps))
 681                 return False;
 682
 683         if(!smb_io_log_info ("", &q_a->clnt_id, ps, depth)) /* client identification info */
 684                 return False;
 685         if(!smb_io_chal("", &q_a->clnt_chal, ps, depth))
 686                 return False;
 687         if(!net_io_neg_flags("", &q_a->clnt_flgs, ps, depth))
 688                 return False;
 689
 690         return True;
 691 }
 692
 693 /*******************************************************************
 694  Reads or writes a structure.
 695 ********************************************************************/
 696
 697 BOOL net_io_r_auth_2(const char *desc, NET_R_AUTH_2 *r_a, prs_struct *ps, int depth)
 698 {
 699         if (r_a == NULL)
 700                 return False;
 701
 702         prs_debug(ps, depth, desc, "net_io_r_auth_2");
 703         depth++;
 704
 705         if(!prs_align(ps))
 706                 return False;
 707
 708         if(!smb_io_chal("", &r_a->srv_chal, ps, depth)) /* server challenge */
 709                 return False;
 710         if(!net_io_neg_flags("", &r_a->srv_flgs, ps, depth))
 711                 return False;
 712
 713         if(!prs_ntstatus("status", ps, depth, &r_a->status))
 714                 return False;
 715
 716         return True;
 717 }
 718
 719 /*******************************************************************
 720  Inits a NET_Q_AUTH_3 struct.
 721 ********************************************************************/
 722
 723 void init_q_auth_3(NET_Q_AUTH_3 *q_a,
 724                 const char *logon_srv, const char *acct_name, uint16 sec_chan, const char *comp_name,
 725                 DOM_CHAL *clnt_chal, uint32 clnt_flgs)
 726 {
 727         DEBUG(5,("init_q_auth_3: %d\n", __LINE__));
 728
 729         init_log_info(&q_a->clnt_id, logon_srv, acct_name, sec_chan, comp_name);
 730         memcpy(q_a->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
 731         q_a->clnt_flgs.neg_flags = clnt_flgs;
 732
 733         DEBUG(5,("init_q_auth_3: %d\n", __LINE__));
 734 }
 735
 736 /*******************************************************************
 737  Reads or writes a structure.
 738 ********************************************************************/
 739
 740 BOOL net_io_q_auth_3(const char *desc, NET_Q_AUTH_3 *q_a, prs_struct *ps, int depth)
 741 {
 742         if (q_a == NULL)
 743                 return False;
 744
 745         prs_debug(ps, depth, desc, "net_io_q_auth_3");
 746         depth++;
 747
 748         if(!prs_align(ps))
 749                 return False;
 750
 751         if(!smb_io_log_info ("", &q_a->clnt_id, ps, depth)) /* client identification info */
 752                 return False;
 753         if(!smb_io_chal("", &q_a->clnt_chal, ps, depth))
 754                 return False;
 755         if(!net_io_neg_flags("", &q_a->clnt_flgs, ps, depth))
 756                 return False;
 757
 758         return True;
 759 }
 760
 761 /*******************************************************************
 762  Reads or writes a structure.
 763 ********************************************************************/
 764
 765 BOOL net_io_r_auth_3(const char *desc, NET_R_AUTH_3 *r_a, prs_struct *ps, int depth)
 766 {
 767         if (r_a == NULL)
 768                 return False;
 769
 770         prs_debug(ps, depth, desc, "net_io_r_auth_3");
 771         depth++;
 772
 773         if(!prs_align(ps))
 774                 return False;
 775
 776         if(!smb_io_chal("srv_chal", &r_a->srv_chal, ps, depth)) /* server challenge */
 777                 return False;
 778         if(!net_io_neg_flags("srv_flgs", &r_a->srv_flgs, ps, depth))
 779                 return False;
 780         if (!prs_uint32("unknown", ps, depth, &r_a->unknown))
 781                 return False;
 782
 783         if(!prs_ntstatus("status", ps, depth, &r_a->status))
 784                 return False;
 785
 786         return True;
 787 }
 788
 789
 790 /*******************************************************************
 791  Inits a NET_Q_SRV_PWSET.
 792 ********************************************************************/
 793
 794 void init_q_srv_pwset(NET_Q_SRV_PWSET *q_s,
 795                 const char *logon_srv, const char *sess_key, const char *acct_name,
 796                 uint16 sec_chan, const char *comp_name,
 797                 DOM_CRED *cred, uchar hashed_mach_pwd[16])
 798 {
 799         unsigned char nt_cypher[16];
 800
 801         DEBUG(5,("init_q_srv_pwset\n"));
 802
 803         /* Process the new password. */
 804         cred_hash3( nt_cypher, hashed_mach_pwd, sess_key, 1);
 805
 806         init_clnt_info(&q_s->clnt_id, logon_srv, acct_name, sec_chan, comp_name, cred);
 807
 808         memcpy(q_s->pwd, nt_cypher, sizeof(q_s->pwd));
 809 }
 810
 811 /*******************************************************************
 812  Reads or writes a structure.
 813 ********************************************************************/
 814
 815 BOOL net_io_q_srv_pwset(const char *desc, NET_Q_SRV_PWSET *q_s, prs_struct *ps, int depth)
 816 {
 817         if (q_s == NULL)
 818                 return False;
 819
 820         prs_debug(ps, depth, desc, "net_io_q_srv_pwset");
 821         depth++;
 822
 823         if(!prs_align(ps))
 824                 return False;
 825
 826         if(!smb_io_clnt_info("", &q_s->clnt_id, ps, depth)) /* client identification/authentication info */
 827                 return False;
 828         if(!prs_uint8s (False, "pwd", ps, depth, q_s->pwd, 16)) /* new password - undocumented */
 829                 return False;
 830
 831         return True;
 832 }
 833
 834 /*******************************************************************
 835  Reads or writes a structure.
 836 ********************************************************************/
 837
 838 BOOL net_io_r_srv_pwset(const char *desc, NET_R_SRV_PWSET *r_s, prs_struct *ps, int depth)
 839 {
 840         if (r_s == NULL)
 841                 return False;
 842
 843         prs_debug(ps, depth, desc, "net_io_r_srv_pwset");
 844         depth++;
 845
 846         if(!prs_align(ps))
 847                 return False;
 848
 849         if(!smb_io_cred("", &r_s->srv_cred, ps, depth)) /* server challenge */
 850                 return False;
 851
 852         if(!prs_ntstatus("status", ps, depth, &r_s->status))
 853                 return False;
 854
 855         return True;
 856 }
 857
 858 /*************************************************************************
 859  Init DOM_SID2 array from a string containing multiple sids
 860  *************************************************************************/
 861
 862 static int init_dom_sid2s(TALLOC_CTX *ctx, const char *sids_str, DOM_SID2 **ppsids)
 863 {
 864         const char *ptr;
 865         pstring s2;
 866         int count = 0;
 867
 868         DEBUG(4,("init_dom_sid2s: %s\n", sids_str ? sids_str:""));
 869
 870         *ppsids = NULL;
 871
 872         if(sids_str) {
 873                 int number;
 874                 DOM_SID2 *sids;
 875
 876                 /* Count the number of valid SIDs. */
 877                 for (count = 0, ptr = sids_str; next_token(&ptr, s2, NULL, sizeof(s2)); ) {
 878                         DOM_SID tmpsid;
 879                         if (string_to_sid(&tmpsid, s2))
 880                                 count++;
 881                 }
 882
 883                 /* Now allocate space for them. */
 884                 *ppsids = (DOM_SID2 *)talloc_zero(ctx, count * sizeof(DOM_SID2));
 885                 if (*ppsids == NULL)
 886                         return 0;
 887
 888                 sids = *ppsids;
 889
 890                 for (number = 0, ptr = sids_str; next_token(&ptr, s2, NULL, sizeof(s2)); ) {
 891                         DOM_SID tmpsid;
 892                         if (string_to_sid(&tmpsid, s2)) {
 893                                 /* count only valid sids */
 894                                 init_dom_sid2(&sids[number], &tmpsid);
 895                                 number++;
 896                         }
 897                 }
 898         }
 899
 900         return count;
 901 }
 902
 903 /*******************************************************************
 904  Inits a NET_ID_INFO_1 structure.
 905 ********************************************************************/
 906
 907 void init_id_info1(NET_ID_INFO_1 *id, const char *domain_name,
 908                                 uint32 param_ctrl, uint32 log_id_low, uint32 log_id_high,
 909                                 const char *user_name, const char *wksta_name,
 910                                 const char *sess_key,
 911                                 unsigned char lm_cypher[16], unsigned char nt_cypher[16])
 912 {
 913         int len_domain_name = strlen(domain_name);
 914         int len_user_name   = strlen(user_name  );
 915         int len_wksta_name  = strlen(wksta_name );
 916
 917         unsigned char lm_owf[16];
 918         unsigned char nt_owf[16];
 919
 920         DEBUG(5,("init_id_info1: %d\n", __LINE__));
 921
 922         id->ptr_id_info1 = 1;
 923
 924         init_uni_hdr(&id->hdr_domain_name, len_domain_name);
 925
 926         id->param_ctrl = param_ctrl;
 927         init_logon_id(&id->logon_id, log_id_low, log_id_high);
 928
 929         init_uni_hdr(&id->hdr_user_name, len_user_name);
 930         init_uni_hdr(&id->hdr_wksta_name, len_wksta_name);
 931
 932         if (lm_cypher && nt_cypher) {
 933                 unsigned char key[16];
 934 #ifdef DEBUG_PASSWORD
 935                 DEBUG(100,("lm cypher:"));
 936                 dump_data(100, (char *)lm_cypher, 16);
 937
 938                 DEBUG(100,("nt cypher:"));
 939                 dump_data(100, (char *)nt_cypher, 16);
 940 #endif
 941
 942                 memset(key, 0, 16);
 943                 memcpy(key, sess_key, 8);
 944
 945                 memcpy(lm_owf, lm_cypher, 16);
 946                 SamOEMhash(lm_owf, key, 16);
 947                 memcpy(nt_owf, nt_cypher, 16);
 948                 SamOEMhash(nt_owf, key, 16);
 949
 950 #ifdef DEBUG_PASSWORD
 951                 DEBUG(100,("encrypt of lm owf password:"));
 952                 dump_data(100, (char *)lm_owf, 16);
 953
 954                 DEBUG(100,("encrypt of nt owf password:"));
 955                 dump_data(100, (char *)nt_owf, 16);
 956 #endif
 957                 /* set up pointers to cypher blocks */
 958                 lm_cypher = lm_owf;
 959                 nt_cypher = nt_owf;
 960         }
 961
 962         init_owf_info(&id->lm_owf, lm_cypher);
 963         init_owf_info(&id->nt_owf, nt_cypher);
 964
 965         init_unistr2(&id->uni_domain_name, domain_name, len_domain_name);
 966         init_unistr2(&id->uni_user_name, user_name, len_user_name);
 967         init_unistr2(&id->uni_wksta_name, wksta_name, len_wksta_name);
 968 }
 969
 970 /*******************************************************************
 971  Reads or writes an NET_ID_INFO_1 structure.
 972 ********************************************************************/
 973
 974 static BOOL net_io_id_info1(const char *desc,  NET_ID_INFO_1 *id, prs_struct *ps, int depth)
 975 {
 976         if (id == NULL)
 977                 return False;
 978
 979         prs_debug(ps, depth, desc, "net_io_id_info1");
 980         depth++;
 981
 982         if(!prs_align(ps))
 983                 return False;
 984
 985         if(!prs_uint32("ptr_id_info1", ps, depth, &id->ptr_id_info1))
 986                 return False;
 987
 988         if (id->ptr_id_info1 != 0) {
 989                 if(!smb_io_unihdr("unihdr", &id->hdr_domain_name, ps, depth))
 990                         return False;
 991
 992                 if(!prs_uint32("param_ctrl", ps, depth, &id->param_ctrl))
 993                         return False;
 994                 if(!smb_io_logon_id("", &id->logon_id, ps, depth))
 995                         return False;
 996
 997                 if(!smb_io_unihdr("unihdr", &id->hdr_user_name, ps, depth))
 998                         return False;
 999                 if(!smb_io_unihdr("unihdr", &id->hdr_wksta_name, ps, depth))
1000                         return False;
1001
1002                 if(!smb_io_owf_info("", &id->lm_owf, ps, depth))
1003                         return False;
1004                 if(!smb_io_owf_info("", &id->nt_owf, ps, depth))
1005                         return False;
1006
1007                 if(!smb_io_unistr2("unistr2", &id->uni_domain_name,
1008                                 id->hdr_domain_name.buffer, ps, depth))
1009                         return False;
1010                 if(!smb_io_unistr2("unistr2", &id->uni_user_name,
1011                                 id->hdr_user_name.buffer, ps, depth))
1012                         return False;
1013                 if(!smb_io_unistr2("unistr2", &id->uni_wksta_name,
1014                                 id->hdr_wksta_name.buffer, ps, depth))
1015                         return False;
1016         }
1017
1018         return True;
1019 }
1020
1021 /*******************************************************************
1022 Inits a NET_ID_INFO_2 structure.
1023
1024 This is a network logon packet. The log_id parameters
1025 are what an NT server would generate for LUID once the
1026 user is logged on. I don't think we care about them.
1027
1028 Note that this has no access to the NT and LM hashed passwords,
1029 so it forwards the challenge, and the NT and LM responses (24
1030 bytes each) over the secure channel to the Domain controller
1031 for it to say yea or nay. This is the preferred method of
1032 checking for a logon as it doesn't export the password
1033 hashes to anyone who has compromised the secure channel. JRA.
1034 ********************************************************************/
1035
1036 void init_id_info2(NET_ID_INFO_2 * id, const char *domain_name,
1037                    uint32 param_ctrl,
1038                    uint32 log_id_low, uint32 log_id_high,
1039                    const char *user_name, const char *wksta_name,
1040                    const uchar lm_challenge[8],
1041                    const uchar * lm_chal_resp, size_t lm_chal_resp_len,
1042                    const uchar * nt_chal_resp, size_t nt_chal_resp_len)
1043 {
1044         size_t len_domain_name = strlen(domain_name);
1045         size_t len_user_name   = strlen(user_name  );
1046         size_t len_wksta_name  = strlen(wksta_name );
1047         unsigned char lm_owf[24];
1048         unsigned char nt_owf[128];
1049
1050         DEBUG(5,("init_id_info2: %d\n", __LINE__));
1051
1052         id->ptr_id_info2 = 1;
1053
1054         init_uni_hdr(&id->hdr_domain_name, len_domain_name);
1055
1056         id->param_ctrl = param_ctrl;
1057         init_logon_id(&id->logon_id, log_id_low, log_id_high);
1058
1059         init_uni_hdr(&id->hdr_user_name, len_user_name);
1060         init_uni_hdr(&id->hdr_wksta_name, len_wksta_name);
1061
1062         if (nt_chal_resp) {
1063                 /* oops.  can only send what-ever-it-is direct */
1064                 memcpy(nt_owf, nt_chal_resp, MIN(sizeof(nt_owf), nt_chal_resp_len));
1065                 nt_chal_resp = nt_owf;
1066         }
1067         if (lm_chal_resp) {
1068                 /* oops.  can only send what-ever-it-is direct */
1069                 memcpy(lm_owf, lm_chal_resp, MIN(sizeof(lm_owf), lm_chal_resp_len));
1070                 lm_chal_resp = lm_owf;
1071         }
1072
1073         memcpy(id->lm_chal, lm_challenge, sizeof(id->lm_chal));
1074         init_str_hdr(&id->hdr_nt_chal_resp, nt_chal_resp_len, nt_chal_resp_len, (nt_chal_resp != NULL) ? 1 : 0);
1075         init_str_hdr(&id->hdr_lm_chal_resp, lm_chal_resp_len, lm_chal_resp_len, (lm_chal_resp != NULL) ? 1 : 0);
1076
1077         init_unistr2(&id->uni_domain_name, domain_name, len_domain_name);
1078         init_unistr2(&id->uni_user_name, user_name, len_user_name);
1079         init_unistr2(&id->uni_wksta_name, wksta_name, len_wksta_name);
1080
1081         init_string2(&id->nt_chal_resp, (const char *)nt_chal_resp, nt_chal_resp_len, nt_chal_resp_len);
1082         init_string2(&id->lm_chal_resp, (const char *)lm_chal_resp, lm_chal_resp_len, lm_chal_resp_len);
1083
1084 }
1085
1086 /*******************************************************************
1087  Reads or writes an NET_ID_INFO_2 structure.
1088 ********************************************************************/
1089
1090 static BOOL net_io_id_info2(const char *desc,  NET_ID_INFO_2 *id, prs_struct *ps, int depth)
1091 {
1092         if (id == NULL)
1093                 return False;
1094
1095         prs_debug(ps, depth, desc, "net_io_id_info2");
1096         depth++;
1097
1098         if(!prs_align(ps))
1099                 return False;
1100
1101         if(!prs_uint32("ptr_id_info2", ps, depth, &id->ptr_id_info2))
1102                 return False;
1103
1104         if (id->ptr_id_info2 != 0) {
1105                 if(!smb_io_unihdr("unihdr", &id->hdr_domain_name, ps, depth))
1106                         return False;
1107
1108                 if(!prs_uint32("param_ctrl", ps, depth, &id->param_ctrl))
1109                         return False;
1110                 if(!smb_io_logon_id("", &id->logon_id, ps, depth))
1111                         return False;
1112
1113                 if(!smb_io_unihdr("unihdr", &id->hdr_user_name, ps, depth))
1114                         return False;
1115                 if(!smb_io_unihdr("unihdr", &id->hdr_wksta_name, ps, depth))
1116                         return False;
1117
1118                 if(!prs_uint8s (False, "lm_chal", ps, depth, id->lm_chal, 8)) /* lm 8 byte challenge */
1119                         return False;
1120
1121                 if(!smb_io_strhdr("hdr_nt_chal_resp", &id->hdr_nt_chal_resp, ps, depth))
1122                         return False;
1123                 if(!smb_io_strhdr("hdr_lm_chal_resp", &id->hdr_lm_chal_resp, ps, depth))
1124                         return False;
1125
1126                 if(!smb_io_unistr2("uni_domain_name", &id->uni_domain_name,
1127                                 id->hdr_domain_name.buffer, ps, depth))
1128                         return False;
1129                 if(!smb_io_unistr2("uni_user_name  ", &id->uni_user_name,
1130                                 id->hdr_user_name.buffer, ps, depth))
1131                         return False;
1132                 if(!smb_io_unistr2("uni_wksta_name ", &id->uni_wksta_name,
1133                                 id->hdr_wksta_name.buffer, ps, depth))
1134                         return False;
1135                 if(!smb_io_string2("nt_chal_resp", &id->nt_chal_resp,
1136                                 id->hdr_nt_chal_resp.buffer, ps, depth))
1137                         return False;
1138                 if(!smb_io_string2("lm_chal_resp", &id->lm_chal_resp,
1139                                 id->hdr_lm_chal_resp.buffer, ps, depth))
1140                         return False;
1141         }
1142
1143         return True;
1144 }
1145
1146
1147 /*******************************************************************
1148  Inits a DOM_SAM_INFO structure.
1149 ********************************************************************/
1150
1151 void init_sam_info(DOM_SAM_INFO *sam,
1152                                 const char *logon_srv, const char *comp_name,
1153                                 DOM_CRED *clnt_cred,
1154                                 DOM_CRED *rtn_cred, uint16 logon_level,
1155                                 NET_ID_INFO_CTR *ctr)
1156 {
1157         DEBUG(5,("init_sam_info: %d\n", __LINE__));
1158
1159         init_clnt_info2(&sam->client, logon_srv, comp_name, clnt_cred);
1160
1161         if (rtn_cred != NULL) {
1162                 sam->ptr_rtn_cred = 1;
1163                 memcpy(&sam->rtn_cred, rtn_cred, sizeof(sam->rtn_cred));
1164         } else {
1165                 sam->ptr_rtn_cred = 0;
1166         }
1167
1168         sam->logon_level  = logon_level;
1169         sam->ctr          = ctr;
1170 }
1171
1172 /*******************************************************************
1173  Reads or writes a DOM_SAM_INFO structure.
1174 ********************************************************************/
1175
1176 static BOOL net_io_id_info_ctr(const char *desc, NET_ID_INFO_CTR **pp_ctr, prs_struct *ps, int depth)
1177 {
1178         NET_ID_INFO_CTR *ctr = *pp_ctr;
1179
1180         prs_debug(ps, depth, desc, "smb_io_sam_info");
1181         depth++;
1182
1183         if (UNMARSHALLING(ps)) {
1184                 ctr = *pp_ctr = (NET_ID_INFO_CTR *)prs_alloc_mem(ps, sizeof(NET_ID_INFO_CTR));
1185                 if (ctr == NULL)
1186                         return False;
1187         }
1188
1189         if (ctr == NULL)
1190                 return False;
1191
1192         /* don't 4-byte align here! */
1193
1194         if(!prs_uint16("switch_value ", ps, depth, &ctr->switch_value))
1195                 return False;
1196
1197         switch (ctr->switch_value) {
1198         case 1:
1199                 if(!net_io_id_info1("", &ctr->auth.id1, ps, depth))
1200                         return False;
1201                 break;
1202         case 2:
1203                 if(!net_io_id_info2("", &ctr->auth.id2, ps, depth))
1204                         return False;
1205                 break;
1206         default:
1207                 /* PANIC! */
1208                 DEBUG(4,("smb_io_sam_info: unknown switch_value!\n"));
1209                 break;
1210         }
1211
1212         return True;
1213 }
1214
1215 /*******************************************************************
1216  Reads or writes a DOM_SAM_INFO structure.
1217  ********************************************************************/
1218
1219 static BOOL smb_io_sam_info(const char *desc, DOM_SAM_INFO *sam, prs_struct *ps, int depth)
1220 {
1221         if (sam == NULL)
1222                 return False;
1223
1224         prs_debug(ps, depth, desc, "smb_io_sam_info");
1225         depth++;
1226
1227         if(!prs_align(ps))
1228                 return False;
1229
1230         if(!smb_io_clnt_info2("", &sam->client, ps, depth))
1231                 return False;
1232
1233         if(!prs_uint32("ptr_rtn_cred ", ps, depth, &sam->ptr_rtn_cred))
1234                 return False;
1235         if(!smb_io_cred("", &sam->rtn_cred, ps, depth))
1236                 return False;
1237
1238         if(!prs_uint16("logon_level  ", ps, depth, &sam->logon_level))
1239                 return False;
1240
1241         if (sam->logon_level != 0) {
1242                 if(!net_io_id_info_ctr("logon_info", &sam->ctr, ps, depth))
1243                         return False;
1244         }
1245
1246         return True;
1247 }
1248
1249 /*************************************************************************
1250  Inits a NET_USER_INFO_3 structure.
1251
1252  This is a network logon reply packet, and contains much information about
1253  the user.  This information is passed as a (very long) paramater list
1254  to avoid having to link in the PASSDB code to every program that deals
1255  with this file.
1256  *************************************************************************/
1257
1258 void init_net_user_info3(TALLOC_CTX *ctx, NET_USER_INFO_3 *usr,
1259                          uint32                user_rid,
1260                          uint32                group_rid,
1261
1262                          const char*            user_name,
1263                          const char*            full_name,
1264                          const char*            home_dir,
1265                          const char*            dir_drive,
1266                          const char*            logon_script,
1267                          const char*            profile_path,
1268
1269                          time_t unix_logon_time,
1270                          time_t unix_logoff_time,
1271                          time_t unix_kickoff_time,
1272                          time_t unix_pass_last_set_time,
1273                          time_t unix_pass_can_change_time,
1274                          time_t unix_pass_must_change_time,
1275
1276                          uint16 logon_count, uint16 bad_pw_count,
1277                          uint32 num_groups, const DOM_GID *gids,
1278                          uint32 user_flgs, uchar sess_key[16],
1279                          const char *logon_srv, const char *logon_dom,
1280                          const DOM_SID *dom_sid, const char *other_sids)
1281 {
1282         /* only cope with one "other" sid, right now. */
1283         /* need to count the number of space-delimited sids */
1284         unsigned int i;
1285         int num_other_sids = 0;
1286
1287         NTTIME          logon_time, logoff_time, kickoff_time,
1288                         pass_last_set_time, pass_can_change_time,
1289                         pass_must_change_time;
1290
1291         int             len_user_name, len_full_name, len_home_dir,
1292                         len_dir_drive, len_logon_script, len_profile_path;
1293
1294         int len_logon_srv    = strlen(logon_srv);
1295         int len_logon_dom    = strlen(logon_dom);
1296
1297         len_user_name    = strlen(user_name    );
1298         len_full_name    = strlen(full_name   );
1299         len_home_dir     = strlen(home_dir    );
1300         len_dir_drive    = strlen(dir_drive   );
1301         len_logon_script = strlen(logon_script);
1302         len_profile_path = strlen(profile_path);
1303
1304
1305         ZERO_STRUCTP(usr);
1306
1307         usr->ptr_user_info = 1; /* yes, we're bothering to put USER_INFO data here */
1308
1309
1310
1311         /* Create NTTIME structs */
1312         unix_to_nt_time (&logon_time,            unix_logon_time);
1313         unix_to_nt_time (&logoff_time,           unix_logoff_time);
1314         unix_to_nt_time (&kickoff_time,          unix_kickoff_time);
1315         unix_to_nt_time (&pass_last_set_time,    unix_pass_last_set_time);
1316         unix_to_nt_time (&pass_can_change_time,  unix_pass_can_change_time);
1317         unix_to_nt_time (&pass_must_change_time, unix_pass_must_change_time);
1318
1319         usr->logon_time            = logon_time;
1320         usr->logoff_time           = logoff_time;
1321         usr->kickoff_time          = kickoff_time;
1322         usr->pass_last_set_time    = pass_last_set_time;
1323         usr->pass_can_change_time  = pass_can_change_time;
1324         usr->pass_must_change_time = pass_must_change_time;
1325
1326         init_uni_hdr(&usr->hdr_user_name, len_user_name);
1327         init_uni_hdr(&usr->hdr_full_name, len_full_name);
1328         init_uni_hdr(&usr->hdr_logon_script, len_logon_script);
1329         init_uni_hdr(&usr->hdr_profile_path, len_profile_path);
1330         init_uni_hdr(&usr->hdr_home_dir, len_home_dir);
1331         init_uni_hdr(&usr->hdr_dir_drive, len_dir_drive);
1332
1333         usr->logon_count = logon_count;
1334         usr->bad_pw_count = bad_pw_count;
1335
1336         usr->user_rid = user_rid;
1337         usr->group_rid = group_rid;
1338         usr->num_groups = num_groups;
1339
1340         usr->buffer_groups = 1; /* indicates fill in groups, below, even if there are none */
1341         usr->user_flgs = user_flgs;
1342
1343         if (sess_key != NULL)
1344                 memcpy(usr->user_sess_key, sess_key, sizeof(usr->user_sess_key));
1345         else
1346                 memset((char *)usr->user_sess_key, '\0', sizeof(usr->user_sess_key));
1347
1348         init_uni_hdr(&usr->hdr_logon_srv, len_logon_srv);
1349         init_uni_hdr(&usr->hdr_logon_dom, len_logon_dom);
1350
1351         usr->buffer_dom_id = dom_sid ? 1 : 0; /* yes, we're bothering to put a domain SID in */
1352
1353         memset((char *)usr->padding, '\0', sizeof(usr->padding));
1354
1355         num_other_sids = init_dom_sid2s(ctx, other_sids, &usr->other_sids);
1356
1357         usr->num_other_sids = num_other_sids;
1358         usr->buffer_other_sids = (num_other_sids != 0) ? 1 : 0;
1359
1360         init_unistr2(&usr->uni_user_name, user_name, len_user_name);
1361         init_unistr2(&usr->uni_full_name, full_name, len_full_name);
1362         init_unistr2(&usr->uni_logon_script, logon_script, len_logon_script);
1363         init_unistr2(&usr->uni_profile_path, profile_path, len_profile_path);
1364         init_unistr2(&usr->uni_home_dir, home_dir, len_home_dir);
1365         init_unistr2(&usr->uni_dir_drive, dir_drive, len_dir_drive);
1366
1367         usr->num_groups2 = num_groups;
1368
1369         usr->gids = (DOM_GID *)talloc_zero(ctx,sizeof(DOM_GID) * (num_groups));
1370         if (usr->gids == NULL && num_groups>0)
1371                 return;
1372
1373         for (i = 0; i < num_groups; i++)
1374                 usr->gids[i] = gids[i];
1375
1376         init_unistr2(&usr->uni_logon_srv, logon_srv, len_logon_srv);
1377         init_unistr2(&usr->uni_logon_dom, logon_dom, len_logon_dom);
1378
1379         init_dom_sid2(&usr->dom_sid, dom_sid);
1380         /* "other" sids are set up above */
1381 }
1382
1383 /*******************************************************************
1384  This code has been modified to cope with a NET_USER_INFO_2 - which is
1385  exactly the same as a NET_USER_INFO_3, minus the other sids parameters.
1386  We use validation level to determine if we're marshalling a info 2 or
1387  INFO_3 - be we always return an INFO_3. Based on code donated by Marc
1388  Jacobsen at HP. JRA.
1389 ********************************************************************/
1390
1391 BOOL net_io_user_info3(const char *desc, NET_USER_INFO_3 *usr, prs_struct *ps,
1392                        int depth, uint16 validation_level)
1393 {
1394         unsigned int i;
1395
1396         if (usr == NULL)
1397                 return False;
1398
1399         prs_debug(ps, depth, desc, "net_io_user_info3");
1400         depth++;
1401
1402         if (UNMARSHALLING(ps))
1403                 ZERO_STRUCTP(usr);
1404
1405         if(!prs_align(ps))
1406                 return False;
1407
1408         if(!prs_uint32("ptr_user_info ", ps, depth, &usr->ptr_user_info))
1409                 return False;
1410
1411         if (usr->ptr_user_info == 0)
1412                 return True;
1413
1414         if(!smb_io_time("logon time", &usr->logon_time, ps, depth)) /* logon time */
1415                 return False;
1416         if(!smb_io_time("logoff time", &usr->logoff_time, ps, depth)) /* logoff time */
1417                 return False;
1418         if(!smb_io_time("kickoff time", &usr->kickoff_time, ps, depth)) /* kickoff time */
1419                 return False;
1420         if(!smb_io_time("last set time", &usr->pass_last_set_time, ps, depth)) /* password last set time */
1421                 return False;
1422         if(!smb_io_time("can change time", &usr->pass_can_change_time , ps, depth)) /* password can change time */
1423                 return False;
1424         if(!smb_io_time("must change time", &usr->pass_must_change_time, ps, depth)) /* password must change time */
1425                 return False;
1426
1427         if(!smb_io_unihdr("hdr_user_name", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
1428                 return False;
1429         if(!smb_io_unihdr("hdr_full_name", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
1430                 return False;
1431         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
1432                 return False;
1433         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
1434                 return False;
1435         if(!smb_io_unihdr("hdr_home_dir", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
1436                 return False;
1437         if(!smb_io_unihdr("hdr_dir_drive", &usr->hdr_dir_drive, ps, depth)) /* home directory drive unicode string header */
1438                 return False;
1439
1440         if(!prs_uint16("logon_count   ", ps, depth, &usr->logon_count))  /* logon count */
1441                 return False;
1442         if(!prs_uint16("bad_pw_count  ", ps, depth, &usr->bad_pw_count)) /* bad password count */
1443                 return False;
1444
1445         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))       /* User RID */
1446                 return False;
1447         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))      /* Group RID */
1448                 return False;
1449         if(!prs_uint32("num_groups    ", ps, depth, &usr->num_groups))    /* num groups */
1450                 return False;
1451         if(!prs_uint32("buffer_groups ", ps, depth, &usr->buffer_groups)) /* undocumented buffer pointer to groups. */
1452                 return False;
1453         if(!prs_uint32("user_flgs     ", ps, depth, &usr->user_flgs))     /* user flags */
1454                 return False;
1455
1456         if(!prs_uint8s(False, "user_sess_key", ps, depth, usr->user_sess_key, 16)) /* user session key */
1457                 return False;
1458
1459         if(!smb_io_unihdr("hdr_logon_srv", &usr->hdr_logon_srv, ps, depth)) /* logon server unicode string header */
1460                 return False;
1461         if(!smb_io_unihdr("hdr_logon_dom", &usr->hdr_logon_dom, ps, depth)) /* logon domain unicode string header */
1462                 return False;
1463
1464         if(!prs_uint32("buffer_dom_id ", ps, depth, &usr->buffer_dom_id)) /* undocumented logon domain id pointer */
1465                 return False;
1466         if(!prs_uint8s (False, "padding       ", ps, depth, usr->padding, 40)) /* unused padding bytes? */
1467                 return False;
1468
1469         if (validation_level == 3) {
1470                 if(!prs_uint32("num_other_sids", ps, depth, &usr->num_other_sids)) /* 0 - num_sids */
1471                         return False;
1472                 if(!prs_uint32("buffer_other_sids", ps, depth, &usr->buffer_other_sids)) /* NULL - undocumented pointer to SIDs. */
1473                         return False;
1474         } else {
1475                 if (UNMARSHALLING(ps)) {
1476                         usr->num_other_sids = 0;
1477                         usr->buffer_other_sids = 0;
1478                 }
1479         }
1480
1481         if(!smb_io_unistr2("uni_user_name", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
1482                 return False;
1483         if(!smb_io_unistr2("uni_full_name", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
1484                 return False;
1485         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
1486                 return False;
1487         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
1488                 return False;
1489         if(!smb_io_unistr2("uni_home_dir", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
1490                 return False;
1491         if(!smb_io_unistr2("uni_dir_drive", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
1492                 return False;
1493
1494         if(!prs_align(ps))
1495                 return False;
1496         if(!prs_uint32("num_groups2   ", ps, depth, &usr->num_groups2))        /* num groups */
1497                 return False;
1498
1499         if (UNMARSHALLING(ps) && usr->num_groups2 > 0) {
1500                 usr->gids = (DOM_GID *)prs_alloc_mem(ps, sizeof(DOM_GID)*usr->num_groups2);
1501                 if (usr->gids == NULL)
1502                         return False;
1503         }
1504
1505         for (i = 0; i < usr->num_groups2; i++) {
1506                 if(!smb_io_gid("", &usr->gids[i], ps, depth)) /* group info */
1507                         return False;
1508         }
1509
1510         if(!smb_io_unistr2("uni_logon_srv", &usr->uni_logon_srv, usr->hdr_logon_srv.buffer, ps, depth)) /* logon server unicode string */
1511                 return False;
1512         if(!smb_io_unistr2("uni_logon_dom", &usr->uni_logon_dom, usr->hdr_logon_srv.buffer, ps, depth)) /* logon domain unicode string */
1513                 return False;
1514
1515         if(!smb_io_dom_sid2("", &usr->dom_sid, ps, depth))           /* domain SID */
1516                 return False;
1517
1518         if (usr->num_other_sids) {
1519
1520                 if (UNMARSHALLING(ps)) {
1521                         usr->other_sids = (DOM_SID2 *)prs_alloc_mem(ps, sizeof(DOM_SID2)*usr->num_other_sids);
1522                         if (usr->other_sids == NULL)
1523                                 return False;
1524                 }
1525
1526                 if(!prs_uint32("num_other_groups", ps, depth, &usr->num_other_groups))
1527                         return False;
1528
1529                 if (UNMARSHALLING(ps) && usr->num_other_groups > 0) {
1530                         usr->other_gids = (DOM_GID *)prs_alloc_mem(ps, sizeof(DOM_GID)*usr->num_other_groups);
1531                         if (usr->other_gids == NULL)
1532                                 return False;
1533                 }
1534
1535                 for (i = 0; i < usr->num_other_groups; i++) {
1536                         if(!smb_io_gid("", &usr->other_gids[i], ps, depth)) /* other GIDs */
1537                                 return False;
1538                 }
1539                 for (i = 0; i < usr->num_other_sids; i++) {
1540                         if(!smb_io_dom_sid2("", &usr->other_sids[i], ps, depth)) /* other domain SIDs */
1541                                 return False;
1542                 }
1543         }
1544
1545         return True;
1546 }
1547
1548 /*******************************************************************
1549  Reads or writes a structure.
1550 ********************************************************************/
1551
1552 BOOL net_io_q_sam_logon(const char *desc, NET_Q_SAM_LOGON *q_l, prs_struct *ps, int depth)
1553 {
1554         if (q_l == NULL)
1555                 return False;
1556
1557         prs_debug(ps, depth, desc, "net_io_q_sam_logon");
1558         depth++;
1559
1560         if(!prs_align(ps))
1561                 return False;
1562
1563         if(!smb_io_sam_info("", &q_l->sam_id, ps, depth))
1564                 return False;
1565
1566         if(!prs_uint16("validation_level", ps, depth, &q_l->validation_level))
1567                 return False;
1568
1569         return True;
1570 }
1571
1572 /*******************************************************************
1573  Reads or writes a structure.
1574 ********************************************************************/
1575
1576 BOOL net_io_r_sam_logon(const char *desc, NET_R_SAM_LOGON *r_l, prs_struct *ps, int depth)
1577 {
1578         if (r_l == NULL)
1579                 return False;
1580
1581         prs_debug(ps, depth, desc, "net_io_r_sam_logon");
1582         depth++;
1583
1584         if(!prs_uint32("buffer_creds", ps, depth, &r_l->buffer_creds)) /* undocumented buffer pointer */
1585                 return False;
1586         if(!smb_io_cred("", &r_l->srv_creds, ps, depth)) /* server credentials.  server time stamp appears to be ignored. */
1587                 return False;
1588
1589         if(!prs_uint16("switch_value", ps, depth, &r_l->switch_value))
1590                 return False;
1591         if(!prs_align(ps))
1592                 return False;
1593
1594 #if 1 /* W2k always needs this - even for bad passwd. JRA */
1595         if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value))
1596                 return False;
1597 #else
1598         if (r_l->switch_value != 0) {
1599                 if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value))
1600                         return False;
1601         }
1602 #endif
1603
1604         if(!prs_uint32("auth_resp   ", ps, depth, &r_l->auth_resp)) /* 1 - Authoritative response; 0 - Non-Auth? */
1605                 return False;
1606
1607         if(!prs_ntstatus("status      ", ps, depth, &r_l->status))
1608                 return False;
1609
1610         if(!prs_align(ps))
1611                 return False;
1612
1613         return True;
1614 }
1615
1616 /*******************************************************************
1617  Reads or writes a structure.
1618 ********************************************************************/
1619
1620 BOOL net_io_q_sam_logoff(const char *desc,  NET_Q_SAM_LOGOFF *q_l, prs_struct *ps, int depth)
1621 {
1622         if (q_l == NULL)
1623                 return False;
1624
1625         prs_debug(ps, depth, desc, "net_io_q_sam_logoff");
1626         depth++;
1627
1628         if(!prs_align(ps))
1629                 return False;
1630
1631         if(!smb_io_sam_info("", &q_l->sam_id, ps, depth))           /* domain SID */
1632                 return False;
1633
1634         return True;
1635 }
1636
1637 /*******************************************************************
1638  Reads or writes a structure.
1639 ********************************************************************/
1640
1641 BOOL net_io_r_sam_logoff(const char *desc, NET_R_SAM_LOGOFF *r_l, prs_struct *ps, int depth)
1642 {
1643         if (r_l == NULL)
1644                 return False;
1645
1646         prs_debug(ps, depth, desc, "net_io_r_sam_logoff");
1647         depth++;
1648
1649         if(!prs_align(ps))
1650                 return False;
1651
1652         if(!prs_uint32("buffer_creds", ps, depth, &r_l->buffer_creds)) /* undocumented buffer pointer */
1653                 return False;
1654         if(!smb_io_cred("", &r_l->srv_creds, ps, depth)) /* server credentials.  server time stamp appears to be ignored. */
1655                 return False;
1656
1657         if(!prs_ntstatus("status      ", ps, depth, &r_l->status))
1658                 return False;
1659
1660         return True;
1661 }
1662
1663 /*******************************************************************
1664 makes a NET_Q_SAM_SYNC structure.
1665 ********************************************************************/
1666 BOOL init_net_q_sam_sync(NET_Q_SAM_SYNC * q_s, const char *srv_name,
1667                          const char *cli_name, DOM_CRED *cli_creds,
1668                          DOM_CRED *ret_creds, uint32 database_id,
1669                          uint32 next_rid)
1670 {
1671         DEBUG(5, ("init_q_sam_sync\n"));
1672
1673         init_unistr2(&q_s->uni_srv_name, srv_name, strlen(srv_name) + 1);
1674         init_unistr2(&q_s->uni_cli_name, cli_name, strlen(cli_name) + 1);
1675
1676         if (cli_creds)
1677                 memcpy(&q_s->cli_creds, cli_creds, sizeof(q_s->cli_creds));
1678
1679         if (cli_creds)
1680                 memcpy(&q_s->ret_creds, ret_creds, sizeof(q_s->ret_creds));
1681         else
1682                 memset(&q_s->ret_creds, 0, sizeof(q_s->ret_creds));
1683
1684         q_s->database_id = database_id;
1685         q_s->restart_state = 0;
1686         q_s->sync_context = next_rid;
1687         q_s->max_size = 0xffff;
1688
1689         return True;
1690 }
1691
1692 /*******************************************************************
1693 reads or writes a structure.
1694 ********************************************************************/
1695 BOOL net_io_q_sam_sync(const char *desc, NET_Q_SAM_SYNC * q_s, prs_struct *ps,
1696                        int depth)
1697 {
1698         prs_debug(ps, depth, desc, "net_io_q_sam_sync");
1699         depth++;
1700
1701         if (!smb_io_unistr2("", &q_s->uni_srv_name, True, ps, depth))
1702                 return False;
1703         if (!smb_io_unistr2("", &q_s->uni_cli_name, True, ps, depth))
1704                 return False;
1705
1706         if (!smb_io_cred("", &q_s->cli_creds, ps, depth))
1707                 return False;
1708         if (!smb_io_cred("", &q_s->ret_creds, ps, depth))
1709                 return False;
1710
1711         if (!prs_uint32("database_id  ", ps, depth, &q_s->database_id))
1712                 return False;
1713         if (!prs_uint32("restart_state", ps, depth, &q_s->restart_state))
1714                 return False;
1715         if (!prs_uint32("sync_context ", ps, depth, &q_s->sync_context))
1716                 return False;
1717
1718         if (!prs_uint32("max_size", ps, depth, &q_s->max_size))
1719                 return False;
1720
1721         return True;
1722 }
1723
1724 /*******************************************************************
1725 reads or writes a structure.
1726 ********************************************************************/
1727 static BOOL net_io_sam_delta_hdr(const char *desc, SAM_DELTA_HDR * delta,
1728                                  prs_struct *ps, int depth)
1729 {
1730         prs_debug(ps, depth, desc, "net_io_sam_delta_hdr");
1731         depth++;
1732
1733         if (!prs_uint16("type", ps, depth, &delta->type))
1734                 return False;
1735         if (!prs_uint16("type2", ps, depth, &delta->type2))
1736                 return False;
1737         if (!prs_uint32("target_rid", ps, depth, &delta->target_rid))
1738                 return False;
1739
1740         if (!prs_uint32("type3", ps, depth, &delta->type3))
1741                 return False;
1742
1743         /* Not sure why we need this but it seems to be necessary to get
1744            sam deltas working. */
1745
1746         if (delta->type != 0x16) {
1747                 if (!prs_uint32("ptr_delta", ps, depth, &delta->ptr_delta))
1748                         return False;
1749         }
1750
1751         return True;
1752 }
1753
1754 /*******************************************************************
1755 reads or writes a structure.
1756 ********************************************************************/
1757 static BOOL net_io_sam_delta_mod_count(const char *desc, SAM_DELTA_MOD_COUNT *info,
1758                                    prs_struct *ps, int depth)
1759 {
1760         prs_debug(ps, depth, desc, "net_io_sam_delta_stamp");
1761         depth++;
1762
1763         if (!prs_uint32("seqnum", ps, depth, &info->seqnum))
1764                 return False;
1765         if (!prs_uint32("dom_mod_count_ptr", ps, depth,
1766                         &info->dom_mod_count_ptr))
1767                 return False;
1768
1769         if (info->dom_mod_count_ptr) {
1770                 if (!prs_uint64("dom_mod_count", ps, depth,
1771                                 &info->dom_mod_count))
1772                         return False;
1773         }
1774
1775         return True;
1776 }
1777
1778 /*******************************************************************
1779 reads or writes a structure.
1780 ********************************************************************/
1781 static BOOL net_io_sam_domain_info(const char *desc, SAM_DOMAIN_INFO * info,
1782                                    prs_struct *ps, int depth)
1783 {
1784         prs_debug(ps, depth, desc, "net_io_sam_domain_info");
1785         depth++;
1786
1787         if (!smb_io_unihdr("hdr_dom_name", &info->hdr_dom_name, ps, depth))
1788                 return False;
1789         if (!smb_io_unihdr("hdr_oem_info", &info->hdr_oem_info, ps, depth))
1790                 return False;
1791
1792         if (!prs_uint64("force_logoff", ps, depth, &info->force_logoff))
1793                 return False;
1794         if (!prs_uint16("min_pwd_len", ps, depth, &info->min_pwd_len))
1795                 return False;
1796         if (!prs_uint16("pwd_history_len", ps, depth, &info->pwd_history_len))
1797                 return False;
1798         if (!prs_uint64("max_pwd_age", ps, depth, &info->max_pwd_age))
1799                 return False;
1800         if (!prs_uint64("min_pwd_age", ps, depth, &info->min_pwd_age))
1801                 return False;
1802         if (!prs_uint64("dom_mod_count", ps, depth, &info->dom_mod_count))
1803                 return False;
1804         if (!smb_io_time("creation_time", &info->creation_time, ps, depth))
1805                 return False;
1806
1807         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
1808                 return False;
1809         if (!smb_io_unihdr("hdr_unknown", &info->hdr_unknown, ps, depth))
1810                 return False;
1811
1812         if (ps->data_offset + 40 > ps->buffer_size)
1813                 return False;
1814         ps->data_offset += 40;
1815
1816         if (!smb_io_unistr2("uni_dom_name", &info->uni_dom_name,
1817                             info->hdr_dom_name.buffer, ps, depth))
1818                 return False;
1819         if (!smb_io_unistr2("buf_oem_info", &info->buf_oem_info,
1820                             info->hdr_oem_info.buffer, ps, depth))
1821                 return False;
1822
1823         if (!smb_io_buffer4("buf_sec_desc", &info->buf_sec_desc,
1824                             info->hdr_sec_desc.buffer, ps, depth))
1825                 return False;
1826         if (!smb_io_unistr2("buf_unknown", &info->buf_unknown,
1827                             info->hdr_unknown.buffer, ps, depth))
1828                 return False;
1829
1830         return True;
1831 }
1832
1833 /*******************************************************************
1834 reads or writes a structure.
1835 ********************************************************************/
1836 static BOOL net_io_sam_group_info(const char *desc, SAM_GROUP_INFO * info,
1837                                   prs_struct *ps, int depth)
1838 {
1839         prs_debug(ps, depth, desc, "net_io_sam_group_info");
1840         depth++;
1841
1842         if (!smb_io_unihdr("hdr_grp_name", &info->hdr_grp_name, ps, depth))
1843                 return False;
1844         if (!smb_io_gid("gid", &info->gid, ps, depth))
1845                 return False;
1846         if (!smb_io_unihdr("hdr_grp_desc", &info->hdr_grp_desc, ps, depth))
1847                 return False;
1848         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
1849                 return False;
1850
1851         if (ps->data_offset + 48 > ps->buffer_size)
1852                 return False;
1853         ps->data_offset += 48;
1854
1855         if (!smb_io_unistr2("uni_grp_name", &info->uni_grp_name,
1856                             info->hdr_grp_name.buffer, ps, depth))
1857                 return False;
1858         if (!smb_io_unistr2("uni_grp_desc", &info->uni_grp_desc,
1859                             info->hdr_grp_desc.buffer, ps, depth))
1860                 return False;
1861         if (!smb_io_buffer4("buf_sec_desc", &info->buf_sec_desc,
1862                             info->hdr_sec_desc.buffer, ps, depth))
1863                 return False;
1864
1865         return True;
1866 }
1867
1868 /*******************************************************************
1869 reads or writes a structure.
1870 ********************************************************************/
1871 static BOOL net_io_sam_passwd_info(const char *desc, SAM_PWD * pwd,
1872                                    prs_struct *ps, int depth)
1873 {
1874         prs_debug(ps, depth, desc, "net_io_sam_passwd_info");
1875         depth++;
1876
1877         if (!prs_uint32("unk_0 ", ps, depth, &pwd->unk_0))
1878                 return False;
1879
1880         if (!smb_io_unihdr("hdr_lm_pwd", &pwd->hdr_lm_pwd, ps, depth))
1881                 return False;
1882         if (!prs_uint8s(False, "buf_lm_pwd", ps, depth, pwd->buf_lm_pwd, 16))
1883                 return False;
1884
1885         if (!smb_io_unihdr("hdr_nt_pwd", &pwd->hdr_nt_pwd, ps, depth))
1886                 return False;
1887         if (!prs_uint8s(False, "buf_nt_pwd", ps, depth, pwd->buf_nt_pwd, 16))
1888                 return False;
1889
1890         if (!smb_io_unihdr("", &pwd->hdr_empty_lm, ps, depth))
1891                 return False;
1892         if (!smb_io_unihdr("", &pwd->hdr_empty_nt, ps, depth))
1893                 return False;
1894
1895         return True;
1896 }
1897
1898 /*******************************************************************
1899 makes a SAM_ACCOUNT_INFO structure.
1900 ********************************************************************/
1901 BOOL make_sam_account_info(SAM_ACCOUNT_INFO * info,
1902                            const UNISTR2 *user_name,
1903                            const UNISTR2 *full_name,
1904                            uint32 user_rid, uint32 group_rid,
1905                            const UNISTR2 *home_dir,
1906                            const UNISTR2 *dir_drive,
1907                            const UNISTR2 *log_scr,
1908                            const UNISTR2 *desc,
1909                            uint32 acb_info,
1910                            const UNISTR2 *prof_path,
1911                            const UNISTR2 *wkstas,
1912                            const UNISTR2 *unk_str, const UNISTR2 *mung_dial)
1913 {
1914         int len_user_name = user_name != NULL ? user_name->uni_str_len : 0;
1915         int len_full_name = full_name != NULL ? full_name->uni_str_len : 0;
1916         int len_home_dir = home_dir != NULL ? home_dir->uni_str_len : 0;
1917         int len_dir_drive = dir_drive != NULL ? dir_drive->uni_str_len : 0;
1918         int len_logon_script = log_scr != NULL ? log_scr->uni_str_len : 0;
1919         int len_profile_path = prof_path != NULL ? prof_path->uni_str_len : 0;
1920         int len_description = desc != NULL ? desc->uni_str_len : 0;
1921         int len_workstations = wkstas != NULL ? wkstas->uni_str_len : 0;
1922         int len_unknown_str = unk_str != NULL ? unk_str->uni_str_len : 0;
1923         int len_munged_dial = mung_dial != NULL ? mung_dial->uni_str_len : 0;
1924
1925         DEBUG(5, ("make_sam_account_info\n"));
1926
1927         make_uni_hdr(&info->hdr_acct_name, len_user_name);
1928         make_uni_hdr(&info->hdr_full_name, len_full_name);
1929         make_uni_hdr(&info->hdr_home_dir, len_home_dir);
1930         make_uni_hdr(&info->hdr_dir_drive, len_dir_drive);
1931         make_uni_hdr(&info->hdr_logon_script, len_logon_script);
1932         make_uni_hdr(&info->hdr_profile, len_profile_path);
1933         make_uni_hdr(&info->hdr_acct_desc, len_description);
1934         make_uni_hdr(&info->hdr_workstations, len_workstations);
1935         make_uni_hdr(&info->hdr_comment, len_unknown_str);
1936         make_uni_hdr(&info->hdr_parameters, len_munged_dial);
1937
1938         /* not present */
1939         make_bufhdr2(&info->hdr_sec_desc, 0, 0, 0);
1940
1941         info->user_rid = user_rid;
1942         info->group_rid = group_rid;
1943
1944         init_nt_time(&info->logon_time);
1945         init_nt_time(&info->logoff_time);
1946         init_nt_time(&info->pwd_last_set_time);
1947         init_nt_time(&info->acct_expiry_time);
1948
1949         info->logon_divs = 0xA8;
1950         info->ptr_logon_hrs = 0;        /* Don't care right now */
1951
1952         info->bad_pwd_count = 0;
1953         info->logon_count = 0;
1954         info->acb_info = acb_info;
1955         info->nt_pwd_present = 0;
1956         info->lm_pwd_present = 0;
1957         info->pwd_expired = 0;
1958         info->country = 0;
1959         info->codepage = 0;
1960
1961         info->unknown1 = 0x4EC;
1962         info->unknown2 = 0;
1963
1964         copy_unistr2(&info->uni_acct_name, user_name);
1965         copy_unistr2(&info->uni_full_name, full_name);
1966         copy_unistr2(&info->uni_home_dir, home_dir);
1967         copy_unistr2(&info->uni_dir_drive, dir_drive);
1968         copy_unistr2(&info->uni_logon_script, log_scr);
1969         copy_unistr2(&info->uni_profile, prof_path);
1970         copy_unistr2(&info->uni_acct_desc, desc);
1971         copy_unistr2(&info->uni_workstations, wkstas);
1972         copy_unistr2(&info->uni_comment, unk_str);
1973         copy_unistr2(&info->uni_parameters, mung_dial);
1974
1975         return True;
1976 }
1977
1978 /*******************************************************************
1979 reads or writes a structure.
1980 ********************************************************************/
1981 static BOOL net_io_sam_account_info(const char *desc, uint8 sess_key[16],
1982                                     SAM_ACCOUNT_INFO * info, prs_struct *ps,
1983                                     int depth)
1984 {
1985         BUFHDR2 hdr_priv_data;
1986         uint32 i;
1987
1988         prs_debug(ps, depth, desc, "net_io_sam_account_info");
1989         depth++;
1990
1991         if (!smb_io_unihdr("hdr_acct_name", &info->hdr_acct_name, ps, depth))
1992                 return False;
1993         if (!smb_io_unihdr("hdr_full_name", &info->hdr_full_name, ps, depth))
1994                 return False;
1995
1996         if (!prs_uint32("user_rid ", ps, depth, &info->user_rid))
1997                 return False;
1998         if (!prs_uint32("group_rid", ps, depth, &info->group_rid))
1999                 return False;
2000
2001         if (!smb_io_unihdr("hdr_home_dir ", &info->hdr_home_dir, ps, depth))
2002                 return False;
2003         if (!smb_io_unihdr("hdr_dir_drive", &info->hdr_dir_drive, ps, depth))
2004                 return False;
2005         if (!smb_io_unihdr("hdr_logon_script", &info->hdr_logon_script, ps,
2006                            depth))
2007                 return False;
2008
2009         if (!smb_io_unihdr("hdr_acct_desc", &info->hdr_acct_desc, ps, depth))
2010                 return False;
2011         if (!smb_io_unihdr("hdr_workstations", &info->hdr_workstations, ps,
2012                            depth))
2013                 return False;
2014
2015         if (!smb_io_time("logon_time", &info->logon_time, ps, depth))
2016                 return False;
2017         if (!smb_io_time("logoff_time", &info->logoff_time, ps, depth))
2018                 return False;
2019
2020         if (!prs_uint32("logon_divs   ", ps, depth, &info->logon_divs))
2021                 return False;
2022         if (!prs_uint32("ptr_logon_hrs", ps, depth, &info->ptr_logon_hrs))
2023                 return False;
2024
2025         if (!prs_uint16("bad_pwd_count", ps, depth, &info->bad_pwd_count))
2026                 return False;
2027         if (!prs_uint16("logon_count", ps, depth, &info->logon_count))
2028                 return False;
2029         if (!smb_io_time("pwd_last_set_time", &info->pwd_last_set_time, ps,
2030                          depth))
2031                 return False;
2032         if (!smb_io_time("acct_expiry_time", &info->acct_expiry_time, ps,
2033                          depth))
2034                 return False;
2035
2036         if (!prs_uint32("acb_info", ps, depth, &info->acb_info))
2037                 return False;
2038         if (!prs_uint8s(False, "nt_pwd", ps, depth, info->nt_pwd, 16))
2039                 return False;
2040         if (!prs_uint8s(False, "lm_pwd", ps, depth, info->lm_pwd, 16))
2041                 return False;
2042         if (!prs_uint8("lm_pwd_present", ps, depth, &info->lm_pwd_present))
2043                 return False;
2044         if (!prs_uint8("nt_pwd_present", ps, depth, &info->nt_pwd_present))
2045                 return False;
2046         if (!prs_uint8("pwd_expired", ps, depth, &info->pwd_expired))
2047                 return False;
2048
2049         if (!smb_io_unihdr("hdr_comment", &info->hdr_comment, ps, depth))
2050                 return False;
2051         if (!smb_io_unihdr("hdr_parameters", &info->hdr_parameters, ps,
2052                            depth))
2053                 return False;
2054         if (!prs_uint16("country", ps, depth, &info->country))
2055                 return False;
2056         if (!prs_uint16("codepage", ps, depth, &info->codepage))
2057                 return False;
2058
2059         if (!smb_io_bufhdr2("hdr_priv_data", &hdr_priv_data, ps, depth))
2060                 return False;
2061         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2062                 return False;
2063         if (!smb_io_unihdr("hdr_profile", &info->hdr_profile, ps, depth))
2064                 return False;
2065
2066         for (i = 0; i < 3; i++)
2067         {
2068                 if (!smb_io_unihdr("hdr_reserved", &info->hdr_reserved[i],
2069                                    ps, depth))
2070                         return False;
2071         }
2072
2073         for (i = 0; i < 4; i++)
2074         {
2075                 if (!prs_uint32("dw_reserved", ps, depth,
2076                                 &info->dw_reserved[i]))
2077                         return False;
2078         }
2079
2080         if (!smb_io_unistr2("uni_acct_name", &info->uni_acct_name,
2081                             info->hdr_acct_name.buffer, ps, depth))
2082                 return False;
2083         prs_align(ps);
2084         if (!smb_io_unistr2("uni_full_name", &info->uni_full_name,
2085                             info->hdr_full_name.buffer, ps, depth))
2086                 return False;
2087         prs_align(ps);
2088         if (!smb_io_unistr2("uni_home_dir ", &info->uni_home_dir,
2089                             info->hdr_home_dir.buffer, ps, depth))
2090                 return False;
2091         prs_align(ps);
2092         if (!smb_io_unistr2("uni_dir_drive", &info->uni_dir_drive,
2093                             info->hdr_dir_drive.buffer, ps, depth))
2094                 return False;
2095         prs_align(ps);
2096         if (!smb_io_unistr2("uni_logon_script", &info->uni_logon_script,
2097                             info->hdr_logon_script.buffer, ps, depth))
2098                 return False;
2099         prs_align(ps);
2100         if (!smb_io_unistr2("uni_acct_desc", &info->uni_acct_desc,
2101                             info->hdr_acct_desc.buffer, ps, depth))
2102                 return False;
2103         prs_align(ps);
2104         if (!smb_io_unistr2("uni_workstations", &info->uni_workstations,
2105                             info->hdr_workstations.buffer, ps, depth))
2106                 return False;
2107         prs_align(ps);
2108
2109         if (!prs_uint32("unknown1", ps, depth, &info->unknown1))
2110                 return False;
2111         if (!prs_uint32("unknown2", ps, depth, &info->unknown2))
2112                 return False;
2113
2114         if (!smb_io_buffer4("buf_logon_hrs", &info->buf_logon_hrs,
2115                             info->ptr_logon_hrs, ps, depth))
2116                 return False;
2117         prs_align(ps);
2118         if (!smb_io_unistr2("uni_comment", &info->uni_comment,
2119                             info->hdr_comment.buffer, ps, depth))
2120                 return False;
2121         prs_align(ps);
2122         if (!smb_io_unistr2("uni_parameters", &info->uni_parameters,
2123                             info->hdr_parameters.buffer, ps, depth))
2124                 return False;
2125         prs_align(ps);
2126         if (hdr_priv_data.buffer != 0)
2127         {
2128                 int old_offset = 0;
2129                 uint32 len = 0x44;
2130                 if (!prs_uint32("pwd_len", ps, depth, &len))
2131                         return False;
2132                 old_offset = ps->data_offset;
2133                 if (len > 0)
2134                 {
2135                         if (ps->io)
2136                         {
2137                                 /* reading */
2138                                 if (!prs_hash1(ps, ps->data_offset, sess_key, len))
2139                                         return False;
2140                         }
2141                         if (!net_io_sam_passwd_info("pass", &info->pass,
2142                                                     ps, depth))
2143                                 return False;
2144
2145                         if (!ps->io)
2146                         {
2147                                 /* writing */
2148                                 if (!prs_hash1(ps, old_offset, sess_key, len))
2149                                         return False;
2150                         }
2151                 }
2152                 if (old_offset + len > ps->buffer_size)
2153                         return False;
2154                 ps->data_offset = old_offset + len;
2155         }
2156         if (!smb_io_buffer4("buf_sec_desc", &info->buf_sec_desc,
2157                             info->hdr_sec_desc.buffer, ps, depth))
2158                 return False;
2159         prs_align(ps);
2160         if (!smb_io_unistr2("uni_profile", &info->uni_profile,
2161                             info->hdr_profile.buffer, ps, depth))
2162                 return False;
2163
2164         prs_align(ps);
2165
2166         return True;
2167 }
2168
2169 /*******************************************************************
2170 reads or writes a structure.
2171 ********************************************************************/
2172 static BOOL net_io_sam_group_mem_info(const char *desc, SAM_GROUP_MEM_INFO * info,
2173                                       prs_struct *ps, int depth)
2174 {
2175         uint32 i;
2176         fstring tmp;
2177
2178         prs_debug(ps, depth, desc, "net_io_sam_group_mem_info");
2179         depth++;
2180
2181         prs_align(ps);
2182         if (!prs_uint32("ptr_rids   ", ps, depth, &info->ptr_rids))
2183                 return False;
2184         if (!prs_uint32("ptr_attribs", ps, depth, &info->ptr_attribs))
2185                 return False;
2186         if (!prs_uint32("num_members", ps, depth, &info->num_members))
2187                 return False;
2188
2189         if (ps->data_offset + 16 > ps->buffer_size)
2190                 return False;
2191         ps->data_offset += 16;
2192
2193         if (info->ptr_rids != 0)
2194         {
2195                 if (!prs_uint32("num_members2", ps, depth,
2196                                 &info->num_members2))
2197                         return False;
2198
2199                 if (info->num_members2 != info->num_members)
2200                 {
2201                         /* RPC fault */
2202                         return False;
2203                 }
2204
2205                 info->rids = talloc(ps->mem_ctx, sizeof(uint32) *
2206                                     info->num_members2);
2207
2208                 if (info->rids == NULL) {
2209                         DEBUG(0, ("out of memory allocating %d rids\n",
2210                                   info->num_members2));
2211                         return False;
2212                 }
2213
2214                 for (i = 0; i < info->num_members2; i++)
2215                 {
2216                         slprintf(tmp, sizeof(tmp) - 1, "rids[%02d]", i);
2217                         if (!prs_uint32(tmp, ps, depth, &info->rids[i]))
2218                                 return False;
2219                 }
2220         }
2221
2222         if (info->ptr_attribs != 0)
2223         {
2224                 if (!prs_uint32("num_members3", ps, depth,
2225                                 &info->num_members3))
2226                         return False;
2227                 if (info->num_members3 != info->num_members)
2228                 {
2229                         /* RPC fault */
2230                         return False;
2231                 }
2232
2233                 info->attribs = talloc(ps->mem_ctx, sizeof(uint32) *
2234                                        info->num_members3);
2235
2236                 if (info->attribs == NULL) {
2237                         DEBUG(0, ("out of memory allocating %d attribs\n",
2238                                   info->num_members3));
2239                         return False;
2240                 }
2241
2242                 for (i = 0; i < info->num_members3; i++)
2243                 {
2244                         slprintf(tmp, sizeof(tmp) - 1, "attribs[%02d]", i);
2245                         if (!prs_uint32(tmp, ps, depth, &info->attribs[i]))
2246                                 return False;
2247                 }
2248         }
2249
2250         return True;
2251 }
2252
2253 /*******************************************************************
2254 reads or writes a structure.
2255 ********************************************************************/
2256 static BOOL net_io_sam_alias_info(const char *desc, SAM_ALIAS_INFO * info,
2257                                   prs_struct *ps, int depth)
2258 {
2259         prs_debug(ps, depth, desc, "net_io_sam_alias_info");
2260         depth++;
2261
2262         if (!smb_io_unihdr("hdr_als_name", &info->hdr_als_name, ps, depth))
2263                 return False;
2264         if (!prs_uint32("als_rid", ps, depth, &info->als_rid))
2265                 return False;
2266         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2267                 return False;
2268         if (!smb_io_unihdr("hdr_als_desc", &info->hdr_als_desc, ps, depth))
2269                 return False;
2270
2271         if (ps->data_offset + 40 > ps->buffer_size)
2272                 return False;
2273         ps->data_offset += 40;
2274
2275         if (!smb_io_unistr2("uni_als_name", &info->uni_als_name,
2276                             info->hdr_als_name.buffer, ps, depth))
2277                 return False;
2278         if (!smb_io_buffer4("buf_sec_desc", &info->buf_sec_desc,
2279                             info->hdr_sec_desc.buffer, ps, depth))
2280                 return False;
2281
2282         if (info->hdr_als_desc.buffer != 0) {
2283                 if (!smb_io_unistr2("uni_als_desc", &info->uni_als_desc,
2284                                     info->hdr_als_name.buffer, ps, depth))
2285                         return False;
2286         }
2287
2288         return True;
2289 }
2290
2291 /*******************************************************************
2292 reads or writes a structure.
2293 ********************************************************************/
2294 static BOOL net_io_sam_alias_mem_info(const char *desc, SAM_ALIAS_MEM_INFO * info,
2295                                       prs_struct *ps, int depth)
2296 {
2297         uint32 i;
2298         fstring tmp;
2299
2300         prs_debug(ps, depth, desc, "net_io_sam_alias_mem_info");
2301         depth++;
2302
2303         prs_align(ps);
2304         if (!prs_uint32("num_members", ps, depth, &info->num_members))
2305                 return False;
2306         if (!prs_uint32("ptr_members", ps, depth, &info->ptr_members))
2307                 return False;
2308
2309         if (info->ptr_members != 0)
2310         {
2311                 if (ps->data_offset + 16 > ps->buffer_size)
2312                         return False;
2313                 ps->data_offset += 16;
2314
2315                 if (!prs_uint32("num_sids", ps, depth, &info->num_sids))
2316                         return False;
2317                 if (info->num_sids != info->num_members)
2318                 {
2319                         /* RPC fault */
2320                         return False;
2321                 }
2322
2323                 info->ptr_sids = talloc(ps->mem_ctx, sizeof(uint32) *
2324                                         info->num_sids);
2325
2326                 if (info->ptr_sids == NULL) {
2327                         DEBUG(0, ("out of memory allocating %d ptr_sids\n",
2328                                   info->num_sids));
2329                         return False;
2330                 }
2331
2332                 for (i = 0; i < info->num_sids; i++)
2333                 {
2334                         slprintf(tmp, sizeof(tmp) - 1, "ptr_sids[%02d]", i);
2335                         if (!prs_uint32(tmp, ps, depth, &info->ptr_sids[i]))
2336                                 return False;
2337                 }
2338
2339                 info->sids = talloc(ps->mem_ctx, sizeof(DOM_SID2) *
2340                                     info->num_sids);
2341
2342                 if (info->sids == NULL) {
2343                         DEBUG(0, ("error allocating %d sids\n",
2344                                   info->num_sids));
2345                         return False;
2346                 }
2347
2348                 for (i = 0; i < info->num_sids; i++)
2349                 {
2350                         if (info->ptr_sids[i] != 0)
2351                         {
2352                                 slprintf(tmp, sizeof(tmp) - 1, "sids[%02d]",
2353                                          i);
2354                                 if (!smb_io_dom_sid2(tmp, &info->sids[i],
2355                                                      ps, depth))
2356                                         return False;
2357                         }
2358                 }
2359         }
2360
2361         return True;
2362 }
2363
2364 /*******************************************************************
2365 reads or writes a structure.
2366 ********************************************************************/
2367 static BOOL net_io_sam_policy_info(const char *desc, SAM_DELTA_POLICY *info,
2368                                       prs_struct *ps, int depth)
2369 {
2370         unsigned int i;
2371         prs_debug(ps, depth, desc, "net_io_sam_policy_info");
2372         depth++;
2373
2374         if(!prs_align(ps))
2375                 return False;
2376
2377         if (!prs_uint32("max_log_size", ps, depth, &info->max_log_size))
2378                 return False;
2379         if (!prs_uint64("audit_retention_period", ps, depth,
2380                         &info->audit_retention_period))
2381                 return False;
2382         if (!prs_uint32("auditing_mode", ps, depth, &info->auditing_mode))
2383                 return False;
2384         if (!prs_uint32("num_events", ps, depth, &info->num_events))
2385                 return False;
2386         if (!prs_uint32("ptr_events", ps, depth, &info->ptr_events))
2387                 return False;
2388
2389         if (!smb_io_unihdr("hdr_dom_name", &info->hdr_dom_name, ps, depth))
2390                 return False;
2391
2392         if (!prs_uint32("sid_ptr", ps, depth, &info->sid_ptr))
2393                 return False;
2394
2395         if (!prs_uint32("paged_pool_limit", ps, depth, &info->paged_pool_limit))
2396                 return False;
2397         if (!prs_uint32("non_paged_pool_limit", ps, depth,
2398                         &info->non_paged_pool_limit))
2399                 return False;
2400         if (!prs_uint32("min_workset_size", ps, depth, &info->min_workset_size))
2401                 return False;
2402         if (!prs_uint32("max_workset_size", ps, depth, &info->max_workset_size))
2403                 return False;
2404         if (!prs_uint32("page_file_limit", ps, depth, &info->page_file_limit))
2405                 return False;
2406         if (!prs_uint64("time_limit", ps, depth, &info->time_limit))
2407                 return False;
2408         if (!smb_io_time("modify_time", &info->modify_time, ps, depth))
2409                 return False;
2410         if (!smb_io_time("create_time", &info->create_time, ps, depth))
2411                 return False;
2412         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2413                 return False;
2414
2415         for (i=0; i<4; i++) {
2416                 UNIHDR dummy;
2417                 if (!smb_io_unihdr("dummy", &dummy, ps, depth))
2418                         return False;
2419         }
2420
2421         for (i=0; i<4; i++) {
2422                 uint32 reserved;
2423                 if (!prs_uint32("reserved", ps, depth, &reserved))
2424                         return False;
2425         }
2426
2427         if (!prs_uint32("num_event_audit_options", ps, depth,
2428                         &info->num_event_audit_options))
2429                 return False;
2430
2431         for (i=0; i<info->num_event_audit_options; i++)
2432                 if (!prs_uint32("event_audit_option", ps, depth,
2433                                 &info->event_audit_option))
2434                         return False;
2435
2436         if (!smb_io_unistr2("domain_name", &info->domain_name, True, ps, depth))
2437                 return False;
2438
2439         if(!smb_io_dom_sid2("domain_sid", &info->domain_sid, ps, depth))
2440                 return False;
2441
2442         if (!smb_io_buffer4("buf_sec_desc", &info->buf_sec_desc,
2443                             info->hdr_sec_desc.buffer, ps, depth))
2444
2445                 return False;
2446
2447         return True;
2448 }
2449
2450 /*******************************************************************
2451 reads or writes a structure.
2452 ********************************************************************/
2453 static BOOL net_io_sam_trustdoms_info(const char *desc, SAM_DELTA_TRUSTDOMS *info,
2454                                       prs_struct *ps, int depth)
2455 {
2456         int i;
2457
2458         prs_debug(ps, depth, desc, "net_io_sam_trustdoms_info");
2459         depth++;
2460
2461         if(!prs_align(ps))
2462                 return False;
2463
2464         if(!prs_uint32("buf_size", ps, depth, &info->buf_size))
2465                 return False;
2466
2467         if(!sec_io_desc("sec_desc", &info->sec_desc, ps, depth))
2468                 return False;
2469
2470         if(!smb_io_dom_sid2("sid", &info->sid, ps, depth))
2471                 return False;
2472
2473         if(!smb_io_unihdr("hdr_domain", &info->hdr_domain, ps, depth))
2474                 return False;
2475
2476         if(!prs_uint32("unknown0", ps, depth, &info->unknown0))
2477                 return False;
2478         if(!prs_uint32("unknown1", ps, depth, &info->unknown1))
2479                 return False;
2480         if(!prs_uint32("unknown2", ps, depth, &info->unknown2))
2481                 return False;
2482
2483         if(!prs_uint32("buf_size2", ps, depth, &info->buf_size2))
2484                 return False;
2485         if(!prs_uint32("ptr", ps, depth, &info->ptr))
2486                 return False;
2487
2488         for (i=0; i<12; i++)
2489                 if(!prs_uint32("unknown3", ps, depth, &info->unknown3))
2490                         return False;
2491
2492         if (!smb_io_unistr2("domain", &info->domain, True, ps, depth))
2493                 return False;
2494
2495         return True;
2496 }
2497
2498 /*******************************************************************
2499 reads or writes a structure.
2500 ********************************************************************/
2501 static BOOL net_io_sam_secret_info(const char *desc, SAM_DELTA_SECRET *info,
2502                                    prs_struct *ps, int depth)
2503 {
2504         int i;
2505
2506         prs_debug(ps, depth, desc, "net_io_sam_secret_info");
2507         depth++;
2508
2509         if(!prs_align(ps))
2510                 return False;
2511
2512         if(!prs_uint32("buf_size", ps, depth, &info->buf_size))
2513                 return False;
2514
2515         if(!sec_io_desc("sec_desc", &info->sec_desc, ps, depth))
2516                 return False;
2517
2518         if (!smb_io_unistr2("secret", &info->secret, True, ps, depth))
2519                 return False;
2520
2521         if(!prs_align(ps))
2522                 return False;
2523
2524         if(!prs_uint32("count1", ps, depth, &info->count1))
2525                 return False;
2526         if(!prs_uint32("count2", ps, depth, &info->count2))
2527                 return False;
2528         if(!prs_uint32("ptr", ps, depth, &info->ptr))
2529                 return False;
2530
2531
2532         if(!smb_io_time("time1", &info->time1, ps, depth)) /* logon time */
2533                 return False;
2534         if(!prs_uint32("count3", ps, depth, &info->count3))
2535                 return False;
2536         if(!prs_uint32("count4", ps, depth, &info->count4))
2537                 return False;
2538         if(!prs_uint32("ptr2", ps, depth, &info->ptr2))
2539                 return False;
2540         if(!smb_io_time("time2", &info->time2, ps, depth)) /* logon time */
2541                 return False;
2542         if(!prs_uint32("unknow1", ps, depth, &info->unknow1))
2543                 return False;
2544
2545
2546         if(!prs_uint32("buf_size2", ps, depth, &info->buf_size2))
2547                 return False;
2548         if(!prs_uint32("ptr3", ps, depth, &info->ptr3))
2549                 return False;
2550         for(i=0; i<12; i++)
2551                 if(!prs_uint32("unknow2", ps, depth, &info->unknow2))
2552                         return False;
2553
2554         if(!prs_uint32("chal_len", ps, depth, &info->chal_len))
2555                 return False;
2556         if(!prs_uint32("reserved1", ps, depth, &info->reserved1))
2557                 return False;
2558         if(!prs_uint32("chal_len2", ps, depth, &info->chal_len2))
2559                 return False;
2560
2561         if(!prs_uint8s (False, "chal", ps, depth, info->chal, info->chal_len2))
2562                 return False;
2563
2564         if(!prs_uint32("key_len", ps, depth, &info->key_len))
2565                 return False;
2566         if(!prs_uint32("reserved2", ps, depth, &info->reserved2))
2567                 return False;
2568         if(!prs_uint32("key_len2", ps, depth, &info->key_len2))
2569                 return False;
2570
2571         if(!prs_uint8s (False, "key", ps, depth, info->key, info->key_len2))
2572                 return False;
2573
2574
2575         if(!prs_uint32("buf_size3", ps, depth, &info->buf_size3))
2576                 return False;
2577
2578         if(!sec_io_desc("sec_desc2", &info->sec_desc2, ps, depth))
2579                 return False;
2580
2581
2582         return True;
2583 }
2584
2585 /*******************************************************************
2586 reads or writes a structure.
2587 ********************************************************************/
2588 static BOOL net_io_sam_privs_info(const char *desc, SAM_DELTA_PRIVS *info,
2589                                       prs_struct *ps, int depth)
2590 {
2591         unsigned int i;
2592
2593         prs_debug(ps, depth, desc, "net_io_sam_privs_info");
2594         depth++;
2595
2596         if(!prs_align(ps))
2597                 return False;
2598
2599         if(!smb_io_dom_sid2("sid", &info->sid, ps, depth))
2600                 return False;
2601
2602         if(!prs_uint32("priv_count", ps, depth, &info->priv_count))
2603                 return False;
2604         if(!prs_uint32("priv_control", ps, depth, &info->priv_control))
2605                 return False;
2606
2607         if(!prs_uint32("priv_attr_ptr", ps, depth, &info->priv_attr_ptr))
2608                 return False;
2609         if(!prs_uint32("priv_name_ptr", ps, depth, &info->priv_name_ptr))
2610                 return False;
2611
2612         if (!prs_uint32("paged_pool_limit", ps, depth, &info->paged_pool_limit))
2613                 return False;
2614         if (!prs_uint32("non_paged_pool_limit", ps, depth,
2615                         &info->non_paged_pool_limit))
2616                 return False;
2617         if (!prs_uint32("min_workset_size", ps, depth, &info->min_workset_size))
2618                 return False;
2619         if (!prs_uint32("max_workset_size", ps, depth, &info->max_workset_size))
2620                 return False;
2621         if (!prs_uint32("page_file_limit", ps, depth, &info->page_file_limit))
2622                 return False;
2623         if (!prs_uint64("time_limit", ps, depth, &info->time_limit))
2624                 return False;
2625         if (!prs_uint32("system_flags", ps, depth, &info->system_flags))
2626                 return False;
2627         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2628                 return False;
2629
2630         for (i=0; i<4; i++) {
2631                 UNIHDR dummy;
2632                 if (!smb_io_unihdr("dummy", &dummy, ps, depth))
2633                         return False;
2634         }
2635
2636         for (i=0; i<4; i++) {
2637                 uint32 reserved;
2638                 if (!prs_uint32("reserved", ps, depth, &reserved))
2639                         return False;
2640         }
2641
2642         if(!prs_uint32("attribute_count", ps, depth, &info->attribute_count))
2643                 return False;
2644
2645         info->attributes = talloc(ps->mem_ctx, sizeof(uint32) * info->attribute_count);
2646
2647         for (i=0; i<info->attribute_count; i++)
2648                 if(!prs_uint32("attributes", ps, depth, &info->attributes[i]))
2649                         return False;
2650
2651         if(!prs_uint32("privlist_count", ps, depth, &info->privlist_count))
2652                 return False;
2653
2654         info->hdr_privslist = talloc(ps->mem_ctx, sizeof(UNIHDR) * info->privlist_count);
2655         info->uni_privslist = talloc(ps->mem_ctx, sizeof(UNISTR2) * info->privlist_count);
2656
2657         for (i=0; i<info->privlist_count; i++)
2658                 if(!smb_io_unihdr("hdr_privslist", &info->hdr_privslist[i], ps, depth))
2659                         return False;
2660
2661         for (i=0; i<info->privlist_count; i++)
2662                 if (!smb_io_unistr2("uni_privslist", &info->uni_privslist[i], True, ps, depth))
2663                         return False;
2664
2665         if (!smb_io_buffer4("buf_sec_desc", &info->buf_sec_desc,
2666                             info->hdr_sec_desc.buffer, ps, depth))
2667                 return False;
2668
2669         return True;
2670 }
2671
2672 /*******************************************************************
2673 reads or writes a structure.
2674 ********************************************************************/
2675 static BOOL net_io_sam_delta_ctr(const char *desc, uint8 sess_key[16],
2676                                  SAM_DELTA_CTR * delta, uint16 type,
2677                                  prs_struct *ps, int depth)
2678 {
2679         prs_debug(ps, depth, desc, "net_io_sam_delta_ctr");
2680         depth++;
2681
2682         switch (type) {
2683                 /* Seen in sam deltas */
2684                 case SAM_DELTA_MODIFIED_COUNT:
2685                         if (!net_io_sam_delta_mod_count("", &delta->mod_count, ps, depth))
2686                                 return False;
2687                         break;
2688
2689                 case SAM_DELTA_DOMAIN_INFO:
2690                         if (!net_io_sam_domain_info("", &delta->domain_info, ps, depth))
2691                                 return False;
2692                         break;
2693
2694                 case SAM_DELTA_GROUP_INFO:
2695                         if (!net_io_sam_group_info("", &delta->group_info, ps, depth))
2696                                 return False;
2697                         break;
2698
2699                 case SAM_DELTA_ACCOUNT_INFO:
2700                         if (!net_io_sam_account_info("", sess_key, &delta->account_info, ps, depth))
2701                                 return False;
2702                         break;
2703
2704                 case SAM_DELTA_GROUP_MEM:
2705                         if (!net_io_sam_group_mem_info("", &delta->grp_mem_info, ps, depth))
2706                                 return False;
2707                         break;
2708
2709                 case SAM_DELTA_ALIAS_INFO:
2710                         if (!net_io_sam_alias_info("", &delta->alias_info, ps, depth))
2711                                 return False;
2712                         break;
2713
2714                 case SAM_DELTA_POLICY_INFO:
2715                         if (!net_io_sam_policy_info("", &delta->policy_info, ps, depth))
2716                                 return False;
2717                         break;
2718
2719                 case SAM_DELTA_ALIAS_MEM:
2720                         if (!net_io_sam_alias_mem_info("", &delta->als_mem_info, ps, depth))
2721                                 return False;
2722                         break;
2723
2724                 case SAM_DELTA_PRIVS_INFO:
2725                         if (!net_io_sam_privs_info("", &delta->privs_info, ps, depth))
2726                                 return False;
2727                         break;
2728
2729                 case SAM_DELTA_TRUST_DOMS:
2730                         if (!net_io_sam_trustdoms_info("", &delta->trustdoms_info, ps, depth))
2731                                 return False;
2732                         break;
2733
2734                 case SAM_DELTA_SECRET_INFO:
2735                         if (!net_io_sam_secret_info("", &delta->secret_info, ps, depth))
2736                                 return False;
2737                         break;
2738
2739                         /* These guys are not implemented yet */
2740
2741                 case SAM_DELTA_RENAME_GROUP:
2742                 case SAM_DELTA_RENAME_USER:
2743                 case SAM_DELTA_RENAME_ALIAS:
2744                 case SAM_DELTA_DELETE_GROUP:
2745                 case SAM_DELTA_DELETE_USER:
2746                 default:
2747                         DEBUG(0, ("Replication error: Unknown delta type 0x%x\n", type));
2748                         break;
2749         }
2750
2751         return True;
2752 }
2753
2754 /*******************************************************************
2755 reads or writes a structure.
2756 ********************************************************************/
2757 BOOL net_io_r_sam_sync(const char *desc, uint8 sess_key[16],
2758                        NET_R_SAM_SYNC * r_s, prs_struct *ps, int depth)
2759 {
2760         uint32 i;
2761
2762         prs_debug(ps, depth, desc, "net_io_r_sam_sync");
2763         depth++;
2764
2765         if (!smb_io_cred("srv_creds", &r_s->srv_creds, ps, depth))
2766                 return False;
2767         if (!prs_uint32("sync_context", ps, depth, &r_s->sync_context))
2768                 return False;
2769
2770         if (!prs_uint32("ptr_deltas", ps, depth, &r_s->ptr_deltas))
2771                 return False;
2772         if (r_s->ptr_deltas != 0)
2773         {
2774                 if (!prs_uint32("num_deltas ", ps, depth, &r_s->num_deltas))
2775                         return False;
2776                 if (!prs_uint32("ptr_deltas2", ps, depth, &r_s->ptr_deltas2))
2777                         return False;
2778                 if (r_s->ptr_deltas2 != 0)
2779                 {
2780                         if (!prs_uint32("num_deltas2", ps, depth,
2781                                         &r_s->num_deltas2))
2782                                 return False;
2783
2784                         if (r_s->num_deltas2 != r_s->num_deltas)
2785                         {
2786                                 /* RPC fault */
2787                                 return False;
2788                         }
2789
2790                         if (r_s->num_deltas2 > 0) {
2791                                 r_s->hdr_deltas = (SAM_DELTA_HDR *)
2792                                         talloc(ps->mem_ctx, r_s->num_deltas2 *
2793                                                sizeof(SAM_DELTA_HDR));
2794
2795                                 if (r_s->hdr_deltas == NULL) {
2796                                         DEBUG(0, ("error tallocating memory "
2797                                                   "for %d delta headers\n",
2798                                                   r_s->num_deltas2));
2799                                         return False;
2800                                 }
2801                         }
2802
2803                         for (i = 0; i < r_s->num_deltas2; i++)
2804                         {
2805                                 if (!net_io_sam_delta_hdr("",
2806                                                           &r_s->hdr_deltas[i],
2807                                                           ps, depth))
2808                                         return False;
2809                         }
2810
2811                         if (r_s->num_deltas2 > 0) {
2812                                 r_s->deltas = (SAM_DELTA_CTR *)
2813                                         talloc(ps->mem_ctx, r_s->num_deltas2 *
2814                                                sizeof(SAM_DELTA_CTR));
2815
2816                                 if (r_s->deltas == NULL) {
2817                                         DEBUG(0, ("error tallocating memory "
2818                                                   "for %d deltas\n",
2819                                                   r_s->num_deltas2));
2820                                         return False;
2821                                 }
2822                         }
2823
2824                         for (i = 0; i < r_s->num_deltas2; i++)
2825                         {
2826                                 if (!net_io_sam_delta_ctr(
2827                                         "", sess_key, &r_s->deltas[i],
2828                                         r_s->hdr_deltas[i].type3,
2829                                         ps, depth)) {
2830                                         DEBUG(0, ("hmm, failed on i=%d\n", i));
2831                                         return False;
2832                                 }
2833                         }
2834                 }
2835         }
2836
2837         prs_align(ps);
2838         if (!prs_ntstatus("status", ps, depth, &(r_s->status)))
2839                 return False;
2840
2841         return True;
2842 }
2843
2844 /*******************************************************************
2845 makes a NET_Q_SAM_DELTAS structure.
2846 ********************************************************************/
2847 BOOL init_net_q_sam_deltas(NET_Q_SAM_DELTAS *q_s, const char *srv_name,
2848                            const char *cli_name, DOM_CRED *cli_creds,
2849                            uint32 database_id, UINT64_S dom_mod_count)
2850 {
2851         DEBUG(5, ("init_net_q_sam_deltas\n"));
2852
2853         init_unistr2(&q_s->uni_srv_name, srv_name, strlen(srv_name) + 1);
2854         init_unistr2(&q_s->uni_cli_name, cli_name, strlen(cli_name) + 1);
2855
2856         memcpy(&q_s->cli_creds, cli_creds, sizeof(q_s->cli_creds));
2857         memset(&q_s->ret_creds, 0, sizeof(q_s->ret_creds));
2858
2859         q_s->database_id = database_id;
2860         q_s->dom_mod_count.low = dom_mod_count.low;
2861         q_s->dom_mod_count.high = dom_mod_count.high;
2862         q_s->max_size = 0xffff;
2863
2864         return True;
2865 }
2866
2867 /*******************************************************************
2868 reads or writes a structure.
2869 ********************************************************************/
2870 BOOL net_io_q_sam_deltas(const char *desc, NET_Q_SAM_DELTAS *q_s, prs_struct *ps,
2871                          int depth)
2872 {
2873         prs_debug(ps, depth, desc, "net_io_q_sam_deltas");
2874         depth++;
2875
2876         if (!smb_io_unistr2("", &q_s->uni_srv_name, True, ps, depth))
2877                 return False;
2878         if (!smb_io_unistr2("", &q_s->uni_cli_name, True, ps, depth))
2879                 return False;
2880
2881         if (!smb_io_cred("", &q_s->cli_creds, ps, depth))
2882                 return False;
2883         if (!smb_io_cred("", &q_s->ret_creds, ps, depth))
2884                 return False;
2885
2886         if (!prs_uint32("database_id  ", ps, depth, &q_s->database_id))
2887                 return False;
2888         if (!prs_uint64("dom_mod_count", ps, depth, &q_s->dom_mod_count))
2889                 return False;
2890         if (!prs_uint32("max_size", ps, depth, &q_s->max_size))
2891                 return False;
2892
2893         return True;
2894 }
2895
2896 /*******************************************************************
2897 reads or writes a structure.
2898 ********************************************************************/
2899 BOOL net_io_r_sam_deltas(const char *desc, uint8 sess_key[16],
2900                          NET_R_SAM_DELTAS *r_s, prs_struct *ps, int depth)
2901 {
2902         unsigned int i;
2903
2904         prs_debug(ps, depth, desc, "net_io_r_sam_deltas");
2905         depth++;
2906
2907         if (!smb_io_cred("srv_creds", &r_s->srv_creds, ps, depth))
2908                 return False;
2909         if (!prs_uint64("dom_mod_count", ps, depth, &r_s->dom_mod_count))
2910                 return False;
2911
2912         if (!prs_uint32("ptr_deltas", ps, depth, &r_s->ptr_deltas))
2913                 return False;
2914         if (!prs_uint32("num_deltas", ps, depth, &r_s->num_deltas))
2915                 return False;
2916         if (!prs_uint32("ptr_deltas2", ps, depth, &r_s->num_deltas2))
2917                 return False;
2918
2919         if (r_s->num_deltas2 != 0)
2920         {
2921                 if (!prs_uint32("num_deltas2 ", ps, depth, &r_s->num_deltas2))
2922                         return False;
2923
2924                 if (r_s->ptr_deltas != 0)
2925                 {
2926                         if (r_s->num_deltas > 0) {
2927                                 r_s->hdr_deltas = (SAM_DELTA_HDR *)
2928                                         talloc(ps->mem_ctx, r_s->num_deltas *
2929                                                sizeof(SAM_DELTA_HDR));
2930                                 if (r_s->hdr_deltas == NULL) {
2931                                         DEBUG(0, ("error tallocating memory "
2932                                                   "for %d delta headers\n",
2933                                                   r_s->num_deltas));
2934                                         return False;
2935                                 }
2936                         }
2937
2938                         for (i = 0; i < r_s->num_deltas; i++)
2939                         {
2940                                 net_io_sam_delta_hdr("", &r_s->hdr_deltas[i],
2941                                                       ps, depth);
2942                         }
2943
2944                         if (r_s->num_deltas > 0) {
2945                                 r_s->deltas = (SAM_DELTA_CTR *)
2946                                         talloc(ps->mem_ctx, r_s->num_deltas *
2947                                                sizeof(SAM_DELTA_CTR));
2948
2949                                 if (r_s->deltas == NULL) {
2950                                         DEBUG(0, ("error tallocating memory "
2951                                                   "for %d deltas\n",
2952                                                   r_s->num_deltas));
2953                                         return False;
2954                                 }
2955                         }
2956
2957                         for (i = 0; i < r_s->num_deltas; i++)
2958                         {
2959                                 if (!net_io_sam_delta_ctr(
2960                                         "", sess_key,
2961                                         &r_s->deltas[i],
2962                                         r_s->hdr_deltas[i].type2,
2963                                         ps, depth))
2964
2965                                         return False;
2966                         }
2967                 }
2968         }
2969
2970         prs_align(ps);
2971         if (!prs_ntstatus("status", ps, depth, &r_s->status))
2972                 return False;
2973
2974         return True;
2975 }