source3/rpc_parse/parse_srv.c

   1
   2 /*
   3  *  Unix SMB/Netbios implementation.
   4  *  Version 1.9.
   5  *  RPC Pipe client / server routines
   6  *  Copyright (C) Andrew Tridgell              1992-1997,
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   8  *  Copyright (C) Paul Ashton                       1997.
   9  *  Copyright (C) Jeremy Allison                    1999.
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26
  27 #include "includes.h"
  28
  29 extern int DEBUGLEVEL;
  30
  31 /*******************************************************************
  32  Inits a SH_INFO_1_STR structure
  33 ********************************************************************/
  34
  35 void init_srv_share_info1_str(SH_INFO_1_STR *sh1, char *net_name, char *remark)
  36 {
  37         DEBUG(5,("init_srv_share_info1_str\n"));
  38
  39         init_unistr2(&sh1->uni_netname, net_name, strlen(net_name)+1);
  40         init_unistr2(&sh1->uni_remark, remark, strlen(remark)+1);
  41 }
  42
  43 /*******************************************************************
  44  Reads or writes a structure.
  45 ********************************************************************/
  46
  47 static BOOL srv_io_share_info1_str(char *desc, SH_INFO_1_STR *sh1, prs_struct *ps, int depth)
  48 {
  49         if (sh1 == NULL)
  50                 return False;
  51
  52         prs_debug(ps, depth, desc, "srv_io_share_info1_str");
  53         depth++;
  54
  55         if(!prs_align(ps))
  56                 return False;
  57
  58         if(!smb_io_unistr2("", &sh1->uni_netname, True, ps, depth))
  59                 return False;
  60         if(!smb_io_unistr2("", &sh1->uni_remark, True, ps, depth))
  61                 return False;
  62
  63         return True;
  64 }
  65
  66 /*******************************************************************
  67  makes a SH_INFO_1 structure
  68 ********************************************************************/
  69
  70 void init_srv_share_info1(SH_INFO_1 *sh1, char *net_name, uint32 type, char *remark)
  71 {
  72         DEBUG(5,("init_srv_share_info1: %s %8x %s\n", net_name, type, remark));
  73
  74         sh1->ptr_netname = (net_name != NULL) ? 1 : 0;
  75         sh1->type        = type;
  76         sh1->ptr_remark  = (remark != NULL) ? 1 : 0;
  77 }
  78
  79 /*******************************************************************
  80  Reads or writes a structure.
  81 ********************************************************************/
  82
  83 static BOOL srv_io_share_info1(char *desc, SH_INFO_1 *sh1, prs_struct *ps, int depth)
  84 {
  85         if (sh1 == NULL)
  86                 return False;
  87
  88         prs_debug(ps, depth, desc, "srv_io_share_info1");
  89         depth++;
  90
  91         if(!prs_align(ps))
  92                 return False;
  93
  94         if(!prs_uint32("ptr_netname", ps, depth, &sh1->ptr_netname))
  95                 return False;
  96         if(!prs_uint32("type       ", ps, depth, &sh1->type))
  97                 return False;
  98         if(!prs_uint32("ptr_remark ", ps, depth, &sh1->ptr_remark))
  99                 return False;
 100
 101         return True;
 102 }
 103
 104 /*******************************************************************
 105  Inits a SH_INFO_2_STR structure
 106 ********************************************************************/
 107
 108 void init_srv_share_info2_str(SH_INFO_2_STR *sh2,
 109                                 char *net_name, char *remark,
 110                                 char *path, char *passwd)
 111 {
 112         DEBUG(5,("init_srv_share_info2_str\n"));
 113
 114         init_unistr2(&sh2->uni_netname, net_name, strlen(net_name)+1);
 115         init_unistr2(&sh2->uni_remark, remark, strlen(remark)+1);
 116         init_unistr2(&sh2->uni_path, path, strlen(path)+1);
 117         init_unistr2(&sh2->uni_passwd, passwd, strlen(passwd)+1);
 118 }
 119
 120 /*******************************************************************
 121  Reads or writes a structure.
 122 ********************************************************************/
 123
 124 static BOOL srv_io_share_info2_str(char *desc, SH_INFO_2_STR *sh2, prs_struct *ps, int depth)
 125 {
 126         if (sh2 == NULL)
 127                 return False;
 128
 129         prs_debug(ps, depth, desc, "srv_io_share_info2_str");
 130         depth++;
 131
 132         if(!prs_align(ps))
 133                 return False;
 134
 135         if(!smb_io_unistr2("", &sh2->uni_netname, True, ps, depth))
 136                 return False;
 137         if(!smb_io_unistr2("", &sh2->uni_remark, True, ps, depth))
 138                 return False;
 139         if(!smb_io_unistr2("", &sh2->uni_path, True, ps, depth))
 140                 return False;
 141         if(!smb_io_unistr2("", &sh2->uni_passwd, True, ps, depth))
 142                 return False;
 143
 144         return True;
 145 }
 146
 147 /*******************************************************************
 148  Inits a SH_INFO_2 structure
 149 ********************************************************************/
 150
 151 void init_srv_share_info2(SH_INFO_2 *sh2,
 152                                 char *net_name, uint32 type, char *remark,
 153                                 uint32 perms, uint32 max_uses, uint32 num_uses,
 154                                 char *path, char *passwd)
 155 {
 156         DEBUG(5,("init_srv_share_info2: %s %8x %s\n", net_name, type, remark));
 157
 158         sh2->ptr_netname = (net_name != NULL) ? 1 : 0;
 159         sh2->type        = type;
 160         sh2->ptr_remark  = (remark != NULL) ? 1 : 0;
 161         sh2->perms       = perms;
 162         sh2->max_uses    = max_uses;
 163         sh2->num_uses    = num_uses;
 164         sh2->type        = type;
 165         sh2->ptr_path    = (path != NULL) ? 1 : 0;
 166         sh2->ptr_passwd  = (passwd != NULL) ? 1 : 0;
 167 }
 168
 169 /*******************************************************************
 170  Reads or writes a structure.
 171 ********************************************************************/
 172
 173 static BOOL srv_io_share_info2(char *desc, SH_INFO_2 *sh2, prs_struct *ps, int depth)
 174 {
 175         if (sh2 == NULL)
 176                 return False;
 177
 178         prs_debug(ps, depth, desc, "srv_io_share_info2");
 179         depth++;
 180
 181         if(!prs_align(ps))
 182                 return False;
 183
 184         if(!prs_uint32("ptr_netname", ps, depth, &sh2->ptr_netname))
 185                 return False;
 186         if(!prs_uint32("type       ", ps, depth, &sh2->type))
 187                 return False;
 188         if(!prs_uint32("ptr_remark ", ps, depth, &sh2->ptr_remark))
 189                 return False;
 190         if(!prs_uint32("perms      ", ps, depth, &sh2->perms))
 191                 return False;
 192         if(!prs_uint32("max_uses   ", ps, depth, &sh2->max_uses))
 193                 return False;
 194         if(!prs_uint32("num_uses   ", ps, depth, &sh2->num_uses))
 195                 return False;
 196         if(!prs_uint32("ptr_path   ", ps, depth, &sh2->ptr_path))
 197                 return False;
 198         if(!prs_uint32("ptr_passwd ", ps, depth, &sh2->ptr_passwd))
 199                 return False;
 200
 201         return True;
 202 }
 203
 204 /*******************************************************************
 205  Reads or writes a structure.
 206 ********************************************************************/
 207
 208 static BOOL srv_io_srv_share_ctr(char *desc, SRV_SHARE_INFO_CTR *ctr, prs_struct *ps, int depth)
 209 {
 210         if (ctr == NULL)
 211                 return False;
 212
 213         prs_debug(ps, depth, desc, "srv_io_srv_share_ctr");
 214         depth++;
 215
 216         if (UNMARSHALLING(ps)) {
 217                 memset(ctr, '\0', sizeof(SRV_SHARE_INFO_CTR));
 218         }
 219
 220         if(!prs_align(ps))
 221                 return False;
 222
 223         if(!prs_uint32("info_level", ps, depth, &ctr->info_level))
 224                 return False;
 225
 226         if (ctr->info_level == 0)
 227                 return True;
 228
 229         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
 230                 return False;
 231         if(!prs_uint32("ptr_share_info", ps, depth, &ctr->ptr_share_info))
 232                 return False;
 233
 234         if (ctr->ptr_share_info == 0)
 235                 return True;
 236
 237         if(!prs_uint32("num_entries", ps, depth, &ctr->num_entries))
 238                 return False;
 239         if(!prs_uint32("ptr_entries", ps, depth, &ctr->ptr_entries))
 240                 return False;
 241
 242         if (ctr->ptr_entries == 0) {
 243                 if (ctr->num_entries == 0)
 244                         return True;
 245                 else
 246                         return False;
 247         }
 248
 249         if(!prs_uint32("num_entries2", ps, depth, &ctr->num_entries2))
 250                 return False;
 251
 252         if (ctr->num_entries2 != ctr->num_entries)
 253                 return False;
 254
 255         switch (ctr->switch_value) {
 256         case 1:
 257         {
 258                 SRV_SHARE_INFO_1 *info1 = ctr->share.info1;
 259                 int num_entries = ctr->num_entries;
 260                 int i;
 261
 262                 if (UNMARSHALLING(ps)) {
 263                         if (!(info1 = malloc(num_entries * sizeof(SRV_SHARE_INFO_1))))
 264                                 return False;
 265                         memset(info1, '\0', num_entries * sizeof(SRV_SHARE_INFO_1));
 266                         ctr->share.info1 = info1;
 267                 }
 268
 269                 for (i = 0; i < num_entries; i++) {
 270                         if(!srv_io_share_info1("", &info1[i].info_1, ps, depth))
 271                                 return False;
 272                 }
 273
 274                 for (i = 0; i < num_entries; i++) {
 275                         if(!srv_io_share_info1_str("", &info1[i].info_1_str, ps, depth))
 276                                 return False;
 277                 }
 278
 279                 break;
 280         }
 281
 282         case 2:
 283         {
 284                 SRV_SHARE_INFO_2 *info2 = ctr->share.info2;
 285                 int num_entries = ctr->num_entries;
 286                 int i;
 287
 288                 if (UNMARSHALLING(ps)) {
 289                         if (!(info2 = malloc(num_entries * sizeof(SRV_SHARE_INFO_2))))
 290                                 return False;
 291                         memset(info2, '\0', num_entries * sizeof(SRV_SHARE_INFO_2));
 292                         ctr->share.info2 = info2;
 293                 }
 294
 295                 for (i = 0; i < num_entries; i++) {
 296                         if(!srv_io_share_info2("", &info2[i].info_2, ps, depth))
 297                                 return False;
 298                 }
 299
 300                 for (i = 0; i < num_entries; i++) {
 301                         if(!srv_io_share_info2_str("", &info2[i].info_2_str, ps, depth))
 302                                 return False;
 303                 }
 304
 305                 break;
 306         }
 307
 308         default:
 309                 DEBUG(5,("%s no share info at switch_value %d\n",
 310                          tab_depth(depth), ctr->switch_value));
 311                 break;
 312         }
 313
 314         return True;
 315 }
 316
 317 /*******************************************************************
 318  Frees a SRV_SHARE_INFO_CTR structure.
 319 ********************************************************************/
 320
 321 void free_srv_share_info_ctr(SRV_SHARE_INFO_CTR *ctr)
 322 {
 323         if(!ctr)
 324                 return;
 325         if(ctr->share.info)
 326                 free(ctr->share.info);
 327         memset(ctr, '\0', sizeof(SRV_SHARE_INFO_CTR));
 328 }
 329
 330 /*******************************************************************
 331  Frees a SRV_Q_NET_SHARE_ENUM structure.
 332 ********************************************************************/
 333
 334 void free_srv_q_net_share_enum(SRV_Q_NET_SHARE_ENUM *q_n)
 335 {
 336         if(!q_n)
 337                 return;
 338         free_srv_share_info_ctr(&q_n->ctr);
 339         memset(q_n, '\0', sizeof(SRV_Q_NET_SHARE_ENUM));
 340 }
 341
 342 /*******************************************************************
 343  Frees a SRV_R_NET_SHARE_ENUM structure.
 344 ********************************************************************/
 345
 346 void free_srv_r_net_share_enum(SRV_R_NET_SHARE_ENUM *r_n)
 347 {
 348         if(!r_n)
 349                 return;
 350         free_srv_share_info_ctr(&r_n->ctr);
 351         memset(r_n, '\0', sizeof(SRV_R_NET_SHARE_ENUM));
 352 }
 353
 354 /*******************************************************************
 355  Inits a SRV_Q_NET_SHARE_ENUM structure.
 356 ********************************************************************/
 357
 358 void init_srv_q_net_share_enum(SRV_Q_NET_SHARE_ENUM *q_n,
 359                                 char *srv_name, uint32 info_level,
 360                                 uint32 preferred_len, ENUM_HND *hnd)
 361 {
 362
 363         DEBUG(5,("init_q_net_share_enum\n"));
 364
 365         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
 366
 367         q_n->ctr.info_level = q_n->ctr.switch_value = info_level;
 368         q_n->ctr.ptr_share_info = 0;
 369         q_n->preferred_len = preferred_len;
 370
 371         memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
 372 }
 373
 374 /*******************************************************************
 375  Reads or writes a structure.
 376 ********************************************************************/
 377
 378 BOOL srv_io_q_net_share_enum(char *desc, SRV_Q_NET_SHARE_ENUM *q_n, prs_struct *ps, int depth)
 379 {
 380         if (q_n == NULL)
 381                 return False;
 382
 383         prs_debug(ps, depth, desc, "srv_io_q_net_share_enum");
 384         depth++;
 385
 386         if(!prs_align(ps))
 387                 return False;
 388
 389         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
 390                 return False;
 391         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
 392                 return False;
 393
 394         if(!srv_io_srv_share_ctr("share_ctr", &q_n->ctr, ps, depth))
 395                 return False;
 396
 397         if(!prs_align(ps))
 398                 return False;
 399
 400         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
 401                 return False;
 402
 403         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
 404                 return False;
 405
 406         return True;
 407 }
 408
 409 /*******************************************************************
 410  Reads or writes a structure.
 411 ********************************************************************/
 412
 413 BOOL srv_io_r_net_share_enum(char *desc, SRV_R_NET_SHARE_ENUM *r_n, prs_struct *ps, int depth)
 414 {
 415         if (r_n == NULL)
 416                 return False;
 417
 418         prs_debug(ps, depth, desc, "srv_io_r_net_share_enum");
 419         depth++;
 420
 421         if(!srv_io_srv_share_ctr("share_ctr", &r_n->ctr, ps, depth))
 422                 return False;
 423
 424         if(!prs_align(ps))
 425                 return False;
 426
 427         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
 428                 return False;
 429         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
 430                 return False;
 431         if(!prs_uint32("status     ", ps, depth, &r_n->status))
 432                 return False;
 433
 434         return True;
 435 }
 436
 437 /*******************************************************************
 438  Frees a SRV_Q_NET_SHARE_GET_INFO structure.
 439 ********************************************************************/
 440
 441 void free_srv_q_net_share_get_info(SRV_Q_NET_SHARE_GET_INFO *q_n)
 442 {
 443         if(!q_n)
 444                 return;
 445         memset(q_n, '\0', sizeof(SRV_Q_NET_SHARE_GET_INFO));
 446 }
 447
 448 /*******************************************************************
 449  Frees a SRV_R_NET_SHARE_GET_INFO structure.
 450 ********************************************************************/
 451
 452 void free_srv_r_net_share_get_info(SRV_R_NET_SHARE_GET_INFO *r_n)
 453 {
 454         if(!r_n)
 455                 return;
 456         memset(r_n, '\0', sizeof(SRV_R_NET_SHARE_GET_INFO));
 457 }
 458
 459 /*******************************************************************
 460  Reads or writes a structure.
 461 ********************************************************************/
 462
 463 BOOL srv_io_q_net_share_get_info(char *desc, SRV_Q_NET_SHARE_GET_INFO *q_n, prs_struct *ps, int depth)
 464 {
 465         if (q_n == NULL)
 466                 return False;
 467
 468         prs_debug(ps, depth, desc, "srv_io_q_net_share_get_info");
 469         depth++;
 470
 471         if(!prs_align(ps))
 472                 return False;
 473
 474         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
 475                 return False;
 476         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
 477                 return False;
 478
 479         if(!smb_io_unistr2("", &q_n->uni_share_name, True, ps, depth))
 480                 return False;
 481
 482         if(!prs_align(ps))
 483                 return False;
 484
 485         if(!prs_uint32("info_level", ps, depth, &q_n->info_level))
 486                 return False;
 487
 488         return True;
 489 }
 490
 491 /*******************************************************************
 492  Reads or writes a structure.
 493 ********************************************************************/
 494
 495 BOOL srv_io_r_net_share_get_info(char *desc, SRV_R_NET_SHARE_GET_INFO *r_n, prs_struct *ps, int depth)
 496 {
 497         if (r_n == NULL)
 498                 return False;
 499
 500         prs_debug(ps, depth, desc, "srv_io_r_net_share_get_info");
 501         depth++;
 502
 503         if(!prs_align(ps))
 504                 return False;
 505
 506         if(!prs_uint32("switch_value ", ps, depth, &r_n->switch_value ))
 507                 return False;
 508
 509         if(!prs_uint32("ptr_share_ctr", ps, depth, &r_n->ptr_share_ctr))
 510                 return False;
 511
 512         if (r_n->ptr_share_ctr != 0) {
 513                 switch (r_n->switch_value) {
 514                 case 1:
 515                         if(!srv_io_share_info1("", &r_n->share.info1.info_1, ps, depth))
 516                                 return False;
 517
 518                         if(!srv_io_share_info1_str("", &r_n->share.info1.info_1_str, ps, depth))
 519                                 return False;
 520
 521                         break;
 522                 case 2:
 523                         if(!srv_io_share_info2("", &r_n->share.info2.info_2, ps, depth))
 524                                 return False;
 525
 526                         if(!srv_io_share_info2_str("", &r_n->share.info2.info_2_str, ps, depth))
 527                                 return False;
 528
 529                         break;
 530                 default:
 531                         DEBUG(5,("%s no share info at switch_value %d\n",
 532                                  tab_depth(depth), r_n->switch_value));
 533                         break;
 534                 }
 535         }
 536
 537         if(!prs_align(ps))
 538                 return False;
 539
 540         if(!prs_uint32("status", ps, depth, &r_n->status))
 541                 return False;
 542
 543         return True;
 544 }
 545
 546 /*******************************************************************
 547  Inits a SESS_INFO_0_STR structure
 548 ********************************************************************/
 549
 550 void init_srv_sess_info0_str(SESS_INFO_0_STR *ss0, char *name)
 551 {
 552         DEBUG(5,("init_srv_sess_info0_str\n"));
 553
 554         init_unistr2(&ss0->uni_name, name, strlen(name)+1);
 555 }
 556
 557 /*******************************************************************
 558  Reads or writes a structure.
 559 ********************************************************************/
 560
 561 static BOOL srv_io_sess_info0_str(char *desc,  SESS_INFO_0_STR *ss0, prs_struct *ps, int depth)
 562 {
 563         if (ss0 == NULL)
 564                 return False;
 565
 566         prs_debug(ps, depth, desc, "srv_io_sess_info0_str");
 567         depth++;
 568
 569         if(!prs_align(ps))
 570                 return False;
 571
 572         if(!smb_io_unistr2("", &ss0->uni_name, True, ps, depth))
 573                 return False;
 574
 575         return True;
 576 }
 577
 578 /*******************************************************************
 579  Inits a SESS_INFO_0 structure
 580 ********************************************************************/
 581
 582 void init_srv_sess_info0(SESS_INFO_0 *ss0, char *name)
 583 {
 584         DEBUG(5,("init_srv_sess_info0: %s\n", name));
 585
 586         ss0->ptr_name = (name != NULL) ? 1 : 0;
 587 }
 588
 589 /*******************************************************************
 590  Reads or writes a structure.
 591 ********************************************************************/
 592
 593 static BOOL srv_io_sess_info0(char *desc, SESS_INFO_0 *ss0, prs_struct *ps, int depth)
 594 {
 595         if (ss0 == NULL)
 596                 return False;
 597
 598         prs_debug(ps, depth, desc, "srv_io_sess_info0");
 599         depth++;
 600
 601         if(!prs_align(ps))
 602                 return False;
 603
 604         if(!prs_uint32("ptr_name", ps, depth, &ss0->ptr_name))
 605                 return False;
 606
 607         return True;
 608 }
 609
 610 /*******************************************************************
 611  Reads or writes a structure.
 612 ********************************************************************/
 613
 614 static BOOL srv_io_srv_sess_info_0(char *desc, SRV_SESS_INFO_0 *ss0, prs_struct *ps, int depth)
 615 {
 616         if (ss0 == NULL)
 617                 return False;
 618
 619         prs_debug(ps, depth, desc, "srv_io_srv_sess_info_0");
 620         depth++;
 621
 622         if(!prs_align(ps))
 623                 return False;
 624
 625         if(!prs_uint32("num_entries_read", ps, depth, &ss0->num_entries_read))
 626                 return False;
 627         if(!prs_uint32("ptr_sess_info", ps, depth, &ss0->ptr_sess_info))
 628                 return False;
 629
 630         if (ss0->ptr_sess_info != 0) {
 631                 int i;
 632                 int num_entries = ss0->num_entries_read;
 633
 634                 if (num_entries > MAX_SESS_ENTRIES) {
 635                         num_entries = MAX_SESS_ENTRIES; /* report this! */
 636                 }
 637
 638                 if(!prs_uint32("num_entries_read2", ps, depth, &ss0->num_entries_read2))
 639                         return False;
 640
 641                 SMB_ASSERT_ARRAY(ss0->info_0, num_entries);
 642
 643                 for (i = 0; i < num_entries; i++) {
 644                         if(!srv_io_sess_info0("", &ss0->info_0[i], ps, depth))
 645                                 return False;
 646                 }
 647
 648                 for (i = 0; i < num_entries; i++) {
 649                         if(!srv_io_sess_info0_str("", &ss0->info_0_str[i], ps, depth))
 650                                 return False;
 651                 }
 652
 653                 if(!prs_align(ps))
 654                         return False;
 655         }
 656
 657         return True;
 658 }
 659
 660 /*******************************************************************
 661  Inits a SESS_INFO_1_STR structure
 662 ********************************************************************/
 663
 664 void init_srv_sess_info1_str(SESS_INFO_1_STR *ss1, char *name, char *user)
 665 {
 666         DEBUG(5,("init_srv_sess_info1_str\n"));
 667
 668         init_unistr2(&ss1->uni_name, name, strlen(name)+1);
 669         init_unistr2(&ss1->uni_user, name, strlen(user)+1);
 670 }
 671
 672 /*******************************************************************
 673  Reads or writes a structure.
 674 ********************************************************************/
 675
 676 static BOOL srv_io_sess_info1_str(char *desc, SESS_INFO_1_STR *ss1, prs_struct *ps, int depth)
 677 {
 678         if (ss1 == NULL)
 679                 return False;
 680
 681         prs_debug(ps, depth, desc, "srv_io_sess_info1_str");
 682         depth++;
 683
 684         if(!prs_align(ps))
 685                 return False;
 686
 687         if(!smb_io_unistr2("", &ss1->uni_name, True, ps, depth))
 688                 return False;
 689         if(!smb_io_unistr2("", &(ss1->uni_user), True, ps, depth))
 690                 return False;
 691
 692         return True;
 693 }
 694
 695 /*******************************************************************
 696  Inits a SESS_INFO_1 structure
 697 ********************************************************************/
 698
 699 void init_srv_sess_info1(SESS_INFO_1 *ss1,
 700                                 char *name, char *user,
 701                                 uint32 num_opens, uint32 open_time, uint32 idle_time,
 702                                 uint32 user_flags)
 703 {
 704         DEBUG(5,("init_srv_sess_info1: %s\n", name));
 705
 706         ss1->ptr_name = (name != NULL) ? 1 : 0;
 707         ss1->ptr_user = (user != NULL) ? 1 : 0;
 708
 709         ss1->num_opens  = num_opens;
 710         ss1->open_time  = open_time;
 711         ss1->idle_time  = idle_time;
 712         ss1->user_flags = user_flags;
 713 }
 714
 715 /*******************************************************************
 716 reads or writes a structure.
 717 ********************************************************************/
 718
 719 static BOOL srv_io_sess_info1(char *desc, SESS_INFO_1 *ss1, prs_struct *ps, int depth)
 720 {
 721         if (ss1 == NULL)
 722                 return False;
 723
 724         prs_debug(ps, depth, desc, "srv_io_sess_info1");
 725         depth++;
 726
 727         if(!prs_align(ps))
 728                 return False;
 729
 730         if(!prs_uint32("ptr_name  ", ps, depth, &ss1->ptr_name))
 731                 return False;
 732         if(!prs_uint32("ptr_user  ", ps, depth, &ss1->ptr_user))
 733                 return False;
 734
 735         if(!prs_uint32("num_opens ", ps, depth, &ss1->num_opens))
 736                 return False;
 737         if(!prs_uint32("open_time ", ps, depth, &ss1->open_time))
 738                 return False;
 739         if(!prs_uint32("idle_time ", ps, depth, &ss1->idle_time))
 740                 return False;
 741         if(!prs_uint32("user_flags", ps, depth, &ss1->user_flags))
 742                 return False;
 743
 744         return True;
 745 }
 746
 747 /*******************************************************************
 748  Reads or writes a structure.
 749 ********************************************************************/
 750
 751 static BOOL srv_io_srv_sess_info_1(char *desc, SRV_SESS_INFO_1 *ss1, prs_struct *ps, int depth)
 752 {
 753         if (ss1 == NULL)
 754                 return False;
 755
 756         prs_debug(ps, depth, desc, "srv_io_srv_sess_info_1");
 757         depth++;
 758
 759         if(!prs_align(ps))
 760                 return False;
 761
 762         if(!prs_uint32("num_entries_read", ps, depth, &ss1->num_entries_read))
 763                 return False;
 764         if(!prs_uint32("ptr_sess_info", ps, depth, &ss1->ptr_sess_info))
 765                 return False;
 766
 767         if (ss1->ptr_sess_info != 0) {
 768                 int i;
 769                 int num_entries = ss1->num_entries_read;
 770
 771                 if (num_entries > MAX_SESS_ENTRIES) {
 772                         num_entries = MAX_SESS_ENTRIES; /* report this! */
 773                 }
 774
 775                 if(!prs_uint32("num_entries_read2", ps, depth, &ss1->num_entries_read2))
 776                         return False;
 777
 778                 SMB_ASSERT_ARRAY(ss1->info_1, num_entries);
 779
 780                 for (i = 0; i < num_entries; i++) {
 781                         if(!srv_io_sess_info1("", &ss1->info_1[i], ps, depth))
 782                                 return False;
 783                 }
 784
 785                 for (i = 0; i < num_entries; i++) {
 786                         if(!srv_io_sess_info1_str("", &ss1->info_1_str[i], ps, depth))
 787                                 return False;
 788                 }
 789
 790                 if(!prs_align(ps))
 791                         return False;
 792         }
 793
 794         return True;
 795 }
 796
 797 /*******************************************************************
 798  Reads or writes a structure.
 799 ********************************************************************/
 800
 801 static BOOL srv_io_srv_sess_ctr(char *desc, SRV_SESS_INFO_CTR *ctr, prs_struct *ps, int depth)
 802 {
 803         if (ctr == NULL)
 804                 return False;
 805
 806         prs_debug(ps, depth, desc, "srv_io_srv_sess_ctr");
 807         depth++;
 808
 809         if(!prs_align(ps))
 810                 return False;
 811
 812         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
 813                 return False;
 814         if(!prs_uint32("ptr_sess_ctr", ps, depth, &ctr->ptr_sess_ctr))
 815                 return False;
 816
 817         if (ctr->ptr_sess_ctr != 0) {
 818                 switch (ctr->switch_value) {
 819                 case 0:
 820                         if(!srv_io_srv_sess_info_0("", &ctr->sess.info0, ps, depth))
 821                                 return False;
 822                         break;
 823                 case 1:
 824                         if(!srv_io_srv_sess_info_1("", &ctr->sess.info1, ps, depth))
 825                                 return False;
 826                         break;
 827                 default:
 828                         DEBUG(5,("%s no session info at switch_value %d\n",
 829                                  tab_depth(depth), ctr->switch_value));
 830                         break;
 831                 }
 832         }
 833
 834         return True;
 835 }
 836
 837 /*******************************************************************
 838  Inits a SRV_Q_NET_SESS_ENUM structure.
 839 ********************************************************************/
 840
 841 void init_srv_q_net_sess_enum(SRV_Q_NET_SESS_ENUM *q_n,
 842                                 char *srv_name, char *qual_name,
 843                                 uint32 sess_level, SRV_SESS_INFO_CTR *ctr,
 844                                 uint32 preferred_len,
 845                                 ENUM_HND *hnd)
 846 {
 847         q_n->ctr = ctr;
 848
 849         DEBUG(5,("init_q_net_sess_enum\n"));
 850
 851         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
 852         init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
 853
 854         q_n->sess_level    = sess_level;
 855         q_n->preferred_len = preferred_len;
 856
 857         memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
 858 }
 859
 860 /*******************************************************************
 861  Reads or writes a structure.
 862 ********************************************************************/
 863
 864 BOOL srv_io_q_net_sess_enum(char *desc, SRV_Q_NET_SESS_ENUM *q_n, prs_struct *ps, int depth)
 865 {
 866         if (q_n == NULL)
 867                 return False;
 868
 869         prs_debug(ps, depth, desc, "srv_io_q_net_sess_enum");
 870         depth++;
 871
 872         if(!prs_align(ps))
 873                 return False;
 874
 875         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
 876                 return False;
 877         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
 878                 return False;
 879
 880         if(!prs_align(ps))
 881                 return False;
 882
 883         if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
 884                 return False;
 885         if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
 886                 return False;
 887
 888         if(!prs_align(ps))
 889                 return False;
 890
 891         if(!prs_uint32("sess_level", ps, depth, &q_n->sess_level))
 892                 return False;
 893
 894         if (q_n->sess_level != -1) {
 895                 if(!srv_io_srv_sess_ctr("sess_ctr", q_n->ctr, ps, depth))
 896                         return False;
 897         }
 898
 899         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
 900                 return False;
 901
 902         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
 903                 return False;
 904
 905         return True;
 906 }
 907
 908 /*******************************************************************
 909  Reads or writes a structure.
 910 ********************************************************************/
 911
 912 BOOL srv_io_r_net_sess_enum(char *desc, SRV_R_NET_SESS_ENUM *r_n, prs_struct *ps, int depth)
 913 {
 914         if (r_n == NULL)
 915                 return False;
 916
 917         prs_debug(ps, depth, desc, "srv_io_r_net_sess_enum");
 918         depth++;
 919
 920         if(!prs_align(ps))
 921                 return False;
 922
 923         if(!prs_uint32("sess_level", ps, depth, &r_n->sess_level))
 924                 return False;
 925
 926         if (r_n->sess_level != -1) {
 927                 if(!srv_io_srv_sess_ctr("sess_ctr", r_n->ctr, ps, depth))
 928                         return False;
 929         }
 930
 931         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
 932                 return False;
 933         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
 934                 return False;
 935         if(!prs_uint32("status     ", ps, depth, &r_n->status))
 936                 return False;
 937
 938         return True;
 939 }
 940
 941 /*******************************************************************
 942  Inits a CONN_INFO_0 structure
 943 ********************************************************************/
 944
 945 void init_srv_conn_info0(CONN_INFO_0 *ss0, uint32 id)
 946 {
 947         DEBUG(5,("init_srv_conn_info0\n"));
 948
 949         ss0->id = id;
 950 }
 951
 952 /*******************************************************************
 953  Reads or writes a structure.
 954 ********************************************************************/
 955
 956 static BOOL srv_io_conn_info0(char *desc, CONN_INFO_0 *ss0, prs_struct *ps, int depth)
 957 {
 958         if (ss0 == NULL)
 959                 return False;
 960
 961         prs_debug(ps, depth, desc, "srv_io_conn_info0");
 962         depth++;
 963
 964         if(!prs_align(ps))
 965                 return False;
 966
 967         if(!prs_uint32("id", ps, depth, &ss0->id))
 968                 return False;
 969
 970         return True;
 971 }
 972
 973 /*******************************************************************
 974  Reads or writes a structure.
 975 ********************************************************************/
 976
 977 static BOOL srv_io_srv_conn_info_0(char *desc, SRV_CONN_INFO_0 *ss0, prs_struct *ps, int depth)
 978 {
 979         if (ss0 == NULL)
 980                 return False;
 981
 982         prs_debug(ps, depth, desc, "srv_io_srv_conn_info_0");
 983         depth++;
 984
 985         if(!prs_align(ps))
 986                 return False;
 987
 988         if(!prs_uint32("num_entries_read", ps, depth, &ss0->num_entries_read))
 989                 return False;
 990         if(!prs_uint32("ptr_conn_info", ps, depth, &ss0->ptr_conn_info))
 991                 return False;
 992
 993         if (ss0->ptr_conn_info != 0) {
 994                 int i;
 995                 int num_entries = ss0->num_entries_read;
 996
 997                 if (num_entries > MAX_CONN_ENTRIES) {
 998                         num_entries = MAX_CONN_ENTRIES; /* report this! */
 999                 }
1000
1001                 if(!prs_uint32("num_entries_read2", ps, depth, &ss0->num_entries_read2))
1002                         return False;
1003
1004                 for (i = 0; i < num_entries; i++) {
1005                         if(!srv_io_conn_info0("", &ss0->info_0[i], ps, depth))
1006                                 return False;
1007                 }
1008
1009                 if(!prs_align(ps))
1010                         return False;
1011         }
1012
1013         return True;
1014 }
1015
1016 /*******************************************************************
1017  Inits a CONN_INFO_1_STR structure
1018 ********************************************************************/
1019
1020 void init_srv_conn_info1_str(CONN_INFO_1_STR *ss1, char *usr_name, char *net_name)
1021 {
1022         DEBUG(5,("init_srv_conn_info1_str\n"));
1023
1024         init_unistr2(&ss1->uni_usr_name, usr_name, strlen(usr_name)+1);
1025         init_unistr2(&ss1->uni_net_name, net_name, strlen(net_name)+1);
1026 }
1027
1028 /*******************************************************************
1029  Reads or writes a structure.
1030 ********************************************************************/
1031
1032 static BOOL srv_io_conn_info1_str(char *desc, CONN_INFO_1_STR *ss1, prs_struct *ps, int depth)
1033 {
1034         if (ss1 == NULL)
1035                 return False;
1036
1037         prs_debug(ps, depth, desc, "srv_io_conn_info1_str");
1038         depth++;
1039
1040         if(!prs_align(ps))
1041                 return False;
1042
1043         if(!smb_io_unistr2("", &ss1->uni_usr_name, True, ps, depth))
1044                 return False;
1045         if(!smb_io_unistr2("", &ss1->uni_net_name, True, ps, depth))
1046                 return False;
1047
1048         return True;
1049 }
1050
1051 /*******************************************************************
1052  Inits a CONN_INFO_1 structure
1053 ********************************************************************/
1054
1055 void init_srv_conn_info1(CONN_INFO_1 *ss1,
1056                                 uint32 id, uint32 type,
1057                                 uint32 num_opens, uint32 num_users, uint32 open_time,
1058                                 char *usr_name, char *net_name)
1059 {
1060         DEBUG(5,("init_srv_conn_info1: %s %s\n", usr_name, net_name));
1061
1062         ss1->id        = id       ;
1063         ss1->type      = type     ;
1064         ss1->num_opens = num_opens ;
1065         ss1->num_users = num_users;
1066         ss1->open_time = open_time;
1067
1068         ss1->ptr_usr_name = (usr_name != NULL) ? 1 : 0;
1069         ss1->ptr_net_name = (net_name != NULL) ? 1 : 0;
1070 }
1071
1072 /*******************************************************************
1073  Reads or writes a structure.
1074 ********************************************************************/
1075
1076 static BOOL srv_io_conn_info1(char *desc, CONN_INFO_1 *ss1, prs_struct *ps, int depth)
1077 {
1078         if (ss1 == NULL)
1079                 return False;
1080
1081         prs_debug(ps, depth, desc, "srv_io_conn_info1");
1082         depth++;
1083
1084         if(!prs_align(ps))
1085                 return False;
1086
1087         if(!prs_uint32("id          ", ps, depth, &ss1->id))
1088                 return False;
1089         if(!prs_uint32("type        ", ps, depth, &ss1->type))
1090                 return False;
1091         if(!prs_uint32("num_opens   ", ps, depth, &ss1->num_opens))
1092                 return False;
1093         if(!prs_uint32("num_users   ", ps, depth, &ss1->num_users))
1094                 return False;
1095         if(!prs_uint32("open_time   ", ps, depth, &ss1->open_time))
1096                 return False;
1097
1098         if(!prs_uint32("ptr_usr_name", ps, depth, &ss1->ptr_usr_name))
1099                 return False;
1100         if(!prs_uint32("ptr_net_name", ps, depth, &ss1->ptr_net_name))
1101                 return False;
1102
1103         return True;
1104 }
1105
1106 /*******************************************************************
1107  Reads or writes a structure.
1108 ********************************************************************/
1109
1110 static BOOL srv_io_srv_conn_info_1(char *desc, SRV_CONN_INFO_1 *ss1, prs_struct *ps, int depth)
1111 {
1112         if (ss1 == NULL)
1113                 return False;
1114
1115         prs_debug(ps, depth, desc, "srv_io_srv_conn_info_1");
1116         depth++;
1117
1118         if(!prs_align(ps))
1119                 return False;
1120
1121         if(!prs_uint32("num_entries_read", ps, depth, &ss1->num_entries_read))
1122                 return False;
1123         if(!prs_uint32("ptr_conn_info", ps, depth, &ss1->ptr_conn_info))
1124                 return False;
1125
1126         if (ss1->ptr_conn_info != 0) {
1127                 int i;
1128                 int num_entries = ss1->num_entries_read;
1129
1130                 if (num_entries > MAX_CONN_ENTRIES) {
1131                         num_entries = MAX_CONN_ENTRIES; /* report this! */
1132                 }
1133
1134                 if(!prs_uint32("num_entries_read2", ps, depth, &ss1->num_entries_read2))
1135                         return False;
1136
1137                 for (i = 0; i < num_entries; i++) {
1138                         if(!srv_io_conn_info1("", &ss1->info_1[i], ps, depth))
1139                                 return False;
1140                 }
1141
1142                 for (i = 0; i < num_entries; i++) {
1143                         if(!srv_io_conn_info1_str("", &ss1->info_1_str[i], ps, depth))
1144                                 return False;
1145                 }
1146
1147                 if(!prs_align(ps))
1148                         return False;
1149         }
1150
1151         return True;
1152 }
1153
1154 /*******************************************************************
1155  Reads or writes a structure.
1156 ********************************************************************/
1157
1158 static BOOL srv_io_srv_conn_ctr(char *desc, SRV_CONN_INFO_CTR *ctr, prs_struct *ps, int depth)
1159 {
1160         if (ctr == NULL)
1161                 return False;
1162
1163         prs_debug(ps, depth, desc, "srv_io_srv_conn_ctr");
1164         depth++;
1165
1166         if(!prs_align(ps))
1167                 return False;
1168
1169         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
1170                 return False;
1171         if(!prs_uint32("ptr_conn_ctr", ps, depth, &ctr->ptr_conn_ctr))
1172                 return False;
1173
1174         if (ctr->ptr_conn_ctr != 0) {
1175                 switch (ctr->switch_value) {
1176                 case 0:
1177                         if(!srv_io_srv_conn_info_0("", &ctr->conn.info0, ps, depth))
1178                                 return False;
1179                         break;
1180                 case 1:
1181                         if(!srv_io_srv_conn_info_1("", &ctr->conn.info1, ps, depth))
1182                                 return False;
1183                         break;
1184                 default:
1185                         DEBUG(5,("%s no connection info at switch_value %d\n",
1186                                  tab_depth(depth), ctr->switch_value));
1187                         break;
1188                 }
1189         }
1190
1191         return True;
1192 }
1193
1194 /*******************************************************************
1195   Reads or writes a structure.
1196 ********************************************************************/
1197
1198 void init_srv_q_net_conn_enum(SRV_Q_NET_CONN_ENUM *q_n,
1199                                 char *srv_name, char *qual_name,
1200                                 uint32 conn_level, SRV_CONN_INFO_CTR *ctr,
1201                                 uint32 preferred_len,
1202                                 ENUM_HND *hnd)
1203 {
1204         DEBUG(5,("init_q_net_conn_enum\n"));
1205
1206         q_n->ctr = ctr;
1207
1208         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name );
1209         init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
1210
1211         q_n->conn_level    = conn_level;
1212         q_n->preferred_len = preferred_len;
1213
1214         memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
1215 }
1216
1217 /*******************************************************************
1218  Reads or writes a structure.
1219 ********************************************************************/
1220
1221 BOOL srv_io_q_net_conn_enum(char *desc, SRV_Q_NET_CONN_ENUM *q_n, prs_struct *ps, int depth)
1222 {
1223         if (q_n == NULL)
1224                 return False;
1225
1226         prs_debug(ps, depth, desc, "srv_io_q_net_conn_enum");
1227         depth++;
1228
1229         if(!prs_align(ps))
1230                 return False;
1231
1232         if(!prs_uint32("ptr_srv_name ", ps, depth, &q_n->ptr_srv_name))
1233                 return False;
1234         if(!smb_io_unistr2("", &q_n->uni_srv_name, q_n->ptr_srv_name, ps, depth))
1235                 return False;
1236
1237         if(!prs_align(ps))
1238                 return False;
1239
1240         if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
1241                 return False;
1242         if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
1243                 return False;
1244
1245         if(!prs_align(ps))
1246                 return False;
1247
1248         if(!prs_uint32("conn_level", ps, depth, &q_n->conn_level))
1249                 return False;
1250
1251         if (q_n->conn_level != -1) {
1252                 if(!srv_io_srv_conn_ctr("conn_ctr", q_n->ctr, ps, depth))
1253                         return False;
1254         }
1255
1256         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
1257                 return False;
1258
1259         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
1260                 return False;
1261
1262         return True;
1263 }
1264
1265 /*******************************************************************
1266  Reads or writes a structure.
1267 ********************************************************************/
1268
1269 BOOL srv_io_r_net_conn_enum(char *desc,  SRV_R_NET_CONN_ENUM *r_n, prs_struct *ps, int depth)
1270 {
1271         if (r_n == NULL)
1272                 return False;
1273
1274         prs_debug(ps, depth, desc, "srv_io_r_net_conn_enum");
1275         depth++;
1276
1277         if(!prs_align(ps))
1278                 return False;
1279
1280         if(!prs_uint32("conn_level", ps, depth, &r_n->conn_level))
1281                 return False;
1282
1283         if (r_n->conn_level != -1) {
1284                 if(!srv_io_srv_conn_ctr("conn_ctr", r_n->ctr, ps, depth))
1285                         return False;
1286         }
1287
1288         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
1289                 return False;
1290         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
1291                 return False;
1292         if(!prs_uint32("status     ", ps, depth, &r_n->status))
1293                 return False;
1294
1295         return True;
1296 }
1297
1298 /*******************************************************************
1299  Inits a FILE_INFO_3_STR structure
1300 ********************************************************************/
1301
1302 void init_srv_file_info3_str(FILE_INFO_3_STR *fi3, char *user_name, char *path_name)
1303 {
1304         DEBUG(5,("init_srv_file_info3_str\n"));
1305
1306         init_unistr2(&fi3->uni_path_name, path_name, strlen(path_name)+1);
1307         init_unistr2(&fi3->uni_user_name, user_name, strlen(user_name)+1);
1308 }
1309
1310 /*******************************************************************
1311  Reads or writes a structure.
1312 ********************************************************************/
1313
1314 static BOOL srv_io_file_info3_str(char *desc, FILE_INFO_3_STR *sh1, prs_struct *ps, int depth)
1315 {
1316         if (sh1 == NULL)
1317                 return False;
1318
1319         prs_debug(ps, depth, desc, "srv_io_file_info3_str");
1320         depth++;
1321
1322         if(!prs_align(ps))
1323                 return False;
1324
1325         if(!smb_io_unistr2("", &sh1->uni_path_name, True, ps, depth))
1326                 return False;
1327         if(!smb_io_unistr2("", &sh1->uni_user_name, True, ps, depth))
1328                 return False;
1329
1330         return True;
1331 }
1332
1333 /*******************************************************************
1334  Inits a FILE_INFO_3 structure
1335 ********************************************************************/
1336
1337 void init_srv_file_info3(FILE_INFO_3 *fl3,
1338                                 uint32 id, uint32 perms, uint32 num_locks,
1339                                 char *path_name, char *user_name)
1340 {
1341         DEBUG(5,("init_srv_file_info3: %s %s\n", path_name, user_name));
1342
1343         fl3->id        = id;
1344         fl3->perms     = perms;
1345         fl3->num_locks = num_locks;
1346
1347         fl3->ptr_path_name = (path_name != NULL) ? 1 : 0;
1348         fl3->ptr_user_name = (user_name != NULL) ? 1 : 0;
1349 }
1350
1351 /*******************************************************************
1352  Reads or writes a structure.
1353 ********************************************************************/
1354
1355 static BOOL srv_io_file_info3(char *desc, FILE_INFO_3 *fl3, prs_struct *ps, int depth)
1356 {
1357         if (fl3 == NULL)
1358                 return False;
1359
1360         prs_debug(ps, depth, desc, "srv_io_file_info3");
1361         depth++;
1362
1363         if(!prs_align(ps))
1364                 return False;
1365
1366         if(!prs_uint32("id           ", ps, depth, &fl3->id))
1367                 return False;
1368         if(!prs_uint32("perms        ", ps, depth, &fl3->perms))
1369                 return False;
1370         if(!prs_uint32("num_locks    ", ps, depth, &fl3->num_locks))
1371                 return False;
1372         if(!prs_uint32("ptr_path_name", ps, depth, &fl3->ptr_path_name))
1373                 return False;
1374         if(!prs_uint32("ptr_user_name", ps, depth, &fl3->ptr_user_name))
1375                 return False;
1376
1377         return True;
1378 }
1379
1380 /*******************************************************************
1381  Reads or writes a structure.
1382 ********************************************************************/
1383
1384 static BOOL srv_io_srv_file_info_3(char *desc, SRV_FILE_INFO_3 *fl3, prs_struct *ps, int depth)
1385 {
1386         if (fl3 == NULL)
1387                 return False;
1388
1389         prs_debug(ps, depth, desc, "srv_io_file_3_fl3");
1390         depth++;
1391
1392         if(!prs_align(ps))
1393                 return False;
1394
1395         if(!prs_uint32("num_entries_read", ps, depth, &fl3->num_entries_read))
1396                 return False;
1397         if(!prs_uint32("ptr_file_fl3", ps, depth, &fl3->ptr_file_info))
1398                 return False;
1399
1400         if (fl3->ptr_file_info != 0) {
1401                 int i;
1402                 int num_entries = fl3->num_entries_read;
1403
1404                 if (num_entries > MAX_FILE_ENTRIES) {
1405                         num_entries = MAX_FILE_ENTRIES; /* report this! */
1406                 }
1407
1408                 if(!prs_uint32("num_entries_read2", ps, depth, &fl3->num_entries_read2))
1409                         return False;
1410
1411                 for (i = 0; i < num_entries; i++) {
1412                         if(!srv_io_file_info3("", &fl3->info_3[i], ps, depth))
1413                                 return False;
1414                 }
1415
1416                 for (i = 0; i < num_entries; i++) {
1417                         if(!srv_io_file_info3_str("", &fl3->info_3_str[i], ps, depth))
1418                                 return False;
1419                 }
1420
1421                 if(!prs_align(ps))
1422                         return False;
1423         }
1424
1425         return True;
1426 }
1427
1428 /*******************************************************************
1429  Reads or writes a structure.
1430 ********************************************************************/
1431
1432 static BOOL srv_io_srv_file_ctr(char *desc, SRV_FILE_INFO_CTR *ctr, prs_struct *ps, int depth)
1433 {
1434         if (ctr == NULL)
1435                 return False;
1436
1437         prs_debug(ps, depth, desc, "srv_io_srv_file_ctr");
1438         depth++;
1439
1440         if(!prs_align(ps))
1441                 return False;
1442
1443         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
1444                 return False;
1445         if(!prs_uint32("ptr_file_ctr", ps, depth, &ctr->ptr_file_ctr))
1446                 return False;
1447
1448         if (ctr->ptr_file_ctr != 0) {
1449                 switch (ctr->switch_value) {
1450                 case 3:
1451                         if(!srv_io_srv_file_info_3("", &ctr->file.info3, ps, depth))
1452                                 return False;
1453                         break;
1454                 default:
1455                         DEBUG(5,("%s no file info at switch_value %d\n",
1456                                  tab_depth(depth), ctr->switch_value));
1457                         break;
1458                 }
1459         }
1460
1461         return True;
1462 }
1463
1464 /*******************************************************************
1465  Inits a SRV_Q_NET_FILE_ENUM structure.
1466 ********************************************************************/
1467
1468 void init_srv_q_net_file_enum(SRV_Q_NET_FILE_ENUM *q_n,
1469                                 char *srv_name, char *qual_name,
1470                                 uint32 file_level, SRV_FILE_INFO_CTR *ctr,
1471                                 uint32 preferred_len,
1472                                 ENUM_HND *hnd)
1473 {
1474         DEBUG(5,("init_q_net_file_enum\n"));
1475
1476         q_n->ctr = ctr;
1477
1478         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
1479         init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
1480
1481         q_n->file_level    = file_level;
1482         q_n->preferred_len = preferred_len;
1483
1484         memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
1485 }
1486
1487 /*******************************************************************
1488  Reads or writes a structure.
1489 ********************************************************************/
1490
1491 BOOL srv_io_q_net_file_enum(char *desc, SRV_Q_NET_FILE_ENUM *q_n, prs_struct *ps, int depth)
1492 {
1493         if (q_n == NULL)
1494                 return False;
1495
1496         prs_debug(ps, depth, desc, "srv_io_q_net_file_enum");
1497         depth++;
1498
1499         if(!prs_align(ps))
1500                 return False;
1501
1502         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1503                 return False;
1504         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1505                 return False;
1506
1507         if(!prs_align(ps))
1508                 return False;
1509
1510         if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
1511                 return False;
1512         if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
1513                 return False;
1514
1515         if(!prs_align(ps))
1516                 return False;
1517
1518         if(!prs_uint32("file_level", ps, depth, &q_n->file_level))
1519                 return False;
1520
1521         if (q_n->file_level != -1) {
1522                 if(!srv_io_srv_file_ctr("file_ctr", q_n->ctr, ps, depth))
1523                         return False;
1524         }
1525
1526         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
1527                 return False;
1528
1529         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
1530                 return False;
1531
1532         return True;
1533 }
1534
1535 /*******************************************************************
1536  Reads or writes a structure.
1537 ********************************************************************/
1538
1539 BOOL srv_io_r_net_file_enum(char *desc, SRV_R_NET_FILE_ENUM *r_n, prs_struct *ps, int depth)
1540 {
1541         if (r_n == NULL)
1542                 return False;
1543
1544         prs_debug(ps, depth, desc, "srv_io_r_net_file_enum");
1545         depth++;
1546
1547         if(!prs_align(ps))
1548                 return False;
1549
1550         if(!prs_uint32("file_level", ps, depth, &r_n->file_level))
1551                 return False;
1552
1553         if (r_n->file_level != 0) {
1554                 if(!srv_io_srv_file_ctr("file_ctr", r_n->ctr, ps, depth))
1555                         return False;
1556         }
1557
1558         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
1559                 return False;
1560         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
1561                 return False;
1562         if(!prs_uint32("status     ", ps, depth, &r_n->status))
1563                 return False;
1564
1565         return True;
1566 }
1567
1568 /*******************************************************************
1569  Inits a SRV_INFO_101 structure.
1570  ********************************************************************/
1571
1572 void init_srv_info_101(SRV_INFO_101 *sv101, uint32 platform_id, char *name,
1573                                 uint32 ver_major, uint32 ver_minor,
1574                                 uint32 srv_type, char *comment)
1575 {
1576         DEBUG(5,("init_srv_info_101\n"));
1577
1578         sv101->platform_id  = platform_id;
1579         init_buf_unistr2(&sv101->uni_name, &sv101->ptr_name, name);
1580         sv101->ver_major    = ver_major;
1581         sv101->ver_minor    = ver_minor;
1582         sv101->srv_type     = srv_type;
1583         init_buf_unistr2(&sv101->uni_comment, &sv101->ptr_comment, comment);
1584 }
1585
1586 /*******************************************************************
1587  Reads or writes a SRV_INFO_101 structure.
1588  ********************************************************************/
1589
1590 static BOOL srv_io_info_101(char *desc, SRV_INFO_101 *sv101, prs_struct *ps, int depth)
1591 {
1592         if (sv101 == NULL)
1593                 return False;
1594
1595         prs_debug(ps, depth, desc, "srv_io_info_101");
1596         depth++;
1597
1598         if(!prs_align(ps))
1599                 return False;
1600
1601         if(!prs_uint32("platform_id ", ps, depth, &sv101->platform_id))
1602                 return False;
1603         if(!prs_uint32("ptr_name    ", ps, depth, &sv101->ptr_name))
1604                 return False;
1605         if(!prs_uint32("ver_major   ", ps, depth, &sv101->ver_major))
1606                 return False;
1607         if(!prs_uint32("ver_minor   ", ps, depth, &sv101->ver_minor))
1608                 return False;
1609         if(!prs_uint32("srv_type    ", ps, depth, &sv101->srv_type))
1610                 return False;
1611         if(!prs_uint32("ptr_comment ", ps, depth, &sv101->ptr_comment))
1612                 return False;
1613
1614         if(!prs_align(ps))
1615                 return False;
1616
1617         if(!smb_io_unistr2("uni_name    ", &sv101->uni_name, True, ps, depth))
1618                 return False;
1619         if(!smb_io_unistr2("uni_comment ", &sv101->uni_comment, True, ps, depth))
1620                 return False;
1621
1622         return True;
1623 }
1624
1625 /*******************************************************************
1626  Inits a SRV_INFO_102 structure.
1627  ********************************************************************/
1628
1629 void init_srv_info_102(SRV_INFO_102 *sv102, uint32 platform_id, char *name,
1630                                 char *comment, uint32 ver_major, uint32 ver_minor,
1631                                 uint32 srv_type, uint32 users, uint32 disc, uint32 hidden,
1632                                 uint32 announce, uint32 ann_delta, uint32 licenses,
1633                                 char *usr_path)
1634 {
1635         DEBUG(5,("init_srv_info_102\n"));
1636
1637         sv102->platform_id  = platform_id;
1638         init_buf_unistr2(&sv102->uni_name, &sv102->ptr_name, name);
1639         sv102->ver_major    = ver_major;
1640         sv102->ver_minor    = ver_minor;
1641         sv102->srv_type     = srv_type;
1642         init_buf_unistr2(&sv102->uni_comment, &sv102->ptr_comment, comment);
1643
1644         /* same as 101 up to here */
1645
1646         sv102->users        = users;
1647         sv102->disc         = disc;
1648         sv102->hidden       = hidden;
1649         sv102->announce     = announce;
1650         sv102->ann_delta    =ann_delta;
1651         sv102->licenses     = licenses;
1652         init_buf_unistr2(&sv102->uni_usr_path, &sv102->ptr_usr_path, usr_path);
1653 }
1654
1655
1656 /*******************************************************************
1657  Reads or writes a SRV_INFO_102 structure.
1658  ********************************************************************/
1659
1660 static BOOL srv_io_info_102(char *desc, SRV_INFO_102 *sv102, prs_struct *ps, int depth)
1661 {
1662         if (sv102 == NULL)
1663                 return False;
1664
1665         prs_debug(ps, depth, desc, "srv_io_info102");
1666         depth++;
1667
1668         if(!prs_align(ps))
1669                 return False;
1670
1671         if(!prs_uint32("platform_id ", ps, depth, &sv102->platform_id))
1672                 return False;
1673         if(!prs_uint32("ptr_name    ", ps, depth, &sv102->ptr_name))
1674                 return False;
1675         if(!prs_uint32("ver_major   ", ps, depth, &sv102->ver_major))
1676                 return False;
1677         if(!prs_uint32("ver_minor   ", ps, depth, &sv102->ver_minor))
1678                 return False;
1679         if(!prs_uint32("srv_type    ", ps, depth, &sv102->srv_type))
1680                 return False;
1681         if(!prs_uint32("ptr_comment ", ps, depth, &sv102->ptr_comment))
1682                 return False;
1683
1684         /* same as 101 up to here */
1685
1686         if(!prs_uint32("users       ", ps, depth, &sv102->users))
1687                 return False;
1688         if(!prs_uint32("disc        ", ps, depth, &sv102->disc))
1689                 return False;
1690         if(!prs_uint32("hidden      ", ps, depth, &sv102->hidden))
1691                 return False;
1692         if(!prs_uint32("announce    ", ps, depth, &sv102->announce))
1693                 return False;
1694         if(!prs_uint32("ann_delta   ", ps, depth, &sv102->ann_delta))
1695                 return False;
1696         if(!prs_uint32("licenses    ", ps, depth, &sv102->licenses))
1697                 return False;
1698         if(!prs_uint32("ptr_usr_path", ps, depth, &sv102->ptr_usr_path))
1699                 return False;
1700
1701         if(!smb_io_unistr2("uni_name    ", &sv102->uni_name, True, ps, depth))
1702                 return False;
1703         if(!prs_align(ps))
1704                 return False;
1705         if(!smb_io_unistr2("uni_comment ", &sv102->uni_comment, True, ps, depth))
1706                 return False;
1707         if(!prs_align(ps))
1708                 return False;
1709         if(!smb_io_unistr2("uni_usr_path", &sv102->uni_usr_path, True, ps, depth))
1710                 return False;
1711
1712         return True;
1713 }
1714
1715 /*******************************************************************
1716  Reads or writes a SRV_INFO_102 structure.
1717  ********************************************************************/
1718
1719 static BOOL srv_io_info_ctr(char *desc, SRV_INFO_CTR *ctr, prs_struct *ps, int depth)
1720 {
1721         if (ctr == NULL)
1722                 return False;
1723
1724         prs_debug(ps, depth, desc, "srv_io_info_ctr");
1725         depth++;
1726
1727         if(!prs_align(ps))
1728                 return False;
1729
1730         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
1731                 return False;
1732         if(!prs_uint32("ptr_srv_ctr ", ps, depth, &ctr->ptr_srv_ctr))
1733                 return False;
1734
1735         if (ctr->ptr_srv_ctr != 0 && ctr->switch_value != 0 && ctr != NULL) {
1736                 switch (ctr->switch_value) {
1737                 case 101:
1738                         if(!srv_io_info_101("sv101", &ctr->srv.sv101, ps, depth))
1739                                 return False;
1740                         break;
1741                 case 102:
1742                         if(!srv_io_info_102("sv102", &ctr->srv.sv102, ps, depth))
1743                                 return False;
1744                         break;
1745                 default:
1746                         DEBUG(5,("%s no server info at switch_value %d\n",
1747                                          tab_depth(depth), ctr->switch_value));
1748                         break;
1749                 }
1750                 if(!prs_align(ps))
1751                         return False;
1752         }
1753
1754         return True;
1755 }
1756
1757 /*******************************************************************
1758  Inits a SRV_Q_NET_SRV_GET_INFO structure.
1759  ********************************************************************/
1760
1761 void init_srv_q_net_srv_get_info(SRV_Q_NET_SRV_GET_INFO *srv,
1762                                 char *server_name, uint32 switch_value)
1763 {
1764         DEBUG(5,("init_srv_q_net_srv_get_info\n"));
1765
1766         init_buf_unistr2(&srv->uni_srv_name, &srv->ptr_srv_name, server_name);
1767
1768         srv->switch_value = switch_value;
1769 }
1770
1771 /*******************************************************************
1772  Reads or writes a structure.
1773 ********************************************************************/
1774
1775 BOOL srv_io_q_net_srv_get_info(char *desc, SRV_Q_NET_SRV_GET_INFO *q_n, prs_struct *ps, int depth)
1776 {
1777         if (q_n == NULL)
1778                 return False;
1779
1780         prs_debug(ps, depth, desc, "srv_io_q_net_srv_get_info");
1781         depth++;
1782
1783         if(!prs_align(ps))
1784                 return False;
1785
1786         if(!prs_uint32("ptr_srv_name  ", ps, depth, &q_n->ptr_srv_name))
1787                 return False;
1788         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1789                 return False;
1790
1791         if(!prs_align(ps))
1792                 return False;
1793
1794         if(!prs_uint32("switch_value  ", ps, depth, &q_n->switch_value))
1795                 return False;
1796
1797         return True;
1798 }
1799
1800 /*******************************************************************
1801  Inits a SRV_R_NET_SRV_GET_INFO structure.
1802  ********************************************************************/
1803
1804 void init_srv_r_net_srv_get_info(SRV_R_NET_SRV_GET_INFO *srv,
1805                                 uint32 switch_value, SRV_INFO_CTR *ctr, uint32 status)
1806 {
1807         DEBUG(5,("init_srv_r_net_srv_get_info\n"));
1808
1809         srv->ctr = ctr;
1810
1811         if (status == 0x0) {
1812                 srv->ctr->switch_value = switch_value;
1813                 srv->ctr->ptr_srv_ctr  = 1;
1814         } else {
1815                 srv->ctr->switch_value = 0;
1816                 srv->ctr->ptr_srv_ctr  = 0;
1817         }
1818
1819         srv->status = status;
1820 }
1821
1822 /*******************************************************************
1823  Reads or writes a structure.
1824  ********************************************************************/
1825
1826 BOOL srv_io_r_net_srv_get_info(char *desc, SRV_R_NET_SRV_GET_INFO *r_n, prs_struct *ps, int depth)
1827 {
1828         if (r_n == NULL)
1829                 return False;
1830
1831         prs_debug(ps, depth, desc, "srv_io_r_net_srv_get_info");
1832         depth++;
1833
1834         if(!prs_align(ps))
1835                 return False;
1836
1837         if(!srv_io_info_ctr("ctr", r_n->ctr, ps, depth))
1838                 return False;
1839
1840         if(!prs_uint32("status      ", ps, depth, &r_n->status))
1841                 return False;
1842
1843         return True;
1844 }
1845
1846
1847 /*******************************************************************
1848  Reads or writes a structure.
1849  ********************************************************************/
1850
1851 BOOL srv_io_q_net_remote_tod(char *desc, SRV_Q_NET_REMOTE_TOD *q_n, prs_struct *ps, int depth)
1852 {
1853         if (q_n == NULL)
1854                 return False;
1855
1856         prs_debug(ps, depth, desc, "srv_io_q_net_remote_tod");
1857         depth++;
1858
1859         if(!prs_align(ps))
1860                 return False;
1861
1862         if(!prs_uint32("ptr_srv_name  ", ps, depth, &q_n->ptr_srv_name))
1863                 return False;
1864         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1865                 return False;
1866
1867         return True;
1868 }
1869
1870 /*******************************************************************
1871  Reads or writes a TIME_OF_DAY_INFO structure.
1872  ********************************************************************/
1873
1874 static BOOL srv_io_time_of_day_info(char *desc, TIME_OF_DAY_INFO *tod, prs_struct *ps, int depth)
1875 {
1876         if (tod == NULL)
1877                 return False;
1878
1879         prs_debug(ps, depth, desc, "srv_io_time_of_day_info");
1880         depth++;
1881
1882         if(!prs_align(ps))
1883                 return False;
1884
1885         if(!prs_uint32("elapsedt   ", ps, depth, &tod->elapsedt))
1886                 return False;
1887         if(!prs_uint32("msecs      ", ps, depth, &tod->msecs))
1888                 return False;
1889         if(!prs_uint32("hours      ", ps, depth, &tod->hours))
1890                 return False;
1891         if(!prs_uint32("mins       ", ps, depth, &tod->mins))
1892                 return False;
1893         if(!prs_uint32("secs       ", ps, depth, &tod->secs))
1894                 return False;
1895         if(!prs_uint32("hunds      ", ps, depth, &tod->hunds))
1896                 return False;
1897         if(!prs_uint32("timezone   ", ps, depth, &tod->zone))
1898                 return False;
1899         if(!prs_uint32("tintervals ", ps, depth, &tod->tintervals))
1900                 return False;
1901         if(!prs_uint32("day        ", ps, depth, &tod->day))
1902                 return False;
1903         if(!prs_uint32("month      ", ps, depth, &tod->month))
1904                 return False;
1905         if(!prs_uint32("year       ", ps, depth, &tod->year))
1906                 return False;
1907         if(!prs_uint32("weekday    ", ps, depth, &tod->weekday))
1908                 return False;
1909
1910         return True;
1911 }
1912
1913 /*******************************************************************
1914  Inits a TIME_OF_DAY_INFO structure.
1915  ********************************************************************/
1916
1917 void init_time_of_day_info(TIME_OF_DAY_INFO *tod, uint32 elapsedt, uint32 msecs,
1918                            uint32 hours, uint32 mins, uint32 secs, uint32 hunds,
1919                            uint32 zone, uint32 tintervals, uint32 day,
1920                            uint32 month, uint32 year, uint32 weekday)
1921 {
1922         DEBUG(5,("init_time_of_day_info\n"));
1923
1924         tod->elapsedt   = elapsedt;
1925         tod->msecs      = msecs;
1926         tod->hours      = hours;
1927         tod->mins       = mins;
1928         tod->secs       = secs;
1929         tod->hunds      = hunds;
1930         tod->zone       = zone;
1931         tod->tintervals = tintervals;
1932         tod->day        = day;
1933         tod->month      = month;
1934         tod->year       = year;
1935         tod->weekday    = weekday;
1936 }
1937
1938
1939 /*******************************************************************
1940  Reads or writes a structure.
1941  ********************************************************************/
1942
1943 BOOL srv_io_r_net_remote_tod(char *desc, SRV_R_NET_REMOTE_TOD *r_n, prs_struct *ps, int depth)
1944 {
1945         if (r_n == NULL)
1946                 return False;
1947
1948         prs_debug(ps, depth, desc, "srv_io_r_net_remote_tod");
1949         depth++;
1950
1951         if(!prs_align(ps))
1952                 return False;
1953
1954         if(!prs_uint32("ptr_srv_tod ", ps, depth, &r_n->ptr_srv_tod))
1955                 return False;
1956
1957         if(!srv_io_time_of_day_info("tod", r_n->tod, ps, depth))
1958                 return False;
1959
1960         if(!prs_uint32("status      ", ps, depth, &r_n->status))
1961                 return False;
1962
1963         return True;
1964 }