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 uuid 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 *unknown, 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 (unknown) {
1881                 v->ptr0_unknown = 1;
1882                 v->unknown = *unknown;
1883         } else {
1884                 v->ptr0_unknown = 0;
1885         }
1886
1887         if (total) {
1888                 v->ptr0_total = 1;
1889                 v->total = *total;
1890         } else {
1891                 v->ptr0_total = 0;
1892         }
1893
1894         return True;
1895 }
1896
1897 BOOL netdfs_io_q_dfs_Enum(const char *desc, NETDFS_Q_DFS_ENUM *v, prs_struct *ps, int depth)
1898 {
1899         if (v == NULL)
1900                 return False;
1901
1902         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Enum");
1903         depth++;
1904         if (!prs_uint32("level", ps, depth, &v->level))
1905                 return False;
1906
1907         if (!prs_uint32("bufsize", ps, depth, &v->bufsize))
1908                 return False;
1909
1910         if (!prs_uint32("ptr0_info", ps, depth, &v->ptr0_info))
1911                 return False;
1912
1913         if (v->ptr0_info) {
1914                 if (!netdfs_io_dfs_EnumStruct_p("info", &v->info, ps, depth))
1915                         return False;
1916                 if (!netdfs_io_dfs_EnumStruct_d("info", &v->info, ps, depth))
1917                         return False;
1918         }
1919
1920         if (!prs_align_custom(ps, 4))
1921                 return False;
1922
1923         if (!prs_uint32("ptr0_unknown", ps, depth, &v->ptr0_unknown))
1924                 return False;
1925
1926         if (v->ptr0_unknown) {
1927                 if (!prs_uint32("unknown", ps, depth, &v->unknown))
1928                         return False;
1929         }
1930
1931         if (!prs_align_custom(ps, 4))
1932                 return False;
1933
1934         if (!prs_uint32("ptr0_total", ps, depth, &v->ptr0_total))
1935                 return False;
1936
1937         if (v->ptr0_total) {
1938                 if (!prs_uint32("total", ps, depth, &v->total))
1939                         return False;
1940         }
1941
1942         return True;
1943 }
1944
1945 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)
1946 {
1947         DEBUG(5,("init_netdfs_r_dfs_Enum\n"));
1948
1949         if (info) {
1950                 v->ptr0_info = 1;
1951                 v->info = *info;
1952         } else {
1953                 v->ptr0_info = 0;
1954         }
1955
1956         if (total) {
1957                 v->ptr0_total = 1;
1958                 v->total = *total;
1959         } else {
1960                 v->ptr0_total = 0;
1961         }
1962
1963         v->status = status;
1964
1965         return True;
1966 }
1967
1968 BOOL netdfs_io_r_dfs_Enum(const char *desc, NETDFS_R_DFS_ENUM *v, prs_struct *ps, int depth)
1969 {
1970         if (v == NULL)
1971                 return False;
1972
1973         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Enum");
1974         depth++;
1975         if (!prs_uint32("ptr0_info", ps, depth, &v->ptr0_info))
1976                 return False;
1977
1978         if (v->ptr0_info) {
1979                 if (!netdfs_io_dfs_EnumStruct_p("info", &v->info, ps, depth))
1980                         return False;
1981                 if (!netdfs_io_dfs_EnumStruct_d("info", &v->info, ps, depth))
1982                         return False;
1983         }
1984
1985         if (!prs_align_custom(ps, 4))
1986                 return False;
1987
1988         if (!prs_uint32("ptr0_total", ps, depth, &v->ptr0_total))
1989                 return False;
1990
1991         if (v->ptr0_total) {
1992                 if (!prs_uint32("total", ps, depth, &v->total))
1993                         return False;
1994         }
1995
1996         if (!prs_align_custom(ps, 4))
1997                 return False;
1998
1999         if (!prs_werror("status", ps, depth, &v->status))
2000                 return False;
2001
2002         return True;
2003 }
2004
2005 BOOL init_netdfs_q_dfs_Rename(NETDFS_Q_DFS_RENAME *v)
2006 {
2007         DEBUG(5,("init_netdfs_q_dfs_Rename\n"));
2008
2009         return True;
2010 }
2011
2012 BOOL netdfs_io_q_dfs_Rename(const char *desc, NETDFS_Q_DFS_RENAME *v, prs_struct *ps, int depth)
2013 {
2014         if (v == NULL)
2015                 return False;
2016
2017         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Rename");
2018         depth++;
2019         return True;
2020 }
2021
2022 BOOL init_netdfs_r_dfs_Rename(NETDFS_R_DFS_RENAME *v, WERROR status)
2023 {
2024         DEBUG(5,("init_netdfs_r_dfs_Rename\n"));
2025
2026         v->status = status;
2027
2028         return True;
2029 }
2030
2031 BOOL netdfs_io_r_dfs_Rename(const char *desc, NETDFS_R_DFS_RENAME *v, prs_struct *ps, int depth)
2032 {
2033         if (v == NULL)
2034                 return False;
2035
2036         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Rename");
2037         depth++;
2038         if (!prs_werror("status", ps, depth, &v->status))
2039                 return False;
2040
2041         return True;
2042 }
2043
2044 BOOL init_netdfs_q_dfs_Move(NETDFS_Q_DFS_MOVE *v)
2045 {
2046         DEBUG(5,("init_netdfs_q_dfs_Move\n"));
2047
2048         return True;
2049 }
2050
2051 BOOL netdfs_io_q_dfs_Move(const char *desc, NETDFS_Q_DFS_MOVE *v, prs_struct *ps, int depth)
2052 {
2053         if (v == NULL)
2054                 return False;
2055
2056         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Move");
2057         depth++;
2058         return True;
2059 }
2060
2061 BOOL init_netdfs_r_dfs_Move(NETDFS_R_DFS_MOVE *v, WERROR status)
2062 {
2063         DEBUG(5,("init_netdfs_r_dfs_Move\n"));
2064
2065         v->status = status;
2066
2067         return True;
2068 }
2069
2070 BOOL netdfs_io_r_dfs_Move(const char *desc, NETDFS_R_DFS_MOVE *v, prs_struct *ps, int depth)
2071 {
2072         if (v == NULL)
2073                 return False;
2074
2075         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Move");
2076         depth++;
2077         if (!prs_werror("status", ps, depth, &v->status))
2078                 return False;
2079
2080         return True;
2081 }
2082
2083 BOOL init_netdfs_q_dfs_ManagerGetConfigInfo(NETDFS_Q_DFS_MANAGERGETCONFIGINFO *v)
2084 {
2085         DEBUG(5,("init_netdfs_q_dfs_ManagerGetConfigInfo\n"));
2086
2087         return True;
2088 }
2089
2090 BOOL netdfs_io_q_dfs_ManagerGetConfigInfo(const char *desc, NETDFS_Q_DFS_MANAGERGETCONFIGINFO *v, prs_struct *ps, int depth)
2091 {
2092         if (v == NULL)
2093                 return False;
2094
2095         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_ManagerGetConfigInfo");
2096         depth++;
2097         return True;
2098 }
2099
2100 BOOL init_netdfs_r_dfs_ManagerGetConfigInfo(NETDFS_R_DFS_MANAGERGETCONFIGINFO *v, WERROR status)
2101 {
2102         DEBUG(5,("init_netdfs_r_dfs_ManagerGetConfigInfo\n"));
2103
2104         v->status = status;
2105
2106         return True;
2107 }
2108
2109 BOOL netdfs_io_r_dfs_ManagerGetConfigInfo(const char *desc, NETDFS_R_DFS_MANAGERGETCONFIGINFO *v, prs_struct *ps, int depth)
2110 {
2111         if (v == NULL)
2112                 return False;
2113
2114         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_ManagerGetConfigInfo");
2115         depth++;
2116         if (!prs_werror("status", ps, depth, &v->status))
2117                 return False;
2118
2119         return True;
2120 }
2121
2122 BOOL init_netdfs_q_dfs_ManagerSendSiteInfo(NETDFS_Q_DFS_MANAGERSENDSITEINFO *v)
2123 {
2124         DEBUG(5,("init_netdfs_q_dfs_ManagerSendSiteInfo\n"));
2125
2126         return True;
2127 }
2128
2129 BOOL netdfs_io_q_dfs_ManagerSendSiteInfo(const char *desc, NETDFS_Q_DFS_MANAGERSENDSITEINFO *v, prs_struct *ps, int depth)
2130 {
2131         if (v == NULL)
2132                 return False;
2133
2134         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_ManagerSendSiteInfo");
2135         depth++;
2136         return True;
2137 }
2138
2139 BOOL init_netdfs_r_dfs_ManagerSendSiteInfo(NETDFS_R_DFS_MANAGERSENDSITEINFO *v, WERROR status)
2140 {
2141         DEBUG(5,("init_netdfs_r_dfs_ManagerSendSiteInfo\n"));
2142
2143         v->status = status;
2144
2145         return True;
2146 }
2147
2148 BOOL netdfs_io_r_dfs_ManagerSendSiteInfo(const char *desc, NETDFS_R_DFS_MANAGERSENDSITEINFO *v, prs_struct *ps, int depth)
2149 {
2150         if (v == NULL)
2151                 return False;
2152
2153         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_ManagerSendSiteInfo");
2154         depth++;
2155         if (!prs_werror("status", ps, depth, &v->status))
2156                 return False;
2157
2158         return True;
2159 }
2160
2161 BOOL init_netdfs_q_dfs_AddFtRoot(NETDFS_Q_DFS_ADDFTROOT *v)
2162 {
2163         DEBUG(5,("init_netdfs_q_dfs_AddFtRoot\n"));
2164
2165         return True;
2166 }
2167
2168 BOOL netdfs_io_q_dfs_AddFtRoot(const char *desc, NETDFS_Q_DFS_ADDFTROOT *v, prs_struct *ps, int depth)
2169 {
2170         if (v == NULL)
2171                 return False;
2172
2173         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_AddFtRoot");
2174         depth++;
2175         return True;
2176 }
2177
2178 BOOL init_netdfs_r_dfs_AddFtRoot(NETDFS_R_DFS_ADDFTROOT *v, WERROR status)
2179 {
2180         DEBUG(5,("init_netdfs_r_dfs_AddFtRoot\n"));
2181
2182         v->status = status;
2183
2184         return True;
2185 }
2186
2187 BOOL netdfs_io_r_dfs_AddFtRoot(const char *desc, NETDFS_R_DFS_ADDFTROOT *v, prs_struct *ps, int depth)
2188 {
2189         if (v == NULL)
2190                 return False;
2191
2192         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_AddFtRoot");
2193         depth++;
2194         if (!prs_werror("status", ps, depth, &v->status))
2195                 return False;
2196
2197         return True;
2198 }
2199
2200 BOOL init_netdfs_q_dfs_RemoveFtRoot(NETDFS_Q_DFS_REMOVEFTROOT *v)
2201 {
2202         DEBUG(5,("init_netdfs_q_dfs_RemoveFtRoot\n"));
2203
2204         return True;
2205 }
2206
2207 BOOL netdfs_io_q_dfs_RemoveFtRoot(const char *desc, NETDFS_Q_DFS_REMOVEFTROOT *v, prs_struct *ps, int depth)
2208 {
2209         if (v == NULL)
2210                 return False;
2211
2212         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_RemoveFtRoot");
2213         depth++;
2214         return True;
2215 }
2216
2217 BOOL init_netdfs_r_dfs_RemoveFtRoot(NETDFS_R_DFS_REMOVEFTROOT *v, WERROR status)
2218 {
2219         DEBUG(5,("init_netdfs_r_dfs_RemoveFtRoot\n"));
2220
2221         v->status = status;
2222
2223         return True;
2224 }
2225
2226 BOOL netdfs_io_r_dfs_RemoveFtRoot(const char *desc, NETDFS_R_DFS_REMOVEFTROOT *v, prs_struct *ps, int depth)
2227 {
2228         if (v == NULL)
2229                 return False;
2230
2231         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_RemoveFtRoot");
2232         depth++;
2233         if (!prs_werror("status", ps, depth, &v->status))
2234                 return False;
2235
2236         return True;
2237 }
2238
2239 BOOL init_netdfs_q_dfs_AddStdRoot(NETDFS_Q_DFS_ADDSTDROOT *v)
2240 {
2241         DEBUG(5,("init_netdfs_q_dfs_AddStdRoot\n"));
2242
2243         return True;
2244 }
2245
2246 BOOL netdfs_io_q_dfs_AddStdRoot(const char *desc, NETDFS_Q_DFS_ADDSTDROOT *v, prs_struct *ps, int depth)
2247 {
2248         if (v == NULL)
2249                 return False;
2250
2251         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_AddStdRoot");
2252         depth++;
2253         return True;
2254 }
2255
2256 BOOL init_netdfs_r_dfs_AddStdRoot(NETDFS_R_DFS_ADDSTDROOT *v, WERROR status)
2257 {
2258         DEBUG(5,("init_netdfs_r_dfs_AddStdRoot\n"));
2259
2260         v->status = status;
2261
2262         return True;
2263 }
2264
2265 BOOL netdfs_io_r_dfs_AddStdRoot(const char *desc, NETDFS_R_DFS_ADDSTDROOT *v, prs_struct *ps, int depth)
2266 {
2267         if (v == NULL)
2268                 return False;
2269
2270         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_AddStdRoot");
2271         depth++;
2272         if (!prs_werror("status", ps, depth, &v->status))
2273                 return False;
2274
2275         return True;
2276 }
2277
2278 BOOL init_netdfs_q_dfs_RemoveStdRoot(NETDFS_Q_DFS_REMOVESTDROOT *v)
2279 {
2280         DEBUG(5,("init_netdfs_q_dfs_RemoveStdRoot\n"));
2281
2282         return True;
2283 }
2284
2285 BOOL netdfs_io_q_dfs_RemoveStdRoot(const char *desc, NETDFS_Q_DFS_REMOVESTDROOT *v, prs_struct *ps, int depth)
2286 {
2287         if (v == NULL)
2288                 return False;
2289
2290         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_RemoveStdRoot");
2291         depth++;
2292         return True;
2293 }
2294
2295 BOOL init_netdfs_r_dfs_RemoveStdRoot(NETDFS_R_DFS_REMOVESTDROOT *v, WERROR status)
2296 {
2297         DEBUG(5,("init_netdfs_r_dfs_RemoveStdRoot\n"));
2298
2299         v->status = status;
2300
2301         return True;
2302 }
2303
2304 BOOL netdfs_io_r_dfs_RemoveStdRoot(const char *desc, NETDFS_R_DFS_REMOVESTDROOT *v, prs_struct *ps, int depth)
2305 {
2306         if (v == NULL)
2307                 return False;
2308
2309         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_RemoveStdRoot");
2310         depth++;
2311         if (!prs_werror("status", ps, depth, &v->status))
2312                 return False;
2313
2314         return True;
2315 }
2316
2317 BOOL init_netdfs_q_dfs_ManagerInitialize(NETDFS_Q_DFS_MANAGERINITIALIZE *v)
2318 {
2319         DEBUG(5,("init_netdfs_q_dfs_ManagerInitialize\n"));
2320
2321         return True;
2322 }
2323
2324 BOOL netdfs_io_q_dfs_ManagerInitialize(const char *desc, NETDFS_Q_DFS_MANAGERINITIALIZE *v, prs_struct *ps, int depth)
2325 {
2326         if (v == NULL)
2327                 return False;
2328
2329         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_ManagerInitialize");
2330         depth++;
2331         return True;
2332 }
2333
2334 BOOL init_netdfs_r_dfs_ManagerInitialize(NETDFS_R_DFS_MANAGERINITIALIZE *v, WERROR status)
2335 {
2336         DEBUG(5,("init_netdfs_r_dfs_ManagerInitialize\n"));
2337
2338         v->status = status;
2339
2340         return True;
2341 }
2342
2343 BOOL netdfs_io_r_dfs_ManagerInitialize(const char *desc, NETDFS_R_DFS_MANAGERINITIALIZE *v, prs_struct *ps, int depth)
2344 {
2345         if (v == NULL)
2346                 return False;
2347
2348         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_ManagerInitialize");
2349         depth++;
2350         if (!prs_werror("status", ps, depth, &v->status))
2351                 return False;
2352
2353         return True;
2354 }
2355
2356 BOOL init_netdfs_q_dfs_AddStdRootForced(NETDFS_Q_DFS_ADDSTDROOTFORCED *v)
2357 {
2358         DEBUG(5,("init_netdfs_q_dfs_AddStdRootForced\n"));
2359
2360         return True;
2361 }
2362
2363 BOOL netdfs_io_q_dfs_AddStdRootForced(const char *desc, NETDFS_Q_DFS_ADDSTDROOTFORCED *v, prs_struct *ps, int depth)
2364 {
2365         if (v == NULL)
2366                 return False;
2367
2368         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_AddStdRootForced");
2369         depth++;
2370         return True;
2371 }
2372
2373 BOOL init_netdfs_r_dfs_AddStdRootForced(NETDFS_R_DFS_ADDSTDROOTFORCED *v, WERROR status)
2374 {
2375         DEBUG(5,("init_netdfs_r_dfs_AddStdRootForced\n"));
2376
2377         v->status = status;
2378
2379         return True;
2380 }
2381
2382 BOOL netdfs_io_r_dfs_AddStdRootForced(const char *desc, NETDFS_R_DFS_ADDSTDROOTFORCED *v, prs_struct *ps, int depth)
2383 {
2384         if (v == NULL)
2385                 return False;
2386
2387         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_AddStdRootForced");
2388         depth++;
2389         if (!prs_werror("status", ps, depth, &v->status))
2390                 return False;
2391
2392         return True;
2393 }
2394
2395 BOOL init_netdfs_q_dfs_GetDcAddress(NETDFS_Q_DFS_GETDCADDRESS *v)
2396 {
2397         DEBUG(5,("init_netdfs_q_dfs_GetDcAddress\n"));
2398
2399         return True;
2400 }
2401
2402 BOOL netdfs_io_q_dfs_GetDcAddress(const char *desc, NETDFS_Q_DFS_GETDCADDRESS *v, prs_struct *ps, int depth)
2403 {
2404         if (v == NULL)
2405                 return False;
2406
2407         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_GetDcAddress");
2408         depth++;
2409         return True;
2410 }
2411
2412 BOOL init_netdfs_r_dfs_GetDcAddress(NETDFS_R_DFS_GETDCADDRESS *v, WERROR status)
2413 {
2414         DEBUG(5,("init_netdfs_r_dfs_GetDcAddress\n"));
2415
2416         v->status = status;
2417
2418         return True;
2419 }
2420
2421 BOOL netdfs_io_r_dfs_GetDcAddress(const char *desc, NETDFS_R_DFS_GETDCADDRESS *v, prs_struct *ps, int depth)
2422 {
2423         if (v == NULL)
2424                 return False;
2425
2426         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_GetDcAddress");
2427         depth++;
2428         if (!prs_werror("status", ps, depth, &v->status))
2429                 return False;
2430
2431         return True;
2432 }
2433
2434 BOOL init_netdfs_q_dfs_SetDcAddress(NETDFS_Q_DFS_SETDCADDRESS *v)
2435 {
2436         DEBUG(5,("init_netdfs_q_dfs_SetDcAddress\n"));
2437
2438         return True;
2439 }
2440
2441 BOOL netdfs_io_q_dfs_SetDcAddress(const char *desc, NETDFS_Q_DFS_SETDCADDRESS *v, prs_struct *ps, int depth)
2442 {
2443         if (v == NULL)
2444                 return False;
2445
2446         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_SetDcAddress");
2447         depth++;
2448         return True;
2449 }
2450
2451 BOOL init_netdfs_r_dfs_SetDcAddress(NETDFS_R_DFS_SETDCADDRESS *v, WERROR status)
2452 {
2453         DEBUG(5,("init_netdfs_r_dfs_SetDcAddress\n"));
2454
2455         v->status = status;
2456
2457         return True;
2458 }
2459
2460 BOOL netdfs_io_r_dfs_SetDcAddress(const char *desc, NETDFS_R_DFS_SETDCADDRESS *v, prs_struct *ps, int depth)
2461 {
2462         if (v == NULL)
2463                 return False;
2464
2465         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_SetDcAddress");
2466         depth++;
2467         if (!prs_werror("status", ps, depth, &v->status))
2468                 return False;
2469
2470         return True;
2471 }
2472
2473 BOOL init_netdfs_q_dfs_FlushFtTable(NETDFS_Q_DFS_FLUSHFTTABLE *v)
2474 {
2475         DEBUG(5,("init_netdfs_q_dfs_FlushFtTable\n"));
2476
2477         return True;
2478 }
2479
2480 BOOL netdfs_io_q_dfs_FlushFtTable(const char *desc, NETDFS_Q_DFS_FLUSHFTTABLE *v, prs_struct *ps, int depth)
2481 {
2482         if (v == NULL)
2483                 return False;
2484
2485         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_FlushFtTable");
2486         depth++;
2487         return True;
2488 }
2489
2490 BOOL init_netdfs_r_dfs_FlushFtTable(NETDFS_R_DFS_FLUSHFTTABLE *v, WERROR status)
2491 {
2492         DEBUG(5,("init_netdfs_r_dfs_FlushFtTable\n"));
2493
2494         v->status = status;
2495
2496         return True;
2497 }
2498
2499 BOOL netdfs_io_r_dfs_FlushFtTable(const char *desc, NETDFS_R_DFS_FLUSHFTTABLE *v, prs_struct *ps, int depth)
2500 {
2501         if (v == NULL)
2502                 return False;
2503
2504         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_FlushFtTable");
2505         depth++;
2506         if (!prs_werror("status", ps, depth, &v->status))
2507                 return False;
2508
2509         return True;
2510 }
2511
2512 BOOL init_netdfs_q_dfs_Add2(NETDFS_Q_DFS_ADD2 *v)
2513 {
2514         DEBUG(5,("init_netdfs_q_dfs_Add2\n"));
2515
2516         return True;
2517 }
2518
2519 BOOL netdfs_io_q_dfs_Add2(const char *desc, NETDFS_Q_DFS_ADD2 *v, prs_struct *ps, int depth)
2520 {
2521         if (v == NULL)
2522                 return False;
2523
2524         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Add2");
2525         depth++;
2526         return True;
2527 }
2528
2529 BOOL init_netdfs_r_dfs_Add2(NETDFS_R_DFS_ADD2 *v, WERROR status)
2530 {
2531         DEBUG(5,("init_netdfs_r_dfs_Add2\n"));
2532
2533         v->status = status;
2534
2535         return True;
2536 }
2537
2538 BOOL netdfs_io_r_dfs_Add2(const char *desc, NETDFS_R_DFS_ADD2 *v, prs_struct *ps, int depth)
2539 {
2540         if (v == NULL)
2541                 return False;
2542
2543         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Add2");
2544         depth++;
2545         if (!prs_werror("status", ps, depth, &v->status))
2546                 return False;
2547
2548         return True;
2549 }
2550
2551 BOOL init_netdfs_q_dfs_Remove2(NETDFS_Q_DFS_REMOVE2 *v)
2552 {
2553         DEBUG(5,("init_netdfs_q_dfs_Remove2\n"));
2554
2555         return True;
2556 }
2557
2558 BOOL netdfs_io_q_dfs_Remove2(const char *desc, NETDFS_Q_DFS_REMOVE2 *v, prs_struct *ps, int depth)
2559 {
2560         if (v == NULL)
2561                 return False;
2562
2563         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_Remove2");
2564         depth++;
2565         return True;
2566 }
2567
2568 BOOL init_netdfs_r_dfs_Remove2(NETDFS_R_DFS_REMOVE2 *v, WERROR status)
2569 {
2570         DEBUG(5,("init_netdfs_r_dfs_Remove2\n"));
2571
2572         v->status = status;
2573
2574         return True;
2575 }
2576
2577 BOOL netdfs_io_r_dfs_Remove2(const char *desc, NETDFS_R_DFS_REMOVE2 *v, prs_struct *ps, int depth)
2578 {
2579         if (v == NULL)
2580                 return False;
2581
2582         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_Remove2");
2583         depth++;
2584         if (!prs_werror("status", ps, depth, &v->status))
2585                 return False;
2586
2587         return True;
2588 }
2589
2590 BOOL init_netdfs_q_dfs_EnumEx(NETDFS_Q_DFS_ENUMEX *v)
2591 {
2592         DEBUG(5,("init_netdfs_q_dfs_EnumEx\n"));
2593
2594         return True;
2595 }
2596
2597 BOOL netdfs_io_q_dfs_EnumEx(const char *desc, NETDFS_Q_DFS_ENUMEX *v, prs_struct *ps, int depth)
2598 {
2599         if (v == NULL)
2600                 return False;
2601
2602         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_EnumEx");
2603         depth++;
2604         return True;
2605 }
2606
2607 BOOL init_netdfs_r_dfs_EnumEx(NETDFS_R_DFS_ENUMEX *v, WERROR status)
2608 {
2609         DEBUG(5,("init_netdfs_r_dfs_EnumEx\n"));
2610
2611         v->status = status;
2612
2613         return True;
2614 }
2615
2616 BOOL netdfs_io_r_dfs_EnumEx(const char *desc, NETDFS_R_DFS_ENUMEX *v, prs_struct *ps, int depth)
2617 {
2618         if (v == NULL)
2619                 return False;
2620
2621         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_EnumEx");
2622         depth++;
2623         if (!prs_werror("status", ps, depth, &v->status))
2624                 return False;
2625
2626         return True;
2627 }
2628
2629 BOOL init_netdfs_q_dfs_SetInfo2(NETDFS_Q_DFS_SETINFO2 *v)
2630 {
2631         DEBUG(5,("init_netdfs_q_dfs_SetInfo2\n"));
2632
2633         return True;
2634 }
2635
2636 BOOL netdfs_io_q_dfs_SetInfo2(const char *desc, NETDFS_Q_DFS_SETINFO2 *v, prs_struct *ps, int depth)
2637 {
2638         if (v == NULL)
2639                 return False;
2640
2641         prs_debug(ps, depth, desc, "netdfs_io_q_dfs_SetInfo2");
2642         depth++;
2643         return True;
2644 }
2645
2646 BOOL init_netdfs_r_dfs_SetInfo2(NETDFS_R_DFS_SETINFO2 *v, WERROR status)
2647 {
2648         DEBUG(5,("init_netdfs_r_dfs_SetInfo2\n"));
2649
2650         v->status = status;
2651
2652         return True;
2653 }
2654
2655 BOOL netdfs_io_r_dfs_SetInfo2(const char *desc, NETDFS_R_DFS_SETINFO2 *v, prs_struct *ps, int depth)
2656 {
2657         if (v == NULL)
2658                 return False;
2659
2660         prs_debug(ps, depth, desc, "netdfs_io_r_dfs_SetInfo2");
2661         depth++;
2662         if (!prs_werror("status", ps, depth, &v->status))
2663                 return False;
2664
2665         return True;
2666 }
2667