git.maemo.org Git - samba/blob - source/rpc_parse/parse_srv.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) Jeremy Allison                    1999,
   8  *  Copyright (C) Nigel Williams                    2001,
   9  *  Copyright (C) Jim McDonough (jmcd@us.ibm.com)   2002.
  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 #include "includes.h"
  27
  28 #undef DBGC_CLASS
  29 #define DBGC_CLASS DBGC_RPC_PARSE
  30
  31 /*******************************************************************
  32  Inits a SH_INFO_0_STR structure
  33 ********************************************************************/
  34
  35 void init_srv_share_info0_str(SH_INFO_0_STR *sh0, const char *net_name)
  36 {
  37         DEBUG(5,("init_srv_share_info0_str\n"));
  38
  39         init_unistr2(&sh0->uni_netname, net_name, UNI_STR_TERMINATE);
  40 }
  41
  42 /*******************************************************************
  43  Reads or writes a structure.
  44 ********************************************************************/
  45
  46 static BOOL srv_io_share_info0_str(const char *desc, SH_INFO_0_STR *sh0, prs_struct *ps, int depth)
  47 {
  48         if (sh0 == NULL)
  49                 return False;
  50
  51         prs_debug(ps, depth, desc, "srv_io_share_info0_str");
  52         depth++;
  53
  54         if(!prs_align(ps))
  55                 return False;
  56         if(sh0->ptrs->ptr_netname)
  57                 if(!smb_io_unistr2("", &sh0->uni_netname, True, ps, depth))
  58                         return False;
  59
  60         return True;
  61 }
  62
  63 /*******************************************************************
  64  makes a SH_INFO_0 structure
  65 ********************************************************************/
  66
  67 void init_srv_share_info0(SH_INFO_0 *sh0, const char *net_name)
  68 {
  69         DEBUG(5,("init_srv_share_info0: %s\n", net_name));
  70
  71         sh0->ptr_netname = (net_name != NULL) ? 1 : 0;
  72 }
  73
  74 /*******************************************************************
  75  Reads or writes a structure.
  76 ********************************************************************/
  77
  78 static BOOL srv_io_share_info0(const char *desc, SH_INFO_0 *sh0, prs_struct *ps, int depth)
  79 {
  80         if (sh0 == NULL)
  81                 return False;
  82
  83         prs_debug(ps, depth, desc, "srv_io_share_info0");
  84         depth++;
  85
  86         if(!prs_align(ps))
  87                 return False;
  88
  89         if(!prs_uint32("ptr_netname", ps, depth, &sh0->ptr_netname))
  90                 return False;
  91
  92         return True;
  93 }
  94
  95 /*******************************************************************
  96  Inits a SH_INFO_1_STR structure
  97 ********************************************************************/
  98
  99 void init_srv_share_info1_str(SH_INFO_1_STR *sh1, const char *net_name, const char *remark)
 100 {
 101         DEBUG(5,("init_srv_share_info1_str\n"));
 102
 103         init_unistr2(&sh1->uni_netname, net_name, UNI_STR_TERMINATE);
 104         init_unistr2(&sh1->uni_remark, remark, UNI_STR_TERMINATE);
 105 }
 106
 107 /*******************************************************************
 108  Reads or writes a structure.
 109 ********************************************************************/
 110
 111 static BOOL srv_io_share_info1_str(const char *desc, SH_INFO_1_STR *sh1, prs_struct *ps, int depth)
 112 {
 113         if (sh1 == NULL)
 114                 return False;
 115
 116         prs_debug(ps, depth, desc, "srv_io_share_info1_str");
 117         depth++;
 118
 119         if(!prs_align(ps))
 120                 return False;
 121
 122         if(sh1->ptrs->ptr_netname)
 123                 if(!smb_io_unistr2("", &sh1->uni_netname, True, ps, depth))
 124                         return False;
 125
 126         if(!prs_align(ps))
 127                 return False;
 128
 129         if(sh1->ptrs->ptr_remark)
 130                 if(!smb_io_unistr2("", &sh1->uni_remark, True, ps, depth))
 131                         return False;
 132
 133         return True;
 134 }
 135
 136 /*******************************************************************
 137  makes a SH_INFO_1 structure
 138 ********************************************************************/
 139
 140 void init_srv_share_info1(SH_INFO_1 *sh1, const char *net_name, uint32 type, const char *remark)
 141 {
 142         DEBUG(5,("init_srv_share_info1: %s %8x %s\n", net_name, type, remark));
 143
 144         sh1->ptr_netname = (net_name != NULL) ? 1 : 0;
 145         sh1->type        = type;
 146         sh1->ptr_remark  = (remark != NULL) ? 1 : 0;
 147 }
 148
 149 /*******************************************************************
 150  Reads or writes a structure.
 151 ********************************************************************/
 152
 153 static BOOL srv_io_share_info1(const char *desc, SH_INFO_1 *sh1, prs_struct *ps, int depth)
 154 {
 155         if (sh1 == NULL)
 156                 return False;
 157
 158         prs_debug(ps, depth, desc, "srv_io_share_info1");
 159         depth++;
 160
 161         if(!prs_align(ps))
 162                 return False;
 163
 164         if(!prs_uint32("ptr_netname", ps, depth, &sh1->ptr_netname))
 165                 return False;
 166         if(!prs_uint32("type       ", ps, depth, &sh1->type))
 167                 return False;
 168         if(!prs_uint32("ptr_remark ", ps, depth, &sh1->ptr_remark))
 169                 return False;
 170
 171         return True;
 172 }
 173
 174 /*******************************************************************
 175  Inits a SH_INFO_2_STR structure
 176 ********************************************************************/
 177
 178 void init_srv_share_info2_str(SH_INFO_2_STR *sh2,
 179                                 const char *net_name, const char *remark,
 180                                 const char *path, const char *passwd)
 181 {
 182         DEBUG(5,("init_srv_share_info2_str\n"));
 183
 184         init_unistr2(&sh2->uni_netname, net_name, UNI_STR_TERMINATE);
 185         init_unistr2(&sh2->uni_remark, remark, UNI_STR_TERMINATE);
 186         init_unistr2(&sh2->uni_path, path, UNI_STR_TERMINATE);
 187         init_unistr2(&sh2->uni_passwd, passwd, UNI_STR_TERMINATE);
 188 }
 189
 190 /*******************************************************************
 191  Reads or writes a structure.
 192 ********************************************************************/
 193
 194 static BOOL srv_io_share_info2_str(const char *desc, SH_INFO_2 *sh, SH_INFO_2_STR *sh2, prs_struct *ps, int depth)
 195 {
 196         if (sh2 == NULL)
 197                 return False;
 198
 199         if (UNMARSHALLING(ps))
 200                 ZERO_STRUCTP(sh2);
 201
 202         prs_debug(ps, depth, desc, "srv_io_share_info2_str");
 203         depth++;
 204
 205         if(!prs_align(ps))
 206                 return False;
 207
 208         if (sh->ptr_netname)
 209                 if(!smb_io_unistr2("", &sh2->uni_netname, True, ps, depth))
 210                         return False;
 211
 212         if (sh->ptr_remark)
 213                 if(!smb_io_unistr2("", &sh2->uni_remark, True, ps, depth))
 214                         return False;
 215
 216         if (sh->ptr_netname)
 217                 if(!smb_io_unistr2("", &sh2->uni_path, True, ps, depth))
 218                         return False;
 219
 220         if (sh->ptr_passwd)
 221                 if(!smb_io_unistr2("", &sh2->uni_passwd, True, ps, depth))
 222                         return False;
 223
 224         return True;
 225 }
 226
 227 /*******************************************************************
 228  Inits a SH_INFO_2 structure
 229 ********************************************************************/
 230
 231 void init_srv_share_info2(SH_INFO_2 *sh2,
 232                                 const char *net_name, uint32 type, const char *remark,
 233                                 uint32 perms, uint32 max_uses, uint32 num_uses,
 234                                 const char *path, const char *passwd)
 235 {
 236         DEBUG(5,("init_srv_share_info2: %s %8x %s\n", net_name, type, remark));
 237
 238         sh2->ptr_netname = (net_name != NULL) ? 1 : 0;
 239         sh2->type        = type;
 240         sh2->ptr_remark  = (remark != NULL) ? 1 : 0;
 241         sh2->perms       = perms;
 242         sh2->max_uses    = max_uses;
 243         sh2->num_uses    = num_uses;
 244         sh2->ptr_path    = (path != NULL) ? 1 : 0;
 245         sh2->ptr_passwd  = (passwd != NULL) ? 1 : 0;
 246 }
 247
 248 /*******************************************************************
 249  Reads or writes a structure.
 250 ********************************************************************/
 251
 252 static BOOL srv_io_share_info2(const char *desc, SH_INFO_2 *sh2, prs_struct *ps, int depth)
 253 {
 254         if (sh2 == NULL)
 255                 return False;
 256
 257         prs_debug(ps, depth, desc, "srv_io_share_info2");
 258         depth++;
 259
 260         if(!prs_align(ps))
 261                 return False;
 262
 263         if(!prs_uint32("ptr_netname", ps, depth, &sh2->ptr_netname))
 264                 return False;
 265         if(!prs_uint32("type       ", ps, depth, &sh2->type))
 266                 return False;
 267         if(!prs_uint32("ptr_remark ", ps, depth, &sh2->ptr_remark))
 268                 return False;
 269         if(!prs_uint32("perms      ", ps, depth, &sh2->perms))
 270                 return False;
 271         if(!prs_uint32("max_uses   ", ps, depth, &sh2->max_uses))
 272                 return False;
 273         if(!prs_uint32("num_uses   ", ps, depth, &sh2->num_uses))
 274                 return False;
 275         if(!prs_uint32("ptr_path   ", ps, depth, &sh2->ptr_path))
 276                 return False;
 277         if(!prs_uint32("ptr_passwd ", ps, depth, &sh2->ptr_passwd))
 278                 return False;
 279
 280         return True;
 281 }
 282
 283 /*******************************************************************
 284  Inits a SH_INFO_501_STR structure
 285 ********************************************************************/
 286
 287 void init_srv_share_info501_str(SH_INFO_501_STR *sh501,
 288                                 const char *net_name, const char *remark)
 289 {
 290         DEBUG(5,("init_srv_share_info501_str\n"));
 291
 292         init_unistr2(&sh501->uni_netname, net_name, UNI_STR_TERMINATE);
 293         init_unistr2(&sh501->uni_remark, remark, UNI_STR_TERMINATE);
 294 }
 295
 296 /*******************************************************************
 297  Inits a SH_INFO_2 structure
 298 *******************************************************************/
 299
 300 void init_srv_share_info501(SH_INFO_501 *sh501, const char *net_name, uint32 type, const char *remark, uint32 csc_policy)
 301 {
 302         DEBUG(5,("init_srv_share_info501: %s %8x %s %08x\n", net_name, type,
 303                 remark, csc_policy));
 304
 305         ZERO_STRUCTP(sh501);
 306
 307         sh501->ptr_netname = (net_name != NULL) ? 1 : 0;
 308         sh501->type = type;
 309         sh501->ptr_remark = (remark != NULL) ? 1 : 0;
 310         sh501->csc_policy = csc_policy;
 311 }
 312
 313 /*******************************************************************
 314  Reads of writes a structure.
 315 *******************************************************************/
 316
 317 static BOOL srv_io_share_info501(const char *desc, SH_INFO_501 *sh501, prs_struct *ps, int depth)
 318 {
 319         if (sh501 == NULL)
 320                 return False;
 321
 322         prs_debug(ps, depth, desc, "srv_io_share_info501");
 323         depth++;
 324
 325         if (!prs_align(ps))
 326                 return False;
 327
 328         if (!prs_uint32("ptr_netname", ps, depth, &sh501->ptr_netname))
 329                 return False;
 330         if (!prs_uint32("type     ", ps, depth, &sh501->type))
 331                 return False;
 332         if (!prs_uint32("ptr_remark ", ps, depth, &sh501->ptr_remark))
 333                 return False;
 334         if (!prs_uint32("csc_policy ", ps, depth, &sh501->csc_policy))
 335                 return False;
 336
 337         return True;
 338 }
 339
 340 /*******************************************************************
 341  Reads or writes a structure.
 342 ********************************************************************/
 343
 344 static BOOL srv_io_share_info501_str(const char *desc, SH_INFO_501_STR *sh501, prs_struct *ps, int depth)
 345 {
 346         if (sh501 == NULL)
 347                 return False;
 348
 349         prs_debug(ps, depth, desc, "srv_io_share_info501_str");
 350         depth++;
 351
 352         if(!prs_align(ps))
 353                 return False;
 354         if(!smb_io_unistr2("", &sh501->uni_netname, True, ps, depth))
 355                 return False;
 356
 357         if(!prs_align(ps))
 358                 return False;
 359         if(!smb_io_unistr2("", &sh501->uni_remark, True, ps, depth))
 360                 return False;
 361
 362         return True;
 363 }
 364
 365 /*******************************************************************
 366  Inits a SH_INFO_502 structure
 367 ********************************************************************/
 368
 369 void init_srv_share_info502(SH_INFO_502 *sh502,
 370                                 const char *net_name, uint32 type, const char *remark,
 371                                 uint32 perms, uint32 max_uses, uint32 num_uses,
 372                                 const char *path, const char *passwd, SEC_DESC *psd, size_t sd_size)
 373 {
 374         DEBUG(5,("init_srv_share_info502: %s %8x %s\n", net_name, type, remark));
 375
 376         ZERO_STRUCTP(sh502);
 377
 378         sh502->ptr_netname = (net_name != NULL) ? 1 : 0;
 379         sh502->type        = type;
 380         sh502->ptr_remark  = (remark != NULL) ? 1 : 0;
 381         sh502->perms       = perms;
 382         sh502->max_uses    = max_uses;
 383         sh502->num_uses    = num_uses;
 384         sh502->ptr_path    = (path != NULL) ? 1 : 0;
 385         sh502->ptr_passwd  = (passwd != NULL) ? 1 : 0;
 386         sh502->reserved    = 0;  /* actual size within rpc */
 387         sh502->sd_size     = (uint32)sd_size;
 388         sh502->ptr_sd      = (psd != NULL) ? 1 : 0;
 389 }
 390
 391 /*******************************************************************
 392  Reads or writes a structure.
 393 ********************************************************************/
 394
 395 static BOOL srv_io_share_info502(const char *desc, SH_INFO_502 *sh502, prs_struct *ps, int depth)
 396 {
 397         if (sh502 == NULL)
 398                 return False;
 399
 400         prs_debug(ps, depth, desc, "srv_io_share_info502");
 401         depth++;
 402
 403         if(!prs_align(ps))
 404                 return False;
 405
 406         if(!prs_uint32("ptr_netname", ps, depth, &sh502->ptr_netname))
 407                 return False;
 408         if(!prs_uint32("type       ", ps, depth, &sh502->type))
 409                 return False;
 410         if(!prs_uint32("ptr_remark ", ps, depth, &sh502->ptr_remark))
 411                 return False;
 412         if(!prs_uint32("perms      ", ps, depth, &sh502->perms))
 413                 return False;
 414         if(!prs_uint32("max_uses   ", ps, depth, &sh502->max_uses))
 415                 return False;
 416         if(!prs_uint32("num_uses   ", ps, depth, &sh502->num_uses))
 417                 return False;
 418         if(!prs_uint32("ptr_path   ", ps, depth, &sh502->ptr_path))
 419                 return False;
 420         if(!prs_uint32("ptr_passwd ", ps, depth, &sh502->ptr_passwd))
 421                 return False;
 422         if(!prs_uint32_pre("reserved   ", ps, depth, &sh502->reserved, &sh502->reserved_offset))
 423                 return False;
 424         if(!prs_uint32("ptr_sd     ", ps, depth, &sh502->ptr_sd))
 425                 return False;
 426
 427         return True;
 428 }
 429
 430 /*******************************************************************
 431  Inits a SH_INFO_502_STR structure
 432 ********************************************************************/
 433
 434 void init_srv_share_info502_str(SH_INFO_502_STR *sh502str,
 435                                 const char *net_name, const char *remark,
 436                                 const char *path, const char *passwd, SEC_DESC *psd, size_t sd_size)
 437 {
 438         DEBUG(5,("init_srv_share_info502_str\n"));
 439
 440         init_unistr2(&sh502str->uni_netname, net_name, UNI_STR_TERMINATE);
 441         init_unistr2(&sh502str->uni_remark, remark, UNI_STR_TERMINATE);
 442         init_unistr2(&sh502str->uni_path, path, UNI_STR_TERMINATE);
 443         init_unistr2(&sh502str->uni_passwd, passwd, UNI_STR_TERMINATE);
 444         sh502str->sd = psd;
 445         sh502str->reserved = 0;
 446         sh502str->sd_size = sd_size;
 447 }
 448
 449 /*******************************************************************
 450  Reads or writes a structure.
 451 ********************************************************************/
 452
 453 static BOOL srv_io_share_info502_str(const char *desc, SH_INFO_502_STR *sh502, prs_struct *ps, int depth)
 454 {
 455         if (sh502 == NULL)
 456                 return False;
 457
 458         prs_debug(ps, depth, desc, "srv_io_share_info502_str");
 459         depth++;
 460
 461         if(!prs_align(ps))
 462                 return False;
 463
 464         if(sh502->ptrs->ptr_netname) {
 465                 if(!smb_io_unistr2("", &sh502->uni_netname, True, ps, depth))
 466                         return False;
 467         }
 468
 469         if(!prs_align(ps))
 470                 return False;
 471
 472         if(sh502->ptrs->ptr_remark) {
 473                 if(!smb_io_unistr2("", &sh502->uni_remark, True, ps, depth))
 474                         return False;
 475         }
 476
 477         if(!prs_align(ps))
 478                 return False;
 479
 480         if(sh502->ptrs->ptr_path) {
 481                 if(!smb_io_unistr2("", &sh502->uni_path, True, ps, depth))
 482                         return False;
 483         }
 484
 485         if(!prs_align(ps))
 486                 return False;
 487
 488         if(sh502->ptrs->ptr_passwd) {
 489                 if(!smb_io_unistr2("", &sh502->uni_passwd, True, ps, depth))
 490                         return False;
 491         }
 492
 493         if(!prs_align(ps))
 494                 return False;
 495
 496         if(sh502->ptrs->ptr_sd) {
 497                 uint32 old_offset;
 498                 uint32 reserved_offset;
 499
 500                 if(!prs_uint32_pre("reserved ", ps, depth, &sh502->reserved, &reserved_offset))
 501                         return False;
 502
 503                 old_offset = prs_offset(ps);
 504
 505                 if (!sec_io_desc(desc, &sh502->sd, ps, depth))
 506                         return False;
 507
 508                 if(UNMARSHALLING(ps)) {
 509
 510                         sh502->ptrs->sd_size = sh502->sd_size = sec_desc_size(sh502->sd);
 511
 512                         prs_set_offset(ps, old_offset + sh502->reserved);
 513                 }
 514
 515                 prs_align(ps);
 516
 517                 if(MARSHALLING(ps)) {
 518
 519                         sh502->ptrs->reserved = sh502->reserved = prs_offset(ps) - old_offset;
 520                 }
 521
 522                 if(!prs_uint32_post("reserved ", ps, depth,
 523                                     &sh502->reserved, reserved_offset, sh502->reserved))
 524                         return False;
 525                 if(!prs_uint32_post("reserved ", ps, depth,
 526                                     &sh502->ptrs->reserved, sh502->ptrs->reserved_offset, sh502->ptrs->reserved))
 527                         return False;
 528         }
 529
 530         return True;
 531 }
 532
 533 /*******************************************************************
 534  Inits a SH_INFO_1004_STR structure
 535 ********************************************************************/
 536
 537 void init_srv_share_info1004_str(SH_INFO_1004_STR *sh1004, const char *remark)
 538 {
 539         DEBUG(5,("init_srv_share_info1004_str\n"));
 540
 541         init_unistr2(&sh1004->uni_remark, remark, UNI_STR_TERMINATE);
 542 }
 543
 544 /*******************************************************************
 545  Reads or writes a structure.
 546 ********************************************************************/
 547
 548 static BOOL srv_io_share_info1004_str(const char *desc, SH_INFO_1004_STR *sh1004, prs_struct *ps, int depth)
 549 {
 550         if (sh1004 == NULL)
 551                 return False;
 552
 553         prs_debug(ps, depth, desc, "srv_io_share_info1004_str");
 554         depth++;
 555
 556         if(!prs_align(ps))
 557                 return False;
 558         if(sh1004->ptrs->ptr_remark)
 559                 if(!smb_io_unistr2("", &sh1004->uni_remark, True, ps, depth))
 560                         return False;
 561
 562         return True;
 563 }
 564
 565 /*******************************************************************
 566  makes a SH_INFO_1004 structure
 567 ********************************************************************/
 568
 569 void init_srv_share_info1004(SH_INFO_1004 *sh1004, const char *remark)
 570 {
 571         DEBUG(5,("init_srv_share_info1004: %s\n", remark));
 572
 573         sh1004->ptr_remark = (remark != NULL) ? 1 : 0;
 574 }
 575
 576 /*******************************************************************
 577  Reads or writes a structure.
 578 ********************************************************************/
 579
 580 static BOOL srv_io_share_info1004(const char *desc, SH_INFO_1004 *sh1004, prs_struct *ps, int depth)
 581 {
 582         if (sh1004 == NULL)
 583                 return False;
 584
 585         prs_debug(ps, depth, desc, "srv_io_share_info1004");
 586         depth++;
 587
 588         if(!prs_align(ps))
 589                 return False;
 590
 591         if(!prs_uint32("ptr_remark", ps, depth, &sh1004->ptr_remark))
 592                 return False;
 593
 594         return True;
 595 }
 596
 597 /*******************************************************************
 598  Reads or writes a structure.
 599 ********************************************************************/
 600
 601 static BOOL srv_io_share_info1005(const char* desc, SRV_SHARE_INFO_1005* sh1005, prs_struct* ps, int depth)
 602 {
 603         if(sh1005 == NULL)
 604                 return False;
 605
 606         prs_debug(ps, depth, desc, "srv_io_share_info1005");
 607                 depth++;
 608
 609         if(!prs_align(ps))
 610                 return False;
 611
 612         if(!prs_uint32("share_info_flags", ps, depth,
 613                        &sh1005->share_info_flags))
 614                 return False;
 615
 616         return True;
 617 }
 618
 619 /*******************************************************************
 620  Reads or writes a structure.
 621 ********************************************************************/
 622
 623 static BOOL srv_io_share_info1006(const char* desc, SRV_SHARE_INFO_1006* sh1006, prs_struct* ps, int depth)
 624 {
 625         if(sh1006 == NULL)
 626                 return False;
 627
 628         prs_debug(ps, depth, desc, "srv_io_share_info1006");
 629         depth++;
 630
 631         if(!prs_align(ps))
 632                 return False;
 633
 634         if(!prs_uint32("max uses     ", ps, depth, &sh1006->max_uses))
 635                 return False;
 636
 637         return True;
 638 }
 639
 640 /*******************************************************************
 641  Inits a SH_INFO_1007_STR structure
 642 ********************************************************************/
 643
 644 void init_srv_share_info1007_str(SH_INFO_1007_STR *sh1007, const char *alternate_directory_name)
 645 {
 646         DEBUG(5,("init_srv_share_info1007_str\n"));
 647
 648         init_unistr2(&sh1007->uni_AlternateDirectoryName, alternate_directory_name, UNI_STR_TERMINATE);
 649 }
 650
 651 /*******************************************************************
 652  Reads or writes a structure.
 653 ********************************************************************/
 654
 655 static BOOL srv_io_share_info1007_str(const char *desc, SH_INFO_1007_STR *sh1007, prs_struct *ps, int depth)
 656 {
 657         if (sh1007 == NULL)
 658                 return False;
 659
 660         prs_debug(ps, depth, desc, "srv_io_share_info1007_str");
 661         depth++;
 662
 663         if(!prs_align(ps))
 664                 return False;
 665         if(sh1007->ptrs->ptr_AlternateDirectoryName)
 666                 if(!smb_io_unistr2("", &sh1007->uni_AlternateDirectoryName, True, ps, depth))
 667                         return False;
 668
 669         return True;
 670 }
 671
 672 /*******************************************************************
 673  makes a SH_INFO_1007 structure
 674 ********************************************************************/
 675
 676 void init_srv_share_info1007(SH_INFO_1007 *sh1007, uint32 flags, const char *alternate_directory_name)
 677 {
 678         DEBUG(5,("init_srv_share_info1007: %s\n", alternate_directory_name));
 679
 680         sh1007->flags                      = flags;
 681         sh1007->ptr_AlternateDirectoryName = (alternate_directory_name != NULL) ? 1 : 0;
 682 }
 683
 684 /*******************************************************************
 685  Reads or writes a structure.
 686 ********************************************************************/
 687
 688 static BOOL srv_io_share_info1007(const char *desc, SH_INFO_1007 *sh1007, prs_struct *ps, int depth)
 689 {
 690         if (sh1007 == NULL)
 691                 return False;
 692
 693         prs_debug(ps, depth, desc, "srv_io_share_info1007");
 694         depth++;
 695
 696         if(!prs_align(ps))
 697                 return False;
 698
 699         if(!prs_uint32("flags      ", ps, depth, &sh1007->flags))
 700                 return False;
 701         if(!prs_uint32("ptr_Alter..", ps, depth, &sh1007->ptr_AlternateDirectoryName))
 702                 return False;
 703
 704         return True;
 705 }
 706
 707 /*******************************************************************
 708  Reads or writes a structure.
 709 ********************************************************************/
 710
 711 static BOOL srv_io_share_info1501(const char* desc, SRV_SHARE_INFO_1501* sh1501,
 712                                   prs_struct* ps, int depth)
 713 {
 714         if(sh1501 == NULL)
 715                 return False;
 716
 717         prs_debug(ps, depth, desc, "srv_io_share_info1501");
 718         depth++;
 719
 720         if(!prs_align(ps))
 721                 return False;
 722
 723         if (!sec_io_desc_buf(desc, &sh1501->sdb, ps, depth))
 724                 return False;
 725
 726         return True;
 727 }
 728
 729 /*******************************************************************
 730  Reads or writes a structure.
 731 ********************************************************************/
 732
 733 static BOOL srv_io_srv_share_ctr(const char *desc, SRV_SHARE_INFO_CTR *ctr, prs_struct *ps, int depth)
 734 {
 735         if (ctr == NULL)
 736                 return False;
 737
 738         prs_debug(ps, depth, desc, "srv_io_srv_share_ctr");
 739         depth++;
 740
 741         if (UNMARSHALLING(ps)) {
 742                 memset(ctr, '\0', sizeof(SRV_SHARE_INFO_CTR));
 743         }
 744
 745         if(!prs_align(ps))
 746                 return False;
 747
 748         if(!prs_uint32("info_level", ps, depth, &ctr->info_level))
 749                 return False;
 750
 751         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
 752                 return False;
 753         if(!prs_uint32("ptr_share_info", ps, depth, &ctr->ptr_share_info))
 754                 return False;
 755
 756         if (ctr->ptr_share_info == 0)
 757                 return True;
 758
 759         if(!prs_uint32("num_entries", ps, depth, &ctr->num_entries))
 760                 return False;
 761         if(!prs_uint32("ptr_entries", ps, depth, &ctr->ptr_entries))
 762                 return False;
 763
 764         if (ctr->ptr_entries == 0) {
 765                 if (ctr->num_entries == 0)
 766                         return True;
 767                 else
 768                         return False;
 769         }
 770
 771         if(!prs_uint32("num_entries2", ps, depth, &ctr->num_entries2))
 772                 return False;
 773
 774         if (ctr->num_entries2 != ctr->num_entries)
 775                 return False;
 776
 777         switch (ctr->switch_value) {
 778
 779         case 0:
 780         {
 781                 SRV_SHARE_INFO_0 *info0 = ctr->share.info0;
 782                 int num_entries = ctr->num_entries;
 783                 int i;
 784
 785                 if (UNMARSHALLING(ps)) {
 786                         if (!(info0 = PRS_ALLOC_MEM(ps, SRV_SHARE_INFO_0, num_entries)))
 787                                 return False;
 788                         ctr->share.info0 = info0;
 789                 }
 790
 791                 for (i = 0; i < num_entries; i++) {
 792                         if(!srv_io_share_info0("", &info0[i].info_0, ps, depth))
 793                                 return False;
 794                 }
 795
 796                 for (i = 0; i < num_entries; i++) {
 797                         info0[i].info_0_str.ptrs = &info0[i].info_0;
 798                         if(!srv_io_share_info0_str("", &info0[i].info_0_str, ps, depth))
 799                                 return False;
 800                 }
 801
 802                 break;
 803         }
 804
 805         case 1:
 806         {
 807                 SRV_SHARE_INFO_1 *info1 = ctr->share.info1;
 808                 int num_entries = ctr->num_entries;
 809                 int i;
 810
 811                 if (UNMARSHALLING(ps)) {
 812                         if (!(info1 = PRS_ALLOC_MEM(ps, SRV_SHARE_INFO_1, num_entries)))
 813                                 return False;
 814                         ctr->share.info1 = info1;
 815                 }
 816
 817                 for (i = 0; i < num_entries; i++) {
 818                         if(!srv_io_share_info1("", &info1[i].info_1, ps, depth))
 819                                 return False;
 820                 }
 821
 822                 for (i = 0; i < num_entries; i++) {
 823                         info1[i].info_1_str.ptrs = &info1[i].info_1;
 824                         if(!srv_io_share_info1_str("", &info1[i].info_1_str, ps, depth))
 825                                 return False;
 826                 }
 827
 828                 break;
 829         }
 830
 831         case 2:
 832         {
 833                 SRV_SHARE_INFO_2 *info2 = ctr->share.info2;
 834                 int num_entries = ctr->num_entries;
 835                 int i;
 836
 837                 if (UNMARSHALLING(ps)) {
 838                         if (!(info2 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_2,num_entries)))
 839                                 return False;
 840                         ctr->share.info2 = info2;
 841                 }
 842
 843                 for (i = 0; i < num_entries; i++) {
 844                         if(!srv_io_share_info2("", &info2[i].info_2, ps, depth))
 845                                 return False;
 846                 }
 847
 848                 for (i = 0; i < num_entries; i++) {
 849                         if(!srv_io_share_info2_str("", &info2[i].info_2, &info2[i].info_2_str, ps, depth))
 850                                 return False;
 851                 }
 852
 853                 break;
 854         }
 855
 856         case 501:
 857         {
 858                 SRV_SHARE_INFO_501 *info501 = ctr->share.info501;
 859                 int num_entries = ctr->num_entries;
 860                 int i;
 861
 862                 if (UNMARSHALLING(ps)) {
 863                         if (!(info501 = PRS_ALLOC_MEM(ps, SRV_SHARE_INFO_501, num_entries)))
 864                                 return False;
 865                         ctr->share.info501 = info501;
 866                 }
 867
 868                 for (i = 0; i < num_entries; i++) {
 869                         if (!srv_io_share_info501("", &info501[i].info_501, ps, depth))
 870                                 return False;
 871                 }
 872
 873                 for (i = 0; i < num_entries; i++) {
 874                         if (!srv_io_share_info501_str("", &info501[i].info_501_str, ps, depth))
 875                                 return False;
 876                 }
 877
 878                 break;
 879         }
 880
 881         case 502:
 882         {
 883                 SRV_SHARE_INFO_502 *info502 = ctr->share.info502;
 884                 int num_entries = ctr->num_entries;
 885                 int i;
 886
 887                 if (UNMARSHALLING(ps)) {
 888                         if (!(info502 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_502,num_entries)))
 889                                 return False;
 890                         ctr->share.info502 = info502;
 891                 }
 892
 893                 for (i = 0; i < num_entries; i++) {
 894                         if(!srv_io_share_info502("", &info502[i].info_502, ps, depth))
 895                                 return False;
 896         }
 897
 898                 for (i = 0; i < num_entries; i++) {
 899                         info502[i].info_502_str.ptrs = &info502[i].info_502;
 900                         if(!srv_io_share_info502_str("", &info502[i].info_502_str, ps, depth))
 901                                 return False;
 902                 }
 903
 904                 break;
 905         }
 906
 907         case 1004:
 908         {
 909                 SRV_SHARE_INFO_1004 *info1004 = ctr->share.info1004;
 910                 int num_entries = ctr->num_entries;
 911                 int i;
 912
 913                 if (UNMARSHALLING(ps)) {
 914                         if (!(info1004 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_1004,num_entries)))
 915                                 return False;
 916                         ctr->share.info1004 = info1004;
 917                 }
 918
 919                 for (i = 0; i < num_entries; i++) {
 920                         if(!srv_io_share_info1004("", &info1004[i].info_1004, ps, depth))
 921                                 return False;
 922                 }
 923
 924                 for (i = 0; i < num_entries; i++) {
 925                         info1004[i].info_1004_str.ptrs = &info1004[i].info_1004;
 926                         if(!srv_io_share_info1004_str("", &info1004[i].info_1004_str, ps, depth))
 927                                 return False;
 928                 }
 929
 930                 break;
 931         }
 932
 933         case 1005:
 934         {
 935                 SRV_SHARE_INFO_1005 *info1005 = ctr->share.info1005;
 936                 int num_entries = ctr->num_entries;
 937                 int i;
 938
 939                 if (UNMARSHALLING(ps)) {
 940                         if (!(info1005 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_1005,num_entries)))
 941                                 return False;
 942                         ctr->share.info1005 = info1005;
 943                 }
 944
 945                 for (i = 0; i < num_entries; i++) {
 946                         if(!srv_io_share_info1005("", &info1005[i], ps, depth))
 947                                 return False;
 948                 }
 949
 950                 break;
 951         }
 952
 953         case 1006:
 954         {
 955                 SRV_SHARE_INFO_1006 *info1006 = ctr->share.info1006;
 956                 int num_entries = ctr->num_entries;
 957                 int i;
 958
 959                 if (UNMARSHALLING(ps)) {
 960                         if (!(info1006 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_1006,num_entries)))
 961                                 return False;
 962                         ctr->share.info1006 = info1006;
 963                 }
 964
 965                 for (i = 0; i < num_entries; i++) {
 966                         if(!srv_io_share_info1006("", &info1006[i], ps, depth))
 967                                 return False;
 968                 }
 969
 970                 break;
 971         }
 972
 973         case 1007:
 974         {
 975                 SRV_SHARE_INFO_1007 *info1007 = ctr->share.info1007;
 976                 int num_entries = ctr->num_entries;
 977                 int i;
 978
 979                 if (UNMARSHALLING(ps)) {
 980                         if (!(info1007 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_1007,num_entries)))
 981                                 return False;
 982                         ctr->share.info1007 = info1007;
 983                 }
 984
 985                 for (i = 0; i < num_entries; i++) {
 986                         if(!srv_io_share_info1007("", &info1007[i].info_1007, ps, depth))
 987                                 return False;
 988                 }
 989
 990                 for (i = 0; i < num_entries; i++) {
 991                         info1007[i].info_1007_str.ptrs = &info1007[i].info_1007;
 992                         if(!srv_io_share_info1007_str("", &info1007[i].info_1007_str, ps, depth))
 993                                 return False;
 994                 }
 995
 996                 break;
 997         }
 998
 999         case 1501:
1000         {
1001                 SRV_SHARE_INFO_1501 *info1501 = ctr->share.info1501;
1002                 int num_entries = ctr->num_entries;
1003                 int i;
1004
1005                 if (UNMARSHALLING(ps)) {
1006                         if (!(info1501 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_1501,num_entries)))
1007                                 return False;
1008                         ctr->share.info1501 = info1501;
1009                 }
1010
1011                 for (i = 0; i < num_entries; i++) {
1012                         if(!srv_io_share_info1501("", &info1501[i], ps, depth))
1013                                 return False;
1014                 }
1015
1016                 break;
1017         }
1018
1019         default:
1020                 DEBUG(5,("%s no share info at switch_value %d\n",
1021                          tab_depth(depth), ctr->switch_value));
1022                 break;
1023         }
1024
1025         return True;
1026 }
1027
1028 /*******************************************************************
1029  Inits a SRV_Q_NET_SHARE_ENUM structure.
1030 ********************************************************************/
1031
1032 void init_srv_q_net_share_enum(SRV_Q_NET_SHARE_ENUM *q_n,
1033                                 const char *srv_name, uint32 info_level,
1034                                 uint32 preferred_len, ENUM_HND *hnd)
1035 {
1036
1037         DEBUG(5,("init_q_net_share_enum\n"));
1038
1039         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
1040
1041         q_n->ctr.info_level = q_n->ctr.switch_value = info_level;
1042         q_n->ctr.ptr_share_info = 1;
1043         q_n->ctr.num_entries  = 0;
1044         q_n->ctr.ptr_entries  = 0;
1045         q_n->ctr.num_entries2 = 0;
1046         q_n->preferred_len = preferred_len;
1047
1048         memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
1049 }
1050
1051 /*******************************************************************
1052  Reads or writes a structure.
1053 ********************************************************************/
1054
1055 BOOL srv_io_q_net_share_enum(const char *desc, SRV_Q_NET_SHARE_ENUM *q_n, prs_struct *ps, int depth)
1056 {
1057         if (q_n == NULL)
1058                 return False;
1059
1060         prs_debug(ps, depth, desc, "srv_io_q_net_share_enum");
1061         depth++;
1062
1063         if(!prs_align(ps))
1064                 return False;
1065
1066         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1067                 return False;
1068         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1069                 return False;
1070
1071         if(!srv_io_srv_share_ctr("share_ctr", &q_n->ctr, ps, depth))
1072                 return False;
1073
1074         if(!prs_align(ps))
1075                 return False;
1076
1077         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
1078                 return False;
1079
1080         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
1081                 return False;
1082
1083         return True;
1084 }
1085
1086 /*******************************************************************
1087  Reads or writes a structure.
1088 ********************************************************************/
1089
1090 BOOL srv_io_r_net_share_enum(const char *desc, SRV_R_NET_SHARE_ENUM *r_n, prs_struct *ps, int depth)
1091 {
1092         if (r_n == NULL)
1093                 return False;
1094
1095         prs_debug(ps, depth, desc, "srv_io_r_net_share_enum");
1096         depth++;
1097
1098         if(!srv_io_srv_share_ctr("share_ctr", &r_n->ctr, ps, depth))
1099                 return False;
1100
1101         if(!prs_align(ps))
1102                 return False;
1103
1104         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
1105                 return False;
1106
1107         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
1108                 return False;
1109
1110         if(!prs_werror("status", ps, depth, &r_n->status))
1111                 return False;
1112
1113         return True;
1114 }
1115
1116 /*******************************************************************
1117  initialises a structure.
1118 ********************************************************************/
1119
1120 BOOL init_srv_q_net_share_get_info(SRV_Q_NET_SHARE_GET_INFO *q_n, const char *srv_name, const char *share_name, uint32 info_level)
1121 {
1122
1123         uint32 ptr_share_name;
1124
1125         DEBUG(5,("init_srv_q_net_share_get_info\n"));
1126
1127         init_buf_unistr2(&q_n->uni_srv_name,   &q_n->ptr_srv_name, srv_name);
1128         init_buf_unistr2(&q_n->uni_share_name, &ptr_share_name,    share_name);
1129
1130         q_n->info_level = info_level;
1131
1132         return True;
1133 }
1134
1135 /*******************************************************************
1136  Reads or writes a structure.
1137 ********************************************************************/
1138
1139 BOOL srv_io_q_net_share_get_info(const char *desc, SRV_Q_NET_SHARE_GET_INFO *q_n, prs_struct *ps, int depth)
1140 {
1141         if (q_n == NULL)
1142                 return False;
1143
1144         prs_debug(ps, depth, desc, "srv_io_q_net_share_get_info");
1145         depth++;
1146
1147         if(!prs_align(ps))
1148                 return False;
1149
1150         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1151                 return False;
1152         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1153                 return False;
1154
1155         if(!smb_io_unistr2("", &q_n->uni_share_name, True, ps, depth))
1156                 return False;
1157
1158         if(!prs_align(ps))
1159                 return False;
1160
1161         if(!prs_uint32("info_level", ps, depth, &q_n->info_level))
1162                 return False;
1163
1164         return True;
1165 }
1166
1167 /*******************************************************************
1168  Reads or writes a structure.
1169 ********************************************************************/
1170
1171 static BOOL srv_io_srv_share_info(const char *desc, prs_struct *ps, int depth, SRV_SHARE_INFO *r_n)
1172 {
1173         if (r_n == NULL)
1174                 return False;
1175
1176         prs_debug(ps, depth, desc, "srv_io_srv_share_info");
1177         depth++;
1178
1179         if(!prs_align(ps))
1180                 return False;
1181
1182         if(!prs_uint32("switch_value ", ps, depth, &r_n->switch_value ))
1183                 return False;
1184
1185         if(!prs_uint32("ptr_share_ctr", ps, depth, &r_n->ptr_share_ctr))
1186                 return False;
1187
1188         if (r_n->ptr_share_ctr != 0) {
1189                 switch (r_n->switch_value) {
1190                 case 0:
1191                         if(!srv_io_share_info0("", &r_n->share.info0.info_0, ps, depth))
1192                                 return False;
1193
1194                         /* allow access to pointers in the str part. */
1195                         r_n->share.info0.info_0_str.ptrs = &r_n->share.info0.info_0;
1196
1197                         if(!srv_io_share_info0_str("", &r_n->share.info0.info_0_str, ps, depth))
1198                                 return False;
1199
1200                         break;
1201                 case 1:
1202                         if(!srv_io_share_info1("", &r_n->share.info1.info_1, ps, depth))
1203                                 return False;
1204
1205                         /* allow access to pointers in the str part. */
1206                         r_n->share.info1.info_1_str.ptrs = &r_n->share.info1.info_1;
1207
1208                         if(!srv_io_share_info1_str("", &r_n->share.info1.info_1_str, ps, depth))
1209                                 return False;
1210
1211                         break;
1212                 case 2:
1213                         if(!srv_io_share_info2("", &r_n->share.info2.info_2, ps, depth))
1214                                 return False;
1215
1216                         if(!srv_io_share_info2_str("", &r_n->share.info2.info_2, &r_n->share.info2.info_2_str, ps, depth))
1217                                 return False;
1218
1219                         break;
1220                 case 501:
1221                         if (!srv_io_share_info501("", &r_n->share.info501.info_501, ps, depth))
1222                                 return False;
1223                         if (!srv_io_share_info501_str("", &r_n->share.info501.info_501_str, ps, depth))
1224                                 return False;
1225                         break;
1226
1227                 case 502:
1228                         if(!srv_io_share_info502("", &r_n->share.info502.info_502, ps, depth))
1229                                 return False;
1230
1231                         /* allow access to pointers in the str part. */
1232                         r_n->share.info502.info_502_str.ptrs = &r_n->share.info502.info_502;
1233
1234                         if(!srv_io_share_info502_str("", &r_n->share.info502.info_502_str, ps, depth))
1235                                 return False;
1236                         break;
1237                 case 1004:
1238                         if(!srv_io_share_info1004("", &r_n->share.info1004.info_1004, ps, depth))
1239                                 return False;
1240
1241                         /* allow access to pointers in the str part. */
1242                         r_n->share.info1004.info_1004_str.ptrs = &r_n->share.info1004.info_1004;
1243
1244                         if(!srv_io_share_info1004_str("", &r_n->share.info1004.info_1004_str, ps, depth))
1245                                 return False;
1246                         break;
1247                 case 1005:
1248                         if(!srv_io_share_info1005("", &r_n->share.info1005, ps, depth))
1249                                 return False;
1250                         break;
1251                 case 1006:
1252                         if(!srv_io_share_info1006("", &r_n->share.info1006, ps, depth))
1253                                 return False;
1254                         break;
1255                 case 1007:
1256                         if(!srv_io_share_info1007("", &r_n->share.info1007.info_1007, ps, depth))
1257                                 return False;
1258
1259                         /* allow access to pointers in the str part. */
1260                         r_n->share.info1007.info_1007_str.ptrs = &r_n->share.info1007.info_1007;
1261
1262                         if(!srv_io_share_info1007_str("", &r_n->share.info1007.info_1007_str, ps, depth))
1263                                 return False;
1264                         break;
1265                 case 1501:
1266                         if (!srv_io_share_info1501("", &r_n->share.info1501, ps, depth))
1267                                 return False;
1268                 default:
1269                         DEBUG(5,("%s no share info at switch_value %d\n",
1270                                  tab_depth(depth), r_n->switch_value));
1271                         break;
1272                 }
1273         }
1274
1275         return True;
1276 }
1277
1278 /*******************************************************************
1279  Reads or writes a structure.
1280 ********************************************************************/
1281
1282 BOOL srv_io_r_net_share_get_info(const char *desc, SRV_R_NET_SHARE_GET_INFO *r_n, prs_struct *ps, int depth)
1283 {
1284         if (r_n == NULL)
1285                 return False;
1286
1287         prs_debug(ps, depth, desc, "srv_io_r_net_share_get_info");
1288         depth++;
1289
1290         if(!prs_align(ps))
1291                 return False;
1292
1293         if(!srv_io_srv_share_info("info  ", ps, depth, &r_n->info))
1294                 return False;
1295
1296         if(!prs_align(ps))
1297                 return False;
1298
1299         if(!prs_werror("status", ps, depth, &r_n->status))
1300                 return False;
1301
1302         return True;
1303 }
1304
1305 /*******************************************************************
1306  intialises a structure.
1307 ********************************************************************/
1308
1309 BOOL init_srv_q_net_share_set_info(SRV_Q_NET_SHARE_SET_INFO *q_n,
1310                                    const char *srv_name,
1311                                    const char *share_name,
1312                                    uint32 info_level,
1313                                    const SRV_SHARE_INFO *info)
1314 {
1315
1316         uint32 ptr_share_name;
1317
1318         DEBUG(5,("init_srv_q_net_share_set_info\n"));
1319
1320         init_buf_unistr2(&q_n->uni_srv_name,   &q_n->ptr_srv_name, srv_name);
1321         init_buf_unistr2(&q_n->uni_share_name, &ptr_share_name,    share_name);
1322
1323         q_n->info_level = info_level;
1324
1325         q_n->info = *info;
1326
1327         q_n->ptr_parm_error = 1;
1328         q_n->parm_error     = 0;
1329
1330         return True;
1331 }
1332
1333 /*******************************************************************
1334  Reads or writes a structure.
1335 ********************************************************************/
1336
1337 BOOL srv_io_q_net_share_set_info(const char *desc, SRV_Q_NET_SHARE_SET_INFO *q_n, prs_struct *ps, int depth)
1338 {
1339         if (q_n == NULL)
1340                 return False;
1341
1342         prs_debug(ps, depth, desc, "srv_io_q_net_share_set_info");
1343         depth++;
1344
1345         if(!prs_align(ps))
1346                 return False;
1347
1348         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1349                 return False;
1350         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1351                 return False;
1352
1353         if(!smb_io_unistr2("", &q_n->uni_share_name, True, ps, depth))
1354                 return False;
1355
1356         if(!prs_align(ps))
1357                 return False;
1358
1359         if(!prs_uint32("info_level", ps, depth, &q_n->info_level))
1360                 return False;
1361
1362         if(!prs_align(ps))
1363                 return False;
1364
1365         if(!srv_io_srv_share_info("info  ", ps, depth, &q_n->info))
1366                 return False;
1367
1368         if(!prs_align(ps))
1369                 return False;
1370         if(!prs_uint32("ptr_parm_error", ps, depth, &q_n->ptr_parm_error))
1371                 return False;
1372         if(q_n->ptr_parm_error!=0) {
1373                 if(!prs_uint32("parm_error", ps, depth, &q_n->parm_error))
1374                         return False;
1375         }
1376
1377         return True;
1378 }
1379
1380 /*******************************************************************
1381  Reads or writes a structure.
1382 ********************************************************************/
1383
1384 BOOL srv_io_r_net_share_set_info(const char *desc, SRV_R_NET_SHARE_SET_INFO *r_n, prs_struct *ps, int depth)
1385 {
1386         if (r_n == NULL)
1387                 return False;
1388
1389         prs_debug(ps, depth, desc, "srv_io_r_net_share_set_info");
1390         depth++;
1391
1392         if(!prs_align(ps))
1393                 return False;
1394
1395         if(!prs_uint32("ptr_parm_error  ", ps, depth, &r_n->ptr_parm_error))
1396                 return False;
1397
1398         if(r_n->ptr_parm_error) {
1399
1400                 if(!prs_uint32("parm_error  ", ps, depth, &r_n->parm_error))
1401                         return False;
1402         }
1403
1404         if(!prs_werror("status", ps, depth, &r_n->status))
1405                 return False;
1406
1407         return True;
1408 }
1409
1410
1411 /*******************************************************************
1412  Reads or writes a structure.
1413 ********************************************************************/
1414
1415 BOOL srv_io_q_net_share_add(const char *desc, SRV_Q_NET_SHARE_ADD *q_n, prs_struct *ps, int depth)
1416 {
1417         if (q_n == NULL)
1418                 return False;
1419
1420         prs_debug(ps, depth, desc, "srv_io_q_net_share_add");
1421         depth++;
1422
1423         if(!prs_align(ps))
1424                 return False;
1425
1426         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1427                 return False;
1428         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1429                 return False;
1430
1431         if(!prs_align(ps))
1432                 return False;
1433
1434         if(!prs_uint32("info_level", ps, depth, &q_n->info_level))
1435                 return False;
1436
1437         if(!prs_align(ps))
1438                 return False;
1439
1440         if(!srv_io_srv_share_info("info  ", ps, depth, &q_n->info))
1441                 return False;
1442
1443         if(!prs_align(ps))
1444                 return False;
1445
1446         if(!prs_uint32("ptr_err_index", ps, depth, &q_n->ptr_err_index))
1447                 return False;
1448         if (q_n->ptr_err_index)
1449                 if (!prs_uint32("err_index", ps, depth, &q_n->err_index))
1450                         return False;
1451
1452         return True;
1453 }
1454
1455 void init_srv_q_net_share_add(SRV_Q_NET_SHARE_ADD *q, const char *srvname,
1456                               const char *netname, uint32 type, const char *remark,
1457                               uint32 perms, uint32 max_uses, uint32 num_uses,
1458                               const char *path, const char *passwd,
1459                               int level, SEC_DESC *sd)
1460 {
1461         switch(level) {
1462         case 502: {
1463                 size_t sd_size = sec_desc_size(sd);
1464                 q->ptr_srv_name = 1;
1465                 init_unistr2(&q->uni_srv_name, srvname, UNI_STR_TERMINATE);
1466                 q->info.switch_value = q->info_level = level;
1467                 q->info.ptr_share_ctr = 1;
1468                 init_srv_share_info502(&q->info.share.info502.info_502, netname, type,
1469                                      remark, perms, max_uses, num_uses, path, passwd, sd, sd_size);
1470                 init_srv_share_info502_str(&q->info.share.info502.info_502_str, netname,
1471                                          remark, path, passwd, sd, sd_size);
1472                 q->ptr_err_index = 1;
1473                 q->err_index = 0;
1474                 }
1475                 break;
1476         case 2:
1477         default:
1478                 q->ptr_srv_name = 1;
1479                 init_unistr2(&q->uni_srv_name, srvname, UNI_STR_TERMINATE);
1480                 q->info.switch_value = q->info_level = level;
1481                 q->info.ptr_share_ctr = 1;
1482                 init_srv_share_info2(&q->info.share.info2.info_2, netname, type,
1483                                      remark, perms, max_uses, num_uses, path, passwd);
1484                 init_srv_share_info2_str(&q->info.share.info2.info_2_str, netname,
1485                                          remark, path, passwd);
1486                 q->ptr_err_index = 1;
1487                 q->err_index = 0;
1488                 break;
1489         }
1490 }
1491
1492
1493 /*******************************************************************
1494  Reads or writes a structure.
1495 ********************************************************************/
1496
1497 BOOL srv_io_r_net_share_add(const char *desc, SRV_R_NET_SHARE_ADD *r_n, prs_struct *ps, int depth)
1498 {
1499         if (r_n == NULL)
1500                 return False;
1501
1502         prs_debug(ps, depth, desc, "srv_io_r_net_share_add");
1503         depth++;
1504
1505         if(!prs_align(ps))
1506                 return False;
1507
1508         if(!prs_uint32("ptr_parm_error", ps, depth, &r_n->ptr_parm_error))
1509                 return False;
1510
1511         if(r_n->ptr_parm_error) {
1512
1513                 if(!prs_uint32("parm_error", ps, depth, &r_n->parm_error))
1514                         return False;
1515         }
1516
1517         if(!prs_werror("status", ps, depth, &r_n->status))
1518                 return False;
1519
1520         return True;
1521 }
1522
1523 /*******************************************************************
1524  initialises a structure.
1525 ********************************************************************/
1526
1527 void init_srv_q_net_share_del(SRV_Q_NET_SHARE_DEL *del, const char *srvname,
1528                               const char *sharename)
1529 {
1530         del->ptr_srv_name = 1;
1531         init_unistr2(&del->uni_srv_name, srvname, UNI_STR_TERMINATE);
1532         init_unistr2(&del->uni_share_name, sharename, UNI_STR_TERMINATE);
1533 }
1534
1535 /*******************************************************************
1536  Reads or writes a structure.
1537 ********************************************************************/
1538
1539 BOOL srv_io_q_net_share_del(const char *desc, SRV_Q_NET_SHARE_DEL *q_n, prs_struct *ps, int depth)
1540 {
1541         if (q_n == NULL)
1542                 return False;
1543
1544         prs_debug(ps, depth, desc, "srv_io_q_net_share_del");
1545         depth++;
1546
1547         if(!prs_align(ps))
1548                 return False;
1549
1550         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1551                 return False;
1552         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1553                 return False;
1554
1555         if(!smb_io_unistr2("", &q_n->uni_share_name, True, ps, depth))
1556                 return False;
1557
1558         if(!prs_align(ps))
1559                 return False;
1560         if(!prs_uint32("reserved", ps, depth, &q_n->reserved))
1561                 return False;
1562
1563         return True;
1564 }
1565
1566 /*******************************************************************
1567  Reads or writes a structure.
1568 ********************************************************************/
1569
1570 BOOL srv_io_r_net_share_del(const char *desc, SRV_R_NET_SHARE_DEL *q_n, prs_struct *ps, int depth)
1571 {
1572         if (q_n == NULL)
1573                 return False;
1574
1575         prs_debug(ps, depth, desc, "srv_io_r_net_share_del");
1576         depth++;
1577
1578         if(!prs_align(ps))
1579                 return False;
1580
1581         if(!prs_werror("status", ps, depth, &q_n->status))
1582                 return False;
1583
1584         return True;
1585 }
1586
1587 /*******************************************************************
1588  Inits a SESS_INFO_0_STR structure
1589 ********************************************************************/
1590
1591 void init_srv_sess_info0_str(SESS_INFO_0_STR *ss0, const char *name)
1592 {
1593         DEBUG(5,("init_srv_sess_info0_str\n"));
1594
1595         init_unistr2(&ss0->uni_name, name, UNI_STR_TERMINATE);
1596 }
1597
1598 /*******************************************************************
1599  Reads or writes a structure.
1600 ********************************************************************/
1601
1602 static BOOL srv_io_sess_info0_str(const char *desc,  SESS_INFO_0_STR *ss0, prs_struct *ps, int depth)
1603 {
1604         if (ss0 == NULL)
1605                 return False;
1606
1607         prs_debug(ps, depth, desc, "srv_io_sess_info0_str");
1608         depth++;
1609
1610         if(!prs_align(ps))
1611                 return False;
1612
1613         if(!smb_io_unistr2("", &ss0->uni_name, True, ps, depth))
1614                 return False;
1615
1616         return True;
1617 }
1618
1619 /*******************************************************************
1620  Inits a SESS_INFO_0 structure
1621 ********************************************************************/
1622
1623 void init_srv_sess_info0(SESS_INFO_0 *ss0, const char *name)
1624 {
1625         DEBUG(5,("init_srv_sess_info0: %s\n", name));
1626
1627         ss0->ptr_name = (name != NULL) ? 1 : 0;
1628 }
1629
1630 /*******************************************************************
1631  Reads or writes a structure.
1632 ********************************************************************/
1633
1634 static BOOL srv_io_sess_info0(const char *desc, SESS_INFO_0 *ss0, prs_struct *ps, int depth)
1635 {
1636         if (ss0 == NULL)
1637                 return False;
1638
1639         prs_debug(ps, depth, desc, "srv_io_sess_info0");
1640         depth++;
1641
1642         if(!prs_align(ps))
1643                 return False;
1644
1645         if(!prs_uint32("ptr_name", ps, depth, &ss0->ptr_name))
1646                 return False;
1647
1648         return True;
1649 }
1650
1651 /*******************************************************************
1652  Reads or writes a structure.
1653 ********************************************************************/
1654
1655 static BOOL srv_io_srv_sess_info_0(const char *desc, SRV_SESS_INFO_0 *ss0, prs_struct *ps, int depth)
1656 {
1657         if (ss0 == NULL)
1658                 return False;
1659
1660         prs_debug(ps, depth, desc, "srv_io_srv_sess_info_0");
1661         depth++;
1662
1663         if(!prs_align(ps))
1664                 return False;
1665
1666         if(!prs_uint32("num_entries_read", ps, depth, &ss0->num_entries_read))
1667                 return False;
1668         if(!prs_uint32("ptr_sess_info", ps, depth, &ss0->ptr_sess_info))
1669                 return False;
1670
1671         if (ss0->ptr_sess_info != 0) {
1672                 uint32 i;
1673                 uint32 num_entries = ss0->num_entries_read;
1674
1675                 if (num_entries > MAX_SESS_ENTRIES) {
1676                         num_entries = MAX_SESS_ENTRIES; /* report this! */
1677                 }
1678
1679                 if(!prs_uint32("num_entries_read2", ps, depth, &ss0->num_entries_read2))
1680                         return False;
1681
1682                 SMB_ASSERT_ARRAY(ss0->info_0, num_entries);
1683
1684                 for (i = 0; i < num_entries; i++) {
1685                         if(!srv_io_sess_info0("", &ss0->info_0[i], ps, depth))
1686                                 return False;
1687                 }
1688
1689                 for (i = 0; i < num_entries; i++) {
1690                         if(!srv_io_sess_info0_str("", &ss0->info_0_str[i], ps, depth))
1691                                 return False;
1692                 }
1693
1694                 if(!prs_align(ps))
1695                         return False;
1696         }
1697
1698         return True;
1699 }
1700
1701 /*******************************************************************
1702  Inits a SESS_INFO_1_STR structure
1703 ********************************************************************/
1704
1705 void init_srv_sess_info1_str(SESS_INFO_1_STR *ss1, const char *name, const char *user)
1706 {
1707         DEBUG(5,("init_srv_sess_info1_str\n"));
1708
1709         init_unistr2(&ss1->uni_name, name, UNI_STR_TERMINATE);
1710         init_unistr2(&ss1->uni_user, user, UNI_STR_TERMINATE);
1711 }
1712
1713 /*******************************************************************
1714  Reads or writes a structure.
1715 ********************************************************************/
1716
1717 static BOOL srv_io_sess_info1_str(const char *desc, SESS_INFO_1_STR *ss1, prs_struct *ps, int depth)
1718 {
1719         if (ss1 == NULL)
1720                 return False;
1721
1722         prs_debug(ps, depth, desc, "srv_io_sess_info1_str");
1723         depth++;
1724
1725         if(!prs_align(ps))
1726                 return False;
1727
1728         if(!smb_io_unistr2("", &ss1->uni_name, True, ps, depth))
1729                 return False;
1730         if(!smb_io_unistr2("", &(ss1->uni_user), True, ps, depth))
1731                 return False;
1732
1733         return True;
1734 }
1735
1736 /*******************************************************************
1737  Inits a SESS_INFO_1 structure
1738 ********************************************************************/
1739
1740 void init_srv_sess_info1(SESS_INFO_1 *ss1,
1741                                 const char *name, const char *user,
1742                                 uint32 num_opens, uint32 open_time, uint32 idle_time,
1743                                 uint32 user_flags)
1744 {
1745         DEBUG(5,("init_srv_sess_info1: %s\n", name));
1746
1747         ss1->ptr_name = (name != NULL) ? 1 : 0;
1748         ss1->ptr_user = (user != NULL) ? 1 : 0;
1749
1750         ss1->num_opens  = num_opens;
1751         ss1->open_time  = open_time;
1752         ss1->idle_time  = idle_time;
1753         ss1->user_flags = user_flags;
1754 }
1755
1756 /*******************************************************************
1757 reads or writes a structure.
1758 ********************************************************************/
1759
1760 static BOOL srv_io_sess_info1(const char *desc, SESS_INFO_1 *ss1, prs_struct *ps, int depth)
1761 {
1762         if (ss1 == NULL)
1763                 return False;
1764
1765         prs_debug(ps, depth, desc, "srv_io_sess_info1");
1766         depth++;
1767
1768         if(!prs_align(ps))
1769                 return False;
1770
1771         if(!prs_uint32("ptr_name  ", ps, depth, &ss1->ptr_name))
1772                 return False;
1773         if(!prs_uint32("ptr_user  ", ps, depth, &ss1->ptr_user))
1774                 return False;
1775
1776         if(!prs_uint32("num_opens ", ps, depth, &ss1->num_opens))
1777                 return False;
1778         if(!prs_uint32("open_time ", ps, depth, &ss1->open_time))
1779                 return False;
1780         if(!prs_uint32("idle_time ", ps, depth, &ss1->idle_time))
1781                 return False;
1782         if(!prs_uint32("user_flags", ps, depth, &ss1->user_flags))
1783                 return False;
1784
1785         return True;
1786 }
1787
1788 /*******************************************************************
1789  Reads or writes a structure.
1790 ********************************************************************/
1791
1792 static BOOL srv_io_srv_sess_info_1(const char *desc, SRV_SESS_INFO_1 *ss1, prs_struct *ps, int depth)
1793 {
1794         if (ss1 == NULL)
1795                 return False;
1796
1797         prs_debug(ps, depth, desc, "srv_io_srv_sess_info_1");
1798         depth++;
1799
1800         if(!prs_align(ps))
1801                 return False;
1802
1803         if(!prs_uint32("num_entries_read", ps, depth, &ss1->num_entries_read))
1804                 return False;
1805         if(!prs_uint32("ptr_sess_info", ps, depth, &ss1->ptr_sess_info))
1806                 return False;
1807
1808         if (ss1->ptr_sess_info != 0) {
1809                 uint32 i;
1810                 uint32 num_entries = ss1->num_entries_read;
1811
1812                 if (num_entries > MAX_SESS_ENTRIES) {
1813                         num_entries = MAX_SESS_ENTRIES; /* report this! */
1814                 }
1815
1816                 if(!prs_uint32("num_entries_read2", ps, depth, &ss1->num_entries_read2))
1817                         return False;
1818
1819                 SMB_ASSERT_ARRAY(ss1->info_1, num_entries);
1820
1821                 for (i = 0; i < num_entries; i++) {
1822                         if(!srv_io_sess_info1("", &ss1->info_1[i], ps, depth))
1823                                 return False;
1824                 }
1825
1826                 for (i = 0; i < num_entries; i++) {
1827                         if(!srv_io_sess_info1_str("", &ss1->info_1_str[i], ps, depth))
1828                                 return False;
1829                 }
1830
1831                 if(!prs_align(ps))
1832                         return False;
1833         }
1834
1835         return True;
1836 }
1837
1838 /*******************************************************************
1839  Reads or writes a structure.
1840 ********************************************************************/
1841
1842 static BOOL srv_io_srv_sess_ctr(const char *desc, SRV_SESS_INFO_CTR **pp_ctr, prs_struct *ps, int depth)
1843 {
1844         SRV_SESS_INFO_CTR *ctr = *pp_ctr;
1845
1846         prs_debug(ps, depth, desc, "srv_io_srv_sess_ctr");
1847         depth++;
1848
1849         if(UNMARSHALLING(ps)) {
1850                 ctr = *pp_ctr = PRS_ALLOC_MEM(ps, SRV_SESS_INFO_CTR, 1);
1851                 if (ctr == NULL)
1852                         return False;
1853         }
1854
1855         if (ctr == NULL)
1856                 return False;
1857
1858         if(!prs_align(ps))
1859                 return False;
1860
1861         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
1862                 return False;
1863         if(!prs_uint32("ptr_sess_ctr", ps, depth, &ctr->ptr_sess_ctr))
1864                 return False;
1865
1866         if (ctr->ptr_sess_ctr != 0) {
1867                 switch (ctr->switch_value) {
1868                 case 0:
1869                         if(!srv_io_srv_sess_info_0("", &ctr->sess.info0, ps, depth))
1870                                 return False;
1871                         break;
1872                 case 1:
1873                         if(!srv_io_srv_sess_info_1("", &ctr->sess.info1, ps, depth))
1874                                 return False;
1875                         break;
1876                 default:
1877                         DEBUG(5,("%s no session info at switch_value %d\n",
1878                                  tab_depth(depth), ctr->switch_value));
1879                         break;
1880                 }
1881         }
1882
1883         return True;
1884 }
1885
1886 /*******************************************************************
1887  Inits a SRV_Q_NET_SESS_ENUM structure.
1888 ********************************************************************/
1889
1890 void init_srv_q_net_sess_enum(SRV_Q_NET_SESS_ENUM *q_n,
1891                               const char *srv_name, const char *qual_name,
1892                               const char *user_name, uint32 sess_level,
1893                               SRV_SESS_INFO_CTR *ctr, uint32 preferred_len,
1894                               ENUM_HND *hnd)
1895 {
1896         q_n->ctr = ctr;
1897
1898         DEBUG(5,("init_q_net_sess_enum\n"));
1899
1900         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
1901         init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
1902         init_buf_unistr2(&q_n->uni_user_name, &q_n->ptr_user_name, user_name);
1903
1904         q_n->sess_level    = sess_level;
1905         q_n->preferred_len = preferred_len;
1906
1907         memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
1908 }
1909
1910 /*******************************************************************
1911  Reads or writes a structure.
1912 ********************************************************************/
1913
1914 BOOL srv_io_q_net_sess_enum(const char *desc, SRV_Q_NET_SESS_ENUM *q_n, prs_struct *ps, int depth)
1915 {
1916         if (q_n == NULL)
1917                 return False;
1918
1919         prs_debug(ps, depth, desc, "srv_io_q_net_sess_enum");
1920         depth++;
1921
1922         if(!prs_align(ps))
1923                 return False;
1924
1925         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1926                 return False;
1927         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1928                 return False;
1929
1930         if(!prs_align(ps))
1931                 return False;
1932
1933         if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
1934                 return False;
1935         if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
1936                 return False;
1937
1938         if(!prs_align(ps))
1939                 return False;
1940         if(!prs_uint32("ptr_user_name", ps, depth, &q_n->ptr_user_name))
1941                 return False;
1942         if(!smb_io_unistr2("", &q_n->uni_user_name, q_n->ptr_user_name, ps, depth))
1943                 return False;
1944
1945         if(!prs_align(ps))
1946                 return False;
1947
1948         if(!prs_uint32("sess_level", ps, depth, &q_n->sess_level))
1949                 return False;
1950
1951         if (q_n->sess_level != (uint32)-1) {
1952                 if(!srv_io_srv_sess_ctr("sess_ctr", &q_n->ctr, ps, depth))
1953                         return False;
1954         }
1955
1956         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
1957                 return False;
1958
1959         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
1960                 return False;
1961
1962         return True;
1963 }
1964
1965 /*******************************************************************
1966  Reads or writes a structure.
1967 ********************************************************************/
1968
1969 BOOL srv_io_r_net_sess_enum(const char *desc, SRV_R_NET_SESS_ENUM *r_n, prs_struct *ps, int depth)
1970 {
1971         if (r_n == NULL)
1972                 return False;
1973
1974         prs_debug(ps, depth, desc, "srv_io_r_net_sess_enum");
1975         depth++;
1976
1977         if(!prs_align(ps))
1978                 return False;
1979
1980         if(!prs_uint32("sess_level", ps, depth, &r_n->sess_level))
1981                 return False;
1982
1983         if (r_n->sess_level != (uint32)-1) {
1984                 if(!srv_io_srv_sess_ctr("sess_ctr", &r_n->ctr, ps, depth))
1985                         return False;
1986         }
1987
1988         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
1989                 return False;
1990         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
1991                 return False;
1992         if(!prs_werror("status", ps, depth, &r_n->status))
1993                 return False;
1994
1995         return True;
1996 }
1997
1998 /*******************************************************************
1999  Inits a SRV_Q_NET_SESS_DEL structure.
2000 ********************************************************************/
2001
2002 void init_srv_q_net_sess_del(SRV_Q_NET_SESS_DEL *q_n, const char *srv_name,
2003                               const char *cli_name, const char *user_name)
2004 {
2005         DEBUG(5,("init_q_net_sess_enum\n"));
2006
2007         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
2008         init_buf_unistr2(&q_n->uni_cli_name, &q_n->ptr_cli_name, cli_name);
2009         init_buf_unistr2(&q_n->uni_user_name, &q_n->ptr_user_name, user_name);
2010 }
2011
2012 /*******************************************************************
2013  Reads or writes a structure.
2014 ********************************************************************/
2015
2016 BOOL srv_io_q_net_sess_del(const char *desc, SRV_Q_NET_SESS_DEL *q_n, prs_struct *ps, int depth)
2017 {
2018         if (q_n == NULL)
2019                 return False;
2020
2021         prs_debug(ps, depth, desc, "srv_io_q_net_sess_del");
2022         depth++;
2023
2024         if(!prs_align(ps))
2025                 return False;
2026
2027         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
2028                 return False;
2029         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
2030                 return False;
2031
2032         if(!prs_align(ps))
2033                 return False;
2034
2035         if(!prs_uint32("ptr_cli_name", ps, depth, &q_n->ptr_cli_name))
2036                 return False;
2037         if(!smb_io_unistr2("", &q_n->uni_cli_name, q_n->ptr_cli_name, ps, depth))
2038                 return False;
2039
2040         if(!prs_align(ps))
2041                 return False;
2042         if(!prs_uint32("ptr_user_name", ps, depth, &q_n->ptr_user_name))
2043                 return False;
2044         if(!smb_io_unistr2("", &q_n->uni_user_name, q_n->ptr_user_name, ps, depth))
2045                 return False;
2046
2047         return True;
2048 }
2049
2050 /*******************************************************************
2051  Reads or writes a structure.
2052 ********************************************************************/
2053
2054 BOOL srv_io_r_net_sess_del(const char *desc, SRV_R_NET_SESS_DEL *r_n, prs_struct *ps, int depth)
2055 {
2056         if (r_n == NULL)
2057                 return False;
2058
2059         prs_debug(ps, depth, desc, "srv_io_r_net_sess_del");
2060         depth++;
2061
2062         if(!prs_align(ps))
2063                 return False;
2064
2065         if(!prs_werror("status", ps, depth, &r_n->status))
2066                 return False;
2067
2068         return True;
2069 }
2070
2071 /*******************************************************************
2072  Inits a CONN_INFO_0 structure
2073 ********************************************************************/
2074
2075 void init_srv_conn_info0(CONN_INFO_0 *ss0, uint32 id)
2076 {
2077         DEBUG(5,("init_srv_conn_info0\n"));
2078
2079         ss0->id = id;
2080 }
2081
2082 /*******************************************************************
2083  Reads or writes a structure.
2084 ********************************************************************/
2085
2086 static BOOL srv_io_conn_info0(const char *desc, CONN_INFO_0 *ss0, prs_struct *ps, int depth)
2087 {
2088         if (ss0 == NULL)
2089                 return False;
2090
2091         prs_debug(ps, depth, desc, "srv_io_conn_info0");
2092         depth++;
2093
2094         if(!prs_align(ps))
2095                 return False;
2096
2097         if(!prs_uint32("id", ps, depth, &ss0->id))
2098                 return False;
2099
2100         return True;
2101 }
2102
2103 /*******************************************************************
2104  Reads or writes a structure.
2105 ********************************************************************/
2106
2107 static BOOL srv_io_srv_conn_info_0(const char *desc, SRV_CONN_INFO_0 *ss0, prs_struct *ps, int depth)
2108 {
2109         if (ss0 == NULL)
2110                 return False;
2111
2112         prs_debug(ps, depth, desc, "srv_io_srv_conn_info_0");
2113         depth++;
2114
2115         if(!prs_align(ps))
2116                 return False;
2117
2118         if(!prs_uint32("num_entries_read", ps, depth, &ss0->num_entries_read))
2119                 return False;
2120         if(!prs_uint32("ptr_conn_info", ps, depth, &ss0->ptr_conn_info))
2121                 return False;
2122
2123         if (ss0->ptr_conn_info != 0) {
2124                 int i;
2125                 int num_entries = ss0->num_entries_read;
2126
2127                 if (num_entries > MAX_CONN_ENTRIES) {
2128                         num_entries = MAX_CONN_ENTRIES; /* report this! */
2129                 }
2130
2131                 if(!prs_uint32("num_entries_read2", ps, depth, &ss0->num_entries_read2))
2132                         return False;
2133
2134                 for (i = 0; i < num_entries; i++) {
2135                         if(!srv_io_conn_info0("", &ss0->info_0[i], ps, depth))
2136                                 return False;
2137                 }
2138
2139                 if(!prs_align(ps))
2140                         return False;
2141         }
2142
2143         return True;
2144 }
2145
2146 /*******************************************************************
2147  Inits a CONN_INFO_1_STR structure
2148 ********************************************************************/
2149
2150 void init_srv_conn_info1_str(CONN_INFO_1_STR *ss1, const char *usr_name, const char *net_name)
2151 {
2152         DEBUG(5,("init_srv_conn_info1_str\n"));
2153
2154         init_unistr2(&ss1->uni_usr_name, usr_name, UNI_STR_TERMINATE);
2155         init_unistr2(&ss1->uni_net_name, net_name, UNI_STR_TERMINATE);
2156 }
2157
2158 /*******************************************************************
2159  Reads or writes a structure.
2160 ********************************************************************/
2161
2162 static BOOL srv_io_conn_info1_str(const char *desc, CONN_INFO_1_STR *ss1, prs_struct *ps, int depth)
2163 {
2164         if (ss1 == NULL)
2165                 return False;
2166
2167         prs_debug(ps, depth, desc, "srv_io_conn_info1_str");
2168         depth++;
2169
2170         if(!prs_align(ps))
2171                 return False;
2172
2173         if(!smb_io_unistr2("", &ss1->uni_usr_name, True, ps, depth))
2174                 return False;
2175         if(!smb_io_unistr2("", &ss1->uni_net_name, True, ps, depth))
2176                 return False;
2177
2178         return True;
2179 }
2180
2181 /*******************************************************************
2182  Inits a CONN_INFO_1 structure
2183 ********************************************************************/
2184
2185 void init_srv_conn_info1(CONN_INFO_1 *ss1,
2186                                 uint32 id, uint32 type,
2187                                 uint32 num_opens, uint32 num_users, uint32 open_time,
2188                                 const char *usr_name, const char *net_name)
2189 {
2190         DEBUG(5,("init_srv_conn_info1: %s %s\n", usr_name, net_name));
2191
2192         ss1->id        = id       ;
2193         ss1->type      = type     ;
2194         ss1->num_opens = num_opens ;
2195         ss1->num_users = num_users;
2196         ss1->open_time = open_time;
2197
2198         ss1->ptr_usr_name = (usr_name != NULL) ? 1 : 0;
2199         ss1->ptr_net_name = (net_name != NULL) ? 1 : 0;
2200 }
2201
2202 /*******************************************************************
2203  Reads or writes a structure.
2204 ********************************************************************/
2205
2206 static BOOL srv_io_conn_info1(const char *desc, CONN_INFO_1 *ss1, prs_struct *ps, int depth)
2207 {
2208         if (ss1 == NULL)
2209                 return False;
2210
2211         prs_debug(ps, depth, desc, "srv_io_conn_info1");
2212         depth++;
2213
2214         if(!prs_align(ps))
2215                 return False;
2216
2217         if(!prs_uint32("id          ", ps, depth, &ss1->id))
2218                 return False;
2219         if(!prs_uint32("type        ", ps, depth, &ss1->type))
2220                 return False;
2221         if(!prs_uint32("num_opens   ", ps, depth, &ss1->num_opens))
2222                 return False;
2223         if(!prs_uint32("num_users   ", ps, depth, &ss1->num_users))
2224                 return False;
2225         if(!prs_uint32("open_time   ", ps, depth, &ss1->open_time))
2226                 return False;
2227
2228         if(!prs_uint32("ptr_usr_name", ps, depth, &ss1->ptr_usr_name))
2229                 return False;
2230         if(!prs_uint32("ptr_net_name", ps, depth, &ss1->ptr_net_name))
2231                 return False;
2232
2233         return True;
2234 }
2235
2236 /*******************************************************************
2237  Reads or writes a structure.
2238 ********************************************************************/
2239
2240 static BOOL srv_io_srv_conn_info_1(const char *desc, SRV_CONN_INFO_1 *ss1, prs_struct *ps, int depth)
2241 {
2242         if (ss1 == NULL)
2243                 return False;
2244
2245         prs_debug(ps, depth, desc, "srv_io_srv_conn_info_1");
2246         depth++;
2247
2248         if(!prs_align(ps))
2249                 return False;
2250
2251         if(!prs_uint32("num_entries_read", ps, depth, &ss1->num_entries_read))
2252                 return False;
2253         if(!prs_uint32("ptr_conn_info", ps, depth, &ss1->ptr_conn_info))
2254                 return False;
2255
2256         if (ss1->ptr_conn_info != 0) {
2257                 int i;
2258                 int num_entries = ss1->num_entries_read;
2259
2260                 if (num_entries > MAX_CONN_ENTRIES) {
2261                         num_entries = MAX_CONN_ENTRIES; /* report this! */
2262                 }
2263
2264                 if(!prs_uint32("num_entries_read2", ps, depth, &ss1->num_entries_read2))
2265                         return False;
2266
2267                 for (i = 0; i < num_entries; i++) {
2268                         if(!srv_io_conn_info1("", &ss1->info_1[i], ps, depth))
2269                                 return False;
2270                 }
2271
2272                 for (i = 0; i < num_entries; i++) {
2273                         if(!srv_io_conn_info1_str("", &ss1->info_1_str[i], ps, depth))
2274                                 return False;
2275                 }
2276
2277                 if(!prs_align(ps))
2278                         return False;
2279         }
2280
2281         return True;
2282 }
2283
2284 /*******************************************************************
2285  Reads or writes a structure.
2286 ********************************************************************/
2287
2288 static BOOL srv_io_srv_conn_ctr(const char *desc, SRV_CONN_INFO_CTR **pp_ctr, prs_struct *ps, int depth)
2289 {
2290         SRV_CONN_INFO_CTR *ctr = *pp_ctr;
2291
2292         prs_debug(ps, depth, desc, "srv_io_srv_conn_ctr");
2293         depth++;
2294
2295         if (UNMARSHALLING(ps)) {
2296                 ctr = *pp_ctr = PRS_ALLOC_MEM(ps, SRV_CONN_INFO_CTR, 1);
2297                 if (ctr == NULL)
2298                         return False;
2299         }
2300
2301         if (ctr == NULL)
2302                 return False;
2303
2304         if(!prs_align(ps))
2305                 return False;
2306
2307         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
2308                 return False;
2309         if(!prs_uint32("ptr_conn_ctr", ps, depth, &ctr->ptr_conn_ctr))
2310                 return False;
2311
2312         if (ctr->ptr_conn_ctr != 0) {
2313                 switch (ctr->switch_value) {
2314                 case 0:
2315                         if(!srv_io_srv_conn_info_0("", &ctr->conn.info0, ps, depth))
2316                                 return False;
2317                         break;
2318                 case 1:
2319                         if(!srv_io_srv_conn_info_1("", &ctr->conn.info1, ps, depth))
2320                                 return False;
2321                         break;
2322                 default:
2323                         DEBUG(5,("%s no connection info at switch_value %d\n",
2324                                  tab_depth(depth), ctr->switch_value));
2325                         break;
2326                 }
2327         }
2328
2329         return True;
2330 }
2331
2332 /*******************************************************************
2333   Reads or writes a structure.
2334 ********************************************************************/
2335
2336 void init_srv_q_net_conn_enum(SRV_Q_NET_CONN_ENUM *q_n,
2337                                 const char *srv_name, const char *qual_name,
2338                                 uint32 conn_level, SRV_CONN_INFO_CTR *ctr,
2339                                 uint32 preferred_len,
2340                                 ENUM_HND *hnd)
2341 {
2342         DEBUG(5,("init_q_net_conn_enum\n"));
2343
2344         q_n->ctr = ctr;
2345
2346         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name );
2347         init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
2348
2349         q_n->conn_level    = conn_level;
2350         q_n->preferred_len = preferred_len;
2351
2352         memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
2353 }
2354
2355 /*******************************************************************
2356  Reads or writes a structure.
2357 ********************************************************************/
2358
2359 BOOL srv_io_q_net_conn_enum(const char *desc, SRV_Q_NET_CONN_ENUM *q_n, prs_struct *ps, int depth)
2360 {
2361         if (q_n == NULL)
2362                 return False;
2363
2364         prs_debug(ps, depth, desc, "srv_io_q_net_conn_enum");
2365         depth++;
2366
2367         if(!prs_align(ps))
2368                 return False;
2369
2370         if(!prs_uint32("ptr_srv_name ", ps, depth, &q_n->ptr_srv_name))
2371                 return False;
2372         if(!smb_io_unistr2("", &q_n->uni_srv_name, q_n->ptr_srv_name, ps, depth))
2373                 return False;
2374
2375         if(!prs_align(ps))
2376                 return False;
2377
2378         if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
2379                 return False;
2380         if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
2381                 return False;
2382
2383         if(!prs_align(ps))
2384                 return False;
2385
2386         if(!prs_uint32("conn_level", ps, depth, &q_n->conn_level))
2387                 return False;
2388
2389         if (q_n->conn_level != (uint32)-1) {
2390                 if(!srv_io_srv_conn_ctr("conn_ctr", &q_n->ctr, ps, depth))
2391                         return False;
2392         }
2393
2394         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
2395                 return False;
2396
2397         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
2398                 return False;
2399
2400         return True;
2401 }
2402
2403 /*******************************************************************
2404  Reads or writes a structure.
2405 ********************************************************************/
2406
2407 BOOL srv_io_r_net_conn_enum(const char *desc,  SRV_R_NET_CONN_ENUM *r_n, prs_struct *ps, int depth)
2408 {
2409         if (r_n == NULL)
2410                 return False;
2411
2412         prs_debug(ps, depth, desc, "srv_io_r_net_conn_enum");
2413         depth++;
2414
2415         if(!prs_align(ps))
2416                 return False;
2417
2418         if(!prs_uint32("conn_level", ps, depth, &r_n->conn_level))
2419                 return False;
2420
2421         if (r_n->conn_level != (uint32)-1) {
2422                 if(!srv_io_srv_conn_ctr("conn_ctr", &r_n->ctr, ps, depth))
2423                         return False;
2424         }
2425
2426         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
2427                 return False;
2428         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
2429                 return False;
2430         if(!prs_werror("status", ps, depth, &r_n->status))
2431                 return False;
2432
2433         return True;
2434 }
2435
2436 /*******************************************************************
2437  Inits a FILE_INFO_3_STR structure
2438 ********************************************************************/
2439
2440 void init_srv_file_info3_str(FILE_INFO_3_STR *fi3, const char *user_name, const char *path_name)
2441 {
2442         DEBUG(5,("init_srv_file_info3_str\n"));
2443
2444         init_unistr2(&fi3->uni_path_name, path_name, UNI_STR_TERMINATE);
2445         init_unistr2(&fi3->uni_user_name, user_name, UNI_STR_TERMINATE);
2446 }
2447
2448 /*******************************************************************
2449  Reads or writes a structure.
2450 ********************************************************************/
2451
2452 static BOOL srv_io_file_info3_str(const char *desc, FILE_INFO_3_STR *sh1, prs_struct *ps, int depth)
2453 {
2454         if (sh1 == NULL)
2455                 return False;
2456
2457         prs_debug(ps, depth, desc, "srv_io_file_info3_str");
2458         depth++;
2459
2460         if(!prs_align(ps))
2461                 return False;
2462
2463         if(!smb_io_unistr2("", &sh1->uni_path_name, True, ps, depth))
2464                 return False;
2465         if(!smb_io_unistr2("", &sh1->uni_user_name, True, ps, depth))
2466                 return False;
2467
2468         return True;
2469 }
2470
2471 /*******************************************************************
2472  Inits a FILE_INFO_3 structure
2473 ********************************************************************/
2474
2475 void init_srv_file_info3(FILE_INFO_3 *fl3,
2476                          uint32 id, uint32 perms, uint32 num_locks,
2477                          const char *path_name, const char *user_name)
2478 {
2479         DEBUG(5,("init_srv_file_info3: %s %s\n", path_name, user_name));
2480
2481         fl3->id        = id;
2482         fl3->perms     = perms;
2483         fl3->num_locks = num_locks;
2484
2485         fl3->ptr_path_name = (path_name != NULL) ? 1 : 0;
2486         fl3->ptr_user_name = (user_name != NULL) ? 1 : 0;
2487 }
2488
2489 /*******************************************************************
2490  Reads or writes a structure.
2491 ********************************************************************/
2492
2493 static BOOL srv_io_file_info3(const char *desc, FILE_INFO_3 *fl3, prs_struct *ps, int depth)
2494 {
2495         if (fl3 == NULL)
2496                 return False;
2497
2498         prs_debug(ps, depth, desc, "srv_io_file_info3");
2499         depth++;
2500
2501         if(!prs_align(ps))
2502                 return False;
2503
2504         if(!prs_uint32("id           ", ps, depth, &fl3->id))
2505                 return False;
2506         if(!prs_uint32("perms        ", ps, depth, &fl3->perms))
2507                 return False;
2508         if(!prs_uint32("num_locks    ", ps, depth, &fl3->num_locks))
2509                 return False;
2510         if(!prs_uint32("ptr_path_name", ps, depth, &fl3->ptr_path_name))
2511                 return False;
2512         if(!prs_uint32("ptr_user_name", ps, depth, &fl3->ptr_user_name))
2513                 return False;
2514
2515         return True;
2516 }
2517
2518 /*******************************************************************
2519  Reads or writes a structure.
2520 ********************************************************************/
2521
2522 static BOOL srv_io_srv_file_ctr(const char *desc, SRV_FILE_INFO_CTR *ctr, prs_struct *ps, int depth)
2523 {
2524         if (ctr == NULL)
2525                 return False;
2526
2527         prs_debug(ps, depth, desc, "srv_io_srv_file_ctr");
2528         depth++;
2529
2530         if (UNMARSHALLING(ps)) {
2531                 memset(ctr, '\0', sizeof(SRV_FILE_INFO_CTR));
2532         }
2533
2534         if(!prs_align(ps))
2535                 return False;
2536
2537         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
2538                 return False;
2539         if (ctr->switch_value != 3) {
2540                 DEBUG(5,("%s File info %d level not supported\n",
2541                          tab_depth(depth), ctr->switch_value));
2542         }
2543         if(!prs_uint32("ptr_file_info", ps, depth, &ctr->ptr_file_info))
2544                 return False;
2545         if(!prs_uint32("num_entries", ps, depth, &ctr->num_entries))
2546                 return False;
2547         if(!prs_uint32("ptr_entries", ps, depth, &ctr->ptr_entries))
2548                 return False;
2549         if (ctr->ptr_entries == 0)
2550                 return True;
2551         if(!prs_uint32("num_entries2", ps, depth,
2552                        &ctr->num_entries2))
2553                 return False;
2554
2555         switch (ctr->switch_value) {
2556         case 3: {
2557                 SRV_FILE_INFO_3 *info3 = ctr->file.info3;
2558                 int num_entries = ctr->num_entries;
2559                 int i;
2560
2561                 if (UNMARSHALLING(ps)) {
2562                         if (!(info3 = PRS_ALLOC_MEM(ps, SRV_FILE_INFO_3, num_entries)))
2563                                 return False;
2564                         ctr->file.info3 = info3;
2565                 }
2566
2567                 for (i = 0; i < num_entries; i++) {
2568                         if(!srv_io_file_info3("", &ctr->file.info3[i].info_3, ps, depth))
2569                                 return False;
2570                 }
2571                 for (i = 0; i < num_entries; i++) {
2572                         if(!srv_io_file_info3_str("", &ctr->file.info3[i].info_3_str, ps, depth))
2573                                 return False;
2574                 }
2575                 break;
2576         }
2577         default:
2578                 DEBUG(5,("%s no file info at switch_value %d\n",
2579                          tab_depth(depth), ctr->switch_value));
2580                 break;
2581         }
2582
2583         return True;
2584 }
2585
2586 /*******************************************************************
2587  Inits a SRV_Q_NET_FILE_ENUM structure.
2588 ********************************************************************/
2589
2590 void init_srv_q_net_file_enum(SRV_Q_NET_FILE_ENUM *q_n,
2591                               const char *srv_name, const char *qual_name,
2592                               const char *user_name,
2593                               uint32 file_level, SRV_FILE_INFO_CTR *ctr,
2594                               uint32 preferred_len,
2595                               ENUM_HND *hnd)
2596 {
2597         DEBUG(5,("init_q_net_file_enum\n"));
2598
2599         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
2600         init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
2601         init_buf_unistr2(&q_n->uni_user_name, &q_n->ptr_user_name, user_name);
2602
2603         q_n->file_level    = q_n->ctr.switch_value = file_level;
2604         q_n->preferred_len = preferred_len;
2605         q_n->ctr.ptr_file_info = 1;
2606         q_n->ctr.num_entries = 0;
2607         q_n->ctr.num_entries2 = 0;
2608
2609         memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
2610 }
2611
2612 /*******************************************************************
2613  Reads or writes a structure.
2614 ********************************************************************/
2615
2616 BOOL srv_io_q_net_file_enum(const char *desc, SRV_Q_NET_FILE_ENUM *q_n, prs_struct *ps, int depth)
2617 {
2618         if (q_n == NULL)
2619                 return False;
2620
2621         prs_debug(ps, depth, desc, "srv_io_q_net_file_enum");
2622         depth++;
2623
2624         if(!prs_align(ps))
2625                 return False;
2626
2627         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
2628                 return False;
2629         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
2630                 return False;
2631
2632         if(!prs_align(ps))
2633                 return False;
2634
2635         if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
2636                 return False;
2637         if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
2638                 return False;
2639
2640         if(!prs_align(ps))
2641                 return False;
2642
2643         if(!prs_uint32("ptr_user_name", ps, depth, &q_n->ptr_user_name))
2644                 return False;
2645         if(!smb_io_unistr2("", &q_n->uni_user_name, q_n->ptr_user_name, ps, depth))
2646                 return False;
2647
2648         if(!prs_align(ps))
2649                 return False;
2650         if(!prs_uint32("file_level", ps, depth, &q_n->file_level))
2651                 return False;
2652
2653         if (q_n->file_level != (uint32)-1) {
2654                 if(!srv_io_srv_file_ctr("file_ctr", &q_n->ctr, ps, depth))
2655                         return False;
2656         }
2657
2658         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
2659                 return False;
2660
2661         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
2662                 return False;
2663
2664         return True;
2665 }
2666
2667 /*******************************************************************
2668  Reads or writes a structure.
2669 ********************************************************************/
2670
2671 BOOL srv_io_r_net_file_enum(const char *desc, SRV_R_NET_FILE_ENUM *r_n, prs_struct *ps, int depth)
2672 {
2673         if (r_n == NULL)
2674                 return False;
2675
2676         prs_debug(ps, depth, desc, "srv_io_r_net_file_enum");
2677         depth++;
2678
2679         if(!prs_align(ps))
2680                 return False;
2681
2682         if(!prs_uint32("file_level", ps, depth, &r_n->file_level))
2683                 return False;
2684
2685         if (r_n->file_level != 0) {
2686                 if(!srv_io_srv_file_ctr("file_ctr", &r_n->ctr, ps, depth))
2687                         return False;
2688         }
2689
2690         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
2691                 return False;
2692         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
2693                 return False;
2694         if(!prs_werror("status", ps, depth, &r_n->status))
2695                 return False;
2696
2697         return True;
2698 }
2699
2700 /*******************************************************************
2701  Initialize a net file close request
2702 ********************************************************************/
2703 void init_srv_q_net_file_close(SRV_Q_NET_FILE_CLOSE *q_n, const char *server,
2704                                uint32 file_id)
2705 {
2706         q_n->ptr_srv_name = 1;
2707         init_unistr2(&q_n->uni_srv_name, server, UNI_STR_TERMINATE);
2708         q_n->file_id = file_id;
2709 }
2710
2711 /*******************************************************************
2712  Reads or writes a structure.
2713 ********************************************************************/
2714 BOOL srv_io_q_net_file_close(const char *desc, SRV_Q_NET_FILE_CLOSE *q_n,
2715                              prs_struct *ps, int depth)
2716 {
2717         if (q_n == NULL)
2718                 return False;
2719
2720         prs_debug(ps, depth, desc, "srv_io_q_net_file_close");
2721         depth++;
2722
2723         if(!prs_align(ps))
2724                 return False;
2725
2726         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
2727                 return False;
2728         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
2729                 return False;
2730
2731         if(!prs_align(ps))
2732                 return False;
2733
2734         if(!prs_uint32("file_id", ps, depth, &q_n->file_id))
2735                 return False;
2736
2737         return True;
2738 }
2739
2740 /*******************************************************************
2741  Reads or writes a structure.
2742 ********************************************************************/
2743
2744 BOOL srv_io_r_net_file_close(const char *desc, SRV_R_NET_FILE_CLOSE *q_n,
2745                              prs_struct *ps, int depth)
2746 {
2747         if (q_n == NULL)
2748                 return False;
2749
2750         prs_debug(ps, depth, desc, "srv_io_r_net_file_close");
2751         depth++;
2752
2753         if(!prs_align(ps))
2754                 return False;
2755
2756         if(!prs_werror("status", ps, depth, &q_n->status))
2757                 return False;
2758
2759         return True;
2760 }
2761
2762 /*******************************************************************
2763  Inits a SRV_INFO_100 structure.
2764  ********************************************************************/
2765
2766 void init_srv_info_100(SRV_INFO_100 *sv100, uint32 platform_id, const char *name)
2767 {
2768         DEBUG(5,("init_srv_info_100\n"));
2769
2770         sv100->platform_id  = platform_id;
2771         init_buf_unistr2(&sv100->uni_name, &sv100->ptr_name, name);
2772 }
2773
2774 /*******************************************************************
2775  Reads or writes a SRV_INFO_101 structure.
2776  ********************************************************************/
2777
2778 static BOOL srv_io_info_100(const char *desc, SRV_INFO_100 *sv100, prs_struct *ps, int depth)
2779 {
2780         if (sv100 == NULL)
2781                 return False;
2782
2783         prs_debug(ps, depth, desc, "srv_io_info_100");
2784         depth++;
2785
2786         if(!prs_align(ps))
2787                 return False;
2788
2789         if(!prs_uint32("platform_id ", ps, depth, &sv100->platform_id))
2790                 return False;
2791         if(!prs_uint32("ptr_name    ", ps, depth, &sv100->ptr_name))
2792                 return False;
2793
2794         if(!smb_io_unistr2("uni_name    ", &sv100->uni_name, True, ps, depth))
2795                 return False;
2796
2797         return True;
2798 }
2799
2800
2801 /*******************************************************************
2802  Inits a SRV_INFO_101 structure.
2803  ********************************************************************/
2804
2805 void init_srv_info_101(SRV_INFO_101 *sv101, uint32 platform_id, const char *name,
2806                                 uint32 ver_major, uint32 ver_minor,
2807                                 uint32 srv_type, const char *comment)
2808 {
2809         DEBUG(5,("init_srv_info_101\n"));
2810
2811         sv101->platform_id  = platform_id;
2812         init_buf_unistr2(&sv101->uni_name, &sv101->ptr_name, name);
2813         sv101->ver_major    = ver_major;
2814         sv101->ver_minor    = ver_minor;
2815         sv101->srv_type     = srv_type;
2816         init_buf_unistr2(&sv101->uni_comment, &sv101->ptr_comment, comment);
2817 }
2818
2819 /*******************************************************************
2820  Reads or writes a SRV_INFO_101 structure.
2821  ********************************************************************/
2822
2823 static BOOL srv_io_info_101(const char *desc, SRV_INFO_101 *sv101, prs_struct *ps, int depth)
2824 {
2825         if (sv101 == NULL)
2826                 return False;
2827
2828         prs_debug(ps, depth, desc, "srv_io_info_101");
2829         depth++;
2830
2831         if(!prs_align(ps))
2832                 return False;
2833
2834         if(!prs_uint32("platform_id ", ps, depth, &sv101->platform_id))
2835                 return False;
2836         if(!prs_uint32("ptr_name    ", ps, depth, &sv101->ptr_name))
2837                 return False;
2838         if(!prs_uint32("ver_major   ", ps, depth, &sv101->ver_major))
2839                 return False;
2840         if(!prs_uint32("ver_minor   ", ps, depth, &sv101->ver_minor))
2841                 return False;
2842         if(!prs_uint32("srv_type    ", ps, depth, &sv101->srv_type))
2843                 return False;
2844         if(!prs_uint32("ptr_comment ", ps, depth, &sv101->ptr_comment))
2845                 return False;
2846
2847         if(!prs_align(ps))
2848                 return False;
2849
2850         if(!smb_io_unistr2("uni_name    ", &sv101->uni_name, True, ps, depth))
2851                 return False;
2852         if(!smb_io_unistr2("uni_comment ", &sv101->uni_comment, True, ps, depth))
2853                 return False;
2854
2855         return True;
2856 }
2857
2858 /*******************************************************************
2859  Inits a SRV_INFO_102 structure.
2860  ********************************************************************/
2861
2862 void init_srv_info_102(SRV_INFO_102 *sv102, uint32 platform_id, const char *name,
2863                                 const char *comment, uint32 ver_major, uint32 ver_minor,
2864                                 uint32 srv_type, uint32 users, uint32 disc, uint32 hidden,
2865                                 uint32 announce, uint32 ann_delta, uint32 licenses,
2866                                 const char *usr_path)
2867 {
2868         DEBUG(5,("init_srv_info_102\n"));
2869
2870         sv102->platform_id  = platform_id;
2871         init_buf_unistr2(&sv102->uni_name, &sv102->ptr_name, name);
2872         sv102->ver_major    = ver_major;
2873         sv102->ver_minor    = ver_minor;
2874         sv102->srv_type     = srv_type;
2875         init_buf_unistr2(&sv102->uni_comment, &sv102->ptr_comment, comment);
2876
2877         /* same as 101 up to here */
2878
2879         sv102->users        = users;
2880         sv102->disc         = disc;
2881         sv102->hidden       = hidden;
2882         sv102->announce     = announce;
2883         sv102->ann_delta    = ann_delta;
2884         sv102->licenses     = licenses;
2885         init_buf_unistr2(&sv102->uni_usr_path, &sv102->ptr_usr_path, usr_path);
2886 }
2887
2888
2889 /*******************************************************************
2890  Reads or writes a SRV_INFO_102 structure.
2891  ********************************************************************/
2892
2893 static BOOL srv_io_info_102(const char *desc, SRV_INFO_102 *sv102, prs_struct *ps, int depth)
2894 {
2895         if (sv102 == NULL)
2896                 return False;
2897
2898         prs_debug(ps, depth, desc, "srv_io_info102");
2899         depth++;
2900
2901         if(!prs_align(ps))
2902                 return False;
2903
2904         if(!prs_uint32("platform_id ", ps, depth, &sv102->platform_id))
2905                 return False;
2906         if(!prs_uint32("ptr_name    ", ps, depth, &sv102->ptr_name))
2907                 return False;
2908         if(!prs_uint32("ver_major   ", ps, depth, &sv102->ver_major))
2909                 return False;
2910         if(!prs_uint32("ver_minor   ", ps, depth, &sv102->ver_minor))
2911                 return False;
2912         if(!prs_uint32("srv_type    ", ps, depth, &sv102->srv_type))
2913                 return False;
2914         if(!prs_uint32("ptr_comment ", ps, depth, &sv102->ptr_comment))
2915                 return False;
2916
2917         /* same as 101 up to here */
2918
2919         if(!prs_uint32("users       ", ps, depth, &sv102->users))
2920                 return False;
2921         if(!prs_uint32("disc        ", ps, depth, &sv102->disc))
2922                 return False;
2923         if(!prs_uint32("hidden      ", ps, depth, &sv102->hidden))
2924                 return False;
2925         if(!prs_uint32("announce    ", ps, depth, &sv102->announce))
2926                 return False;
2927         if(!prs_uint32("ann_delta   ", ps, depth, &sv102->ann_delta))
2928                 return False;
2929         if(!prs_uint32("licenses    ", ps, depth, &sv102->licenses))
2930                 return False;
2931         if(!prs_uint32("ptr_usr_path", ps, depth, &sv102->ptr_usr_path))
2932                 return False;
2933
2934         if(!smb_io_unistr2("uni_name    ", &sv102->uni_name, True, ps, depth))
2935                 return False;
2936         if(!prs_align(ps))
2937                 return False;
2938         if(!smb_io_unistr2("uni_comment ", &sv102->uni_comment, True, ps, depth))
2939                 return False;
2940         if(!prs_align(ps))
2941                 return False;
2942         if(!smb_io_unistr2("uni_usr_path", &sv102->uni_usr_path, True, ps, depth))
2943                 return False;
2944
2945         return True;
2946 }
2947
2948 /*******************************************************************
2949  Reads or writes a SRV_INFO_102 structure.
2950  ********************************************************************/
2951
2952 static BOOL srv_io_info_ctr(const char *desc, SRV_INFO_CTR *ctr, prs_struct *ps, int depth)
2953 {
2954         if (ctr == NULL)
2955                 return False;
2956
2957         prs_debug(ps, depth, desc, "srv_io_info_ctr");
2958         depth++;
2959
2960         if(!prs_align(ps))
2961                 return False;
2962
2963         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
2964                 return False;
2965         if(!prs_uint32("ptr_srv_ctr ", ps, depth, &ctr->ptr_srv_ctr))
2966                 return False;
2967
2968         if (ctr->ptr_srv_ctr != 0 && ctr->switch_value != 0 && ctr != NULL) {
2969                 switch (ctr->switch_value) {
2970                 case 100:
2971                         if(!srv_io_info_100("sv100", &ctr->srv.sv100, ps, depth))
2972                                 return False;
2973                         break;
2974                 case 101:
2975                         if(!srv_io_info_101("sv101", &ctr->srv.sv101, ps, depth))
2976                                 return False;
2977                         break;
2978                 case 102:
2979                         if(!srv_io_info_102("sv102", &ctr->srv.sv102, ps, depth))
2980                                 return False;
2981                         break;
2982                 default:
2983                         DEBUG(5,("%s no server info at switch_value %d\n",
2984                                          tab_depth(depth), ctr->switch_value));
2985                         break;
2986                 }
2987                 if(!prs_align(ps))
2988                         return False;
2989         }
2990
2991         return True;
2992 }
2993
2994 /*******************************************************************
2995  Inits a SRV_Q_NET_SRV_GET_INFO structure.
2996  ********************************************************************/
2997
2998 void init_srv_q_net_srv_get_info(SRV_Q_NET_SRV_GET_INFO *srv,
2999                                 const char *server_name, uint32 switch_value)
3000 {
3001         DEBUG(5,("init_srv_q_net_srv_get_info\n"));
3002
3003         init_buf_unistr2(&srv->uni_srv_name, &srv->ptr_srv_name, server_name);
3004
3005         srv->switch_value = switch_value;
3006 }
3007
3008 /*******************************************************************
3009  Reads or writes a structure.
3010 ********************************************************************/
3011
3012 BOOL srv_io_q_net_srv_get_info(const char *desc, SRV_Q_NET_SRV_GET_INFO *q_n, prs_struct *ps, int depth)
3013 {
3014         if (q_n == NULL)
3015                 return False;
3016
3017         prs_debug(ps, depth, desc, "srv_io_q_net_srv_get_info");
3018         depth++;
3019
3020         if(!prs_align(ps))
3021                 return False;
3022
3023         if(!prs_uint32("ptr_srv_name  ", ps, depth, &q_n->ptr_srv_name))
3024                 return False;
3025         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3026                 return False;
3027
3028         if(!prs_align(ps))
3029                 return False;
3030
3031         if(!prs_uint32("switch_value  ", ps, depth, &q_n->switch_value))
3032                 return False;
3033
3034         return True;
3035 }
3036
3037 /*******************************************************************
3038  Inits a SRV_R_NET_SRV_GET_INFO structure.
3039  ********************************************************************/
3040
3041 void init_srv_r_net_srv_get_info(SRV_R_NET_SRV_GET_INFO *srv,
3042                                 uint32 switch_value, SRV_INFO_CTR *ctr, WERROR status)
3043 {
3044         DEBUG(5,("init_srv_r_net_srv_get_info\n"));
3045
3046         srv->ctr = ctr;
3047
3048         if (W_ERROR_IS_OK(status)) {
3049                 srv->ctr->switch_value = switch_value;
3050                 srv->ctr->ptr_srv_ctr  = 1;
3051         } else {
3052                 srv->ctr->switch_value = 0;
3053                 srv->ctr->ptr_srv_ctr  = 0;
3054         }
3055
3056         srv->status = status;
3057 }
3058
3059 /*******************************************************************
3060  Inits a SRV_R_NET_SRV_SET_INFO structure.
3061  ********************************************************************/
3062
3063 void init_srv_r_net_srv_set_info(SRV_R_NET_SRV_SET_INFO *srv,
3064                                  uint32 switch_value, WERROR status)
3065 {
3066         DEBUG(5,("init_srv_r_net_srv_set_info\n"));
3067
3068         srv->switch_value = switch_value;
3069         srv->status = status;
3070 }
3071
3072 /*******************************************************************
3073  Reads or writes a structure.
3074 ********************************************************************/
3075
3076 BOOL srv_io_q_net_srv_set_info(const char *desc, SRV_Q_NET_SRV_SET_INFO *q_n,
3077                                prs_struct *ps, int depth)
3078 {
3079         prs_debug(ps, depth, desc, "srv_io_q_net_srv_set_info");
3080         depth++;
3081
3082         if(!prs_align(ps))
3083                 return False;
3084
3085         if(!prs_uint32("ptr_srv_name  ", ps, depth, &q_n->ptr_srv_name))
3086                 return False;
3087         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3088                 return False;
3089
3090         if(!prs_align(ps))
3091                 return False;
3092
3093         if(!prs_uint32("switch_value  ", ps, depth, &q_n->switch_value))
3094                 return False;
3095
3096         if (UNMARSHALLING(ps)) {
3097                 q_n->ctr = PRS_ALLOC_MEM(ps, SRV_INFO_CTR, 1);
3098
3099                 if (!q_n->ctr)
3100                         return False;
3101         }
3102
3103         if(!srv_io_info_ctr("ctr", q_n->ctr, ps, depth))
3104                 return False;
3105
3106         return True;
3107 }
3108
3109 /*******************************************************************
3110  Reads or writes a structure.
3111  ********************************************************************/
3112
3113 BOOL srv_io_r_net_srv_get_info(const char *desc, SRV_R_NET_SRV_GET_INFO *r_n, prs_struct *ps, int depth)
3114 {
3115         if (r_n == NULL)
3116                 return False;
3117
3118         prs_debug(ps, depth, desc, "srv_io_r_net_srv_get_info");
3119         depth++;
3120
3121         if(!prs_align(ps))
3122                 return False;
3123
3124         if(!srv_io_info_ctr("ctr", r_n->ctr, ps, depth))
3125                 return False;
3126
3127         if(!prs_werror("status", ps, depth, &r_n->status))
3128                 return False;
3129
3130         return True;
3131 }
3132
3133 /*******************************************************************
3134  Reads or writes a structure.
3135  ********************************************************************/
3136
3137 BOOL srv_io_r_net_srv_set_info(const char *desc, SRV_R_NET_SRV_SET_INFO *r_n,
3138                                prs_struct *ps, int depth)
3139 {
3140         prs_debug(ps, depth, desc, "srv_io_r_net_srv_set_info");
3141         depth++;
3142
3143         if(!prs_align(ps))
3144                 return False;
3145
3146         if(!prs_uint32("switch value ", ps, depth, &r_n->switch_value))
3147                 return False;
3148
3149         if(!prs_werror("status", ps, depth, &r_n->status))
3150                 return False;
3151
3152         return True;
3153 }
3154
3155 /*******************************************************************
3156  Reads or writes a structure.
3157  ********************************************************************/
3158
3159 BOOL srv_io_q_net_remote_tod(const char *desc, SRV_Q_NET_REMOTE_TOD *q_n, prs_struct *ps, int depth)
3160 {
3161         if (q_n == NULL)
3162                 return False;
3163
3164         prs_debug(ps, depth, desc, "srv_io_q_net_remote_tod");
3165         depth++;
3166
3167         if(!prs_align(ps))
3168                 return False;
3169
3170         if(!prs_uint32("ptr_srv_name  ", ps, depth, &q_n->ptr_srv_name))
3171                 return False;
3172         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3173                 return False;
3174
3175         return True;
3176 }
3177
3178 /*******************************************************************
3179  Reads or writes a TIME_OF_DAY_INFO structure.
3180  ********************************************************************/
3181
3182 static BOOL srv_io_time_of_day_info(const char *desc, TIME_OF_DAY_INFO *tod, prs_struct *ps, int depth)
3183 {
3184         if (tod == NULL)
3185                 return False;
3186
3187         prs_debug(ps, depth, desc, "srv_io_time_of_day_info");
3188         depth++;
3189
3190         if(!prs_align(ps))
3191                 return False;
3192
3193         if(!prs_uint32("elapsedt   ", ps, depth, &tod->elapsedt))
3194                 return False;
3195         if(!prs_uint32("msecs      ", ps, depth, &tod->msecs))
3196                 return False;
3197         if(!prs_uint32("hours      ", ps, depth, &tod->hours))
3198                 return False;
3199         if(!prs_uint32("mins       ", ps, depth, &tod->mins))
3200                 return False;
3201         if(!prs_uint32("secs       ", ps, depth, &tod->secs))
3202                 return False;
3203         if(!prs_uint32("hunds      ", ps, depth, &tod->hunds))
3204                 return False;
3205         if(!prs_uint32("timezone   ", ps, depth, &tod->zone))
3206                 return False;
3207         if(!prs_uint32("tintervals ", ps, depth, &tod->tintervals))
3208                 return False;
3209         if(!prs_uint32("day        ", ps, depth, &tod->day))
3210                 return False;
3211         if(!prs_uint32("month      ", ps, depth, &tod->month))
3212                 return False;
3213         if(!prs_uint32("year       ", ps, depth, &tod->year))
3214                 return False;
3215         if(!prs_uint32("weekday    ", ps, depth, &tod->weekday))
3216                 return False;
3217
3218         return True;
3219 }
3220
3221 /*******************************************************************
3222  Inits a TIME_OF_DAY_INFO structure.
3223  ********************************************************************/
3224
3225 void init_time_of_day_info(TIME_OF_DAY_INFO *tod, uint32 elapsedt, uint32 msecs,
3226                            uint32 hours, uint32 mins, uint32 secs, uint32 hunds,
3227                            uint32 zone, uint32 tintervals, uint32 day,
3228                            uint32 month, uint32 year, uint32 weekday)
3229 {
3230         DEBUG(5,("init_time_of_day_info\n"));
3231
3232         tod->elapsedt   = elapsedt;
3233         tod->msecs      = msecs;
3234         tod->hours      = hours;
3235         tod->mins       = mins;
3236         tod->secs       = secs;
3237         tod->hunds      = hunds;
3238         tod->zone       = zone;
3239         tod->tintervals = tintervals;
3240         tod->day        = day;
3241         tod->month      = month;
3242         tod->year       = year;
3243         tod->weekday    = weekday;
3244 }
3245
3246
3247 /*******************************************************************
3248  Reads or writes a structure.
3249  ********************************************************************/
3250
3251 BOOL srv_io_r_net_remote_tod(const char *desc, SRV_R_NET_REMOTE_TOD *r_n, prs_struct *ps, int depth)
3252 {
3253         if (r_n == NULL)
3254                 return False;
3255
3256         prs_debug(ps, depth, desc, "srv_io_r_net_remote_tod");
3257         depth++;
3258
3259         if(!prs_align(ps))
3260                 return False;
3261
3262         if(!prs_uint32("ptr_srv_tod ", ps, depth, &r_n->ptr_srv_tod))
3263                 return False;
3264
3265         if(!srv_io_time_of_day_info("tod", r_n->tod, ps, depth))
3266                 return False;
3267
3268         if(!prs_werror("status", ps, depth, &r_n->status))
3269                 return False;
3270
3271         return True;
3272 }
3273
3274 /*******************************************************************
3275  initialises a structure.
3276  ********************************************************************/
3277
3278 BOOL init_srv_q_net_disk_enum(SRV_Q_NET_DISK_ENUM *q_n,
3279                               const char *srv_name,
3280                               uint32 preferred_len,
3281                               ENUM_HND *enum_hnd
3282         )
3283 {
3284
3285
3286         DEBUG(5,("init_srv_q_net_srv_disk_enum\n"));
3287
3288         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
3289
3290         q_n->disk_enum_ctr.level = 0;
3291         q_n->disk_enum_ctr.disk_info_ptr   = 0;
3292
3293         q_n->preferred_len = preferred_len;
3294         memcpy(&q_n->enum_hnd, enum_hnd, sizeof(*enum_hnd));
3295
3296         return True;
3297 }
3298
3299 /*******************************************************************
3300  Reads or writes a structure.
3301  ********************************************************************/
3302
3303 BOOL srv_io_q_net_disk_enum(const char *desc, SRV_Q_NET_DISK_ENUM *q_n, prs_struct *ps, int depth)
3304 {
3305         if (q_n == NULL)
3306                 return False;
3307
3308         prs_debug(ps, depth, desc, "srv_io_q_net_disk_enum");
3309         depth++;
3310
3311         if(!prs_align(ps))
3312                 return False;
3313
3314         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
3315                 return False;
3316
3317         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3318                 return False;
3319
3320         if(!prs_align(ps))
3321                 return False;
3322
3323         if(!prs_uint32("level", ps, depth, &q_n->disk_enum_ctr.level))
3324                 return False;
3325
3326         if(!prs_uint32("entries_read", ps, depth, &q_n->disk_enum_ctr.entries_read))
3327                 return False;
3328
3329         if(!prs_uint32("buffer", ps, depth, &q_n->disk_enum_ctr.disk_info_ptr))
3330                 return False;
3331
3332         if(!prs_align(ps))
3333                 return False;
3334
3335         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
3336                 return False;
3337         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
3338                 return False;
3339
3340         return True;
3341 }
3342
3343 /*******************************************************************
3344  Reads or writes a structure.
3345  ********************************************************************/
3346
3347 BOOL srv_io_r_net_disk_enum(const char *desc, SRV_R_NET_DISK_ENUM *r_n, prs_struct *ps, int depth)
3348 {
3349
3350         unsigned int i;
3351         uint32 entries_read, entries_read2, entries_read3;
3352
3353         if (r_n == NULL)
3354                 return False;
3355
3356         prs_debug(ps, depth, desc, "srv_io_r_net_disk_enum");
3357         depth++;
3358
3359         entries_read = entries_read2 = entries_read3 = r_n->disk_enum_ctr.entries_read;
3360
3361         if(!prs_align(ps))
3362                 return False;
3363
3364         if(!prs_uint32("entries_read", ps, depth, &entries_read))
3365                 return False;
3366         if(!prs_uint32("ptr_disk_info", ps, depth, &r_n->disk_enum_ctr.disk_info_ptr))
3367                 return False;
3368
3369         /*this may be max, unknown, actual?*/
3370
3371         if(!prs_uint32("max_elements", ps, depth, &entries_read2))
3372                 return False;
3373         if(!prs_uint32("unknown", ps, depth, &r_n->disk_enum_ctr.unknown))
3374                 return False;
3375         if(!prs_uint32("actual_elements", ps, depth, &entries_read3))
3376                 return False;
3377
3378         r_n->disk_enum_ctr.entries_read = entries_read3;
3379
3380         if(UNMARSHALLING(ps)) {
3381
3382                 DISK_INFO *dinfo;
3383
3384                 if(!(dinfo = PRS_ALLOC_MEM(ps, DISK_INFO, entries_read3)))
3385                         return False;
3386                 r_n->disk_enum_ctr.disk_info = dinfo;
3387         }
3388
3389         for(i=0; i < r_n->disk_enum_ctr.entries_read; i++) {
3390
3391                 if(!prs_uint32("unknown", ps, depth, &r_n->disk_enum_ctr.disk_info[i].unknown))
3392                         return False;
3393
3394                 if(!smb_io_unistr3("disk_name", &r_n->disk_enum_ctr.disk_info[i].disk_name, ps, depth))
3395                         return False;
3396
3397                 if(!prs_align(ps))
3398                         return False;
3399         }
3400
3401         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
3402                 return False;
3403
3404         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
3405                 return False;
3406
3407         if(!prs_werror("status", ps, depth, &r_n->status))
3408                 return False;
3409
3410         return True;
3411 }
3412
3413 /*******************************************************************
3414  initialises a structure.
3415  ********************************************************************/
3416
3417 BOOL init_srv_q_net_name_validate(SRV_Q_NET_NAME_VALIDATE *q_n, const char *srv_name, const char *share_name, int type)
3418 {
3419         uint32 ptr_share_name;
3420
3421         DEBUG(5,("init_srv_q_net_name_validate\n"));
3422
3423         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
3424         init_buf_unistr2(&q_n->uni_name,     &ptr_share_name,    share_name);
3425
3426         q_n->type  = type;
3427         q_n->flags = 0;
3428
3429         return True;
3430 }
3431
3432 /*******************************************************************
3433  Reads or writes a structure.
3434  ********************************************************************/
3435
3436 BOOL srv_io_q_net_name_validate(const char *desc, SRV_Q_NET_NAME_VALIDATE *q_n, prs_struct *ps, int depth)
3437 {
3438         if (q_n == NULL)
3439                 return False;
3440
3441         prs_debug(ps, depth, desc, "srv_io_q_net_name_validate");
3442         depth++;
3443
3444         if(!prs_align(ps))
3445                 return False;
3446
3447         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
3448                 return False;
3449
3450         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3451                 return False;
3452
3453         if(!prs_align(ps))
3454                 return False;
3455
3456         if(!smb_io_unistr2("", &q_n->uni_name, True, ps, depth))
3457                 return False;
3458
3459         if(!prs_align(ps))
3460                 return False;
3461
3462         if(!prs_uint32("type", ps, depth, &q_n->type))
3463                 return False;
3464
3465         if(!prs_uint32("flags", ps, depth, &q_n->flags))
3466                 return False;
3467
3468         return True;
3469 }
3470
3471 /*******************************************************************
3472  Reads or writes a structure.
3473  ********************************************************************/
3474
3475 BOOL srv_io_r_net_name_validate(const char *desc, SRV_R_NET_NAME_VALIDATE *r_n, prs_struct *ps, int depth)
3476 {
3477         if (r_n == NULL)
3478                 return False;
3479
3480         prs_debug(ps, depth, desc, "srv_io_r_net_name_validate");
3481         depth++;
3482
3483         if(!prs_align(ps))
3484                 return False;
3485
3486         if(!prs_werror("status", ps, depth, &r_n->status))
3487                 return False;
3488
3489         return True;
3490 }
3491
3492 /*******************************************************************
3493  Reads or writes a structure.
3494 ********************************************************************/
3495
3496 BOOL srv_io_q_net_file_query_secdesc(const char *desc, SRV_Q_NET_FILE_QUERY_SECDESC *q_n, prs_struct *ps, int depth)
3497 {
3498         if (q_n == NULL)
3499                 return False;
3500
3501         prs_debug(ps, depth, desc, "srv_io_q_net_file_query_secdesc");
3502         depth++;
3503
3504         if(!prs_align(ps))
3505                 return False;
3506
3507         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
3508                 return False;
3509
3510         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3511                 return False;
3512
3513         if(!prs_align(ps))
3514                 return False;
3515
3516         if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
3517                 return False;
3518
3519         if(!smb_io_unistr2("", &q_n->uni_qual_name, True, ps, depth))
3520                 return False;
3521
3522         if(!prs_align(ps))
3523                 return False;
3524
3525         if(!smb_io_unistr2("", &q_n->uni_file_name, True, ps, depth))
3526                 return False;
3527
3528         if(!prs_uint32("unknown1", ps, depth, &q_n->unknown1))
3529                 return False;
3530
3531         if(!prs_uint32("unknown2", ps, depth, &q_n->unknown2))
3532                 return False;
3533
3534         if(!prs_uint32("unknown3", ps, depth, &q_n->unknown3))
3535                 return False;
3536
3537         return True;
3538 }
3539
3540 /*******************************************************************
3541  Reads or writes a structure.
3542 ********************************************************************/
3543
3544 BOOL srv_io_r_net_file_query_secdesc(const char *desc, SRV_R_NET_FILE_QUERY_SECDESC *r_n, prs_struct *ps, int depth)
3545 {
3546         if (r_n == NULL)
3547                 return False;
3548
3549         prs_debug(ps, depth, desc, "srv_io_r_net_file_query_secdesc");
3550         depth++;
3551
3552         if(!prs_align(ps))
3553                 return False;
3554
3555         if(!prs_uint32("ptr_response", ps, depth, &r_n->ptr_response))
3556                 return False;
3557
3558         if(!prs_uint32("size_response", ps, depth, &r_n->size_response))
3559                 return False;
3560
3561         if(!prs_uint32("ptr_secdesc", ps, depth, &r_n->ptr_secdesc))
3562                 return False;
3563
3564         if(!prs_uint32("size_secdesc", ps, depth, &r_n->size_secdesc))
3565                 return False;
3566
3567         if(!sec_io_desc("sec_desc", &r_n->sec_desc, ps, depth))
3568                 return False;
3569
3570         if(!prs_align(ps))
3571                 return False;
3572
3573         if(!prs_werror("status", ps, depth, &r_n->status))
3574                 return False;
3575
3576         return True;
3577 }
3578
3579 /*******************************************************************
3580  Reads or writes a structure.
3581 ********************************************************************/
3582
3583 BOOL srv_io_q_net_file_set_secdesc(const char *desc, SRV_Q_NET_FILE_SET_SECDESC *q_n, prs_struct *ps, int depth)
3584 {
3585         if (q_n == NULL)
3586                 return False;
3587
3588         prs_debug(ps, depth, desc, "srv_io_q_net_file_set_secdesc");
3589         depth++;
3590
3591         if(!prs_align(ps))
3592                 return False;
3593
3594         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
3595                 return False;
3596
3597         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3598                 return False;
3599
3600         if(!prs_align(ps))
3601                 return False;
3602
3603         if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
3604                 return False;
3605
3606         if(!smb_io_unistr2("", &q_n->uni_qual_name, True, ps, depth))
3607                 return False;
3608
3609         if(!prs_align(ps))
3610                 return False;
3611
3612         if(!smb_io_unistr2("", &q_n->uni_file_name, True, ps, depth))
3613                 return False;
3614
3615         if(!prs_align(ps))
3616                 return False;
3617
3618         if(!prs_uint32("sec_info", ps, depth, &q_n->sec_info))
3619                 return False;
3620
3621         if(!prs_uint32("size_set", ps, depth, &q_n->size_set))
3622                 return False;
3623
3624         if(!prs_uint32("ptr_secdesc", ps, depth, &q_n->ptr_secdesc))
3625                 return False;
3626
3627         if(!prs_uint32("size_secdesc", ps, depth, &q_n->size_secdesc))
3628                 return False;
3629
3630         if(!sec_io_desc("sec_desc", &q_n->sec_desc, ps, depth))
3631                 return False;
3632
3633         return True;
3634 }
3635
3636 /*******************************************************************
3637  Reads or writes a structure.
3638 ********************************************************************/
3639
3640 BOOL srv_io_r_net_file_set_secdesc(const char *desc, SRV_R_NET_FILE_SET_SECDESC *r_n, prs_struct *ps, int depth)
3641 {
3642         if (r_n == NULL)
3643                 return False;
3644
3645         prs_debug(ps, depth, desc, "srv_io_r_net_file_set_secdesc");
3646         depth++;
3647
3648         if(!prs_align(ps))
3649                 return False;
3650
3651         if(!prs_werror("status", ps, depth, &r_n->status))
3652                 return False;
3653
3654         return True;
3655 }
3656
3657 /*******************************************************************
3658  Inits a structure
3659 ********************************************************************/
3660
3661 void init_srv_q_net_remote_tod(SRV_Q_NET_REMOTE_TOD *q_u, const char *server)
3662 {
3663         q_u->ptr_srv_name = 1;
3664         init_unistr2(&q_u->uni_srv_name, server, UNI_STR_TERMINATE);
3665 }