source/rpc_parse/parse_dfs.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * parser auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7
   8 #undef DBGC_CLASS
   9 #define DBGC_CLASS DBGC_RPC_PARSE
  10
  11 /* netdfs structures */
  12 BOOL init_netdfs_dfs_Info0(NETDFS_DFS_INFO0 *v)
  13 {
  14         DEBUG(5,("init_netdfs_dfs_Info0\n"));
  15
  16         return True;
  17 }
  18
  19 BOOL netdfs_io_dfs_Info0_p(const char *desc, NETDFS_DFS_INFO0 *v, prs_struct *ps, int depth)
  20 {
  21         if (v == NULL)
  22                 return False;
  23
  24         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info0_p");
  25         depth++;
  26         return True;
  27 }
  28
  29 BOOL netdfs_io_dfs_Info0_d(const char *desc, NETDFS_DFS_INFO0 *v, prs_struct *ps, int depth)
  30 {
  31         if (v == NULL)
  32                 return False;
  33
  34         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info0_d");
  35         depth++;
  36         return True;
  37 }
  38
  39 BOOL init_netdfs_dfs_Info1(NETDFS_DFS_INFO1 *v, const char *path)
  40 {
  41         DEBUG(5,("init_netdfs_dfs_Info1\n"));
  42
  43         if (path) {
  44                 v->ptr0_path = 1;
  45                 init_unistr2(&v->path, path, UNI_FLAGS_NONE);
  46         } else {
  47                 v->ptr0_path = 0;
  48         }
  49
  50         return True;
  51 }
  52
  53 BOOL netdfs_io_dfs_Info1_p(const char *desc, NETDFS_DFS_INFO1 *v, prs_struct *ps, int depth)
  54 {
  55         if (v == NULL)
  56                 return False;
  57
  58         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info1_p");
  59         depth++;
  60         if (!prs_uint32("ptr0_path", ps, depth, &v->ptr0_path))
  61                 return False;
  62
  63
  64         return True;
  65 }
  66
  67 BOOL netdfs_io_dfs_Info1_d(const char *desc, NETDFS_DFS_INFO1 *v, prs_struct *ps, int depth)
  68 {
  69         if (v == NULL)
  70                 return False;
  71
  72         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info1_d");
  73         depth++;
  74         if (v->ptr0_path) {
  75                 if (!prs_align_custom(ps, 4))
  76                         return False;
  77
  78                 if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
  79                         return False;
  80         }
  81
  82         return True;
  83 }
  84
  85 BOOL init_netdfs_dfs_Info2(NETDFS_DFS_INFO2 *v, const char *path, const char *comment, uint32 state, uint32 num_stores)
  86 {
  87         DEBUG(5,("init_netdfs_dfs_Info2\n"));
  88
  89         if (path) {
  90                 v->ptr0_path = 1;
  91                 init_unistr2(&v->path, path, UNI_FLAGS_NONE);
  92         } else {
  93                 v->ptr0_path = 0;
  94         }
  95
  96         if (comment) {
  97                 v->ptr0_comment = 1;
  98                 init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
  99         } else {
 100                 v->ptr0_comment = 0;
 101         }
 102
 103         v->state = state;
 104
 105         v->num_stores = num_stores;
 106
 107         return True;
 108 }
 109
 110 BOOL netdfs_io_dfs_Info2_p(const char *desc, NETDFS_DFS_INFO2 *v, prs_struct *ps, int depth)
 111 {
 112         if (v == NULL)
 113                 return False;
 114
 115         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info2_p");
 116         depth++;
 117         if (!prs_uint32("ptr0_path", ps, depth, &v->ptr0_path))
 118                 return False;
 119
 120
 121         if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
 122                 return False;
 123
 124
 125         if (!prs_uint32("state", ps, depth, &v->state))
 126                 return False;
 127
 128         if (!prs_uint32("num_stores", ps, depth, &v->num_stores))
 129                 return False;
 130
 131         return True;
 132 }
 133
 134 BOOL netdfs_io_dfs_Info2_d(const char *desc, NETDFS_DFS_INFO2 *v, prs_struct *ps, int depth)
 135 {
 136         if (v == NULL)
 137                 return False;
 138
 139         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info2_d");
 140         depth++;
 141         if (v->ptr0_path) {
 142                 if (!prs_align_custom(ps, 4))
 143                         return False;
 144
 145                 if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
 146                         return False;
 147         }
 148
 149         if (v->ptr0_comment) {
 150                 if (!prs_align_custom(ps, 4))
 151                         return False;
 152
 153                 if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
 154                         return False;
 155         }
 156
 157
 158
 159         return True;
 160 }
 161
 162 BOOL init_netdfs_dfs_StorageInfo(NETDFS_DFS_STORAGEINFO *v, uint32 state, const char *server, const char *share)
 163 {
 164         DEBUG(5,("init_netdfs_dfs_StorageInfo\n"));
 165
 166         v->state = state;
 167
 168         if (server) {
 169                 v->ptr0_server = 1;
 170                 init_unistr2(&v->server, server, UNI_FLAGS_NONE);
 171         } else {
 172                 v->ptr0_server = 0;
 173         }
 174
 175         if (share) {
 176                 v->ptr0_share = 1;
 177                 init_unistr2(&v->share, share, UNI_FLAGS_NONE);
 178         } else {
 179                 v->ptr0_share = 0;
 180         }
 181
 182         return True;
 183 }
 184
 185 BOOL netdfs_io_dfs_StorageInfo_p(const char *desc, NETDFS_DFS_STORAGEINFO *v, prs_struct *ps, int depth)
 186 {
 187         if (v == NULL)
 188                 return False;
 189
 190         prs_debug(ps, depth, desc, "netdfs_io_dfs_StorageInfo_p");
 191         depth++;
 192         if (!prs_uint32("state", ps, depth, &v->state))
 193                 return False;
 194
 195         if (!prs_uint32("ptr0_server", ps, depth, &v->ptr0_server))
 196                 return False;
 197
 198
 199         if (!prs_uint32("ptr0_share", ps, depth, &v->ptr0_share))
 200                 return False;
 201
 202
 203         return True;
 204 }
 205
 206 BOOL netdfs_io_dfs_StorageInfo_d(const char *desc, NETDFS_DFS_STORAGEINFO *v, prs_struct *ps, int depth)
 207 {
 208         if (v == NULL)
 209                 return False;
 210
 211         prs_debug(ps, depth, desc, "netdfs_io_dfs_StorageInfo_d");
 212         depth++;
 213
 214         if (v->ptr0_server) {
 215                 if (!prs_align_custom(ps, 4))
 216                         return False;
 217
 218                 if (!smb_io_unistr2("server", &v->server, 1, ps, depth))
 219                         return False;
 220         }
 221
 222         if (v->ptr0_share) {
 223                 if (!prs_align_custom(ps, 4))
 224                         return False;
 225
 226                 if (!smb_io_unistr2("share", &v->share, 1, ps, depth))
 227                         return False;
 228         }
 229
 230         return True;
 231 }
 232
 233 BOOL init_netdfs_dfs_Info3(NETDFS_DFS_INFO3 *v, const char *path, const char *comment, uint32 state, uint32 num_stores, NETDFS_DFS_STORAGEINFO **stores)
 234 {
 235         DEBUG(5,("init_netdfs_dfs_Info3\n"));
 236
 237         if (path) {
 238                 v->ptr0_path = 1;
 239                 init_unistr2(&v->path, path, UNI_FLAGS_NONE);
 240         } else {
 241                 v->ptr0_path = 0;
 242         }
 243
 244         if (comment) {
 245                 v->ptr0_comment = 1;
 246                 init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
 247         } else {
 248                 v->ptr0_comment = 0;
 249         }
 250
 251         v->state = state;
 252
 253         v->num_stores = num_stores;
 254
 255         if (stores) {
 256                 v->ptr0_stores = 1;
 257                 v->stores = *stores;
 258         } else {
 259                 v->ptr0_stores = 0;
 260         }
 261
 262         return True;
 263 }
 264
 265 BOOL netdfs_io_dfs_Info3_p(const char *desc, NETDFS_DFS_INFO3 *v, prs_struct *ps, int depth)
 266 {
 267         if (v == NULL)
 268                 return False;
 269
 270         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info3_p");
 271         depth++;
 272         if (!prs_uint32("ptr0_path", ps, depth, &v->ptr0_path))
 273                 return False;
 274
 275
 276         if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
 277                 return False;
 278
 279
 280         if (!prs_uint32("state", ps, depth, &v->state))
 281                 return False;
 282
 283         if (!prs_uint32("num_stores", ps, depth, &v->num_stores))
 284                 return False;
 285
 286         if (!prs_uint32("ptr0_stores", ps, depth, &v->ptr0_stores))
 287                 return False;
 288
 289
 290         return True;
 291 }
 292
 293 BOOL netdfs_io_dfs_Info3_d(const char *desc, NETDFS_DFS_INFO3 *v, prs_struct *ps, int depth)
 294 {
 295         uint32 i_stores_1;
 296
 297         if (v == NULL)
 298                 return False;
 299
 300         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info3_d");
 301         depth++;
 302         if (v->ptr0_path) {
 303                 if (!prs_align_custom(ps, 4))
 304                         return False;
 305
 306                 if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
 307                         return False;
 308         }
 309
 310         if (v->ptr0_comment) {
 311                 if (!prs_align_custom(ps, 4))
 312                         return False;
 313
 314                 if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
 315                         return False;
 316         }
 317
 318
 319
 320         if (v->ptr0_stores) {
 321                 if (!prs_align_custom(ps, 4))
 322                         return False;
 323
 324                 if (!prs_uint32("size_stores", ps, depth, &v->size_stores))
 325                         return False;
 326
 327                 if (UNMARSHALLING(ps)) {
 328                         if (v->num_stores) {
 329                                 v->stores = PRS_ALLOC_MEM(ps,NETDFS_DFS_STORAGEINFO,v->num_stores);
 330                                 if (!v->stores) {
 331                                         return False;
 332                                 }
 333                         } else {
 334                                 v->stores = NULL;
 335                         }
 336                 }
 337                 for (i_stores_1=0; i_stores_1<v->num_stores;i_stores_1++) {
 338                         if (!netdfs_io_dfs_StorageInfo_p("stores", &v->stores[i_stores_1], ps, depth))
 339                                 return False;
 340                 }
 341                 for (i_stores_1=0; i_stores_1<v->num_stores;i_stores_1++) {
 342                         if (!netdfs_io_dfs_StorageInfo_d("stores", &v->stores[i_stores_1], ps, depth))
 343                                 return False;
 344                 }
 345         }
 346
 347         return True;
 348 }
 349
 350 BOOL init_netdfs_dfs_Info4(NETDFS_DFS_INFO4 *v, const char *path, const char *comment, uint32 state, uint32 timeout, struct GUID guid, uint32 num_stores, NETDFS_DFS_STORAGEINFO **stores)
 351 {
 352         DEBUG(5,("init_netdfs_dfs_Info4\n"));
 353
 354         if (path) {
 355                 v->ptr0_path = 1;
 356                 init_unistr2(&v->path, path, UNI_FLAGS_NONE);
 357         } else {
 358                 v->ptr0_path = 0;
 359         }
 360
 361         if (comment) {
 362                 v->ptr0_comment = 1;
 363                 init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
 364         } else {
 365                 v->ptr0_comment = 0;
 366         }
 367
 368         v->state = state;
 369
 370         v->timeout = timeout;
 371
 372
 373
 374         v->num_stores = num_stores;
 375
 376         if (stores) {
 377                 v->ptr0_stores = 1;
 378                 v->stores = *stores;
 379         } else {
 380                 v->ptr0_stores = 0;
 381         }
 382
 383         return True;
 384 }
 385
 386 BOOL netdfs_io_dfs_Info4_p(const char *desc, NETDFS_DFS_INFO4 *v, prs_struct *ps, int depth)
 387 {
 388         if (v == NULL)
 389                 return False;
 390
 391         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info4_p");
 392         depth++;
 393         if (!prs_uint32("ptr0_path", ps, depth, &v->ptr0_path))
 394                 return False;
 395
 396
 397         if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
 398                 return False;
 399
 400
 401         if (!prs_uint32("state", ps, depth, &v->state))
 402                 return False;
 403
 404         if (!prs_uint32("timeout", ps, depth, &v->timeout))
 405                 return False;
 406
 407         if (!smb_io_uuid("guid", &v->guid, ps, depth))
 408                 return False;
 409
 410         if (!prs_uint32("num_stores", ps, depth, &v->num_stores))
 411                 return False;
 412
 413         if (!prs_uint32("ptr0_stores", ps, depth, &v->ptr0_stores))
 414                 return False;
 415
 416
 417         return True;
 418 }
 419
 420 BOOL netdfs_io_dfs_Info4_d(const char *desc, NETDFS_DFS_INFO4 *v, prs_struct *ps, int depth)
 421 {
 422         uint32 i_stores_1;
 423
 424         if (v == NULL)
 425                 return False;
 426
 427         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info4_d");
 428         depth++;
 429         if (v->ptr0_path) {
 430                 if (!prs_align_custom(ps, 4))
 431                         return False;
 432
 433                 if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
 434                         return False;
 435         }
 436
 437         if (v->ptr0_comment) {
 438                 if (!prs_align_custom(ps, 4))
 439                         return False;
 440
 441                 if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
 442                         return False;
 443         }
 444
 445
 446
 447
 448
 449         if (v->ptr0_stores) {
 450                 if (!prs_align_custom(ps, 4))
 451                         return False;
 452
 453                 if (!prs_uint32("size_stores", ps, depth, &v->size_stores))
 454                         return False;
 455
 456                 if (UNMARSHALLING(ps)) {
 457                         if (v->num_stores) {
 458                                 v->stores = PRS_ALLOC_MEM(ps,NETDFS_DFS_STORAGEINFO,v->num_stores);
 459                                 if (!v->stores) {
 460                                         return False;
 461                                 }
 462                         } else {
 463                                 v->stores = NULL;
 464                         }
 465                 }
 466                 for (i_stores_1=0; i_stores_1<v->num_stores;i_stores_1++) {
 467                         if (!netdfs_io_dfs_StorageInfo_p("stores", &v->stores[i_stores_1], ps, depth))
 468                                 return False;
 469                 }
 470                 for (i_stores_1=0; i_stores_1<v->num_stores;i_stores_1++) {
 471                         if (!netdfs_io_dfs_StorageInfo_d("stores", &v->stores[i_stores_1], ps, depth))
 472                                 return False;
 473                 }
 474         }
 475
 476         return True;
 477 }
 478
 479 BOOL init_netdfs_dfs_Info100(NETDFS_DFS_INFO100 *v, const char *comment)
 480 {
 481         DEBUG(5,("init_netdfs_dfs_Info100\n"));
 482
 483         if (comment) {
 484                 v->ptr0_comment = 1;
 485                 init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
 486         } else {
 487                 v->ptr0_comment = 0;
 488         }
 489
 490         return True;
 491 }
 492
 493 BOOL netdfs_io_dfs_Info100_p(const char *desc, NETDFS_DFS_INFO100 *v, prs_struct *ps, int depth)
 494 {
 495         if (v == NULL)
 496                 return False;
 497
 498         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info100_p");
 499         depth++;
 500         if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
 501                 return False;
 502
 503
 504         return True;
 505 }
 506
 507 BOOL netdfs_io_dfs_Info100_d(const char *desc, NETDFS_DFS_INFO100 *v, prs_struct *ps, int depth)
 508 {
 509         if (v == NULL)
 510                 return False;
 511
 512         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info100_d");
 513         depth++;
 514         if (v->ptr0_comment) {
 515                 if (!prs_align_custom(ps, 4))
 516                         return False;
 517
 518                 if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
 519                         return False;
 520         }
 521
 522         return True;
 523 }
 524
 525 BOOL init_netdfs_dfs_Info101(NETDFS_DFS_INFO101 *v, uint32 state)
 526 {
 527         DEBUG(5,("init_netdfs_dfs_Info101\n"));
 528
 529         v->state = state;
 530
 531         return True;
 532 }
 533
 534 BOOL netdfs_io_dfs_Info101_p(const char *desc, NETDFS_DFS_INFO101 *v, prs_struct *ps, int depth)
 535 {
 536         if (v == NULL)
 537                 return False;
 538
 539         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info101_p");
 540         depth++;
 541         if (!prs_uint32("state", ps, depth, &v->state))
 542                 return False;
 543
 544         return True;
 545 }
 546
 547 BOOL netdfs_io_dfs_Info101_d(const char *desc, NETDFS_DFS_INFO101 *v, prs_struct *ps, int depth)
 548 {
 549         if (v == NULL)
 550                 return False;
 551
 552         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info101_d");
 553         depth++;
 554
 555         return True;
 556 }
 557
 558 BOOL init_netdfs_dfs_Info102(NETDFS_DFS_INFO102 *v, uint32 timeout)
 559 {
 560         DEBUG(5,("init_netdfs_dfs_Info102\n"));
 561
 562         v->timeout = timeout;
 563
 564         return True;
 565 }
 566
 567 BOOL netdfs_io_dfs_Info102_p(const char *desc, NETDFS_DFS_INFO102 *v, prs_struct *ps, int depth)
 568 {
 569         if (v == NULL)
 570                 return False;
 571
 572         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info102_p");
 573         depth++;
 574         if (!prs_uint32("timeout", ps, depth, &v->timeout))
 575                 return False;
 576
 577         return True;
 578 }
 579
 580 BOOL netdfs_io_dfs_Info102_d(const char *desc, NETDFS_DFS_INFO102 *v, prs_struct *ps, int depth)
 581 {
 582         if (v == NULL)
 583                 return False;
 584
 585         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info102_d");
 586         depth++;
 587
 588         return True;
 589 }
 590
 591 BOOL init_netdfs_dfs_Info200(NETDFS_DFS_INFO200 *v, const char *dom_root)
 592 {
 593         DEBUG(5,("init_netdfs_dfs_Info200\n"));
 594
 595         if (dom_root) {
 596                 v->ptr0_dom_root = 1;
 597                 init_unistr2(&v->dom_root, dom_root, UNI_FLAGS_NONE);
 598         } else {
 599                 v->ptr0_dom_root = 0;
 600         }
 601
 602         return True;
 603 }
 604
 605 BOOL netdfs_io_dfs_Info200_p(const char *desc, NETDFS_DFS_INFO200 *v, prs_struct *ps, int depth)
 606 {
 607         if (v == NULL)
 608                 return False;
 609
 610         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info200_p");
 611         depth++;
 612         if (!prs_uint32("ptr0_dom_root", ps, depth, &v->ptr0_dom_root))
 613                 return False;
 614
 615
 616         return True;
 617 }
 618
 619 BOOL netdfs_io_dfs_Info200_d(const char *desc, NETDFS_DFS_INFO200 *v, prs_struct *ps, int depth)
 620 {
 621         if (v == NULL)
 622                 return False;
 623
 624         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info200_d");
 625         depth++;
 626         if (v->ptr0_dom_root) {
 627                 if (!prs_align_custom(ps, 4))
 628                         return False;
 629
 630                 if (!smb_io_unistr2("dom_root", &v->dom_root, 1, ps, depth))
 631                         return False;
 632         }
 633
 634         return True;
 635 }
 636
 637 BOOL init_netdfs_dfs_Info300(NETDFS_DFS_INFO300 *v, uint32 flags, const char *dom_root)
 638 {
 639         DEBUG(5,("init_netdfs_dfs_Info300\n"));
 640
 641         v->flags = flags;
 642
 643         if (dom_root) {
 644                 v->ptr0_dom_root = 1;
 645                 init_unistr2(&v->dom_root, dom_root, UNI_FLAGS_NONE);
 646         } else {
 647                 v->ptr0_dom_root = 0;
 648         }
 649
 650         return True;
 651 }
 652
 653 BOOL netdfs_io_dfs_Info300_p(const char *desc, NETDFS_DFS_INFO300 *v, prs_struct *ps, int depth)
 654 {
 655         if (v == NULL)
 656                 return False;
 657
 658         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info300_p");
 659         depth++;
 660         if (!prs_uint32("flags", ps, depth, &v->flags))
 661                 return False;
 662
 663         if (!prs_uint32("ptr0_dom_root", ps, depth, &v->ptr0_dom_root))
 664                 return False;
 665
 666
 667         return True;
 668 }
 669
 670 BOOL netdfs_io_dfs_Info300_d(const char *desc, NETDFS_DFS_INFO300 *v, prs_struct *ps, int depth)
 671 {
 672         if (v == NULL)
 673                 return False;
 674
 675         prs_debug(ps, depth, desc, "netdfs_io_dfs_Info300_d");
 676         depth++;
 677
 678         if (v->ptr0_dom_root) {
 679                 if (!prs_align_custom(ps, 4))
 680                         return False;
 681
 682                 if (!smb_io_unistr2("dom_root", &v->dom_root, 1, ps, depth))
 683                         return False;
 684         }
 685
 686         return True;
 687 }
 688
 689 BOOL netdfs_io_dfs_Info_p(const char *desc, NETDFS_DFS_INFO_CTR* v, prs_struct *ps, int depth)
 690 {
 691         if (!prs_uint32("switch_value", ps, depth, &v->switch_value))
 692                 return False;
 693
 694         switch (v->switch_value) {
 695                 case 0:
 696                         depth++;
 697                         if (!prs_uint32("ptr0_info0", ps, depth, &v->ptr0))
 698                                 return False;
 699
 700                         depth--;
 701                         break;
 702
 703                 case 1:
 704                         depth++;
 705                         if (!prs_uint32("ptr0_info1", ps, depth, &v->ptr0))
 706                                 return False;
 707
 708                         depth--;
 709                         break;
 710
 711                 case 2:
 712                         depth++;
 713                         if (!prs_uint32("ptr0_info2", ps, depth, &v->ptr0))
 714                                 return False;
 715
 716                         depth--;
 717                         break;
 718
 719                 case 3:
 720                         depth++;
 721                         if (!prs_uint32("ptr0_info3", ps, depth, &v->ptr0))
 722                                 return False;
 723
 724                         depth--;
 725                         break;
 726
 727                 case 4:
 728                         depth++;
 729                         if (!prs_uint32("ptr0_info4", ps, depth, &v->ptr0))
 730                                 return False;
 731
 732                         depth--;
 733                         break;
 734
 735                 case 100:
 736                         depth++;
 737                         if (!prs_uint32("ptr0_info100", ps, depth, &v->ptr0))
 738                                 return False;
 739
 740                         depth--;
 741                         break;
 742
 743                 case 101:
 744                         depth++;
 745                         if (!prs_uint32("ptr0_info101", ps, depth, &v->ptr0))
 746                                 return False;
 747
 748                         depth--;
 749                         break;
 750
 751                 case 102:
 752                         depth++;
 753                         if (!prs_uint32("ptr0_info102", ps, depth, &v->ptr0))
 754                                 return False;
 755
 756                         depth--;
 757                         break;
 758
 759                 default:
 760                         return False;
 761
 762         }
 763
 764         return True;
 765 }
 766
 767 BOOL netdfs_io_dfs_Info_d(const char *desc, NETDFS_DFS_INFO_CTR* v, prs_struct *ps, int depth)
 768 {
 769         switch (v->switch_value) {
 770                 case 0:
 771                         depth++;
 772                         if (v->ptr0) {
 773                                 if (!prs_align_custom(ps, 1))
 774                                         return False;
 775
 776                                 if (!netdfs_io_dfs_Info0_p("info0", &v->u.info0, ps, depth))
 777                                         return False;
 778                                 if (!netdfs_io_dfs_Info0_d("info0", &v->u.info0, ps, depth))
 779                                         return False;
 780                         }
 781                         depth--;
 782                         break;
 783
 784                 case 1:
 785                         depth++;
 786                         if (v->ptr0) {
 787                                 if (!prs_align_custom(ps, 4))
 788                                         return False;
 789
 790                                 if (!netdfs_io_dfs_Info1_p("info1", &v->u.info1, ps, depth))
 791                                         return False;
 792                                 if (!netdfs_io_dfs_Info1_d("info1", &v->u.info1, ps, depth))
 793                                         return False;
 794                         }
 795                         depth--;
 796                         break;
 797
 798                 case 2:
 799                         depth++;
 800                         if (v->ptr0) {
 801                                 if (!prs_align_custom(ps, 4))
 802                                         return False;
 803
 804                                 if (!netdfs_io_dfs_Info2_p("info2", &v->u.info2, ps, depth))
 805                                         return False;
 806                                 if (!netdfs_io_dfs_Info2_d("info2", &v->u.info2, ps, depth))
 807                                         return False;
 808                         }
 809                         depth--;
 810                         break;
 811
 812                 case 3:
 813                         depth++;
 814                         if (v->ptr0) {
 815                                 if (!prs_align_custom(ps, 4))
 816                                         return False;
 817
 818                                 if (!netdfs_io_dfs_Info3_p("info3", &v->u.info3, ps, depth))
 819                                         return False;
 820                                 if (!netdfs_io_dfs_Info3_d("info3", &v->u.info3, ps, depth))
 821                                         return False;
 822                         }
 823                         depth--;
 824                         break;
 825
 826                 case 4:
 827                         depth++;
 828                         if (v->ptr0) {
 829                                 if (!prs_align_custom(ps, 4))
 830                                         return False;
 831
 832                                 if (!netdfs_io_dfs_Info4_p("info4", &v->u.info4, ps, depth))
 833                                         return False;
 834                                 if (!netdfs_io_dfs_Info4_d("info4", &v->u.info4, ps, depth))
 835                                         return False;
 836                         }
 837                         depth--;
 838                         break;
 839
 840                 case 100:
 841                         depth++;
 842                         if (v->ptr0) {
 843                                 if (!prs_align_custom(ps, 4))
 844                                         return False;
 845
 846                                 if (!netdfs_io_dfs_Info100_p("info100", &v->u.info100, ps, depth))
 847                                         return False;
 848                                 if (!netdfs_io_dfs_Info100_d("info100", &v->u.info100, ps, depth))
 849                                         return False;
 850                         }
 851                         depth--;
 852                         break;
 853
 854                 case 101:
 855                         depth++;
 856                         if (v->ptr0) {
 857                                 if (!prs_align_custom(ps, 4))
 858                                         return False;
 859
 860                                 if (!netdfs_io_dfs_Info101_p("info101", &v->u.info101, ps, depth))
 861                                         return False;
 862                                 if (!netdfs_io_dfs_Info101_d("info101", &v->u.info101, ps, depth))
 863                                         return False;
 864                         }
 865                         depth--;
 866                         break;
 867
 868                 case 102:
 869                         depth++;
 870                         if (v->ptr0) {
 871                                 if (!prs_align_custom(ps, 4))
 872                                         return False;
 873
 874                                 if (!netdfs_io_dfs_Info102_p("info102", &v->u.info102, ps, depth))
 875                                         return False;
 876                                 if (!netdfs_io_dfs_Info102_d("info102", &v->u.info102, ps, depth))
 877                                         return False;
 878                         }
 879                         depth--;
 880                         break;
 881
 882         }
 883
 884         return True;
 885 }
 886 BOOL init_netdfs_dfs_EnumArray1(NETDFS_DFS_ENUMARRAY1 *v, uint32 count, NETDFS_DFS_INFO1 **s)
 887 {
 888         DEBUG(5,("init_netdfs_dfs_EnumArray1\n"));
 889
 890         v->count = count;
 891
 892         if (s) {
 893                 v->ptr0_s = 1;
 894                 v->s = *s;
 895         } else {
 896                 v->ptr0_s = 0;
 897         }
 898
 899         return True;
 900 }
 901
 902 BOOL netdfs_io_dfs_EnumArray1_p(const char *desc, NETDFS_DFS_ENUMARRAY1 *v, prs_struct *ps, int depth)
 903 {
 904         if (v == NULL)
 905                 return False;
 906
 907         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray1_p");
 908         depth++;
 909         if (!prs_uint32("count", ps, depth, &v->count))
 910                 return False;
 911
 912         if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
 913                 return False;
 914
 915
 916         return True;
 917 }
 918
 919 BOOL netdfs_io_dfs_EnumArray1_d(const char *desc, NETDFS_DFS_ENUMARRAY1 *v, prs_struct *ps, int depth)
 920 {
 921         uint32 i_s_1;
 922
 923         if (v == NULL)
 924                 return False;
 925
 926         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray1_d");
 927         depth++;
 928
 929         if (v->ptr0_s) {
 930                 if (!prs_align_custom(ps, 4))
 931                         return False;
 932
 933                 if (!prs_uint32("size_s", ps, depth, &v->size_s))
 934                         return False;
 935
 936                 if (UNMARSHALLING(ps)) {
 937                         if (v->count) {
 938                                 v->s = PRS_ALLOC_MEM(ps,NETDFS_DFS_INFO1,v->count);
 939                                 if (!v->s) {
 940                                         return False;
 941                                 }
 942                         } else {
 943                                 v->s = NULL;
 944                         }
 945                 }
 946                 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 947                         if (!netdfs_io_dfs_Info1_p("s", &v->s[i_s_1], ps, depth))
 948                                 return False;
 949                 }
 950                 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
 951                         if (!netdfs_io_dfs_Info1_d("s", &v->s[i_s_1], ps, depth))
 952                                 return False;
 953                 }
 954         }
 955
 956         return True;
 957 }
 958
 959 BOOL init_netdfs_dfs_EnumArray2(NETDFS_DFS_ENUMARRAY2 *v, uint32 count, NETDFS_DFS_INFO2 **s)
 960 {
 961         DEBUG(5,("init_netdfs_dfs_EnumArray2\n"));
 962
 963         v->count = count;
 964
 965         if (s) {
 966                 v->ptr0_s = 1;
 967                 v->s = *s;
 968         } else {
 969                 v->ptr0_s = 0;
 970         }
 971
 972         return True;
 973 }
 974
 975 BOOL netdfs_io_dfs_EnumArray2_p(const char *desc, NETDFS_DFS_ENUMARRAY2 *v, prs_struct *ps, int depth)
 976 {
 977         if (v == NULL)
 978                 return False;
 979
 980         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray2_p");
 981         depth++;
 982         if (!prs_uint32("count", ps, depth, &v->count))
 983                 return False;
 984
 985         if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
 986                 return False;
 987
 988
 989         return True;
 990 }
 991
 992 BOOL netdfs_io_dfs_EnumArray2_d(const char *desc, NETDFS_DFS_ENUMARRAY2 *v, prs_struct *ps, int depth)
 993 {
 994         uint32 i_s_1;
 995
 996         if (v == NULL)
 997                 return False;
 998
 999         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray2_d");
1000         depth++;
1001
1002         if (v->ptr0_s) {
1003                 if (!prs_align_custom(ps, 4))
1004                         return False;
1005
1006                 if (!prs_uint32("size_s", ps, depth, &v->size_s))
1007                         return False;
1008
1009                 if (UNMARSHALLING(ps)) {
1010                         if (v->count) {
1011                                 v->s = PRS_ALLOC_MEM(ps,NETDFS_DFS_INFO2,v->count);
1012                                 if (!v->s) {
1013                                         return False;
1014                                 }
1015                         } else {
1016                                 v->s = NULL;
1017                         }
1018                 }
1019                 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
1020                         if (!netdfs_io_dfs_Info2_p("s", &v->s[i_s_1], ps, depth))
1021                                 return False;
1022                 }
1023                 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
1024                         if (!netdfs_io_dfs_Info2_d("s", &v->s[i_s_1], ps, depth))
1025                                 return False;
1026                 }
1027         }
1028
1029         return True;
1030 }
1031
1032 BOOL init_netdfs_dfs_EnumArray3(NETDFS_DFS_ENUMARRAY3 *v, uint32 count, NETDFS_DFS_INFO3 **s)
1033 {
1034         DEBUG(5,("init_netdfs_dfs_EnumArray3\n"));
1035
1036         v->count = count;
1037
1038         if (s) {
1039                 v->ptr0_s = 1;
1040                 v->s = *s;
1041         } else {
1042                 v->ptr0_s = 0;
1043         }
1044
1045         return True;
1046 }
1047
1048 BOOL netdfs_io_dfs_EnumArray3_p(const char *desc, NETDFS_DFS_ENUMARRAY3 *v, prs_struct *ps, int depth)
1049 {
1050         if (v == NULL)
1051                 return False;
1052
1053         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray3_p");
1054         depth++;
1055         if (!prs_uint32("count", ps, depth, &v->count))
1056                 return False;
1057
1058         if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
1059                 return False;
1060
1061
1062         return True;
1063 }
1064
1065 BOOL netdfs_io_dfs_EnumArray3_d(const char *desc, NETDFS_DFS_ENUMARRAY3 *v, prs_struct *ps, int depth)
1066 {
1067         uint32 i_s_1;
1068
1069         if (v == NULL)
1070                 return False;
1071
1072         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray3_d");
1073         depth++;
1074
1075         if (v->ptr0_s) {
1076                 if (!prs_align_custom(ps, 4))
1077                         return False;
1078
1079                 if (!prs_uint32("size_s", ps, depth, &v->size_s))
1080                         return False;
1081
1082                 if (UNMARSHALLING(ps)) {
1083                         if (v->count) {
1084                                 v->s = PRS_ALLOC_MEM(ps,NETDFS_DFS_INFO3,v->count);
1085                                 if (!v->s) {
1086                                         return False;
1087                                 }
1088                         } else {
1089                                 v->s = NULL;
1090                         }
1091                 }
1092                 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
1093                         if (!netdfs_io_dfs_Info3_p("s", &v->s[i_s_1], ps, depth))
1094                                 return False;
1095                 }
1096                 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
1097                         if (!netdfs_io_dfs_Info3_d("s", &v->s[i_s_1], ps, depth))
1098                                 return False;
1099                 }
1100         }
1101
1102         return True;
1103 }
1104
1105 BOOL init_netdfs_dfs_EnumArray4(NETDFS_DFS_ENUMARRAY4 *v, uint32 count, NETDFS_DFS_INFO4 **s)
1106 {
1107         DEBUG(5,("init_netdfs_dfs_EnumArray4\n"));
1108
1109         v->count = count;
1110
1111         if (s) {
1112                 v->ptr0_s = 1;
1113                 v->s = *s;
1114         } else {
1115                 v->ptr0_s = 0;
1116         }
1117
1118         return True;
1119 }
1120
1121 BOOL netdfs_io_dfs_EnumArray4_p(const char *desc, NETDFS_DFS_ENUMARRAY4 *v, prs_struct *ps, int depth)
1122 {
1123         if (v == NULL)
1124                 return False;
1125
1126         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray4_p");
1127         depth++;
1128         if (!prs_uint32("count", ps, depth, &v->count))
1129                 return False;
1130
1131         if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
1132                 return False;
1133
1134
1135         return True;
1136 }
1137
1138 BOOL netdfs_io_dfs_EnumArray4_d(const char *desc, NETDFS_DFS_ENUMARRAY4 *v, prs_struct *ps, int depth)
1139 {
1140         uint32 i_s_1;
1141
1142         if (v == NULL)
1143                 return False;
1144
1145         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray4_d");
1146         depth++;
1147
1148         if (v->ptr0_s) {
1149                 if (!prs_align_custom(ps, 4))
1150                         return False;
1151
1152                 if (!prs_uint32("size_s", ps, depth, &v->size_s))
1153                         return False;
1154
1155                 if (UNMARSHALLING(ps)) {
1156                         if (v->count) {
1157                                 v->s = PRS_ALLOC_MEM(ps,NETDFS_DFS_INFO4,v->count);
1158                                 if (!v->s) {
1159                                         return False;
1160                                 }
1161                         } else {
1162                                 v->s = NULL;
1163                         }
1164                 }
1165                 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
1166                         if (!netdfs_io_dfs_Info4_p("s", &v->s[i_s_1], ps, depth))
1167                                 return False;
1168                 }
1169                 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
1170                         if (!netdfs_io_dfs_Info4_d("s", &v->s[i_s_1], ps, depth))
1171                                 return False;
1172                 }
1173         }
1174
1175         return True;
1176 }
1177
1178 BOOL init_netdfs_dfs_EnumArray200(NETDFS_DFS_ENUMARRAY200 *v, uint32 count, NETDFS_DFS_INFO200 **s)
1179 {
1180         DEBUG(5,("init_netdfs_dfs_EnumArray200\n"));
1181
1182         v->count = count;
1183
1184         if (s) {
1185                 v->ptr0_s = 1;
1186                 v->s = *s;
1187         } else {
1188                 v->ptr0_s = 0;
1189         }
1190
1191         return True;
1192 }
1193
1194 BOOL netdfs_io_dfs_EnumArray200_p(const char *desc, NETDFS_DFS_ENUMARRAY200 *v, prs_struct *ps, int depth)
1195 {
1196         if (v == NULL)
1197                 return False;
1198
1199         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray200_p");
1200         depth++;
1201         if (!prs_uint32("count", ps, depth, &v->count))
1202                 return False;
1203
1204         if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
1205                 return False;
1206
1207
1208         return True;
1209 }
1210
1211 BOOL netdfs_io_dfs_EnumArray200_d(const char *desc, NETDFS_DFS_ENUMARRAY200 *v, prs_struct *ps, int depth)
1212 {
1213         uint32 i_s_1;
1214
1215         if (v == NULL)
1216                 return False;
1217
1218         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray200_d");
1219         depth++;
1220
1221         if (v->ptr0_s) {
1222                 if (!prs_align_custom(ps, 4))
1223                         return False;
1224
1225                 if (!prs_uint32("size_s", ps, depth, &v->size_s))
1226                         return False;
1227
1228                 if (UNMARSHALLING(ps)) {
1229                         if (v->count) {
1230                                 v->s = PRS_ALLOC_MEM(ps,NETDFS_DFS_INFO200,v->count);
1231                                 if (!v->s) {
1232                                         return False;
1233                                 }
1234                         } else {
1235                                 v->s = NULL;
1236                         }
1237                 }
1238                 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
1239                         if (!netdfs_io_dfs_Info200_p("s", &v->s[i_s_1], ps, depth))
1240                                 return False;
1241                 }
1242                 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
1243                         if (!netdfs_io_dfs_Info200_d("s", &v->s[i_s_1], ps, depth))
1244                                 return False;
1245                 }
1246         }
1247
1248         return True;
1249 }
1250
1251 BOOL init_netdfs_dfs_EnumArray300(NETDFS_DFS_ENUMARRAY300 *v, uint32 count, NETDFS_DFS_INFO300 **s)
1252 {
1253         DEBUG(5,("init_netdfs_dfs_EnumArray300\n"));
1254
1255         v->count = count;
1256
1257         if (s) {
1258                 v->ptr0_s = 1;
1259                 v->s = *s;
1260         } else {
1261                 v->ptr0_s = 0;
1262         }
1263
1264         return True;
1265 }
1266
1267 BOOL netdfs_io_dfs_EnumArray300_p(const char *desc, NETDFS_DFS_ENUMARRAY300 *v, prs_struct *ps, int depth)
1268 {
1269         if (v == NULL)
1270                 return False;
1271
1272         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray300_p");
1273         depth++;
1274         if (!prs_uint32("count", ps, depth, &v->count))
1275                 return False;
1276
1277         if (!prs_uint32("ptr0_s", ps, depth, &v->ptr0_s))
1278                 return False;
1279
1280
1281         return True;
1282 }
1283
1284 BOOL netdfs_io_dfs_EnumArray300_d(const char *desc, NETDFS_DFS_ENUMARRAY300 *v, prs_struct *ps, int depth)
1285 {
1286         uint32 i_s_1;
1287
1288         if (v == NULL)
1289                 return False;
1290
1291         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumArray300_d");
1292         depth++;
1293
1294         if (v->ptr0_s) {
1295                 if (!prs_align_custom(ps, 4))
1296                         return False;
1297
1298                 if (!prs_uint32("size_s", ps, depth, &v->size_s))
1299                         return False;
1300
1301                 if (UNMARSHALLING(ps)) {
1302                         if (v->count) {
1303                                 v->s = PRS_ALLOC_MEM(ps,NETDFS_DFS_INFO300,v->count);
1304                                 if (!v->s) {
1305                                         return False;
1306                                 }
1307                         } else {
1308                                 v->s = NULL;
1309                         }
1310                 }
1311                 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
1312                         if (!netdfs_io_dfs_Info300_p("s", &v->s[i_s_1], ps, depth))
1313                                 return False;
1314                 }
1315                 for (i_s_1=0; i_s_1<v->count;i_s_1++) {
1316                         if (!netdfs_io_dfs_Info300_d("s", &v->s[i_s_1], ps, depth))
1317                                 return False;
1318                 }
1319         }
1320
1321         return True;
1322 }
1323
1324 BOOL netdfs_io_dfs_EnumInfo_p(const char *desc, NETDFS_DFS_ENUMINFO_CTR* v, prs_struct *ps, int depth)
1325 {
1326         if (!prs_uint32("switch_value", ps, depth, &v->switch_value))
1327                 return False;
1328
1329         switch (v->switch_value) {
1330                 case 1:
1331                         depth++;
1332                         if (!prs_uint32("ptr0_info1", ps, depth, &v->ptr0))
1333                                 return False;
1334
1335                         depth--;
1336                         break;
1337
1338                 case 2:
1339                         depth++;
1340                         if (!prs_uint32("ptr0_info2", ps, depth, &v->ptr0))
1341                                 return False;
1342
1343                         depth--;
1344                         break;
1345
1346                 case 3:
1347                         depth++;
1348                         if (!prs_uint32("ptr0_info3", ps, depth, &v->ptr0))
1349                                 return False;
1350
1351                         depth--;
1352                         break;
1353
1354                 case 4:
1355                         depth++;
1356                         if (!prs_uint32("ptr0_info4", ps, depth, &v->ptr0))
1357                                 return False;
1358
1359                         depth--;
1360                         break;
1361
1362                 case 200:
1363                         depth++;
1364                         if (!prs_uint32("ptr0_info200", ps, depth, &v->ptr0))
1365                                 return False;
1366
1367                         depth--;
1368                         break;
1369
1370                 case 300:
1371                         depth++;
1372                         if (!prs_uint32("ptr0_info300", ps, depth, &v->ptr0))
1373                                 return False;
1374
1375                         depth--;
1376                         break;
1377
1378                 default:
1379                         return False;
1380
1381         }
1382
1383         return True;
1384 }
1385
1386 BOOL netdfs_io_dfs_EnumInfo_d(const char *desc, NETDFS_DFS_ENUMINFO_CTR* v, prs_struct *ps, int depth)
1387 {
1388         switch (v->switch_value) {
1389                 case 1:
1390                         depth++;
1391                         if (v->ptr0) {
1392                                 if (!prs_align_custom(ps, 4))
1393                                         return False;
1394
1395                                 if (!netdfs_io_dfs_EnumArray1_p("info1", &v->u.info1, ps, depth))
1396                                         return False;
1397                                 if (!netdfs_io_dfs_EnumArray1_d("info1", &v->u.info1, ps, depth))
1398                                         return False;
1399                         }
1400                         depth--;
1401                         break;
1402
1403                 case 2:
1404                         depth++;
1405                         if (v->ptr0) {
1406                                 if (!prs_align_custom(ps, 4))
1407                                         return False;
1408
1409                                 if (!netdfs_io_dfs_EnumArray2_p("info2", &v->u.info2, ps, depth))
1410                                         return False;
1411                                 if (!netdfs_io_dfs_EnumArray2_d("info2", &v->u.info2, ps, depth))
1412                                         return False;
1413                         }
1414                         depth--;
1415                         break;
1416
1417                 case 3:
1418                         depth++;
1419                         if (v->ptr0) {
1420                                 if (!prs_align_custom(ps, 4))
1421                                         return False;
1422
1423                                 if (!netdfs_io_dfs_EnumArray3_p("info3", &v->u.info3, ps, depth))
1424                                         return False;
1425                                 if (!netdfs_io_dfs_EnumArray3_d("info3", &v->u.info3, ps, depth))
1426                                         return False;
1427                         }
1428                         depth--;
1429                         break;
1430
1431                 case 4:
1432                         depth++;
1433                         if (v->ptr0) {
1434                                 if (!prs_align_custom(ps, 4))
1435                                         return False;
1436
1437                                 if (!netdfs_io_dfs_EnumArray4_p("info4", &v->u.info4, ps, depth))
1438                                         return False;
1439                                 if (!netdfs_io_dfs_EnumArray4_d("info4", &v->u.info4, ps, depth))
1440                                         return False;
1441                         }
1442                         depth--;
1443                         break;
1444
1445                 case 200:
1446                         depth++;
1447                         if (v->ptr0) {
1448                                 if (!prs_align_custom(ps, 4))
1449                                         return False;
1450
1451                                 if (!netdfs_io_dfs_EnumArray200_p("info200", &v->u.info200, ps, depth))
1452                                         return False;
1453                                 if (!netdfs_io_dfs_EnumArray200_d("info200", &v->u.info200, ps, depth))
1454                                         return False;
1455                         }
1456                         depth--;
1457                         break;
1458
1459                 case 300:
1460                         depth++;
1461                         if (v->ptr0) {
1462                                 if (!prs_align_custom(ps, 4))
1463                                         return False;
1464
1465                                 if (!netdfs_io_dfs_EnumArray300_p("info300", &v->u.info300, ps, depth))
1466                                         return False;
1467                                 if (!netdfs_io_dfs_EnumArray300_d("info300", &v->u.info300, ps, depth))
1468                                         return False;
1469                         }
1470                         depth--;
1471                         break;
1472
1473         }
1474
1475         return True;
1476 }
1477 BOOL init_netdfs_dfs_EnumStruct(NETDFS_DFS_ENUMSTRUCT *v, uint32 level, NETDFS_DFS_ENUMINFO_CTR e)
1478 {
1479         DEBUG(5,("init_netdfs_dfs_EnumStruct\n"));
1480
1481         v->level = level;
1482
1483         v->e = e;
1484         v->e.switch_value = v->level;
1485
1486         return True;
1487 }
1488
1489 BOOL netdfs_io_dfs_EnumStruct_p(const char *desc, NETDFS_DFS_ENUMSTRUCT *v, prs_struct *ps, int depth)
1490 {
1491         if (v == NULL)
1492                 return False;
1493
1494         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumStruct_p");
1495         depth++;
1496         if (!prs_uint32("level", ps, depth, &v->level))
1497                 return False;
1498
1499         if (!netdfs_io_dfs_EnumInfo_p("e", &v->e, ps, depth))
1500                 return False;
1501
1502         return True;
1503 }
1504
1505 BOOL netdfs_io_dfs_EnumStruct_d(const char *desc, NETDFS_DFS_ENUMSTRUCT *v, prs_struct *ps, int depth)
1506 {
1507         if (v == NULL)
1508                 return False;
1509
1510         prs_debug(ps, depth, desc, "netdfs_io_dfs_EnumStruct_d");
1511         depth++;
1512
1513         if (!prs_align_custom(ps, 4))
1514                 return False;
1515
1516         if (!netdfs_io_dfs_EnumInfo_d("e", &v->e, ps, depth))
1517                 return False;
1518
1519         return True;
1520 }
1521
1522 /* netdfs functions */
1523 BOOL init_netdfs_q_dfs_GetManagerVersion(NETDFS_Q_DFS_GETMANAGERVERSION *v)
1524 {
1525         DEBUG(5,("init_netdfs_q_dfs_GetManagerVersion\n"));
1526
1527         return True;
1528 }
1529
1530 BOOL netdfs_io_q_dfs_GetManagerVersion(const char *desc, NETDFS_Q_DFS_GETMANAGERVERSION *v, prs_struct *ps, int depth)
1531 {
1532         if (v == NULL)
1533                 return False;
1534
1535         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_GetManagerVersion");
1536         depth++;
1537         return True;
1538 }
1539
1540 BOOL init_netdfs_r_dfs_GetManagerVersion(NETDFS_R_DFS_GETMANAGERVERSION *v, uint32 *exist_flag)
1541 {
1542         DEBUG(5,("init_netdfs_r_dfs_GetManagerVersion\n"));
1543
1544         if (!exist_flag)
1545                 return False;
1546
1547         v->exist_flag = *exist_flag;
1548
1549         return True;
1550 }
1551
1552 BOOL netdfs_io_r_dfs_GetManagerVersion(const char *desc, NETDFS_R_DFS_GETMANAGERVERSION *v, prs_struct *ps, int depth)
1553 {
1554         if (v == NULL)
1555                 return False;
1556
1557         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_GetManagerVersion");
1558         depth++;
1559         if (!prs_uint32("exist_flag", ps, depth, &v->exist_flag))
1560                 return False;
1561
1562         return True;
1563 }
1564
1565 BOOL init_netdfs_q_dfs_Add(NETDFS_Q_DFS_ADD *v, const char *path, const char *server, const char *share, const char *comment, uint32 flags)
1566 {
1567         DEBUG(5,("init_netdfs_q_dfs_Add\n"));
1568
1569         if (!path)
1570                 return False;
1571
1572         init_unistr2(&v->path, path, UNI_FLAGS_NONE);
1573
1574         if (!server)
1575                 return False;
1576
1577         init_unistr2(&v->server, server, UNI_FLAGS_NONE);
1578
1579         if (share) {
1580                 v->ptr0_share = 1;
1581                 init_unistr2(&v->share, share, UNI_FLAGS_NONE);
1582         } else {
1583                 v->ptr0_share = 0;
1584         }
1585
1586         if (comment) {
1587                 v->ptr0_comment = 1;
1588                 init_unistr2(&v->comment, comment, UNI_FLAGS_NONE);
1589         } else {
1590                 v->ptr0_comment = 0;
1591         }
1592
1593         v->flags = flags;
1594
1595         return True;
1596 }
1597
1598 BOOL netdfs_io_q_dfs_Add(const char *desc, NETDFS_Q_DFS_ADD *v, prs_struct *ps, int depth)
1599 {
1600         if (v == NULL)
1601                 return False;
1602
1603         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Add");
1604         depth++;
1605         if (!prs_align_custom(ps, 4))
1606                 return False;
1607
1608         if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
1609                 return False;
1610
1611         if (!prs_align_custom(ps, 4))
1612                 return False;
1613
1614         if (!smb_io_unistr2("server", &v->server, 1, ps, depth))
1615                 return False;
1616
1617         if (!prs_align_custom(ps, 4))
1618                 return False;
1619
1620         if (!prs_uint32("ptr0_share", ps, depth, &v->ptr0_share))
1621                 return False;
1622
1623         if (v->ptr0_share) {
1624                 if (!prs_align_custom(ps, 4))
1625                         return False;
1626
1627                 if (!smb_io_unistr2("share", &v->share, 1, ps, depth))
1628                         return False;
1629         }
1630
1631         if (!prs_align_custom(ps, 4))
1632                 return False;
1633
1634         if (!prs_uint32("ptr0_comment", ps, depth, &v->ptr0_comment))
1635                 return False;
1636
1637         if (v->ptr0_comment) {
1638                 if (!prs_align_custom(ps, 4))
1639                         return False;
1640
1641                 if (!smb_io_unistr2("comment", &v->comment, 1, ps, depth))
1642                         return False;
1643         }
1644
1645         if (!prs_align_custom(ps, 4))
1646                 return False;
1647
1648         if (!prs_uint32("flags", ps, depth, &v->flags))
1649                 return False;
1650
1651         return True;
1652 }
1653
1654 BOOL init_netdfs_r_dfs_Add(NETDFS_R_DFS_ADD *v, const char *path, const char *server, const char *share, const char *comment, uint32 flags, WERROR status)
1655 {
1656         DEBUG(5,("init_netdfs_r_dfs_Add\n"));
1657
1658         v->status = status;
1659
1660         return True;
1661 }
1662
1663 BOOL netdfs_io_r_dfs_Add(const char *desc, NETDFS_R_DFS_ADD *v, prs_struct *ps, int depth)
1664 {
1665         if (v == NULL)
1666                 return False;
1667
1668         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Add");
1669         depth++;
1670         if (!prs_werror("status", ps, depth, &v->status))
1671                 return False;
1672
1673         return True;
1674 }
1675
1676 BOOL init_netdfs_q_dfs_Remove(NETDFS_Q_DFS_REMOVE *v, const char *path, const char *server, const char *share)
1677 {
1678         DEBUG(5,("init_netdfs_q_dfs_Remove\n"));
1679
1680         if (!path)
1681                 return False;
1682
1683         init_unistr2(&v->path, path, UNI_FLAGS_NONE);
1684
1685         if (server) {
1686                 v->ptr0_server = 1;
1687                 init_unistr2(&v->server, server, UNI_FLAGS_NONE);
1688         } else {
1689                 v->ptr0_server = 0;
1690         }
1691
1692         if (share) {
1693                 v->ptr0_share = 1;
1694                 init_unistr2(&v->share, share, UNI_FLAGS_NONE);
1695         } else {
1696                 v->ptr0_share = 0;
1697         }
1698
1699         return True;
1700 }
1701
1702 BOOL netdfs_io_q_dfs_Remove(const char *desc, NETDFS_Q_DFS_REMOVE *v, prs_struct *ps, int depth)
1703 {
1704         if (v == NULL)
1705                 return False;
1706
1707         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Remove");
1708         depth++;
1709         if (!prs_align_custom(ps, 4))
1710                 return False;
1711
1712         if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
1713                 return False;
1714
1715         if (!prs_align_custom(ps, 4))
1716                 return False;
1717
1718         if (!prs_uint32("ptr0_server", ps, depth, &v->ptr0_server))
1719                 return False;
1720
1721         if (v->ptr0_server) {
1722                 if (!prs_align_custom(ps, 4))
1723                         return False;
1724
1725                 if (!smb_io_unistr2("server", &v->server, 1, ps, depth))
1726                         return False;
1727         }
1728
1729         if (!prs_align_custom(ps, 4))
1730                 return False;
1731
1732         if (!prs_uint32("ptr0_share", ps, depth, &v->ptr0_share))
1733                 return False;
1734
1735         if (v->ptr0_share) {
1736                 if (!prs_align_custom(ps, 4))
1737                         return False;
1738
1739                 if (!smb_io_unistr2("share", &v->share, 1, ps, depth))
1740                         return False;
1741         }
1742
1743         return True;
1744 }
1745
1746 BOOL init_netdfs_r_dfs_Remove(NETDFS_R_DFS_REMOVE *v, const char *path, const char *server, const char *share, WERROR status)
1747 {
1748         DEBUG(5,("init_netdfs_r_dfs_Remove\n"));
1749
1750         v->status = status;
1751
1752         return True;
1753 }
1754
1755 BOOL netdfs_io_r_dfs_Remove(const char *desc, NETDFS_R_DFS_REMOVE *v, prs_struct *ps, int depth)
1756 {
1757         if (v == NULL)
1758                 return False;
1759
1760         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Remove");
1761         depth++;
1762         if (!prs_werror("status", ps, depth, &v->status))
1763                 return False;
1764
1765         return True;
1766 }
1767
1768 BOOL init_netdfs_q_dfs_SetInfo(NETDFS_Q_DFS_SETINFO *v)
1769 {
1770         DEBUG(5,("init_netdfs_q_dfs_SetInfo\n"));
1771
1772         return True;
1773 }
1774
1775 BOOL netdfs_io_q_dfs_SetInfo(const char *desc, NETDFS_Q_DFS_SETINFO *v, prs_struct *ps, int depth)
1776 {
1777         if (v == NULL)
1778                 return False;
1779
1780         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_SetInfo");
1781         depth++;
1782         return True;
1783 }
1784
1785 BOOL init_netdfs_r_dfs_SetInfo(NETDFS_R_DFS_SETINFO *v, WERROR status)
1786 {
1787         DEBUG(5,("init_netdfs_r_dfs_SetInfo\n"));
1788
1789         v->status = status;
1790
1791         return True;
1792 }
1793
1794 BOOL netdfs_io_r_dfs_SetInfo(const char *desc, NETDFS_R_DFS_SETINFO *v, prs_struct *ps, int depth)
1795 {
1796         if (v == NULL)
1797                 return False;
1798
1799         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_SetInfo");
1800         depth++;
1801         if (!prs_werror("status", ps, depth, &v->status))
1802                 return False;
1803
1804         return True;
1805 }
1806
1807 BOOL init_netdfs_q_dfs_GetInfo(NETDFS_Q_DFS_GETINFO *v, const char *path, const char *server, const char *share, uint32 level)
1808 {
1809         DEBUG(5,("init_netdfs_q_dfs_GetInfo\n"));
1810
1811         if (!path)
1812                 return False;
1813
1814         init_unistr2(&v->path, path, UNI_FLAGS_NONE);
1815
1816         if (server) {
1817                 v->ptr0_server = 1;
1818                 init_unistr2(&v->server, server, UNI_FLAGS_NONE);
1819         } else {
1820                 v->ptr0_server = 0;
1821         }
1822
1823         if (share) {
1824                 v->ptr0_share = 1;
1825                 init_unistr2(&v->share, share, UNI_FLAGS_NONE);
1826         } else {
1827                 v->ptr0_share = 0;
1828         }
1829
1830         v->level = level;
1831
1832         return True;
1833 }
1834
1835 BOOL netdfs_io_q_dfs_GetInfo(const char *desc, NETDFS_Q_DFS_GETINFO *v, prs_struct *ps, int depth)
1836 {
1837         if (v == NULL)
1838                 return False;
1839
1840         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_GetInfo");
1841         depth++;
1842         if (!prs_align_custom(ps, 4))
1843                 return False;
1844
1845         if (!smb_io_unistr2("path", &v->path, 1, ps, depth))
1846                 return False;
1847
1848         if (!prs_align_custom(ps, 4))
1849                 return False;
1850
1851         if (!prs_uint32("ptr0_server", ps, depth, &v->ptr0_server))
1852                 return False;
1853
1854         if (v->ptr0_server) {
1855                 if (!prs_align_custom(ps, 4))
1856                         return False;
1857
1858                 if (!smb_io_unistr2("server", &v->server, 1, ps, depth))
1859                         return False;
1860         }
1861
1862         if (!prs_align_custom(ps, 4))
1863                 return False;
1864
1865         if (!prs_uint32("ptr0_share", ps, depth, &v->ptr0_share))
1866                 return False;
1867
1868         if (v->ptr0_share) {
1869                 if (!prs_align_custom(ps, 4))
1870                         return False;
1871
1872                 if (!smb_io_unistr2("share", &v->share, 1, ps, depth))
1873                         return False;
1874         }
1875
1876         if (!prs_align_custom(ps, 4))
1877                 return False;
1878
1879         if (!prs_uint32("level", ps, depth, &v->level))
1880                 return False;
1881
1882         return True;
1883 }
1884
1885 BOOL init_netdfs_r_dfs_GetInfo(NETDFS_R_DFS_GETINFO *v, const char *path, const char *server, const char *share, uint32 level, NETDFS_DFS_INFO_CTR *info, WERROR status)
1886 {
1887         DEBUG(5,("init_netdfs_r_dfs_GetInfo\n"));
1888
1889         if (!info)
1890                 return False;
1891
1892         v->info = *info;
1893         v->info.switch_value = level;
1894
1895         v->status = status;
1896
1897         return True;
1898 }
1899
1900 BOOL netdfs_io_r_dfs_GetInfo(const char *desc, NETDFS_R_DFS_GETINFO *v, prs_struct *ps, int depth)
1901 {
1902         if (v == NULL)
1903                 return False;
1904
1905         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_GetInfo");
1906         depth++;
1907         if (!netdfs_io_dfs_Info_p("info", &v->info, ps, depth))
1908                 return False;
1909         if (!netdfs_io_dfs_Info_d("info", &v->info, ps, depth))
1910                 return False;
1911
1912         if (!prs_align_custom(ps, 4))
1913                 return False;
1914
1915         if (!prs_werror("status", ps, depth, &v->status))
1916                 return False;
1917
1918         return True;
1919 }
1920
1921 BOOL init_netdfs_q_dfs_Enum(NETDFS_Q_DFS_ENUM *v, uint32 level, uint32 bufsize, NETDFS_DFS_ENUMSTRUCT *info, uint32 *total)
1922 {
1923         DEBUG(5,("init_netdfs_q_dfs_Enum\n"));
1924
1925         v->level = level;
1926
1927         v->bufsize = bufsize;
1928
1929         if (info) {
1930                 v->ptr0_info = 1;
1931                 v->info = *info;
1932         } else {
1933                 v->ptr0_info = 0;
1934         }
1935
1936         if (total) {
1937                 v->ptr0_total = 1;
1938                 v->total = *total;
1939         } else {
1940                 v->ptr0_total = 0;
1941         }
1942
1943         return True;
1944 }
1945
1946 BOOL netdfs_io_q_dfs_Enum(const char *desc, NETDFS_Q_DFS_ENUM *v, prs_struct *ps, int depth)
1947 {
1948         if (v == NULL)
1949                 return False;
1950
1951         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Enum");
1952         depth++;
1953         if (!prs_uint32("level", ps, depth, &v->level))
1954                 return False;
1955
1956         if (!prs_uint32("bufsize", ps, depth, &v->bufsize))
1957                 return False;
1958
1959         if (!prs_uint32("ptr0_info", ps, depth, &v->ptr0_info))
1960                 return False;
1961
1962         if (v->ptr0_info) {
1963                 if (!netdfs_io_dfs_EnumStruct_p("info", &v->info, ps, depth))
1964                         return False;
1965                 if (!netdfs_io_dfs_EnumStruct_d("info", &v->info, ps, depth))
1966                         return False;
1967         }
1968
1969         if (!prs_align_custom(ps, 4))
1970                 return False;
1971
1972         if (!prs_uint32("ptr0_total", ps, depth, &v->ptr0_total))
1973                 return False;
1974
1975         if (v->ptr0_total) {
1976                 if (!prs_uint32("total", ps, depth, &v->total))
1977                         return False;
1978         }
1979
1980         return True;
1981 }
1982
1983 BOOL init_netdfs_r_dfs_Enum(NETDFS_R_DFS_ENUM *v, uint32 level, uint32 bufsize, NETDFS_DFS_ENUMSTRUCT *info, uint32 *unknown, uint32 *total, WERROR status)
1984 {
1985         DEBUG(5,("init_netdfs_r_dfs_Enum\n"));
1986
1987         if (info) {
1988                 v->ptr0_info = 1;
1989                 v->info = *info;
1990         } else {
1991                 v->ptr0_info = 0;
1992         }
1993
1994         if (total) {
1995                 v->ptr0_total = 1;
1996                 v->total = *total;
1997         } else {
1998                 v->ptr0_total = 0;
1999         }
2000
2001         v->status = status;
2002
2003         return True;
2004 }
2005
2006 BOOL netdfs_io_r_dfs_Enum(const char *desc, NETDFS_R_DFS_ENUM *v, prs_struct *ps, int depth)
2007 {
2008         if (v == NULL)
2009                 return False;
2010
2011         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Enum");
2012         depth++;
2013         if (!prs_uint32("ptr0_info", ps, depth, &v->ptr0_info))
2014                 return False;
2015
2016         if (v->ptr0_info) {
2017                 if (!netdfs_io_dfs_EnumStruct_p("info", &v->info, ps, depth))
2018                         return False;
2019                 if (!netdfs_io_dfs_EnumStruct_d("info", &v->info, ps, depth))
2020                         return False;
2021         }
2022
2023         if (!prs_align_custom(ps, 4))
2024                 return False;
2025
2026         if (!prs_uint32("ptr0_total", ps, depth, &v->ptr0_total))
2027                 return False;
2028
2029         if (v->ptr0_total) {
2030                 if (!prs_uint32("total", ps, depth, &v->total))
2031                         return False;
2032         }
2033
2034         if (!prs_align_custom(ps, 4))
2035                 return False;
2036
2037         if (!prs_werror("status", ps, depth, &v->status))
2038                 return False;
2039
2040         return True;
2041 }
2042
2043 BOOL init_netdfs_q_dfs_Rename(NETDFS_Q_DFS_RENAME *v)
2044 {
2045         DEBUG(5,("init_netdfs_q_dfs_Rename\n"));
2046
2047         return True;
2048 }
2049
2050 BOOL netdfs_io_q_dfs_Rename(const char *desc, NETDFS_Q_DFS_RENAME *v, prs_struct *ps, int depth)
2051 {
2052         if (v == NULL)
2053                 return False;
2054
2055         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Rename");
2056         depth++;
2057         return True;
2058 }
2059
2060 BOOL init_netdfs_r_dfs_Rename(NETDFS_R_DFS_RENAME *v, WERROR status)
2061 {
2062         DEBUG(5,("init_netdfs_r_dfs_Rename\n"));
2063
2064         v->status = status;
2065
2066         return True;
2067 }
2068
2069 BOOL netdfs_io_r_dfs_Rename(const char *desc, NETDFS_R_DFS_RENAME *v, prs_struct *ps, int depth)
2070 {
2071         if (v == NULL)
2072                 return False;
2073
2074         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Rename");
2075         depth++;
2076         if (!prs_werror("status", ps, depth, &v->status))
2077                 return False;
2078
2079         return True;
2080 }
2081
2082 BOOL init_netdfs_q_dfs_Move(NETDFS_Q_DFS_MOVE *v)
2083 {
2084         DEBUG(5,("init_netdfs_q_dfs_Move\n"));
2085
2086         return True;
2087 }
2088
2089 BOOL netdfs_io_q_dfs_Move(const char *desc, NETDFS_Q_DFS_MOVE *v, prs_struct *ps, int depth)
2090 {
2091         if (v == NULL)
2092                 return False;
2093
2094         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Move");
2095         depth++;
2096         return True;
2097 }
2098
2099 BOOL init_netdfs_r_dfs_Move(NETDFS_R_DFS_MOVE *v, WERROR status)
2100 {
2101         DEBUG(5,("init_netdfs_r_dfs_Move\n"));
2102
2103         v->status = status;
2104
2105         return True;
2106 }
2107
2108 BOOL netdfs_io_r_dfs_Move(const char *desc, NETDFS_R_DFS_MOVE *v, prs_struct *ps, int depth)
2109 {
2110         if (v == NULL)
2111                 return False;
2112
2113         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Move");
2114         depth++;
2115         if (!prs_werror("status", ps, depth, &v->status))
2116                 return False;
2117
2118         return True;
2119 }
2120
2121 BOOL init_netdfs_q_dfs_ManagerGetConfigInfo(NETDFS_Q_DFS_MANAGERGETCONFIGINFO *v)
2122 {
2123         DEBUG(5,("init_netdfs_q_dfs_ManagerGetConfigInfo\n"));
2124
2125         return True;
2126 }
2127
2128 BOOL netdfs_io_q_dfs_ManagerGetConfigInfo(const char *desc, NETDFS_Q_DFS_MANAGERGETCONFIGINFO *v, prs_struct *ps, int depth)
2129 {
2130         if (v == NULL)
2131                 return False;
2132
2133         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_ManagerGetConfigInfo");
2134         depth++;
2135         return True;
2136 }
2137
2138 BOOL init_netdfs_r_dfs_ManagerGetConfigInfo(NETDFS_R_DFS_MANAGERGETCONFIGINFO *v, WERROR status)
2139 {
2140         DEBUG(5,("init_netdfs_r_dfs_ManagerGetConfigInfo\n"));
2141
2142         v->status = status;
2143
2144         return True;
2145 }
2146
2147 BOOL netdfs_io_r_dfs_ManagerGetConfigInfo(const char *desc, NETDFS_R_DFS_MANAGERGETCONFIGINFO *v, prs_struct *ps, int depth)
2148 {
2149         if (v == NULL)
2150                 return False;
2151
2152         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_ManagerGetConfigInfo");
2153         depth++;
2154         if (!prs_werror("status", ps, depth, &v->status))
2155                 return False;
2156
2157         return True;
2158 }
2159
2160 BOOL init_netdfs_q_dfs_ManagerSendSiteInfo(NETDFS_Q_DFS_MANAGERSENDSITEINFO *v)
2161 {
2162         DEBUG(5,("init_netdfs_q_dfs_ManagerSendSiteInfo\n"));
2163
2164         return True;
2165 }
2166
2167 BOOL netdfs_io_q_dfs_ManagerSendSiteInfo(const char *desc, NETDFS_Q_DFS_MANAGERSENDSITEINFO *v, prs_struct *ps, int depth)
2168 {
2169         if (v == NULL)
2170                 return False;
2171
2172         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_ManagerSendSiteInfo");
2173         depth++;
2174         return True;
2175 }
2176
2177 BOOL init_netdfs_r_dfs_ManagerSendSiteInfo(NETDFS_R_DFS_MANAGERSENDSITEINFO *v, WERROR status)
2178 {
2179         DEBUG(5,("init_netdfs_r_dfs_ManagerSendSiteInfo\n"));
2180
2181         v->status = status;
2182
2183         return True;
2184 }
2185
2186 BOOL netdfs_io_r_dfs_ManagerSendSiteInfo(const char *desc, NETDFS_R_DFS_MANAGERSENDSITEINFO *v, prs_struct *ps, int depth)
2187 {
2188         if (v == NULL)
2189                 return False;
2190
2191         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_ManagerSendSiteInfo");
2192         depth++;
2193         if (!prs_werror("status", ps, depth, &v->status))
2194                 return False;
2195
2196         return True;
2197 }
2198
2199 BOOL init_netdfs_q_dfs_AddFtRoot(NETDFS_Q_DFS_ADDFTROOT *v)
2200 {
2201         DEBUG(5,("init_netdfs_q_dfs_AddFtRoot\n"));
2202
2203         return True;
2204 }
2205
2206 BOOL netdfs_io_q_dfs_AddFtRoot(const char *desc, NETDFS_Q_DFS_ADDFTROOT *v, prs_struct *ps, int depth)
2207 {
2208         if (v == NULL)
2209                 return False;
2210
2211         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_AddFtRoot");
2212         depth++;
2213         return True;
2214 }
2215
2216 BOOL init_netdfs_r_dfs_AddFtRoot(NETDFS_R_DFS_ADDFTROOT *v, WERROR status)
2217 {
2218         DEBUG(5,("init_netdfs_r_dfs_AddFtRoot\n"));
2219
2220         v->status = status;
2221
2222         return True;
2223 }
2224
2225 BOOL netdfs_io_r_dfs_AddFtRoot(const char *desc, NETDFS_R_DFS_ADDFTROOT *v, prs_struct *ps, int depth)
2226 {
2227         if (v == NULL)
2228                 return False;
2229
2230         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_AddFtRoot");
2231         depth++;
2232         if (!prs_werror("status", ps, depth, &v->status))
2233                 return False;
2234
2235         return True;
2236 }
2237
2238 BOOL init_netdfs_q_dfs_RemoveFtRoot(NETDFS_Q_DFS_REMOVEFTROOT *v)
2239 {
2240         DEBUG(5,("init_netdfs_q_dfs_RemoveFtRoot\n"));
2241
2242         return True;
2243 }
2244
2245 BOOL netdfs_io_q_dfs_RemoveFtRoot(const char *desc, NETDFS_Q_DFS_REMOVEFTROOT *v, prs_struct *ps, int depth)
2246 {
2247         if (v == NULL)
2248                 return False;
2249
2250         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_RemoveFtRoot");
2251         depth++;
2252         return True;
2253 }
2254
2255 BOOL init_netdfs_r_dfs_RemoveFtRoot(NETDFS_R_DFS_REMOVEFTROOT *v, WERROR status)
2256 {
2257         DEBUG(5,("init_netdfs_r_dfs_RemoveFtRoot\n"));
2258
2259         v->status = status;
2260
2261         return True;
2262 }
2263
2264 BOOL netdfs_io_r_dfs_RemoveFtRoot(const char *desc, NETDFS_R_DFS_REMOVEFTROOT *v, prs_struct *ps, int depth)
2265 {
2266         if (v == NULL)
2267                 return False;
2268
2269         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_RemoveFtRoot");
2270         depth++;
2271         if (!prs_werror("status", ps, depth, &v->status))
2272                 return False;
2273
2274         return True;
2275 }
2276
2277 BOOL init_netdfs_q_dfs_AddStdRoot(NETDFS_Q_DFS_ADDSTDROOT *v)
2278 {
2279         DEBUG(5,("init_netdfs_q_dfs_AddStdRoot\n"));
2280
2281         return True;
2282 }
2283
2284 BOOL netdfs_io_q_dfs_AddStdRoot(const char *desc, NETDFS_Q_DFS_ADDSTDROOT *v, prs_struct *ps, int depth)
2285 {
2286         if (v == NULL)
2287                 return False;
2288
2289         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_AddStdRoot");
2290         depth++;
2291         return True;
2292 }
2293
2294 BOOL init_netdfs_r_dfs_AddStdRoot(NETDFS_R_DFS_ADDSTDROOT *v, WERROR status)
2295 {
2296         DEBUG(5,("init_netdfs_r_dfs_AddStdRoot\n"));
2297
2298         v->status = status;
2299
2300         return True;
2301 }
2302
2303 BOOL netdfs_io_r_dfs_AddStdRoot(const char *desc, NETDFS_R_DFS_ADDSTDROOT *v, prs_struct *ps, int depth)
2304 {
2305         if (v == NULL)
2306                 return False;
2307
2308         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_AddStdRoot");
2309         depth++;
2310         if (!prs_werror("status", ps, depth, &v->status))
2311                 return False;
2312
2313         return True;
2314 }
2315
2316 BOOL init_netdfs_q_dfs_RemoveStdRoot(NETDFS_Q_DFS_REMOVESTDROOT *v)
2317 {
2318         DEBUG(5,("init_netdfs_q_dfs_RemoveStdRoot\n"));
2319
2320         return True;
2321 }
2322
2323 BOOL netdfs_io_q_dfs_RemoveStdRoot(const char *desc, NETDFS_Q_DFS_REMOVESTDROOT *v, prs_struct *ps, int depth)
2324 {
2325         if (v == NULL)
2326                 return False;
2327
2328         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_RemoveStdRoot");
2329         depth++;
2330         return True;
2331 }
2332
2333 BOOL init_netdfs_r_dfs_RemoveStdRoot(NETDFS_R_DFS_REMOVESTDROOT *v, WERROR status)
2334 {
2335         DEBUG(5,("init_netdfs_r_dfs_RemoveStdRoot\n"));
2336
2337         v->status = status;
2338
2339         return True;
2340 }
2341
2342 BOOL netdfs_io_r_dfs_RemoveStdRoot(const char *desc, NETDFS_R_DFS_REMOVESTDROOT *v, prs_struct *ps, int depth)
2343 {
2344         if (v == NULL)
2345                 return False;
2346
2347         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_RemoveStdRoot");
2348         depth++;
2349         if (!prs_werror("status", ps, depth, &v->status))
2350                 return False;
2351
2352         return True;
2353 }
2354
2355 BOOL init_netdfs_q_dfs_ManagerInitialize(NETDFS_Q_DFS_MANAGERINITIALIZE *v)
2356 {
2357         DEBUG(5,("init_netdfs_q_dfs_ManagerInitialize\n"));
2358
2359         return True;
2360 }
2361
2362 BOOL netdfs_io_q_dfs_ManagerInitialize(const char *desc, NETDFS_Q_DFS_MANAGERINITIALIZE *v, prs_struct *ps, int depth)
2363 {
2364         if (v == NULL)
2365                 return False;
2366
2367         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_ManagerInitialize");
2368         depth++;
2369         return True;
2370 }
2371
2372 BOOL init_netdfs_r_dfs_ManagerInitialize(NETDFS_R_DFS_MANAGERINITIALIZE *v, WERROR status)
2373 {
2374         DEBUG(5,("init_netdfs_r_dfs_ManagerInitialize\n"));
2375
2376         v->status = status;
2377
2378         return True;
2379 }
2380
2381 BOOL netdfs_io_r_dfs_ManagerInitialize(const char *desc, NETDFS_R_DFS_MANAGERINITIALIZE *v, prs_struct *ps, int depth)
2382 {
2383         if (v == NULL)
2384                 return False;
2385
2386         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_ManagerInitialize");
2387         depth++;
2388         if (!prs_werror("status", ps, depth, &v->status))
2389                 return False;
2390
2391         return True;
2392 }
2393
2394 BOOL init_netdfs_q_dfs_AddStdRootForced(NETDFS_Q_DFS_ADDSTDROOTFORCED *v)
2395 {
2396         DEBUG(5,("init_netdfs_q_dfs_AddStdRootForced\n"));
2397
2398         return True;
2399 }
2400
2401 BOOL netdfs_io_q_dfs_AddStdRootForced(const char *desc, NETDFS_Q_DFS_ADDSTDROOTFORCED *v, prs_struct *ps, int depth)
2402 {
2403         if (v == NULL)
2404                 return False;
2405
2406         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_AddStdRootForced");
2407         depth++;
2408         return True;
2409 }
2410
2411 BOOL init_netdfs_r_dfs_AddStdRootForced(NETDFS_R_DFS_ADDSTDROOTFORCED *v, WERROR status)
2412 {
2413         DEBUG(5,("init_netdfs_r_dfs_AddStdRootForced\n"));
2414
2415         v->status = status;
2416
2417         return True;
2418 }
2419
2420 BOOL netdfs_io_r_dfs_AddStdRootForced(const char *desc, NETDFS_R_DFS_ADDSTDROOTFORCED *v, prs_struct *ps, int depth)
2421 {
2422         if (v == NULL)
2423                 return False;
2424
2425         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_AddStdRootForced");
2426         depth++;
2427         if (!prs_werror("status", ps, depth, &v->status))
2428                 return False;
2429
2430         return True;
2431 }
2432
2433 BOOL init_netdfs_q_dfs_GetDcAddress(NETDFS_Q_DFS_GETDCADDRESS *v)
2434 {
2435         DEBUG(5,("init_netdfs_q_dfs_GetDcAddress\n"));
2436
2437         return True;
2438 }
2439
2440 BOOL netdfs_io_q_dfs_GetDcAddress(const char *desc, NETDFS_Q_DFS_GETDCADDRESS *v, prs_struct *ps, int depth)
2441 {
2442         if (v == NULL)
2443                 return False;
2444
2445         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_GetDcAddress");
2446         depth++;
2447         return True;
2448 }
2449
2450 BOOL init_netdfs_r_dfs_GetDcAddress(NETDFS_R_DFS_GETDCADDRESS *v, WERROR status)
2451 {
2452         DEBUG(5,("init_netdfs_r_dfs_GetDcAddress\n"));
2453
2454         v->status = status;
2455
2456         return True;
2457 }
2458
2459 BOOL netdfs_io_r_dfs_GetDcAddress(const char *desc, NETDFS_R_DFS_GETDCADDRESS *v, prs_struct *ps, int depth)
2460 {
2461         if (v == NULL)
2462                 return False;
2463
2464         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_GetDcAddress");
2465         depth++;
2466         if (!prs_werror("status", ps, depth, &v->status))
2467                 return False;
2468
2469         return True;
2470 }
2471
2472 BOOL init_netdfs_q_dfs_SetDcAddress(NETDFS_Q_DFS_SETDCADDRESS *v)
2473 {
2474         DEBUG(5,("init_netdfs_q_dfs_SetDcAddress\n"));
2475
2476         return True;
2477 }
2478
2479 BOOL netdfs_io_q_dfs_SetDcAddress(const char *desc, NETDFS_Q_DFS_SETDCADDRESS *v, prs_struct *ps, int depth)
2480 {
2481         if (v == NULL)
2482                 return False;
2483
2484         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_SetDcAddress");
2485         depth++;
2486         return True;
2487 }
2488
2489 BOOL init_netdfs_r_dfs_SetDcAddress(NETDFS_R_DFS_SETDCADDRESS *v, WERROR status)
2490 {
2491         DEBUG(5,("init_netdfs_r_dfs_SetDcAddress\n"));
2492
2493         v->status = status;
2494
2495         return True;
2496 }
2497
2498 BOOL netdfs_io_r_dfs_SetDcAddress(const char *desc, NETDFS_R_DFS_SETDCADDRESS *v, prs_struct *ps, int depth)
2499 {
2500         if (v == NULL)
2501                 return False;
2502
2503         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_SetDcAddress");
2504         depth++;
2505         if (!prs_werror("status", ps, depth, &v->status))
2506                 return False;
2507
2508         return True;
2509 }
2510
2511 BOOL init_netdfs_q_dfs_FlushFtTable(NETDFS_Q_DFS_FLUSHFTTABLE *v)
2512 {
2513         DEBUG(5,("init_netdfs_q_dfs_FlushFtTable\n"));
2514
2515         return True;
2516 }
2517
2518 BOOL netdfs_io_q_dfs_FlushFtTable(const char *desc, NETDFS_Q_DFS_FLUSHFTTABLE *v, prs_struct *ps, int depth)
2519 {
2520         if (v == NULL)
2521                 return False;
2522
2523         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_FlushFtTable");
2524         depth++;
2525         return True;
2526 }
2527
2528 BOOL init_netdfs_r_dfs_FlushFtTable(NETDFS_R_DFS_FLUSHFTTABLE *v, WERROR status)
2529 {
2530         DEBUG(5,("init_netdfs_r_dfs_FlushFtTable\n"));
2531
2532         v->status = status;
2533
2534         return True;
2535 }
2536
2537 BOOL netdfs_io_r_dfs_FlushFtTable(const char *desc, NETDFS_R_DFS_FLUSHFTTABLE *v, prs_struct *ps, int depth)
2538 {
2539         if (v == NULL)
2540                 return False;
2541
2542         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_FlushFtTable");
2543         depth++;
2544         if (!prs_werror("status", ps, depth, &v->status))
2545                 return False;
2546
2547         return True;
2548 }
2549
2550 BOOL init_netdfs_q_dfs_Add2(NETDFS_Q_DFS_ADD2 *v)
2551 {
2552         DEBUG(5,("init_netdfs_q_dfs_Add2\n"));
2553
2554         return True;
2555 }
2556
2557 BOOL netdfs_io_q_dfs_Add2(const char *desc, NETDFS_Q_DFS_ADD2 *v, prs_struct *ps, int depth)
2558 {
2559         if (v == NULL)
2560                 return False;
2561
2562         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Add2");
2563         depth++;
2564         return True;
2565 }
2566
2567 BOOL init_netdfs_r_dfs_Add2(NETDFS_R_DFS_ADD2 *v, WERROR status)
2568 {
2569         DEBUG(5,("init_netdfs_r_dfs_Add2\n"));
2570
2571         v->status = status;
2572
2573         return True;
2574 }
2575
2576 BOOL netdfs_io_r_dfs_Add2(const char *desc, NETDFS_R_DFS_ADD2 *v, prs_struct *ps, int depth)
2577 {
2578         if (v == NULL)
2579                 return False;
2580
2581         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Add2");
2582         depth++;
2583         if (!prs_werror("status", ps, depth, &v->status))
2584                 return False;
2585
2586         return True;
2587 }
2588
2589 BOOL init_netdfs_q_dfs_Remove2(NETDFS_Q_DFS_REMOVE2 *v)
2590 {
2591         DEBUG(5,("init_netdfs_q_dfs_Remove2\n"));
2592
2593         return True;
2594 }
2595
2596 BOOL netdfs_io_q_dfs_Remove2(const char *desc, NETDFS_Q_DFS_REMOVE2 *v, prs_struct *ps, int depth)
2597 {
2598         if (v == NULL)
2599                 return False;
2600
2601         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Remove2");
2602         depth++;
2603         return True;
2604 }
2605
2606 BOOL init_netdfs_r_dfs_Remove2(NETDFS_R_DFS_REMOVE2 *v, WERROR status)
2607 {
2608         DEBUG(5,("init_netdfs_r_dfs_Remove2\n"));
2609
2610         v->status = status;
2611
2612         return True;
2613 }
2614
2615 BOOL netdfs_io_r_dfs_Remove2(const char *desc, NETDFS_R_DFS_REMOVE2 *v, prs_struct *ps, int depth)
2616 {
2617         if (v == NULL)
2618                 return False;
2619
2620         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Remove2");
2621         depth++;
2622         if (!prs_werror("status", ps, depth, &v->status))
2623                 return False;
2624
2625         return True;
2626 }
2627
2628 BOOL init_netdfs_q_dfs_EnumEx(NETDFS_Q_DFS_ENUMEX *v)
2629 {
2630         DEBUG(5,("init_netdfs_q_dfs_EnumEx\n"));
2631
2632         return True;
2633 }
2634
2635 BOOL netdfs_io_q_dfs_EnumEx(const char *desc, NETDFS_Q_DFS_ENUMEX *v, prs_struct *ps, int depth)
2636 {
2637         if (v == NULL)
2638                 return False;
2639
2640         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_EnumEx");
2641         depth++;
2642         return True;
2643 }
2644
2645 BOOL init_netdfs_r_dfs_EnumEx(NETDFS_R_DFS_ENUMEX *v, WERROR status)
2646 {
2647         DEBUG(5,("init_netdfs_r_dfs_EnumEx\n"));
2648
2649         v->status = status;
2650
2651         return True;
2652 }
2653
2654 BOOL netdfs_io_r_dfs_EnumEx(const char *desc, NETDFS_R_DFS_ENUMEX *v, prs_struct *ps, int depth)
2655 {
2656         if (v == NULL)
2657                 return False;
2658
2659         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_EnumEx");
2660         depth++;
2661         if (!prs_werror("status", ps, depth, &v->status))
2662                 return False;
2663
2664         return True;
2665 }
2666
2667 BOOL init_netdfs_q_dfs_SetInfo2(NETDFS_Q_DFS_SETINFO2 *v)
2668 {
2669         DEBUG(5,("init_netdfs_q_dfs_SetInfo2\n"));
2670
2671         return True;
2672 }
2673
2674 BOOL netdfs_io_q_dfs_SetInfo2(const char *desc, NETDFS_Q_DFS_SETINFO2 *v, prs_struct *ps, int depth)
2675 {
2676         if (v == NULL)
2677                 return False;
2678
2679         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_SetInfo2");
2680         depth++;
2681         return True;
2682 }
2683
2684 BOOL init_netdfs_r_dfs_SetInfo2(NETDFS_R_DFS_SETINFO2 *v, WERROR status)
2685 {
2686         DEBUG(5,("init_netdfs_r_dfs_SetInfo2\n"));
2687
2688         v->status = status;
2689
2690         return True;
2691 }
2692
2693 BOOL netdfs_io_r_dfs_SetInfo2(const char *desc, NETDFS_R_DFS_SETINFO2 *v, prs_struct *ps, int depth)
2694 {
2695         if (v == NULL)
2696                 return False;
2697
2698         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_SetInfo2");
2699         depth++;
2700         if (!prs_werror("status", ps, depth, &v->status))
2701                 return False;
2702
2703         return True;
2704 }
2705