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 = (SRV_SHARE_INFO_0 *)prs_alloc_mem(ps, num_entries * sizeof(SRV_SHARE_INFO_0))))
 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 = (SRV_SHARE_INFO_1 *)prs_alloc_mem(ps, num_entries * sizeof(SRV_SHARE_INFO_1))))
 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 = (SRV_SHARE_INFO_2 *)prs_alloc_mem(ps,num_entries * sizeof(SRV_SHARE_INFO_2))))
 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 = (SRV_SHARE_INFO_501 *) prs_alloc_mem(ps, num_entries *
 864                                         sizeof (SRV_SHARE_INFO_501))))
 865                                 return False;
 866                         ctr->share.info501 = info501;
 867                 }
 868
 869                 for (i = 0; i < num_entries; i++) {
 870                         if (!srv_io_share_info501("", &info501[i].info_501, ps, depth))
 871                                 return False;
 872                 }
 873
 874                 for (i = 0; i < num_entries; i++) {
 875                         if (!srv_io_share_info501_str("", &info501[i].info_501_str, ps, depth))
 876                                 return False;
 877                 }
 878
 879                 break;
 880         }
 881
 882         case 502:
 883         {
 884                 SRV_SHARE_INFO_502 *info502 = ctr->share.info502;
 885                 int num_entries = ctr->num_entries;
 886                 int i;
 887
 888                 if (UNMARSHALLING(ps)) {
 889                         if (!(info502 = (SRV_SHARE_INFO_502 *)prs_alloc_mem(ps,num_entries * sizeof(SRV_SHARE_INFO_502))))
 890                                 return False;
 891                         ctr->share.info502 = info502;
 892                 }
 893
 894                 for (i = 0; i < num_entries; i++) {
 895                         if(!srv_io_share_info502("", &info502[i].info_502, ps, depth))
 896                                 return False;
 897         }
 898
 899                 for (i = 0; i < num_entries; i++) {
 900                         info502[i].info_502_str.ptrs = &info502[i].info_502;
 901                         if(!srv_io_share_info502_str("", &info502[i].info_502_str, ps, depth))
 902                                 return False;
 903                 }
 904
 905                 break;
 906         }
 907
 908         case 1004:
 909         {
 910                 SRV_SHARE_INFO_1004 *info1004 = ctr->share.info1004;
 911                 int num_entries = ctr->num_entries;
 912                 int i;
 913
 914                 if (UNMARSHALLING(ps)) {
 915                         if (!(info1004 = (SRV_SHARE_INFO_1004 *)prs_alloc_mem(ps,num_entries * sizeof(SRV_SHARE_INFO_1004))))
 916                                 return False;
 917                         ctr->share.info1004 = info1004;
 918                 }
 919
 920                 for (i = 0; i < num_entries; i++) {
 921                         if(!srv_io_share_info1004("", &info1004[i].info_1004, ps, depth))
 922                                 return False;
 923                 }
 924
 925                 for (i = 0; i < num_entries; i++) {
 926                         info1004[i].info_1004_str.ptrs = &info1004[i].info_1004;
 927                         if(!srv_io_share_info1004_str("", &info1004[i].info_1004_str, ps, depth))
 928                                 return False;
 929                 }
 930
 931                 break;
 932         }
 933
 934         case 1005:
 935         {
 936                 SRV_SHARE_INFO_1005 *info1005 = ctr->share.info1005;
 937                 int num_entries = ctr->num_entries;
 938                 int i;
 939
 940                 if (UNMARSHALLING(ps)) {
 941                         if (!(info1005 = (SRV_SHARE_INFO_1005 *)prs_alloc_mem(ps,num_entries * sizeof(SRV_SHARE_INFO_1005))))
 942                                 return False;
 943                         ctr->share.info1005 = info1005;
 944                 }
 945
 946                 for (i = 0; i < num_entries; i++) {
 947                         if(!srv_io_share_info1005("", &info1005[i], ps, depth))
 948                                 return False;
 949                 }
 950
 951                 break;
 952         }
 953
 954         case 1006:
 955         {
 956                 SRV_SHARE_INFO_1006 *info1006 = ctr->share.info1006;
 957                 int num_entries = ctr->num_entries;
 958                 int i;
 959
 960                 if (UNMARSHALLING(ps)) {
 961                         if (!(info1006 = (SRV_SHARE_INFO_1006 *)prs_alloc_mem(ps,num_entries * sizeof(SRV_SHARE_INFO_1006))))
 962                                 return False;
 963                         ctr->share.info1006 = info1006;
 964                 }
 965
 966                 for (i = 0; i < num_entries; i++) {
 967                         if(!srv_io_share_info1006("", &info1006[i], ps, depth))
 968                                 return False;
 969                 }
 970
 971                 break;
 972         }
 973
 974         case 1007:
 975         {
 976                 SRV_SHARE_INFO_1007 *info1007 = ctr->share.info1007;
 977                 int num_entries = ctr->num_entries;
 978                 int i;
 979
 980                 if (UNMARSHALLING(ps)) {
 981                         if (!(info1007 = (SRV_SHARE_INFO_1007 *)prs_alloc_mem(ps,num_entries * sizeof(SRV_SHARE_INFO_1007))))
 982                                 return False;
 983                         ctr->share.info1007 = info1007;
 984                 }
 985
 986                 for (i = 0; i < num_entries; i++) {
 987                         if(!srv_io_share_info1007("", &info1007[i].info_1007, ps, depth))
 988                                 return False;
 989                 }
 990
 991                 for (i = 0; i < num_entries; i++) {
 992                         info1007[i].info_1007_str.ptrs = &info1007[i].info_1007;
 993                         if(!srv_io_share_info1007_str("", &info1007[i].info_1007_str, ps, depth))
 994                                 return False;
 995                 }
 996
 997                 break;
 998         }
 999
1000         case 1501:
1001         {
1002                 SRV_SHARE_INFO_1501 *info1501 = ctr->share.info1501;
1003                 int num_entries = ctr->num_entries;
1004                 int i;
1005
1006                 if (UNMARSHALLING(ps)) {
1007                         if (!(info1501 = (SRV_SHARE_INFO_1501 *)prs_alloc_mem(ps,num_entries * sizeof(SRV_SHARE_INFO_1501))))
1008                                 return False;
1009                         ctr->share.info1501 = info1501;
1010                 }
1011
1012                 for (i = 0; i < num_entries; i++) {
1013                         if(!srv_io_share_info1501("", &info1501[i], ps, depth))
1014                                 return False;
1015                 }
1016
1017                 break;
1018         }
1019
1020         default:
1021                 DEBUG(5,("%s no share info at switch_value %d\n",
1022                          tab_depth(depth), ctr->switch_value));
1023                 break;
1024         }
1025
1026         return True;
1027 }
1028
1029 /*******************************************************************
1030  Inits a SRV_Q_NET_SHARE_ENUM structure.
1031 ********************************************************************/
1032
1033 void init_srv_q_net_share_enum(SRV_Q_NET_SHARE_ENUM *q_n,
1034                                 const char *srv_name, uint32 info_level,
1035                                 uint32 preferred_len, ENUM_HND *hnd)
1036 {
1037
1038         DEBUG(5,("init_q_net_share_enum\n"));
1039
1040         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
1041
1042         q_n->ctr.info_level = q_n->ctr.switch_value = info_level;
1043         q_n->ctr.ptr_share_info = 1;
1044         q_n->ctr.num_entries  = 0;
1045         q_n->ctr.ptr_entries  = 0;
1046         q_n->ctr.num_entries2 = 0;
1047         q_n->preferred_len = preferred_len;
1048
1049         memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
1050 }
1051
1052 /*******************************************************************
1053  Reads or writes a structure.
1054 ********************************************************************/
1055
1056 BOOL srv_io_q_net_share_enum(const char *desc, SRV_Q_NET_SHARE_ENUM *q_n, prs_struct *ps, int depth)
1057 {
1058         if (q_n == NULL)
1059                 return False;
1060
1061         prs_debug(ps, depth, desc, "srv_io_q_net_share_enum");
1062         depth++;
1063
1064         if(!prs_align(ps))
1065                 return False;
1066
1067         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1068                 return False;
1069         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1070                 return False;
1071
1072         if(!srv_io_srv_share_ctr("share_ctr", &q_n->ctr, ps, depth))
1073                 return False;
1074
1075         if(!prs_align(ps))
1076                 return False;
1077
1078         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
1079                 return False;
1080
1081         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
1082                 return False;
1083
1084         return True;
1085 }
1086
1087 /*******************************************************************
1088  Reads or writes a structure.
1089 ********************************************************************/
1090
1091 BOOL srv_io_r_net_share_enum(const char *desc, SRV_R_NET_SHARE_ENUM *r_n, prs_struct *ps, int depth)
1092 {
1093         if (r_n == NULL)
1094                 return False;
1095
1096         prs_debug(ps, depth, desc, "srv_io_r_net_share_enum");
1097         depth++;
1098
1099         if(!srv_io_srv_share_ctr("share_ctr", &r_n->ctr, ps, depth))
1100                 return False;
1101
1102         if(!prs_align(ps))
1103                 return False;
1104
1105         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
1106                 return False;
1107
1108         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
1109                 return False;
1110
1111         if(!prs_werror("status", ps, depth, &r_n->status))
1112                 return False;
1113
1114         return True;
1115 }
1116
1117 /*******************************************************************
1118  initialises a structure.
1119 ********************************************************************/
1120
1121 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)
1122 {
1123
1124         uint32 ptr_share_name;
1125
1126         DEBUG(5,("init_srv_q_net_share_get_info\n"));
1127
1128         init_buf_unistr2(&q_n->uni_srv_name,   &q_n->ptr_srv_name, srv_name);
1129         init_buf_unistr2(&q_n->uni_share_name, &ptr_share_name,    share_name);
1130
1131         q_n->info_level = info_level;
1132
1133         return True;
1134 }
1135
1136 /*******************************************************************
1137  Reads or writes a structure.
1138 ********************************************************************/
1139
1140 BOOL srv_io_q_net_share_get_info(const char *desc, SRV_Q_NET_SHARE_GET_INFO *q_n, prs_struct *ps, int depth)
1141 {
1142         if (q_n == NULL)
1143                 return False;
1144
1145         prs_debug(ps, depth, desc, "srv_io_q_net_share_get_info");
1146         depth++;
1147
1148         if(!prs_align(ps))
1149                 return False;
1150
1151         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1152                 return False;
1153         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1154                 return False;
1155
1156         if(!smb_io_unistr2("", &q_n->uni_share_name, True, ps, depth))
1157                 return False;
1158
1159         if(!prs_align(ps))
1160                 return False;
1161
1162         if(!prs_uint32("info_level", ps, depth, &q_n->info_level))
1163                 return False;
1164
1165         return True;
1166 }
1167
1168 /*******************************************************************
1169  Reads or writes a structure.
1170 ********************************************************************/
1171
1172 static BOOL srv_io_srv_share_info(const char *desc, prs_struct *ps, int depth, SRV_SHARE_INFO *r_n)
1173 {
1174         if (r_n == NULL)
1175                 return False;
1176
1177         prs_debug(ps, depth, desc, "srv_io_srv_share_info");
1178         depth++;
1179
1180         if(!prs_align(ps))
1181                 return False;
1182
1183         if(!prs_uint32("switch_value ", ps, depth, &r_n->switch_value ))
1184                 return False;
1185
1186         if(!prs_uint32("ptr_share_ctr", ps, depth, &r_n->ptr_share_ctr))
1187                 return False;
1188
1189         if (r_n->ptr_share_ctr != 0) {
1190                 switch (r_n->switch_value) {
1191                 case 0:
1192                         if(!srv_io_share_info0("", &r_n->share.info0.info_0, ps, depth))
1193                                 return False;
1194
1195                         /* allow access to pointers in the str part. */
1196                         r_n->share.info0.info_0_str.ptrs = &r_n->share.info0.info_0;
1197
1198                         if(!srv_io_share_info0_str("", &r_n->share.info0.info_0_str, ps, depth))
1199                                 return False;
1200
1201                         break;
1202                 case 1:
1203                         if(!srv_io_share_info1("", &r_n->share.info1.info_1, ps, depth))
1204                                 return False;
1205
1206                         /* allow access to pointers in the str part. */
1207                         r_n->share.info1.info_1_str.ptrs = &r_n->share.info1.info_1;
1208
1209                         if(!srv_io_share_info1_str("", &r_n->share.info1.info_1_str, ps, depth))
1210                                 return False;
1211
1212                         break;
1213                 case 2:
1214                         if(!srv_io_share_info2("", &r_n->share.info2.info_2, ps, depth))
1215                                 return False;
1216
1217                         if(!srv_io_share_info2_str("", &r_n->share.info2.info_2, &r_n->share.info2.info_2_str, ps, depth))
1218                                 return False;
1219
1220                         break;
1221                 case 501:
1222                         if (!srv_io_share_info501("", &r_n->share.info501.info_501, ps, depth))
1223                                 return False;
1224                         if (!srv_io_share_info501_str("", &r_n->share.info501.info_501_str, ps, depth))
1225                                 return False;
1226                         break;
1227
1228                 case 502:
1229                         if(!srv_io_share_info502("", &r_n->share.info502.info_502, ps, depth))
1230                                 return False;
1231
1232                         /* allow access to pointers in the str part. */
1233                         r_n->share.info502.info_502_str.ptrs = &r_n->share.info502.info_502;
1234
1235                         if(!srv_io_share_info502_str("", &r_n->share.info502.info_502_str, ps, depth))
1236                                 return False;
1237                         break;
1238                 case 1004:
1239                         if(!srv_io_share_info1004("", &r_n->share.info1004.info_1004, ps, depth))
1240                                 return False;
1241
1242                         /* allow access to pointers in the str part. */
1243                         r_n->share.info1004.info_1004_str.ptrs = &r_n->share.info1004.info_1004;
1244
1245                         if(!srv_io_share_info1004_str("", &r_n->share.info1004.info_1004_str, ps, depth))
1246                                 return False;
1247                         break;
1248                 case 1005:
1249                         if(!srv_io_share_info1005("", &r_n->share.info1005, ps, depth))
1250                                 return False;
1251                         break;
1252                 case 1006:
1253                         if(!srv_io_share_info1006("", &r_n->share.info1006, ps, depth))
1254                                 return False;
1255                         break;
1256                 case 1007:
1257                         if(!srv_io_share_info1007("", &r_n->share.info1007.info_1007, ps, depth))
1258                                 return False;
1259
1260                         /* allow access to pointers in the str part. */
1261                         r_n->share.info1007.info_1007_str.ptrs = &r_n->share.info1007.info_1007;
1262
1263                         if(!srv_io_share_info1007_str("", &r_n->share.info1007.info_1007_str, ps, depth))
1264                                 return False;
1265                         break;
1266                 case 1501:
1267                         if (!srv_io_share_info1501("", &r_n->share.info1501, ps, depth))
1268                                 return False;
1269                 default:
1270                         DEBUG(5,("%s no share info at switch_value %d\n",
1271                                  tab_depth(depth), r_n->switch_value));
1272                         break;
1273                 }
1274         }
1275
1276         return True;
1277 }
1278
1279 /*******************************************************************
1280  Reads or writes a structure.
1281 ********************************************************************/
1282
1283 BOOL srv_io_r_net_share_get_info(const char *desc, SRV_R_NET_SHARE_GET_INFO *r_n, prs_struct *ps, int depth)
1284 {
1285         if (r_n == NULL)
1286                 return False;
1287
1288         prs_debug(ps, depth, desc, "srv_io_r_net_share_get_info");
1289         depth++;
1290
1291         if(!prs_align(ps))
1292                 return False;
1293
1294         if(!srv_io_srv_share_info("info  ", ps, depth, &r_n->info))
1295                 return False;
1296
1297         if(!prs_align(ps))
1298                 return False;
1299
1300         if(!prs_werror("status", ps, depth, &r_n->status))
1301                 return False;
1302
1303         return True;
1304 }
1305
1306 /*******************************************************************
1307  intialises a structure.
1308 ********************************************************************/
1309
1310 BOOL init_srv_q_net_share_set_info(SRV_Q_NET_SHARE_SET_INFO *q_n,
1311                                    const char *srv_name,
1312                                    const char *share_name,
1313                                    uint32 info_level,
1314                                    const SRV_SHARE_INFO *info)
1315 {
1316
1317         uint32 ptr_share_name;
1318
1319         DEBUG(5,("init_srv_q_net_share_set_info\n"));
1320
1321         init_buf_unistr2(&q_n->uni_srv_name,   &q_n->ptr_srv_name, srv_name);
1322         init_buf_unistr2(&q_n->uni_share_name, &ptr_share_name,    share_name);
1323
1324         q_n->info_level = info_level;
1325
1326         q_n->info = *info;
1327
1328         q_n->ptr_parm_error = 1;
1329         q_n->parm_error     = 0;
1330
1331         return True;
1332 }
1333
1334 /*******************************************************************
1335  Reads or writes a structure.
1336 ********************************************************************/
1337
1338 BOOL srv_io_q_net_share_set_info(const char *desc, SRV_Q_NET_SHARE_SET_INFO *q_n, prs_struct *ps, int depth)
1339 {
1340         if (q_n == NULL)
1341                 return False;
1342
1343         prs_debug(ps, depth, desc, "srv_io_q_net_share_set_info");
1344         depth++;
1345
1346         if(!prs_align(ps))
1347                 return False;
1348
1349         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1350                 return False;
1351         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1352                 return False;
1353
1354         if(!smb_io_unistr2("", &q_n->uni_share_name, True, ps, depth))
1355                 return False;
1356
1357         if(!prs_align(ps))
1358                 return False;
1359
1360         if(!prs_uint32("info_level", ps, depth, &q_n->info_level))
1361                 return False;
1362
1363         if(!prs_align(ps))
1364                 return False;
1365
1366         if(!srv_io_srv_share_info("info  ", ps, depth, &q_n->info))
1367                 return False;
1368
1369         if(!prs_align(ps))
1370                 return False;
1371         if(!prs_uint32("ptr_parm_error", ps, depth, &q_n->ptr_parm_error))
1372                 return False;
1373         if(q_n->ptr_parm_error!=0) {
1374                 if(!prs_uint32("parm_error", ps, depth, &q_n->parm_error))
1375                         return False;
1376         }
1377
1378         return True;
1379 }
1380
1381 /*******************************************************************
1382  Reads or writes a structure.
1383 ********************************************************************/
1384
1385 BOOL srv_io_r_net_share_set_info(const char *desc, SRV_R_NET_SHARE_SET_INFO *r_n, prs_struct *ps, int depth)
1386 {
1387         if (r_n == NULL)
1388                 return False;
1389
1390         prs_debug(ps, depth, desc, "srv_io_r_net_share_set_info");
1391         depth++;
1392
1393         if(!prs_align(ps))
1394                 return False;
1395
1396         if(!prs_uint32("ptr_parm_error  ", ps, depth, &r_n->ptr_parm_error))
1397                 return False;
1398
1399         if(r_n->ptr_parm_error) {
1400
1401                 if(!prs_uint32("parm_error  ", ps, depth, &r_n->parm_error))
1402                         return False;
1403         }
1404
1405         if(!prs_werror("status", ps, depth, &r_n->status))
1406                 return False;
1407
1408         return True;
1409 }
1410
1411
1412 /*******************************************************************
1413  Reads or writes a structure.
1414 ********************************************************************/
1415
1416 BOOL srv_io_q_net_share_add(const char *desc, SRV_Q_NET_SHARE_ADD *q_n, prs_struct *ps, int depth)
1417 {
1418         if (q_n == NULL)
1419                 return False;
1420
1421         prs_debug(ps, depth, desc, "srv_io_q_net_share_add");
1422         depth++;
1423
1424         if(!prs_align(ps))
1425                 return False;
1426
1427         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1428                 return False;
1429         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1430                 return False;
1431
1432         if(!prs_align(ps))
1433                 return False;
1434
1435         if(!prs_uint32("info_level", ps, depth, &q_n->info_level))
1436                 return False;
1437
1438         if(!prs_align(ps))
1439                 return False;
1440
1441         if(!srv_io_srv_share_info("info  ", ps, depth, &q_n->info))
1442                 return False;
1443
1444         if(!prs_align(ps))
1445                 return False;
1446
1447         if(!prs_uint32("ptr_err_index", ps, depth, &q_n->ptr_err_index))
1448                 return False;
1449         if (q_n->ptr_err_index)
1450                 if (!prs_uint32("err_index", ps, depth, &q_n->err_index))
1451                         return False;
1452
1453         return True;
1454 }
1455
1456 void init_srv_q_net_share_add(SRV_Q_NET_SHARE_ADD *q, const char *srvname,
1457                               const char *netname, uint32 type, const char *remark,
1458                               uint32 perms, uint32 max_uses, uint32 num_uses,
1459                               const char *path, const char *passwd)
1460 {
1461         q->ptr_srv_name = 1;
1462         init_unistr2(&q->uni_srv_name, srvname, UNI_STR_TERMINATE);
1463         q->info.switch_value = q->info_level = 2;
1464
1465         q->info.ptr_share_ctr = 1;
1466         init_srv_share_info2(&q->info.share.info2.info_2, netname, type,
1467                              remark, perms, max_uses, num_uses, path, passwd);
1468         init_srv_share_info2_str(&q->info.share.info2.info_2_str, netname,
1469                                  remark, path, passwd);
1470         q->ptr_err_index = 1;
1471         q->err_index = 0;
1472 }
1473
1474
1475 /*******************************************************************
1476  Reads or writes a structure.
1477 ********************************************************************/
1478
1479 BOOL srv_io_r_net_share_add(const char *desc, SRV_R_NET_SHARE_ADD *r_n, prs_struct *ps, int depth)
1480 {
1481         if (r_n == NULL)
1482                 return False;
1483
1484         prs_debug(ps, depth, desc, "srv_io_r_net_share_add");
1485         depth++;
1486
1487         if(!prs_align(ps))
1488                 return False;
1489
1490         if(!prs_uint32("ptr_parm_error", ps, depth, &r_n->ptr_parm_error))
1491                 return False;
1492
1493         if(r_n->ptr_parm_error) {
1494
1495                 if(!prs_uint32("parm_error", ps, depth, &r_n->parm_error))
1496                         return False;
1497         }
1498
1499         if(!prs_werror("status", ps, depth, &r_n->status))
1500                 return False;
1501
1502         return True;
1503 }
1504
1505 /*******************************************************************
1506  initialises a structure.
1507 ********************************************************************/
1508
1509 void init_srv_q_net_share_del(SRV_Q_NET_SHARE_DEL *del, const char *srvname,
1510                               const char *sharename)
1511 {
1512         del->ptr_srv_name = 1;
1513         init_unistr2(&del->uni_srv_name, srvname, UNI_STR_TERMINATE);
1514         init_unistr2(&del->uni_share_name, sharename, UNI_STR_TERMINATE);
1515 }
1516
1517 /*******************************************************************
1518  Reads or writes a structure.
1519 ********************************************************************/
1520
1521 BOOL srv_io_q_net_share_del(const char *desc, SRV_Q_NET_SHARE_DEL *q_n, prs_struct *ps, int depth)
1522 {
1523         if (q_n == NULL)
1524                 return False;
1525
1526         prs_debug(ps, depth, desc, "srv_io_q_net_share_del");
1527         depth++;
1528
1529         if(!prs_align(ps))
1530                 return False;
1531
1532         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1533                 return False;
1534         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1535                 return False;
1536
1537         if(!smb_io_unistr2("", &q_n->uni_share_name, True, ps, depth))
1538                 return False;
1539
1540         if(!prs_align(ps))
1541                 return False;
1542         if(!prs_uint32("reserved", ps, depth, &q_n->reserved))
1543                 return False;
1544
1545         return True;
1546 }
1547
1548 /*******************************************************************
1549  Reads or writes a structure.
1550 ********************************************************************/
1551
1552 BOOL srv_io_r_net_share_del(const char *desc, SRV_R_NET_SHARE_DEL *q_n, prs_struct *ps, int depth)
1553 {
1554         if (q_n == NULL)
1555                 return False;
1556
1557         prs_debug(ps, depth, desc, "srv_io_r_net_share_del");
1558         depth++;
1559
1560         if(!prs_align(ps))
1561                 return False;
1562
1563         if(!prs_werror("status", ps, depth, &q_n->status))
1564                 return False;
1565
1566         return True;
1567 }
1568
1569 /*******************************************************************
1570  Inits a SESS_INFO_0_STR structure
1571 ********************************************************************/
1572
1573 void init_srv_sess_info0_str(SESS_INFO_0_STR *ss0, const char *name)
1574 {
1575         DEBUG(5,("init_srv_sess_info0_str\n"));
1576
1577         init_unistr2(&ss0->uni_name, name, UNI_STR_TERMINATE);
1578 }
1579
1580 /*******************************************************************
1581  Reads or writes a structure.
1582 ********************************************************************/
1583
1584 static BOOL srv_io_sess_info0_str(const char *desc,  SESS_INFO_0_STR *ss0, prs_struct *ps, int depth)
1585 {
1586         if (ss0 == NULL)
1587                 return False;
1588
1589         prs_debug(ps, depth, desc, "srv_io_sess_info0_str");
1590         depth++;
1591
1592         if(!prs_align(ps))
1593                 return False;
1594
1595         if(!smb_io_unistr2("", &ss0->uni_name, True, ps, depth))
1596                 return False;
1597
1598         return True;
1599 }
1600
1601 /*******************************************************************
1602  Inits a SESS_INFO_0 structure
1603 ********************************************************************/
1604
1605 void init_srv_sess_info0(SESS_INFO_0 *ss0, const char *name)
1606 {
1607         DEBUG(5,("init_srv_sess_info0: %s\n", name));
1608
1609         ss0->ptr_name = (name != NULL) ? 1 : 0;
1610 }
1611
1612 /*******************************************************************
1613  Reads or writes a structure.
1614 ********************************************************************/
1615
1616 static BOOL srv_io_sess_info0(const char *desc, SESS_INFO_0 *ss0, prs_struct *ps, int depth)
1617 {
1618         if (ss0 == NULL)
1619                 return False;
1620
1621         prs_debug(ps, depth, desc, "srv_io_sess_info0");
1622         depth++;
1623
1624         if(!prs_align(ps))
1625                 return False;
1626
1627         if(!prs_uint32("ptr_name", ps, depth, &ss0->ptr_name))
1628                 return False;
1629
1630         return True;
1631 }
1632
1633 /*******************************************************************
1634  Reads or writes a structure.
1635 ********************************************************************/
1636
1637 static BOOL srv_io_srv_sess_info_0(const char *desc, SRV_SESS_INFO_0 *ss0, prs_struct *ps, int depth)
1638 {
1639         if (ss0 == NULL)
1640                 return False;
1641
1642         prs_debug(ps, depth, desc, "srv_io_srv_sess_info_0");
1643         depth++;
1644
1645         if(!prs_align(ps))
1646                 return False;
1647
1648         if(!prs_uint32("num_entries_read", ps, depth, &ss0->num_entries_read))
1649                 return False;
1650         if(!prs_uint32("ptr_sess_info", ps, depth, &ss0->ptr_sess_info))
1651                 return False;
1652
1653         if (ss0->ptr_sess_info != 0) {
1654                 uint32 i;
1655                 uint32 num_entries = ss0->num_entries_read;
1656
1657                 if (num_entries > MAX_SESS_ENTRIES) {
1658                         num_entries = MAX_SESS_ENTRIES; /* report this! */
1659                 }
1660
1661                 if(!prs_uint32("num_entries_read2", ps, depth, &ss0->num_entries_read2))
1662                         return False;
1663
1664                 SMB_ASSERT_ARRAY(ss0->info_0, num_entries);
1665
1666                 for (i = 0; i < num_entries; i++) {
1667                         if(!srv_io_sess_info0("", &ss0->info_0[i], ps, depth))
1668                                 return False;
1669                 }
1670
1671                 for (i = 0; i < num_entries; i++) {
1672                         if(!srv_io_sess_info0_str("", &ss0->info_0_str[i], ps, depth))
1673                                 return False;
1674                 }
1675
1676                 if(!prs_align(ps))
1677                         return False;
1678         }
1679
1680         return True;
1681 }
1682
1683 /*******************************************************************
1684  Inits a SESS_INFO_1_STR structure
1685 ********************************************************************/
1686
1687 void init_srv_sess_info1_str(SESS_INFO_1_STR *ss1, const char *name, const char *user)
1688 {
1689         DEBUG(5,("init_srv_sess_info1_str\n"));
1690
1691         init_unistr2(&ss1->uni_name, name, UNI_STR_TERMINATE);
1692         init_unistr2(&ss1->uni_user, user, UNI_STR_TERMINATE);
1693 }
1694
1695 /*******************************************************************
1696  Reads or writes a structure.
1697 ********************************************************************/
1698
1699 static BOOL srv_io_sess_info1_str(const char *desc, SESS_INFO_1_STR *ss1, prs_struct *ps, int depth)
1700 {
1701         if (ss1 == NULL)
1702                 return False;
1703
1704         prs_debug(ps, depth, desc, "srv_io_sess_info1_str");
1705         depth++;
1706
1707         if(!prs_align(ps))
1708                 return False;
1709
1710         if(!smb_io_unistr2("", &ss1->uni_name, True, ps, depth))
1711                 return False;
1712         if(!smb_io_unistr2("", &(ss1->uni_user), True, ps, depth))
1713                 return False;
1714
1715         return True;
1716 }
1717
1718 /*******************************************************************
1719  Inits a SESS_INFO_1 structure
1720 ********************************************************************/
1721
1722 void init_srv_sess_info1(SESS_INFO_1 *ss1,
1723                                 const char *name, const char *user,
1724                                 uint32 num_opens, uint32 open_time, uint32 idle_time,
1725                                 uint32 user_flags)
1726 {
1727         DEBUG(5,("init_srv_sess_info1: %s\n", name));
1728
1729         ss1->ptr_name = (name != NULL) ? 1 : 0;
1730         ss1->ptr_user = (user != NULL) ? 1 : 0;
1731
1732         ss1->num_opens  = num_opens;
1733         ss1->open_time  = open_time;
1734         ss1->idle_time  = idle_time;
1735         ss1->user_flags = user_flags;
1736 }
1737
1738 /*******************************************************************
1739 reads or writes a structure.
1740 ********************************************************************/
1741
1742 static BOOL srv_io_sess_info1(const char *desc, SESS_INFO_1 *ss1, prs_struct *ps, int depth)
1743 {
1744         if (ss1 == NULL)
1745                 return False;
1746
1747         prs_debug(ps, depth, desc, "srv_io_sess_info1");
1748         depth++;
1749
1750         if(!prs_align(ps))
1751                 return False;
1752
1753         if(!prs_uint32("ptr_name  ", ps, depth, &ss1->ptr_name))
1754                 return False;
1755         if(!prs_uint32("ptr_user  ", ps, depth, &ss1->ptr_user))
1756                 return False;
1757
1758         if(!prs_uint32("num_opens ", ps, depth, &ss1->num_opens))
1759                 return False;
1760         if(!prs_uint32("open_time ", ps, depth, &ss1->open_time))
1761                 return False;
1762         if(!prs_uint32("idle_time ", ps, depth, &ss1->idle_time))
1763                 return False;
1764         if(!prs_uint32("user_flags", ps, depth, &ss1->user_flags))
1765                 return False;
1766
1767         return True;
1768 }
1769
1770 /*******************************************************************
1771  Reads or writes a structure.
1772 ********************************************************************/
1773
1774 static BOOL srv_io_srv_sess_info_1(const char *desc, SRV_SESS_INFO_1 *ss1, prs_struct *ps, int depth)
1775 {
1776         if (ss1 == NULL)
1777                 return False;
1778
1779         prs_debug(ps, depth, desc, "srv_io_srv_sess_info_1");
1780         depth++;
1781
1782         if(!prs_align(ps))
1783                 return False;
1784
1785         if(!prs_uint32("num_entries_read", ps, depth, &ss1->num_entries_read))
1786                 return False;
1787         if(!prs_uint32("ptr_sess_info", ps, depth, &ss1->ptr_sess_info))
1788                 return False;
1789
1790         if (ss1->ptr_sess_info != 0) {
1791                 uint32 i;
1792                 uint32 num_entries = ss1->num_entries_read;
1793
1794                 if (num_entries > MAX_SESS_ENTRIES) {
1795                         num_entries = MAX_SESS_ENTRIES; /* report this! */
1796                 }
1797
1798                 if(!prs_uint32("num_entries_read2", ps, depth, &ss1->num_entries_read2))
1799                         return False;
1800
1801                 SMB_ASSERT_ARRAY(ss1->info_1, num_entries);
1802
1803                 for (i = 0; i < num_entries; i++) {
1804                         if(!srv_io_sess_info1("", &ss1->info_1[i], ps, depth))
1805                                 return False;
1806                 }
1807
1808                 for (i = 0; i < num_entries; i++) {
1809                         if(!srv_io_sess_info1_str("", &ss1->info_1_str[i], ps, depth))
1810                                 return False;
1811                 }
1812
1813                 if(!prs_align(ps))
1814                         return False;
1815         }
1816
1817         return True;
1818 }
1819
1820 /*******************************************************************
1821  Reads or writes a structure.
1822 ********************************************************************/
1823
1824 static BOOL srv_io_srv_sess_ctr(const char *desc, SRV_SESS_INFO_CTR **pp_ctr, prs_struct *ps, int depth)
1825 {
1826         SRV_SESS_INFO_CTR *ctr = *pp_ctr;
1827
1828         prs_debug(ps, depth, desc, "srv_io_srv_sess_ctr");
1829         depth++;
1830
1831         if(UNMARSHALLING(ps)) {
1832                 ctr = *pp_ctr = (SRV_SESS_INFO_CTR *)prs_alloc_mem(ps, sizeof(SRV_SESS_INFO_CTR));
1833                 if (ctr == NULL)
1834                         return False;
1835         }
1836
1837         if (ctr == NULL)
1838                 return False;
1839
1840         if(!prs_align(ps))
1841                 return False;
1842
1843         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
1844                 return False;
1845         if(!prs_uint32("ptr_sess_ctr", ps, depth, &ctr->ptr_sess_ctr))
1846                 return False;
1847
1848         if (ctr->ptr_sess_ctr != 0) {
1849                 switch (ctr->switch_value) {
1850                 case 0:
1851                         if(!srv_io_srv_sess_info_0("", &ctr->sess.info0, ps, depth))
1852                                 return False;
1853                         break;
1854                 case 1:
1855                         if(!srv_io_srv_sess_info_1("", &ctr->sess.info1, ps, depth))
1856                                 return False;
1857                         break;
1858                 default:
1859                         DEBUG(5,("%s no session info at switch_value %d\n",
1860                                  tab_depth(depth), ctr->switch_value));
1861                         break;
1862                 }
1863         }
1864
1865         return True;
1866 }
1867
1868 /*******************************************************************
1869  Inits a SRV_Q_NET_SESS_ENUM structure.
1870 ********************************************************************/
1871
1872 void init_srv_q_net_sess_enum(SRV_Q_NET_SESS_ENUM *q_n,
1873                               const char *srv_name, const char *qual_name,
1874                               const char *user_name, uint32 sess_level,
1875                               SRV_SESS_INFO_CTR *ctr, uint32 preferred_len,
1876                               ENUM_HND *hnd)
1877 {
1878         q_n->ctr = ctr;
1879
1880         DEBUG(5,("init_q_net_sess_enum\n"));
1881
1882         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
1883         init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
1884         init_buf_unistr2(&q_n->uni_user_name, &q_n->ptr_user_name, user_name);
1885
1886         q_n->sess_level    = sess_level;
1887         q_n->preferred_len = preferred_len;
1888
1889         memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
1890 }
1891
1892 /*******************************************************************
1893  Reads or writes a structure.
1894 ********************************************************************/
1895
1896 BOOL srv_io_q_net_sess_enum(const char *desc, SRV_Q_NET_SESS_ENUM *q_n, prs_struct *ps, int depth)
1897 {
1898         if (q_n == NULL)
1899                 return False;
1900
1901         prs_debug(ps, depth, desc, "srv_io_q_net_sess_enum");
1902         depth++;
1903
1904         if(!prs_align(ps))
1905                 return False;
1906
1907         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1908                 return False;
1909         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1910                 return False;
1911
1912         if(!prs_align(ps))
1913                 return False;
1914
1915         if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
1916                 return False;
1917         if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
1918                 return False;
1919
1920         if(!prs_align(ps))
1921                 return False;
1922         if(!prs_uint32("ptr_user_name", ps, depth, &q_n->ptr_user_name))
1923                 return False;
1924         if(!smb_io_unistr2("", &q_n->uni_user_name, q_n->ptr_user_name, ps, depth))
1925                 return False;
1926
1927         if(!prs_align(ps))
1928                 return False;
1929
1930         if(!prs_uint32("sess_level", ps, depth, &q_n->sess_level))
1931                 return False;
1932
1933         if (q_n->sess_level != (uint32)-1) {
1934                 if(!srv_io_srv_sess_ctr("sess_ctr", &q_n->ctr, ps, depth))
1935                         return False;
1936         }
1937
1938         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
1939                 return False;
1940
1941         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
1942                 return False;
1943
1944         return True;
1945 }
1946
1947 /*******************************************************************
1948  Reads or writes a structure.
1949 ********************************************************************/
1950
1951 BOOL srv_io_r_net_sess_enum(const char *desc, SRV_R_NET_SESS_ENUM *r_n, prs_struct *ps, int depth)
1952 {
1953         if (r_n == NULL)
1954                 return False;
1955
1956         prs_debug(ps, depth, desc, "srv_io_r_net_sess_enum");
1957         depth++;
1958
1959         if(!prs_align(ps))
1960                 return False;
1961
1962         if(!prs_uint32("sess_level", ps, depth, &r_n->sess_level))
1963                 return False;
1964
1965         if (r_n->sess_level != (uint32)-1) {
1966                 if(!srv_io_srv_sess_ctr("sess_ctr", &r_n->ctr, ps, depth))
1967                         return False;
1968         }
1969
1970         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
1971                 return False;
1972         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
1973                 return False;
1974         if(!prs_werror("status", ps, depth, &r_n->status))
1975                 return False;
1976
1977         return True;
1978 }
1979
1980 /*******************************************************************
1981  Inits a CONN_INFO_0 structure
1982 ********************************************************************/
1983
1984 void init_srv_conn_info0(CONN_INFO_0 *ss0, uint32 id)
1985 {
1986         DEBUG(5,("init_srv_conn_info0\n"));
1987
1988         ss0->id = id;
1989 }
1990
1991 /*******************************************************************
1992  Reads or writes a structure.
1993 ********************************************************************/
1994
1995 static BOOL srv_io_conn_info0(const char *desc, CONN_INFO_0 *ss0, prs_struct *ps, int depth)
1996 {
1997         if (ss0 == NULL)
1998                 return False;
1999
2000         prs_debug(ps, depth, desc, "srv_io_conn_info0");
2001         depth++;
2002
2003         if(!prs_align(ps))
2004                 return False;
2005
2006         if(!prs_uint32("id", ps, depth, &ss0->id))
2007                 return False;
2008
2009         return True;
2010 }
2011
2012 /*******************************************************************
2013  Reads or writes a structure.
2014 ********************************************************************/
2015
2016 static BOOL srv_io_srv_conn_info_0(const char *desc, SRV_CONN_INFO_0 *ss0, prs_struct *ps, int depth)
2017 {
2018         if (ss0 == NULL)
2019                 return False;
2020
2021         prs_debug(ps, depth, desc, "srv_io_srv_conn_info_0");
2022         depth++;
2023
2024         if(!prs_align(ps))
2025                 return False;
2026
2027         if(!prs_uint32("num_entries_read", ps, depth, &ss0->num_entries_read))
2028                 return False;
2029         if(!prs_uint32("ptr_conn_info", ps, depth, &ss0->ptr_conn_info))
2030                 return False;
2031
2032         if (ss0->ptr_conn_info != 0) {
2033                 int i;
2034                 int num_entries = ss0->num_entries_read;
2035
2036                 if (num_entries > MAX_CONN_ENTRIES) {
2037                         num_entries = MAX_CONN_ENTRIES; /* report this! */
2038                 }
2039
2040                 if(!prs_uint32("num_entries_read2", ps, depth, &ss0->num_entries_read2))
2041                         return False;
2042
2043                 for (i = 0; i < num_entries; i++) {
2044                         if(!srv_io_conn_info0("", &ss0->info_0[i], ps, depth))
2045                                 return False;
2046                 }
2047
2048                 if(!prs_align(ps))
2049                         return False;
2050         }
2051
2052         return True;
2053 }
2054
2055 /*******************************************************************
2056  Inits a CONN_INFO_1_STR structure
2057 ********************************************************************/
2058
2059 void init_srv_conn_info1_str(CONN_INFO_1_STR *ss1, const char *usr_name, const char *net_name)
2060 {
2061         DEBUG(5,("init_srv_conn_info1_str\n"));
2062
2063         init_unistr2(&ss1->uni_usr_name, usr_name, UNI_STR_TERMINATE);
2064         init_unistr2(&ss1->uni_net_name, net_name, UNI_STR_TERMINATE);
2065 }
2066
2067 /*******************************************************************
2068  Reads or writes a structure.
2069 ********************************************************************/
2070
2071 static BOOL srv_io_conn_info1_str(const char *desc, CONN_INFO_1_STR *ss1, prs_struct *ps, int depth)
2072 {
2073         if (ss1 == NULL)
2074                 return False;
2075
2076         prs_debug(ps, depth, desc, "srv_io_conn_info1_str");
2077         depth++;
2078
2079         if(!prs_align(ps))
2080                 return False;
2081
2082         if(!smb_io_unistr2("", &ss1->uni_usr_name, True, ps, depth))
2083                 return False;
2084         if(!smb_io_unistr2("", &ss1->uni_net_name, True, ps, depth))
2085                 return False;
2086
2087         return True;
2088 }
2089
2090 /*******************************************************************
2091  Inits a CONN_INFO_1 structure
2092 ********************************************************************/
2093
2094 void init_srv_conn_info1(CONN_INFO_1 *ss1,
2095                                 uint32 id, uint32 type,
2096                                 uint32 num_opens, uint32 num_users, uint32 open_time,
2097                                 const char *usr_name, const char *net_name)
2098 {
2099         DEBUG(5,("init_srv_conn_info1: %s %s\n", usr_name, net_name));
2100
2101         ss1->id        = id       ;
2102         ss1->type      = type     ;
2103         ss1->num_opens = num_opens ;
2104         ss1->num_users = num_users;
2105         ss1->open_time = open_time;
2106
2107         ss1->ptr_usr_name = (usr_name != NULL) ? 1 : 0;
2108         ss1->ptr_net_name = (net_name != NULL) ? 1 : 0;
2109 }
2110
2111 /*******************************************************************
2112  Reads or writes a structure.
2113 ********************************************************************/
2114
2115 static BOOL srv_io_conn_info1(const char *desc, CONN_INFO_1 *ss1, prs_struct *ps, int depth)
2116 {
2117         if (ss1 == NULL)
2118                 return False;
2119
2120         prs_debug(ps, depth, desc, "srv_io_conn_info1");
2121         depth++;
2122
2123         if(!prs_align(ps))
2124                 return False;
2125
2126         if(!prs_uint32("id          ", ps, depth, &ss1->id))
2127                 return False;
2128         if(!prs_uint32("type        ", ps, depth, &ss1->type))
2129                 return False;
2130         if(!prs_uint32("num_opens   ", ps, depth, &ss1->num_opens))
2131                 return False;
2132         if(!prs_uint32("num_users   ", ps, depth, &ss1->num_users))
2133                 return False;
2134         if(!prs_uint32("open_time   ", ps, depth, &ss1->open_time))
2135                 return False;
2136
2137         if(!prs_uint32("ptr_usr_name", ps, depth, &ss1->ptr_usr_name))
2138                 return False;
2139         if(!prs_uint32("ptr_net_name", ps, depth, &ss1->ptr_net_name))
2140                 return False;
2141
2142         return True;
2143 }
2144
2145 /*******************************************************************
2146  Reads or writes a structure.
2147 ********************************************************************/
2148
2149 static BOOL srv_io_srv_conn_info_1(const char *desc, SRV_CONN_INFO_1 *ss1, prs_struct *ps, int depth)
2150 {
2151         if (ss1 == NULL)
2152                 return False;
2153
2154         prs_debug(ps, depth, desc, "srv_io_srv_conn_info_1");
2155         depth++;
2156
2157         if(!prs_align(ps))
2158                 return False;
2159
2160         if(!prs_uint32("num_entries_read", ps, depth, &ss1->num_entries_read))
2161                 return False;
2162         if(!prs_uint32("ptr_conn_info", ps, depth, &ss1->ptr_conn_info))
2163                 return False;
2164
2165         if (ss1->ptr_conn_info != 0) {
2166                 int i;
2167                 int num_entries = ss1->num_entries_read;
2168
2169                 if (num_entries > MAX_CONN_ENTRIES) {
2170                         num_entries = MAX_CONN_ENTRIES; /* report this! */
2171                 }
2172
2173                 if(!prs_uint32("num_entries_read2", ps, depth, &ss1->num_entries_read2))
2174                         return False;
2175
2176                 for (i = 0; i < num_entries; i++) {
2177                         if(!srv_io_conn_info1("", &ss1->info_1[i], ps, depth))
2178                                 return False;
2179                 }
2180
2181                 for (i = 0; i < num_entries; i++) {
2182                         if(!srv_io_conn_info1_str("", &ss1->info_1_str[i], ps, depth))
2183                                 return False;
2184                 }
2185
2186                 if(!prs_align(ps))
2187                         return False;
2188         }
2189
2190         return True;
2191 }
2192
2193 /*******************************************************************
2194  Reads or writes a structure.
2195 ********************************************************************/
2196
2197 static BOOL srv_io_srv_conn_ctr(const char *desc, SRV_CONN_INFO_CTR **pp_ctr, prs_struct *ps, int depth)
2198 {
2199         SRV_CONN_INFO_CTR *ctr = *pp_ctr;
2200
2201         prs_debug(ps, depth, desc, "srv_io_srv_conn_ctr");
2202         depth++;
2203
2204         if (UNMARSHALLING(ps)) {
2205                 ctr = *pp_ctr = (SRV_CONN_INFO_CTR *)prs_alloc_mem(ps, sizeof(SRV_CONN_INFO_CTR));
2206                 if (ctr == NULL)
2207                         return False;
2208         }
2209
2210         if (ctr == NULL)
2211                 return False;
2212
2213         if(!prs_align(ps))
2214                 return False;
2215
2216         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
2217                 return False;
2218         if(!prs_uint32("ptr_conn_ctr", ps, depth, &ctr->ptr_conn_ctr))
2219                 return False;
2220
2221         if (ctr->ptr_conn_ctr != 0) {
2222                 switch (ctr->switch_value) {
2223                 case 0:
2224                         if(!srv_io_srv_conn_info_0("", &ctr->conn.info0, ps, depth))
2225                                 return False;
2226                         break;
2227                 case 1:
2228                         if(!srv_io_srv_conn_info_1("", &ctr->conn.info1, ps, depth))
2229                                 return False;
2230                         break;
2231                 default:
2232                         DEBUG(5,("%s no connection info at switch_value %d\n",
2233                                  tab_depth(depth), ctr->switch_value));
2234                         break;
2235                 }
2236         }
2237
2238         return True;
2239 }
2240
2241 /*******************************************************************
2242   Reads or writes a structure.
2243 ********************************************************************/
2244
2245 void init_srv_q_net_conn_enum(SRV_Q_NET_CONN_ENUM *q_n,
2246                                 const char *srv_name, const char *qual_name,
2247                                 uint32 conn_level, SRV_CONN_INFO_CTR *ctr,
2248                                 uint32 preferred_len,
2249                                 ENUM_HND *hnd)
2250 {
2251         DEBUG(5,("init_q_net_conn_enum\n"));
2252
2253         q_n->ctr = ctr;
2254
2255         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name );
2256         init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
2257
2258         q_n->conn_level    = conn_level;
2259         q_n->preferred_len = preferred_len;
2260
2261         memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
2262 }
2263
2264 /*******************************************************************
2265  Reads or writes a structure.
2266 ********************************************************************/
2267
2268 BOOL srv_io_q_net_conn_enum(const char *desc, SRV_Q_NET_CONN_ENUM *q_n, prs_struct *ps, int depth)
2269 {
2270         if (q_n == NULL)
2271                 return False;
2272
2273         prs_debug(ps, depth, desc, "srv_io_q_net_conn_enum");
2274         depth++;
2275
2276         if(!prs_align(ps))
2277                 return False;
2278
2279         if(!prs_uint32("ptr_srv_name ", ps, depth, &q_n->ptr_srv_name))
2280                 return False;
2281         if(!smb_io_unistr2("", &q_n->uni_srv_name, q_n->ptr_srv_name, ps, depth))
2282                 return False;
2283
2284         if(!prs_align(ps))
2285                 return False;
2286
2287         if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
2288                 return False;
2289         if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
2290                 return False;
2291
2292         if(!prs_align(ps))
2293                 return False;
2294
2295         if(!prs_uint32("conn_level", ps, depth, &q_n->conn_level))
2296                 return False;
2297
2298         if (q_n->conn_level != (uint32)-1) {
2299                 if(!srv_io_srv_conn_ctr("conn_ctr", &q_n->ctr, ps, depth))
2300                         return False;
2301         }
2302
2303         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
2304                 return False;
2305
2306         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
2307                 return False;
2308
2309         return True;
2310 }
2311
2312 /*******************************************************************
2313  Reads or writes a structure.
2314 ********************************************************************/
2315
2316 BOOL srv_io_r_net_conn_enum(const char *desc,  SRV_R_NET_CONN_ENUM *r_n, prs_struct *ps, int depth)
2317 {
2318         if (r_n == NULL)
2319                 return False;
2320
2321         prs_debug(ps, depth, desc, "srv_io_r_net_conn_enum");
2322         depth++;
2323
2324         if(!prs_align(ps))
2325                 return False;
2326
2327         if(!prs_uint32("conn_level", ps, depth, &r_n->conn_level))
2328                 return False;
2329
2330         if (r_n->conn_level != (uint32)-1) {
2331                 if(!srv_io_srv_conn_ctr("conn_ctr", &r_n->ctr, ps, depth))
2332                         return False;
2333         }
2334
2335         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
2336                 return False;
2337         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
2338                 return False;
2339         if(!prs_werror("status", ps, depth, &r_n->status))
2340                 return False;
2341
2342         return True;
2343 }
2344
2345 /*******************************************************************
2346  Inits a FILE_INFO_3_STR structure
2347 ********************************************************************/
2348
2349 void init_srv_file_info3_str(FILE_INFO_3_STR *fi3, const char *user_name, const char *path_name)
2350 {
2351         DEBUG(5,("init_srv_file_info3_str\n"));
2352
2353         init_unistr2(&fi3->uni_path_name, path_name, UNI_STR_TERMINATE);
2354         init_unistr2(&fi3->uni_user_name, user_name, UNI_STR_TERMINATE);
2355 }
2356
2357 /*******************************************************************
2358  Reads or writes a structure.
2359 ********************************************************************/
2360
2361 static BOOL srv_io_file_info3_str(const char *desc, FILE_INFO_3_STR *sh1, prs_struct *ps, int depth)
2362 {
2363         if (sh1 == NULL)
2364                 return False;
2365
2366         prs_debug(ps, depth, desc, "srv_io_file_info3_str");
2367         depth++;
2368
2369         if(!prs_align(ps))
2370                 return False;
2371
2372         if(!smb_io_unistr2("", &sh1->uni_path_name, True, ps, depth))
2373                 return False;
2374         if(!smb_io_unistr2("", &sh1->uni_user_name, True, ps, depth))
2375                 return False;
2376
2377         return True;
2378 }
2379
2380 /*******************************************************************
2381  Inits a FILE_INFO_3 structure
2382 ********************************************************************/
2383
2384 void init_srv_file_info3(FILE_INFO_3 *fl3,
2385                          uint32 id, uint32 perms, uint32 num_locks,
2386                          const char *path_name, const char *user_name)
2387 {
2388         DEBUG(5,("init_srv_file_info3: %s %s\n", path_name, user_name));
2389
2390         fl3->id        = id;
2391         fl3->perms     = perms;
2392         fl3->num_locks = num_locks;
2393
2394         fl3->ptr_path_name = (path_name != NULL) ? 1 : 0;
2395         fl3->ptr_user_name = (user_name != NULL) ? 1 : 0;
2396 }
2397
2398 /*******************************************************************
2399  Reads or writes a structure.
2400 ********************************************************************/
2401
2402 static BOOL srv_io_file_info3(const char *desc, FILE_INFO_3 *fl3, prs_struct *ps, int depth)
2403 {
2404         if (fl3 == NULL)
2405                 return False;
2406
2407         prs_debug(ps, depth, desc, "srv_io_file_info3");
2408         depth++;
2409
2410         if(!prs_align(ps))
2411                 return False;
2412
2413         if(!prs_uint32("id           ", ps, depth, &fl3->id))
2414                 return False;
2415         if(!prs_uint32("perms        ", ps, depth, &fl3->perms))
2416                 return False;
2417         if(!prs_uint32("num_locks    ", ps, depth, &fl3->num_locks))
2418                 return False;
2419         if(!prs_uint32("ptr_path_name", ps, depth, &fl3->ptr_path_name))
2420                 return False;
2421         if(!prs_uint32("ptr_user_name", ps, depth, &fl3->ptr_user_name))
2422                 return False;
2423
2424         return True;
2425 }
2426
2427 /*******************************************************************
2428  Reads or writes a structure.
2429 ********************************************************************/
2430
2431 static BOOL srv_io_srv_file_ctr(const char *desc, SRV_FILE_INFO_CTR *ctr, prs_struct *ps, int depth)
2432 {
2433         if (ctr == NULL)
2434                 return False;
2435
2436         prs_debug(ps, depth, desc, "srv_io_srv_file_ctr");
2437         depth++;
2438
2439         if (UNMARSHALLING(ps)) {
2440                 memset(ctr, '\0', sizeof(SRV_FILE_INFO_CTR));
2441         }
2442
2443         if(!prs_align(ps))
2444                 return False;
2445
2446         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
2447                 return False;
2448         if (ctr->switch_value != 3) {
2449                 DEBUG(5,("%s File info %d level not supported\n",
2450                          tab_depth(depth), ctr->switch_value));
2451         }
2452         if(!prs_uint32("ptr_file_info", ps, depth, &ctr->ptr_file_info))
2453                 return False;
2454         if(!prs_uint32("num_entries", ps, depth, &ctr->num_entries))
2455                 return False;
2456         if(!prs_uint32("ptr_entries", ps, depth, &ctr->ptr_entries))
2457                 return False;
2458         if (ctr->ptr_entries == 0)
2459                 return True;
2460         if(!prs_uint32("num_entries2", ps, depth,
2461                        &ctr->num_entries2))
2462                 return False;
2463
2464         switch (ctr->switch_value) {
2465         case 3: {
2466                 SRV_FILE_INFO_3 *info3 = ctr->file.info3;
2467                 int num_entries = ctr->num_entries;
2468                 int i;
2469
2470                 if (UNMARSHALLING(ps)) {
2471                         if (!(info3 = (SRV_FILE_INFO_3 *)prs_alloc_mem(ps, num_entries * sizeof(SRV_FILE_INFO_3))))
2472                                 return False;
2473                         ctr->file.info3 = info3;
2474                 }
2475
2476                 for (i = 0; i < num_entries; i++) {
2477                         if(!srv_io_file_info3("", &ctr->file.info3[i].info_3, ps, depth))
2478                                 return False;
2479                 }
2480                 for (i = 0; i < num_entries; i++) {
2481                         if(!srv_io_file_info3_str("", &ctr->file.info3[i].info_3_str, ps, depth))
2482                                 return False;
2483                 }
2484                 break;
2485         }
2486         default:
2487                 DEBUG(5,("%s no file info at switch_value %d\n",
2488                          tab_depth(depth), ctr->switch_value));
2489                 break;
2490         }
2491
2492         return True;
2493 }
2494
2495 /*******************************************************************
2496  Inits a SRV_Q_NET_FILE_ENUM structure.
2497 ********************************************************************/
2498
2499 void init_srv_q_net_file_enum(SRV_Q_NET_FILE_ENUM *q_n,
2500                               const char *srv_name, const char *qual_name,
2501                               const char *user_name,
2502                               uint32 file_level, SRV_FILE_INFO_CTR *ctr,
2503                               uint32 preferred_len,
2504                               ENUM_HND *hnd)
2505 {
2506         DEBUG(5,("init_q_net_file_enum\n"));
2507
2508         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
2509         init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
2510         init_buf_unistr2(&q_n->uni_user_name, &q_n->ptr_user_name, user_name);
2511
2512         q_n->file_level    = q_n->ctr.switch_value = file_level;
2513         q_n->preferred_len = preferred_len;
2514         q_n->ctr.ptr_file_info = 1;
2515         q_n->ctr.num_entries = 0;
2516         q_n->ctr.num_entries2 = 0;
2517
2518         memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
2519 }
2520
2521 /*******************************************************************
2522  Reads or writes a structure.
2523 ********************************************************************/
2524
2525 BOOL srv_io_q_net_file_enum(const char *desc, SRV_Q_NET_FILE_ENUM *q_n, prs_struct *ps, int depth)
2526 {
2527         if (q_n == NULL)
2528                 return False;
2529
2530         prs_debug(ps, depth, desc, "srv_io_q_net_file_enum");
2531         depth++;
2532
2533         if(!prs_align(ps))
2534                 return False;
2535
2536         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
2537                 return False;
2538         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
2539                 return False;
2540
2541         if(!prs_align(ps))
2542                 return False;
2543
2544         if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
2545                 return False;
2546         if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
2547                 return False;
2548
2549         if(!prs_align(ps))
2550                 return False;
2551
2552         if(!prs_uint32("ptr_user_name", ps, depth, &q_n->ptr_user_name))
2553                 return False;
2554         if(!smb_io_unistr2("", &q_n->uni_user_name, q_n->ptr_user_name, ps, depth))
2555                 return False;
2556
2557         if(!prs_align(ps))
2558                 return False;
2559         if(!prs_uint32("file_level", ps, depth, &q_n->file_level))
2560                 return False;
2561
2562         if (q_n->file_level != (uint32)-1) {
2563                 if(!srv_io_srv_file_ctr("file_ctr", &q_n->ctr, ps, depth))
2564                         return False;
2565         }
2566
2567         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
2568                 return False;
2569
2570         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
2571                 return False;
2572
2573         return True;
2574 }
2575
2576 /*******************************************************************
2577  Reads or writes a structure.
2578 ********************************************************************/
2579
2580 BOOL srv_io_r_net_file_enum(const char *desc, SRV_R_NET_FILE_ENUM *r_n, prs_struct *ps, int depth)
2581 {
2582         if (r_n == NULL)
2583                 return False;
2584
2585         prs_debug(ps, depth, desc, "srv_io_r_net_file_enum");
2586         depth++;
2587
2588         if(!prs_align(ps))
2589                 return False;
2590
2591         if(!prs_uint32("file_level", ps, depth, &r_n->file_level))
2592                 return False;
2593
2594         if (r_n->file_level != 0) {
2595                 if(!srv_io_srv_file_ctr("file_ctr", &r_n->ctr, ps, depth))
2596                         return False;
2597         }
2598
2599         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
2600                 return False;
2601         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
2602                 return False;
2603         if(!prs_werror("status", ps, depth, &r_n->status))
2604                 return False;
2605
2606         return True;
2607 }
2608
2609 /*******************************************************************
2610  Initialize a net file close request
2611 ********************************************************************/
2612 void init_srv_q_net_file_close(SRV_Q_NET_FILE_CLOSE *q_n, const char *server,
2613                                uint32 file_id)
2614 {
2615         q_n->ptr_srv_name = 1;
2616         init_unistr2(&q_n->uni_srv_name, server, UNI_STR_TERMINATE);
2617         q_n->file_id = file_id;
2618 }
2619
2620 /*******************************************************************
2621  Reads or writes a structure.
2622 ********************************************************************/
2623 BOOL srv_io_q_net_file_close(const char *desc, SRV_Q_NET_FILE_CLOSE *q_n,
2624                              prs_struct *ps, int depth)
2625 {
2626         if (q_n == NULL)
2627                 return False;
2628
2629         prs_debug(ps, depth, desc, "srv_io_q_net_file_close");
2630         depth++;
2631
2632         if(!prs_align(ps))
2633                 return False;
2634
2635         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
2636                 return False;
2637         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
2638                 return False;
2639
2640         if(!prs_align(ps))
2641                 return False;
2642
2643         if(!prs_uint32("file_id", ps, depth, &q_n->file_id))
2644                 return False;
2645
2646         return True;
2647 }
2648
2649 /*******************************************************************
2650  Reads or writes a structure.
2651 ********************************************************************/
2652
2653 BOOL srv_io_r_net_file_close(const char *desc, SRV_R_NET_FILE_CLOSE *q_n,
2654                              prs_struct *ps, int depth)
2655 {
2656         if (q_n == NULL)
2657                 return False;
2658
2659         prs_debug(ps, depth, desc, "srv_io_r_net_file_close");
2660         depth++;
2661
2662         if(!prs_align(ps))
2663                 return False;
2664
2665         if(!prs_werror("status", ps, depth, &q_n->status))
2666                 return False;
2667
2668         return True;
2669 }
2670
2671 /*******************************************************************
2672  Inits a SRV_INFO_100 structure.
2673  ********************************************************************/
2674
2675 void init_srv_info_100(SRV_INFO_100 *sv100, uint32 platform_id, const char *name)
2676 {
2677         DEBUG(5,("init_srv_info_100\n"));
2678
2679         sv100->platform_id  = platform_id;
2680         init_buf_unistr2(&sv100->uni_name, &sv100->ptr_name, name);
2681 }
2682
2683 /*******************************************************************
2684  Reads or writes a SRV_INFO_101 structure.
2685  ********************************************************************/
2686
2687 static BOOL srv_io_info_100(const char *desc, SRV_INFO_100 *sv100, prs_struct *ps, int depth)
2688 {
2689         if (sv100 == NULL)
2690                 return False;
2691
2692         prs_debug(ps, depth, desc, "srv_io_info_100");
2693         depth++;
2694
2695         if(!prs_align(ps))
2696                 return False;
2697
2698         if(!prs_uint32("platform_id ", ps, depth, &sv100->platform_id))
2699                 return False;
2700         if(!prs_uint32("ptr_name    ", ps, depth, &sv100->ptr_name))
2701                 return False;
2702
2703         if(!smb_io_unistr2("uni_name    ", &sv100->uni_name, True, ps, depth))
2704                 return False;
2705
2706         return True;
2707 }
2708
2709
2710 /*******************************************************************
2711  Inits a SRV_INFO_101 structure.
2712  ********************************************************************/
2713
2714 void init_srv_info_101(SRV_INFO_101 *sv101, uint32 platform_id, const char *name,
2715                                 uint32 ver_major, uint32 ver_minor,
2716                                 uint32 srv_type, const char *comment)
2717 {
2718         DEBUG(5,("init_srv_info_101\n"));
2719
2720         sv101->platform_id  = platform_id;
2721         init_buf_unistr2(&sv101->uni_name, &sv101->ptr_name, name);
2722         sv101->ver_major    = ver_major;
2723         sv101->ver_minor    = ver_minor;
2724         sv101->srv_type     = srv_type;
2725         init_buf_unistr2(&sv101->uni_comment, &sv101->ptr_comment, comment);
2726 }
2727
2728 /*******************************************************************
2729  Reads or writes a SRV_INFO_101 structure.
2730  ********************************************************************/
2731
2732 static BOOL srv_io_info_101(const char *desc, SRV_INFO_101 *sv101, prs_struct *ps, int depth)
2733 {
2734         if (sv101 == NULL)
2735                 return False;
2736
2737         prs_debug(ps, depth, desc, "srv_io_info_101");
2738         depth++;
2739
2740         if(!prs_align(ps))
2741                 return False;
2742
2743         if(!prs_uint32("platform_id ", ps, depth, &sv101->platform_id))
2744                 return False;
2745         if(!prs_uint32("ptr_name    ", ps, depth, &sv101->ptr_name))
2746                 return False;
2747         if(!prs_uint32("ver_major   ", ps, depth, &sv101->ver_major))
2748                 return False;
2749         if(!prs_uint32("ver_minor   ", ps, depth, &sv101->ver_minor))
2750                 return False;
2751         if(!prs_uint32("srv_type    ", ps, depth, &sv101->srv_type))
2752                 return False;
2753         if(!prs_uint32("ptr_comment ", ps, depth, &sv101->ptr_comment))
2754                 return False;
2755
2756         if(!prs_align(ps))
2757                 return False;
2758
2759         if(!smb_io_unistr2("uni_name    ", &sv101->uni_name, True, ps, depth))
2760                 return False;
2761         if(!smb_io_unistr2("uni_comment ", &sv101->uni_comment, True, ps, depth))
2762                 return False;
2763
2764         return True;
2765 }
2766
2767 /*******************************************************************
2768  Inits a SRV_INFO_102 structure.
2769  ********************************************************************/
2770
2771 void init_srv_info_102(SRV_INFO_102 *sv102, uint32 platform_id, const char *name,
2772                                 const char *comment, uint32 ver_major, uint32 ver_minor,
2773                                 uint32 srv_type, uint32 users, uint32 disc, uint32 hidden,
2774                                 uint32 announce, uint32 ann_delta, uint32 licenses,
2775                                 const char *usr_path)
2776 {
2777         DEBUG(5,("init_srv_info_102\n"));
2778
2779         sv102->platform_id  = platform_id;
2780         init_buf_unistr2(&sv102->uni_name, &sv102->ptr_name, name);
2781         sv102->ver_major    = ver_major;
2782         sv102->ver_minor    = ver_minor;
2783         sv102->srv_type     = srv_type;
2784         init_buf_unistr2(&sv102->uni_comment, &sv102->ptr_comment, comment);
2785
2786         /* same as 101 up to here */
2787
2788         sv102->users        = users;
2789         sv102->disc         = disc;
2790         sv102->hidden       = hidden;
2791         sv102->announce     = announce;
2792         sv102->ann_delta    = ann_delta;
2793         sv102->licenses     = licenses;
2794         init_buf_unistr2(&sv102->uni_usr_path, &sv102->ptr_usr_path, usr_path);
2795 }
2796
2797
2798 /*******************************************************************
2799  Reads or writes a SRV_INFO_102 structure.
2800  ********************************************************************/
2801
2802 static BOOL srv_io_info_102(const char *desc, SRV_INFO_102 *sv102, prs_struct *ps, int depth)
2803 {
2804         if (sv102 == NULL)
2805                 return False;
2806
2807         prs_debug(ps, depth, desc, "srv_io_info102");
2808         depth++;
2809
2810         if(!prs_align(ps))
2811                 return False;
2812
2813         if(!prs_uint32("platform_id ", ps, depth, &sv102->platform_id))
2814                 return False;
2815         if(!prs_uint32("ptr_name    ", ps, depth, &sv102->ptr_name))
2816                 return False;
2817         if(!prs_uint32("ver_major   ", ps, depth, &sv102->ver_major))
2818                 return False;
2819         if(!prs_uint32("ver_minor   ", ps, depth, &sv102->ver_minor))
2820                 return False;
2821         if(!prs_uint32("srv_type    ", ps, depth, &sv102->srv_type))
2822                 return False;
2823         if(!prs_uint32("ptr_comment ", ps, depth, &sv102->ptr_comment))
2824                 return False;
2825
2826         /* same as 101 up to here */
2827
2828         if(!prs_uint32("users       ", ps, depth, &sv102->users))
2829                 return False;
2830         if(!prs_uint32("disc        ", ps, depth, &sv102->disc))
2831                 return False;
2832         if(!prs_uint32("hidden      ", ps, depth, &sv102->hidden))
2833                 return False;
2834         if(!prs_uint32("announce    ", ps, depth, &sv102->announce))
2835                 return False;
2836         if(!prs_uint32("ann_delta   ", ps, depth, &sv102->ann_delta))
2837                 return False;
2838         if(!prs_uint32("licenses    ", ps, depth, &sv102->licenses))
2839                 return False;
2840         if(!prs_uint32("ptr_usr_path", ps, depth, &sv102->ptr_usr_path))
2841                 return False;
2842
2843         if(!smb_io_unistr2("uni_name    ", &sv102->uni_name, True, ps, depth))
2844                 return False;
2845         if(!prs_align(ps))
2846                 return False;
2847         if(!smb_io_unistr2("uni_comment ", &sv102->uni_comment, True, ps, depth))
2848                 return False;
2849         if(!prs_align(ps))
2850                 return False;
2851         if(!smb_io_unistr2("uni_usr_path", &sv102->uni_usr_path, True, ps, depth))
2852                 return False;
2853
2854         return True;
2855 }
2856
2857 /*******************************************************************
2858  Reads or writes a SRV_INFO_102 structure.
2859  ********************************************************************/
2860
2861 static BOOL srv_io_info_ctr(const char *desc, SRV_INFO_CTR *ctr, prs_struct *ps, int depth)
2862 {
2863         if (ctr == NULL)
2864                 return False;
2865
2866         prs_debug(ps, depth, desc, "srv_io_info_ctr");
2867         depth++;
2868
2869         if(!prs_align(ps))
2870                 return False;
2871
2872         if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
2873                 return False;
2874         if(!prs_uint32("ptr_srv_ctr ", ps, depth, &ctr->ptr_srv_ctr))
2875                 return False;
2876
2877         if (ctr->ptr_srv_ctr != 0 && ctr->switch_value != 0 && ctr != NULL) {
2878                 switch (ctr->switch_value) {
2879                 case 100:
2880                         if(!srv_io_info_100("sv100", &ctr->srv.sv100, ps, depth))
2881                                 return False;
2882                         break;
2883                 case 101:
2884                         if(!srv_io_info_101("sv101", &ctr->srv.sv101, ps, depth))
2885                                 return False;
2886                         break;
2887                 case 102:
2888                         if(!srv_io_info_102("sv102", &ctr->srv.sv102, ps, depth))
2889                                 return False;
2890                         break;
2891                 default:
2892                         DEBUG(5,("%s no server info at switch_value %d\n",
2893                                          tab_depth(depth), ctr->switch_value));
2894                         break;
2895                 }
2896                 if(!prs_align(ps))
2897                         return False;
2898         }
2899
2900         return True;
2901 }
2902
2903 /*******************************************************************
2904  Inits a SRV_Q_NET_SRV_GET_INFO structure.
2905  ********************************************************************/
2906
2907 void init_srv_q_net_srv_get_info(SRV_Q_NET_SRV_GET_INFO *srv,
2908                                 const char *server_name, uint32 switch_value)
2909 {
2910         DEBUG(5,("init_srv_q_net_srv_get_info\n"));
2911
2912         init_buf_unistr2(&srv->uni_srv_name, &srv->ptr_srv_name, server_name);
2913
2914         srv->switch_value = switch_value;
2915 }
2916
2917 /*******************************************************************
2918  Reads or writes a structure.
2919 ********************************************************************/
2920
2921 BOOL srv_io_q_net_srv_get_info(const char *desc, SRV_Q_NET_SRV_GET_INFO *q_n, prs_struct *ps, int depth)
2922 {
2923         if (q_n == NULL)
2924                 return False;
2925
2926         prs_debug(ps, depth, desc, "srv_io_q_net_srv_get_info");
2927         depth++;
2928
2929         if(!prs_align(ps))
2930                 return False;
2931
2932         if(!prs_uint32("ptr_srv_name  ", ps, depth, &q_n->ptr_srv_name))
2933                 return False;
2934         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
2935                 return False;
2936
2937         if(!prs_align(ps))
2938                 return False;
2939
2940         if(!prs_uint32("switch_value  ", ps, depth, &q_n->switch_value))
2941                 return False;
2942
2943         return True;
2944 }
2945
2946 /*******************************************************************
2947  Inits a SRV_R_NET_SRV_GET_INFO structure.
2948  ********************************************************************/
2949
2950 void init_srv_r_net_srv_get_info(SRV_R_NET_SRV_GET_INFO *srv,
2951                                 uint32 switch_value, SRV_INFO_CTR *ctr, WERROR status)
2952 {
2953         DEBUG(5,("init_srv_r_net_srv_get_info\n"));
2954
2955         srv->ctr = ctr;
2956
2957         if (W_ERROR_IS_OK(status)) {
2958                 srv->ctr->switch_value = switch_value;
2959                 srv->ctr->ptr_srv_ctr  = 1;
2960         } else {
2961                 srv->ctr->switch_value = 0;
2962                 srv->ctr->ptr_srv_ctr  = 0;
2963         }
2964
2965         srv->status = status;
2966 }
2967
2968 /*******************************************************************
2969  Inits a SRV_R_NET_SRV_SET_INFO structure.
2970  ********************************************************************/
2971
2972 void init_srv_r_net_srv_set_info(SRV_R_NET_SRV_SET_INFO *srv,
2973                                  uint32 switch_value, WERROR status)
2974 {
2975         DEBUG(5,("init_srv_r_net_srv_set_info\n"));
2976
2977         srv->switch_value = switch_value;
2978         srv->status = status;
2979 }
2980
2981 /*******************************************************************
2982  Reads or writes a structure.
2983 ********************************************************************/
2984
2985 BOOL srv_io_q_net_srv_set_info(const char *desc, SRV_Q_NET_SRV_SET_INFO *q_n,
2986                                prs_struct *ps, int depth)
2987 {
2988         prs_debug(ps, depth, desc, "srv_io_q_net_srv_set_info");
2989         depth++;
2990
2991         if(!prs_align(ps))
2992                 return False;
2993
2994         if(!prs_uint32("ptr_srv_name  ", ps, depth, &q_n->ptr_srv_name))
2995                 return False;
2996         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
2997                 return False;
2998
2999         if(!prs_align(ps))
3000                 return False;
3001
3002         if(!prs_uint32("switch_value  ", ps, depth, &q_n->switch_value))
3003                 return False;
3004
3005         if (UNMARSHALLING(ps)) {
3006                 q_n->ctr = (SRV_INFO_CTR *)
3007                         prs_alloc_mem(ps, sizeof(SRV_INFO_CTR));
3008
3009                 if (!q_n->ctr)
3010                         return False;
3011         }
3012
3013         if(!srv_io_info_ctr("ctr", q_n->ctr, ps, depth))
3014                 return False;
3015
3016         return True;
3017 }
3018
3019 /*******************************************************************
3020  Reads or writes a structure.
3021  ********************************************************************/
3022
3023 BOOL srv_io_r_net_srv_get_info(const char *desc, SRV_R_NET_SRV_GET_INFO *r_n, prs_struct *ps, int depth)
3024 {
3025         if (r_n == NULL)
3026                 return False;
3027
3028         prs_debug(ps, depth, desc, "srv_io_r_net_srv_get_info");
3029         depth++;
3030
3031         if(!prs_align(ps))
3032                 return False;
3033
3034         if(!srv_io_info_ctr("ctr", r_n->ctr, ps, depth))
3035                 return False;
3036
3037         if(!prs_werror("status", ps, depth, &r_n->status))
3038                 return False;
3039
3040         return True;
3041 }
3042
3043 /*******************************************************************
3044  Reads or writes a structure.
3045  ********************************************************************/
3046
3047 BOOL srv_io_r_net_srv_set_info(const char *desc, SRV_R_NET_SRV_SET_INFO *r_n,
3048                                prs_struct *ps, int depth)
3049 {
3050         prs_debug(ps, depth, desc, "srv_io_r_net_srv_set_info");
3051         depth++;
3052
3053         if(!prs_align(ps))
3054                 return False;
3055
3056         if(!prs_uint32("switch value ", ps, depth, &r_n->switch_value))
3057                 return False;
3058
3059         if(!prs_werror("status", ps, depth, &r_n->status))
3060                 return False;
3061
3062         return True;
3063 }
3064
3065 /*******************************************************************
3066  Reads or writes a structure.
3067  ********************************************************************/
3068
3069 BOOL srv_io_q_net_remote_tod(const char *desc, SRV_Q_NET_REMOTE_TOD *q_n, prs_struct *ps, int depth)
3070 {
3071         if (q_n == NULL)
3072                 return False;
3073
3074         prs_debug(ps, depth, desc, "srv_io_q_net_remote_tod");
3075         depth++;
3076
3077         if(!prs_align(ps))
3078                 return False;
3079
3080         if(!prs_uint32("ptr_srv_name  ", ps, depth, &q_n->ptr_srv_name))
3081                 return False;
3082         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3083                 return False;
3084
3085         return True;
3086 }
3087
3088 /*******************************************************************
3089  Reads or writes a TIME_OF_DAY_INFO structure.
3090  ********************************************************************/
3091
3092 static BOOL srv_io_time_of_day_info(const char *desc, TIME_OF_DAY_INFO *tod, prs_struct *ps, int depth)
3093 {
3094         if (tod == NULL)
3095                 return False;
3096
3097         prs_debug(ps, depth, desc, "srv_io_time_of_day_info");
3098         depth++;
3099
3100         if(!prs_align(ps))
3101                 return False;
3102
3103         if(!prs_uint32("elapsedt   ", ps, depth, &tod->elapsedt))
3104                 return False;
3105         if(!prs_uint32("msecs      ", ps, depth, &tod->msecs))
3106                 return False;
3107         if(!prs_uint32("hours      ", ps, depth, &tod->hours))
3108                 return False;
3109         if(!prs_uint32("mins       ", ps, depth, &tod->mins))
3110                 return False;
3111         if(!prs_uint32("secs       ", ps, depth, &tod->secs))
3112                 return False;
3113         if(!prs_uint32("hunds      ", ps, depth, &tod->hunds))
3114                 return False;
3115         if(!prs_uint32("timezone   ", ps, depth, &tod->zone))
3116                 return False;
3117         if(!prs_uint32("tintervals ", ps, depth, &tod->tintervals))
3118                 return False;
3119         if(!prs_uint32("day        ", ps, depth, &tod->day))
3120                 return False;
3121         if(!prs_uint32("month      ", ps, depth, &tod->month))
3122                 return False;
3123         if(!prs_uint32("year       ", ps, depth, &tod->year))
3124                 return False;
3125         if(!prs_uint32("weekday    ", ps, depth, &tod->weekday))
3126                 return False;
3127
3128         return True;
3129 }
3130
3131 /*******************************************************************
3132  Inits a TIME_OF_DAY_INFO structure.
3133  ********************************************************************/
3134
3135 void init_time_of_day_info(TIME_OF_DAY_INFO *tod, uint32 elapsedt, uint32 msecs,
3136                            uint32 hours, uint32 mins, uint32 secs, uint32 hunds,
3137                            uint32 zone, uint32 tintervals, uint32 day,
3138                            uint32 month, uint32 year, uint32 weekday)
3139 {
3140         DEBUG(5,("init_time_of_day_info\n"));
3141
3142         tod->elapsedt   = elapsedt;
3143         tod->msecs      = msecs;
3144         tod->hours      = hours;
3145         tod->mins       = mins;
3146         tod->secs       = secs;
3147         tod->hunds      = hunds;
3148         tod->zone       = zone;
3149         tod->tintervals = tintervals;
3150         tod->day        = day;
3151         tod->month      = month;
3152         tod->year       = year;
3153         tod->weekday    = weekday;
3154 }
3155
3156
3157 /*******************************************************************
3158  Reads or writes a structure.
3159  ********************************************************************/
3160
3161 BOOL srv_io_r_net_remote_tod(const char *desc, SRV_R_NET_REMOTE_TOD *r_n, prs_struct *ps, int depth)
3162 {
3163         if (r_n == NULL)
3164                 return False;
3165
3166         prs_debug(ps, depth, desc, "srv_io_r_net_remote_tod");
3167         depth++;
3168
3169         if(!prs_align(ps))
3170                 return False;
3171
3172         if(!prs_uint32("ptr_srv_tod ", ps, depth, &r_n->ptr_srv_tod))
3173                 return False;
3174
3175         if(!srv_io_time_of_day_info("tod", r_n->tod, ps, depth))
3176                 return False;
3177
3178         if(!prs_werror("status", ps, depth, &r_n->status))
3179                 return False;
3180
3181         return True;
3182 }
3183
3184 /*******************************************************************
3185  initialises a structure.
3186  ********************************************************************/
3187
3188 BOOL init_srv_q_net_disk_enum(SRV_Q_NET_DISK_ENUM *q_n,
3189                               const char *srv_name,
3190                               uint32 preferred_len,
3191                               ENUM_HND *enum_hnd
3192         )
3193 {
3194
3195
3196         DEBUG(5,("init_srv_q_net_srv_disk_enum\n"));
3197
3198         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
3199
3200         q_n->disk_enum_ctr.level = 0;
3201         q_n->disk_enum_ctr.disk_info_ptr   = 0;
3202
3203         q_n->preferred_len = preferred_len;
3204         memcpy(&q_n->enum_hnd, enum_hnd, sizeof(*enum_hnd));
3205
3206         return True;
3207 }
3208
3209 /*******************************************************************
3210  Reads or writes a structure.
3211  ********************************************************************/
3212
3213 BOOL srv_io_q_net_disk_enum(const char *desc, SRV_Q_NET_DISK_ENUM *q_n, prs_struct *ps, int depth)
3214 {
3215         if (q_n == NULL)
3216                 return False;
3217
3218         prs_debug(ps, depth, desc, "srv_io_q_net_disk_enum");
3219         depth++;
3220
3221         if(!prs_align(ps))
3222                 return False;
3223
3224         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
3225                 return False;
3226
3227         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3228                 return False;
3229
3230         if(!prs_align(ps))
3231                 return False;
3232
3233         if(!prs_uint32("level", ps, depth, &q_n->disk_enum_ctr.level))
3234                 return False;
3235
3236         if(!prs_uint32("entries_read", ps, depth, &q_n->disk_enum_ctr.entries_read))
3237                 return False;
3238
3239         if(!prs_uint32("buffer", ps, depth, &q_n->disk_enum_ctr.disk_info_ptr))
3240                 return False;
3241
3242         if(!prs_align(ps))
3243                 return False;
3244
3245         if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
3246                 return False;
3247         if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
3248                 return False;
3249
3250         return True;
3251 }
3252
3253 /*******************************************************************
3254  Reads or writes a structure.
3255  ********************************************************************/
3256
3257 BOOL srv_io_r_net_disk_enum(const char *desc, SRV_R_NET_DISK_ENUM *r_n, prs_struct *ps, int depth)
3258 {
3259
3260         unsigned int i;
3261         uint32 entries_read, entries_read2, entries_read3;
3262
3263         if (r_n == NULL)
3264                 return False;
3265
3266         prs_debug(ps, depth, desc, "srv_io_r_net_disk_enum");
3267         depth++;
3268
3269         entries_read = entries_read2 = entries_read3 = r_n->disk_enum_ctr.entries_read;
3270
3271         if(!prs_align(ps))
3272                 return False;
3273
3274         if(!prs_uint32("entries_read", ps, depth, &entries_read))
3275                 return False;
3276         if(!prs_uint32("ptr_disk_info", ps, depth, &r_n->disk_enum_ctr.disk_info_ptr))
3277                 return False;
3278
3279         /*this may be max, unknown, actual?*/
3280
3281         if(!prs_uint32("max_elements", ps, depth, &entries_read2))
3282                 return False;
3283         if(!prs_uint32("unknown", ps, depth, &r_n->disk_enum_ctr.unknown))
3284                 return False;
3285         if(!prs_uint32("actual_elements", ps, depth, &entries_read3))
3286                 return False;
3287
3288         r_n->disk_enum_ctr.entries_read = entries_read3;
3289
3290         if(UNMARSHALLING(ps)) {
3291
3292                 DISK_INFO *dinfo;
3293
3294                 if(!(dinfo = (DISK_INFO *)prs_alloc_mem(ps, sizeof(*dinfo) * entries_read3)))
3295                 return False;
3296                 r_n->disk_enum_ctr.disk_info = dinfo;
3297         }
3298
3299         for(i=0; i < r_n->disk_enum_ctr.entries_read; i++) {
3300
3301                 if(!prs_uint32("unknown", ps, depth, &r_n->disk_enum_ctr.disk_info[i].unknown))
3302                         return False;
3303
3304                 if(!smb_io_unistr3("disk_name", &r_n->disk_enum_ctr.disk_info[i].disk_name, ps, depth))
3305                         return False;
3306
3307                 if(!prs_align(ps))
3308                         return False;
3309         }
3310
3311         if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
3312                 return False;
3313
3314         if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
3315                 return False;
3316
3317         if(!prs_werror("status", ps, depth, &r_n->status))
3318                 return False;
3319
3320         return True;
3321 }
3322
3323 /*******************************************************************
3324  initialises a structure.
3325  ********************************************************************/
3326
3327 BOOL init_srv_q_net_name_validate(SRV_Q_NET_NAME_VALIDATE *q_n, const char *srv_name, const char *share_name, int type)
3328 {
3329         uint32 ptr_share_name;
3330
3331         DEBUG(5,("init_srv_q_net_name_validate\n"));
3332
3333         init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
3334         init_buf_unistr2(&q_n->uni_name,     &ptr_share_name,    share_name);
3335
3336         q_n->type  = type;
3337         q_n->flags = 0;
3338
3339         return True;
3340 }
3341
3342 /*******************************************************************
3343  Reads or writes a structure.
3344  ********************************************************************/
3345
3346 BOOL srv_io_q_net_name_validate(const char *desc, SRV_Q_NET_NAME_VALIDATE *q_n, prs_struct *ps, int depth)
3347 {
3348         if (q_n == NULL)
3349                 return False;
3350
3351         prs_debug(ps, depth, desc, "srv_io_q_net_name_validate");
3352         depth++;
3353
3354         if(!prs_align(ps))
3355                 return False;
3356
3357         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
3358                 return False;
3359
3360         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3361                 return False;
3362
3363         if(!prs_align(ps))
3364                 return False;
3365
3366         if(!smb_io_unistr2("", &q_n->uni_name, True, ps, depth))
3367                 return False;
3368
3369         if(!prs_align(ps))
3370                 return False;
3371
3372         if(!prs_uint32("type", ps, depth, &q_n->type))
3373                 return False;
3374
3375         if(!prs_uint32("flags", ps, depth, &q_n->flags))
3376                 return False;
3377
3378         return True;
3379 }
3380
3381 /*******************************************************************
3382  Reads or writes a structure.
3383  ********************************************************************/
3384
3385 BOOL srv_io_r_net_name_validate(const char *desc, SRV_R_NET_NAME_VALIDATE *r_n, prs_struct *ps, int depth)
3386 {
3387         if (r_n == NULL)
3388                 return False;
3389
3390         prs_debug(ps, depth, desc, "srv_io_r_net_name_validate");
3391         depth++;
3392
3393         if(!prs_align(ps))
3394                 return False;
3395
3396         if(!prs_werror("status", ps, depth, &r_n->status))
3397                 return False;
3398
3399         return True;
3400 }
3401
3402 /*******************************************************************
3403  Reads or writes a structure.
3404 ********************************************************************/
3405
3406 BOOL srv_io_q_net_file_query_secdesc(const char *desc, SRV_Q_NET_FILE_QUERY_SECDESC *q_n, prs_struct *ps, int depth)
3407 {
3408         if (q_n == NULL)
3409                 return False;
3410
3411         prs_debug(ps, depth, desc, "srv_io_q_net_file_query_secdesc");
3412         depth++;
3413
3414         if(!prs_align(ps))
3415                 return False;
3416
3417         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
3418                 return False;
3419
3420         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3421                 return False;
3422
3423         if(!prs_align(ps))
3424                 return False;
3425
3426         if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
3427                 return False;
3428
3429         if(!smb_io_unistr2("", &q_n->uni_qual_name, True, ps, depth))
3430                 return False;
3431
3432         if(!prs_align(ps))
3433                 return False;
3434
3435         if(!smb_io_unistr2("", &q_n->uni_file_name, True, ps, depth))
3436                 return False;
3437
3438         if(!prs_uint32("unknown1", ps, depth, &q_n->unknown1))
3439                 return False;
3440
3441         if(!prs_uint32("unknown2", ps, depth, &q_n->unknown2))
3442                 return False;
3443
3444         if(!prs_uint32("unknown3", ps, depth, &q_n->unknown3))
3445                 return False;
3446
3447         return True;
3448 }
3449
3450 /*******************************************************************
3451  Reads or writes a structure.
3452 ********************************************************************/
3453
3454 BOOL srv_io_r_net_file_query_secdesc(const char *desc, SRV_R_NET_FILE_QUERY_SECDESC *r_n, prs_struct *ps, int depth)
3455 {
3456         if (r_n == NULL)
3457                 return False;
3458
3459         prs_debug(ps, depth, desc, "srv_io_r_net_file_query_secdesc");
3460         depth++;
3461
3462         if(!prs_align(ps))
3463                 return False;
3464
3465         if(!prs_uint32("ptr_response", ps, depth, &r_n->ptr_response))
3466                 return False;
3467
3468         if(!prs_uint32("size_response", ps, depth, &r_n->size_response))
3469                 return False;
3470
3471         if(!prs_uint32("ptr_secdesc", ps, depth, &r_n->ptr_secdesc))
3472                 return False;
3473
3474         if(!prs_uint32("size_secdesc", ps, depth, &r_n->size_secdesc))
3475                 return False;
3476
3477         if(!sec_io_desc("sec_desc", &r_n->sec_desc, ps, depth))
3478                 return False;
3479
3480         if(!prs_align(ps))
3481                 return False;
3482
3483         if(!prs_werror("status", ps, depth, &r_n->status))
3484                 return False;
3485
3486         return True;
3487 }
3488
3489 /*******************************************************************
3490  Reads or writes a structure.
3491 ********************************************************************/
3492
3493 BOOL srv_io_q_net_file_set_secdesc(const char *desc, SRV_Q_NET_FILE_SET_SECDESC *q_n, prs_struct *ps, int depth)
3494 {
3495         if (q_n == NULL)
3496                 return False;
3497
3498         prs_debug(ps, depth, desc, "srv_io_q_net_file_set_secdesc");
3499         depth++;
3500
3501         if(!prs_align(ps))
3502                 return False;
3503
3504         if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
3505                 return False;
3506
3507         if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3508                 return False;
3509
3510         if(!prs_align(ps))
3511                 return False;
3512
3513         if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
3514                 return False;
3515
3516         if(!smb_io_unistr2("", &q_n->uni_qual_name, True, ps, depth))
3517                 return False;
3518
3519         if(!prs_align(ps))
3520                 return False;
3521
3522         if(!smb_io_unistr2("", &q_n->uni_file_name, True, ps, depth))
3523                 return False;
3524
3525         if(!prs_align(ps))
3526                 return False;
3527
3528         if(!prs_uint32("sec_info", ps, depth, &q_n->sec_info))
3529                 return False;
3530
3531         if(!prs_uint32("size_set", ps, depth, &q_n->size_set))
3532                 return False;
3533
3534         if(!prs_uint32("ptr_secdesc", ps, depth, &q_n->ptr_secdesc))
3535                 return False;
3536
3537         if(!prs_uint32("size_secdesc", ps, depth, &q_n->size_secdesc))
3538                 return False;
3539
3540         if(!sec_io_desc("sec_desc", &q_n->sec_desc, ps, depth))
3541                 return False;
3542
3543         return True;
3544 }
3545
3546 /*******************************************************************
3547  Reads or writes a structure.
3548 ********************************************************************/
3549
3550 BOOL srv_io_r_net_file_set_secdesc(const char *desc, SRV_R_NET_FILE_SET_SECDESC *r_n, prs_struct *ps, int depth)
3551 {
3552         if (r_n == NULL)
3553                 return False;
3554
3555         prs_debug(ps, depth, desc, "srv_io_r_net_file_set_secdesc");
3556         depth++;
3557
3558         if(!prs_align(ps))
3559                 return False;
3560
3561         if(!prs_werror("status", ps, depth, &r_n->status))
3562                 return False;
3563
3564         return True;
3565 }
3566
3567 /*******************************************************************
3568  Inits a structure
3569 ********************************************************************/
3570
3571 void init_srv_q_net_remote_tod(SRV_Q_NET_REMOTE_TOD *q_u, const char *server)
3572 {
3573         q_u->ptr_srv_name = 1;
3574         init_unistr2(&q_u->uni_srv_name, server, UNI_STR_TERMINATE);
3575 }