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