source/rpc_parse/parse_net.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-1997,
   5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   6  *  Copyright (C) Paul Ashton                       1997.
   7  *  Copyright (C) Jean François Micouleau           2002.
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include "includes.h"
  25
  26 #undef DBGC_CLASS
  27 #define DBGC_CLASS DBGC_RPC_PARSE
  28
  29 /*******************************************************************
  30  Reads or writes a structure.
  31 ********************************************************************/
  32
  33 static BOOL net_io_neg_flags(const char *desc, NEG_FLAGS *neg, prs_struct *ps, int depth)
  34 {
  35         if (neg == NULL)
  36                 return False;
  37
  38         prs_debug(ps, depth, desc, "net_io_neg_flags");
  39         depth++;
  40
  41         if(!prs_align(ps))
  42                 return False;
  43
  44         if(!prs_uint32("neg_flags", ps, depth, &neg->neg_flags))
  45                 return False;
  46
  47         return True;
  48 }
  49
  50 /*******************************************************************
  51  Inits a NETLOGON_INFO_3 structure.
  52 ********************************************************************/
  53
  54 static void init_netinfo_3(NETLOGON_INFO_3 *info, uint32 flags, uint32 logon_attempts)
  55 {
  56         info->flags          = flags;
  57         info->logon_attempts = logon_attempts;
  58         info->reserved_1     = 0x0;
  59         info->reserved_2     = 0x0;
  60         info->reserved_3     = 0x0;
  61         info->reserved_4     = 0x0;
  62         info->reserved_5     = 0x0;
  63 }
  64
  65 /*******************************************************************
  66  Reads or writes a NETLOGON_INFO_3 structure.
  67 ********************************************************************/
  68
  69 static BOOL net_io_netinfo_3(const char *desc,  NETLOGON_INFO_3 *info, prs_struct *ps, int depth)
  70 {
  71         if (info == NULL)
  72                 return False;
  73
  74         prs_debug(ps, depth, desc, "net_io_netinfo_3");
  75         depth++;
  76
  77         if(!prs_align(ps))
  78                 return False;
  79
  80         if(!prs_uint32("flags         ", ps, depth, &info->flags))
  81                 return False;
  82         if(!prs_uint32("logon_attempts", ps, depth, &info->logon_attempts))
  83                 return False;
  84         if(!prs_uint32("reserved_1    ", ps, depth, &info->reserved_1))
  85                 return False;
  86         if(!prs_uint32("reserved_2    ", ps, depth, &info->reserved_2))
  87                 return False;
  88         if(!prs_uint32("reserved_3    ", ps, depth, &info->reserved_3))
  89                 return False;
  90         if(!prs_uint32("reserved_4    ", ps, depth, &info->reserved_4))
  91                 return False;
  92         if(!prs_uint32("reserved_5    ", ps, depth, &info->reserved_5))
  93                 return False;
  94
  95         return True;
  96 }
  97
  98
  99 /*******************************************************************
 100  Inits a NETLOGON_INFO_1 structure.
 101 ********************************************************************/
 102
 103 static void init_netinfo_1(NETLOGON_INFO_1 *info, uint32 flags, uint32 pdc_status)
 104 {
 105         info->flags      = flags;
 106         info->pdc_status = pdc_status;
 107 }
 108
 109 /*******************************************************************
 110  Reads or writes a NETLOGON_INFO_1 structure.
 111 ********************************************************************/
 112
 113 static BOOL net_io_netinfo_1(const char *desc, NETLOGON_INFO_1 *info, prs_struct *ps, int depth)
 114 {
 115         if (info == NULL)
 116                 return False;
 117
 118         prs_debug(ps, depth, desc, "net_io_netinfo_1");
 119         depth++;
 120
 121         if(!prs_align(ps))
 122                 return False;
 123
 124         if(!prs_uint32("flags     ", ps, depth, &info->flags))
 125                 return False;
 126         if(!prs_uint32("pdc_status", ps, depth, &info->pdc_status))
 127                 return False;
 128
 129         return True;
 130 }
 131
 132 /*******************************************************************
 133  Inits a NETLOGON_INFO_2 structure.
 134 ********************************************************************/
 135
 136 static void init_netinfo_2(NETLOGON_INFO_2 *info, uint32 flags, uint32 pdc_status,
 137                                 uint32 tc_status, const char *trusted_dc_name)
 138 {
 139         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_srv("", &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, uint32 acct_flags,
1428                          uchar user_session_key[16],
1429                          uchar lm_session_key[16],
1430                          const char *logon_srv, const char *logon_dom,
1431                          const DOM_SID *dom_sid)
1432 {
1433         /* only cope with one "other" sid, right now. */
1434         /* need to count the number of space-delimited sids */
1435         unsigned int i;
1436         int num_other_sids = 0;
1437
1438         NTTIME          logon_time, logoff_time, kickoff_time,
1439                         pass_last_set_time, pass_can_change_time,
1440                         pass_must_change_time;
1441
1442         ZERO_STRUCTP(usr);
1443
1444         usr->ptr_user_info = 1; /* yes, we're bothering to put USER_INFO data here */
1445
1446         /* Create NTTIME structs */
1447         unix_to_nt_time (&logon_time,            unix_logon_time);
1448         unix_to_nt_time (&logoff_time,           unix_logoff_time);
1449         unix_to_nt_time (&kickoff_time,          unix_kickoff_time);
1450         unix_to_nt_time (&pass_last_set_time,    unix_pass_last_set_time);
1451         unix_to_nt_time (&pass_can_change_time,  unix_pass_can_change_time);
1452         unix_to_nt_time (&pass_must_change_time, unix_pass_must_change_time);
1453
1454         usr->logon_time            = logon_time;
1455         usr->logoff_time           = logoff_time;
1456         usr->kickoff_time          = kickoff_time;
1457         usr->pass_last_set_time    = pass_last_set_time;
1458         usr->pass_can_change_time  = pass_can_change_time;
1459         usr->pass_must_change_time = pass_must_change_time;
1460
1461         usr->logon_count = logon_count;
1462         usr->bad_pw_count = bad_pw_count;
1463
1464         usr->user_rid = user_rid;
1465         usr->group_rid = group_rid;
1466         usr->num_groups = num_groups;
1467
1468         usr->buffer_groups = 1; /* indicates fill in groups, below, even if there are none */
1469         usr->user_flgs = user_flgs;
1470         usr->acct_flags = acct_flags;
1471
1472         if (user_session_key != NULL)
1473                 memcpy(usr->user_sess_key, user_session_key, sizeof(usr->user_sess_key));
1474         else
1475                 memset((char *)usr->user_sess_key, '\0', sizeof(usr->user_sess_key));
1476
1477         usr->buffer_dom_id = dom_sid ? 1 : 0; /* yes, we're bothering to put a domain SID in */
1478
1479         memset((char *)usr->lm_sess_key, '\0', sizeof(usr->lm_sess_key));
1480
1481         for (i=0; i<7; i++) {
1482                 memset(&usr->unknown[i], '\0', sizeof(usr->unknown));
1483         }
1484
1485         if (lm_session_key != NULL) {
1486                 memcpy(usr->lm_sess_key, lm_session_key, sizeof(usr->lm_sess_key));
1487         }
1488
1489         num_other_sids = init_dom_sid2s(ctx, NULL, &usr->other_sids);
1490
1491         usr->num_other_sids = num_other_sids;
1492         usr->buffer_other_sids = (num_other_sids != 0) ? 1 : 0;
1493
1494         init_unistr2(&usr->uni_user_name, user_name, UNI_FLAGS_NONE);
1495         init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
1496         init_unistr2(&usr->uni_full_name, full_name, UNI_FLAGS_NONE);
1497         init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
1498         init_unistr2(&usr->uni_logon_script, logon_script, UNI_FLAGS_NONE);
1499         init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
1500         init_unistr2(&usr->uni_profile_path, profile_path, UNI_FLAGS_NONE);
1501         init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
1502         init_unistr2(&usr->uni_home_dir, home_dir, UNI_FLAGS_NONE);
1503         init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
1504         init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_FLAGS_NONE);
1505         init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
1506
1507         usr->num_groups2 = num_groups;
1508
1509         usr->gids = TALLOC_ZERO_ARRAY(ctx,DOM_GID,num_groups);
1510         if (usr->gids == NULL && num_groups>0)
1511                 return;
1512
1513         for (i = 0; i < num_groups; i++)
1514                 usr->gids[i] = gids[i];
1515
1516         init_unistr2(&usr->uni_logon_srv, logon_srv, UNI_FLAGS_NONE);
1517         init_uni_hdr(&usr->hdr_logon_srv, &usr->uni_logon_srv);
1518         init_unistr2(&usr->uni_logon_dom, logon_dom, UNI_FLAGS_NONE);
1519         init_uni_hdr(&usr->hdr_logon_dom, &usr->uni_logon_dom);
1520
1521         init_dom_sid2(&usr->dom_sid, dom_sid);
1522         /* "other" sids are set up above */
1523 }
1524
1525  void dump_acct_flags(uint32 acct_flags) {
1526
1527         int lvl = 10;
1528         DEBUG(lvl,("dump_acct_flags\n"));
1529         if (acct_flags & ACB_NORMAL) {
1530                 DEBUGADD(lvl,("\taccount has ACB_NORMAL\n"));
1531         }
1532         if (acct_flags & ACB_PWNOEXP) {
1533                 DEBUGADD(lvl,("\taccount has ACB_PWNOEXP\n"));
1534         }
1535         if (acct_flags & ACB_ENC_TXT_PWD_ALLOWED) {
1536                 DEBUGADD(lvl,("\taccount has ACB_ENC_TXT_PWD_ALLOWED\n"));
1537         }
1538         if (acct_flags & ACB_NOT_DELEGATED) {
1539                 DEBUGADD(lvl,("\taccount has ACB_NOT_DELEGATED\n"));
1540         }
1541         if (acct_flags & ACB_USE_DES_KEY_ONLY) {
1542                 DEBUGADD(lvl,("\taccount has ACB_USE_DES_KEY_ONLY set, sig verify wont work\n"));
1543         }
1544         if (acct_flags & ACB_NO_AUTH_DATA_REQD) {
1545                 DEBUGADD(lvl,("\taccount has ACB_NO_AUTH_DATA_REQD set\n"));
1546         }
1547         if (acct_flags & ACB_PWEXPIRED) {
1548                 DEBUGADD(lvl,("\taccount has ACB_PWEXPIRED set\n"));
1549         }
1550 }
1551
1552  void dump_user_flgs(uint32 user_flags) {
1553
1554         int lvl = 10;
1555         DEBUG(lvl,("dump_user_flgs\n"));
1556         if (user_flags & LOGON_EXTRA_SIDS) {
1557                 DEBUGADD(lvl,("\taccount has LOGON_EXTRA_SIDS\n"));
1558         }
1559         if (user_flags & LOGON_RESOURCE_GROUPS) {
1560                 DEBUGADD(lvl,("\taccount has LOGON_RESOURCE_GROUPS\n"));
1561         }
1562         if (user_flags & LOGON_NTLMV2_ENABLED) {
1563                 DEBUGADD(lvl,("\taccount has LOGON_NTLMV2_ENABLED\n"));
1564         }
1565         if (user_flags & LOGON_CACHED_ACCOUNT) {
1566                 DEBUGADD(lvl,("\taccount has LOGON_CACHED_ACCOUNT\n"));
1567         }
1568         if (user_flags & LOGON_PROFILE_PATH_RETURNED) {
1569                 DEBUGADD(lvl,("\taccount has LOGON_PROFILE_PATH_RETURNED\n"));
1570         }
1571         if (user_flags & LOGON_SERVER_TRUST_ACCOUNT) {
1572                 DEBUGADD(lvl,("\taccount has LOGON_SERVER_TRUST_ACCOUNT\n"));
1573         }
1574
1575
1576 }
1577
1578 /*******************************************************************
1579  This code has been modified to cope with a NET_USER_INFO_2 - which is
1580  exactly the same as a NET_USER_INFO_3, minus the other sids parameters.
1581  We use validation level to determine if we're marshalling a info 2 or
1582  INFO_3 - be we always return an INFO_3. Based on code donated by Marc
1583  Jacobsen at HP. JRA.
1584 ********************************************************************/
1585
1586 BOOL net_io_user_info3(const char *desc, NET_USER_INFO_3 *usr, prs_struct *ps,
1587                        int depth, uint16 validation_level, BOOL kerb_validation_level)
1588 {
1589         unsigned int i;
1590
1591         if (usr == NULL)
1592                 return False;
1593
1594         prs_debug(ps, depth, desc, "net_io_user_info3");
1595         depth++;
1596
1597         if (UNMARSHALLING(ps))
1598                 ZERO_STRUCTP(usr);
1599
1600         if(!prs_align(ps))
1601                 return False;
1602
1603         if(!prs_uint32("ptr_user_info ", ps, depth, &usr->ptr_user_info))
1604                 return False;
1605
1606         if (usr->ptr_user_info == 0)
1607                 return True;
1608
1609         if(!smb_io_time("logon time", &usr->logon_time, ps, depth)) /* logon time */
1610                 return False;
1611         if(!smb_io_time("logoff time", &usr->logoff_time, ps, depth)) /* logoff time */
1612                 return False;
1613         if(!smb_io_time("kickoff time", &usr->kickoff_time, ps, depth)) /* kickoff time */
1614                 return False;
1615         if(!smb_io_time("last set time", &usr->pass_last_set_time, ps, depth)) /* password last set time */
1616                 return False;
1617         if(!smb_io_time("can change time", &usr->pass_can_change_time , ps, depth)) /* password can change time */
1618                 return False;
1619         if(!smb_io_time("must change time", &usr->pass_must_change_time, ps, depth)) /* password must change time */
1620                 return False;
1621
1622         if(!smb_io_unihdr("hdr_user_name", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
1623                 return False;
1624         if(!smb_io_unihdr("hdr_full_name", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
1625                 return False;
1626         if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
1627                 return False;
1628         if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
1629                 return False;
1630         if(!smb_io_unihdr("hdr_home_dir", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
1631                 return False;
1632         if(!smb_io_unihdr("hdr_dir_drive", &usr->hdr_dir_drive, ps, depth)) /* home directory drive unicode string header */
1633                 return False;
1634
1635         if(!prs_uint16("logon_count   ", ps, depth, &usr->logon_count))  /* logon count */
1636                 return False;
1637         if(!prs_uint16("bad_pw_count  ", ps, depth, &usr->bad_pw_count)) /* bad password count */
1638                 return False;
1639
1640         if(!prs_uint32("user_rid      ", ps, depth, &usr->user_rid))       /* User RID */
1641                 return False;
1642         if(!prs_uint32("group_rid     ", ps, depth, &usr->group_rid))      /* Group RID */
1643                 return False;
1644         if(!prs_uint32("num_groups    ", ps, depth, &usr->num_groups))    /* num groups */
1645                 return False;
1646         if(!prs_uint32("buffer_groups ", ps, depth, &usr->buffer_groups)) /* undocumented buffer pointer to groups. */
1647                 return False;
1648         if(!prs_uint32("user_flgs     ", ps, depth, &usr->user_flgs))     /* user flags */
1649                 return False;
1650         dump_user_flgs(usr->user_flgs);
1651         if(!prs_uint8s(False, "user_sess_key", ps, depth, usr->user_sess_key, 16)) /* user session key */
1652                 return False;
1653
1654         if(!smb_io_unihdr("hdr_logon_srv", &usr->hdr_logon_srv, ps, depth)) /* logon server unicode string header */
1655                 return False;
1656         if(!smb_io_unihdr("hdr_logon_dom", &usr->hdr_logon_dom, ps, depth)) /* logon domain unicode string header */
1657                 return False;
1658
1659         if(!prs_uint32("buffer_dom_id ", ps, depth, &usr->buffer_dom_id)) /* undocumented logon domain id pointer */
1660                 return False;
1661
1662         if(!prs_uint8s(False, "lm_sess_key", ps, depth, usr->lm_sess_key, 8)) /* lm session key */
1663                 return False;
1664
1665         if(!prs_uint32("acct_flags ", ps, depth, &usr->acct_flags)) /* Account flags  */
1666                 return False;
1667         dump_acct_flags(usr->acct_flags);
1668         for (i = 0; i < 7; i++)
1669         {
1670                 if (!prs_uint32("unkown", ps, depth, &usr->unknown[i])) /* unknown */
1671                         return False;
1672         }
1673
1674         if (validation_level == 3) {
1675                 if(!prs_uint32("num_other_sids", ps, depth, &usr->num_other_sids)) /* 0 - num_sids */
1676                         return False;
1677                 if(!prs_uint32("buffer_other_sids", ps, depth, &usr->buffer_other_sids)) /* NULL - undocumented pointer to SIDs. */
1678                         return False;
1679         } else {
1680                 if (UNMARSHALLING(ps)) {
1681                         usr->num_other_sids = 0;
1682                         usr->buffer_other_sids = 0;
1683                 }
1684         }
1685
1686         /* get kerb validation info (not really part of user_info_3) - Guenther */
1687
1688         if (kerb_validation_level) {
1689
1690                 if(!prs_uint32("ptr_res_group_dom_sid", ps, depth, &usr->ptr_res_group_dom_sid))
1691                         return False;
1692                 if(!prs_uint32("res_group_count", ps, depth, &usr->res_group_count))
1693                         return False;
1694                 if(!prs_uint32("ptr_res_groups", ps, depth, &usr->ptr_res_groups))
1695                         return False;
1696         }
1697
1698         if(!smb_io_unistr2("uni_user_name", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
1699                 return False;
1700         if(!smb_io_unistr2("uni_full_name", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
1701                 return False;
1702         if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
1703                 return False;
1704         if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
1705                 return False;
1706         if(!smb_io_unistr2("uni_home_dir", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
1707                 return False;
1708         if(!smb_io_unistr2("uni_dir_drive", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
1709                 return False;
1710
1711         if(!prs_align(ps))
1712                 return False;
1713
1714         if (usr->num_groups > 0) {
1715
1716                 if(!prs_uint32("num_groups2   ", ps, depth, &usr->num_groups2))        /* num groups2 */
1717                         return False;
1718
1719                 if (usr->num_groups != usr->num_groups2) {
1720                         DEBUG(3,("net_io_user_info3: num_groups mismatch! (%d != %d)\n",
1721                         usr->num_groups, usr->num_groups2));
1722                         return False;
1723                 }
1724
1725
1726                 if (UNMARSHALLING(ps)) {
1727                         usr->gids = PRS_ALLOC_MEM(ps, DOM_GID, usr->num_groups);
1728                         if (usr->gids == NULL)
1729                                 return False;
1730                 }
1731
1732                 for (i = 0; i < usr->num_groups; i++) {
1733                         if(!smb_io_gid("", &usr->gids[i], ps, depth)) /* group info */
1734                                 return False;
1735                 }
1736
1737         }
1738
1739         if(!smb_io_unistr2("uni_logon_srv", &usr->uni_logon_srv, usr->hdr_logon_srv.buffer, ps, depth)) /* logon server unicode string */
1740                 return False;
1741         if(!smb_io_unistr2("uni_logon_dom", &usr->uni_logon_dom, usr->hdr_logon_dom.buffer, ps, depth)) /* logon domain unicode string */
1742                 return False;
1743
1744         if(!smb_io_dom_sid2("", &usr->dom_sid, ps, depth))           /* domain SID */
1745                 return False;
1746
1747         if (validation_level == 3 && usr->buffer_other_sids) {
1748
1749                 uint32 num_other_sids = usr->num_other_sids;
1750
1751                 if (!(usr->user_flgs & LOGON_EXTRA_SIDS)) {
1752                         DEBUG(10,("net_io_user_info3: user_flgs attribute does not have LOGON_EXTRA_SIDS\n"));
1753                         /* return False; */
1754                 }
1755
1756                 if (!prs_uint32("num_other_sids", ps, depth,
1757                                 &num_other_sids))
1758                         return False;
1759
1760                 if (num_other_sids != usr->num_other_sids)
1761                         return False;
1762
1763                 if (UNMARSHALLING(ps)) {
1764                         usr->other_sids = PRS_ALLOC_MEM(ps, DOM_SID2, usr->num_other_sids);
1765                         usr->other_sids_attrib =
1766                                 PRS_ALLOC_MEM(ps, uint32, usr->num_other_sids);
1767
1768                         if ((num_other_sids != 0) &&
1769                             ((usr->other_sids == NULL) ||
1770                              (usr->other_sids_attrib == NULL)))
1771                                 return False;
1772                 }
1773
1774                 /* First the pointers to the SIDS and attributes */
1775
1776                 depth++;
1777
1778                 for (i=0; i<usr->num_other_sids; i++) {
1779                         uint32 ptr = 1;
1780
1781                         if (!prs_uint32("sid_ptr", ps, depth, &ptr))
1782                                 return False;
1783
1784                         if (UNMARSHALLING(ps) && (ptr == 0))
1785                                 return False;
1786
1787                         if (!prs_uint32("attribute", ps, depth,
1788                                         &usr->other_sids_attrib[i]))
1789                                 return False;
1790                 }
1791
1792                 for (i = 0; i < usr->num_other_sids; i++) {
1793                         if(!smb_io_dom_sid2("", &usr->other_sids[i], ps, depth)) /* other domain SIDs */
1794                                 return False;
1795                 }
1796
1797                 depth--;
1798         }
1799
1800         return True;
1801 }
1802
1803 /*******************************************************************
1804  Reads or writes a structure.
1805 ********************************************************************/
1806
1807 BOOL net_io_q_sam_logon(const char *desc, NET_Q_SAM_LOGON *q_l, prs_struct *ps, int depth)
1808 {
1809         if (q_l == NULL)
1810                 return False;
1811
1812         prs_debug(ps, depth, desc, "net_io_q_sam_logon");
1813         depth++;
1814
1815         if(!prs_align(ps))
1816                 return False;
1817
1818         if(!smb_io_sam_info("", &q_l->sam_id, ps, depth))
1819                 return False;
1820
1821         if(!prs_align_uint16(ps))
1822                 return False;
1823
1824         if(!prs_uint16("validation_level", ps, depth, &q_l->validation_level))
1825                 return False;
1826
1827         return True;
1828 }
1829
1830 /*******************************************************************
1831  Reads or writes a structure.
1832 ********************************************************************/
1833
1834 BOOL net_io_r_sam_logon(const char *desc, NET_R_SAM_LOGON *r_l, prs_struct *ps, int depth)
1835 {
1836         if (r_l == NULL)
1837                 return False;
1838
1839         prs_debug(ps, depth, desc, "net_io_r_sam_logon");
1840         depth++;
1841
1842         if(!prs_uint32("buffer_creds", ps, depth, &r_l->buffer_creds)) /* undocumented buffer pointer */
1843                 return False;
1844         if (&r_l->buffer_creds) {
1845                 if(!smb_io_cred("", &r_l->srv_creds, ps, depth)) /* server credentials.  server time stamp appears to be ignored. */
1846                         return False;
1847         }
1848
1849         if(!prs_uint16("switch_value", ps, depth, &r_l->switch_value))
1850                 return False;
1851         if(!prs_align(ps))
1852                 return False;
1853
1854 #if 1 /* W2k always needs this - even for bad passwd. JRA */
1855         if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value, False))
1856                 return False;
1857 #else
1858         if (r_l->switch_value != 0) {
1859                 if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value, False))
1860                         return False;
1861         }
1862 #endif
1863
1864         if(!prs_uint32("auth_resp   ", ps, depth, &r_l->auth_resp)) /* 1 - Authoritative response; 0 - Non-Auth? */
1865                 return False;
1866
1867         if(!prs_ntstatus("status      ", ps, depth, &r_l->status))
1868                 return False;
1869
1870         if(!prs_align(ps))
1871                 return False;
1872
1873         return True;
1874 }
1875
1876 /*******************************************************************
1877  Reads or writes a structure.
1878 ********************************************************************/
1879
1880 BOOL net_io_q_sam_logon_ex(const char *desc, NET_Q_SAM_LOGON_EX *q_l, prs_struct *ps, int depth)
1881 {
1882         if (q_l == NULL)
1883                 return False;
1884
1885         prs_debug(ps, depth, desc, "net_io_q_sam_logon_ex");
1886         depth++;
1887
1888         if(!prs_align(ps))
1889                 return False;
1890
1891         if(!smb_io_sam_info_ex("", &q_l->sam_id, ps, depth))
1892                 return False;
1893
1894         if(!prs_align_uint16(ps))
1895                 return False;
1896
1897         if(!prs_uint16("validation_level", ps, depth, &q_l->validation_level))
1898                 return False;
1899
1900         if(!prs_uint32("flags  ", ps, depth, &q_l->flags))
1901                 return False;
1902
1903         return True;
1904 }
1905
1906 /*******************************************************************
1907  Reads or writes a structure.
1908 ********************************************************************/
1909
1910 BOOL net_io_r_sam_logon_ex(const char *desc, NET_R_SAM_LOGON_EX *r_l, prs_struct *ps, int depth)
1911 {
1912         if (r_l == NULL)
1913                 return False;
1914
1915         prs_debug(ps, depth, desc, "net_io_r_sam_logon_ex");
1916         depth++;
1917
1918         if(!prs_uint16("switch_value", ps, depth, &r_l->switch_value))
1919                 return False;
1920         if(!prs_align(ps))
1921                 return False;
1922
1923 #if 1 /* W2k always needs this - even for bad passwd. JRA */
1924         if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value, False))
1925                 return False;
1926 #else
1927         if (r_l->switch_value != 0) {
1928                 if(!net_io_user_info3("", r_l->user, ps, depth, r_l->switch_value, False))
1929                         return False;
1930         }
1931 #endif
1932
1933         if(!prs_uint32("auth_resp   ", ps, depth, &r_l->auth_resp)) /* 1 - Authoritative response; 0 - Non-Auth? */
1934                 return False;
1935
1936         if(!prs_uint32("flags   ", ps, depth, &r_l->flags))
1937                 return False;
1938
1939         if(!prs_ntstatus("status      ", ps, depth, &r_l->status))
1940                 return False;
1941
1942         if(!prs_align(ps))
1943                 return False;
1944
1945         return True;
1946 }
1947
1948
1949 /*******************************************************************
1950  Reads or writes a structure.
1951 ********************************************************************/
1952
1953 BOOL net_io_q_sam_logoff(const char *desc,  NET_Q_SAM_LOGOFF *q_l, prs_struct *ps, int depth)
1954 {
1955         if (q_l == NULL)
1956                 return False;
1957
1958         prs_debug(ps, depth, desc, "net_io_q_sam_logoff");
1959         depth++;
1960
1961         if(!prs_align(ps))
1962                 return False;
1963
1964         if(!smb_io_sam_info("", &q_l->sam_id, ps, depth))           /* domain SID */
1965                 return False;
1966
1967         return True;
1968 }
1969
1970 /*******************************************************************
1971  Reads or writes a structure.
1972 ********************************************************************/
1973
1974 BOOL net_io_r_sam_logoff(const char *desc, NET_R_SAM_LOGOFF *r_l, prs_struct *ps, int depth)
1975 {
1976         if (r_l == NULL)
1977                 return False;
1978
1979         prs_debug(ps, depth, desc, "net_io_r_sam_logoff");
1980         depth++;
1981
1982         if(!prs_align(ps))
1983                 return False;
1984
1985         if(!prs_uint32("buffer_creds", ps, depth, &r_l->buffer_creds)) /* undocumented buffer pointer */
1986                 return False;
1987         if(!smb_io_cred("", &r_l->srv_creds, ps, depth)) /* server credentials.  server time stamp appears to be ignored. */
1988                 return False;
1989
1990         if(!prs_ntstatus("status      ", ps, depth, &r_l->status))
1991                 return False;
1992
1993         return True;
1994 }
1995
1996 /*******************************************************************
1997 makes a NET_Q_SAM_SYNC structure.
1998 ********************************************************************/
1999 BOOL init_net_q_sam_sync(NET_Q_SAM_SYNC * q_s, const char *srv_name,
2000                          const char *cli_name, DOM_CRED *cli_creds,
2001                          DOM_CRED *ret_creds, uint32 database_id,
2002                          uint32 next_rid)
2003 {
2004         DEBUG(5, ("init_q_sam_sync\n"));
2005
2006         init_unistr2(&q_s->uni_srv_name, srv_name, UNI_STR_TERMINATE);
2007         init_unistr2(&q_s->uni_cli_name, cli_name, UNI_STR_TERMINATE);
2008
2009         if (cli_creds)
2010                 memcpy(&q_s->cli_creds, cli_creds, sizeof(q_s->cli_creds));
2011
2012         if (cli_creds)
2013                 memcpy(&q_s->ret_creds, ret_creds, sizeof(q_s->ret_creds));
2014         else
2015                 memset(&q_s->ret_creds, 0, sizeof(q_s->ret_creds));
2016
2017         q_s->database_id = database_id;
2018         q_s->restart_state = 0;
2019         q_s->sync_context = next_rid;
2020         q_s->max_size = 0xffff;
2021
2022         return True;
2023 }
2024
2025 /*******************************************************************
2026 reads or writes a structure.
2027 ********************************************************************/
2028 BOOL net_io_q_sam_sync(const char *desc, NET_Q_SAM_SYNC * q_s, prs_struct *ps,
2029                        int depth)
2030 {
2031         prs_debug(ps, depth, desc, "net_io_q_sam_sync");
2032         depth++;
2033
2034         if (!smb_io_unistr2("", &q_s->uni_srv_name, True, ps, depth))
2035                 return False;
2036         if (!smb_io_unistr2("", &q_s->uni_cli_name, True, ps, depth))
2037                 return False;
2038
2039         if (!smb_io_cred("", &q_s->cli_creds, ps, depth))
2040                 return False;
2041         if (!smb_io_cred("", &q_s->ret_creds, ps, depth))
2042                 return False;
2043
2044         if (!prs_uint32("database_id  ", ps, depth, &q_s->database_id))
2045                 return False;
2046         if (!prs_uint32("restart_state", ps, depth, &q_s->restart_state))
2047                 return False;
2048         if (!prs_uint32("sync_context ", ps, depth, &q_s->sync_context))
2049                 return False;
2050
2051         if (!prs_uint32("max_size", ps, depth, &q_s->max_size))
2052                 return False;
2053
2054         return True;
2055 }
2056
2057 /*******************************************************************
2058 reads or writes a structure.
2059 ********************************************************************/
2060 static BOOL net_io_sam_delta_hdr(const char *desc, SAM_DELTA_HDR * delta,
2061                                  prs_struct *ps, int depth)
2062 {
2063         prs_debug(ps, depth, desc, "net_io_sam_delta_hdr");
2064         depth++;
2065
2066         if (!prs_uint16("type", ps, depth, &delta->type))
2067                 return False;
2068         if (!prs_uint16("type2", ps, depth, &delta->type2))
2069                 return False;
2070         if (!prs_uint32("target_rid", ps, depth, &delta->target_rid))
2071                 return False;
2072
2073         if (!prs_uint32("type3", ps, depth, &delta->type3))
2074                 return False;
2075
2076         /* Not sure why we need this but it seems to be necessary to get
2077            sam deltas working. */
2078
2079         if (delta->type != 0x16) {
2080                 if (!prs_uint32("ptr_delta", ps, depth, &delta->ptr_delta))
2081                         return False;
2082         }
2083
2084         return True;
2085 }
2086
2087 /*******************************************************************
2088 reads or writes a structure.
2089 ********************************************************************/
2090 static BOOL net_io_sam_delta_mod_count(const char *desc, SAM_DELTA_MOD_COUNT *info,
2091                                    prs_struct *ps, int depth)
2092 {
2093         prs_debug(ps, depth, desc, "net_io_sam_delta_stamp");
2094         depth++;
2095
2096         if (!prs_uint32("seqnum", ps, depth, &info->seqnum))
2097                 return False;
2098         if (!prs_uint32("dom_mod_count_ptr", ps, depth,
2099                         &info->dom_mod_count_ptr))
2100                 return False;
2101
2102         if (info->dom_mod_count_ptr) {
2103                 if (!prs_uint64("dom_mod_count", ps, depth,
2104                                 &info->dom_mod_count))
2105                         return False;
2106         }
2107
2108         return True;
2109 }
2110
2111 /*******************************************************************
2112 reads or writes a structure.
2113 ********************************************************************/
2114 static BOOL net_io_sam_domain_info(const char *desc, SAM_DOMAIN_INFO * info,
2115                                    prs_struct *ps, int depth)
2116 {
2117         prs_debug(ps, depth, desc, "net_io_sam_domain_info");
2118         depth++;
2119
2120         if (!smb_io_unihdr("hdr_dom_name", &info->hdr_dom_name, ps, depth))
2121                 return False;
2122         if (!smb_io_unihdr("hdr_oem_info", &info->hdr_oem_info, ps, depth))
2123                 return False;
2124
2125         if (!prs_uint64("force_logoff", ps, depth, &info->force_logoff))
2126                 return False;
2127         if (!prs_uint16("min_pwd_len", ps, depth, &info->min_pwd_len))
2128                 return False;
2129         if (!prs_uint16("pwd_history_len", ps, depth, &info->pwd_history_len))
2130                 return False;
2131         if (!prs_uint64("max_pwd_age", ps, depth, &info->max_pwd_age))
2132                 return False;
2133         if (!prs_uint64("min_pwd_age", ps, depth, &info->min_pwd_age))
2134                 return False;
2135         if (!prs_uint64("dom_mod_count", ps, depth, &info->dom_mod_count))
2136                 return False;
2137         if (!smb_io_time("creation_time", &info->creation_time, ps, depth))
2138                 return False;
2139         if (!prs_uint32("security_information", ps, depth, &info->security_information))
2140                 return False;
2141         if (!smb_io_bufhdr4("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2142                 return False;
2143         if (!smb_io_lockout_string_hdr("hdr_account_lockout_string", &info->hdr_account_lockout, ps, depth))
2144                 return False;
2145         if (!smb_io_unihdr("hdr_unknown2", &info->hdr_unknown2, ps, depth))
2146                 return False;
2147         if (!smb_io_unihdr("hdr_unknown3", &info->hdr_unknown3, ps, depth))
2148                 return False;
2149         if (!smb_io_unihdr("hdr_unknown4", &info->hdr_unknown4, ps, depth))
2150                 return False;
2151         if (!prs_uint32("logon_chgpass", ps, depth, &info->logon_chgpass))
2152                 return False;
2153         if (!prs_uint32("unknown6", ps, depth, &info->unknown6))
2154                 return False;
2155         if (!prs_uint32("unknown7", ps, depth, &info->unknown7))
2156                 return False;
2157         if (!prs_uint32("unknown8", ps, depth, &info->unknown8))
2158                 return False;
2159
2160         if (!smb_io_unistr2("uni_dom_name", &info->uni_dom_name,
2161                             info->hdr_dom_name.buffer, ps, depth))
2162                 return False;
2163         if (!smb_io_unistr2("buf_oem_info", &info->buf_oem_info,
2164                             info->hdr_oem_info.buffer, ps, depth))
2165                 return False;
2166
2167         if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2168                 return False;
2169
2170         if (!smb_io_account_lockout_str("account_lockout", &info->account_lockout,
2171                                         info->hdr_account_lockout.buffer, ps, depth))
2172                 return False;
2173
2174         if (!smb_io_unistr2("buf_unknown2", &info->buf_unknown2,
2175                             info->hdr_unknown2.buffer, ps, depth))
2176                 return False;
2177         if (!smb_io_unistr2("buf_unknown3", &info->buf_unknown3,
2178                             info->hdr_unknown3.buffer, ps, depth))
2179                 return False;
2180         if (!smb_io_unistr2("buf_unknown4", &info->buf_unknown4,
2181                             info->hdr_unknown4.buffer, ps, depth))
2182                 return False;
2183
2184         return True;
2185 }
2186
2187 /*******************************************************************
2188 reads or writes a structure.
2189 ********************************************************************/
2190 static BOOL net_io_sam_group_info(const char *desc, SAM_GROUP_INFO * info,
2191                                   prs_struct *ps, int depth)
2192 {
2193         prs_debug(ps, depth, desc, "net_io_sam_group_info");
2194         depth++;
2195
2196         if (!smb_io_unihdr("hdr_grp_name", &info->hdr_grp_name, ps, depth))
2197                 return False;
2198         if (!smb_io_gid("gid", &info->gid, ps, depth))
2199                 return False;
2200         if (!smb_io_unihdr("hdr_grp_desc", &info->hdr_grp_desc, ps, depth))
2201                 return False;
2202         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2203                 return False;
2204
2205         if (ps->data_offset + 48 > ps->buffer_size)
2206                 return False;
2207         ps->data_offset += 48;
2208
2209         if (!smb_io_unistr2("uni_grp_name", &info->uni_grp_name,
2210                             info->hdr_grp_name.buffer, ps, depth))
2211                 return False;
2212         if (!smb_io_unistr2("uni_grp_desc", &info->uni_grp_desc,
2213                             info->hdr_grp_desc.buffer, ps, depth))
2214                 return False;
2215         if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2216                 return False;
2217
2218         return True;
2219 }
2220
2221 /*******************************************************************
2222 reads or writes a structure.
2223 ********************************************************************/
2224 static BOOL net_io_sam_passwd_info(const char *desc, SAM_PWD * pwd,
2225                                    prs_struct *ps, int depth)
2226 {
2227         prs_debug(ps, depth, desc, "net_io_sam_passwd_info");
2228         depth++;
2229
2230         if (!prs_uint32("unk_0 ", ps, depth, &pwd->unk_0))
2231                 return False;
2232
2233         if (!smb_io_unihdr("hdr_lm_pwd", &pwd->hdr_lm_pwd, ps, depth))
2234                 return False;
2235         if (!prs_uint8s(False, "buf_lm_pwd", ps, depth, pwd->buf_lm_pwd, 16))
2236                 return False;
2237
2238         if (!smb_io_unihdr("hdr_nt_pwd", &pwd->hdr_nt_pwd, ps, depth))
2239                 return False;
2240         if (!prs_uint8s(False, "buf_nt_pwd", ps, depth, pwd->buf_nt_pwd, 16))
2241                 return False;
2242
2243         if (!smb_io_unihdr("", &pwd->hdr_empty_lm, ps, depth))
2244                 return False;
2245         if (!smb_io_unihdr("", &pwd->hdr_empty_nt, ps, depth))
2246                 return False;
2247
2248         return True;
2249 }
2250
2251 /*******************************************************************
2252 reads or writes a structure.
2253 ********************************************************************/
2254 static BOOL net_io_sam_account_info(const char *desc, SAM_ACCOUNT_INFO *info,
2255                                 prs_struct *ps, int depth)
2256 {
2257         BUFHDR2 hdr_priv_data;
2258         uint32 i;
2259
2260         prs_debug(ps, depth, desc, "net_io_sam_account_info");
2261         depth++;
2262
2263         if (!smb_io_unihdr("hdr_acct_name", &info->hdr_acct_name, ps, depth))
2264                 return False;
2265         if (!smb_io_unihdr("hdr_full_name", &info->hdr_full_name, ps, depth))
2266                 return False;
2267
2268         if (!prs_uint32("user_rid ", ps, depth, &info->user_rid))
2269                 return False;
2270         if (!prs_uint32("group_rid", ps, depth, &info->group_rid))
2271                 return False;
2272
2273         if (!smb_io_unihdr("hdr_home_dir ", &info->hdr_home_dir, ps, depth))
2274                 return False;
2275         if (!smb_io_unihdr("hdr_dir_drive", &info->hdr_dir_drive, ps, depth))
2276                 return False;
2277         if (!smb_io_unihdr("hdr_logon_script", &info->hdr_logon_script, ps,
2278                            depth))
2279                 return False;
2280
2281         if (!smb_io_unihdr("hdr_acct_desc", &info->hdr_acct_desc, ps, depth))
2282                 return False;
2283         if (!smb_io_unihdr("hdr_workstations", &info->hdr_workstations, ps,
2284                            depth))
2285                 return False;
2286
2287         if (!smb_io_time("logon_time", &info->logon_time, ps, depth))
2288                 return False;
2289         if (!smb_io_time("logoff_time", &info->logoff_time, ps, depth))
2290                 return False;
2291
2292         if (!prs_uint32("logon_divs   ", ps, depth, &info->logon_divs))
2293                 return False;
2294         if (!prs_uint32("ptr_logon_hrs", ps, depth, &info->ptr_logon_hrs))
2295                 return False;
2296
2297         if (!prs_uint16("bad_pwd_count", ps, depth, &info->bad_pwd_count))
2298                 return False;
2299         if (!prs_uint16("logon_count", ps, depth, &info->logon_count))
2300                 return False;
2301         if (!smb_io_time("pwd_last_set_time", &info->pwd_last_set_time, ps,
2302                          depth))
2303                 return False;
2304         if (!smb_io_time("acct_expiry_time", &info->acct_expiry_time, ps,
2305                          depth))
2306                 return False;
2307
2308         if (!prs_uint32("acb_info", ps, depth, &info->acb_info))
2309                 return False;
2310         if (!prs_uint8s(False, "nt_pwd", ps, depth, info->nt_pwd, 16))
2311                 return False;
2312         if (!prs_uint8s(False, "lm_pwd", ps, depth, info->lm_pwd, 16))
2313                 return False;
2314         if (!prs_uint8("lm_pwd_present", ps, depth, &info->lm_pwd_present))
2315                 return False;
2316         if (!prs_uint8("nt_pwd_present", ps, depth, &info->nt_pwd_present))
2317                 return False;
2318         if (!prs_uint8("pwd_expired", ps, depth, &info->pwd_expired))
2319                 return False;
2320
2321         if (!smb_io_unihdr("hdr_comment", &info->hdr_comment, ps, depth))
2322                 return False;
2323         if (!smb_io_unihdr("hdr_parameters", &info->hdr_parameters, ps,
2324                            depth))
2325                 return False;
2326         if (!prs_uint16("country", ps, depth, &info->country))
2327                 return False;
2328         if (!prs_uint16("codepage", ps, depth, &info->codepage))
2329                 return False;
2330
2331         if (!smb_io_bufhdr2("hdr_priv_data", &hdr_priv_data, ps, depth))
2332                 return False;
2333         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2334                 return False;
2335         if (!smb_io_unihdr("hdr_profile", &info->hdr_profile, ps, depth))
2336                 return False;
2337
2338         for (i = 0; i < 3; i++)
2339         {
2340                 if (!smb_io_unihdr("hdr_reserved", &info->hdr_reserved[i],
2341                                    ps, depth))
2342                         return False;
2343         }
2344
2345         for (i = 0; i < 4; i++)
2346         {
2347                 if (!prs_uint32("dw_reserved", ps, depth,
2348                                 &info->dw_reserved[i]))
2349                         return False;
2350         }
2351
2352         if (!smb_io_unistr2("uni_acct_name", &info->uni_acct_name,
2353                             info->hdr_acct_name.buffer, ps, depth))
2354                 return False;
2355         prs_align(ps);
2356         if (!smb_io_unistr2("uni_full_name", &info->uni_full_name,
2357                             info->hdr_full_name.buffer, ps, depth))
2358                 return False;
2359         prs_align(ps);
2360         if (!smb_io_unistr2("uni_home_dir ", &info->uni_home_dir,
2361                             info->hdr_home_dir.buffer, ps, depth))
2362                 return False;
2363         prs_align(ps);
2364         if (!smb_io_unistr2("uni_dir_drive", &info->uni_dir_drive,
2365                             info->hdr_dir_drive.buffer, ps, depth))
2366                 return False;
2367         prs_align(ps);
2368         if (!smb_io_unistr2("uni_logon_script", &info->uni_logon_script,
2369                             info->hdr_logon_script.buffer, ps, depth))
2370                 return False;
2371         prs_align(ps);
2372         if (!smb_io_unistr2("uni_acct_desc", &info->uni_acct_desc,
2373                             info->hdr_acct_desc.buffer, ps, depth))
2374                 return False;
2375         prs_align(ps);
2376         if (!smb_io_unistr2("uni_workstations", &info->uni_workstations,
2377                             info->hdr_workstations.buffer, ps, depth))
2378                 return False;
2379         prs_align(ps);
2380
2381         if (!prs_uint32("unknown1", ps, depth, &info->unknown1))
2382                 return False;
2383         if (!prs_uint32("unknown2", ps, depth, &info->unknown2))
2384                 return False;
2385
2386         if (!smb_io_rpc_blob("buf_logon_hrs", &info->buf_logon_hrs, ps, depth))
2387                 return False;
2388         prs_align(ps);
2389         if (!smb_io_unistr2("uni_comment", &info->uni_comment,
2390                             info->hdr_comment.buffer, ps, depth))
2391                 return False;
2392         prs_align(ps);
2393         if (!smb_io_unistr2("uni_parameters", &info->uni_parameters,
2394                             info->hdr_parameters.buffer, ps, depth))
2395                 return False;
2396         prs_align(ps);
2397         if (hdr_priv_data.buffer != 0)
2398         {
2399                 int old_offset = 0;
2400                 uint32 len = 0x44;
2401                 if (!prs_uint32("pwd_len", ps, depth, &len))
2402                         return False;
2403                 old_offset = ps->data_offset;
2404                 if (len > 0)
2405                 {
2406                         if (ps->io)
2407                         {
2408                                 /* reading */
2409                                 if (!prs_hash1(ps, ps->data_offset, len))
2410                                         return False;
2411                         }
2412                         if (!net_io_sam_passwd_info("pass", &info->pass,
2413                                                     ps, depth))
2414                                 return False;
2415
2416                         if (!ps->io)
2417                         {
2418                                 /* writing */
2419                                 if (!prs_hash1(ps, old_offset, len))
2420                                         return False;
2421                         }
2422                 }
2423                 if (old_offset + len > ps->buffer_size)
2424                         return False;
2425                 ps->data_offset = old_offset + len;
2426         }
2427         if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2428                 return False;
2429         prs_align(ps);
2430         if (!smb_io_unistr2("uni_profile", &info->uni_profile,
2431                             info->hdr_profile.buffer, ps, depth))
2432                 return False;
2433
2434         prs_align(ps);
2435
2436         return True;
2437 }
2438
2439 /*******************************************************************
2440 reads or writes a structure.
2441 ********************************************************************/
2442 static BOOL net_io_sam_group_mem_info(const char *desc, SAM_GROUP_MEM_INFO * info,
2443                                       prs_struct *ps, int depth)
2444 {
2445         uint32 i;
2446         fstring tmp;
2447
2448         prs_debug(ps, depth, desc, "net_io_sam_group_mem_info");
2449         depth++;
2450
2451         prs_align(ps);
2452         if (!prs_uint32("ptr_rids   ", ps, depth, &info->ptr_rids))
2453                 return False;
2454         if (!prs_uint32("ptr_attribs", ps, depth, &info->ptr_attribs))
2455                 return False;
2456         if (!prs_uint32("num_members", ps, depth, &info->num_members))
2457                 return False;
2458
2459         if (ps->data_offset + 16 > ps->buffer_size)
2460                 return False;
2461         ps->data_offset += 16;
2462
2463         if (info->ptr_rids != 0)
2464         {
2465                 if (!prs_uint32("num_members2", ps, depth,
2466                                 &info->num_members2))
2467                         return False;
2468
2469                 if (info->num_members2 != info->num_members)
2470                 {
2471                         /* RPC fault */
2472                         return False;
2473                 }
2474
2475                 info->rids = TALLOC_ARRAY(ps->mem_ctx, uint32, info->num_members2);
2476
2477                 if (info->rids == NULL) {
2478                         DEBUG(0, ("out of memory allocating %d rids\n",
2479                                   info->num_members2));
2480                         return False;
2481                 }
2482
2483                 for (i = 0; i < info->num_members2; i++)
2484                 {
2485                         slprintf(tmp, sizeof(tmp) - 1, "rids[%02d]", i);
2486                         if (!prs_uint32(tmp, ps, depth, &info->rids[i]))
2487                                 return False;
2488                 }
2489         }
2490
2491         if (info->ptr_attribs != 0)
2492         {
2493                 if (!prs_uint32("num_members3", ps, depth,
2494                                 &info->num_members3))
2495                         return False;
2496                 if (info->num_members3 != info->num_members)
2497                 {
2498                         /* RPC fault */
2499                         return False;
2500                 }
2501
2502                 info->attribs = TALLOC_ARRAY(ps->mem_ctx, uint32, info->num_members3);
2503
2504                 if (info->attribs == NULL) {
2505                         DEBUG(0, ("out of memory allocating %d attribs\n",
2506                                   info->num_members3));
2507                         return False;
2508                 }
2509
2510                 for (i = 0; i < info->num_members3; i++)
2511                 {
2512                         slprintf(tmp, sizeof(tmp) - 1, "attribs[%02d]", i);
2513                         if (!prs_uint32(tmp, ps, depth, &info->attribs[i]))
2514                                 return False;
2515                 }
2516         }
2517
2518         return True;
2519 }
2520
2521 /*******************************************************************
2522 reads or writes a structure.
2523 ********************************************************************/
2524 static BOOL net_io_sam_alias_info(const char *desc, SAM_ALIAS_INFO * info,
2525                                   prs_struct *ps, int depth)
2526 {
2527         prs_debug(ps, depth, desc, "net_io_sam_alias_info");
2528         depth++;
2529
2530         if (!smb_io_unihdr("hdr_als_name", &info->hdr_als_name, ps, depth))
2531                 return False;
2532         if (!prs_uint32("als_rid", ps, depth, &info->als_rid))
2533                 return False;
2534         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2535                 return False;
2536         if (!smb_io_unihdr("hdr_als_desc", &info->hdr_als_desc, ps, depth))
2537                 return False;
2538
2539         if (ps->data_offset + 40 > ps->buffer_size)
2540                 return False;
2541         ps->data_offset += 40;
2542
2543         if (!smb_io_unistr2("uni_als_name", &info->uni_als_name,
2544                             info->hdr_als_name.buffer, ps, depth))
2545                 return False;
2546         if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2547                 return False;
2548
2549         if (!smb_io_unistr2("uni_als_desc", &info->uni_als_desc,
2550                             info->hdr_als_desc.buffer, ps, depth))
2551                 return False;
2552
2553         return True;
2554 }
2555
2556 /*******************************************************************
2557 reads or writes a structure.
2558 ********************************************************************/
2559 static BOOL net_io_sam_alias_mem_info(const char *desc, SAM_ALIAS_MEM_INFO * info,
2560                                       prs_struct *ps, int depth)
2561 {
2562         uint32 i;
2563         fstring tmp;
2564
2565         prs_debug(ps, depth, desc, "net_io_sam_alias_mem_info");
2566         depth++;
2567
2568         prs_align(ps);
2569         if (!prs_uint32("num_members", ps, depth, &info->num_members))
2570                 return False;
2571         if (!prs_uint32("ptr_members", ps, depth, &info->ptr_members))
2572                 return False;
2573
2574         if (ps->data_offset + 16 > ps->buffer_size)
2575                 return False;
2576         ps->data_offset += 16;
2577
2578         if (info->ptr_members != 0)
2579         {
2580                 if (!prs_uint32("num_sids", ps, depth, &info->num_sids))
2581                         return False;
2582                 if (info->num_sids != info->num_members)
2583                 {
2584                         /* RPC fault */
2585                         return False;
2586                 }
2587
2588                 info->ptr_sids = TALLOC_ARRAY(ps->mem_ctx, uint32, info->num_sids);
2589
2590                 if (info->ptr_sids == NULL) {
2591                         DEBUG(0, ("out of memory allocating %d ptr_sids\n",
2592                                   info->num_sids));
2593                         return False;
2594                 }
2595
2596                 for (i = 0; i < info->num_sids; i++)
2597                 {
2598                         slprintf(tmp, sizeof(tmp) - 1, "ptr_sids[%02d]", i);
2599                         if (!prs_uint32(tmp, ps, depth, &info->ptr_sids[i]))
2600                                 return False;
2601                 }
2602
2603                 info->sids = TALLOC_ARRAY(ps->mem_ctx, DOM_SID2, info->num_sids);
2604
2605                 if (info->sids == NULL) {
2606                         DEBUG(0, ("error allocating %d sids\n",
2607                                   info->num_sids));
2608                         return False;
2609                 }
2610
2611                 for (i = 0; i < info->num_sids; i++)
2612                 {
2613                         if (info->ptr_sids[i] != 0)
2614                         {
2615                                 slprintf(tmp, sizeof(tmp) - 1, "sids[%02d]",
2616                                          i);
2617                                 if (!smb_io_dom_sid2(tmp, &info->sids[i],
2618                                                      ps, depth))
2619                                         return False;
2620                         }
2621                 }
2622         }
2623
2624         return True;
2625 }
2626
2627 /*******************************************************************
2628 reads or writes a structure.
2629 ********************************************************************/
2630 static BOOL net_io_sam_policy_info(const char *desc, SAM_DELTA_POLICY *info,
2631                                       prs_struct *ps, int depth)
2632 {
2633         unsigned int i;
2634         prs_debug(ps, depth, desc, "net_io_sam_policy_info");
2635         depth++;
2636
2637         if(!prs_align(ps))
2638                 return False;
2639
2640         if (!prs_uint32("max_log_size", ps, depth, &info->max_log_size))
2641                 return False;
2642         if (!prs_uint64("audit_retention_period", ps, depth,
2643                         &info->audit_retention_period))
2644                 return False;
2645         if (!prs_uint32("auditing_mode", ps, depth, &info->auditing_mode))
2646                 return False;
2647         if (!prs_uint32("num_events", ps, depth, &info->num_events))
2648                 return False;
2649         if (!prs_uint32("ptr_events", ps, depth, &info->ptr_events))
2650                 return False;
2651
2652         if (!smb_io_unihdr("hdr_dom_name", &info->hdr_dom_name, ps, depth))
2653                 return False;
2654
2655         if (!prs_uint32("sid_ptr", ps, depth, &info->sid_ptr))
2656                 return False;
2657
2658         if (!prs_uint32("paged_pool_limit", ps, depth, &info->paged_pool_limit))
2659                 return False;
2660         if (!prs_uint32("non_paged_pool_limit", ps, depth,
2661                         &info->non_paged_pool_limit))
2662                 return False;
2663         if (!prs_uint32("min_workset_size", ps, depth, &info->min_workset_size))
2664                 return False;
2665         if (!prs_uint32("max_workset_size", ps, depth, &info->max_workset_size))
2666                 return False;
2667         if (!prs_uint32("page_file_limit", ps, depth, &info->page_file_limit))
2668                 return False;
2669         if (!prs_uint64("time_limit", ps, depth, &info->time_limit))
2670                 return False;
2671         if (!smb_io_time("modify_time", &info->modify_time, ps, depth))
2672                 return False;
2673         if (!smb_io_time("create_time", &info->create_time, ps, depth))
2674                 return False;
2675         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2676                 return False;
2677
2678         for (i=0; i<4; i++) {
2679                 UNIHDR dummy;
2680                 if (!smb_io_unihdr("dummy", &dummy, ps, depth))
2681                         return False;
2682         }
2683
2684         for (i=0; i<4; i++) {
2685                 uint32 reserved;
2686                 if (!prs_uint32("reserved", ps, depth, &reserved))
2687                         return False;
2688         }
2689
2690         if (!prs_uint32("num_event_audit_options", ps, depth,
2691                         &info->num_event_audit_options))
2692                 return False;
2693
2694         for (i=0; i<info->num_event_audit_options; i++)
2695                 if (!prs_uint32("event_audit_option", ps, depth,
2696                                 &info->event_audit_option))
2697                         return False;
2698
2699         if (!smb_io_unistr2("domain_name", &info->domain_name, True, ps, depth))
2700                 return False;
2701
2702         if(!smb_io_dom_sid2("domain_sid", &info->domain_sid, ps, depth))
2703                 return False;
2704
2705         if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2706
2707                 return False;
2708
2709         return True;
2710 }
2711
2712 #if 0
2713
2714 /* This function is pretty broken - see bug #334 */
2715
2716 /*******************************************************************
2717 reads or writes a structure.
2718 ********************************************************************/
2719 static BOOL net_io_sam_trustdoms_info(const char *desc, SAM_DELTA_TRUSTDOMS *info,
2720                                       prs_struct *ps, int depth)
2721 {
2722         int i;
2723
2724         prs_debug(ps, depth, desc, "net_io_sam_trustdoms_info");
2725         depth++;
2726
2727         if(!prs_align(ps))
2728                 return False;
2729
2730         if(!prs_uint32("buf_size", ps, depth, &info->buf_size))
2731                 return False;
2732
2733         if(!sec_io_desc("sec_desc", &info->sec_desc, ps, depth))
2734                 return False;
2735
2736         if(!smb_io_dom_sid2("sid", &info->sid, ps, depth))
2737                 return False;
2738
2739         if(!smb_io_unihdr("hdr_domain", &info->hdr_domain, ps, depth))
2740                 return False;
2741
2742         if(!prs_uint32("unknown0", ps, depth, &info->unknown0))
2743                 return False;
2744         if(!prs_uint32("unknown1", ps, depth, &info->unknown1))
2745                 return False;
2746         if(!prs_uint32("unknown2", ps, depth, &info->unknown2))
2747                 return False;
2748
2749         if(!prs_uint32("buf_size2", ps, depth, &info->buf_size2))
2750                 return False;
2751         if(!prs_uint32("ptr", ps, depth, &info->ptr))
2752                 return False;
2753
2754         for (i=0; i<12; i++)
2755                 if(!prs_uint32("unknown3", ps, depth, &info->unknown3))
2756                         return False;
2757
2758         if (!smb_io_unistr2("domain", &info->domain, True, ps, depth))
2759                 return False;
2760
2761         return True;
2762 }
2763
2764 #endif
2765
2766 #if 0
2767
2768 /* This function doesn't work - see bug #334 */
2769
2770 /*******************************************************************
2771 reads or writes a structure.
2772 ********************************************************************/
2773 static BOOL net_io_sam_secret_info(const char *desc, SAM_DELTA_SECRET *info,
2774                                    prs_struct *ps, int depth)
2775 {
2776         int i;
2777
2778         prs_debug(ps, depth, desc, "net_io_sam_secret_info");
2779         depth++;
2780
2781         if(!prs_align(ps))
2782                 return False;
2783
2784         if(!prs_uint32("buf_size", ps, depth, &info->buf_size))
2785                 return False;
2786
2787         if(!sec_io_desc("sec_desc", &info->sec_desc, ps, depth))
2788                 return False;
2789
2790         if (!smb_io_unistr2("secret", &info->secret, True, ps, depth))
2791                 return False;
2792
2793         if(!prs_align(ps))
2794                 return False;
2795
2796         if(!prs_uint32("count1", ps, depth, &info->count1))
2797                 return False;
2798         if(!prs_uint32("count2", ps, depth, &info->count2))
2799                 return False;
2800         if(!prs_uint32("ptr", ps, depth, &info->ptr))
2801                 return False;
2802
2803
2804         if(!smb_io_time("time1", &info->time1, ps, depth)) /* logon time */
2805                 return False;
2806         if(!prs_uint32("count3", ps, depth, &info->count3))
2807                 return False;
2808         if(!prs_uint32("count4", ps, depth, &info->count4))
2809                 return False;
2810         if(!prs_uint32("ptr2", ps, depth, &info->ptr2))
2811                 return False;
2812         if(!smb_io_time("time2", &info->time2, ps, depth)) /* logon time */
2813                 return False;
2814         if(!prs_uint32("unknow1", ps, depth, &info->unknow1))
2815                 return False;
2816
2817
2818         if(!prs_uint32("buf_size2", ps, depth, &info->buf_size2))
2819                 return False;
2820         if(!prs_uint32("ptr3", ps, depth, &info->ptr3))
2821                 return False;
2822         for(i=0; i<12; i++)
2823                 if(!prs_uint32("unknow2", ps, depth, &info->unknow2))
2824                         return False;
2825
2826         if(!prs_uint32("chal_len", ps, depth, &info->chal_len))
2827                 return False;
2828         if(!prs_uint32("reserved1", ps, depth, &info->reserved1))
2829                 return False;
2830         if(!prs_uint32("chal_len2", ps, depth, &info->chal_len2))
2831                 return False;
2832
2833         if(!prs_uint8s (False, "chal", ps, depth, info->chal, info->chal_len2))
2834                 return False;
2835
2836         if(!prs_uint32("key_len", ps, depth, &info->key_len))
2837                 return False;
2838         if(!prs_uint32("reserved2", ps, depth, &info->reserved2))
2839                 return False;
2840         if(!prs_uint32("key_len2", ps, depth, &info->key_len2))
2841                 return False;
2842
2843         if(!prs_uint8s (False, "key", ps, depth, info->key, info->key_len2))
2844                 return False;
2845
2846
2847         if(!prs_uint32("buf_size3", ps, depth, &info->buf_size3))
2848                 return False;
2849
2850         if(!sec_io_desc("sec_desc2", &info->sec_desc2, ps, depth))
2851                 return False;
2852
2853
2854         return True;
2855 }
2856
2857 #endif
2858
2859 /*******************************************************************
2860 reads or writes a structure.
2861 ********************************************************************/
2862 static BOOL net_io_sam_privs_info(const char *desc, SAM_DELTA_PRIVS *info,
2863                                       prs_struct *ps, int depth)
2864 {
2865         unsigned int i;
2866
2867         prs_debug(ps, depth, desc, "net_io_sam_privs_info");
2868         depth++;
2869
2870         if(!prs_align(ps))
2871                 return False;
2872
2873         if(!smb_io_dom_sid2("sid", &info->sid, ps, depth))
2874                 return False;
2875
2876         if(!prs_uint32("priv_count", ps, depth, &info->priv_count))
2877                 return False;
2878         if(!prs_uint32("priv_control", ps, depth, &info->priv_control))
2879                 return False;
2880
2881         if(!prs_uint32("priv_attr_ptr", ps, depth, &info->priv_attr_ptr))
2882                 return False;
2883         if(!prs_uint32("priv_name_ptr", ps, depth, &info->priv_name_ptr))
2884                 return False;
2885
2886         if (!prs_uint32("paged_pool_limit", ps, depth, &info->paged_pool_limit))
2887                 return False;
2888         if (!prs_uint32("non_paged_pool_limit", ps, depth,
2889                         &info->non_paged_pool_limit))
2890                 return False;
2891         if (!prs_uint32("min_workset_size", ps, depth, &info->min_workset_size))
2892                 return False;
2893         if (!prs_uint32("max_workset_size", ps, depth, &info->max_workset_size))
2894                 return False;
2895         if (!prs_uint32("page_file_limit", ps, depth, &info->page_file_limit))
2896                 return False;
2897         if (!prs_uint64("time_limit", ps, depth, &info->time_limit))
2898                 return False;
2899         if (!prs_uint32("system_flags", ps, depth, &info->system_flags))
2900                 return False;
2901         if (!smb_io_bufhdr2("hdr_sec_desc", &info->hdr_sec_desc, ps, depth))
2902                 return False;
2903
2904         for (i=0; i<4; i++) {
2905                 UNIHDR dummy;
2906                 if (!smb_io_unihdr("dummy", &dummy, ps, depth))
2907                         return False;
2908         }
2909
2910         for (i=0; i<4; i++) {
2911                 uint32 reserved;
2912                 if (!prs_uint32("reserved", ps, depth, &reserved))
2913                         return False;
2914         }
2915
2916         if(!prs_uint32("attribute_count", ps, depth, &info->attribute_count))
2917                 return False;
2918
2919         info->attributes = TALLOC_ARRAY(ps->mem_ctx, uint32, info->attribute_count);
2920
2921         for (i=0; i<info->attribute_count; i++)
2922                 if(!prs_uint32("attributes", ps, depth, &info->attributes[i]))
2923                         return False;
2924
2925         if(!prs_uint32("privlist_count", ps, depth, &info->privlist_count))
2926                 return False;
2927
2928         info->hdr_privslist = TALLOC_ARRAY(ps->mem_ctx, UNIHDR, info->privlist_count);
2929         info->uni_privslist = TALLOC_ARRAY(ps->mem_ctx, UNISTR2, info->privlist_count);
2930
2931         for (i=0; i<info->privlist_count; i++)
2932                 if(!smb_io_unihdr("hdr_privslist", &info->hdr_privslist[i], ps, depth))
2933                         return False;
2934
2935         for (i=0; i<info->privlist_count; i++)
2936                 if (!smb_io_unistr2("uni_privslist", &info->uni_privslist[i], True, ps, depth))
2937                         return False;
2938
2939         if (!smb_io_rpc_blob("buf_sec_desc", &info->buf_sec_desc, ps, depth))
2940                 return False;
2941
2942         return True;
2943 }
2944
2945 /*******************************************************************
2946 reads or writes a structure.
2947 ********************************************************************/
2948 static BOOL net_io_sam_delta_ctr(const char *desc,
2949                                  SAM_DELTA_CTR * delta, uint16 type,
2950                                  prs_struct *ps, int depth)
2951 {
2952         prs_debug(ps, depth, desc, "net_io_sam_delta_ctr");
2953         depth++;
2954
2955         switch (type) {
2956                 /* Seen in sam deltas */
2957                 case SAM_DELTA_MODIFIED_COUNT:
2958                         if (!net_io_sam_delta_mod_count("", &delta->mod_count, ps, depth))
2959                                 return False;
2960                         break;
2961
2962                 case SAM_DELTA_DOMAIN_INFO:
2963                         if (!net_io_sam_domain_info("", &delta->domain_info, ps, depth))
2964                                 return False;
2965                         break;
2966
2967                 case SAM_DELTA_GROUP_INFO:
2968                         if (!net_io_sam_group_info("", &delta->group_info, ps, depth))
2969                                 return False;
2970                         break;
2971
2972                 case SAM_DELTA_ACCOUNT_INFO:
2973                         if (!net_io_sam_account_info("", &delta->account_info, ps, depth))
2974                                 return False;
2975                         break;
2976
2977                 case SAM_DELTA_GROUP_MEM:
2978                         if (!net_io_sam_group_mem_info("", &delta->grp_mem_info, ps, depth))
2979                                 return False;
2980                         break;
2981
2982                 case SAM_DELTA_ALIAS_INFO:
2983                         if (!net_io_sam_alias_info("", &delta->alias_info, ps, depth))
2984                                 return False;
2985                         break;
2986
2987                 case SAM_DELTA_POLICY_INFO:
2988                         if (!net_io_sam_policy_info("", &delta->policy_info, ps, depth))
2989                                 return False;
2990                         break;
2991
2992                 case SAM_DELTA_ALIAS_MEM:
2993                         if (!net_io_sam_alias_mem_info("", &delta->als_mem_info, ps, depth))
2994                                 return False;
2995                         break;
2996
2997                 case SAM_DELTA_PRIVS_INFO:
2998                         if (!net_io_sam_privs_info("", &delta->privs_info, ps, depth))
2999                                 return False;
3000                         break;
3001
3002                         /* These guys are implemented but broken */
3003
3004                 case SAM_DELTA_TRUST_DOMS:
3005                 case SAM_DELTA_SECRET_INFO:
3006                         break;
3007
3008                         /* These guys are not implemented yet */
3009
3010                 case SAM_DELTA_RENAME_GROUP:
3011                 case SAM_DELTA_RENAME_USER:
3012                 case SAM_DELTA_RENAME_ALIAS:
3013                 case SAM_DELTA_DELETE_GROUP:
3014                 case SAM_DELTA_DELETE_USER:
3015                 default:
3016                         DEBUG(0, ("Replication error: Unknown delta type 0x%x\n", type));
3017                         break;
3018         }
3019
3020         return True;
3021 }
3022
3023 /*******************************************************************
3024 reads or writes a structure.
3025 ********************************************************************/
3026 BOOL net_io_r_sam_sync(const char *desc,
3027                        NET_R_SAM_SYNC * r_s, prs_struct *ps, int depth)
3028 {
3029         uint32 i;
3030
3031         prs_debug(ps, depth, desc, "net_io_r_sam_sync");
3032         depth++;
3033
3034         if (!smb_io_cred("srv_creds", &r_s->srv_creds, ps, depth))
3035                 return False;
3036         if (!prs_uint32("sync_context", ps, depth, &r_s->sync_context))
3037                 return False;
3038
3039         if (!prs_uint32("ptr_deltas", ps, depth, &r_s->ptr_deltas))
3040                 return False;
3041         if (r_s->ptr_deltas != 0)
3042         {
3043                 if (!prs_uint32("num_deltas ", ps, depth, &r_s->num_deltas))
3044                         return False;
3045                 if (!prs_uint32("ptr_deltas2", ps, depth, &r_s->ptr_deltas2))
3046                         return False;
3047                 if (r_s->ptr_deltas2 != 0)
3048                 {
3049                         if (!prs_uint32("num_deltas2", ps, depth,
3050                                         &r_s->num_deltas2))
3051                                 return False;
3052
3053                         if (r_s->num_deltas2 != r_s->num_deltas)
3054                         {
3055                                 /* RPC fault */
3056                                 return False;
3057                         }
3058
3059                         if (r_s->num_deltas2 > 0) {
3060                                 r_s->hdr_deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_HDR, r_s->num_deltas2);
3061                                 if (r_s->hdr_deltas == NULL) {
3062                                         DEBUG(0, ("error tallocating memory "
3063                                                   "for %d delta headers\n",
3064                                                   r_s->num_deltas2));
3065                                         return False;
3066                                 }
3067                         }
3068
3069                         for (i = 0; i < r_s->num_deltas2; i++)
3070                         {
3071                                 if (!net_io_sam_delta_hdr("",
3072                                                           &r_s->hdr_deltas[i],
3073                                                           ps, depth))
3074                                         return False;
3075                         }
3076
3077                         if (r_s->num_deltas2 > 0) {
3078                                 r_s->deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_CTR, r_s->num_deltas2);
3079                                 if (r_s->deltas == NULL) {
3080                                         DEBUG(0, ("error tallocating memory "
3081                                                   "for %d deltas\n",
3082                                                   r_s->num_deltas2));
3083                                         return False;
3084                                 }
3085                         }
3086
3087                         for (i = 0; i < r_s->num_deltas2; i++)
3088                         {
3089                                 if (!net_io_sam_delta_ctr(
3090                                         "", &r_s->deltas[i],
3091                                         r_s->hdr_deltas[i].type3,
3092                                         ps, depth)) {
3093                                         DEBUG(0, ("hmm, failed on i=%d\n", i));
3094                                         return False;
3095                                 }
3096                         }
3097                 }
3098         }
3099
3100         prs_align(ps);
3101         if (!prs_ntstatus("status", ps, depth, &(r_s->status)))
3102                 return False;
3103
3104         return True;
3105 }
3106
3107 /*******************************************************************
3108 makes a NET_Q_SAM_DELTAS structure.
3109 ********************************************************************/
3110 BOOL init_net_q_sam_deltas(NET_Q_SAM_DELTAS *q_s, const char *srv_name,
3111                            const char *cli_name, DOM_CRED *cli_creds,
3112                            uint32 database_id, UINT64_S dom_mod_count)
3113 {
3114         DEBUG(5, ("init_net_q_sam_deltas\n"));
3115
3116         init_unistr2(&q_s->uni_srv_name, srv_name, UNI_STR_TERMINATE);
3117         init_unistr2(&q_s->uni_cli_name, cli_name, UNI_STR_TERMINATE);
3118
3119         memcpy(&q_s->cli_creds, cli_creds, sizeof(q_s->cli_creds));
3120         memset(&q_s->ret_creds, 0, sizeof(q_s->ret_creds));
3121
3122         q_s->database_id = database_id;
3123         q_s->dom_mod_count.low = dom_mod_count.low;
3124         q_s->dom_mod_count.high = dom_mod_count.high;
3125         q_s->max_size = 0xffff;
3126
3127         return True;
3128 }
3129
3130 /*******************************************************************
3131 reads or writes a structure.
3132 ********************************************************************/
3133 BOOL net_io_q_sam_deltas(const char *desc, NET_Q_SAM_DELTAS *q_s, prs_struct *ps,
3134                          int depth)
3135 {
3136         prs_debug(ps, depth, desc, "net_io_q_sam_deltas");
3137         depth++;
3138
3139         if (!smb_io_unistr2("", &q_s->uni_srv_name, True, ps, depth))
3140                 return False;
3141         if (!smb_io_unistr2("", &q_s->uni_cli_name, True, ps, depth))
3142                 return False;
3143
3144         if (!smb_io_cred("", &q_s->cli_creds, ps, depth))
3145                 return False;
3146         if (!smb_io_cred("", &q_s->ret_creds, ps, depth))
3147                 return False;
3148
3149         if (!prs_uint32("database_id  ", ps, depth, &q_s->database_id))
3150                 return False;
3151         if (!prs_uint64("dom_mod_count", ps, depth, &q_s->dom_mod_count))
3152                 return False;
3153         if (!prs_uint32("max_size", ps, depth, &q_s->max_size))
3154                 return False;
3155
3156         return True;
3157 }
3158
3159 /*******************************************************************
3160 reads or writes a structure.
3161 ********************************************************************/
3162 BOOL net_io_r_sam_deltas(const char *desc,
3163                          NET_R_SAM_DELTAS *r_s, prs_struct *ps, int depth)
3164 {
3165         unsigned int i;
3166
3167         prs_debug(ps, depth, desc, "net_io_r_sam_deltas");
3168         depth++;
3169
3170         if (!smb_io_cred("srv_creds", &r_s->srv_creds, ps, depth))
3171                 return False;
3172         if (!prs_uint64("dom_mod_count", ps, depth, &r_s->dom_mod_count))
3173                 return False;
3174
3175         if (!prs_uint32("ptr_deltas", ps, depth, &r_s->ptr_deltas))
3176                 return False;
3177         if (!prs_uint32("num_deltas", ps, depth, &r_s->num_deltas))
3178                 return False;
3179         if (!prs_uint32("ptr_deltas2", ps, depth, &r_s->num_deltas2))
3180                 return False;
3181
3182         if (r_s->num_deltas2 != 0)
3183         {
3184                 if (!prs_uint32("num_deltas2 ", ps, depth, &r_s->num_deltas2))
3185                         return False;
3186
3187                 if (r_s->ptr_deltas != 0)
3188                 {
3189                         if (r_s->num_deltas > 0) {
3190                                 r_s->hdr_deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_HDR, r_s->num_deltas);
3191                                 if (r_s->hdr_deltas == NULL) {
3192                                         DEBUG(0, ("error tallocating memory "
3193                                                   "for %d delta headers\n",
3194                                                   r_s->num_deltas));
3195                                         return False;
3196                                 }
3197                         }
3198
3199                         for (i = 0; i < r_s->num_deltas; i++)
3200                         {
3201                                 net_io_sam_delta_hdr("", &r_s->hdr_deltas[i],
3202                                                       ps, depth);
3203                         }
3204
3205                         if (r_s->num_deltas > 0) {
3206                                 r_s->deltas = TALLOC_ARRAY(ps->mem_ctx, SAM_DELTA_CTR, r_s->num_deltas);
3207                                 if (r_s->deltas == NULL) {
3208                                         DEBUG(0, ("error tallocating memory "
3209                                                   "for %d deltas\n",
3210                                                   r_s->num_deltas));
3211                                         return False;
3212                                 }
3213                         }
3214
3215                         for (i = 0; i < r_s->num_deltas; i++)
3216                         {
3217                                 if (!net_io_sam_delta_ctr(
3218                                         "",
3219                                         &r_s->deltas[i],
3220                                         r_s->hdr_deltas[i].type2,
3221                                         ps, depth))
3222
3223                                         return False;
3224                         }
3225                 }
3226         }
3227
3228         prs_align(ps);
3229         if (!prs_ntstatus("status", ps, depth, &r_s->status))
3230                 return False;
3231
3232         return True;
3233 }
3234
3235 /*******************************************************************
3236  Inits a NET_Q_DSR_GETDCNAME structure.
3237 ********************************************************************/
3238
3239 void init_net_q_dsr_getdcname(NET_Q_DSR_GETDCNAME *r_t, const char *server_unc,
3240                               const char *domain_name,
3241                               struct uuid *domain_guid,
3242                               struct uuid *site_guid,
3243                               uint32_t flags)
3244 {
3245         DEBUG(5, ("init_net_q_dsr_getdcname\n"));
3246
3247         r_t->ptr_server_unc = (server_unc != NULL);
3248         init_unistr2(&r_t->uni_server_unc, server_unc, UNI_STR_TERMINATE);
3249
3250         r_t->ptr_domain_name = (domain_name != NULL);
3251         init_unistr2(&r_t->uni_domain_name, domain_name, UNI_STR_TERMINATE);
3252
3253         r_t->ptr_domain_guid = (domain_guid != NULL);
3254         r_t->domain_guid = domain_guid;
3255
3256         r_t->ptr_site_guid = (site_guid != NULL);
3257         r_t->site_guid = site_guid;
3258
3259         r_t->flags = flags;
3260 }
3261
3262 /*******************************************************************
3263  Reads or writes an NET_Q_DSR_GETDCNAME structure.
3264 ********************************************************************/
3265
3266 BOOL net_io_q_dsr_getdcname(const char *desc, NET_Q_DSR_GETDCNAME *r_t,
3267                             prs_struct *ps, int depth)
3268 {
3269         if (r_t == NULL)
3270                 return False;
3271
3272         prs_debug(ps, depth, desc, "net_io_q_dsr_getdcname");
3273         depth++;
3274
3275         if (!prs_uint32("ptr_server_unc", ps, depth, &r_t->ptr_server_unc))
3276                 return False;
3277
3278         if (!smb_io_unistr2("server_unc", &r_t->uni_server_unc,
3279                             r_t->ptr_server_unc, ps, depth))
3280                 return False;
3281
3282         if (!prs_align(ps))
3283                 return False;
3284
3285         if (!prs_uint32("ptr_domain_name", ps, depth, &r_t->ptr_domain_name))
3286                 return False;
3287
3288         if (!smb_io_unistr2("domain_name", &r_t->uni_domain_name,
3289                             r_t->ptr_domain_name, ps, depth))
3290                 return False;
3291
3292         if (!prs_align(ps))
3293                 return False;
3294
3295         if (!prs_uint32("ptr_domain_guid", ps, depth, &r_t->ptr_domain_guid))
3296                 return False;
3297
3298         if (UNMARSHALLING(ps) && (r_t->ptr_domain_guid)) {
3299                 r_t->domain_guid = PRS_ALLOC_MEM(ps, struct uuid, 1);
3300                 if (r_t->domain_guid == NULL)
3301                         return False;
3302         }
3303
3304         if ((r_t->ptr_domain_guid) &&
3305             (!smb_io_uuid("domain_guid", r_t->domain_guid, ps, depth)))
3306                 return False;
3307
3308         if (!prs_align(ps))
3309                 return False;
3310
3311         if (!prs_uint32("ptr_site_guid", ps, depth, &r_t->ptr_site_guid))
3312                 return False;
3313
3314         if (UNMARSHALLING(ps) && (r_t->ptr_site_guid)) {
3315                 r_t->site_guid = PRS_ALLOC_MEM(ps, struct uuid, 1);
3316                 if (r_t->site_guid == NULL)
3317                         return False;
3318         }
3319
3320         if ((r_t->ptr_site_guid) &&
3321             (!smb_io_uuid("site_guid", r_t->site_guid, ps, depth)))
3322                 return False;
3323
3324         if (!prs_align(ps))
3325                 return False;
3326
3327         if (!prs_uint32("flags", ps, depth, &r_t->flags))
3328                 return False;
3329
3330         return True;
3331 }
3332
3333 /*******************************************************************
3334  Inits a NET_R_DSR_GETDCNAME structure.
3335 ********************************************************************/
3336 void init_net_r_dsr_getdcname(NET_R_DSR_GETDCNAME *r_t, const char *dc_unc,
3337                               const char *dc_address, int32 dc_address_type,
3338                               struct uuid domain_guid, const char *domain_name,
3339                               const char *forest_name, uint32 dc_flags,
3340                               const char *dc_site_name,
3341                               const char *client_site_name)
3342 {
3343         DEBUG(5, ("init_net_q_dsr_getdcname\n"));
3344
3345         r_t->ptr_dc_unc = (dc_unc != NULL);
3346         init_unistr2(&r_t->uni_dc_unc, dc_unc, UNI_STR_TERMINATE);
3347
3348         r_t->ptr_dc_address = (dc_address != NULL);
3349         init_unistr2(&r_t->uni_dc_address, dc_address, UNI_STR_TERMINATE);
3350
3351         r_t->dc_address_type = dc_address_type;
3352         r_t->domain_guid = domain_guid;
3353
3354         r_t->ptr_domain_name = (domain_name != NULL);
3355         init_unistr2(&r_t->uni_domain_name, domain_name, UNI_STR_TERMINATE);
3356
3357         r_t->ptr_forest_name = (forest_name != NULL);
3358         init_unistr2(&r_t->uni_forest_name, forest_name, UNI_STR_TERMINATE);
3359
3360         r_t->dc_flags = dc_flags;
3361
3362         r_t->ptr_dc_site_name = (dc_site_name != NULL);
3363         init_unistr2(&r_t->uni_dc_site_name, dc_site_name, UNI_STR_TERMINATE);
3364
3365         r_t->ptr_client_site_name = (client_site_name != NULL);
3366         init_unistr2(&r_t->uni_client_site_name, client_site_name,
3367                      UNI_STR_TERMINATE);
3368 }
3369
3370 /*******************************************************************
3371  Reads or writes an NET_R_DSR_GETDCNAME structure.
3372 ********************************************************************/
3373
3374 BOOL net_io_r_dsr_getdcname(const char *desc, NET_R_DSR_GETDCNAME *r_t,
3375                             prs_struct *ps, int depth)
3376 {
3377         uint32 info_ptr = 1;
3378
3379         if (r_t == NULL)
3380                 return False;
3381
3382         prs_debug(ps, depth, desc, "net_io_r_dsr_getdcname");
3383         depth++;
3384
3385         /* The reply contains *just* an info struct, this is the ptr to it */
3386         if (!prs_uint32("info_ptr", ps, depth, &info_ptr))
3387                 return False;
3388
3389         if (info_ptr == 0)
3390                 return False;
3391
3392         if (!prs_uint32("ptr_dc_unc", ps, depth, &r_t->ptr_dc_unc))
3393                 return False;
3394
3395         if (!prs_uint32("ptr_dc_address", ps, depth, &r_t->ptr_dc_address))
3396                 return False;
3397
3398         if (!prs_int32("dc_address_type", ps, depth, &r_t->dc_address_type))
3399                 return False;
3400
3401         if (!smb_io_uuid("domain_guid", &r_t->domain_guid, ps, depth))
3402                 return False;
3403
3404         if (!prs_uint32("ptr_domain_name", ps, depth, &r_t->ptr_domain_name))
3405                 return False;
3406
3407         if (!prs_uint32("ptr_forest_name", ps, depth, &r_t->ptr_forest_name))
3408                 return False;
3409
3410         if (!prs_uint32("dc_flags", ps, depth, &r_t->dc_flags))
3411                 return False;
3412
3413         if (!prs_uint32("ptr_dc_site_name", ps, depth, &r_t->ptr_dc_site_name))
3414                 return False;
3415
3416         if (!prs_uint32("ptr_client_site_name", ps, depth,
3417                         &r_t->ptr_client_site_name))
3418                 return False;
3419
3420         if (!prs_align(ps))
3421                 return False;
3422
3423         if (!smb_io_unistr2("dc_unc", &r_t->uni_dc_unc,
3424                             r_t->ptr_dc_unc, ps, depth))
3425                 return False;
3426
3427         if (!prs_align(ps))
3428                 return False;
3429
3430         if (!smb_io_unistr2("dc_address", &r_t->uni_dc_address,
3431                             r_t->ptr_dc_address, ps, depth))
3432                 return False;
3433
3434         if (!prs_align(ps))
3435                 return False;
3436
3437         if (!smb_io_unistr2("domain_name", &r_t->uni_domain_name,
3438                             r_t->ptr_domain_name, ps, depth))
3439                 return False;
3440
3441         if (!prs_align(ps))
3442                 return False;
3443
3444         if (!smb_io_unistr2("forest_name", &r_t->uni_forest_name,
3445                             r_t->ptr_forest_name, ps, depth))
3446                 return False;
3447
3448         if (!prs_align(ps))
3449                 return False;
3450
3451         if (!smb_io_unistr2("dc_site_name", &r_t->uni_dc_site_name,
3452                             r_t->ptr_dc_site_name, ps, depth))
3453                 return False;
3454
3455         if (!prs_align(ps))
3456                 return False;
3457
3458         if (!smb_io_unistr2("client_site_name", &r_t->uni_client_site_name,
3459                             r_t->ptr_client_site_name, ps, depth))
3460                 return False;
3461
3462         if (!prs_align(ps))
3463                 return False;
3464
3465         if (!prs_werror("result", ps, depth, &r_t->result))
3466                 return False;
3467
3468         return True;
3469 }
3470
3471 /*******************************************************************
3472  Inits a NET_Q_DSR_GETSITENAME structure.
3473 ********************************************************************/
3474
3475 void init_net_q_dsr_getsitename(NET_Q_DSR_GETSITENAME *r_t, const char *computer_name)
3476 {
3477         DEBUG(5, ("init_net_q_dsr_getsitename\n"));
3478
3479         r_t->ptr_computer_name = (computer_name != NULL);
3480         init_unistr2(&r_t->uni_computer_name, computer_name, UNI_STR_TERMINATE);
3481 }
3482
3483 /*******************************************************************
3484  Reads or writes an NET_Q_DSR_GETSITENAME structure.
3485 ********************************************************************/
3486
3487 BOOL net_io_q_dsr_getsitename(const char *desc, NET_Q_DSR_GETSITENAME *r_t,
3488                               prs_struct *ps, int depth)
3489 {
3490         if (r_t == NULL)
3491                 return False;
3492
3493         prs_debug(ps, depth, desc, "net_io_q_dsr_getsitename");
3494         depth++;
3495
3496         if (!prs_uint32("ptr_computer_name", ps, depth, &r_t->ptr_computer_name))
3497                 return False;
3498
3499         if (!smb_io_unistr2("computer_name", &r_t->uni_computer_name,
3500                             r_t->ptr_computer_name, ps, depth))
3501                 return False;
3502
3503         if (!prs_align(ps))
3504                 return False;
3505
3506         return True;
3507 }
3508
3509 /*******************************************************************
3510  Reads or writes an NET_R_DSR_GETSITENAME structure.
3511 ********************************************************************/
3512
3513 BOOL net_io_r_dsr_getsitename(const char *desc, NET_R_DSR_GETSITENAME *r_t,
3514                               prs_struct *ps, int depth)
3515 {
3516         if (r_t == NULL)
3517                 return False;
3518
3519         prs_debug(ps, depth, desc, "net_io_r_dsr_getsitename");
3520         depth++;
3521
3522         if (!prs_uint32("ptr_site_name", ps, depth, &r_t->ptr_site_name))
3523                 return False;
3524
3525         if (!prs_align(ps))
3526                 return False;
3527
3528         if (!smb_io_unistr2("site_name", &r_t->uni_site_name,
3529                             r_t->ptr_site_name, ps, depth))
3530                 return False;
3531
3532         if (!prs_align(ps))
3533                 return False;
3534
3535         if (!prs_werror("result", ps, depth, &r_t->result))
3536                 return False;
3537
3538         return True;
3539 }
3540
3541