source3/librpc/gen_ndr/srv_dfs.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * server auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "librpc/gen_ndr/srv_dfs.h"
   8
   9 static bool api_dfs_GetManagerVersion(pipes_struct *p)
  10 {
  11         const struct ndr_interface_call *call;
  12         struct ndr_pull *pull;
  13         struct ndr_push *push;
  14         enum ndr_err_code ndr_err;
  15         DATA_BLOB blob;
  16         struct dfs_GetManagerVersion *r;
  17
  18         call = &ndr_table_netdfs.calls[NDR_DFS_GETMANAGERVERSION];
  19
  20         r = talloc(NULL, struct dfs_GetManagerVersion);
  21         if (r == NULL) {
  22                 return false;
  23         }
  24
  25         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
  26                 talloc_free(r);
  27                 return false;
  28         }
  29
  30         pull = ndr_pull_init_blob(&blob, r);
  31         if (pull == NULL) {
  32                 talloc_free(r);
  33                 return false;
  34         }
  35
  36         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
  37         ndr_err = call->ndr_pull(pull, NDR_IN, r);
  38         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  39                 talloc_free(r);
  40                 return false;
  41         }
  42
  43         if (DEBUGLEVEL >= 10) {
  44                 NDR_PRINT_IN_DEBUG(dfs_GetManagerVersion, r);
  45         }
  46
  47         ZERO_STRUCT(r->out);
  48         r->out.version = talloc_zero(r, enum dfs_ManagerVersion);
  49         if (r->out.version == NULL) {
  50                 talloc_free(r);
  51                 return false;
  52         }
  53
  54         _dfs_GetManagerVersion(p, r);
  55
  56         if (p->rng_fault_state) {
  57                 talloc_free(r);
  58                 /* Return true here, srv_pipe_hnd.c will take care */
  59                 return true;
  60         }
  61
  62         if (DEBUGLEVEL >= 10) {
  63                 NDR_PRINT_OUT_DEBUG(dfs_GetManagerVersion, r);
  64         }
  65
  66         push = ndr_push_init_ctx(r);
  67         if (push == NULL) {
  68                 talloc_free(r);
  69                 return false;
  70         }
  71
  72         ndr_err = call->ndr_push(push, NDR_OUT, r);
  73         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  74                 talloc_free(r);
  75                 return false;
  76         }
  77
  78         blob = ndr_push_blob(push);
  79         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
  80                 talloc_free(r);
  81                 return false;
  82         }
  83
  84         talloc_free(r);
  85
  86         return true;
  87 }
  88
  89 static bool api_dfs_Add(pipes_struct *p)
  90 {
  91         const struct ndr_interface_call *call;
  92         struct ndr_pull *pull;
  93         struct ndr_push *push;
  94         enum ndr_err_code ndr_err;
  95         DATA_BLOB blob;
  96         struct dfs_Add *r;
  97
  98         call = &ndr_table_netdfs.calls[NDR_DFS_ADD];
  99
 100         r = talloc(NULL, struct dfs_Add);
 101         if (r == NULL) {
 102                 return false;
 103         }
 104
 105         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 106                 talloc_free(r);
 107                 return false;
 108         }
 109
 110         pull = ndr_pull_init_blob(&blob, r);
 111         if (pull == NULL) {
 112                 talloc_free(r);
 113                 return false;
 114         }
 115
 116         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 117         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 118         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 119                 talloc_free(r);
 120                 return false;
 121         }
 122
 123         if (DEBUGLEVEL >= 10) {
 124                 NDR_PRINT_IN_DEBUG(dfs_Add, r);
 125         }
 126
 127         r->out.result = _dfs_Add(p, r);
 128
 129         if (p->rng_fault_state) {
 130                 talloc_free(r);
 131                 /* Return true here, srv_pipe_hnd.c will take care */
 132                 return true;
 133         }
 134
 135         if (DEBUGLEVEL >= 10) {
 136                 NDR_PRINT_OUT_DEBUG(dfs_Add, r);
 137         }
 138
 139         push = ndr_push_init_ctx(r);
 140         if (push == NULL) {
 141                 talloc_free(r);
 142                 return false;
 143         }
 144
 145         ndr_err = call->ndr_push(push, NDR_OUT, r);
 146         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 147                 talloc_free(r);
 148                 return false;
 149         }
 150
 151         blob = ndr_push_blob(push);
 152         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 153                 talloc_free(r);
 154                 return false;
 155         }
 156
 157         talloc_free(r);
 158
 159         return true;
 160 }
 161
 162 static bool api_dfs_Remove(pipes_struct *p)
 163 {
 164         const struct ndr_interface_call *call;
 165         struct ndr_pull *pull;
 166         struct ndr_push *push;
 167         enum ndr_err_code ndr_err;
 168         DATA_BLOB blob;
 169         struct dfs_Remove *r;
 170
 171         call = &ndr_table_netdfs.calls[NDR_DFS_REMOVE];
 172
 173         r = talloc(NULL, struct dfs_Remove);
 174         if (r == NULL) {
 175                 return false;
 176         }
 177
 178         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 179                 talloc_free(r);
 180                 return false;
 181         }
 182
 183         pull = ndr_pull_init_blob(&blob, r);
 184         if (pull == NULL) {
 185                 talloc_free(r);
 186                 return false;
 187         }
 188
 189         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 190         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 191         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 192                 talloc_free(r);
 193                 return false;
 194         }
 195
 196         if (DEBUGLEVEL >= 10) {
 197                 NDR_PRINT_IN_DEBUG(dfs_Remove, r);
 198         }
 199
 200         r->out.result = _dfs_Remove(p, r);
 201
 202         if (p->rng_fault_state) {
 203                 talloc_free(r);
 204                 /* Return true here, srv_pipe_hnd.c will take care */
 205                 return true;
 206         }
 207
 208         if (DEBUGLEVEL >= 10) {
 209                 NDR_PRINT_OUT_DEBUG(dfs_Remove, r);
 210         }
 211
 212         push = ndr_push_init_ctx(r);
 213         if (push == NULL) {
 214                 talloc_free(r);
 215                 return false;
 216         }
 217
 218         ndr_err = call->ndr_push(push, NDR_OUT, r);
 219         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 220                 talloc_free(r);
 221                 return false;
 222         }
 223
 224         blob = ndr_push_blob(push);
 225         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 226                 talloc_free(r);
 227                 return false;
 228         }
 229
 230         talloc_free(r);
 231
 232         return true;
 233 }
 234
 235 static bool api_dfs_SetInfo(pipes_struct *p)
 236 {
 237         const struct ndr_interface_call *call;
 238         struct ndr_pull *pull;
 239         struct ndr_push *push;
 240         enum ndr_err_code ndr_err;
 241         DATA_BLOB blob;
 242         struct dfs_SetInfo *r;
 243
 244         call = &ndr_table_netdfs.calls[NDR_DFS_SETINFO];
 245
 246         r = talloc(NULL, struct dfs_SetInfo);
 247         if (r == NULL) {
 248                 return false;
 249         }
 250
 251         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 252                 talloc_free(r);
 253                 return false;
 254         }
 255
 256         pull = ndr_pull_init_blob(&blob, r);
 257         if (pull == NULL) {
 258                 talloc_free(r);
 259                 return false;
 260         }
 261
 262         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 263         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 264         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 265                 talloc_free(r);
 266                 return false;
 267         }
 268
 269         if (DEBUGLEVEL >= 10) {
 270                 NDR_PRINT_IN_DEBUG(dfs_SetInfo, r);
 271         }
 272
 273         r->out.result = _dfs_SetInfo(p, r);
 274
 275         if (p->rng_fault_state) {
 276                 talloc_free(r);
 277                 /* Return true here, srv_pipe_hnd.c will take care */
 278                 return true;
 279         }
 280
 281         if (DEBUGLEVEL >= 10) {
 282                 NDR_PRINT_OUT_DEBUG(dfs_SetInfo, r);
 283         }
 284
 285         push = ndr_push_init_ctx(r);
 286         if (push == NULL) {
 287                 talloc_free(r);
 288                 return false;
 289         }
 290
 291         ndr_err = call->ndr_push(push, NDR_OUT, r);
 292         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 293                 talloc_free(r);
 294                 return false;
 295         }
 296
 297         blob = ndr_push_blob(push);
 298         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 299                 talloc_free(r);
 300                 return false;
 301         }
 302
 303         talloc_free(r);
 304
 305         return true;
 306 }
 307
 308 static bool api_dfs_GetInfo(pipes_struct *p)
 309 {
 310         const struct ndr_interface_call *call;
 311         struct ndr_pull *pull;
 312         struct ndr_push *push;
 313         enum ndr_err_code ndr_err;
 314         DATA_BLOB blob;
 315         struct dfs_GetInfo *r;
 316
 317         call = &ndr_table_netdfs.calls[NDR_DFS_GETINFO];
 318
 319         r = talloc(NULL, struct dfs_GetInfo);
 320         if (r == NULL) {
 321                 return false;
 322         }
 323
 324         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 325                 talloc_free(r);
 326                 return false;
 327         }
 328
 329         pull = ndr_pull_init_blob(&blob, r);
 330         if (pull == NULL) {
 331                 talloc_free(r);
 332                 return false;
 333         }
 334
 335         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 336         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 337         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 338                 talloc_free(r);
 339                 return false;
 340         }
 341
 342         if (DEBUGLEVEL >= 10) {
 343                 NDR_PRINT_IN_DEBUG(dfs_GetInfo, r);
 344         }
 345
 346         ZERO_STRUCT(r->out);
 347         r->out.info = talloc_zero(r, union dfs_Info);
 348         if (r->out.info == NULL) {
 349                 talloc_free(r);
 350                 return false;
 351         }
 352
 353         r->out.result = _dfs_GetInfo(p, r);
 354
 355         if (p->rng_fault_state) {
 356                 talloc_free(r);
 357                 /* Return true here, srv_pipe_hnd.c will take care */
 358                 return true;
 359         }
 360
 361         if (DEBUGLEVEL >= 10) {
 362                 NDR_PRINT_OUT_DEBUG(dfs_GetInfo, r);
 363         }
 364
 365         push = ndr_push_init_ctx(r);
 366         if (push == NULL) {
 367                 talloc_free(r);
 368                 return false;
 369         }
 370
 371         ndr_err = call->ndr_push(push, NDR_OUT, r);
 372         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 373                 talloc_free(r);
 374                 return false;
 375         }
 376
 377         blob = ndr_push_blob(push);
 378         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 379                 talloc_free(r);
 380                 return false;
 381         }
 382
 383         talloc_free(r);
 384
 385         return true;
 386 }
 387
 388 static bool api_dfs_Enum(pipes_struct *p)
 389 {
 390         const struct ndr_interface_call *call;
 391         struct ndr_pull *pull;
 392         struct ndr_push *push;
 393         enum ndr_err_code ndr_err;
 394         DATA_BLOB blob;
 395         struct dfs_Enum *r;
 396
 397         call = &ndr_table_netdfs.calls[NDR_DFS_ENUM];
 398
 399         r = talloc(NULL, struct dfs_Enum);
 400         if (r == NULL) {
 401                 return false;
 402         }
 403
 404         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 405                 talloc_free(r);
 406                 return false;
 407         }
 408
 409         pull = ndr_pull_init_blob(&blob, r);
 410         if (pull == NULL) {
 411                 talloc_free(r);
 412                 return false;
 413         }
 414
 415         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 416         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 417         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 418                 talloc_free(r);
 419                 return false;
 420         }
 421
 422         if (DEBUGLEVEL >= 10) {
 423                 NDR_PRINT_IN_DEBUG(dfs_Enum, r);
 424         }
 425
 426         ZERO_STRUCT(r->out);
 427         r->out.info = r->in.info;
 428         r->out.total = r->in.total;
 429         r->out.result = _dfs_Enum(p, r);
 430
 431         if (p->rng_fault_state) {
 432                 talloc_free(r);
 433                 /* Return true here, srv_pipe_hnd.c will take care */
 434                 return true;
 435         }
 436
 437         if (DEBUGLEVEL >= 10) {
 438                 NDR_PRINT_OUT_DEBUG(dfs_Enum, r);
 439         }
 440
 441         push = ndr_push_init_ctx(r);
 442         if (push == NULL) {
 443                 talloc_free(r);
 444                 return false;
 445         }
 446
 447         ndr_err = call->ndr_push(push, NDR_OUT, r);
 448         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 449                 talloc_free(r);
 450                 return false;
 451         }
 452
 453         blob = ndr_push_blob(push);
 454         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 455                 talloc_free(r);
 456                 return false;
 457         }
 458
 459         talloc_free(r);
 460
 461         return true;
 462 }
 463
 464 static bool api_dfs_Rename(pipes_struct *p)
 465 {
 466         const struct ndr_interface_call *call;
 467         struct ndr_pull *pull;
 468         struct ndr_push *push;
 469         enum ndr_err_code ndr_err;
 470         DATA_BLOB blob;
 471         struct dfs_Rename *r;
 472
 473         call = &ndr_table_netdfs.calls[NDR_DFS_RENAME];
 474
 475         r = talloc(NULL, struct dfs_Rename);
 476         if (r == NULL) {
 477                 return false;
 478         }
 479
 480         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 481                 talloc_free(r);
 482                 return false;
 483         }
 484
 485         pull = ndr_pull_init_blob(&blob, r);
 486         if (pull == NULL) {
 487                 talloc_free(r);
 488                 return false;
 489         }
 490
 491         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 492         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 493         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 494                 talloc_free(r);
 495                 return false;
 496         }
 497
 498         if (DEBUGLEVEL >= 10) {
 499                 NDR_PRINT_IN_DEBUG(dfs_Rename, r);
 500         }
 501
 502         r->out.result = _dfs_Rename(p, r);
 503
 504         if (p->rng_fault_state) {
 505                 talloc_free(r);
 506                 /* Return true here, srv_pipe_hnd.c will take care */
 507                 return true;
 508         }
 509
 510         if (DEBUGLEVEL >= 10) {
 511                 NDR_PRINT_OUT_DEBUG(dfs_Rename, r);
 512         }
 513
 514         push = ndr_push_init_ctx(r);
 515         if (push == NULL) {
 516                 talloc_free(r);
 517                 return false;
 518         }
 519
 520         ndr_err = call->ndr_push(push, NDR_OUT, r);
 521         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 522                 talloc_free(r);
 523                 return false;
 524         }
 525
 526         blob = ndr_push_blob(push);
 527         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 528                 talloc_free(r);
 529                 return false;
 530         }
 531
 532         talloc_free(r);
 533
 534         return true;
 535 }
 536
 537 static bool api_dfs_Move(pipes_struct *p)
 538 {
 539         const struct ndr_interface_call *call;
 540         struct ndr_pull *pull;
 541         struct ndr_push *push;
 542         enum ndr_err_code ndr_err;
 543         DATA_BLOB blob;
 544         struct dfs_Move *r;
 545
 546         call = &ndr_table_netdfs.calls[NDR_DFS_MOVE];
 547
 548         r = talloc(NULL, struct dfs_Move);
 549         if (r == NULL) {
 550                 return false;
 551         }
 552
 553         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 554                 talloc_free(r);
 555                 return false;
 556         }
 557
 558         pull = ndr_pull_init_blob(&blob, r);
 559         if (pull == NULL) {
 560                 talloc_free(r);
 561                 return false;
 562         }
 563
 564         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 565         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 566         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 567                 talloc_free(r);
 568                 return false;
 569         }
 570
 571         if (DEBUGLEVEL >= 10) {
 572                 NDR_PRINT_IN_DEBUG(dfs_Move, r);
 573         }
 574
 575         r->out.result = _dfs_Move(p, r);
 576
 577         if (p->rng_fault_state) {
 578                 talloc_free(r);
 579                 /* Return true here, srv_pipe_hnd.c will take care */
 580                 return true;
 581         }
 582
 583         if (DEBUGLEVEL >= 10) {
 584                 NDR_PRINT_OUT_DEBUG(dfs_Move, r);
 585         }
 586
 587         push = ndr_push_init_ctx(r);
 588         if (push == NULL) {
 589                 talloc_free(r);
 590                 return false;
 591         }
 592
 593         ndr_err = call->ndr_push(push, NDR_OUT, r);
 594         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 595                 talloc_free(r);
 596                 return false;
 597         }
 598
 599         blob = ndr_push_blob(push);
 600         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 601                 talloc_free(r);
 602                 return false;
 603         }
 604
 605         talloc_free(r);
 606
 607         return true;
 608 }
 609
 610 static bool api_dfs_ManagerGetConfigInfo(pipes_struct *p)
 611 {
 612         const struct ndr_interface_call *call;
 613         struct ndr_pull *pull;
 614         struct ndr_push *push;
 615         enum ndr_err_code ndr_err;
 616         DATA_BLOB blob;
 617         struct dfs_ManagerGetConfigInfo *r;
 618
 619         call = &ndr_table_netdfs.calls[NDR_DFS_MANAGERGETCONFIGINFO];
 620
 621         r = talloc(NULL, struct dfs_ManagerGetConfigInfo);
 622         if (r == NULL) {
 623                 return false;
 624         }
 625
 626         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 627                 talloc_free(r);
 628                 return false;
 629         }
 630
 631         pull = ndr_pull_init_blob(&blob, r);
 632         if (pull == NULL) {
 633                 talloc_free(r);
 634                 return false;
 635         }
 636
 637         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 638         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 639         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 640                 talloc_free(r);
 641                 return false;
 642         }
 643
 644         if (DEBUGLEVEL >= 10) {
 645                 NDR_PRINT_IN_DEBUG(dfs_ManagerGetConfigInfo, r);
 646         }
 647
 648         r->out.result = _dfs_ManagerGetConfigInfo(p, r);
 649
 650         if (p->rng_fault_state) {
 651                 talloc_free(r);
 652                 /* Return true here, srv_pipe_hnd.c will take care */
 653                 return true;
 654         }
 655
 656         if (DEBUGLEVEL >= 10) {
 657                 NDR_PRINT_OUT_DEBUG(dfs_ManagerGetConfigInfo, r);
 658         }
 659
 660         push = ndr_push_init_ctx(r);
 661         if (push == NULL) {
 662                 talloc_free(r);
 663                 return false;
 664         }
 665
 666         ndr_err = call->ndr_push(push, NDR_OUT, r);
 667         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 668                 talloc_free(r);
 669                 return false;
 670         }
 671
 672         blob = ndr_push_blob(push);
 673         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 674                 talloc_free(r);
 675                 return false;
 676         }
 677
 678         talloc_free(r);
 679
 680         return true;
 681 }
 682
 683 static bool api_dfs_ManagerSendSiteInfo(pipes_struct *p)
 684 {
 685         const struct ndr_interface_call *call;
 686         struct ndr_pull *pull;
 687         struct ndr_push *push;
 688         enum ndr_err_code ndr_err;
 689         DATA_BLOB blob;
 690         struct dfs_ManagerSendSiteInfo *r;
 691
 692         call = &ndr_table_netdfs.calls[NDR_DFS_MANAGERSENDSITEINFO];
 693
 694         r = talloc(NULL, struct dfs_ManagerSendSiteInfo);
 695         if (r == NULL) {
 696                 return false;
 697         }
 698
 699         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 700                 talloc_free(r);
 701                 return false;
 702         }
 703
 704         pull = ndr_pull_init_blob(&blob, r);
 705         if (pull == NULL) {
 706                 talloc_free(r);
 707                 return false;
 708         }
 709
 710         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 711         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 712         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 713                 talloc_free(r);
 714                 return false;
 715         }
 716
 717         if (DEBUGLEVEL >= 10) {
 718                 NDR_PRINT_IN_DEBUG(dfs_ManagerSendSiteInfo, r);
 719         }
 720
 721         r->out.result = _dfs_ManagerSendSiteInfo(p, r);
 722
 723         if (p->rng_fault_state) {
 724                 talloc_free(r);
 725                 /* Return true here, srv_pipe_hnd.c will take care */
 726                 return true;
 727         }
 728
 729         if (DEBUGLEVEL >= 10) {
 730                 NDR_PRINT_OUT_DEBUG(dfs_ManagerSendSiteInfo, r);
 731         }
 732
 733         push = ndr_push_init_ctx(r);
 734         if (push == NULL) {
 735                 talloc_free(r);
 736                 return false;
 737         }
 738
 739         ndr_err = call->ndr_push(push, NDR_OUT, r);
 740         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 741                 talloc_free(r);
 742                 return false;
 743         }
 744
 745         blob = ndr_push_blob(push);
 746         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 747                 talloc_free(r);
 748                 return false;
 749         }
 750
 751         talloc_free(r);
 752
 753         return true;
 754 }
 755
 756 static bool api_dfs_AddFtRoot(pipes_struct *p)
 757 {
 758         const struct ndr_interface_call *call;
 759         struct ndr_pull *pull;
 760         struct ndr_push *push;
 761         enum ndr_err_code ndr_err;
 762         DATA_BLOB blob;
 763         struct dfs_AddFtRoot *r;
 764
 765         call = &ndr_table_netdfs.calls[NDR_DFS_ADDFTROOT];
 766
 767         r = talloc(NULL, struct dfs_AddFtRoot);
 768         if (r == NULL) {
 769                 return false;
 770         }
 771
 772         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 773                 talloc_free(r);
 774                 return false;
 775         }
 776
 777         pull = ndr_pull_init_blob(&blob, r);
 778         if (pull == NULL) {
 779                 talloc_free(r);
 780                 return false;
 781         }
 782
 783         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 784         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 785         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 786                 talloc_free(r);
 787                 return false;
 788         }
 789
 790         if (DEBUGLEVEL >= 10) {
 791                 NDR_PRINT_IN_DEBUG(dfs_AddFtRoot, r);
 792         }
 793
 794         ZERO_STRUCT(r->out);
 795         r->out.unknown2 = r->in.unknown2;
 796         r->out.result = _dfs_AddFtRoot(p, r);
 797
 798         if (p->rng_fault_state) {
 799                 talloc_free(r);
 800                 /* Return true here, srv_pipe_hnd.c will take care */
 801                 return true;
 802         }
 803
 804         if (DEBUGLEVEL >= 10) {
 805                 NDR_PRINT_OUT_DEBUG(dfs_AddFtRoot, r);
 806         }
 807
 808         push = ndr_push_init_ctx(r);
 809         if (push == NULL) {
 810                 talloc_free(r);
 811                 return false;
 812         }
 813
 814         ndr_err = call->ndr_push(push, NDR_OUT, r);
 815         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 816                 talloc_free(r);
 817                 return false;
 818         }
 819
 820         blob = ndr_push_blob(push);
 821         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 822                 talloc_free(r);
 823                 return false;
 824         }
 825
 826         talloc_free(r);
 827
 828         return true;
 829 }
 830
 831 static bool api_dfs_RemoveFtRoot(pipes_struct *p)
 832 {
 833         const struct ndr_interface_call *call;
 834         struct ndr_pull *pull;
 835         struct ndr_push *push;
 836         enum ndr_err_code ndr_err;
 837         DATA_BLOB blob;
 838         struct dfs_RemoveFtRoot *r;
 839
 840         call = &ndr_table_netdfs.calls[NDR_DFS_REMOVEFTROOT];
 841
 842         r = talloc(NULL, struct dfs_RemoveFtRoot);
 843         if (r == NULL) {
 844                 return false;
 845         }
 846
 847         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 848                 talloc_free(r);
 849                 return false;
 850         }
 851
 852         pull = ndr_pull_init_blob(&blob, r);
 853         if (pull == NULL) {
 854                 talloc_free(r);
 855                 return false;
 856         }
 857
 858         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 859         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 860         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 861                 talloc_free(r);
 862                 return false;
 863         }
 864
 865         if (DEBUGLEVEL >= 10) {
 866                 NDR_PRINT_IN_DEBUG(dfs_RemoveFtRoot, r);
 867         }
 868
 869         ZERO_STRUCT(r->out);
 870         r->out.unknown = r->in.unknown;
 871         r->out.result = _dfs_RemoveFtRoot(p, r);
 872
 873         if (p->rng_fault_state) {
 874                 talloc_free(r);
 875                 /* Return true here, srv_pipe_hnd.c will take care */
 876                 return true;
 877         }
 878
 879         if (DEBUGLEVEL >= 10) {
 880                 NDR_PRINT_OUT_DEBUG(dfs_RemoveFtRoot, r);
 881         }
 882
 883         push = ndr_push_init_ctx(r);
 884         if (push == NULL) {
 885                 talloc_free(r);
 886                 return false;
 887         }
 888
 889         ndr_err = call->ndr_push(push, NDR_OUT, r);
 890         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 891                 talloc_free(r);
 892                 return false;
 893         }
 894
 895         blob = ndr_push_blob(push);
 896         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 897                 talloc_free(r);
 898                 return false;
 899         }
 900
 901         talloc_free(r);
 902
 903         return true;
 904 }
 905
 906 static bool api_dfs_AddStdRoot(pipes_struct *p)
 907 {
 908         const struct ndr_interface_call *call;
 909         struct ndr_pull *pull;
 910         struct ndr_push *push;
 911         enum ndr_err_code ndr_err;
 912         DATA_BLOB blob;
 913         struct dfs_AddStdRoot *r;
 914
 915         call = &ndr_table_netdfs.calls[NDR_DFS_ADDSTDROOT];
 916
 917         r = talloc(NULL, struct dfs_AddStdRoot);
 918         if (r == NULL) {
 919                 return false;
 920         }
 921
 922         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 923                 talloc_free(r);
 924                 return false;
 925         }
 926
 927         pull = ndr_pull_init_blob(&blob, r);
 928         if (pull == NULL) {
 929                 talloc_free(r);
 930                 return false;
 931         }
 932
 933         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 934         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 935         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 936                 talloc_free(r);
 937                 return false;
 938         }
 939
 940         if (DEBUGLEVEL >= 10) {
 941                 NDR_PRINT_IN_DEBUG(dfs_AddStdRoot, r);
 942         }
 943
 944         r->out.result = _dfs_AddStdRoot(p, r);
 945
 946         if (p->rng_fault_state) {
 947                 talloc_free(r);
 948                 /* Return true here, srv_pipe_hnd.c will take care */
 949                 return true;
 950         }
 951
 952         if (DEBUGLEVEL >= 10) {
 953                 NDR_PRINT_OUT_DEBUG(dfs_AddStdRoot, r);
 954         }
 955
 956         push = ndr_push_init_ctx(r);
 957         if (push == NULL) {
 958                 talloc_free(r);
 959                 return false;
 960         }
 961
 962         ndr_err = call->ndr_push(push, NDR_OUT, r);
 963         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 964                 talloc_free(r);
 965                 return false;
 966         }
 967
 968         blob = ndr_push_blob(push);
 969         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 970                 talloc_free(r);
 971                 return false;
 972         }
 973
 974         talloc_free(r);
 975
 976         return true;
 977 }
 978
 979 static bool api_dfs_RemoveStdRoot(pipes_struct *p)
 980 {
 981         const struct ndr_interface_call *call;
 982         struct ndr_pull *pull;
 983         struct ndr_push *push;
 984         enum ndr_err_code ndr_err;
 985         DATA_BLOB blob;
 986         struct dfs_RemoveStdRoot *r;
 987
 988         call = &ndr_table_netdfs.calls[NDR_DFS_REMOVESTDROOT];
 989
 990         r = talloc(NULL, struct dfs_RemoveStdRoot);
 991         if (r == NULL) {
 992                 return false;
 993         }
 994
 995         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 996                 talloc_free(r);
 997                 return false;
 998         }
 999
1000         pull = ndr_pull_init_blob(&blob, r);
1001         if (pull == NULL) {
1002                 talloc_free(r);
1003                 return false;
1004         }
1005
1006         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1007         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1008         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1009                 talloc_free(r);
1010                 return false;
1011         }
1012
1013         if (DEBUGLEVEL >= 10) {
1014                 NDR_PRINT_IN_DEBUG(dfs_RemoveStdRoot, r);
1015         }
1016
1017         r->out.result = _dfs_RemoveStdRoot(p, r);
1018
1019         if (p->rng_fault_state) {
1020                 talloc_free(r);
1021                 /* Return true here, srv_pipe_hnd.c will take care */
1022                 return true;
1023         }
1024
1025         if (DEBUGLEVEL >= 10) {
1026                 NDR_PRINT_OUT_DEBUG(dfs_RemoveStdRoot, r);
1027         }
1028
1029         push = ndr_push_init_ctx(r);
1030         if (push == NULL) {
1031                 talloc_free(r);
1032                 return false;
1033         }
1034
1035         ndr_err = call->ndr_push(push, NDR_OUT, r);
1036         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1037                 talloc_free(r);
1038                 return false;
1039         }
1040
1041         blob = ndr_push_blob(push);
1042         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1043                 talloc_free(r);
1044                 return false;
1045         }
1046
1047         talloc_free(r);
1048
1049         return true;
1050 }
1051
1052 static bool api_dfs_ManagerInitialize(pipes_struct *p)
1053 {
1054         const struct ndr_interface_call *call;
1055         struct ndr_pull *pull;
1056         struct ndr_push *push;
1057         enum ndr_err_code ndr_err;
1058         DATA_BLOB blob;
1059         struct dfs_ManagerInitialize *r;
1060
1061         call = &ndr_table_netdfs.calls[NDR_DFS_MANAGERINITIALIZE];
1062
1063         r = talloc(NULL, struct dfs_ManagerInitialize);
1064         if (r == NULL) {
1065                 return false;
1066         }
1067
1068         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1069                 talloc_free(r);
1070                 return false;
1071         }
1072
1073         pull = ndr_pull_init_blob(&blob, r);
1074         if (pull == NULL) {
1075                 talloc_free(r);
1076                 return false;
1077         }
1078
1079         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1080         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1081         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1082                 talloc_free(r);
1083                 return false;
1084         }
1085
1086         if (DEBUGLEVEL >= 10) {
1087                 NDR_PRINT_IN_DEBUG(dfs_ManagerInitialize, r);
1088         }
1089
1090         r->out.result = _dfs_ManagerInitialize(p, r);
1091
1092         if (p->rng_fault_state) {
1093                 talloc_free(r);
1094                 /* Return true here, srv_pipe_hnd.c will take care */
1095                 return true;
1096         }
1097
1098         if (DEBUGLEVEL >= 10) {
1099                 NDR_PRINT_OUT_DEBUG(dfs_ManagerInitialize, r);
1100         }
1101
1102         push = ndr_push_init_ctx(r);
1103         if (push == NULL) {
1104                 talloc_free(r);
1105                 return false;
1106         }
1107
1108         ndr_err = call->ndr_push(push, NDR_OUT, r);
1109         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1110                 talloc_free(r);
1111                 return false;
1112         }
1113
1114         blob = ndr_push_blob(push);
1115         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1116                 talloc_free(r);
1117                 return false;
1118         }
1119
1120         talloc_free(r);
1121
1122         return true;
1123 }
1124
1125 static bool api_dfs_AddStdRootForced(pipes_struct *p)
1126 {
1127         const struct ndr_interface_call *call;
1128         struct ndr_pull *pull;
1129         struct ndr_push *push;
1130         enum ndr_err_code ndr_err;
1131         DATA_BLOB blob;
1132         struct dfs_AddStdRootForced *r;
1133
1134         call = &ndr_table_netdfs.calls[NDR_DFS_ADDSTDROOTFORCED];
1135
1136         r = talloc(NULL, struct dfs_AddStdRootForced);
1137         if (r == NULL) {
1138                 return false;
1139         }
1140
1141         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1142                 talloc_free(r);
1143                 return false;
1144         }
1145
1146         pull = ndr_pull_init_blob(&blob, r);
1147         if (pull == NULL) {
1148                 talloc_free(r);
1149                 return false;
1150         }
1151
1152         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1153         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1154         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1155                 talloc_free(r);
1156                 return false;
1157         }
1158
1159         if (DEBUGLEVEL >= 10) {
1160                 NDR_PRINT_IN_DEBUG(dfs_AddStdRootForced, r);
1161         }
1162
1163         r->out.result = _dfs_AddStdRootForced(p, r);
1164
1165         if (p->rng_fault_state) {
1166                 talloc_free(r);
1167                 /* Return true here, srv_pipe_hnd.c will take care */
1168                 return true;
1169         }
1170
1171         if (DEBUGLEVEL >= 10) {
1172                 NDR_PRINT_OUT_DEBUG(dfs_AddStdRootForced, r);
1173         }
1174
1175         push = ndr_push_init_ctx(r);
1176         if (push == NULL) {
1177                 talloc_free(r);
1178                 return false;
1179         }
1180
1181         ndr_err = call->ndr_push(push, NDR_OUT, r);
1182         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1183                 talloc_free(r);
1184                 return false;
1185         }
1186
1187         blob = ndr_push_blob(push);
1188         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1189                 talloc_free(r);
1190                 return false;
1191         }
1192
1193         talloc_free(r);
1194
1195         return true;
1196 }
1197
1198 static bool api_dfs_GetDcAddress(pipes_struct *p)
1199 {
1200         const struct ndr_interface_call *call;
1201         struct ndr_pull *pull;
1202         struct ndr_push *push;
1203         enum ndr_err_code ndr_err;
1204         DATA_BLOB blob;
1205         struct dfs_GetDcAddress *r;
1206
1207         call = &ndr_table_netdfs.calls[NDR_DFS_GETDCADDRESS];
1208
1209         r = talloc(NULL, struct dfs_GetDcAddress);
1210         if (r == NULL) {
1211                 return false;
1212         }
1213
1214         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1215                 talloc_free(r);
1216                 return false;
1217         }
1218
1219         pull = ndr_pull_init_blob(&blob, r);
1220         if (pull == NULL) {
1221                 talloc_free(r);
1222                 return false;
1223         }
1224
1225         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1226         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1227         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1228                 talloc_free(r);
1229                 return false;
1230         }
1231
1232         if (DEBUGLEVEL >= 10) {
1233                 NDR_PRINT_IN_DEBUG(dfs_GetDcAddress, r);
1234         }
1235
1236         r->out.result = _dfs_GetDcAddress(p, r);
1237
1238         if (p->rng_fault_state) {
1239                 talloc_free(r);
1240                 /* Return true here, srv_pipe_hnd.c will take care */
1241                 return true;
1242         }
1243
1244         if (DEBUGLEVEL >= 10) {
1245                 NDR_PRINT_OUT_DEBUG(dfs_GetDcAddress, r);
1246         }
1247
1248         push = ndr_push_init_ctx(r);
1249         if (push == NULL) {
1250                 talloc_free(r);
1251                 return false;
1252         }
1253
1254         ndr_err = call->ndr_push(push, NDR_OUT, r);
1255         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1256                 talloc_free(r);
1257                 return false;
1258         }
1259
1260         blob = ndr_push_blob(push);
1261         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1262                 talloc_free(r);
1263                 return false;
1264         }
1265
1266         talloc_free(r);
1267
1268         return true;
1269 }
1270
1271 static bool api_dfs_SetDcAddress(pipes_struct *p)
1272 {
1273         const struct ndr_interface_call *call;
1274         struct ndr_pull *pull;
1275         struct ndr_push *push;
1276         enum ndr_err_code ndr_err;
1277         DATA_BLOB blob;
1278         struct dfs_SetDcAddress *r;
1279
1280         call = &ndr_table_netdfs.calls[NDR_DFS_SETDCADDRESS];
1281
1282         r = talloc(NULL, struct dfs_SetDcAddress);
1283         if (r == NULL) {
1284                 return false;
1285         }
1286
1287         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1288                 talloc_free(r);
1289                 return false;
1290         }
1291
1292         pull = ndr_pull_init_blob(&blob, r);
1293         if (pull == NULL) {
1294                 talloc_free(r);
1295                 return false;
1296         }
1297
1298         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1299         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1300         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1301                 talloc_free(r);
1302                 return false;
1303         }
1304
1305         if (DEBUGLEVEL >= 10) {
1306                 NDR_PRINT_IN_DEBUG(dfs_SetDcAddress, r);
1307         }
1308
1309         r->out.result = _dfs_SetDcAddress(p, r);
1310
1311         if (p->rng_fault_state) {
1312                 talloc_free(r);
1313                 /* Return true here, srv_pipe_hnd.c will take care */
1314                 return true;
1315         }
1316
1317         if (DEBUGLEVEL >= 10) {
1318                 NDR_PRINT_OUT_DEBUG(dfs_SetDcAddress, r);
1319         }
1320
1321         push = ndr_push_init_ctx(r);
1322         if (push == NULL) {
1323                 talloc_free(r);
1324                 return false;
1325         }
1326
1327         ndr_err = call->ndr_push(push, NDR_OUT, r);
1328         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1329                 talloc_free(r);
1330                 return false;
1331         }
1332
1333         blob = ndr_push_blob(push);
1334         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1335                 talloc_free(r);
1336                 return false;
1337         }
1338
1339         talloc_free(r);
1340
1341         return true;
1342 }
1343
1344 static bool api_dfs_FlushFtTable(pipes_struct *p)
1345 {
1346         const struct ndr_interface_call *call;
1347         struct ndr_pull *pull;
1348         struct ndr_push *push;
1349         enum ndr_err_code ndr_err;
1350         DATA_BLOB blob;
1351         struct dfs_FlushFtTable *r;
1352
1353         call = &ndr_table_netdfs.calls[NDR_DFS_FLUSHFTTABLE];
1354
1355         r = talloc(NULL, struct dfs_FlushFtTable);
1356         if (r == NULL) {
1357                 return false;
1358         }
1359
1360         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1361                 talloc_free(r);
1362                 return false;
1363         }
1364
1365         pull = ndr_pull_init_blob(&blob, r);
1366         if (pull == NULL) {
1367                 talloc_free(r);
1368                 return false;
1369         }
1370
1371         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1372         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1373         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1374                 talloc_free(r);
1375                 return false;
1376         }
1377
1378         if (DEBUGLEVEL >= 10) {
1379                 NDR_PRINT_IN_DEBUG(dfs_FlushFtTable, r);
1380         }
1381
1382         r->out.result = _dfs_FlushFtTable(p, r);
1383
1384         if (p->rng_fault_state) {
1385                 talloc_free(r);
1386                 /* Return true here, srv_pipe_hnd.c will take care */
1387                 return true;
1388         }
1389
1390         if (DEBUGLEVEL >= 10) {
1391                 NDR_PRINT_OUT_DEBUG(dfs_FlushFtTable, r);
1392         }
1393
1394         push = ndr_push_init_ctx(r);
1395         if (push == NULL) {
1396                 talloc_free(r);
1397                 return false;
1398         }
1399
1400         ndr_err = call->ndr_push(push, NDR_OUT, r);
1401         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1402                 talloc_free(r);
1403                 return false;
1404         }
1405
1406         blob = ndr_push_blob(push);
1407         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1408                 talloc_free(r);
1409                 return false;
1410         }
1411
1412         talloc_free(r);
1413
1414         return true;
1415 }
1416
1417 static bool api_dfs_Add2(pipes_struct *p)
1418 {
1419         const struct ndr_interface_call *call;
1420         struct ndr_pull *pull;
1421         struct ndr_push *push;
1422         enum ndr_err_code ndr_err;
1423         DATA_BLOB blob;
1424         struct dfs_Add2 *r;
1425
1426         call = &ndr_table_netdfs.calls[NDR_DFS_ADD2];
1427
1428         r = talloc(NULL, struct dfs_Add2);
1429         if (r == NULL) {
1430                 return false;
1431         }
1432
1433         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1434                 talloc_free(r);
1435                 return false;
1436         }
1437
1438         pull = ndr_pull_init_blob(&blob, r);
1439         if (pull == NULL) {
1440                 talloc_free(r);
1441                 return false;
1442         }
1443
1444         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1445         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1446         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1447                 talloc_free(r);
1448                 return false;
1449         }
1450
1451         if (DEBUGLEVEL >= 10) {
1452                 NDR_PRINT_IN_DEBUG(dfs_Add2, r);
1453         }
1454
1455         r->out.result = _dfs_Add2(p, r);
1456
1457         if (p->rng_fault_state) {
1458                 talloc_free(r);
1459                 /* Return true here, srv_pipe_hnd.c will take care */
1460                 return true;
1461         }
1462
1463         if (DEBUGLEVEL >= 10) {
1464                 NDR_PRINT_OUT_DEBUG(dfs_Add2, r);
1465         }
1466
1467         push = ndr_push_init_ctx(r);
1468         if (push == NULL) {
1469                 talloc_free(r);
1470                 return false;
1471         }
1472
1473         ndr_err = call->ndr_push(push, NDR_OUT, r);
1474         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1475                 talloc_free(r);
1476                 return false;
1477         }
1478
1479         blob = ndr_push_blob(push);
1480         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1481                 talloc_free(r);
1482                 return false;
1483         }
1484
1485         talloc_free(r);
1486
1487         return true;
1488 }
1489
1490 static bool api_dfs_Remove2(pipes_struct *p)
1491 {
1492         const struct ndr_interface_call *call;
1493         struct ndr_pull *pull;
1494         struct ndr_push *push;
1495         enum ndr_err_code ndr_err;
1496         DATA_BLOB blob;
1497         struct dfs_Remove2 *r;
1498
1499         call = &ndr_table_netdfs.calls[NDR_DFS_REMOVE2];
1500
1501         r = talloc(NULL, struct dfs_Remove2);
1502         if (r == NULL) {
1503                 return false;
1504         }
1505
1506         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1507                 talloc_free(r);
1508                 return false;
1509         }
1510
1511         pull = ndr_pull_init_blob(&blob, r);
1512         if (pull == NULL) {
1513                 talloc_free(r);
1514                 return false;
1515         }
1516
1517         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1518         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1519         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1520                 talloc_free(r);
1521                 return false;
1522         }
1523
1524         if (DEBUGLEVEL >= 10) {
1525                 NDR_PRINT_IN_DEBUG(dfs_Remove2, r);
1526         }
1527
1528         r->out.result = _dfs_Remove2(p, r);
1529
1530         if (p->rng_fault_state) {
1531                 talloc_free(r);
1532                 /* Return true here, srv_pipe_hnd.c will take care */
1533                 return true;
1534         }
1535
1536         if (DEBUGLEVEL >= 10) {
1537                 NDR_PRINT_OUT_DEBUG(dfs_Remove2, r);
1538         }
1539
1540         push = ndr_push_init_ctx(r);
1541         if (push == NULL) {
1542                 talloc_free(r);
1543                 return false;
1544         }
1545
1546         ndr_err = call->ndr_push(push, NDR_OUT, r);
1547         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1548                 talloc_free(r);
1549                 return false;
1550         }
1551
1552         blob = ndr_push_blob(push);
1553         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1554                 talloc_free(r);
1555                 return false;
1556         }
1557
1558         talloc_free(r);
1559
1560         return true;
1561 }
1562
1563 static bool api_dfs_EnumEx(pipes_struct *p)
1564 {
1565         const struct ndr_interface_call *call;
1566         struct ndr_pull *pull;
1567         struct ndr_push *push;
1568         enum ndr_err_code ndr_err;
1569         DATA_BLOB blob;
1570         struct dfs_EnumEx *r;
1571
1572         call = &ndr_table_netdfs.calls[NDR_DFS_ENUMEX];
1573
1574         r = talloc(NULL, struct dfs_EnumEx);
1575         if (r == NULL) {
1576                 return false;
1577         }
1578
1579         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1580                 talloc_free(r);
1581                 return false;
1582         }
1583
1584         pull = ndr_pull_init_blob(&blob, r);
1585         if (pull == NULL) {
1586                 talloc_free(r);
1587                 return false;
1588         }
1589
1590         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1591         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1592         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1593                 talloc_free(r);
1594                 return false;
1595         }
1596
1597         if (DEBUGLEVEL >= 10) {
1598                 NDR_PRINT_IN_DEBUG(dfs_EnumEx, r);
1599         }
1600
1601         ZERO_STRUCT(r->out);
1602         r->out.info = r->in.info;
1603         r->out.total = r->in.total;
1604         r->out.result = _dfs_EnumEx(p, r);
1605
1606         if (p->rng_fault_state) {
1607                 talloc_free(r);
1608                 /* Return true here, srv_pipe_hnd.c will take care */
1609                 return true;
1610         }
1611
1612         if (DEBUGLEVEL >= 10) {
1613                 NDR_PRINT_OUT_DEBUG(dfs_EnumEx, r);
1614         }
1615
1616         push = ndr_push_init_ctx(r);
1617         if (push == NULL) {
1618                 talloc_free(r);
1619                 return false;
1620         }
1621
1622         ndr_err = call->ndr_push(push, NDR_OUT, r);
1623         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1624                 talloc_free(r);
1625                 return false;
1626         }
1627
1628         blob = ndr_push_blob(push);
1629         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1630                 talloc_free(r);
1631                 return false;
1632         }
1633
1634         talloc_free(r);
1635
1636         return true;
1637 }
1638
1639 static bool api_dfs_SetInfo2(pipes_struct *p)
1640 {
1641         const struct ndr_interface_call *call;
1642         struct ndr_pull *pull;
1643         struct ndr_push *push;
1644         enum ndr_err_code ndr_err;
1645         DATA_BLOB blob;
1646         struct dfs_SetInfo2 *r;
1647
1648         call = &ndr_table_netdfs.calls[NDR_DFS_SETINFO2];
1649
1650         r = talloc(NULL, struct dfs_SetInfo2);
1651         if (r == NULL) {
1652                 return false;
1653         }
1654
1655         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1656                 talloc_free(r);
1657                 return false;
1658         }
1659
1660         pull = ndr_pull_init_blob(&blob, r);
1661         if (pull == NULL) {
1662                 talloc_free(r);
1663                 return false;
1664         }
1665
1666         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1667         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1668         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1669                 talloc_free(r);
1670                 return false;
1671         }
1672
1673         if (DEBUGLEVEL >= 10) {
1674                 NDR_PRINT_IN_DEBUG(dfs_SetInfo2, r);
1675         }
1676
1677         r->out.result = _dfs_SetInfo2(p, r);
1678
1679         if (p->rng_fault_state) {
1680                 talloc_free(r);
1681                 /* Return true here, srv_pipe_hnd.c will take care */
1682                 return true;
1683         }
1684
1685         if (DEBUGLEVEL >= 10) {
1686                 NDR_PRINT_OUT_DEBUG(dfs_SetInfo2, r);
1687         }
1688
1689         push = ndr_push_init_ctx(r);
1690         if (push == NULL) {
1691                 talloc_free(r);
1692                 return false;
1693         }
1694
1695         ndr_err = call->ndr_push(push, NDR_OUT, r);
1696         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1697                 talloc_free(r);
1698                 return false;
1699         }
1700
1701         blob = ndr_push_blob(push);
1702         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1703                 talloc_free(r);
1704                 return false;
1705         }
1706
1707         talloc_free(r);
1708
1709         return true;
1710 }
1711
1712
1713 /* Tables */
1714 static struct api_struct api_netdfs_cmds[] =
1715 {
1716         {"DFS_GETMANAGERVERSION", NDR_DFS_GETMANAGERVERSION, api_dfs_GetManagerVersion},
1717         {"DFS_ADD", NDR_DFS_ADD, api_dfs_Add},
1718         {"DFS_REMOVE", NDR_DFS_REMOVE, api_dfs_Remove},
1719         {"DFS_SETINFO", NDR_DFS_SETINFO, api_dfs_SetInfo},
1720         {"DFS_GETINFO", NDR_DFS_GETINFO, api_dfs_GetInfo},
1721         {"DFS_ENUM", NDR_DFS_ENUM, api_dfs_Enum},
1722         {"DFS_RENAME", NDR_DFS_RENAME, api_dfs_Rename},
1723         {"DFS_MOVE", NDR_DFS_MOVE, api_dfs_Move},
1724         {"DFS_MANAGERGETCONFIGINFO", NDR_DFS_MANAGERGETCONFIGINFO, api_dfs_ManagerGetConfigInfo},
1725         {"DFS_MANAGERSENDSITEINFO", NDR_DFS_MANAGERSENDSITEINFO, api_dfs_ManagerSendSiteInfo},
1726         {"DFS_ADDFTROOT", NDR_DFS_ADDFTROOT, api_dfs_AddFtRoot},
1727         {"DFS_REMOVEFTROOT", NDR_DFS_REMOVEFTROOT, api_dfs_RemoveFtRoot},
1728         {"DFS_ADDSTDROOT", NDR_DFS_ADDSTDROOT, api_dfs_AddStdRoot},
1729         {"DFS_REMOVESTDROOT", NDR_DFS_REMOVESTDROOT, api_dfs_RemoveStdRoot},
1730         {"DFS_MANAGERINITIALIZE", NDR_DFS_MANAGERINITIALIZE, api_dfs_ManagerInitialize},
1731         {"DFS_ADDSTDROOTFORCED", NDR_DFS_ADDSTDROOTFORCED, api_dfs_AddStdRootForced},
1732         {"DFS_GETDCADDRESS", NDR_DFS_GETDCADDRESS, api_dfs_GetDcAddress},
1733         {"DFS_SETDCADDRESS", NDR_DFS_SETDCADDRESS, api_dfs_SetDcAddress},
1734         {"DFS_FLUSHFTTABLE", NDR_DFS_FLUSHFTTABLE, api_dfs_FlushFtTable},
1735         {"DFS_ADD2", NDR_DFS_ADD2, api_dfs_Add2},
1736         {"DFS_REMOVE2", NDR_DFS_REMOVE2, api_dfs_Remove2},
1737         {"DFS_ENUMEX", NDR_DFS_ENUMEX, api_dfs_EnumEx},
1738         {"DFS_SETINFO2", NDR_DFS_SETINFO2, api_dfs_SetInfo2},
1739 };
1740
1741 void netdfs_get_pipe_fns(struct api_struct **fns, int *n_fns)
1742 {
1743         *fns = api_netdfs_cmds;
1744         *n_fns = sizeof(api_netdfs_cmds) / sizeof(struct api_struct);
1745 }
1746
1747 NTSTATUS rpc_netdfs_init(void)
1748 {
1749         return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "netdfs", "netdfs", api_netdfs_cmds, sizeof(api_netdfs_cmds) / sizeof(struct api_struct));
1750 }