source3/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         info->flags      = flags;
 140         info->pdc_status = pdc_status;
 141         info->ptr_trusted_dc_name = 1;
 142         info->tc_status  = tc_status;
 143
 144         if (trusted_dc_name != NULL)
 145                 init_unistr2(&info->uni_trusted_dc_name, trusted_dc_name, UNI_STR_TERMINATE);
 146         else
 147                 init_unistr2(&info->uni_trusted_dc_name, "", UNI_STR_TERMINATE);
 148 }
 149
 150 /*******************************************************************
 151  Reads or writes a NETLOGON_INFO_2 structure.
 152 ********************************************************************/
 153
 154 static BOOL net_io_netinfo_2(const char *desc, NETLOGON_INFO_2 *info, prs_struct *ps, int depth)
 155 {
 156         if (info == NULL)
 157                 return False;
 158
 159         prs_debug(ps, depth, desc, "net_io_netinfo_2");
 160         depth++;
 161
 162         if(!prs_align(ps))
 163                 return False;
 164
 165         if(!prs_uint32("flags              ", ps, depth, &info->flags))
 166                 return False;
 167         if(!prs_uint32("pdc_status         ", ps, depth, &info->pdc_status))
 168                 return False;
 169         if(!prs_uint32("ptr_trusted_dc_name", ps, depth, &info->ptr_trusted_dc_name))
 170                 return False;
 171         if(!prs_uint32("tc_status          ", ps, depth, &info->tc_status))
 172                 return False;
 173
 174         if (info->ptr_trusted_dc_name != 0) {
 175                 if(!smb_io_unistr2("unistr2", &info->uni_trusted_dc_name, info->ptr_trusted_dc_name, ps, depth))
 176                         return False;
 177         }
 178
 179         if(!prs_align(ps))
 180                 return False;
 181
 182         return True;
 183 }
 184
 185 static BOOL net_io_ctrl_data_info_5(const char *desc, CTRL_DATA_INFO_5 *info, prs_struct *ps, int depth)
 186 {
 187         if (info == NULL)
 188                 return False;
 189
 190         prs_debug(ps, depth, desc, "net_io_ctrl_data_info_5");
 191         depth++;
 192
 193         if ( !prs_uint32( "function_code", ps, depth, &info->function_code ) )
 194                 return False;
 195
 196         if(!prs_uint32("ptr_domain", ps, depth, &info->ptr_domain))
 197                 return False;
 198
 199         if ( info->ptr_domain ) {
 200                 if(!smb_io_unistr2("domain", &info->domain, info->ptr_domain, ps, depth))
 201                         return False;
 202         }
 203
 204         return True;
 205 }
 206
 207 static BOOL net_io_ctrl_data_info_6(const char *desc, CTRL_DATA_INFO_6 *info, prs_struct *ps, int depth)
 208 {
 209         if (info == NULL)
 210                 return False;
 211
 212         prs_debug(ps, depth, desc, "net_io_ctrl_data_info_6");
 213         depth++;
 214
 215         if ( !prs_uint32( "function_code", ps, depth, &info->function_code ) )
 216                 return False;
 217
 218         if(!prs_uint32("ptr_domain", ps, depth, &info->ptr_domain))
 219                 return False;
 220
 221         if ( info->ptr_domain ) {
 222                 if(!smb_io_unistr2("domain", &info->domain, info->ptr_domain, ps, depth))
 223                         return False;
 224         }
 225
 226         return True;
 227 }
 228
 229 /*******************************************************************
 230  Reads or writes an NET_Q_LOGON_CTRL2 structure.
 231 ********************************************************************/
 232
 233 BOOL net_io_q_logon_ctrl2(const char *desc, NET_Q_LOGON_CTRL2 *q_l, prs_struct *ps, int depth)
 234 {
 235         if (q_l == NULL)
 236                 return False;
 237
 238         prs_debug(ps, depth, desc, "net_io_q_logon_ctrl2");
 239         depth++;
 240
 241         if(!prs_align(ps))
 242                 return False;
 243
 244         if(!prs_uint32("ptr          ", ps, depth, &q_l->ptr))
 245                 return False;
 246
 247         if(!smb_io_unistr2 ("", &q_l->uni_server_name, q_l->ptr, ps, depth))
 248                 return False;
 249
 250         if(!prs_align(ps))
 251                 return False;
 252
 253         if(!prs_uint32("function_code", ps, depth, &q_l->function_code))
 254                 return False;
 255         if(!prs_uint32("query_level  ", ps, depth, &q_l->query_level))
 256                 return False;
 257         switch ( q_l->function_code ) {
 258                 case NETLOGON_CONTROL_REDISCOVER:
 259                         if ( !net_io_ctrl_data_info_5( "ctrl_data_info5", &q_l->info.info5, ps, depth) )
 260                                 return False;
 261                         break;
 262
 263                 case NETLOGON_CONTROL_TC_QUERY:
 264                         if ( !net_io_ctrl_data_info_6( "ctrl_data_info6", &q_l->info.info6, ps, depth) )
 265                                 return False;
 266                         break;
 267
 268                 default:
 269                         DEBUG(0,("net_io_q_logon_ctrl2: unknown function_code [%d]\n",
 270                                 q_l->function_code));
 271                         return False;
 272         }
 273
 274         return True;
 275 }
 276
 277 /*******************************************************************
 278  Inits an NET_Q_LOGON_CTRL2 structure.
 279 ********************************************************************/
 280
 281 void init_net_q_logon_ctrl2(NET_Q_LOGON_CTRL2 *q_l, const char *srv_name,
 282                             uint32 query_level)
 283 {
 284         DEBUG(5,("init_q_logon_ctrl2\n"));
 285
 286         q_l->function_code = 0x01;
 287         q_l->query_level = query_level;
 288
 289         init_unistr2(&q_l->uni_server_name, srv_name, UNI_STR_TERMINATE);
 290 }
 291
 292 /*******************************************************************
 293  Inits an NET_R_LOGON_CTRL2 structure.
 294 ********************************************************************/
 295
 296 void init_net_r_logon_ctrl2(NET_R_LOGON_CTRL2 *r_l, uint32 query_level,
 297                             uint32 flags, uint32 pdc_status,
 298                             uint32 logon_attempts, uint32 tc_status,
 299                             const char *trusted_domain_name)
 300 {
 301         r_l->switch_value  = query_level;
 302
 303         switch (query_level) {
 304         case 1:
 305                 r_l->ptr = 1; /* undocumented pointer */
 306                 init_netinfo_1(&r_l->logon.info1, flags, pdc_status);
 307                 r_l->status = NT_STATUS_OK;
 308                 break;
 309         case 2:
 310                 r_l->ptr = 1; /* undocumented pointer */
 311                 init_netinfo_2(&r_l->logon.info2, flags, pdc_status,
 312                                tc_status, trusted_domain_name);
 313                 r_l->status = NT_STATUS_OK;
 314                 break;
 315         case 3:
 316                 r_l->ptr = 1; /* undocumented pointer */
 317                 init_netinfo_3(&r_l->logon.info3, flags, logon_attempts);
 318                 r_l->status = NT_STATUS_OK;
 319                 break;
 320         default:
 321                 DEBUG(2,("init_r_logon_ctrl2: unsupported switch value %d\n",
 322                         r_l->switch_value));
 323                 r_l->ptr = 0; /* undocumented pointer */
 324
 325                 /* take a guess at an error code... */
 326                 r_l->status = NT_STATUS_INVALID_INFO_CLASS;
 327                 break;
 328         }
 329 }
 330
 331 /*******************************************************************
 332  Reads or writes an NET_R_LOGON_CTRL2 structure.
 333 ********************************************************************/
 334
 335 BOOL net_io_r_logon_ctrl2(const char *desc, NET_R_LOGON_CTRL2 *r_l, prs_struct *ps, int depth)
 336 {
 337         if (r_l == NULL)
 338                 return False;
 339
 340         prs_debug(ps, depth, desc, "net_io_r_logon_ctrl2");
 341         depth++;
 342
 343         if(!prs_uint32("switch_value ", ps, depth, &r_l->switch_value))
 344                 return False;
 345         if(!prs_uint32("ptr          ", ps, depth, &r_l->ptr))
 346                 return False;
 347
 348         if (r_l->ptr != 0) {
 349                 switch (r_l->switch_value) {
 350                 case 1:
 351                         if(!net_io_netinfo_1("", &r_l->logon.info1, ps, depth))
 352                                 return False;
 353                         break;
 354                 case 2:
 355                         if(!net_io_netinfo_2("", &r_l->logon.info2, ps, depth))
 356                                 return False;
 357                         break;
 358                 case 3:
 359                         if(!net_io_netinfo_3("", &r_l->logon.info3, ps, depth))
 360                                 return False;
 361                         break;
 362                 default:
 363                         DEBUG(2,("net_io_r_logon_ctrl2: unsupported switch value %d\n",
 364                                 r_l->switch_value));
 365                         break;
 366                 }
 367         }
 368
 369         if(!prs_ntstatus("status       ", ps, depth, &r_l->status))
 370                 return False;
 371
 372         return True;
 373 }
 374
 375 /*******************************************************************
 376  Reads or writes an NET_Q_LOGON_CTRL structure.
 377 ********************************************************************/
 378
 379 BOOL net_io_q_logon_ctrl(const char *desc, NET_Q_LOGON_CTRL *q_l, prs_struct *ps,
 380                          int depth)
 381 {
 382         prs_debug(ps, depth, desc, "net_io_q_logon_ctrl");
 383         depth++;
 384
 385         if(!prs_align(ps))
 386                 return False;
 387
 388         if(!prs_uint32("ptr          ", ps, depth, &q_l->ptr))
 389                 return False;
 390
 391         if(!smb_io_unistr2 ("", &q_l->uni_server_name, q_l->ptr, ps, depth))
 392                 return False;
 393
 394         if(!prs_align(ps))
 395                 return False;
 396
 397         if(!prs_uint32("function_code", ps, depth, &q_l->function_code))
 398                 return False;
 399         if(!prs_uint32("query_level  ", ps, depth, &q_l->query_level))
 400                 return False;
 401
 402         return True;
 403 }
 404
 405 /*******************************************************************
 406  Inits an NET_Q_LOGON_CTRL structure.
 407 ********************************************************************/
 408
 409 void init_net_q_logon_ctrl(NET_Q_LOGON_CTRL *q_l, const char *srv_name,
 410                            uint32 query_level)
 411 {
 412         DEBUG(5,("init_q_logon_ctrl\n"));
 413
 414         q_l->function_code = 0x01; /* ??? */
 415         q_l->query_level = query_level;
 416
 417         init_unistr2(&q_l->uni_server_name, srv_name, UNI_STR_TERMINATE);
 418 }
 419
 420 /*******************************************************************
 421  Inits an NET_R_LOGON_CTRL structure.
 422 ********************************************************************/
 423
 424 void init_net_r_logon_ctrl(NET_R_LOGON_CTRL *r_l, uint32 query_level,
 425                            uint32 flags, uint32 pdc_status)
 426 {
 427         DEBUG(5,("init_r_logon_ctrl\n"));
 428
 429         r_l->switch_value  = query_level; /* should only be 0x1 */
 430
 431         switch (query_level) {
 432         case 1:
 433                 r_l->ptr = 1; /* undocumented pointer */
 434                 init_netinfo_1(&r_l->logon.info1, flags, pdc_status);
 435                 r_l->status = NT_STATUS_OK;
 436                 break;
 437         default:
 438                 DEBUG(2,("init_r_logon_ctrl: unsupported switch value %d\n",
 439                         r_l->switch_value));
 440                 r_l->ptr = 0; /* undocumented pointer */
 441
 442                 /* take a guess at an error code... */
 443                 r_l->status = NT_STATUS_INVALID_INFO_CLASS;
 444                 break;
 445         }
 446 }
 447
 448 /*******************************************************************
 449  Reads or writes an NET_R_LOGON_CTRL structure.
 450 ********************************************************************/
 451
 452 BOOL net_io_r_logon_ctrl(const char *desc, NET_R_LOGON_CTRL *r_l, prs_struct *ps,
 453                          int depth)
 454 {
 455         prs_debug(ps, depth, desc, "net_io_r_logon_ctrl");
 456         depth++;
 457
 458         if(!prs_uint32("switch_value ", ps, depth, &r_l->switch_value))
 459                 return False;
 460         if(!prs_uint32("ptr          ", ps, depth, &r_l->ptr))
 461                 return False;
 462
 463         if (r_l->ptr != 0) {
 464                 switch (r_l->switch_value) {
 465                 case 1:
 466                         if(!net_io_netinfo_1("", &r_l->logon.info1, ps, depth))
 467                                 return False;
 468                         break;
 469                 default:
 470                         DEBUG(2,("net_io_r_logon_ctrl: unsupported switch value %d\n",
 471                                 r_l->switch_value));
 472                         break;
 473                 }
 474         }
 475
 476         if(!prs_ntstatus("status       ", ps, depth, &r_l->status))
 477                 return False;
 478
 479         return True;
 480 }
 481
 482 /*******************************************************************
 483  Inits an NET_R_GETDCNAME structure.
 484 ********************************************************************/
 485 void init_net_q_getdcname(NET_Q_GETDCNAME *r_t, const char *logon_server,
 486                           const char *domainname)
 487 {
 488         DEBUG(5,("init_r_getdcname\n"));
 489
 490         r_t->ptr_logon_server = (logon_server != NULL);
 491         init_unistr2(&r_t->uni_logon_server, logon_server, UNI_STR_TERMINATE);
 492         r_t->ptr_domainname = (domainname != NULL);
 493         init_unistr2(&r_t->uni_domainname, domainname, UNI_STR_TERMINATE);
 494 }
 495
 496 /*******************************************************************
 497  Reads or writes an NET_Q_GETDCNAME structure.
 498 ********************************************************************/
 499
 500 BOOL net_io_q_getdcname(const char *desc, NET_Q_GETDCNAME *r_t, prs_struct *ps,
 501                         int depth)
 502 {
 503         if (r_t == NULL)
 504                 return False;
 505
 506         prs_debug(ps, depth, desc, "net_io_q_getdcname");
 507         depth++;
 508
 509         if (!prs_uint32("ptr_logon_server", ps, depth, &r_t->ptr_logon_server))
 510                 return False;
 511
 512         if (!smb_io_unistr2("logon_server", &r_t->uni_logon_server,
 513                             r_t->ptr_logon_server, ps, depth))
 514                 return False;
 515
 516         if (!prs_align(ps))
 517                 return False;
 518
 519         if (!prs_uint32("ptr_domainname", ps, depth, &r_t->ptr_domainname))
 520                 return False;
 521
 522         if (!smb_io_unistr2("domainname", &r_t->uni_domainname,
 523                             r_t->ptr_domainname, ps, depth))
 524                 return False;
 525
 526         return True;
 527 }
 528
 529
 530 /*******************************************************************
 531  Inits an NET_R_GETDCNAME structure.
 532 ********************************************************************/
 533 void init_net_r_getdcname(NET_R_GETDCNAME *r_t, const char *dcname)
 534 {
 535         DEBUG(5,("init_r_getdcname\n"));
 536
 537         init_unistr2(&r_t->uni_dcname, dcname, UNI_STR_TERMINATE);
 538 }
 539
 540 /*******************************************************************
 541  Reads or writes an NET_R_GETDCNAME structure.
 542 ********************************************************************/
 543
 544 BOOL net_io_r_getdcname(const char *desc, NET_R_GETDCNAME *r_t, prs_struct *ps,
 545                         int depth)
 546 {
 547         if (r_t == NULL)
 548                 return False;
 549
 550         prs_debug(ps, depth, desc, "net_io_r_getdcname");
 551         depth++;
 552
 553         if (!prs_uint32("ptr_dcname", ps, depth, &r_t->ptr_dcname))
 554                 return False;
 555
 556         if (!smb_io_unistr2("dcname", &r_t->uni_dcname,
 557                             r_t->ptr_dcname, ps, depth))
 558                 return False;
 559
 560         if (!prs_align(ps))
 561                 return False;
 562
 563         if (!prs_ntstatus("status", ps, depth, &r_t->status))
 564                 return False;
 565
 566         return True;
 567 }
 568
 569 /*******************************************************************
 570  Inits an NET_R_TRUST_DOM_LIST structure.
 571 ********************************************************************/
 572
 573 void init_r_trust_dom(NET_R_TRUST_DOM_LIST *r_t,
 574                         uint32 num_doms, const char *dom_name)
 575 {
 576         unsigned int i = 0;
 577
 578         DEBUG(5,("init_r_trust_dom\n"));
 579
 580         for (i = 0; i < MAX_TRUST_DOMS; i++) {
 581                 r_t->uni_trust_dom_name[i].uni_str_len = 0;
 582                 r_t->uni_trust_dom_name[i].uni_max_len = 0;
 583         }
 584         if (num_doms > MAX_TRUST_DOMS)
 585                 num_doms = MAX_TRUST_DOMS;
 586
 587         for (i = 0; i < num_doms; i++) {
 588                 fstring domain_name;
 589                 fstrcpy(domain_name, dom_name);
 590                 strupper_m(domain_name);
 591                 init_unistr2(&r_t->uni_trust_dom_name[i], domain_name, UNI_STR_TERMINATE);
 592                 /* the use of UNISTR2 here is non-standard. */
 593                 r_t->uni_trust_dom_name[i].offset = 0x1;
 594         }
 595
 596         r_t->status = NT_STATUS_OK;
 597 }
 598
 599 /*******************************************************************
 600  Reads or writes an NET_R_TRUST_DOM_LIST structure.
 601 ********************************************************************/
 602
 603 BOOL net_io_r_trust_dom(const char *desc, NET_R_TRUST_DOM_LIST *r_t, prs_struct *ps, int depth)
 604 {
 605         uint32 value;
 606
 607         if (r_t == NULL)
 608                  return False;
 609
 610         prs_debug(ps, depth, desc, "net_io_r_trust_dom");
 611         depth++;
 612
 613         /* temporary code to give a valid response */
 614         value=2;
 615         if(!prs_uint32("status", ps, depth, &value))
 616                  return False;
 617
 618         value=1;
 619         if(!prs_uint32("status", ps, depth, &value))
 620                  return False;
 621         value=2;
 622         if(!prs_uint32("status", ps, depth, &value))
 623                  return False;
 624
 625         value=0;
 626         if(!prs_uint32("status", ps, depth, &value))
 627                  return False;
 628
 629         value=0;
 630         if(!prs_uint32("status", ps, depth, &value))
 631                  return False;
 632
 633 /* old non working code */
 634 #if 0
 635         int i;
 636
 637         for (i = 0; i < MAX_TRUST_DOMS; i++) {
 638                 if (r_t->uni_trust_dom_name[i].uni_str_len == 0)
 639                         break;
 640                 if(!smb_io_unistr2("", &r_t->uni_trust_dom_name[i], True, ps, depth))
 641                          return False;
 642         }
 643
 644         if(!prs_ntstatus("status", ps, depth, &r_t->status))
 645                  return False;
 646 #endif
 647         return True;
 648 }
 649
 650
 651 /*******************************************************************
 652  Reads or writes an NET_Q_TRUST_DOM_LIST structure.
 653 ********************************************************************/
 654
 655 BOOL net_io_q_trust_dom(const char *desc, NET_Q_TRUST_DOM_LIST *q_l, prs_struct *ps, int depth)
 656 {
 657         if (q_l == NULL)
 658                  return False;
 659
 660         prs_debug(ps, depth, desc, "net_io_q_trust_dom");
 661         depth++;
 662
 663         if(!prs_uint32("ptr          ", ps, depth, &q_l->ptr))
 664                  return False;
 665         if(!smb_io_unistr2 ("", &q_l->uni_server_name, q_l->ptr, ps, depth))
 666                  return False;
 667
 668         return True;
 669 }
 670
 671 /*******************************************************************
 672  Inits an NET_Q_REQ_CHAL structure.
 673 ********************************************************************/
 674
 675 void init_q_req_chal(NET_Q_REQ_CHAL *q_c,
 676                      const char *logon_srv, const char *logon_clnt,
 677                      const DOM_CHAL *clnt_chal)
 678 {
 679         DEBUG(5,("init_q_req_chal: %d\n", __LINE__));
 680
 681         q_c->undoc_buffer = 1; /* don't know what this buffer is */
 682
 683         init_unistr2(&q_c->uni_logon_srv, logon_srv , UNI_STR_TERMINATE);
 684         init_unistr2(&q_c->uni_logon_clnt, logon_clnt, UNI_STR_TERMINATE);
 685
 686         memcpy(q_c->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
 687
 688         DEBUG(5,("init_q_req_chal: %d\n", __LINE__));
 689 }
 690
 691 /*******************************************************************
 692  Reads or writes an NET_Q_REQ_CHAL structure.
 693 ********************************************************************/
 694
 695 BOOL net_io_q_req_chal(const char *desc,  NET_Q_REQ_CHAL *q_c, prs_struct *ps, int depth)
 696 {
 697         if (q_c == NULL)
 698                 return False;
 699
 700         prs_debug(ps, depth, desc, "net_io_q_req_chal");
 701         depth++;
 702
 703         if(!prs_align(ps))
 704                 return False;
 705
 706         if(!prs_uint32("undoc_buffer", ps, depth, &q_c->undoc_buffer))
 707                 return False;
 708
 709         if(!smb_io_unistr2("", &q_c->uni_logon_srv, True, ps, depth)) /* logon server unicode string */
 710                 return False;
 711         if(!smb_io_unistr2("", &q_c->uni_logon_clnt, True, ps, depth)) /* logon client unicode string */
 712                 return False;
 713
 714         if(!smb_io_chal("", &q_c->clnt_chal, ps, depth))
 715                 return False;
 716
 717         return True;
 718 }
 719
 720 /*******************************************************************
 721  Reads or writes a structure.
 722 ********************************************************************/
 723
 724 BOOL net_io_r_req_chal(const char *desc, NET_R_REQ_CHAL *r_c, prs_struct *ps, int depth)
 725 {
 726         if (r_c == NULL)
 727                 return False;
 728
 729         prs_debug(ps, depth, desc, "net_io_r_req_chal");
 730         depth++;
 731
 732         if(!prs_align(ps))
 733                 return False;
 734
 735         if(!smb_io_chal("", &r_c->srv_chal, ps, depth)) /* server challenge */
 736                 return False;
 737
 738         if(!prs_ntstatus("status", ps, depth, &r_c->status))
 739                 return False;
 740
 741         return True;
 742 }
 743
 744
 745 /*******************************************************************
 746  Reads or writes a structure.
 747 ********************************************************************/
 748
 749 BOOL net_io_q_auth(const char *desc, NET_Q_AUTH *q_a, prs_struct *ps, int depth)
 750 {
 751         if (q_a == NULL)
 752                 return False;
 753
 754         prs_debug(ps, depth, desc, "net_io_q_auth");
 755         depth++;
 756
 757         if(!prs_align(ps))
 758                 return False;
 759
 760         if(!smb_io_log_info ("", &q_a->clnt_id, ps, depth)) /* client identification info */
 761                 return False;
 762         if(!smb_io_chal("", &q_a->clnt_chal, ps, depth))
 763                 return False;
 764
 765         return True;
 766 }
 767
 768 /*******************************************************************
 769  Reads or writes a structure.
 770 ********************************************************************/
 771
 772 BOOL net_io_r_auth(const char *desc, NET_R_AUTH *r_a, prs_struct *ps, int depth)
 773 {
 774         if (r_a == NULL)
 775                 return False;
 776
 777         prs_debug(ps, depth, desc, "net_io_r_auth");
 778         depth++;
 779
 780         if(!prs_align(ps))
 781                 return False;
 782
 783         if(!smb_io_chal("", &r_a->srv_chal, ps, depth)) /* server challenge */
 784                 return False;
 785
 786         if(!prs_ntstatus("status", ps, depth, &r_a->status))
 787                 return False;
 788
 789         return True;
 790 }
 791
 792 /*******************************************************************
 793  Inits a NET_Q_AUTH_2 struct.
 794 ********************************************************************/
 795
 796 void init_q_auth_2(NET_Q_AUTH_2 *q_a,
 797                 const char *logon_srv, const char *acct_name, uint16 sec_chan, const char *comp_name,
 798                 const DOM_CHAL *clnt_chal, uint32 clnt_flgs)
 799 {
 800         DEBUG(5,("init_q_auth_2: %d\n", __LINE__));
 801
 802         init_log_info(&q_a->clnt_id, logon_srv, acct_name, sec_chan, comp_name);
 803         memcpy(q_a->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
 804         q_a->clnt_flgs.neg_flags = clnt_flgs;
 805
 806         DEBUG(5,("init_q_auth_2: %d\n", __LINE__));
 807 }
 808
 809 /*******************************************************************
 810  Reads or writes a structure.
 811 ********************************************************************/
 812
 813 BOOL net_io_q_auth_2(const char *desc, NET_Q_AUTH_2 *q_a, prs_struct *ps, int depth)
 814 {
 815         if (q_a == NULL)
 816                 return False;
 817
 818         prs_debug(ps, depth, desc, "net_io_q_auth_2");
 819         depth++;
 820
 821         if(!prs_align(ps))
 822                 return False;
 823
 824         if(!smb_io_log_info ("", &q_a->clnt_id, ps, depth)) /* client identification info */
 825                 return False;
 826         if(!smb_io_chal("", &q_a->clnt_chal, ps, depth))
 827                 return False;
 828         if(!net_io_neg_flags("", &q_a->clnt_flgs, ps, depth))
 829                 return False;
 830
 831         return True;
 832 }
 833
 834 /*******************************************************************
 835  Reads or writes a structure.
 836 ********************************************************************/
 837
 838 BOOL net_io_r_auth_2(const char *desc, NET_R_AUTH_2 *r_a, prs_struct *ps, int depth)
 839 {
 840         if (r_a == NULL)
 841                 return False;
 842
 843         prs_debug(ps, depth, desc, "net_io_r_auth_2");
 844         depth++;
 845
 846         if(!prs_align(ps))
 847                 return False;
 848
 849         if(!smb_io_chal("", &r_a->srv_chal, ps, depth)) /* server challenge */
 850                 return False;
 851         if(!net_io_neg_flags("", &r_a->srv_flgs, ps, depth))
 852                 return False;
 853
 854         if(!prs_ntstatus("status", ps, depth, &r_a->status))
 855                 return False;
 856
 857         return True;
 858 }
 859
 860 /*******************************************************************
 861  Inits a NET_Q_AUTH_3 struct.
 862 ********************************************************************/
 863
 864 void init_q_auth_3(NET_Q_AUTH_3 *q_a,
 865                 const char *logon_srv, const char *acct_name, uint16 sec_chan, const char *comp_name,
 866                 const DOM_CHAL *clnt_chal, uint32 clnt_flgs)
 867 {
 868         DEBUG(5,("init_q_auth_3: %d\n", __LINE__));
 869
 870         init_log_info(&q_a->clnt_id, logon_srv, acct_name, sec_chan, comp_name);
 871         memcpy(q_a->clnt_chal.data, clnt_chal->data, sizeof(clnt_chal->data));
 872         q_a->clnt_flgs.neg_flags = clnt_flgs;
 873
 874         DEBUG(5,("init_q_auth_3: %d\n", __LINE__));
 875 }
 876
 877 /*******************************************************************
 878  Reads or writes a structure.
 879 ********************************************************************/
 880
 881 BOOL net_io_q_auth_3(const char *desc, NET_Q_AUTH_3 *q_a, prs_struct *ps, int depth)
 882 {
 883         if (q_a == NULL)
 884                 return False;
 885
 886         prs_debug(ps, depth, desc, "net_io_q_auth_3");
 887         depth++;
 888
 889         if(!prs_align(ps))
 890                 return False;
 891
 892         if(!smb_io_log_info ("", &q_a->clnt_id, ps, depth)) /* client identification info */
 893                 return False;
 894         if(!smb_io_chal("", &q_a->clnt_chal, ps, depth))
 895                 return False;
 896         if(!net_io_neg_flags("", &q_a->clnt_flgs, ps, depth))
 897                 return False;
 898
 899         return True;
 900 }
 901
 902 /*******************************************************************
 903  Reads or writes a structure.
 904 ********************************************************************/
 905
 906 BOOL net_io_r_auth_3(const char *desc, NET_R_AUTH_3 *r_a, prs_struct *ps, int depth)
 907 {
 908         if (r_a == NULL)
 909                 return False;
 910
 911         prs_debug(ps, depth, desc, "net_io_r_auth_3");
 912         depth++;
 913
 914         if(!prs_align(ps))
 915                 return False;
 916
 917         if(!smb_io_chal("srv_chal", &r_a->srv_chal, ps, depth)) /* server challenge */
 918                 return False;
 919         if(!net_io_neg_flags("srv_flgs", &r_a->srv_flgs, ps, depth))
 920                 return False;
 921         if (!prs_uint32("unknown", ps, depth, &r_a->unknown))
 922                 return False;
 923
 924         if(!prs_ntstatus("status", ps, depth, &r_a->status))
 925                 return False;
 926
 927         return True;
 928 }
 929
 930
 931 /*******************************************************************
 932  Inits a NET_Q_SRV_PWSET.
 933 ********************************************************************/
 934
 935 void init_q_srv_pwset(NET_Q_SRV_PWSET *q_s,
 936                 const char *logon_srv, const char *sess_key, const char *acct_name,
 937                 uint16 sec_chan, const char *comp_name,
 938                 DOM_CRED *cred, const uchar hashed_mach_pwd[16])
 939 {
 940         unsigned char nt_cypher[16];
 941
 942         DEBUG(5,("init_q_srv_pwset\n"));
 943
 944         /* Process the new password. */
 945         cred_hash3( nt_cypher, hashed_mach_pwd, (const unsigned char *)sess_key, 1);
 946
 947         init_clnt_info(&q_s->clnt_id, logon_srv, acct_name, sec_chan, comp_name, cred);
 948
 949         memcpy(q_s->pwd, nt_cypher, sizeof(q_s->pwd));
 950 }
 951
 952 /*******************************************************************
 953  Reads or writes a structure.
 954 ********************************************************************/
 955
 956 BOOL net_io_q_srv_pwset(const char *desc, NET_Q_SRV_PWSET *q_s, prs_struct *ps, int depth)
 957 {
 958         if (q_s == NULL)
 959                 return False;
 960
 961         prs_debug(ps, depth, desc, "net_io_q_srv_pwset");
 962         depth++;
 963
 964         if(!prs_align(ps))
 965                 return False;
 966
 967         if(!smb_io_clnt_info("", &q_s->clnt_id, ps, depth)) /* client identification/authentication info */
 968                 return False;
 969         if(!prs_uint8s (False, "pwd", ps, depth, q_s->pwd, 16)) /* new password - undocumented */
 970                 return False;
 971
 972         return True;
 973 }
 974
 975 /*******************************************************************
 976  Reads or writes a structure.
 977 ********************************************************************/
 978
 979 BOOL net_io_r_srv_pwset(const char *desc, NET_R_SRV_PWSET *r_s, prs_struct *ps, int depth)
 980 {
 981         if (r_s == NULL)
 982                 return False;
 983
 984         prs_debug(ps, depth, desc, "net_io_r_srv_pwset");
 985         depth++;
 986
 987         if(!prs_align(ps))
 988                 return False;
 989
 990         if(!smb_io_cred("", &r_s->srv_cred, ps, depth)) /* server challenge */
 991                 return False;
 992
 993         if(!prs_ntstatus("status", ps, depth, &r_s->status))
 994                 return False;
 995
 996         return True;
 997 }
 998
 999 /*************************************************************************
1000  Init DOM_SID2 array from a string containing multiple sids
1001  *************************************************************************/
1002
1003 static int init_dom_sid2s(TALLOC_CTX *ctx, const char *sids_str, DOM_SID2 **ppsids)
1004 {
1005         const char *ptr;
1006         pstring s2;
1007         int count = 0;
1008
1009         DEBUG(4,("init_dom_sid2s: %s\n", sids_str ? sids_str:""));
1010
1011         *ppsids = NULL;
1012
1013         if(sids_str) {
1014                 int number;
1015                 DOM_SID2 *sids;
1016
1017                 /* Count the number of valid SIDs. */
1018                 for (count = 0, ptr = sids_str; next_token(&ptr, s2, NULL, sizeof(s2)); ) {
1019                         DOM_SID tmpsid;
1020                         if (string_to_sid(&tmpsid, s2))
1021                                 count++;
1022                 }
1023
1024                 /* Now allocate space for them. */
1025                 *ppsids = TALLOC_ZERO_ARRAY(ctx, DOM_SID2, count);
1026                 if (*ppsids == NULL)
1027                         return 0;
1028
1029                 sids = *ppsids;
1030
1031                 for (number = 0, ptr = sids_str; next_token(&ptr, s2, NULL, sizeof(s2)); ) {
1032                         DOM_SID tmpsid;
1033                         if (string_to_sid(&tmpsid, s2)) {
1034                                 /* count only valid sids */
1035                                 init_dom_sid2(&sids[number], &tmpsid);
1036                                 number++;
1037                         }
1038                 }
1039         }
1040
1041         return count;
1042 }
1043
1044 /*******************************************************************
1045  Inits a NET_ID_INFO_1 structure.
1046 ********************************************************************/
1047
1048 void init_id_info1(NET_ID_INFO_1 *id, const char *domain_name,
1049                                 uint32 param_ctrl, uint32 log_id_low, uint32 log_id_high,
1050                                 const char *user_name, const char *wksta_name,
1051                                 const char *sess_key,
1052                                 unsigned char lm_cypher[16], unsigned char nt_cypher[16])
1053 {
1054         unsigned char lm_owf[16];
1055         unsigned char nt_owf[16];
1056
1057         DEBUG(5,("init_id_info1: %d\n", __LINE__));
1058
1059         id->ptr_id_info1 = 1;
1060
1061         id->param_ctrl = param_ctrl;
1062         init_logon_id(&id->logon_id, log_id_low, log_id_high);
1063
1064
1065         if (lm_cypher && nt_cypher) {
1066                 unsigned char key[16];
1067 #ifdef DEBUG_PASSWORD
1068                 DEBUG(100,("lm cypher:"));
1069                 dump_data(100, (char *)lm_cypher, 16);
1070
1071                 DEBUG(100,("nt cypher:"));
1072                 dump_data(100, (char *)nt_cypher, 16);
1073 #endif
1074
1075                 memset(key, 0, 16);
1076                 memcpy(key, sess_key, 8);
1077
1078                 memcpy(lm_owf, lm_cypher, 16);
1079                 SamOEMhash(lm_owf, key, 16);
1080                 memcpy(nt_owf, nt_cypher, 16);
1081                 SamOEMhash(nt_owf, key, 16);
1082
1083 #ifdef DEBUG_PASSWORD
1084                 DEBUG(100,("encrypt of lm owf password:"));
1085                 dump_data(100, (char *)lm_owf, 16);
1086
1087                 DEBUG(100,("encrypt of nt owf password:"));
1088                 dump_data(100, (char *)nt_owf, 16);
1089 #endif
1090                 /* set up pointers to cypher blocks */
1091                 lm_cypher = lm_owf;
1092                 nt_cypher = nt_owf;
1093         }
1094
1095         init_owf_info(&id->lm_owf, lm_cypher);
1096         init_owf_info(&id->nt_owf, nt_cypher);
1097
1098         init_unistr2(&id->uni_domain_name, domain_name, UNI_FLAGS_NONE);
1099         init_uni_hdr(&id->hdr_domain_name, &id->uni_domain_name);
1100         init_unistr2(&id->uni_user_name, user_name, UNI_FLAGS_NONE);
1101         init_uni_hdr(&id->hdr_user_name, &id->uni_user_name);
1102         init_unistr2(&id->uni_wksta_name, wksta_name, UNI_FLAGS_NONE);
1103         init_uni_hdr(&id->hdr_wksta_name, &id->uni_wksta_name);
1104 }
1105
1106 /*******************************************************************
1107  Reads or writes an NET_ID_INFO_1 structure.
1108 ********************************************************************/
1109
1110 static BOOL net_io_id_info1(const char *desc,  NET_ID_INFO_1 *id, prs_struct *ps, int depth)
1111 {
1112         if (id == NULL)
1113                 return False;
1114
1115         prs_debug(ps, depth, desc, "net_io_id_info1");
1116         depth++;
1117
1118         if(!prs_align(ps))
1119                 return False;
1120
1121         if(!prs_uint32("ptr_id_info1", ps, depth, &id->ptr_id_info1))
1122                 return False;
1123
1124         if (id->ptr_id_info1 != 0) {
1125                 if(!smb_io_unihdr("unihdr", &id->hdr_domain_name, ps, depth))
1126                         return False;
1127
1128                 if(!prs_uint32("param_ctrl", ps, depth, &id->param_ctrl))
1129                         return False;
1130                 if(!smb_io_logon_id("", &id->logon_id, ps, depth))
1131                         return False;
1132
1133                 if(!smb_io_unihdr("unihdr", &id->hdr_user_name, ps, depth))
1134                         return False;
1135                 if(!smb_io_unihdr("unihdr", &id->hdr_wksta_name, ps, depth))
1136                         return False;
1137
1138                 if(!smb_io_owf_info("", &id->lm_owf, ps, depth))
1139                         return False;
1140                 if(!smb_io_owf_info("", &id->nt_owf, ps, depth))
1141                         return False;
1142
1143                 if(!smb_io_unistr2("unistr2", &id->uni_domain_name,
1144                                 id->hdr_domain_name.buffer, ps, depth))
1145                         return False;
1146                 if(!smb_io_unistr2("unistr2", &id->uni_user_name,
1147                                 id->hdr_user_name.buffer, ps, depth))
1148                         return False;
1149                 if(!smb_io_unistr2("unistr2", &id->uni_wksta_name,
1150                                 id->hdr_wksta_name.buffer, ps, depth))
1151                         return False;
1152         }
1153
1154         return True;
1155 }
1156
1157 /*******************************************************************
1158 Inits a NET_ID_INFO_2 structure.
1159
1160 This is a network logon packet. The log_id parameters
1161 are what an NT server would generate for LUID once the
1162 user is logged on. I don't think we care about them.
1163
1164 Note that this has no access to the NT and LM hashed passwords,
1165 so it forwards the challenge, and the NT and LM responses (24
1166 bytes each) over the secure channel to the Domain controller
1167 for it to say yea or nay. This is the preferred method of
1168 checking for a logon as it doesn't export the password
1169 hashes to anyone who has compromised the secure channel. JRA.
1170 ********************************************************************/
1171
1172 void init_id_info2(NET_ID_INFO_2 * id, const char *domain_name,
1173                    uint32 param_ctrl,
1174                    uint32 log_id_low, uint32 log_id_high,
1175                    const char *user_name, const char *wksta_name,
1176                    const uchar lm_challenge[8],
1177                    const uchar * lm_chal_resp, size_t lm_chal_resp_len,
1178                    const uchar * nt_chal_resp, size_t nt_chal_resp_len)
1179 {
1180
1181         DEBUG(5,("init_id_info2: %d\n", __LINE__));
1182
1183         id->ptr_id_info2 = 1;
1184
1185         id->param_ctrl = param_ctrl;
1186         init_logon_id(&id->logon_id, log_id_low, log_id_high);
1187
1188         memcpy(id->lm_chal, lm_challenge, sizeof(id->lm_chal));
1189         init_str_hdr(&id->hdr_nt_chal_resp, nt_chal_resp_len, nt_chal_resp_len, (nt_chal_resp != NULL) ? 1 : 0);
1190         init_str_hdr(&id->hdr_lm_chal_resp, lm_chal_resp_len, lm_chal_resp_len, (lm_chal_resp != NULL) ? 1 : 0);
1191
1192         init_unistr2(&id->uni_domain_name, domain_name, UNI_FLAGS_NONE);
1193         init_uni_hdr(&id->hdr_domain_name, &id->uni_domain_name);
1194         init_unistr2(&id->uni_user_name, user_name, UNI_FLAGS_NONE);
1195         init_uni_hdr(&id->hdr_user_name, &id->uni_user_name);
1196         init_unistr2(&id->uni_wksta_name, wksta_name, UNI_FLAGS_NONE);
1197         init_uni_hdr(&id->hdr_wksta_name, &id->uni_wksta_name);
1198
1199         init_string2(&id->nt_chal_resp, (const char *)nt_chal_resp, nt_chal_resp_len, nt_chal_resp_len);
1200         init_string2(&id->lm_chal_resp, (const char *)lm_chal_resp, lm_chal_resp_len, lm_chal_resp_len);
1201
1202 }
1203
1204 /*******************************************************************
1205  Reads or writes an NET_ID_INFO_2 structure.
1206 ********************************************************************/
1207
1208 static BOOL net_io_id_info2(const char *desc,  NET_ID_INFO_2 *id, prs_struct *ps, int depth)
1209 {
1210         if (id == NULL)
1211                 return False;
1212
1213         prs_debug(ps, depth, desc, "net_io_id_info2");
1214         depth++;
1215
1216         if(!prs_align(ps))
1217                 return False;
1218
1219         if(!prs_uint32("ptr_id_info2", ps, depth, &id->ptr_id_info2))
1220                 return False;
1221
1222         if (id->ptr_id_info2 != 0) {
1223                 if(!smb_io_unihdr("unihdr", &id->hdr_domain_name, ps, depth))
1224                         return False;
1225
1226                 if(!prs_uint32("param_ctrl", ps, depth, &id->param_ctrl))
1227                         return False;
1228                 if(!smb_io_logon_id("", &id->logon_id, ps, depth))
1229                         return False;
1230
1231                 if(!smb_io_unihdr("unihdr", &id->hdr_user_name, ps, depth))
1232                         return False;
1233                 if(!smb_io_unihdr("unihdr", &id->hdr_wksta_name, ps, depth))
1234                         return False;
1235
1236                 if(!prs_uint8s (False, "lm_chal", ps, depth, id->lm_chal, 8)) /* lm 8 byte challenge */
1237                         return False;
1238
1239                 if(!smb_io_strhdr("hdr_nt_chal_resp", &id->hdr_nt_chal_resp, ps, depth))
1240                         return False;
1241                 if(!smb_io_strhdr("hdr_lm_chal_resp", &id->hdr_lm_chal_resp, ps, depth))
1242                         return False;
1243
1244                 if(!smb_io_unistr2("uni_domain_name", &id->uni_domain_name,
1245                                 id->hdr_domain_name.buffer, ps, depth))
1246                         return False;
1247                 if(!smb_io_unistr2("uni_user_name  ", &id->uni_user_name,
1248                                 id->hdr_user_name.buffer, ps, depth))
1249                         return False;
1250                 if(!smb_io_unistr2("uni_wksta_name ", &id->uni_wksta_name,
1251                                 id->hdr_wksta_name.buffer, ps, depth))
1252                         return False;
1253                 if(!smb_io_string2("nt_chal_resp", &id->nt_chal_resp,
1254                                 id->hdr_nt_chal_resp.buffer, ps, depth))
1255                         return False;
1256                 if(!smb_io_string2("lm_chal_resp", &id->lm_chal_resp,
1257                                 id->hdr_lm_chal_resp.buffer, ps, depth))
1258                         return False;
1259         }
1260
1261         return True;
1262 }
1263
1264
1265 /*******************************************************************
1266  Inits a DOM_SAM_INFO structure.
1267 ********************************************************************/
1268
1269 void init_sam_info(DOM_SAM_INFO *sam,
1270                                 const char *logon_srv, const char *comp_name,
1271                                 DOM_CRED *clnt_cred,
1272                                 DOM_CRED *rtn_cred, uint16 logon_level,
1273                                 NET_ID_INFO_CTR *ctr)
1274 {
1275         DEBUG(5,("init_sam_info: %d\n", __LINE__));
1276
1277         init_clnt_info2(&sam->client, logon_srv, comp_name, clnt_cred);
1278
1279         if (rtn_cred != NULL) {
1280                 sam->ptr_rtn_cred = 1;
1281                 memcpy(&sam->rtn_cred, rtn_cred, sizeof(sam->rtn_cred));
1282         } else {
1283                 sam->ptr_rtn_cred = 0;
1284         }
1285
1286         sam->logon_level  = logon_level;
1287         sam->ctr          = ctr;
1288 }
1289
1290 /*******************************************************************
1291  Reads or writes a DOM_SAM_INFO structure.
1292 ********************************************************************/
1293
1294 static BOOL net_io_id_info_ctr(const char *desc, NET_ID_INFO_CTR **pp_ctr, prs_struct *ps, int depth)
1295 {
1296         NET_ID_INFO_CTR *ctr = *pp_ctr;
1297
1298         prs_debug(ps, depth, desc, "smb_io_sam_info_ctr");
1299         depth++;
1300
1301         if (UNMARSHALLING(ps)) {
1302                 ctr = *pp_ctr = PRS_ALLOC_MEM(ps, NET_ID_INFO_CTR, 1);
1303                 if (ctr == NULL)
1304                         return False;
1305         }
1306
1307         if (ctr == NULL)
1308                 return False;
1309
1310         /* don't 4-byte align here! */
1311
1312         if(!prs_uint16("switch_value ", ps, depth, &ctr->switch_value))
1313                 return False;
1314
1315         switch (ctr->switch_value) {
1316         case 1:
1317                 if(!net_io_id_info1("", &ctr->auth.id1, ps, depth))
1318                         return False;
1319                 break;
1320         case 2:
1321                 if(!net_io_id_info2("", &ctr->auth.id2, ps, depth))
1322                         return False;
1323                 break;
1324         default:
1325                 /* PANIC! */
1326                 DEBUG(4,("smb_io_sam_info_ctr: unknown switch_value!\n"));
1327                 break;
1328         }
1329
1330         return True;
1331 }
1332
1333 /*******************************************************************
1334  Reads or writes a DOM_SAM_INFO structure.
1335  ********************************************************************/
1336
1337 static BOOL smb_io_sam_info(const char *desc, DOM_SAM_INFO *sam, prs_struct *ps, int depth)
1338 {
1339         if (sam == NULL)
1340                 return False;
1341
1342         prs_debug(ps, depth, desc, "smb_io_sam_info");
1343         depth++;
1344
1345         if(!prs_align(ps))
1346                 return False;
1347
1348         if(!smb_io_clnt_info2("", &sam->client, ps, depth))
1349                 return False;
1350
1351         if(!prs_uint32("ptr_rtn_cred ", ps, depth, &sam->ptr_rtn_cred))
1352                 return False;
1353         if (sam->ptr_rtn_cred) {
1354                 if(!smb_io_cred("", &sam->rtn_cred, ps, depth))
1355                         return False;
1356         }
1357
1358         if(!prs_uint16("logon_level  ", ps, depth, &sam->logon_level))
1359                 return False;
1360
1361         if (sam->logon_level != 0) {
1362                 if(!net_io_id_info_ctr("logon_info", &sam->ctr, ps, depth))
1363                         return False;
1364         }
1365
1366         return True;
1367 }
1368
1369 /*******************************************************************
1370  Reads or writes a DOM_SAM_INFO_EX structure.
1371  ********************************************************************/
1372
1373 static BOOL smb_io_sam_info_ex(const char *desc, DOM_SAM_INFO_EX *sam, prs_struct *ps, int depth)
1374 {
1375         if (sam == NULL)
1376                 return False;
1377
1378         prs_debug(ps, depth, desc, "smb_io_sam_info_ex");
1379         depth++;
1380
1381         if(!prs_align(ps))
1382                 return False;
1383
1384         if(!smb_io_clnt_info2("", &sam->client, ps, depth))
1385                 return False;
1386
1387         if(!prs_uint16("logon_level  ", ps, depth, &sam->logon_level))
1388                 return False;
1389
1390         if (sam->logon_level != 0) {
1391                 if(!net_io_id_info_ctr("logon_info", &sam->ctr, ps, depth))
1392                         return False;
1393         }
1394
1395         return True;
1396 }
1397
1398 /*************************************************************************
1399  Inits a NET_USER_INFO_3 structure.
1400
1401  This is a network logon reply packet, and contains much information about
1402  the user.  This information is passed as a (very long) paramater list
1403  to avoid having to link in the PASSDB code to every program that deals
1404  with this file.
1405  *************************************************************************/
1406
1407 void init_net_user_info3(TALLOC_CTX *ctx, NET_USER_INFO_3 *usr,
1408                          uint32                user_rid,
1409                          uint32                group_rid,
1410
1411                          const char*            user_name,
1412                          const char*            full_name,
1413                          const char*            home_dir,
1414                          const char*            dir_drive,
1415                          const char*            logon_script,
1416                          const char*            profile_path,
1417
1418                          time_t unix_logon_time,
1419                          time_t unix_logoff_time,
1420                          time_t unix_kickoff_time,
1421                          time_t unix_pass_last_set_time,
1422                          time_t unix_pass_can_change_time,
1423                          time_t unix_pass_must_change_time,
1424
1425                          uint16 logon_count, uint16 bad_pw_count,
1426                          uint32 num_groups, const DOM_GID *gids,
1427                          uint32 user_flgs, uchar user_session_key[16],
1428                          uchar lm_session_key[16],
1429                          const char *logon_srv, const char *logon_dom,
1430                          const DOM_SID *dom_sid)
1431 {
1432         /* only cope with one "other" sid, right now. */
1433         /* need to count the number of space-delimited sids */
1434         unsigned int i;
1435         int num_other_sids = 0;
1436
1437         NTTIME          logon_time, logoff_time, kickoff_time,
1438                         pass_last_set_time, pass_can_change_time,
1439                         pass_must_change_time;
1440
1441         ZERO_STRUCTP(usr);
1442
1443         usr->ptr_user_info = 1; /* yes, we're bothering to put USER_INFO data here */
1444
1445         /* Create NTTIME structs */
1446         unix_to_nt_time (&logon_time,            unix_logon_time);
1447         unix_to_nt_time (&logoff_time,           unix_logoff_time);
1448         unix_to_nt_time (&kickoff_time,          unix_kickoff_time);
1449         unix_to_nt_time (&pass_last_set_time,    unix_pass_last_set_time);
1450         unix_to_nt_time (&pass_can_change_time,  unix_pass_can_change_time);
1451         unix_to_nt_time (&pass_must_change_time, unix_pass_must_change_time);
1452
1453         usr->logon_time            = logon_time;
1454         usr->logoff_time           = logoff_time;
1455         usr->kickoff_time          = kickoff_time;
1456         usr->pass_last_set_time    = pass_last_set_time;
1457         usr->pass_can_change_time  = pass_can_change_time;
1458         usr->pass_must_change_time = pass_must_change_time;
1459
1460         usr->logon_count = logon_count;
1461         usr->bad_pw_count = bad_pw_count;
1462
1463         usr->user_rid = user_rid;
1464         usr->group_rid = group_rid;
1465         usr->num_groups = num_groups;
1466
1467         usr->buffer_groups = 1; /* indicates fill in groups, below, even if there are none */
1468         usr->user_flgs = user_flgs;
1469
1470         if (user_session_key != NULL)
1471                 memcpy(usr->user_sess_key, user_session_key, sizeof(usr->user_sess_key));
1472         else
1473                 memset((char *)usr->user_sess_key, '\0', sizeof(usr->user_sess_key));
1474
1475         usr->buffer_dom_id = dom_sid ? 1 : 0; /* yes, we're bothering to put a domain SID in */
1476
1477         memset((char *)usr->lm_sess_key, '\0', sizeof(usr->lm_sess_key));
1478         memset(&usr->acct_flags, '\0', sizeof(usr->acct_flags));
1479
1480         for (i=0; i<7; i++) {
1481                 memset(&usr->unknown[i], '\0', sizeof(usr->unknown));
1482         }
1483
1484         if (lm_session_key != NULL) {
1485                 memcpy(usr->lm_sess_key, lm_session_key, sizeof(usr->lm_sess_key));
1486         }
1487
1488         num_other_sids = init_dom_sid2s(ctx, NULL, &usr->other_sids);
1489
1490         usr->num_other_sids = num_other_sids;
1491         usr->buffer_other_sids = (num_other_sids != 0) ? 1 : 0;
1492
1493         init_unistr2(&usr->uni_user_name, user_name, UNI_FLAGS_NONE);
1494         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
1495         init_unistr2(&usr->uni_full_name, full_name, UNI_FLAGS_NONE);
1496         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
1497         init_unistr2(&usr->uni_logon_script, logon_script, UNI_FLAGS_NONE);
1498         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
1499         init_unistr2(&usr->uni_profile_path, profile_path, UNI_FLAGS_NONE);
1500         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
1501         init_unistr2(&usr->uni_home_dir, home_dir, UNI_FLAGS_NONE);
1502         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
1503         init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_FLAGS_NONE);
1504         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
1505
1506         usr->num_groups2 = num_groups;
1507
1508         usr->gids = TALLOC_ZERO_ARRAY(ctx,DOM_GID,num_groups);
1509         if (usr->gids == NULL && num_groups>0)
1510                 return;
1511
1512         for (i = 0; i < num_groups; i++)
1513                 usr->gids[i] = gids[i];
1514
1515         init_unistr2(&usr->uni_logon_srv, logon_srv, UNI_FLAGS_NONE);
1516         init_uni_hdr(&usr->hdr_logon_srv, &usr->uni_logon_srv);
1517         init_unistr2(&usr->uni_logon_dom, logon_dom, UNI_FLAGS_NONE);
1518         init_uni_hdr(&usr->hdr_logon_dom, &usr->uni_logon_dom);
1519
1520         init_dom_sid2(&usr->dom_sid, dom_sid);
1521         /* "other" sids are set up above */
1522 }
1523
1524  void dump_acct_flags(uint32 acct_flags) {
1525
1526         int lvl = 10;
1527         DEBUG(lvl,("dump_acct_flags\n"));
1528         if (acct_flags & ACB_NORMAL) {
1529                 DEBUGADD(lvl,("\taccount has UF_NORMAL_ACCOUNT\n"));
1530         }
1531         if (acct_flags & ACB_PWNOEXP) {
1532                 DEBUGADD(lvl,("\taccount has UF_DONT_EXPIRE_PASSWD\n"));
1533         }
1534         if (acct_flags & ACB_ENC_TXT_PWD_ALLOWED) {
1535                 DEBUGADD(lvl,("\taccount has UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED\n"));
1536         }
1537         if (acct_flags & ACB_NOT_DELEGATED) {
1538                 DEBUGADD(lvl,("\taccount has UF_NOT_DELEGATED\n"));
1539         }
1540         if (acct_flags & ACB_USE_DES_KEY_ONLY) {
1541                 DEBUGADD(lvl,("\taccount has UF_USE_DES_KEY_ONLY set, sig verify wont work\n"));
1542         }
1543 }
1544
1545  void dump_user_flgs(uint32 user_flags) {
1546
1547         int lvl = 10;
1548         DEBUG(lvl,("dump_user_flgs\n"));
1549         if (user_flags & LOGON_EXTRA_SIDS) {
1550                 DEBUGADD(lvl,("\taccount has LOGON_EXTRA_SIDS\n"));
1551         }
1552         if (user_flags & LOGON_RESOURCE_GROUPS) {
1553                 DEBUGADD(lvl,("\taccount has LOGON_RESOURCE_GROUPS\n"));
1554         }
1555         if (user_flags & LOGON_NTLMV2_ENABLED) {
1556                 DEBUGADD(lvl,("\taccount has LOGON_NTLMV2_ENABLED\n"));
1557         }
1558         if (user_flags & LOGON_CACHED_ACCOUNT) {
1559                 DEBUGADD(lvl,("\taccount has LOGON_CACHED_ACCOUNT\n"));
1560         }
1561
1562
1563 }
1564
1565 /*******************************************************************
1566  This code has been modified to cope with a NET_USER_INFO_2 - which is
1567  exactly the same as a NET_USER_INFO_3, minus the other sids parameters.
1568  We use validation level to determine if we're marshalling a info 2 or
1569  INFO_3 - be we always return an INFO_3. Based on code donated by Marc
1570  Jacobsen at HP. JRA.
1571 ********************************************************************/
1572
1573 BOOL net_io_user_info3(const char *desc, NET_USER_INFO_3 *usr, prs_struct *ps,
1574                        int depth, uint16 validation_level, BOOL kerb_validation_level)
1575 {
1576         unsigned int i;
1577
1578         if (usr == NULL)
1579                 return False;
1580
1581         prs_debug(ps, depth, desc, "net_io_user_info3");
1582         depth++;
1583
1584         if (UNMARSHALLING(ps))
1585                 ZERO_STRUCTP(usr);
1586
1587         if(!prs_align(ps))
1588                 return False;
1589
1590         if(!prs_uint32("ptr_user_info ", ps, depth, &usr->ptr_user_info))
1591                 return False;
1592
1593         if (usr->ptr_user_info == 0)
1594                 return True;
1595
1596         if(!smb_io_time("logon time", &usr->logon_time, ps, depth)) /* logon time */
1597                 return False;
1598         if(!smb_io_time("logoff time", &usr->logoff_time, ps, depth)) /* logoff time */
1599                 return False;
1600         if(!smb_io_time("kickoff time", &usr->kickoff_time, ps, depth)) /* kickoff time */
1601                 return False;
1602         if(!smb_io_time("last set time", &usr->pass_last_set_time, ps, depth)) /* password last set time */
1603                 return False;
1604         if(!smb_io_time("can change time", &usr->pass_can_change_time , ps, depth)) /* password can change time */
1605                 return False;
1606         if(!smb_io_time("must change time", &usr->pass_must_change_time, ps, depth)) /* password must change time */
1607                 return False;
1608
1609         if(!smb_io_unihdr("hdr_user_name", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
1610                 return False;
1611         if(!smb_io_unihdr("hdr_full_name", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
1612                 return False;
1613         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
1614                 return False;
1615         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
1616                 return False;
1617         if(!smb_io_unihdr("hdr_home_dir", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
1618                 return False;
1619         if(!smb_io_unihdr("hdr_dir_drive", &usr->hdr_dir_drive, ps, depth)) /* home directory drive unicode string header */
1620                 return False;
1621
1622         if(!prs_uint16("logon_count   ", ps, depth, &usr->logon_count))  /* logon count */
1623                 return False;
1624         if(!prs_uint16("bad_pw_count  ", ps, depth, &usr->bad_pw_count)) /* bad password count */
1625                 return False;
1626
1627         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))       /* User RID */
1628                 return False;
1629         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))      /* Group RID */
1630                 return False;
1631         if(!prs_uint32("num_groups    ", ps, depth, &usr->num_groups))    /* num groups */
1632                 return False;
1633         if(!prs_uint32("buffer_groups ", ps, depth, &usr->buffer_groups)) /* undocumented buffer pointer to groups. */
1634                 return False;
1635         if(!prs_uint32("user_flgs     ", ps, depth, &usr->user_flgs))     /* user flags */
1636                 return False;
1637         dump_user_flgs(usr->user_flgs);
1638         if(!prs_uint8s(False, "user_sess_key", ps, depth, usr->user_sess_key, 16)) /* user session key */
1639                 return False;
1640
1641         if(!smb_io_unihdr("hdr_logon_srv", &usr->hdr_logon_srv, ps, depth)) /* logon server unicode string header */
1642                 return False;
1643         if(!smb_io_unihdr("hdr_logon_dom", &usr->hdr_logon_dom, ps, depth)) /* logon domain unicode string header */
1644                 return False;
1645
1646         if(!prs_uint32("buffer_dom_id ", ps, depth, &usr->buffer_dom_id)) /* undocumented logon domain id pointer */
1647                 return False;
1648
1649         if(!prs_uint8s(False, "lm_sess_key", ps, depth, usr->lm_sess_key, 8)) /* lm session key */
1650                 return False;
1651
1652         if(!prs_uint32("acct_flags ", ps, depth, &usr->acct_flags)) /* Account flags  */
1653                 return False;
1654         dump_acct_flags(usr->acct_flags);
1655         for (i = 0; i < 7; i++)
1656         {
1657                 if (!prs_uint32("unkown", ps, depth, &usr->unknown[i])) /* unknown */
1658                         return False;
1659         }
1660
1661         if (validation_level == 3) {
1662                 if(!prs_uint32("num_other_sids", ps, depth, &usr->num_other_sids)) /* 0 - num_sids */
1663                         return False;
1664                 if(!prs_uint32("buffer_other_sids", ps, depth, &usr->buffer_other_sids)) /* NULL - undocumented pointer to SIDs. */
1665                         return False;
1666         } else {
1667                 if (UNMARSHALLING(ps)) {
1668                         usr->num_other_sids = 0;
1669                         usr->buffer_other_sids = 0;
1670                 }
1671         }
1672
1673         /* get kerb validation info (not really part of user_info_3) - Guenther */
1674
1675         if (kerb_validation_level) {
1676
1677                 if(!prs_uint32("ptr_res_group_dom_sid", ps, depth, &usr->ptr_res_group_dom_sid))
1678                         return False;
1679                 if(!prs_uint32("res_group_count", ps, depth, &usr->res_group_count))
1680                         return False;
1681                 if(!prs_uint32("ptr_res_groups", ps, depth, &usr->ptr_res_groups))
1682                         return False;
1683         }
1684
1685         if(!smb_io_unistr2("uni_user_name", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
1686                 return False;
1687         if(!smb_io_unistr2("uni_full_name", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
1688                 return False;
1689         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
1690                 return False;
1691         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
1692                 return False;
1693         if(!smb_io_unistr2("uni_home_dir", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
1694                 return False;
1695         if(!smb_io_unistr2("uni_dir_drive", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
1696                 return False;
1697
1698         if(!prs_align(ps))
1699                 return False;
1700
1701         if (usr->num_groups > 0) {
1702
1703                 if(!prs_uint32("num_groups2   ", ps, depth, &usr->num_groups2))        /* num groups2 */
1704                         return False;
1705
1706                 if (usr->num_groups != usr->num_groups2) {
1707                         DEBUG(3,("net_io_user_info3: num_groups mismatch! (%d != %d)\n",
1708                         usr->num_groups, usr->num_groups2));
1709                         return False;
1710                 }
1711
1712
1713                 if (UNMARSHALLING(ps)) {
1714                         usr->gids = PRS_ALLOC_MEM(ps, DOM_GID, usr->num_groups);
1715                         if (usr->gids == NULL)
1716                                 return False;
1717                 }
1718
1719                 for (i = 0; i < usr->num_groups; i++) {
1720                         if(!smb_io_gid("", &usr->gids[i], ps, depth)) /* group info */
1721                                 return False;
1722                 }
1723
1724         }
1725
1726         if(!smb_io_unistr2("uni_logon_srv", &usr->uni_logon_srv, usr->hdr_logon_srv.buffer, ps, depth)) /* logon server unicode string */
1727                 return False;
1728         if(!smb_io_unistr2("uni_logon_dom", &usr->uni_logon_dom, usr->hdr_logon_dom.buffer, ps, depth)) /* logon domain unicode string */
1729                 return False;
1730
1731         if(!smb_io_dom_sid2("", &usr->dom_sid, ps, depth))           /* domain SID */
1732                 return False;
1733
1734         if (validation_level == 3 && usr->buffer_other_sids) {
1735
1736                 uint32 num_other_sids = usr->num_other_sids;
1737
1738                 if (!(usr->user_flgs & LOGON_EXTRA_SIDS)) {
1739                         DEBUG(10,("net_io_user_info3: user_flgs attribute does not have LOGON_EXTRA_SIDS\n"));
1740                         /* return False; */
1741                 }
1742
1743                 if (!prs_uint32("num_other_sids", ps, depth,
1744                                 &num_other_sids))
1745                         return False;
1746
1747                 if (num_other_sids != usr->num_other_sids)
1748                         return False;
1749
1750                 if (UNMARSHALLING(ps)) {
1751                         usr->other_sids = PRS_ALLOC_MEM(ps, DOM_SID2, usr->num_other_sids);
1752                         usr->other_sids_attrib =
1753                                 PRS_ALLOC_MEM(ps, uint32, usr->num_other_sids);
1754
1755                         if ((num_other_sids != 0) &&
1756                             ((usr->other_sids == NULL) ||
1757                              (usr->other_sids_attrib == NULL)))
1758                                 return False;
1759                 }
1760
1761                 /* First the pointers to the SIDS and attributes */
1762
1763                 depth++;
1764
1765                 for (i=0; i<usr->num_other_sids; i++) {
1766                         uint32 ptr = 1;
1767
1768                         if (!prs_uint32("sid_ptr", ps, depth, &ptr))
1769                                 return False;
1770
1771                         if (UNMARSHALLING(ps) && (ptr == 0))
1772                                 return False;
1773
1774                         if (!prs_uint32("attribute", ps, depth,
1775                                         &usr->other_sids_attrib[i]))
1776                                 return False;
1777                 }
1778
1779                 for (i = 0; i < usr->num_other_sids; i++) {
1780                         if(!smb_io_dom_sid2("", &usr->other_sids[i], ps, depth)) /* other domain SIDs */
1781                                 return False;
1782                 }
1783
1784                 depth--;
1785         }
1786
1787         return True;
1788 }
1789
1790 /*******************************************************************
1791  Reads or writes a structure.
1792 ********************************************************************/
1793
1794 BOOL net_io_q_sam_logon(const char *desc, NET_Q_SAM_LOGON *q_l, prs_struct *ps, int depth)
1795 {
1796         if (q_l == NULL)
1797                 return False;
1798
1799         prs_debug(ps, depth, desc, "net_io_q_sam_logon");
1800         depth++;
1801
1802         if(!prs_align(ps))
1803                 return False;
1804
1805         if(!smb_io_sam_info("", &q_l->sam_id, ps, depth))
1806                 return False;
1807
1808         if(!prs_align_uint16(ps))
1809                 return False;
1810
1811         if(!prs_uint16("validation_level", ps, depth, &q_l->validation_level))
1812                 return False;
1813
1814         return True;
1815 }
1816
1817 /*******************************************************************
1818  Reads or writes a structure.
1819 ********************************************************************/
1820
1821 BOOL net_io_r_sam_logon(const char *desc, NET_R_SAM_LOGON *r_l, prs_struct *ps, int depth)
1822 {
1823         if (r_l == NULL)
1824                 return False;
1825
1826         prs_debug(ps, depth, desc, "net_io_r_sam_logon");
1827         depth++;
1828
1829         if(!prs_uint32("buffer_creds", ps, depth, &r_l->buffer_creds)) /* undocumented buffer pointer */
1830                 return False;
1831         if (&r_l->buffer_creds) {
1832                 if(!smb_io_cred("", &r_l->srv_creds, ps, depth)) /* server credentials.  server time stamp appears to be ignored. */
1833                         return False;
1834         }
1835
1836         if(!prs_uint16("switch_value", ps, depth, &r_l->switch_value))
1837                 return False;
1838         if(!prs_align(ps))
1839                 return False;
1840
1841 #if 1 /* W2k always needs this - even for bad passwd. JRA */
1842         if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value, False))
1843                 return False;
1844 #else
1845         if (r_l->switch_value != 0) {
1846                 if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value, False))
1847                         return False;
1848         }
1849 #endif
1850
1851         if(!prs_uint32("auth_resp   ", ps, depth, &r_l->auth_resp)) /* 1 - Authoritative response; 0 - Non-Auth? */
1852                 return False;
1853
1854         if(!prs_ntstatus("status      ", ps, depth, &r_l->status))
1855                 return False;
1856
1857         if(!prs_align(ps))
1858                 return False;
1859
1860         return True;
1861 }
1862
1863 /*******************************************************************
1864  Reads or writes a structure.
1865 ********************************************************************/
1866
1867 BOOL net_io_q_sam_logon_ex(const char *desc, NET_Q_SAM_LOGON_EX *q_l, prs_struct *ps, int depth)
1868 {
1869         if (q_l == NULL)
1870                 return False;
1871
1872         prs_debug(ps, depth, desc, "net_io_q_sam_logon_ex");
1873         depth++;
1874
1875         if(!prs_align(ps))
1876                 return False;
1877
1878         if(!smb_io_sam_info_ex("", &q_l->sam_id, ps, depth))
1879                 return False;
1880
1881         if(!prs_align_uint16(ps))
1882                 return False;
1883
1884         if(!prs_uint16("validation_level", ps, depth, &q_l->validation_level))
1885                 return False;
1886
1887         if(!prs_uint32("flags  ", ps, depth, &q_l->flags))
1888                 return False;
1889
1890         return True;
1891 }
1892
1893 /*******************************************************************
1894  Reads or writes a structure.
1895 ********************************************************************/
1896
1897 BOOL net_io_r_sam_logon_ex(const char *desc, NET_R_SAM_LOGON_EX *r_l, prs_struct *ps, int depth)
1898 {
1899         if (r_l == NULL)
1900                 return False;
1901
1902         prs_debug(ps, depth, desc, "net_io_r_sam_logon_ex");
1903         depth++;
1904
1905         if(!prs_uint16("switch_value", ps, depth, &r_l->switch_value))
1906                 return False;
1907         if(!prs_align(ps))
1908                 return False;
1909
1910 #if 1 /* W2k always needs this - even for bad passwd. JRA */
1911         if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value, False))
1912                 return False;
1913 #else
1914         if (r_l->switch_value != 0) {
1915                 if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value, False))
1916                         return False;
1917         }
1918 #endif
1919
1920         if(!prs_uint32("auth_resp   ", ps, depth, &r_l->auth_resp)) /* 1 - Authoritative response; 0 - Non-Auth? */
1921                 return False;
1922
1923         if(!prs_uint32("flags   ", ps, depth, &r_l->flags))
1924                 return False;
1925
1926         if(!prs_ntstatus("status      ", ps, depth, &r_l->status))
1927                 return False;
1928
1929         if(!prs_align(ps))
1930                 return False;
1931
1932         return True;
1933 }
1934
1935
1936 /*******************************************************************
1937  Reads or writes a structure.
1938 ********************************************************************/
1939
1940 BOOL net_io_q_sam_logoff(const char *desc,  NET_Q_SAM_LOGOFF *q_l, prs_struct *ps, int depth)
1941 {
1942         if (q_l == NULL)
1943                 return False;
1944
1945         prs_debug(ps, depth, desc, "net_io_q_sam_logoff");
1946         depth++;
1947
1948         if(!prs_align(ps))
1949                 return False;
1950
1951         if(!smb_io_sam_info("", &q_l->sam_id, ps, depth))           /* domain SID */
1952                 return False;
1953
1954         return True;
1955 }
1956
1957 /*******************************************************************
1958  Reads or writes a structure.
1959 ********************************************************************/
1960
1961 BOOL net_io_r_sam_logoff(const char *desc, NET_R_SAM_LOGOFF *r_l, prs_struct *ps, int depth)
1962 {
1963         if (r_l == NULL)
1964                 return False;
1965
1966         prs_debug(ps, depth, desc, "net_io_r_sam_logoff");
1967         depth++;
1968
1969         if(!prs_align(ps))
1970                 return False;
1971
1972         if(!prs_uint32("buffer_creds", ps, depth, &r_l->buffer_creds)) /* undocumented buffer pointer */
1973                 return False;
1974         if(!smb_io_cred("", &r_l->srv_creds, ps, depth)) /* server credentials.  server time stamp appears to be ignored. */
1975                 return False;
1976
1977         if(!prs_ntstatus("status      ", ps, depth, &r_l->status))
1978                 return False;
1979
1980         return True;
1981 }
1982
1983 /*******************************************************************
1984 makes a NET_Q_SAM_SYNC structure.
1985 ********************************************************************/
1986 BOOL init_net_q_sam_sync(NET_Q_SAM_SYNC * q_s, const char *srv_name,
1987                          const char *cli_name, DOM_CRED *cli_creds,
1988                          DOM_CRED *ret_creds, uint32 database_id,
1989                          uint32 next_rid)
1990 {
1991         DEBUG(5, ("init_q_sam_sync\n"));
1992
1993         init_unistr2(&q_s->uni_srv_name, srv_name, UNI_STR_TERMINATE);
1994         init_unistr2(&q_s->uni_cli_name, cli_name, UNI_STR_TERMINATE);
1995
1996         if (cli_creds)
1997                 memcpy(&q_s->cli_creds, cli_creds, sizeof(q_s->cli_creds));
1998
1999         if (cli_creds)
2000                 memcpy(&q_s->ret_creds, ret_creds, sizeof(q_s->ret_creds));
2001         else
2002                 memset(&q_s->ret_creds, 0, sizeof(q_s->ret_creds));
2003
2004         q_s->database_id = database_id;
2005         q_s->restart_state = 0;
2006         q_s->sync_context = next_rid;
2007         q_s->max_size = 0xffff;
2008
2009         return True;
2010 }
2011
2012 /*******************************************************************
2013 reads or writes a structure.
2014 ********************************************************************/
2015 BOOL net_io_q_sam_sync(const char *desc, NET_Q_SAM_SYNC * q_s, prs_struct *ps,
2016                        int depth)
2017 {
2018         prs_debug(ps, depth, desc, "net_io_q_sam_sync");
2019         depth++;
2020
2021         if (!smb_io_unistr2("", &q_s->uni_srv_name, True, ps, depth))
2022                 return False;
2023         if (!smb_io_unistr2("", &q_s->uni_cli_name, True, ps, depth))
2024                 return False;
2025
2026         if (!smb_io_cred("", &q_s->cli_creds, ps, depth))
2027                 return False;
2028         if (!smb_io_cred("", &q_s->ret_creds, ps, depth))
2029                 return False;
2030
2031         if (!prs_uint32("database_id  ", ps, depth, &q_s->database_id))
2032                 return False;
2033         if (!prs_uint32("restart_state", ps, depth, &q_s->restart_state))
2034                 return False;
2035         if (!prs_uint32("sync_context ", ps, depth, &q_s->sync_context))
2036                 return False;
2037
2038         if (!prs_uint32("max_size", ps, depth, &q_s->max_size))
2039                 return False;
2040
2041         return True;
2042 }
2043
2044 /*******************************************************************
2045 reads or writes a structure.
2046 ********************************************************************/
2047 static BOOL net_io_sam_delta_hdr(const char *desc, SAM_DELTA_HDR * delta,
2048                                  prs_struct *ps, int depth)
2049 {
2050         prs_debug(ps, depth, desc, "net_io_sam_delta_hdr");
2051         depth++;
2052
2053         if (!prs_uint16("type", ps, depth, &delta->type))
2054                 return False;
2055         if (!prs_uint16("type2", ps, depth, &delta->type2))
2056                 return False;
2057         if (!prs_uint32("target_rid", ps, depth, &delta->target_rid))
2058                 return False;
2059
2060         if (!prs_uint32("type3", ps, depth, &delta->type3))
2061                 return False;
2062
2063         /* Not sure why we need this but it seems to be necessary to get
2064            sam deltas working. */
2065
2066         if (delta->type != 0x16) {
2067                 if (!prs_uint32("ptr_delta", ps, depth, &delta->ptr_delta))
2068                         return False;
2069         }
2070
2071         return True;
2072 }
2073
2074 /*******************************************************************
2075 reads or writes a structure.
2076 ********************************************************************/
2077 static BOOL net_io_sam_delta_mod_count(const char *desc, SAM_DELTA_MOD_COUNT *info,
2078                                    prs_struct *ps, int depth)
2079 {
2080         prs_debug(ps, depth, desc, "net_io_sam_delta_stamp");
2081         depth++;
2082
2083         if (!prs_uint32("seqnum", ps, depth, &info->seqnum))
2084                 return False;
2085         if (!prs_uint32("dom_mod_count_ptr", ps, depth,
2086                         &info->dom_mod_count_ptr))
2087                 return False;
2088
2089         if (info->dom_mod_count_ptr) {
2090                 if (!prs_uint64("dom_mod_count", ps, depth,
2091                                 &info->dom_mod_count))
2092                         return False;
2093         }
2094
2095         return True;
2096 }
2097
2098 /*******************************************************************
2099 reads or writes a structure.
2100 ********************************************************************/
2101 static BOOL net_io_sam_domain_info(const char *desc, SAM_DOMAIN_INFO * info,
2102                                    prs_struct *ps, int depth)
2103 {
2104         prs_debug(ps, depth, desc, "net_io_sam_domain_info");
2105         depth++;
2106
2107         if (!smb_io_unihdr("hdr_dom_name", &info->hdr_dom_name, ps, depth))
2108                 return False;
2109         if (!smb_io_unihdr("hdr_oem_info", &info->hdr_oem_info, ps, depth))
2110                 return False;
2111
2112         if (!prs_uint64("force_logoff", ps, depth, &info->force_logoff))
2113                 return False;
2114         if (!prs_uint16("min_pwd_len", ps, depth, &info->min_pwd_len))
2115                 return False;
2116         if (!prs_uint16("pwd_history_len", ps, depth, &info->pwd_history_len))
2117                 return False;
2118         if (!prs_uint64("max_pwd_age", ps, depth, &info->max_pwd_age))
2119                 return False;
2120         if (!prs_uint64("min_pwd_age", ps, depth, &info->min_pwd_age))
2121                 return False;
2122         if (!prs_uint64("dom_mod_count", ps, depth, &info->dom_mod_count))
2123                 return False;
2124         if (!smb_io_time("creation_time", &info->creation_time, ps, depth))
2125                 return False;
2126         if (!prs_uint32("security_information", ps, depth, &info->security_information))
2127                 return False;
2128         if (!smb_io_bufhdr4("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2129                 return False;
2130         if (!smb_io_lockout_string_hdr("hdr_account_lockout_string", &info->hdr_account_lockout, ps, depth))
2131                 return False;
2132         if (!smb_io_unihdr("hdr_unknown2", &info->hdr_unknown2, ps, depth))
2133                 return False;
2134         if (!smb_io_unihdr("hdr_unknown3", &info->hdr_unknown3, ps, depth))
2135                 return False;
2136         if (!smb_io_unihdr("hdr_unknown4", &info->hdr_unknown4, ps, depth))
2137                 return False;
2138         if (!prs_uint32("logon_chgpass", ps, depth, &info->logon_chgpass))
2139                 return False;
2140         if (!prs_uint32("unknown6", ps, depth, &info->unknown6))
2141                 return False;
2142         if (!prs_uint32("unknown7", ps, depth, &info->unknown7))
2143                 return False;
2144         if (!prs_uint32("unknown8", ps, depth, &info->unknown8))
2145                 return False;
2146
2147         if (!smb_io_unistr2("uni_dom_name", &info->uni_dom_name,
2148                             info->hdr_dom_name.buffer, ps, depth))
2149                 return False;
2150         if (!smb_io_unistr2("buf_oem_info", &info->buf_oem_info,
2151                             info->hdr_oem_info.buffer, ps, depth))
2152                 return False;
2153
2154         if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2155                 return False;
2156
2157         if (!smb_io_account_lockout_str("account_lockout", &info->account_lockout,
2158                                         info->hdr_account_lockout.buffer, ps, depth))
2159                 return False;
2160
2161         if (!smb_io_unistr2("buf_unknown2", &info->buf_unknown2,
2162                             info->hdr_unknown2.buffer, ps, depth))
2163                 return False;
2164         if (!smb_io_unistr2("buf_unknown3", &info->buf_unknown3,
2165                             info->hdr_unknown3.buffer, ps, depth))
2166                 return False;
2167         if (!smb_io_unistr2("buf_unknown4", &info->buf_unknown4,
2168                             info->hdr_unknown4.buffer, ps, depth))
2169                 return False;
2170
2171         return True;
2172 }
2173
2174 /*******************************************************************
2175 reads or writes a structure.
2176 ********************************************************************/
2177 static BOOL net_io_sam_group_info(const char *desc, SAM_GROUP_INFO * info,
2178                                   prs_struct *ps, int depth)
2179 {
2180         prs_debug(ps, depth, desc, "net_io_sam_group_info");
2181         depth++;
2182
2183         if (!smb_io_unihdr("hdr_grp_name", &info->hdr_grp_name, ps, depth))
2184                 return False;
2185         if (!smb_io_gid("gid", &info->gid, ps, depth))
2186                 return False;
2187         if (!smb_io_unihdr("hdr_grp_desc", &info->hdr_grp_desc, ps, depth))
2188                 return False;
2189         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2190                 return False;
2191
2192         if (ps->data_offset + 48 > ps->buffer_size)
2193                 return False;
2194         ps->data_offset += 48;
2195
2196         if (!smb_io_unistr2("uni_grp_name", &info->uni_grp_name,
2197                             info->hdr_grp_name.buffer, ps, depth))
2198                 return False;
2199         if (!smb_io_unistr2("uni_grp_desc", &info->uni_grp_desc,
2200                             info->hdr_grp_desc.buffer, ps, depth))
2201                 return False;
2202         if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2203                 return False;
2204
2205         return True;
2206 }
2207
2208 /*******************************************************************
2209 reads or writes a structure.
2210 ********************************************************************/
2211 static BOOL net_io_sam_passwd_info(const char *desc, SAM_PWD * pwd,
2212                                    prs_struct *ps, int depth)
2213 {
2214         prs_debug(ps, depth, desc, "net_io_sam_passwd_info");
2215         depth++;
2216
2217         if (!prs_uint32("unk_0 ", ps, depth, &pwd->unk_0))
2218                 return False;
2219
2220         if (!smb_io_unihdr("hdr_lm_pwd", &pwd->hdr_lm_pwd, ps, depth))
2221                 return False;
2222         if (!prs_uint8s(False, "buf_lm_pwd", ps, depth, pwd->buf_lm_pwd, 16))
2223                 return False;
2224
2225         if (!smb_io_unihdr("hdr_nt_pwd", &pwd->hdr_nt_pwd, ps, depth))
2226                 return False;
2227         if (!prs_uint8s(False, "buf_nt_pwd", ps, depth, pwd->buf_nt_pwd, 16))
2228                 return False;
2229
2230         if (!smb_io_unihdr("", &pwd->hdr_empty_lm, ps, depth))
2231                 return False;
2232         if (!smb_io_unihdr("", &pwd->hdr_empty_nt, ps, depth))
2233                 return False;
2234
2235         return True;
2236 }
2237
2238 /*******************************************************************
2239 makes a SAM_ACCOUNT_INFO structure.
2240 ********************************************************************/
2241 BOOL make_sam_account_info(SAM_ACCOUNT_INFO * info,
2242                            const UNISTR2 *user_name,
2243                            const UNISTR2 *full_name,
2244                            uint32 user_rid, uint32 group_rid,
2245                            const UNISTR2 *home_dir,
2246                            const UNISTR2 *dir_drive,
2247                            const UNISTR2 *log_scr,
2248                            const UNISTR2 *desc,
2249                            uint32 acb_info,
2250                            const UNISTR2 *prof_path,
2251                            const UNISTR2 *wkstas,
2252                            const UNISTR2 *unk_str, const UNISTR2 *mung_dial)
2253 {
2254         int len_user_name = user_name != NULL ? user_name->uni_str_len : 0;
2255         int len_full_name = full_name != NULL ? full_name->uni_str_len : 0;
2256         int len_home_dir = home_dir != NULL ? home_dir->uni_str_len : 0;
2257         int len_dir_drive = dir_drive != NULL ? dir_drive->uni_str_len : 0;
2258         int len_logon_script = log_scr != NULL ? log_scr->uni_str_len : 0;
2259         int len_profile_path = prof_path != NULL ? prof_path->uni_str_len : 0;
2260         int len_description = desc != NULL ? desc->uni_str_len : 0;
2261         int len_workstations = wkstas != NULL ? wkstas->uni_str_len : 0;
2262         int len_unknown_str = unk_str != NULL ? unk_str->uni_str_len : 0;
2263         int len_munged_dial = mung_dial != NULL ? mung_dial->uni_str_len : 0;
2264
2265         DEBUG(5, ("make_sam_account_info\n"));
2266
2267         make_uni_hdr(&info->hdr_acct_name, len_user_name);
2268         make_uni_hdr(&info->hdr_full_name, len_full_name);
2269         make_uni_hdr(&info->hdr_home_dir, len_home_dir);
2270         make_uni_hdr(&info->hdr_dir_drive, len_dir_drive);
2271         make_uni_hdr(&info->hdr_logon_script, len_logon_script);
2272         make_uni_hdr(&info->hdr_profile, len_profile_path);
2273         make_uni_hdr(&info->hdr_acct_desc, len_description);
2274         make_uni_hdr(&info->hdr_workstations, len_workstations);
2275         make_uni_hdr(&info->hdr_comment, len_unknown_str);
2276         make_uni_hdr(&info->hdr_parameters, len_munged_dial);
2277
2278         /* not present */
2279         make_bufhdr2(&info->hdr_sec_desc, 0, 0, 0);
2280
2281         info->user_rid = user_rid;
2282         info->group_rid = group_rid;
2283
2284         init_nt_time(&info->logon_time);
2285         init_nt_time(&info->logoff_time);
2286         init_nt_time(&info->pwd_last_set_time);
2287         init_nt_time(&info->acct_expiry_time);
2288
2289         info->logon_divs = 0xA8;
2290         info->ptr_logon_hrs = 0;        /* Don't care right now */
2291
2292         info->bad_pwd_count = 0;
2293         info->logon_count = 0;
2294         info->acb_info = acb_info;
2295         info->nt_pwd_present = 0;
2296         info->lm_pwd_present = 0;
2297         info->pwd_expired = 0;
2298         info->country = 0;
2299         info->codepage = 0;
2300
2301         info->unknown1 = 0x4EC;
2302         info->unknown2 = 0;
2303
2304         copy_unistr2(&info->uni_acct_name, user_name);
2305         copy_unistr2(&info->uni_full_name, full_name);
2306         copy_unistr2(&info->uni_home_dir, home_dir);
2307         copy_unistr2(&info->uni_dir_drive, dir_drive);
2308         copy_unistr2(&info->uni_logon_script, log_scr);
2309         copy_unistr2(&info->uni_profile, prof_path);
2310         copy_unistr2(&info->uni_acct_desc, desc);
2311         copy_unistr2(&info->uni_workstations, wkstas);
2312         copy_unistr2(&info->uni_comment, unk_str);
2313         copy_unistr2(&info->uni_parameters, mung_dial);
2314
2315         return True;
2316 }
2317
2318 /*******************************************************************
2319 reads or writes a structure.
2320 ********************************************************************/
2321 static BOOL net_io_sam_account_info(const char *desc, SAM_ACCOUNT_INFO *info,
2322                                 prs_struct *ps, int depth)
2323 {
2324         BUFHDR2 hdr_priv_data;
2325         uint32 i;
2326
2327         prs_debug(ps, depth, desc, "net_io_sam_account_info");
2328         depth++;
2329
2330         if (!smb_io_unihdr("hdr_acct_name", &info->hdr_acct_name, ps, depth))
2331                 return False;
2332         if (!smb_io_unihdr("hdr_full_name", &info->hdr_full_name, ps, depth))
2333                 return False;
2334
2335         if (!prs_uint32("user_rid ", ps, depth, &info->user_rid))
2336                 return False;
2337         if (!prs_uint32("group_rid", ps, depth, &info->group_rid))
2338                 return False;
2339
2340         if (!smb_io_unihdr("hdr_home_dir ", &info->hdr_home_dir, ps, depth))
2341                 return False;
2342         if (!smb_io_unihdr("hdr_dir_drive", &info->hdr_dir_drive, ps, depth))
2343                 return False;
2344         if (!smb_io_unihdr("hdr_logon_script", &info->hdr_logon_script, ps,
2345                            depth))
2346                 return False;
2347
2348         if (!smb_io_unihdr("hdr_acct_desc", &info->hdr_acct_desc, ps, depth))
2349                 return False;
2350         if (!smb_io_unihdr("hdr_workstations", &info->hdr_workstations, ps,
2351                            depth))
2352                 return False;
2353
2354         if (!smb_io_time("logon_time", &info->logon_time, ps, depth))
2355                 return False;
2356         if (!smb_io_time("logoff_time", &info->logoff_time, ps, depth))
2357                 return False;
2358
2359         if (!prs_uint32("logon_divs   ", ps, depth, &info->logon_divs))
2360                 return False;
2361         if (!prs_uint32("ptr_logon_hrs", ps, depth, &info->ptr_logon_hrs))
2362                 return False;
2363
2364         if (!prs_uint16("bad_pwd_count", ps, depth, &info->bad_pwd_count))
2365                 return False;
2366         if (!prs_uint16("logon_count", ps, depth, &info->logon_count))
2367                 return False;
2368         if (!smb_io_time("pwd_last_set_time", &info->pwd_last_set_time, ps,
2369                          depth))
2370                 return False;
2371         if (!smb_io_time("acct_expiry_time", &info->acct_expiry_time, ps,
2372                          depth))
2373                 return False;
2374
2375         if (!prs_uint32("acb_info", ps, depth, &info->acb_info))
2376                 return False;
2377         if (!prs_uint8s(False, "nt_pwd", ps, depth, info->nt_pwd, 16))
2378                 return False;
2379         if (!prs_uint8s(False, "lm_pwd", ps, depth, info->lm_pwd, 16))
2380                 return False;
2381         if (!prs_uint8("lm_pwd_present", ps, depth, &info->lm_pwd_present))
2382                 return False;
2383         if (!prs_uint8("nt_pwd_present", ps, depth, &info->nt_pwd_present))
2384                 return False;
2385         if (!prs_uint8("pwd_expired", ps, depth, &info->pwd_expired))
2386                 return False;
2387
2388         if (!smb_io_unihdr("hdr_comment", &info->hdr_comment, ps, depth))
2389                 return False;
2390         if (!smb_io_unihdr("hdr_parameters", &info->hdr_parameters, ps,
2391                            depth))
2392                 return False;
2393         if (!prs_uint16("country", ps, depth, &info->country))
2394                 return False;
2395         if (!prs_uint16("codepage", ps, depth, &info->codepage))
2396                 return False;
2397
2398         if (!smb_io_bufhdr2("hdr_priv_data", &hdr_priv_data, ps, depth))
2399                 return False;
2400         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2401                 return False;
2402         if (!smb_io_unihdr("hdr_profile", &info->hdr_profile, ps, depth))
2403                 return False;
2404
2405         for (i = 0; i < 3; i++)
2406         {
2407                 if (!smb_io_unihdr("hdr_reserved", &info->hdr_reserved[i],
2408                                    ps, depth))
2409                         return False;
2410         }
2411
2412         for (i = 0; i < 4; i++)
2413         {
2414                 if (!prs_uint32("dw_reserved", ps, depth,
2415                                 &info->dw_reserved[i]))
2416                         return False;
2417         }
2418
2419         if (!smb_io_unistr2("uni_acct_name", &info->uni_acct_name,
2420                             info->hdr_acct_name.buffer, ps, depth))
2421                 return False;
2422         prs_align(ps);
2423         if (!smb_io_unistr2("uni_full_name", &info->uni_full_name,
2424                             info->hdr_full_name.buffer, ps, depth))
2425                 return False;
2426         prs_align(ps);
2427         if (!smb_io_unistr2("uni_home_dir ", &info->uni_home_dir,
2428                             info->hdr_home_dir.buffer, ps, depth))
2429                 return False;
2430         prs_align(ps);
2431         if (!smb_io_unistr2("uni_dir_drive", &info->uni_dir_drive,
2432                             info->hdr_dir_drive.buffer, ps, depth))
2433                 return False;
2434         prs_align(ps);
2435         if (!smb_io_unistr2("uni_logon_script", &info->uni_logon_script,
2436                             info->hdr_logon_script.buffer, ps, depth))
2437                 return False;
2438         prs_align(ps);
2439         if (!smb_io_unistr2("uni_acct_desc", &info->uni_acct_desc,
2440                             info->hdr_acct_desc.buffer, ps, depth))
2441                 return False;
2442         prs_align(ps);
2443         if (!smb_io_unistr2("uni_workstations", &info->uni_workstations,
2444                             info->hdr_workstations.buffer, ps, depth))
2445                 return False;
2446         prs_align(ps);
2447
2448         if (!prs_uint32("unknown1", ps, depth, &info->unknown1))
2449                 return False;
2450         if (!prs_uint32("unknown2", ps, depth, &info->unknown2))
2451                 return False;
2452
2453         if (!smb_io_rpc_blob("buf_logon_hrs", &info->buf_logon_hrs, ps, depth))
2454                 return False;
2455         prs_align(ps);
2456         if (!smb_io_unistr2("uni_comment", &info->uni_comment,
2457                             info->hdr_comment.buffer, ps, depth))
2458                 return False;
2459         prs_align(ps);
2460         if (!smb_io_unistr2("uni_parameters", &info->uni_parameters,
2461                             info->hdr_parameters.buffer, ps, depth))
2462                 return False;
2463         prs_align(ps);
2464         if (hdr_priv_data.buffer != 0)
2465         {
2466                 int old_offset = 0;
2467                 uint32 len = 0x44;
2468                 if (!prs_uint32("pwd_len", ps, depth, &len))
2469                         return False;
2470                 old_offset = ps->data_offset;
2471                 if (len > 0)
2472                 {
2473                         if (ps->io)
2474                         {
2475                                 /* reading */
2476                                 if (!prs_hash1(ps, ps->data_offset, len))
2477                                         return False;
2478                         }
2479                         if (!net_io_sam_passwd_info("pass", &info->pass,
2480                                                     ps, depth))
2481                                 return False;
2482
2483                         if (!ps->io)
2484                         {
2485                                 /* writing */
2486                                 if (!prs_hash1(ps, old_offset, len))
2487                                         return False;
2488                         }
2489                 }
2490                 if (old_offset + len > ps->buffer_size)
2491                         return False;
2492                 ps->data_offset = old_offset + len;
2493         }
2494         if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2495                 return False;
2496         prs_align(ps);
2497         if (!smb_io_unistr2("uni_profile", &info->uni_profile,
2498                             info->hdr_profile.buffer, ps, depth))
2499                 return False;
2500
2501         prs_align(ps);
2502
2503         return True;
2504 }
2505
2506 /*******************************************************************
2507 reads or writes a structure.
2508 ********************************************************************/
2509 static BOOL net_io_sam_group_mem_info(const char *desc, SAM_GROUP_MEM_INFO * info,
2510                                       prs_struct *ps, int depth)
2511 {
2512         uint32 i;
2513         fstring tmp;
2514
2515         prs_debug(ps, depth, desc, "net_io_sam_group_mem_info");
2516         depth++;
2517
2518         prs_align(ps);
2519         if (!prs_uint32("ptr_rids   ", ps, depth, &info->ptr_rids))
2520                 return False;
2521         if (!prs_uint32("ptr_attribs", ps, depth, &info->ptr_attribs))
2522                 return False;
2523         if (!prs_uint32("num_members", ps, depth, &info->num_members))
2524                 return False;
2525
2526         if (ps->data_offset + 16 > ps->buffer_size)
2527                 return False;
2528         ps->data_offset += 16;
2529
2530         if (info->ptr_rids != 0)
2531         {
2532                 if (!prs_uint32("num_members2", ps, depth,
2533                                 &info->num_members2))
2534                         return False;
2535
2536                 if (info->num_members2 != info->num_members)
2537                 {
2538                         /* RPC fault */
2539                         return False;
2540                 }
2541
2542                 info->rids = TALLOC_ARRAY(ps->mem_ctx, uint32, info->num_members2);
2543
2544                 if (info->rids == NULL) {
2545                         DEBUG(0, ("out of memory allocating %d rids\n",
2546                                   info->num_members2));
2547                         return False;
2548                 }
2549
2550                 for (i = 0; i < info->num_members2; i++)
2551                 {
2552                         slprintf(tmp, sizeof(tmp) - 1, "rids[%02d]", i);
2553                         if (!prs_uint32(tmp, ps, depth, &info->rids[i]))
2554                                 return False;
2555                 }
2556         }
2557
2558         if (info->ptr_attribs != 0)
2559         {
2560                 if (!prs_uint32("num_members3", ps, depth,
2561                                 &info->num_members3))
2562                         return False;
2563                 if (info->num_members3 != info->num_members)
2564                 {
2565                         /* RPC fault */
2566                         return False;
2567                 }
2568
2569                 info->attribs = TALLOC_ARRAY(ps->mem_ctx, uint32, info->num_members3);
2570
2571                 if (info->attribs == NULL) {
2572                         DEBUG(0, ("out of memory allocating %d attribs\n",
2573                                   info->num_members3));
2574                         return False;
2575                 }
2576
2577                 for (i = 0; i < info->num_members3; i++)
2578                 {
2579                         slprintf(tmp, sizeof(tmp) - 1, "attribs[%02d]", i);
2580                         if (!prs_uint32(tmp, ps, depth, &info->attribs[i]))
2581                                 return False;
2582                 }
2583         }
2584
2585         return True;
2586 }
2587
2588 /*******************************************************************
2589 reads or writes a structure.
2590 ********************************************************************/
2591 static BOOL net_io_sam_alias_info(const char *desc, SAM_ALIAS_INFO * info,
2592                                   prs_struct *ps, int depth)
2593 {
2594         prs_debug(ps, depth, desc, "net_io_sam_alias_info");
2595         depth++;
2596
2597         if (!smb_io_unihdr("hdr_als_name", &info->hdr_als_name, ps, depth))
2598                 return False;
2599         if (!prs_uint32("als_rid", ps, depth, &info->als_rid))
2600                 return False;
2601         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2602                 return False;
2603         if (!smb_io_unihdr("hdr_als_desc", &info->hdr_als_desc, ps, depth))
2604                 return False;
2605
2606         if (ps->data_offset + 40 > ps->buffer_size)
2607                 return False;
2608         ps->data_offset += 40;
2609
2610         if (!smb_io_unistr2("uni_als_name", &info->uni_als_name,
2611                             info->hdr_als_name.buffer, ps, depth))
2612                 return False;
2613         if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2614                 return False;
2615
2616         if (!smb_io_unistr2("uni_als_desc", &info->uni_als_desc,
2617                             info->hdr_als_desc.buffer, ps, depth))
2618                 return False;
2619
2620         return True;
2621 }
2622
2623 /*******************************************************************
2624 reads or writes a structure.
2625 ********************************************************************/
2626 static BOOL net_io_sam_alias_mem_info(const char *desc, SAM_ALIAS_MEM_INFO * info,
2627                                       prs_struct *ps, int depth)
2628 {
2629         uint32 i;
2630         fstring tmp;
2631
2632         prs_debug(ps, depth, desc, "net_io_sam_alias_mem_info");
2633         depth++;
2634
2635         prs_align(ps);
2636         if (!prs_uint32("num_members", ps, depth, &info->num_members))
2637                 return False;
2638         if (!prs_uint32("ptr_members", ps, depth, &info->ptr_members))
2639                 return False;
2640
2641         if (ps->data_offset + 16 > ps->buffer_size)
2642                 return False;
2643         ps->data_offset += 16;
2644
2645         if (info->ptr_members != 0)
2646         {
2647                 if (!prs_uint32("num_sids", ps, depth, &info->num_sids))
2648                         return False;
2649                 if (info->num_sids != info->num_members)
2650                 {
2651                         /* RPC fault */
2652                         return False;
2653                 }
2654
2655                 info->ptr_sids = TALLOC_ARRAY(ps->mem_ctx, uint32, info->num_sids);
2656
2657                 if (info->ptr_sids == NULL) {
2658                         DEBUG(0, ("out of memory allocating %d ptr_sids\n",
2659                                   info->num_sids));
2660                         return False;
2661                 }
2662
2663                 for (i = 0; i < info->num_sids; i++)
2664                 {
2665                         slprintf(tmp, sizeof(tmp) - 1, "ptr_sids[%02d]", i);
2666                         if (!prs_uint32(tmp, ps, depth, &info->ptr_sids[i]))
2667                                 return False;
2668                 }
2669
2670                 info->sids = TALLOC_ARRAY(ps->mem_ctx, DOM_SID2, info->num_sids);
2671
2672                 if (info->sids == NULL) {
2673                         DEBUG(0, ("error allocating %d sids\n",
2674                                   info->num_sids));
2675                         return False;
2676                 }
2677
2678                 for (i = 0; i < info->num_sids; i++)
2679                 {
2680                         if (info->ptr_sids[i] != 0)
2681                         {
2682                                 slprintf(tmp, sizeof(tmp) - 1, "sids[%02d]",
2683                                          i);
2684                                 if (!smb_io_dom_sid2(tmp, &info->sids[i],
2685                                                      ps, depth))
2686                                         return False;
2687                         }
2688                 }
2689         }
2690
2691         return True;
2692 }
2693
2694 /*******************************************************************
2695 reads or writes a structure.
2696 ********************************************************************/
2697 static BOOL net_io_sam_policy_info(const char *desc, SAM_DELTA_POLICY *info,
2698                                       prs_struct *ps, int depth)
2699 {
2700         unsigned int i;
2701         prs_debug(ps, depth, desc, "net_io_sam_policy_info");
2702         depth++;
2703
2704         if(!prs_align(ps))
2705                 return False;
2706
2707         if (!prs_uint32("max_log_size", ps, depth, &info->max_log_size))
2708                 return False;
2709         if (!prs_uint64("audit_retention_period", ps, depth,
2710                         &info->audit_retention_period))
2711                 return False;
2712         if (!prs_uint32("auditing_mode", ps, depth, &info->auditing_mode))
2713                 return False;
2714         if (!prs_uint32("num_events", ps, depth, &info->num_events))
2715                 return False;
2716         if (!prs_uint32("ptr_events", ps, depth, &info->ptr_events))
2717                 return False;
2718
2719         if (!smb_io_unihdr("hdr_dom_name", &info->hdr_dom_name, ps, depth))
2720                 return False;
2721
2722         if (!prs_uint32("sid_ptr", ps, depth, &info->sid_ptr))
2723                 return False;
2724
2725         if (!prs_uint32("paged_pool_limit", ps, depth, &info->paged_pool_limit))
2726                 return False;
2727         if (!prs_uint32("non_paged_pool_limit", ps, depth,
2728                         &info->non_paged_pool_limit))
2729                 return False;
2730         if (!prs_uint32("min_workset_size", ps, depth, &info->min_workset_size))
2731                 return False;
2732         if (!prs_uint32("max_workset_size", ps, depth, &info->max_workset_size))
2733                 return False;
2734         if (!prs_uint32("page_file_limit", ps, depth, &info->page_file_limit))
2735                 return False;
2736         if (!prs_uint64("time_limit", ps, depth, &info->time_limit))
2737                 return False;
2738         if (!smb_io_time("modify_time", &info->modify_time, ps, depth))
2739                 return False;
2740         if (!smb_io_time("create_time", &info->create_time, ps, depth))
2741                 return False;
2742         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2743                 return False;
2744
2745         for (i=0; i<4; i++) {
2746                 UNIHDR dummy;
2747                 if (!smb_io_unihdr("dummy", &dummy, ps, depth))
2748                         return False;
2749         }
2750
2751         for (i=0; i<4; i++) {
2752                 uint32 reserved;
2753                 if (!prs_uint32("reserved", ps, depth, &reserved))
2754                         return False;
2755         }
2756
2757         if (!prs_uint32("num_event_audit_options", ps, depth,
2758                         &info->num_event_audit_options))
2759                 return False;
2760
2761         for (i=0; i<info->num_event_audit_options; i++)
2762                 if (!prs_uint32("event_audit_option", ps, depth,
2763                                 &info->event_audit_option))
2764                         return False;
2765
2766         if (!smb_io_unistr2("domain_name", &info->domain_name, True, ps, depth))
2767                 return False;
2768
2769         if(!smb_io_dom_sid2("domain_sid", &info->domain_sid, ps, depth))
2770                 return False;
2771
2772         if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2773
2774                 return False;
2775
2776         return True;
2777 }
2778
2779 #if 0
2780
2781 /* This function is pretty broken - see bug #334 */
2782
2783 /*******************************************************************
2784 reads or writes a structure.
2785 ********************************************************************/
2786 static BOOL net_io_sam_trustdoms_info(const char *desc, SAM_DELTA_TRUSTDOMS *info,
2787                                       prs_struct *ps, int depth)
2788 {
2789         int i;
2790
2791         prs_debug(ps, depth, desc, "net_io_sam_trustdoms_info");
2792         depth++;
2793
2794         if(!prs_align(ps))
2795                 return False;
2796
2797         if(!prs_uint32("buf_size", ps, depth, &info->buf_size))
2798                 return False;
2799
2800         if(!sec_io_desc("sec_desc", &info->sec_desc, ps, depth))
2801                 return False;
2802
2803         if(!smb_io_dom_sid2("sid", &info->sid, ps, depth))
2804                 return False;
2805
2806         if(!smb_io_unihdr("hdr_domain", &info->hdr_domain, ps, depth))
2807                 return False;
2808
2809         if(!prs_uint32("unknown0", ps, depth, &info->unknown0))
2810                 return False;
2811         if(!prs_uint32("unknown1", ps, depth, &info->unknown1))
2812                 return False;
2813         if(!prs_uint32("unknown2", ps, depth, &info->unknown2))
2814                 return False;
2815
2816         if(!prs_uint32("buf_size2", ps, depth, &info->buf_size2))
2817                 return False;
2818         if(!prs_uint32("ptr", ps, depth, &info->ptr))
2819                 return False;
2820
2821         for (i=0; i<12; i++)
2822                 if(!prs_uint32("unknown3", ps, depth, &info->unknown3))
2823                         return False;
2824
2825         if (!smb_io_unistr2("domain", &info->domain, True, ps, depth))
2826                 return False;
2827
2828         return True;
2829 }
2830
2831 #endif
2832
2833 #if 0
2834
2835 /* This function doesn't work - see bug #334 */
2836
2837 /*******************************************************************
2838 reads or writes a structure.
2839 ********************************************************************/
2840 static BOOL net_io_sam_secret_info(const char *desc, SAM_DELTA_SECRET *info,
2841                                    prs_struct *ps, int depth)
2842 {
2843         int i;
2844
2845         prs_debug(ps, depth, desc, "net_io_sam_secret_info");
2846         depth++;
2847
2848         if(!prs_align(ps))
2849                 return False;
2850
2851         if(!prs_uint32("buf_size", ps, depth, &info->buf_size))
2852                 return False;
2853
2854         if(!sec_io_desc("sec_desc", &info->sec_desc, ps, depth))
2855                 return False;
2856
2857         if (!smb_io_unistr2("secret", &info->secret, True, ps, depth))
2858                 return False;
2859
2860         if(!prs_align(ps))
2861                 return False;
2862
2863         if(!prs_uint32("count1", ps, depth, &info->count1))
2864                 return False;
2865         if(!prs_uint32("count2", ps, depth, &info->count2))
2866                 return False;
2867         if(!prs_uint32("ptr", ps, depth, &info->ptr))
2868                 return False;
2869
2870
2871         if(!smb_io_time("time1", &info->time1, ps, depth)) /* logon time */
2872                 return False;
2873         if(!prs_uint32("count3", ps, depth, &info->count3))
2874                 return False;
2875         if(!prs_uint32("count4", ps, depth, &info->count4))
2876                 return False;
2877         if(!prs_uint32("ptr2", ps, depth, &info->ptr2))
2878                 return False;
2879         if(!smb_io_time("time2", &info->time2, ps, depth)) /* logon time */
2880                 return False;
2881         if(!prs_uint32("unknow1", ps, depth, &info->unknow1))
2882                 return False;
2883
2884
2885         if(!prs_uint32("buf_size2", ps, depth, &info->buf_size2))
2886                 return False;
2887         if(!prs_uint32("ptr3", ps, depth, &info->ptr3))
2888                 return False;
2889         for(i=0; i<12; i++)
2890                 if(!prs_uint32("unknow2", ps, depth, &info->unknow2))
2891                         return False;
2892
2893         if(!prs_uint32("chal_len", ps, depth, &info->chal_len))
2894                 return False;
2895         if(!prs_uint32("reserved1", ps, depth, &info->reserved1))
2896                 return False;
2897         if(!prs_uint32("chal_len2", ps, depth, &info->chal_len2))
2898                 return False;
2899
2900         if(!prs_uint8s (False, "chal", ps, depth, info->chal, info->chal_len2))
2901                 return False;
2902
2903         if(!prs_uint32("key_len", ps, depth, &info->key_len))
2904                 return False;
2905         if(!prs_uint32("reserved2", ps, depth, &info->reserved2))
2906                 return False;
2907         if(!prs_uint32("key_len2", ps, depth, &info->key_len2))
2908                 return False;
2909
2910         if(!prs_uint8s (False, "key", ps, depth, info->key, info->key_len2))
2911                 return False;
2912
2913
2914         if(!prs_uint32("buf_size3", ps, depth, &info->buf_size3))
2915                 return False;
2916
2917         if(!sec_io_desc("sec_desc2", &info->sec_desc2, ps, depth))
2918                 return False;
2919
2920
2921         return True;
2922 }
2923
2924 #endif
2925
2926 /*******************************************************************
2927 reads or writes a structure.
2928 ********************************************************************/
2929 static BOOL net_io_sam_privs_info(const char *desc, SAM_DELTA_PRIVS *info,
2930                                       prs_struct *ps, int depth)
2931 {
2932         unsigned int i;
2933
2934         prs_debug(ps, depth, desc, "net_io_sam_privs_info");
2935         depth++;
2936
2937         if(!prs_align(ps))
2938                 return False;
2939
2940         if(!smb_io_dom_sid2("sid", &info->sid, ps, depth))
2941                 return False;
2942
2943         if(!prs_uint32("priv_count", ps, depth, &info->priv_count))
2944                 return False;
2945         if(!prs_uint32("priv_control", ps, depth, &info->priv_control))
2946                 return False;
2947
2948         if(!prs_uint32("priv_attr_ptr", ps, depth, &info->priv_attr_ptr))
2949                 return False;
2950         if(!prs_uint32("priv_name_ptr", ps, depth, &info->priv_name_ptr))
2951                 return False;
2952
2953         if (!prs_uint32("paged_pool_limit", ps, depth, &info->paged_pool_limit))
2954                 return False;
2955         if (!prs_uint32("non_paged_pool_limit", ps, depth,
2956                         &info->non_paged_pool_limit))
2957                 return False;
2958         if (!prs_uint32("min_workset_size", ps, depth, &info->min_workset_size))
2959                 return False;
2960         if (!prs_uint32("max_workset_size", ps, depth, &info->max_workset_size))
2961                 return False;
2962         if (!prs_uint32("page_file_limit", ps, depth, &info->page_file_limit))
2963                 return False;
2964         if (!prs_uint64("time_limit", ps, depth, &info->time_limit))
2965                 return False;
2966         if (!prs_uint32("system_flags", ps, depth, &info->system_flags))
2967                 return False;
2968         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2969                 return False;
2970
2971         for (i=0; i<4; i++) {
2972                 UNIHDR dummy;
2973                 if (!smb_io_unihdr("dummy", &dummy, ps, depth))
2974                         return False;
2975         }
2976
2977         for (i=0; i<4; i++) {
2978                 uint32 reserved;
2979                 if (!prs_uint32("reserved", ps, depth, &reserved))
2980                         return False;
2981         }
2982
2983         if(!prs_uint32("attribute_count", ps, depth, &info->attribute_count))
2984                 return False;
2985
2986         info->attributes = TALLOC_ARRAY(ps->mem_ctx, uint32, info->attribute_count);
2987
2988         for (i=0; i<info->attribute_count; i++)
2989                 if(!prs_uint32("attributes", ps, depth, &info->attributes[i]))
2990                         return False;
2991
2992         if(!prs_uint32("privlist_count", ps, depth, &info->privlist_count))
2993                 return False;
2994
2995         info->hdr_privslist = TALLOC_ARRAY(ps->mem_ctx, UNIHDR, info->privlist_count);
2996         info->uni_privslist = TALLOC_ARRAY(ps->mem_ctx, UNISTR2, info->privlist_count);
2997
2998         for (i=0; i<info->privlist_count; i++)
2999                 if(!smb_io_unihdr("hdr_privslist", &info->hdr_privslist[i], ps, depth))
3000                         return False;
3001
3002         for (i=0; i<info->privlist_count; i++)
3003                 if (!smb_io_unistr2("uni_privslist", &info->uni_privslist[i], True, ps, depth))
3004                         return False;
3005
3006         if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
3007                 return False;
3008
3009         return True;
3010 }
3011
3012 /*******************************************************************
3013 reads or writes a structure.
3014 ********************************************************************/
3015 static BOOL net_io_sam_delta_ctr(const char *desc,
3016                                  SAM_DELTA_CTR * delta, uint16 type,
3017                                  prs_struct *ps, int depth)
3018 {
3019         prs_debug(ps, depth, desc, "net_io_sam_delta_ctr");
3020         depth++;
3021
3022         switch (type) {
3023                 /* Seen in sam deltas */
3024                 case SAM_DELTA_MODIFIED_COUNT:
3025                         if (!net_io_sam_delta_mod_count("", &delta->mod_count, ps, depth))
3026                                 return False;
3027                         break;
3028
3029                 case SAM_DELTA_DOMAIN_INFO:
3030                         if (!net_io_sam_domain_info("", &delta->domain_info, ps, depth))
3031                                 return False;
3032                         break;
3033
3034                 case SAM_DELTA_GROUP_INFO:
3035                         if (!net_io_sam_group_info("", &delta->group_info, ps, depth))
3036                                 return False;
3037                         break;
3038
3039                 case SAM_DELTA_ACCOUNT_INFO:
3040                         if (!net_io_sam_account_info("", &delta->account_info, ps, depth))
3041                                 return False;
3042                         break;
3043
3044                 case SAM_DELTA_GROUP_MEM:
3045                         if (!net_io_sam_group_mem_info("", &delta->grp_mem_info, ps, depth))
3046                                 return False;
3047                         break;
3048
3049                 case SAM_DELTA_ALIAS_INFO:
3050                         if (!net_io_sam_alias_info("", &delta->alias_info, ps, depth))
3051                                 return False;
3052                         break;
3053
3054                 case SAM_DELTA_POLICY_INFO:
3055                         if (!net_io_sam_policy_info("", &delta->policy_info, ps, depth))
3056                                 return False;
3057                         break;
3058
3059                 case SAM_DELTA_ALIAS_MEM:
3060                         if (!net_io_sam_alias_mem_info("", &delta->als_mem_info, ps, depth))
3061                                 return False;
3062                         break;
3063
3064                 case SAM_DELTA_PRIVS_INFO:
3065                         if (!net_io_sam_privs_info("", &delta->privs_info, ps, depth))
3066                                 return False;
3067                         break;
3068
3069                         /* These guys are implemented but broken */
3070
3071                 case SAM_DELTA_TRUST_DOMS:
3072                 case SAM_DELTA_SECRET_INFO:
3073                         break;
3074
3075                         /* These guys are not implemented yet */
3076
3077                 case SAM_DELTA_RENAME_GROUP:
3078                 case SAM_DELTA_RENAME_USER:
3079                 case SAM_DELTA_RENAME_ALIAS:
3080                 case SAM_DELTA_DELETE_GROUP:
3081                 case SAM_DELTA_DELETE_USER:
3082                 default:
3083                         DEBUG(0, ("Replication error: Unknown delta type 0x%x\n", type));
3084                         break;
3085         }
3086
3087         return True;
3088 }
3089
3090 /*******************************************************************
3091 reads or writes a structure.
3092 ********************************************************************/
3093 BOOL net_io_r_sam_sync(const char *desc,
3094                        NET_R_SAM_SYNC * r_s, prs_struct *ps, int depth)
3095 {
3096         uint32 i;
3097
3098         prs_debug(ps, depth, desc, "net_io_r_sam_sync");
3099         depth++;
3100
3101         if (!smb_io_cred("srv_creds", &r_s->srv_creds, ps, depth))
3102                 return False;
3103         if (!prs_uint32("sync_context", ps, depth, &r_s->sync_context))
3104                 return False;
3105
3106         if (!prs_uint32("ptr_deltas", ps, depth, &r_s->ptr_deltas))
3107                 return False;
3108         if (r_s->ptr_deltas != 0)
3109         {
3110                 if (!prs_uint32("num_deltas ", ps, depth, &r_s->num_deltas))
3111                         return False;
3112                 if (!prs_uint32("ptr_deltas2", ps, depth, &r_s->ptr_deltas2))
3113                         return False;
3114                 if (r_s->ptr_deltas2 != 0)
3115                 {
3116                         if (!prs_uint32("num_deltas2", ps, depth,
3117                                         &r_s->num_deltas2))
3118                                 return False;
3119
3120                         if (r_s->num_deltas2 != r_s->num_deltas)
3121                         {
3122                                 /* RPC fault */
3123                                 return False;
3124                         }
3125
3126                         if (r_s->num_deltas2 > 0) {
3127                                 r_s->hdr_deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_HDR, r_s->num_deltas2);
3128                                 if (r_s->hdr_deltas == NULL) {
3129                                         DEBUG(0, ("error tallocating memory "
3130                                                   "for %d delta headers\n",
3131                                                   r_s->num_deltas2));
3132                                         return False;
3133                                 }
3134                         }
3135
3136                         for (i = 0; i < r_s->num_deltas2; i++)
3137                         {
3138                                 if (!net_io_sam_delta_hdr("",
3139                                                           &r_s->hdr_deltas[i],
3140                                                           ps, depth))
3141                                         return False;
3142                         }
3143
3144                         if (r_s->num_deltas2 > 0) {
3145                                 r_s->deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_CTR, r_s->num_deltas2);
3146                                 if (r_s->deltas == NULL) {
3147                                         DEBUG(0, ("error tallocating memory "
3148                                                   "for %d deltas\n",
3149                                                   r_s->num_deltas2));
3150                                         return False;
3151                                 }
3152                         }
3153
3154                         for (i = 0; i < r_s->num_deltas2; i++)
3155                         {
3156                                 if (!net_io_sam_delta_ctr(
3157                                         "", &r_s->deltas[i],
3158                                         r_s->hdr_deltas[i].type3,
3159                                         ps, depth)) {
3160                                         DEBUG(0, ("hmm, failed on i=%d\n", i));
3161                                         return False;
3162                                 }
3163                         }
3164                 }
3165         }
3166
3167         prs_align(ps);
3168         if (!prs_ntstatus("status", ps, depth, &(r_s->status)))
3169                 return False;
3170
3171         return True;
3172 }
3173
3174 /*******************************************************************
3175 makes a NET_Q_SAM_DELTAS structure.
3176 ********************************************************************/
3177 BOOL init_net_q_sam_deltas(NET_Q_SAM_DELTAS *q_s, const char *srv_name,
3178                            const char *cli_name, DOM_CRED *cli_creds,
3179                            uint32 database_id, UINT64_S dom_mod_count)
3180 {
3181         DEBUG(5, ("init_net_q_sam_deltas\n"));
3182
3183         init_unistr2(&q_s->uni_srv_name, srv_name, UNI_STR_TERMINATE);
3184         init_unistr2(&q_s->uni_cli_name, cli_name, UNI_STR_TERMINATE);
3185
3186         memcpy(&q_s->cli_creds, cli_creds, sizeof(q_s->cli_creds));
3187         memset(&q_s->ret_creds, 0, sizeof(q_s->ret_creds));
3188
3189         q_s->database_id = database_id;
3190         q_s->dom_mod_count.low = dom_mod_count.low;
3191         q_s->dom_mod_count.high = dom_mod_count.high;
3192         q_s->max_size = 0xffff;
3193
3194         return True;
3195 }
3196
3197 /*******************************************************************
3198 reads or writes a structure.
3199 ********************************************************************/
3200 BOOL net_io_q_sam_deltas(const char *desc, NET_Q_SAM_DELTAS *q_s, prs_struct *ps,
3201                          int depth)
3202 {
3203         prs_debug(ps, depth, desc, "net_io_q_sam_deltas");
3204         depth++;
3205
3206         if (!smb_io_unistr2("", &q_s->uni_srv_name, True, ps, depth))
3207                 return False;
3208         if (!smb_io_unistr2("", &q_s->uni_cli_name, True, ps, depth))
3209                 return False;
3210
3211         if (!smb_io_cred("", &q_s->cli_creds, ps, depth))
3212                 return False;
3213         if (!smb_io_cred("", &q_s->ret_creds, ps, depth))
3214                 return False;
3215
3216         if (!prs_uint32("database_id  ", ps, depth, &q_s->database_id))
3217                 return False;
3218         if (!prs_uint64("dom_mod_count", ps, depth, &q_s->dom_mod_count))
3219                 return False;
3220         if (!prs_uint32("max_size", ps, depth, &q_s->max_size))
3221                 return False;
3222
3223         return True;
3224 }
3225
3226 /*******************************************************************
3227 reads or writes a structure.
3228 ********************************************************************/
3229 BOOL net_io_r_sam_deltas(const char *desc,
3230                          NET_R_SAM_DELTAS *r_s, prs_struct *ps, int depth)
3231 {
3232         unsigned int i;
3233
3234         prs_debug(ps, depth, desc, "net_io_r_sam_deltas");
3235         depth++;
3236
3237         if (!smb_io_cred("srv_creds", &r_s->srv_creds, ps, depth))
3238                 return False;
3239         if (!prs_uint64("dom_mod_count", ps, depth, &r_s->dom_mod_count))
3240                 return False;
3241
3242         if (!prs_uint32("ptr_deltas", ps, depth, &r_s->ptr_deltas))
3243                 return False;
3244         if (!prs_uint32("num_deltas", ps, depth, &r_s->num_deltas))
3245                 return False;
3246         if (!prs_uint32("ptr_deltas2", ps, depth, &r_s->num_deltas2))
3247                 return False;
3248
3249         if (r_s->num_deltas2 != 0)
3250         {
3251                 if (!prs_uint32("num_deltas2 ", ps, depth, &r_s->num_deltas2))
3252                         return False;
3253
3254                 if (r_s->ptr_deltas != 0)
3255                 {
3256                         if (r_s->num_deltas > 0) {
3257                                 r_s->hdr_deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_HDR, r_s->num_deltas);
3258                                 if (r_s->hdr_deltas == NULL) {
3259                                         DEBUG(0, ("error tallocating memory "
3260                                                   "for %d delta headers\n",
3261                                                   r_s->num_deltas));
3262                                         return False;
3263                                 }
3264                         }
3265
3266                         for (i = 0; i < r_s->num_deltas; i++)
3267                         {
3268                                 net_io_sam_delta_hdr("", &r_s->hdr_deltas[i],
3269                                                       ps, depth);
3270                         }
3271
3272                         if (r_s->num_deltas > 0) {
3273                                 r_s->deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_CTR, r_s->num_deltas);
3274                                 if (r_s->deltas == NULL) {
3275                                         DEBUG(0, ("error tallocating memory "
3276                                                   "for %d deltas\n",
3277                                                   r_s->num_deltas));
3278                                         return False;
3279                                 }
3280                         }
3281
3282                         for (i = 0; i < r_s->num_deltas; i++)
3283                         {
3284                                 if (!net_io_sam_delta_ctr(
3285                                         "",
3286                                         &r_s->deltas[i],
3287                                         r_s->hdr_deltas[i].type2,
3288                                         ps, depth))
3289
3290                                         return False;
3291                         }
3292                 }
3293         }
3294
3295         prs_align(ps);
3296         if (!prs_ntstatus("status", ps, depth, &r_s->status))
3297                 return False;
3298
3299         return True;
3300 }
3301
3302 /*******************************************************************
3303  Inits a NET_Q_DSR_GETDCNAME structure.
3304 ********************************************************************/
3305
3306 void init_net_q_dsr_getdcname(NET_Q_DSR_GETDCNAME *r_t, const char *server_unc,
3307                               const char *domain_name,
3308                               struct uuid *domain_guid,
3309                               struct uuid *site_guid,
3310                               uint32_t flags)
3311 {
3312         DEBUG(5, ("init_net_q_dsr_getdcname\n"));
3313
3314         r_t->ptr_server_unc = (server_unc != NULL);
3315         init_unistr2(&r_t->uni_server_unc, server_unc, UNI_STR_TERMINATE);
3316
3317         r_t->ptr_domain_name = (domain_name != NULL);
3318         init_unistr2(&r_t->uni_domain_name, domain_name, UNI_STR_TERMINATE);
3319
3320         r_t->ptr_domain_guid = (domain_guid != NULL);
3321         r_t->domain_guid = domain_guid;
3322
3323         r_t->ptr_site_guid = (site_guid != NULL);
3324         r_t->site_guid = site_guid;
3325
3326         r_t->flags = flags;
3327 }
3328
3329 /*******************************************************************
3330  Reads or writes an NET_Q_DSR_GETDCNAME structure.
3331 ********************************************************************/
3332
3333 BOOL net_io_q_dsr_getdcname(const char *desc, NET_Q_DSR_GETDCNAME *r_t,
3334                             prs_struct *ps, int depth)
3335 {
3336         if (r_t == NULL)
3337                 return False;
3338
3339         prs_debug(ps, depth, desc, "net_io_q_dsr_getdcname");
3340         depth++;
3341
3342         if (!prs_uint32("ptr_server_unc", ps, depth, &r_t->ptr_server_unc))
3343                 return False;
3344
3345         if (!smb_io_unistr2("server_unc", &r_t->uni_server_unc,
3346                             r_t->ptr_server_unc, ps, depth))
3347                 return False;
3348
3349         if (!prs_align(ps))
3350                 return False;
3351
3352         if (!prs_uint32("ptr_domain_name", ps, depth, &r_t->ptr_domain_name))
3353                 return False;
3354
3355         if (!smb_io_unistr2("domain_name", &r_t->uni_domain_name,
3356                             r_t->ptr_domain_name, ps, depth))
3357                 return False;
3358
3359         if (!prs_align(ps))
3360                 return False;
3361
3362         if (!prs_uint32("ptr_domain_guid", ps, depth, &r_t->ptr_domain_guid))
3363                 return False;
3364
3365         if (UNMARSHALLING(ps) && (r_t->ptr_domain_guid)) {
3366                 r_t->domain_guid = PRS_ALLOC_MEM(ps, struct uuid, 1);
3367                 if (r_t->domain_guid == NULL)
3368                         return False;
3369         }
3370
3371         if ((r_t->ptr_domain_guid) &&
3372             (!smb_io_uuid("domain_guid", r_t->domain_guid, ps, depth)))
3373                 return False;
3374
3375         if (!prs_align(ps))
3376                 return False;
3377
3378         if (!prs_uint32("ptr_site_guid", ps, depth, &r_t->ptr_site_guid))
3379                 return False;
3380
3381         if (UNMARSHALLING(ps) && (r_t->ptr_site_guid)) {
3382                 r_t->site_guid = PRS_ALLOC_MEM(ps, struct uuid, 1);
3383                 if (r_t->site_guid == NULL)
3384                         return False;
3385         }
3386
3387         if ((r_t->ptr_site_guid) &&
3388             (!smb_io_uuid("site_guid", r_t->site_guid, ps, depth)))
3389                 return False;
3390
3391         if (!prs_align(ps))
3392                 return False;
3393
3394         if (!prs_uint32("flags", ps, depth, &r_t->flags))
3395                 return False;
3396
3397         return True;
3398 }
3399
3400 /*******************************************************************
3401  Inits a NET_R_DSR_GETDCNAME structure.
3402 ********************************************************************/
3403 void init_net_r_dsr_getdcname(NET_R_DSR_GETDCNAME *r_t, const char *dc_unc,
3404                               const char *dc_address, int32 dc_address_type,
3405                               struct uuid domain_guid, const char *domain_name,
3406                               const char *forest_name, uint32 dc_flags,
3407                               const char *dc_site_name,
3408                               const char *client_site_name)
3409 {
3410         DEBUG(5, ("init_net_q_dsr_getdcname\n"));
3411
3412         r_t->ptr_dc_unc = (dc_unc != NULL);
3413         init_unistr2(&r_t->uni_dc_unc, dc_unc, UNI_STR_TERMINATE);
3414
3415         r_t->ptr_dc_address = (dc_address != NULL);
3416         init_unistr2(&r_t->uni_dc_address, dc_address, UNI_STR_TERMINATE);
3417
3418         r_t->dc_address_type = dc_address_type;
3419         r_t->domain_guid = domain_guid;
3420
3421         r_t->ptr_domain_name = (domain_name != NULL);
3422         init_unistr2(&r_t->uni_domain_name, domain_name, UNI_STR_TERMINATE);
3423
3424         r_t->ptr_forest_name = (forest_name != NULL);
3425         init_unistr2(&r_t->uni_forest_name, forest_name, UNI_STR_TERMINATE);
3426
3427         r_t->dc_flags = dc_flags;
3428
3429         r_t->ptr_dc_site_name = (dc_site_name != NULL);
3430         init_unistr2(&r_t->uni_dc_site_name, dc_site_name, UNI_STR_TERMINATE);
3431
3432         r_t->ptr_client_site_name = (client_site_name != NULL);
3433         init_unistr2(&r_t->uni_client_site_name, client_site_name,
3434                      UNI_STR_TERMINATE);
3435 }
3436
3437 /*******************************************************************
3438  Reads or writes an NET_R_DSR_GETDCNAME structure.
3439 ********************************************************************/
3440
3441 BOOL net_io_r_dsr_getdcname(const char *desc, NET_R_DSR_GETDCNAME *r_t,
3442                             prs_struct *ps, int depth)
3443 {
3444         uint32 info_ptr = 1;
3445
3446         if (r_t == NULL)
3447                 return False;
3448
3449         prs_debug(ps, depth, desc, "net_io_r_dsr_getdcname");
3450         depth++;
3451
3452         /* The reply contains *just* an info struct, this is the ptr to it */
3453         if (!prs_uint32("info_ptr", ps, depth, &info_ptr))
3454                 return False;
3455
3456         if (info_ptr == 0)
3457                 return False;
3458
3459         if (!prs_uint32("ptr_dc_unc", ps, depth, &r_t->ptr_dc_unc))
3460                 return False;
3461
3462         if (!prs_uint32("ptr_dc_address", ps, depth, &r_t->ptr_dc_address))
3463                 return False;
3464
3465         if (!prs_int32("dc_address_type", ps, depth, &r_t->dc_address_type))
3466                 return False;
3467
3468         if (!smb_io_uuid("domain_guid", &r_t->domain_guid, ps, depth))
3469                 return False;
3470
3471         if (!prs_uint32("ptr_domain_name", ps, depth, &r_t->ptr_domain_name))
3472                 return False;
3473
3474         if (!prs_uint32("ptr_forest_name", ps, depth, &r_t->ptr_forest_name))
3475                 return False;
3476
3477         if (!prs_uint32("dc_flags", ps, depth, &r_t->dc_flags))
3478                 return False;
3479
3480         if (!prs_uint32("ptr_dc_site_name", ps, depth, &r_t->ptr_dc_site_name))
3481                 return False;
3482
3483         if (!prs_uint32("ptr_client_site_name", ps, depth,
3484                         &r_t->ptr_client_site_name))
3485                 return False;
3486
3487         if (!prs_align(ps))
3488                 return False;
3489
3490         if (!smb_io_unistr2("dc_unc", &r_t->uni_dc_unc,
3491                             r_t->ptr_dc_unc, ps, depth))
3492                 return False;
3493
3494         if (!prs_align(ps))
3495                 return False;
3496
3497         if (!smb_io_unistr2("dc_address", &r_t->uni_dc_address,
3498                             r_t->ptr_dc_address, ps, depth))
3499                 return False;
3500
3501         if (!prs_align(ps))
3502                 return False;
3503
3504         if (!smb_io_unistr2("domain_name", &r_t->uni_domain_name,
3505                             r_t->ptr_domain_name, ps, depth))
3506                 return False;
3507
3508         if (!prs_align(ps))
3509                 return False;
3510
3511         if (!smb_io_unistr2("forest_name", &r_t->uni_forest_name,
3512                             r_t->ptr_forest_name, ps, depth))
3513                 return False;
3514
3515         if (!prs_align(ps))
3516                 return False;
3517
3518         if (!smb_io_unistr2("dc_site_name", &r_t->uni_dc_site_name,
3519                             r_t->ptr_dc_site_name, ps, depth))
3520                 return False;
3521
3522         if (!prs_align(ps))
3523                 return False;
3524
3525         if (!smb_io_unistr2("client_site_name", &r_t->uni_client_site_name,
3526                             r_t->ptr_client_site_name, ps, depth))
3527                 return False;
3528
3529         if (!prs_align(ps))
3530                 return False;
3531
3532         if (!prs_werror("result", ps, depth, &r_t->result))
3533                 return False;
3534
3535         return True;
3536 }
3537
3538 /*******************************************************************
3539  Inits a NET_Q_DSR_GETSITENAME structure.
3540 ********************************************************************/
3541
3542 void init_net_q_dsr_getsitename(NET_Q_DSR_GETSITENAME *r_t, const char *computer_name)
3543 {
3544         DEBUG(5, ("init_net_q_dsr_getsitename\n"));
3545
3546         r_t->ptr_computer_name = (computer_name != NULL);
3547         init_unistr2(&r_t->uni_computer_name, computer_name, UNI_STR_TERMINATE);
3548 }
3549
3550 /*******************************************************************
3551  Reads or writes an NET_Q_DSR_GETSITENAME structure.
3552 ********************************************************************/
3553
3554 BOOL net_io_q_dsr_getsitename(const char *desc, NET_Q_DSR_GETSITENAME *r_t,
3555                               prs_struct *ps, int depth)
3556 {
3557         if (r_t == NULL)
3558                 return False;
3559
3560         prs_debug(ps, depth, desc, "net_io_q_dsr_getsitename");
3561         depth++;
3562
3563         if (!prs_uint32("ptr_computer_name", ps, depth, &r_t->ptr_computer_name))
3564                 return False;
3565
3566         if (!smb_io_unistr2("computer_name", &r_t->uni_computer_name,
3567                             r_t->ptr_computer_name, ps, depth))
3568                 return False;
3569
3570         if (!prs_align(ps))
3571                 return False;
3572
3573         return True;
3574 }
3575
3576 /*******************************************************************
3577  Reads or writes an NET_R_DSR_GETSITENAME structure.
3578 ********************************************************************/
3579
3580 BOOL net_io_r_dsr_getsitename(const char *desc, NET_R_DSR_GETSITENAME *r_t,
3581                               prs_struct *ps, int depth)
3582 {
3583         if (r_t == NULL)
3584                 return False;
3585
3586         prs_debug(ps, depth, desc, "net_io_r_dsr_getsitename");
3587         depth++;
3588
3589         if (!prs_uint32("ptr_site_name", ps, depth, &r_t->ptr_site_name))
3590                 return False;
3591
3592         if (!prs_align(ps))
3593                 return False;
3594
3595         if (!smb_io_unistr2("site_name", &r_t->uni_site_name,
3596                             r_t->ptr_site_name, ps, depth))
3597                 return False;
3598
3599         if (!prs_align(ps))
3600                 return False;
3601
3602         if (!prs_werror("result", ps, depth, &r_t->result))
3603                 return False;
3604
3605         return True;
3606 }
3607
3608