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_srvsvc.h" 8 9static bool api_srvsvc_NetCharDevEnum(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 srvsvc_NetCharDevEnum *r; 17 18 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVENUM]; 19 20 r = talloc(talloc_tos(), struct srvsvc_NetCharDevEnum); 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, NULL); 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(srvsvc_NetCharDevEnum, r); 45 } 46 47 ZERO_STRUCT(r->out); 48 r->out.info_ctr = r->in.info_ctr; 49 r->out.resume_handle = r->in.resume_handle; 50 r->out.totalentries = talloc_zero(r, uint32_t); 51 if (r->out.totalentries == NULL) { 52 talloc_free(r); 53 return false; 54 } 55 56 r->out.result = _srvsvc_NetCharDevEnum(p, r); 57 58 if (p->rng_fault_state) { 59 talloc_free(r); 60 /* Return true here, srv_pipe_hnd.c will take care */ 61 return true; 62 } 63 64 if (DEBUGLEVEL >= 10) { 65 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevEnum, r); 66 } 67 68 push = ndr_push_init_ctx(r, NULL); 69 if (push == NULL) { 70 talloc_free(r); 71 return false; 72 } 73 74 ndr_err = call->ndr_push(push, NDR_OUT, r); 75 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 76 talloc_free(r); 77 return false; 78 } 79 80 blob = ndr_push_blob(push); 81 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 82 talloc_free(r); 83 return false; 84 } 85 86 talloc_free(r); 87 88 return true; 89} 90 91static bool api_srvsvc_NetCharDevGetInfo(pipes_struct *p) 92{ 93 const struct ndr_interface_call *call; 94 struct ndr_pull *pull; 95 struct ndr_push *push; 96 enum ndr_err_code ndr_err; 97 DATA_BLOB blob; 98 struct srvsvc_NetCharDevGetInfo *r; 99 100 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVGETINFO]; 101 102 r = talloc(talloc_tos(), struct srvsvc_NetCharDevGetInfo); 103 if (r == NULL) { 104 return false; 105 } 106 107 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 108 talloc_free(r); 109 return false; 110 } 111 112 pull = ndr_pull_init_blob(&blob, r, NULL); 113 if (pull == NULL) { 114 talloc_free(r); 115 return false; 116 } 117 118 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 119 ndr_err = call->ndr_pull(pull, NDR_IN, r); 120 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 121 talloc_free(r); 122 return false; 123 } 124 125 if (DEBUGLEVEL >= 10) { 126 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevGetInfo, r); 127 } 128 129 ZERO_STRUCT(r->out); 130 r->out.info = talloc_zero(r, union srvsvc_NetCharDevInfo); 131 if (r->out.info == NULL) { 132 talloc_free(r); 133 return false; 134 } 135 136 r->out.result = _srvsvc_NetCharDevGetInfo(p, r); 137 138 if (p->rng_fault_state) { 139 talloc_free(r); 140 /* Return true here, srv_pipe_hnd.c will take care */ 141 return true; 142 } 143 144 if (DEBUGLEVEL >= 10) { 145 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevGetInfo, r); 146 } 147 148 push = ndr_push_init_ctx(r, NULL); 149 if (push == NULL) { 150 talloc_free(r); 151 return false; 152 } 153 154 ndr_err = call->ndr_push(push, NDR_OUT, r); 155 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 156 talloc_free(r); 157 return false; 158 } 159 160 blob = ndr_push_blob(push); 161 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 162 talloc_free(r); 163 return false; 164 } 165 166 talloc_free(r); 167 168 return true; 169} 170 171static bool api_srvsvc_NetCharDevControl(pipes_struct *p) 172{ 173 const struct ndr_interface_call *call; 174 struct ndr_pull *pull; 175 struct ndr_push *push; 176 enum ndr_err_code ndr_err; 177 DATA_BLOB blob; 178 struct srvsvc_NetCharDevControl *r; 179 180 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVCONTROL]; 181 182 r = talloc(talloc_tos(), struct srvsvc_NetCharDevControl); 183 if (r == NULL) { 184 return false; 185 } 186 187 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 188 talloc_free(r); 189 return false; 190 } 191 192 pull = ndr_pull_init_blob(&blob, r, NULL); 193 if (pull == NULL) { 194 talloc_free(r); 195 return false; 196 } 197 198 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 199 ndr_err = call->ndr_pull(pull, NDR_IN, r); 200 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 201 talloc_free(r); 202 return false; 203 } 204 205 if (DEBUGLEVEL >= 10) { 206 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevControl, r); 207 } 208 209 r->out.result = _srvsvc_NetCharDevControl(p, r); 210 211 if (p->rng_fault_state) { 212 talloc_free(r); 213 /* Return true here, srv_pipe_hnd.c will take care */ 214 return true; 215 } 216 217 if (DEBUGLEVEL >= 10) { 218 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevControl, r); 219 } 220 221 push = ndr_push_init_ctx(r, NULL); 222 if (push == NULL) { 223 talloc_free(r); 224 return false; 225 } 226 227 ndr_err = call->ndr_push(push, NDR_OUT, r); 228 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 229 talloc_free(r); 230 return false; 231 } 232 233 blob = ndr_push_blob(push); 234 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 235 talloc_free(r); 236 return false; 237 } 238 239 talloc_free(r); 240 241 return true; 242} 243 244static bool api_srvsvc_NetCharDevQEnum(pipes_struct *p) 245{ 246 const struct ndr_interface_call *call; 247 struct ndr_pull *pull; 248 struct ndr_push *push; 249 enum ndr_err_code ndr_err; 250 DATA_BLOB blob; 251 struct srvsvc_NetCharDevQEnum *r; 252 253 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQENUM]; 254 255 r = talloc(talloc_tos(), struct srvsvc_NetCharDevQEnum); 256 if (r == NULL) { 257 return false; 258 } 259 260 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 261 talloc_free(r); 262 return false; 263 } 264 265 pull = ndr_pull_init_blob(&blob, r, NULL); 266 if (pull == NULL) { 267 talloc_free(r); 268 return false; 269 } 270 271 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 272 ndr_err = call->ndr_pull(pull, NDR_IN, r); 273 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 274 talloc_free(r); 275 return false; 276 } 277 278 if (DEBUGLEVEL >= 10) { 279 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQEnum, r); 280 } 281 282 ZERO_STRUCT(r->out); 283 r->out.info_ctr = r->in.info_ctr; 284 r->out.resume_handle = r->in.resume_handle; 285 r->out.totalentries = talloc_zero(r, uint32_t); 286 if (r->out.totalentries == NULL) { 287 talloc_free(r); 288 return false; 289 } 290 291 r->out.result = _srvsvc_NetCharDevQEnum(p, r); 292 293 if (p->rng_fault_state) { 294 talloc_free(r); 295 /* Return true here, srv_pipe_hnd.c will take care */ 296 return true; 297 } 298 299 if (DEBUGLEVEL >= 10) { 300 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQEnum, r); 301 } 302 303 push = ndr_push_init_ctx(r, NULL); 304 if (push == NULL) { 305 talloc_free(r); 306 return false; 307 } 308 309 ndr_err = call->ndr_push(push, NDR_OUT, r); 310 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 311 talloc_free(r); 312 return false; 313 } 314 315 blob = ndr_push_blob(push); 316 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 317 talloc_free(r); 318 return false; 319 } 320 321 talloc_free(r); 322 323 return true; 324} 325 326static bool api_srvsvc_NetCharDevQGetInfo(pipes_struct *p) 327{ 328 const struct ndr_interface_call *call; 329 struct ndr_pull *pull; 330 struct ndr_push *push; 331 enum ndr_err_code ndr_err; 332 DATA_BLOB blob; 333 struct srvsvc_NetCharDevQGetInfo *r; 334 335 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQGETINFO]; 336 337 r = talloc(talloc_tos(), struct srvsvc_NetCharDevQGetInfo); 338 if (r == NULL) { 339 return false; 340 } 341 342 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 343 talloc_free(r); 344 return false; 345 } 346 347 pull = ndr_pull_init_blob(&blob, r, NULL); 348 if (pull == NULL) { 349 talloc_free(r); 350 return false; 351 } 352 353 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 354 ndr_err = call->ndr_pull(pull, NDR_IN, r); 355 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 356 talloc_free(r); 357 return false; 358 } 359 360 if (DEBUGLEVEL >= 10) { 361 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQGetInfo, r); 362 } 363 364 ZERO_STRUCT(r->out); 365 r->out.info = talloc_zero(r, union srvsvc_NetCharDevQInfo); 366 if (r->out.info == NULL) { 367 talloc_free(r); 368 return false; 369 } 370 371 r->out.result = _srvsvc_NetCharDevQGetInfo(p, r); 372 373 if (p->rng_fault_state) { 374 talloc_free(r); 375 /* Return true here, srv_pipe_hnd.c will take care */ 376 return true; 377 } 378 379 if (DEBUGLEVEL >= 10) { 380 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQGetInfo, r); 381 } 382 383 push = ndr_push_init_ctx(r, NULL); 384 if (push == NULL) { 385 talloc_free(r); 386 return false; 387 } 388 389 ndr_err = call->ndr_push(push, NDR_OUT, r); 390 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 391 talloc_free(r); 392 return false; 393 } 394 395 blob = ndr_push_blob(push); 396 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 397 talloc_free(r); 398 return false; 399 } 400 401 talloc_free(r); 402 403 return true; 404} 405 406static bool api_srvsvc_NetCharDevQSetInfo(pipes_struct *p) 407{ 408 const struct ndr_interface_call *call; 409 struct ndr_pull *pull; 410 struct ndr_push *push; 411 enum ndr_err_code ndr_err; 412 DATA_BLOB blob; 413 struct srvsvc_NetCharDevQSetInfo *r; 414 415 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQSETINFO]; 416 417 r = talloc(talloc_tos(), struct srvsvc_NetCharDevQSetInfo); 418 if (r == NULL) { 419 return false; 420 } 421 422 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 423 talloc_free(r); 424 return false; 425 } 426 427 pull = ndr_pull_init_blob(&blob, r, NULL); 428 if (pull == NULL) { 429 talloc_free(r); 430 return false; 431 } 432 433 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 434 ndr_err = call->ndr_pull(pull, NDR_IN, r); 435 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 436 talloc_free(r); 437 return false; 438 } 439 440 if (DEBUGLEVEL >= 10) { 441 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQSetInfo, r); 442 } 443 444 ZERO_STRUCT(r->out); 445 r->out.parm_error = r->in.parm_error; 446 r->out.result = _srvsvc_NetCharDevQSetInfo(p, r); 447 448 if (p->rng_fault_state) { 449 talloc_free(r); 450 /* Return true here, srv_pipe_hnd.c will take care */ 451 return true; 452 } 453 454 if (DEBUGLEVEL >= 10) { 455 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQSetInfo, r); 456 } 457 458 push = ndr_push_init_ctx(r, NULL); 459 if (push == NULL) { 460 talloc_free(r); 461 return false; 462 } 463 464 ndr_err = call->ndr_push(push, NDR_OUT, r); 465 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 466 talloc_free(r); 467 return false; 468 } 469 470 blob = ndr_push_blob(push); 471 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 472 talloc_free(r); 473 return false; 474 } 475 476 talloc_free(r); 477 478 return true; 479} 480 481static bool api_srvsvc_NetCharDevQPurge(pipes_struct *p) 482{ 483 const struct ndr_interface_call *call; 484 struct ndr_pull *pull; 485 struct ndr_push *push; 486 enum ndr_err_code ndr_err; 487 DATA_BLOB blob; 488 struct srvsvc_NetCharDevQPurge *r; 489 490 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQPURGE]; 491 492 r = talloc(talloc_tos(), struct srvsvc_NetCharDevQPurge); 493 if (r == NULL) { 494 return false; 495 } 496 497 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 498 talloc_free(r); 499 return false; 500 } 501 502 pull = ndr_pull_init_blob(&blob, r, NULL); 503 if (pull == NULL) { 504 talloc_free(r); 505 return false; 506 } 507 508 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 509 ndr_err = call->ndr_pull(pull, NDR_IN, r); 510 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 511 talloc_free(r); 512 return false; 513 } 514 515 if (DEBUGLEVEL >= 10) { 516 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurge, r); 517 } 518 519 r->out.result = _srvsvc_NetCharDevQPurge(p, r); 520 521 if (p->rng_fault_state) { 522 talloc_free(r); 523 /* Return true here, srv_pipe_hnd.c will take care */ 524 return true; 525 } 526 527 if (DEBUGLEVEL >= 10) { 528 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurge, r); 529 } 530 531 push = ndr_push_init_ctx(r, NULL); 532 if (push == NULL) { 533 talloc_free(r); 534 return false; 535 } 536 537 ndr_err = call->ndr_push(push, NDR_OUT, r); 538 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 539 talloc_free(r); 540 return false; 541 } 542 543 blob = ndr_push_blob(push); 544 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 545 talloc_free(r); 546 return false; 547 } 548 549 talloc_free(r); 550 551 return true; 552} 553 554static bool api_srvsvc_NetCharDevQPurgeSelf(pipes_struct *p) 555{ 556 const struct ndr_interface_call *call; 557 struct ndr_pull *pull; 558 struct ndr_push *push; 559 enum ndr_err_code ndr_err; 560 DATA_BLOB blob; 561 struct srvsvc_NetCharDevQPurgeSelf *r; 562 563 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQPURGESELF]; 564 565 r = talloc(talloc_tos(), struct srvsvc_NetCharDevQPurgeSelf); 566 if (r == NULL) { 567 return false; 568 } 569 570 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 571 talloc_free(r); 572 return false; 573 } 574 575 pull = ndr_pull_init_blob(&blob, r, NULL); 576 if (pull == NULL) { 577 talloc_free(r); 578 return false; 579 } 580 581 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 582 ndr_err = call->ndr_pull(pull, NDR_IN, r); 583 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 584 talloc_free(r); 585 return false; 586 } 587 588 if (DEBUGLEVEL >= 10) { 589 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurgeSelf, r); 590 } 591 592 r->out.result = _srvsvc_NetCharDevQPurgeSelf(p, r); 593 594 if (p->rng_fault_state) { 595 talloc_free(r); 596 /* Return true here, srv_pipe_hnd.c will take care */ 597 return true; 598 } 599 600 if (DEBUGLEVEL >= 10) { 601 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurgeSelf, r); 602 } 603 604 push = ndr_push_init_ctx(r, NULL); 605 if (push == NULL) { 606 talloc_free(r); 607 return false; 608 } 609 610 ndr_err = call->ndr_push(push, NDR_OUT, r); 611 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 612 talloc_free(r); 613 return false; 614 } 615 616 blob = ndr_push_blob(push); 617 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 618 talloc_free(r); 619 return false; 620 } 621 622 talloc_free(r); 623 624 return true; 625} 626 627static bool api_srvsvc_NetConnEnum(pipes_struct *p) 628{ 629 const struct ndr_interface_call *call; 630 struct ndr_pull *pull; 631 struct ndr_push *push; 632 enum ndr_err_code ndr_err; 633 DATA_BLOB blob; 634 struct srvsvc_NetConnEnum *r; 635 636 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCONNENUM]; 637 638 r = talloc(talloc_tos(), struct srvsvc_NetConnEnum); 639 if (r == NULL) { 640 return false; 641 } 642 643 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 644 talloc_free(r); 645 return false; 646 } 647 648 pull = ndr_pull_init_blob(&blob, r, NULL); 649 if (pull == NULL) { 650 talloc_free(r); 651 return false; 652 } 653 654 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 655 ndr_err = call->ndr_pull(pull, NDR_IN, r); 656 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 657 talloc_free(r); 658 return false; 659 } 660 661 if (DEBUGLEVEL >= 10) { 662 NDR_PRINT_IN_DEBUG(srvsvc_NetConnEnum, r); 663 } 664 665 ZERO_STRUCT(r->out); 666 r->out.info_ctr = r->in.info_ctr; 667 r->out.resume_handle = r->in.resume_handle; 668 r->out.totalentries = talloc_zero(r, uint32_t); 669 if (r->out.totalentries == NULL) { 670 talloc_free(r); 671 return false; 672 } 673 674 r->out.result = _srvsvc_NetConnEnum(p, r); 675 676 if (p->rng_fault_state) { 677 talloc_free(r); 678 /* Return true here, srv_pipe_hnd.c will take care */ 679 return true; 680 } 681 682 if (DEBUGLEVEL >= 10) { 683 NDR_PRINT_OUT_DEBUG(srvsvc_NetConnEnum, r); 684 } 685 686 push = ndr_push_init_ctx(r, NULL); 687 if (push == NULL) { 688 talloc_free(r); 689 return false; 690 } 691 692 ndr_err = call->ndr_push(push, NDR_OUT, r); 693 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 694 talloc_free(r); 695 return false; 696 } 697 698 blob = ndr_push_blob(push); 699 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 700 talloc_free(r); 701 return false; 702 } 703 704 talloc_free(r); 705 706 return true; 707} 708 709static bool api_srvsvc_NetFileEnum(pipes_struct *p) 710{ 711 const struct ndr_interface_call *call; 712 struct ndr_pull *pull; 713 struct ndr_push *push; 714 enum ndr_err_code ndr_err; 715 DATA_BLOB blob; 716 struct srvsvc_NetFileEnum *r; 717 718 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETFILEENUM]; 719 720 r = talloc(talloc_tos(), struct srvsvc_NetFileEnum); 721 if (r == NULL) { 722 return false; 723 } 724 725 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 726 talloc_free(r); 727 return false; 728 } 729 730 pull = ndr_pull_init_blob(&blob, r, NULL); 731 if (pull == NULL) { 732 talloc_free(r); 733 return false; 734 } 735 736 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 737 ndr_err = call->ndr_pull(pull, NDR_IN, r); 738 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 739 talloc_free(r); 740 return false; 741 } 742 743 if (DEBUGLEVEL >= 10) { 744 NDR_PRINT_IN_DEBUG(srvsvc_NetFileEnum, r); 745 } 746 747 ZERO_STRUCT(r->out); 748 r->out.info_ctr = r->in.info_ctr; 749 r->out.resume_handle = r->in.resume_handle; 750 r->out.totalentries = talloc_zero(r, uint32_t); 751 if (r->out.totalentries == NULL) { 752 talloc_free(r); 753 return false; 754 } 755 756 r->out.result = _srvsvc_NetFileEnum(p, r); 757 758 if (p->rng_fault_state) { 759 talloc_free(r); 760 /* Return true here, srv_pipe_hnd.c will take care */ 761 return true; 762 } 763 764 if (DEBUGLEVEL >= 10) { 765 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileEnum, r); 766 } 767 768 push = ndr_push_init_ctx(r, NULL); 769 if (push == NULL) { 770 talloc_free(r); 771 return false; 772 } 773 774 ndr_err = call->ndr_push(push, NDR_OUT, r); 775 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 776 talloc_free(r); 777 return false; 778 } 779 780 blob = ndr_push_blob(push); 781 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 782 talloc_free(r); 783 return false; 784 } 785 786 talloc_free(r); 787 788 return true; 789} 790 791static bool api_srvsvc_NetFileGetInfo(pipes_struct *p) 792{ 793 const struct ndr_interface_call *call; 794 struct ndr_pull *pull; 795 struct ndr_push *push; 796 enum ndr_err_code ndr_err; 797 DATA_BLOB blob; 798 struct srvsvc_NetFileGetInfo *r; 799 800 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETFILEGETINFO]; 801 802 r = talloc(talloc_tos(), struct srvsvc_NetFileGetInfo); 803 if (r == NULL) { 804 return false; 805 } 806 807 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 808 talloc_free(r); 809 return false; 810 } 811 812 pull = ndr_pull_init_blob(&blob, r, NULL); 813 if (pull == NULL) { 814 talloc_free(r); 815 return false; 816 } 817 818 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 819 ndr_err = call->ndr_pull(pull, NDR_IN, r); 820 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 821 talloc_free(r); 822 return false; 823 } 824 825 if (DEBUGLEVEL >= 10) { 826 NDR_PRINT_IN_DEBUG(srvsvc_NetFileGetInfo, r); 827 } 828 829 ZERO_STRUCT(r->out); 830 r->out.info = talloc_zero(r, union srvsvc_NetFileInfo); 831 if (r->out.info == NULL) { 832 talloc_free(r); 833 return false; 834 } 835 836 r->out.result = _srvsvc_NetFileGetInfo(p, r); 837 838 if (p->rng_fault_state) { 839 talloc_free(r); 840 /* Return true here, srv_pipe_hnd.c will take care */ 841 return true; 842 } 843 844 if (DEBUGLEVEL >= 10) { 845 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileGetInfo, r); 846 } 847 848 push = ndr_push_init_ctx(r, NULL); 849 if (push == NULL) { 850 talloc_free(r); 851 return false; 852 } 853 854 ndr_err = call->ndr_push(push, NDR_OUT, r); 855 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 856 talloc_free(r); 857 return false; 858 } 859 860 blob = ndr_push_blob(push); 861 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 862 talloc_free(r); 863 return false; 864 } 865 866 talloc_free(r); 867 868 return true; 869} 870 871static bool api_srvsvc_NetFileClose(pipes_struct *p) 872{ 873 const struct ndr_interface_call *call; 874 struct ndr_pull *pull; 875 struct ndr_push *push; 876 enum ndr_err_code ndr_err; 877 DATA_BLOB blob; 878 struct srvsvc_NetFileClose *r; 879 880 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETFILECLOSE]; 881 882 r = talloc(talloc_tos(), struct srvsvc_NetFileClose); 883 if (r == NULL) { 884 return false; 885 } 886 887 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 888 talloc_free(r); 889 return false; 890 } 891 892 pull = ndr_pull_init_blob(&blob, r, NULL); 893 if (pull == NULL) { 894 talloc_free(r); 895 return false; 896 } 897 898 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 899 ndr_err = call->ndr_pull(pull, NDR_IN, r); 900 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 901 talloc_free(r); 902 return false; 903 } 904 905 if (DEBUGLEVEL >= 10) { 906 NDR_PRINT_IN_DEBUG(srvsvc_NetFileClose, r); 907 } 908 909 r->out.result = _srvsvc_NetFileClose(p, r); 910 911 if (p->rng_fault_state) { 912 talloc_free(r); 913 /* Return true here, srv_pipe_hnd.c will take care */ 914 return true; 915 } 916 917 if (DEBUGLEVEL >= 10) { 918 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileClose, r); 919 } 920 921 push = ndr_push_init_ctx(r, NULL); 922 if (push == NULL) { 923 talloc_free(r); 924 return false; 925 } 926 927 ndr_err = call->ndr_push(push, NDR_OUT, r); 928 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 929 talloc_free(r); 930 return false; 931 } 932 933 blob = ndr_push_blob(push); 934 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 935 talloc_free(r); 936 return false; 937 } 938 939 talloc_free(r); 940 941 return true; 942} 943 944static bool api_srvsvc_NetSessEnum(pipes_struct *p) 945{ 946 const struct ndr_interface_call *call; 947 struct ndr_pull *pull; 948 struct ndr_push *push; 949 enum ndr_err_code ndr_err; 950 DATA_BLOB blob; 951 struct srvsvc_NetSessEnum *r; 952 953 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSESSENUM]; 954 955 r = talloc(talloc_tos(), struct srvsvc_NetSessEnum); 956 if (r == NULL) { 957 return false; 958 } 959 960 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 961 talloc_free(r); 962 return false; 963 } 964 965 pull = ndr_pull_init_blob(&blob, r, NULL); 966 if (pull == NULL) { 967 talloc_free(r); 968 return false; 969 } 970 971 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 972 ndr_err = call->ndr_pull(pull, NDR_IN, r); 973 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 974 talloc_free(r); 975 return false; 976 } 977 978 if (DEBUGLEVEL >= 10) { 979 NDR_PRINT_IN_DEBUG(srvsvc_NetSessEnum, r); 980 } 981 982 ZERO_STRUCT(r->out); 983 r->out.info_ctr = r->in.info_ctr; 984 r->out.resume_handle = r->in.resume_handle; 985 r->out.totalentries = talloc_zero(r, uint32_t); 986 if (r->out.totalentries == NULL) { 987 talloc_free(r); 988 return false; 989 } 990 991 r->out.result = _srvsvc_NetSessEnum(p, r); 992 993 if (p->rng_fault_state) { 994 talloc_free(r); 995 /* Return true here, srv_pipe_hnd.c will take care */ 996 return true; 997 } 998 999 if (DEBUGLEVEL >= 10) { 1000 NDR_PRINT_OUT_DEBUG(srvsvc_NetSessEnum, r); 1001 } 1002 1003 push = ndr_push_init_ctx(r, NULL); 1004 if (push == NULL) { 1005 talloc_free(r); 1006 return false; 1007 } 1008 1009 ndr_err = call->ndr_push(push, NDR_OUT, r); 1010 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1011 talloc_free(r); 1012 return false; 1013 } 1014 1015 blob = ndr_push_blob(push); 1016 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1017 talloc_free(r); 1018 return false; 1019 } 1020 1021 talloc_free(r); 1022 1023 return true; 1024} 1025 1026static bool api_srvsvc_NetSessDel(pipes_struct *p) 1027{ 1028 const struct ndr_interface_call *call; 1029 struct ndr_pull *pull; 1030 struct ndr_push *push; 1031 enum ndr_err_code ndr_err; 1032 DATA_BLOB blob; 1033 struct srvsvc_NetSessDel *r; 1034 1035 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSESSDEL]; 1036 1037 r = talloc(talloc_tos(), struct srvsvc_NetSessDel); 1038 if (r == NULL) { 1039 return false; 1040 } 1041 1042 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1043 talloc_free(r); 1044 return false; 1045 } 1046 1047 pull = ndr_pull_init_blob(&blob, r, NULL); 1048 if (pull == NULL) { 1049 talloc_free(r); 1050 return false; 1051 } 1052 1053 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1054 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1055 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1056 talloc_free(r); 1057 return false; 1058 } 1059 1060 if (DEBUGLEVEL >= 10) { 1061 NDR_PRINT_IN_DEBUG(srvsvc_NetSessDel, r); 1062 } 1063 1064 r->out.result = _srvsvc_NetSessDel(p, r); 1065 1066 if (p->rng_fault_state) { 1067 talloc_free(r); 1068 /* Return true here, srv_pipe_hnd.c will take care */ 1069 return true; 1070 } 1071 1072 if (DEBUGLEVEL >= 10) { 1073 NDR_PRINT_OUT_DEBUG(srvsvc_NetSessDel, r); 1074 } 1075 1076 push = ndr_push_init_ctx(r, NULL); 1077 if (push == NULL) { 1078 talloc_free(r); 1079 return false; 1080 } 1081 1082 ndr_err = call->ndr_push(push, NDR_OUT, r); 1083 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1084 talloc_free(r); 1085 return false; 1086 } 1087 1088 blob = ndr_push_blob(push); 1089 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1090 talloc_free(r); 1091 return false; 1092 } 1093 1094 talloc_free(r); 1095 1096 return true; 1097} 1098 1099static bool api_srvsvc_NetShareAdd(pipes_struct *p) 1100{ 1101 const struct ndr_interface_call *call; 1102 struct ndr_pull *pull; 1103 struct ndr_push *push; 1104 enum ndr_err_code ndr_err; 1105 DATA_BLOB blob; 1106 struct srvsvc_NetShareAdd *r; 1107 1108 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREADD]; 1109 1110 r = talloc(talloc_tos(), struct srvsvc_NetShareAdd); 1111 if (r == NULL) { 1112 return false; 1113 } 1114 1115 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1116 talloc_free(r); 1117 return false; 1118 } 1119 1120 pull = ndr_pull_init_blob(&blob, r, NULL); 1121 if (pull == NULL) { 1122 talloc_free(r); 1123 return false; 1124 } 1125 1126 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1127 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1128 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1129 talloc_free(r); 1130 return false; 1131 } 1132 1133 if (DEBUGLEVEL >= 10) { 1134 NDR_PRINT_IN_DEBUG(srvsvc_NetShareAdd, r); 1135 } 1136 1137 ZERO_STRUCT(r->out); 1138 r->out.parm_error = r->in.parm_error; 1139 r->out.result = _srvsvc_NetShareAdd(p, r); 1140 1141 if (p->rng_fault_state) { 1142 talloc_free(r); 1143 /* Return true here, srv_pipe_hnd.c will take care */ 1144 return true; 1145 } 1146 1147 if (DEBUGLEVEL >= 10) { 1148 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareAdd, r); 1149 } 1150 1151 push = ndr_push_init_ctx(r, NULL); 1152 if (push == NULL) { 1153 talloc_free(r); 1154 return false; 1155 } 1156 1157 ndr_err = call->ndr_push(push, NDR_OUT, r); 1158 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1159 talloc_free(r); 1160 return false; 1161 } 1162 1163 blob = ndr_push_blob(push); 1164 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1165 talloc_free(r); 1166 return false; 1167 } 1168 1169 talloc_free(r); 1170 1171 return true; 1172} 1173 1174static bool api_srvsvc_NetShareEnumAll(pipes_struct *p) 1175{ 1176 const struct ndr_interface_call *call; 1177 struct ndr_pull *pull; 1178 struct ndr_push *push; 1179 enum ndr_err_code ndr_err; 1180 DATA_BLOB blob; 1181 struct srvsvc_NetShareEnumAll *r; 1182 1183 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREENUMALL]; 1184 1185 r = talloc(talloc_tos(), struct srvsvc_NetShareEnumAll); 1186 if (r == NULL) { 1187 return false; 1188 } 1189 1190 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1191 talloc_free(r); 1192 return false; 1193 } 1194 1195 pull = ndr_pull_init_blob(&blob, r, NULL); 1196 if (pull == NULL) { 1197 talloc_free(r); 1198 return false; 1199 } 1200 1201 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1202 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1203 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1204 talloc_free(r); 1205 return false; 1206 } 1207 1208 if (DEBUGLEVEL >= 10) { 1209 NDR_PRINT_IN_DEBUG(srvsvc_NetShareEnumAll, r); 1210 } 1211 1212 ZERO_STRUCT(r->out); 1213 r->out.info_ctr = r->in.info_ctr; 1214 r->out.resume_handle = r->in.resume_handle; 1215 r->out.totalentries = talloc_zero(r, uint32_t); 1216 if (r->out.totalentries == NULL) { 1217 talloc_free(r); 1218 return false; 1219 } 1220 1221 r->out.result = _srvsvc_NetShareEnumAll(p, r); 1222 1223 if (p->rng_fault_state) { 1224 talloc_free(r); 1225 /* Return true here, srv_pipe_hnd.c will take care */ 1226 return true; 1227 } 1228 1229 if (DEBUGLEVEL >= 10) { 1230 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnumAll, r); 1231 } 1232 1233 push = ndr_push_init_ctx(r, NULL); 1234 if (push == NULL) { 1235 talloc_free(r); 1236 return false; 1237 } 1238 1239 ndr_err = call->ndr_push(push, NDR_OUT, r); 1240 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1241 talloc_free(r); 1242 return false; 1243 } 1244 1245 blob = ndr_push_blob(push); 1246 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1247 talloc_free(r); 1248 return false; 1249 } 1250 1251 talloc_free(r); 1252 1253 return true; 1254} 1255 1256static bool api_srvsvc_NetShareGetInfo(pipes_struct *p) 1257{ 1258 const struct ndr_interface_call *call; 1259 struct ndr_pull *pull; 1260 struct ndr_push *push; 1261 enum ndr_err_code ndr_err; 1262 DATA_BLOB blob; 1263 struct srvsvc_NetShareGetInfo *r; 1264 1265 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREGETINFO]; 1266 1267 r = talloc(talloc_tos(), struct srvsvc_NetShareGetInfo); 1268 if (r == NULL) { 1269 return false; 1270 } 1271 1272 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1273 talloc_free(r); 1274 return false; 1275 } 1276 1277 pull = ndr_pull_init_blob(&blob, r, NULL); 1278 if (pull == NULL) { 1279 talloc_free(r); 1280 return false; 1281 } 1282 1283 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1284 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1285 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1286 talloc_free(r); 1287 return false; 1288 } 1289 1290 if (DEBUGLEVEL >= 10) { 1291 NDR_PRINT_IN_DEBUG(srvsvc_NetShareGetInfo, r); 1292 } 1293 1294 ZERO_STRUCT(r->out); 1295 r->out.info = talloc_zero(r, union srvsvc_NetShareInfo); 1296 if (r->out.info == NULL) { 1297 talloc_free(r); 1298 return false; 1299 } 1300 1301 r->out.result = _srvsvc_NetShareGetInfo(p, r); 1302 1303 if (p->rng_fault_state) { 1304 talloc_free(r); 1305 /* Return true here, srv_pipe_hnd.c will take care */ 1306 return true; 1307 } 1308 1309 if (DEBUGLEVEL >= 10) { 1310 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareGetInfo, r); 1311 } 1312 1313 push = ndr_push_init_ctx(r, NULL); 1314 if (push == NULL) { 1315 talloc_free(r); 1316 return false; 1317 } 1318 1319 ndr_err = call->ndr_push(push, NDR_OUT, r); 1320 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1321 talloc_free(r); 1322 return false; 1323 } 1324 1325 blob = ndr_push_blob(push); 1326 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1327 talloc_free(r); 1328 return false; 1329 } 1330 1331 talloc_free(r); 1332 1333 return true; 1334} 1335 1336static bool api_srvsvc_NetShareSetInfo(pipes_struct *p) 1337{ 1338 const struct ndr_interface_call *call; 1339 struct ndr_pull *pull; 1340 struct ndr_push *push; 1341 enum ndr_err_code ndr_err; 1342 DATA_BLOB blob; 1343 struct srvsvc_NetShareSetInfo *r; 1344 1345 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHARESETINFO]; 1346 1347 r = talloc(talloc_tos(), struct srvsvc_NetShareSetInfo); 1348 if (r == NULL) { 1349 return false; 1350 } 1351 1352 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1353 talloc_free(r); 1354 return false; 1355 } 1356 1357 pull = ndr_pull_init_blob(&blob, r, NULL); 1358 if (pull == NULL) { 1359 talloc_free(r); 1360 return false; 1361 } 1362 1363 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1364 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1365 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1366 talloc_free(r); 1367 return false; 1368 } 1369 1370 if (DEBUGLEVEL >= 10) { 1371 NDR_PRINT_IN_DEBUG(srvsvc_NetShareSetInfo, r); 1372 } 1373 1374 ZERO_STRUCT(r->out); 1375 r->out.parm_error = r->in.parm_error; 1376 r->out.result = _srvsvc_NetShareSetInfo(p, r); 1377 1378 if (p->rng_fault_state) { 1379 talloc_free(r); 1380 /* Return true here, srv_pipe_hnd.c will take care */ 1381 return true; 1382 } 1383 1384 if (DEBUGLEVEL >= 10) { 1385 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareSetInfo, r); 1386 } 1387 1388 push = ndr_push_init_ctx(r, NULL); 1389 if (push == NULL) { 1390 talloc_free(r); 1391 return false; 1392 } 1393 1394 ndr_err = call->ndr_push(push, NDR_OUT, r); 1395 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1396 talloc_free(r); 1397 return false; 1398 } 1399 1400 blob = ndr_push_blob(push); 1401 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1402 talloc_free(r); 1403 return false; 1404 } 1405 1406 talloc_free(r); 1407 1408 return true; 1409} 1410 1411static bool api_srvsvc_NetShareDel(pipes_struct *p) 1412{ 1413 const struct ndr_interface_call *call; 1414 struct ndr_pull *pull; 1415 struct ndr_push *push; 1416 enum ndr_err_code ndr_err; 1417 DATA_BLOB blob; 1418 struct srvsvc_NetShareDel *r; 1419 1420 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDEL]; 1421 1422 r = talloc(talloc_tos(), struct srvsvc_NetShareDel); 1423 if (r == NULL) { 1424 return false; 1425 } 1426 1427 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1428 talloc_free(r); 1429 return false; 1430 } 1431 1432 pull = ndr_pull_init_blob(&blob, r, NULL); 1433 if (pull == NULL) { 1434 talloc_free(r); 1435 return false; 1436 } 1437 1438 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1439 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1440 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1441 talloc_free(r); 1442 return false; 1443 } 1444 1445 if (DEBUGLEVEL >= 10) { 1446 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDel, r); 1447 } 1448 1449 r->out.result = _srvsvc_NetShareDel(p, r); 1450 1451 if (p->rng_fault_state) { 1452 talloc_free(r); 1453 /* Return true here, srv_pipe_hnd.c will take care */ 1454 return true; 1455 } 1456 1457 if (DEBUGLEVEL >= 10) { 1458 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDel, r); 1459 } 1460 1461 push = ndr_push_init_ctx(r, NULL); 1462 if (push == NULL) { 1463 talloc_free(r); 1464 return false; 1465 } 1466 1467 ndr_err = call->ndr_push(push, NDR_OUT, r); 1468 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1469 talloc_free(r); 1470 return false; 1471 } 1472 1473 blob = ndr_push_blob(push); 1474 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1475 talloc_free(r); 1476 return false; 1477 } 1478 1479 talloc_free(r); 1480 1481 return true; 1482} 1483 1484static bool api_srvsvc_NetShareDelSticky(pipes_struct *p) 1485{ 1486 const struct ndr_interface_call *call; 1487 struct ndr_pull *pull; 1488 struct ndr_push *push; 1489 enum ndr_err_code ndr_err; 1490 DATA_BLOB blob; 1491 struct srvsvc_NetShareDelSticky *r; 1492 1493 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDELSTICKY]; 1494 1495 r = talloc(talloc_tos(), struct srvsvc_NetShareDelSticky); 1496 if (r == NULL) { 1497 return false; 1498 } 1499 1500 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1501 talloc_free(r); 1502 return false; 1503 } 1504 1505 pull = ndr_pull_init_blob(&blob, r, NULL); 1506 if (pull == NULL) { 1507 talloc_free(r); 1508 return false; 1509 } 1510 1511 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1512 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1513 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1514 talloc_free(r); 1515 return false; 1516 } 1517 1518 if (DEBUGLEVEL >= 10) { 1519 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelSticky, r); 1520 } 1521 1522 r->out.result = _srvsvc_NetShareDelSticky(p, r); 1523 1524 if (p->rng_fault_state) { 1525 talloc_free(r); 1526 /* Return true here, srv_pipe_hnd.c will take care */ 1527 return true; 1528 } 1529 1530 if (DEBUGLEVEL >= 10) { 1531 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelSticky, r); 1532 } 1533 1534 push = ndr_push_init_ctx(r, NULL); 1535 if (push == NULL) { 1536 talloc_free(r); 1537 return false; 1538 } 1539 1540 ndr_err = call->ndr_push(push, NDR_OUT, r); 1541 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1542 talloc_free(r); 1543 return false; 1544 } 1545 1546 blob = ndr_push_blob(push); 1547 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1548 talloc_free(r); 1549 return false; 1550 } 1551 1552 talloc_free(r); 1553 1554 return true; 1555} 1556 1557static bool api_srvsvc_NetShareCheck(pipes_struct *p) 1558{ 1559 const struct ndr_interface_call *call; 1560 struct ndr_pull *pull; 1561 struct ndr_push *push; 1562 enum ndr_err_code ndr_err; 1563 DATA_BLOB blob; 1564 struct srvsvc_NetShareCheck *r; 1565 1566 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHARECHECK]; 1567 1568 r = talloc(talloc_tos(), struct srvsvc_NetShareCheck); 1569 if (r == NULL) { 1570 return false; 1571 } 1572 1573 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1574 talloc_free(r); 1575 return false; 1576 } 1577 1578 pull = ndr_pull_init_blob(&blob, r, NULL); 1579 if (pull == NULL) { 1580 talloc_free(r); 1581 return false; 1582 } 1583 1584 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1585 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1586 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1587 talloc_free(r); 1588 return false; 1589 } 1590 1591 if (DEBUGLEVEL >= 10) { 1592 NDR_PRINT_IN_DEBUG(srvsvc_NetShareCheck, r); 1593 } 1594 1595 ZERO_STRUCT(r->out); 1596 r->out.type = talloc_zero(r, enum srvsvc_ShareType); 1597 if (r->out.type == NULL) { 1598 talloc_free(r); 1599 return false; 1600 } 1601 1602 r->out.result = _srvsvc_NetShareCheck(p, r); 1603 1604 if (p->rng_fault_state) { 1605 talloc_free(r); 1606 /* Return true here, srv_pipe_hnd.c will take care */ 1607 return true; 1608 } 1609 1610 if (DEBUGLEVEL >= 10) { 1611 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareCheck, r); 1612 } 1613 1614 push = ndr_push_init_ctx(r, NULL); 1615 if (push == NULL) { 1616 talloc_free(r); 1617 return false; 1618 } 1619 1620 ndr_err = call->ndr_push(push, NDR_OUT, r); 1621 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1622 talloc_free(r); 1623 return false; 1624 } 1625 1626 blob = ndr_push_blob(push); 1627 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1628 talloc_free(r); 1629 return false; 1630 } 1631 1632 talloc_free(r); 1633 1634 return true; 1635} 1636 1637static bool api_srvsvc_NetSrvGetInfo(pipes_struct *p) 1638{ 1639 const struct ndr_interface_call *call; 1640 struct ndr_pull *pull; 1641 struct ndr_push *push; 1642 enum ndr_err_code ndr_err; 1643 DATA_BLOB blob; 1644 struct srvsvc_NetSrvGetInfo *r; 1645 1646 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSRVGETINFO]; 1647 1648 r = talloc(talloc_tos(), struct srvsvc_NetSrvGetInfo); 1649 if (r == NULL) { 1650 return false; 1651 } 1652 1653 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1654 talloc_free(r); 1655 return false; 1656 } 1657 1658 pull = ndr_pull_init_blob(&blob, r, NULL); 1659 if (pull == NULL) { 1660 talloc_free(r); 1661 return false; 1662 } 1663 1664 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1665 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1666 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1667 talloc_free(r); 1668 return false; 1669 } 1670 1671 if (DEBUGLEVEL >= 10) { 1672 NDR_PRINT_IN_DEBUG(srvsvc_NetSrvGetInfo, r); 1673 } 1674 1675 ZERO_STRUCT(r->out); 1676 r->out.info = talloc_zero(r, union srvsvc_NetSrvInfo); 1677 if (r->out.info == NULL) { 1678 talloc_free(r); 1679 return false; 1680 } 1681 1682 r->out.result = _srvsvc_NetSrvGetInfo(p, r); 1683 1684 if (p->rng_fault_state) { 1685 talloc_free(r); 1686 /* Return true here, srv_pipe_hnd.c will take care */ 1687 return true; 1688 } 1689 1690 if (DEBUGLEVEL >= 10) { 1691 NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvGetInfo, r); 1692 } 1693 1694 push = ndr_push_init_ctx(r, NULL); 1695 if (push == NULL) { 1696 talloc_free(r); 1697 return false; 1698 } 1699 1700 ndr_err = call->ndr_push(push, NDR_OUT, r); 1701 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1702 talloc_free(r); 1703 return false; 1704 } 1705 1706 blob = ndr_push_blob(push); 1707 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1708 talloc_free(r); 1709 return false; 1710 } 1711 1712 talloc_free(r); 1713 1714 return true; 1715} 1716 1717static bool api_srvsvc_NetSrvSetInfo(pipes_struct *p) 1718{ 1719 const struct ndr_interface_call *call; 1720 struct ndr_pull *pull; 1721 struct ndr_push *push; 1722 enum ndr_err_code ndr_err; 1723 DATA_BLOB blob; 1724 struct srvsvc_NetSrvSetInfo *r; 1725 1726 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSRVSETINFO]; 1727 1728 r = talloc(talloc_tos(), struct srvsvc_NetSrvSetInfo); 1729 if (r == NULL) { 1730 return false; 1731 } 1732 1733 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1734 talloc_free(r); 1735 return false; 1736 } 1737 1738 pull = ndr_pull_init_blob(&blob, r, NULL); 1739 if (pull == NULL) { 1740 talloc_free(r); 1741 return false; 1742 } 1743 1744 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1745 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1746 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1747 talloc_free(r); 1748 return false; 1749 } 1750 1751 if (DEBUGLEVEL >= 10) { 1752 NDR_PRINT_IN_DEBUG(srvsvc_NetSrvSetInfo, r); 1753 } 1754 1755 ZERO_STRUCT(r->out); 1756 r->out.parm_error = r->in.parm_error; 1757 r->out.result = _srvsvc_NetSrvSetInfo(p, r); 1758 1759 if (p->rng_fault_state) { 1760 talloc_free(r); 1761 /* Return true here, srv_pipe_hnd.c will take care */ 1762 return true; 1763 } 1764 1765 if (DEBUGLEVEL >= 10) { 1766 NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvSetInfo, r); 1767 } 1768 1769 push = ndr_push_init_ctx(r, NULL); 1770 if (push == NULL) { 1771 talloc_free(r); 1772 return false; 1773 } 1774 1775 ndr_err = call->ndr_push(push, NDR_OUT, r); 1776 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1777 talloc_free(r); 1778 return false; 1779 } 1780 1781 blob = ndr_push_blob(push); 1782 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1783 talloc_free(r); 1784 return false; 1785 } 1786 1787 talloc_free(r); 1788 1789 return true; 1790} 1791 1792static bool api_srvsvc_NetDiskEnum(pipes_struct *p) 1793{ 1794 const struct ndr_interface_call *call; 1795 struct ndr_pull *pull; 1796 struct ndr_push *push; 1797 enum ndr_err_code ndr_err; 1798 DATA_BLOB blob; 1799 struct srvsvc_NetDiskEnum *r; 1800 1801 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETDISKENUM]; 1802 1803 r = talloc(talloc_tos(), struct srvsvc_NetDiskEnum); 1804 if (r == NULL) { 1805 return false; 1806 } 1807 1808 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1809 talloc_free(r); 1810 return false; 1811 } 1812 1813 pull = ndr_pull_init_blob(&blob, r, NULL); 1814 if (pull == NULL) { 1815 talloc_free(r); 1816 return false; 1817 } 1818 1819 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1820 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1821 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1822 talloc_free(r); 1823 return false; 1824 } 1825 1826 if (DEBUGLEVEL >= 10) { 1827 NDR_PRINT_IN_DEBUG(srvsvc_NetDiskEnum, r); 1828 } 1829 1830 ZERO_STRUCT(r->out); 1831 r->out.info = r->in.info; 1832 r->out.resume_handle = r->in.resume_handle; 1833 r->out.totalentries = talloc_zero(r, uint32_t); 1834 if (r->out.totalentries == NULL) { 1835 talloc_free(r); 1836 return false; 1837 } 1838 1839 r->out.result = _srvsvc_NetDiskEnum(p, r); 1840 1841 if (p->rng_fault_state) { 1842 talloc_free(r); 1843 /* Return true here, srv_pipe_hnd.c will take care */ 1844 return true; 1845 } 1846 1847 if (DEBUGLEVEL >= 10) { 1848 NDR_PRINT_OUT_DEBUG(srvsvc_NetDiskEnum, r); 1849 } 1850 1851 push = ndr_push_init_ctx(r, NULL); 1852 if (push == NULL) { 1853 talloc_free(r); 1854 return false; 1855 } 1856 1857 ndr_err = call->ndr_push(push, NDR_OUT, r); 1858 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1859 talloc_free(r); 1860 return false; 1861 } 1862 1863 blob = ndr_push_blob(push); 1864 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1865 talloc_free(r); 1866 return false; 1867 } 1868 1869 talloc_free(r); 1870 1871 return true; 1872} 1873 1874static bool api_srvsvc_NetServerStatisticsGet(pipes_struct *p) 1875{ 1876 const struct ndr_interface_call *call; 1877 struct ndr_pull *pull; 1878 struct ndr_push *push; 1879 enum ndr_err_code ndr_err; 1880 DATA_BLOB blob; 1881 struct srvsvc_NetServerStatisticsGet *r; 1882 1883 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSERVERSTATISTICSGET]; 1884 1885 r = talloc(talloc_tos(), struct srvsvc_NetServerStatisticsGet); 1886 if (r == NULL) { 1887 return false; 1888 } 1889 1890 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1891 talloc_free(r); 1892 return false; 1893 } 1894 1895 pull = ndr_pull_init_blob(&blob, r, NULL); 1896 if (pull == NULL) { 1897 talloc_free(r); 1898 return false; 1899 } 1900 1901 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1902 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1903 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1904 talloc_free(r); 1905 return false; 1906 } 1907 1908 if (DEBUGLEVEL >= 10) { 1909 NDR_PRINT_IN_DEBUG(srvsvc_NetServerStatisticsGet, r); 1910 } 1911 1912 ZERO_STRUCT(r->out); 1913 r->out.stats = talloc_zero(r, struct srvsvc_Statistics *); 1914 if (r->out.stats == NULL) { 1915 talloc_free(r); 1916 return false; 1917 } 1918 1919 r->out.result = _srvsvc_NetServerStatisticsGet(p, r); 1920 1921 if (p->rng_fault_state) { 1922 talloc_free(r); 1923 /* Return true here, srv_pipe_hnd.c will take care */ 1924 return true; 1925 } 1926 1927 if (DEBUGLEVEL >= 10) { 1928 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerStatisticsGet, r); 1929 } 1930 1931 push = ndr_push_init_ctx(r, NULL); 1932 if (push == NULL) { 1933 talloc_free(r); 1934 return false; 1935 } 1936 1937 ndr_err = call->ndr_push(push, NDR_OUT, r); 1938 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1939 talloc_free(r); 1940 return false; 1941 } 1942 1943 blob = ndr_push_blob(push); 1944 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 1945 talloc_free(r); 1946 return false; 1947 } 1948 1949 talloc_free(r); 1950 1951 return true; 1952} 1953 1954static bool api_srvsvc_NetTransportAdd(pipes_struct *p) 1955{ 1956 const struct ndr_interface_call *call; 1957 struct ndr_pull *pull; 1958 struct ndr_push *push; 1959 enum ndr_err_code ndr_err; 1960 DATA_BLOB blob; 1961 struct srvsvc_NetTransportAdd *r; 1962 1963 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETTRANSPORTADD]; 1964 1965 r = talloc(talloc_tos(), struct srvsvc_NetTransportAdd); 1966 if (r == NULL) { 1967 return false; 1968 } 1969 1970 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 1971 talloc_free(r); 1972 return false; 1973 } 1974 1975 pull = ndr_pull_init_blob(&blob, r, NULL); 1976 if (pull == NULL) { 1977 talloc_free(r); 1978 return false; 1979 } 1980 1981 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 1982 ndr_err = call->ndr_pull(pull, NDR_IN, r); 1983 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 1984 talloc_free(r); 1985 return false; 1986 } 1987 1988 if (DEBUGLEVEL >= 10) { 1989 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportAdd, r); 1990 } 1991 1992 r->out.result = _srvsvc_NetTransportAdd(p, r); 1993 1994 if (p->rng_fault_state) { 1995 talloc_free(r); 1996 /* Return true here, srv_pipe_hnd.c will take care */ 1997 return true; 1998 } 1999 2000 if (DEBUGLEVEL >= 10) { 2001 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportAdd, r); 2002 } 2003 2004 push = ndr_push_init_ctx(r, NULL); 2005 if (push == NULL) { 2006 talloc_free(r); 2007 return false; 2008 } 2009 2010 ndr_err = call->ndr_push(push, NDR_OUT, r); 2011 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2012 talloc_free(r); 2013 return false; 2014 } 2015 2016 blob = ndr_push_blob(push); 2017 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2018 talloc_free(r); 2019 return false; 2020 } 2021 2022 talloc_free(r); 2023 2024 return true; 2025} 2026 2027static bool api_srvsvc_NetTransportEnum(pipes_struct *p) 2028{ 2029 const struct ndr_interface_call *call; 2030 struct ndr_pull *pull; 2031 struct ndr_push *push; 2032 enum ndr_err_code ndr_err; 2033 DATA_BLOB blob; 2034 struct srvsvc_NetTransportEnum *r; 2035 2036 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETTRANSPORTENUM]; 2037 2038 r = talloc(talloc_tos(), struct srvsvc_NetTransportEnum); 2039 if (r == NULL) { 2040 return false; 2041 } 2042 2043 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2044 talloc_free(r); 2045 return false; 2046 } 2047 2048 pull = ndr_pull_init_blob(&blob, r, NULL); 2049 if (pull == NULL) { 2050 talloc_free(r); 2051 return false; 2052 } 2053 2054 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2055 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2056 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2057 talloc_free(r); 2058 return false; 2059 } 2060 2061 if (DEBUGLEVEL >= 10) { 2062 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportEnum, r); 2063 } 2064 2065 ZERO_STRUCT(r->out); 2066 r->out.transports = r->in.transports; 2067 r->out.resume_handle = r->in.resume_handle; 2068 r->out.totalentries = talloc_zero(r, uint32_t); 2069 if (r->out.totalentries == NULL) { 2070 talloc_free(r); 2071 return false; 2072 } 2073 2074 r->out.result = _srvsvc_NetTransportEnum(p, r); 2075 2076 if (p->rng_fault_state) { 2077 talloc_free(r); 2078 /* Return true here, srv_pipe_hnd.c will take care */ 2079 return true; 2080 } 2081 2082 if (DEBUGLEVEL >= 10) { 2083 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportEnum, r); 2084 } 2085 2086 push = ndr_push_init_ctx(r, NULL); 2087 if (push == NULL) { 2088 talloc_free(r); 2089 return false; 2090 } 2091 2092 ndr_err = call->ndr_push(push, NDR_OUT, r); 2093 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2094 talloc_free(r); 2095 return false; 2096 } 2097 2098 blob = ndr_push_blob(push); 2099 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2100 talloc_free(r); 2101 return false; 2102 } 2103 2104 talloc_free(r); 2105 2106 return true; 2107} 2108 2109static bool api_srvsvc_NetTransportDel(pipes_struct *p) 2110{ 2111 const struct ndr_interface_call *call; 2112 struct ndr_pull *pull; 2113 struct ndr_push *push; 2114 enum ndr_err_code ndr_err; 2115 DATA_BLOB blob; 2116 struct srvsvc_NetTransportDel *r; 2117 2118 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETTRANSPORTDEL]; 2119 2120 r = talloc(talloc_tos(), struct srvsvc_NetTransportDel); 2121 if (r == NULL) { 2122 return false; 2123 } 2124 2125 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2126 talloc_free(r); 2127 return false; 2128 } 2129 2130 pull = ndr_pull_init_blob(&blob, r, NULL); 2131 if (pull == NULL) { 2132 talloc_free(r); 2133 return false; 2134 } 2135 2136 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2137 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2138 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2139 talloc_free(r); 2140 return false; 2141 } 2142 2143 if (DEBUGLEVEL >= 10) { 2144 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportDel, r); 2145 } 2146 2147 r->out.result = _srvsvc_NetTransportDel(p, r); 2148 2149 if (p->rng_fault_state) { 2150 talloc_free(r); 2151 /* Return true here, srv_pipe_hnd.c will take care */ 2152 return true; 2153 } 2154 2155 if (DEBUGLEVEL >= 10) { 2156 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportDel, r); 2157 } 2158 2159 push = ndr_push_init_ctx(r, NULL); 2160 if (push == NULL) { 2161 talloc_free(r); 2162 return false; 2163 } 2164 2165 ndr_err = call->ndr_push(push, NDR_OUT, r); 2166 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2167 talloc_free(r); 2168 return false; 2169 } 2170 2171 blob = ndr_push_blob(push); 2172 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2173 talloc_free(r); 2174 return false; 2175 } 2176 2177 talloc_free(r); 2178 2179 return true; 2180} 2181 2182static bool api_srvsvc_NetRemoteTOD(pipes_struct *p) 2183{ 2184 const struct ndr_interface_call *call; 2185 struct ndr_pull *pull; 2186 struct ndr_push *push; 2187 enum ndr_err_code ndr_err; 2188 DATA_BLOB blob; 2189 struct srvsvc_NetRemoteTOD *r; 2190 2191 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETREMOTETOD]; 2192 2193 r = talloc(talloc_tos(), struct srvsvc_NetRemoteTOD); 2194 if (r == NULL) { 2195 return false; 2196 } 2197 2198 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2199 talloc_free(r); 2200 return false; 2201 } 2202 2203 pull = ndr_pull_init_blob(&blob, r, NULL); 2204 if (pull == NULL) { 2205 talloc_free(r); 2206 return false; 2207 } 2208 2209 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2210 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2211 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2212 talloc_free(r); 2213 return false; 2214 } 2215 2216 if (DEBUGLEVEL >= 10) { 2217 NDR_PRINT_IN_DEBUG(srvsvc_NetRemoteTOD, r); 2218 } 2219 2220 ZERO_STRUCT(r->out); 2221 r->out.info = talloc_zero(r, struct srvsvc_NetRemoteTODInfo *); 2222 if (r->out.info == NULL) { 2223 talloc_free(r); 2224 return false; 2225 } 2226 2227 r->out.result = _srvsvc_NetRemoteTOD(p, r); 2228 2229 if (p->rng_fault_state) { 2230 talloc_free(r); 2231 /* Return true here, srv_pipe_hnd.c will take care */ 2232 return true; 2233 } 2234 2235 if (DEBUGLEVEL >= 10) { 2236 NDR_PRINT_OUT_DEBUG(srvsvc_NetRemoteTOD, r); 2237 } 2238 2239 push = ndr_push_init_ctx(r, NULL); 2240 if (push == NULL) { 2241 talloc_free(r); 2242 return false; 2243 } 2244 2245 ndr_err = call->ndr_push(push, NDR_OUT, r); 2246 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2247 talloc_free(r); 2248 return false; 2249 } 2250 2251 blob = ndr_push_blob(push); 2252 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2253 talloc_free(r); 2254 return false; 2255 } 2256 2257 talloc_free(r); 2258 2259 return true; 2260} 2261 2262static bool api_srvsvc_NetSetServiceBits(pipes_struct *p) 2263{ 2264 const struct ndr_interface_call *call; 2265 struct ndr_pull *pull; 2266 struct ndr_push *push; 2267 enum ndr_err_code ndr_err; 2268 DATA_BLOB blob; 2269 struct srvsvc_NetSetServiceBits *r; 2270 2271 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSETSERVICEBITS]; 2272 2273 r = talloc(talloc_tos(), struct srvsvc_NetSetServiceBits); 2274 if (r == NULL) { 2275 return false; 2276 } 2277 2278 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2279 talloc_free(r); 2280 return false; 2281 } 2282 2283 pull = ndr_pull_init_blob(&blob, r, NULL); 2284 if (pull == NULL) { 2285 talloc_free(r); 2286 return false; 2287 } 2288 2289 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2290 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2291 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2292 talloc_free(r); 2293 return false; 2294 } 2295 2296 if (DEBUGLEVEL >= 10) { 2297 NDR_PRINT_IN_DEBUG(srvsvc_NetSetServiceBits, r); 2298 } 2299 2300 r->out.result = _srvsvc_NetSetServiceBits(p, r); 2301 2302 if (p->rng_fault_state) { 2303 talloc_free(r); 2304 /* Return true here, srv_pipe_hnd.c will take care */ 2305 return true; 2306 } 2307 2308 if (DEBUGLEVEL >= 10) { 2309 NDR_PRINT_OUT_DEBUG(srvsvc_NetSetServiceBits, r); 2310 } 2311 2312 push = ndr_push_init_ctx(r, NULL); 2313 if (push == NULL) { 2314 talloc_free(r); 2315 return false; 2316 } 2317 2318 ndr_err = call->ndr_push(push, NDR_OUT, r); 2319 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2320 talloc_free(r); 2321 return false; 2322 } 2323 2324 blob = ndr_push_blob(push); 2325 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2326 talloc_free(r); 2327 return false; 2328 } 2329 2330 talloc_free(r); 2331 2332 return true; 2333} 2334 2335static bool api_srvsvc_NetPathType(pipes_struct *p) 2336{ 2337 const struct ndr_interface_call *call; 2338 struct ndr_pull *pull; 2339 struct ndr_push *push; 2340 enum ndr_err_code ndr_err; 2341 DATA_BLOB blob; 2342 struct srvsvc_NetPathType *r; 2343 2344 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPATHTYPE]; 2345 2346 r = talloc(talloc_tos(), struct srvsvc_NetPathType); 2347 if (r == NULL) { 2348 return false; 2349 } 2350 2351 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2352 talloc_free(r); 2353 return false; 2354 } 2355 2356 pull = ndr_pull_init_blob(&blob, r, NULL); 2357 if (pull == NULL) { 2358 talloc_free(r); 2359 return false; 2360 } 2361 2362 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2363 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2364 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2365 talloc_free(r); 2366 return false; 2367 } 2368 2369 if (DEBUGLEVEL >= 10) { 2370 NDR_PRINT_IN_DEBUG(srvsvc_NetPathType, r); 2371 } 2372 2373 ZERO_STRUCT(r->out); 2374 r->out.pathtype = talloc_zero(r, uint32_t); 2375 if (r->out.pathtype == NULL) { 2376 talloc_free(r); 2377 return false; 2378 } 2379 2380 r->out.result = _srvsvc_NetPathType(p, r); 2381 2382 if (p->rng_fault_state) { 2383 talloc_free(r); 2384 /* Return true here, srv_pipe_hnd.c will take care */ 2385 return true; 2386 } 2387 2388 if (DEBUGLEVEL >= 10) { 2389 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathType, r); 2390 } 2391 2392 push = ndr_push_init_ctx(r, NULL); 2393 if (push == NULL) { 2394 talloc_free(r); 2395 return false; 2396 } 2397 2398 ndr_err = call->ndr_push(push, NDR_OUT, r); 2399 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2400 talloc_free(r); 2401 return false; 2402 } 2403 2404 blob = ndr_push_blob(push); 2405 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2406 talloc_free(r); 2407 return false; 2408 } 2409 2410 talloc_free(r); 2411 2412 return true; 2413} 2414 2415static bool api_srvsvc_NetPathCanonicalize(pipes_struct *p) 2416{ 2417 const struct ndr_interface_call *call; 2418 struct ndr_pull *pull; 2419 struct ndr_push *push; 2420 enum ndr_err_code ndr_err; 2421 DATA_BLOB blob; 2422 struct srvsvc_NetPathCanonicalize *r; 2423 2424 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPATHCANONICALIZE]; 2425 2426 r = talloc(talloc_tos(), struct srvsvc_NetPathCanonicalize); 2427 if (r == NULL) { 2428 return false; 2429 } 2430 2431 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2432 talloc_free(r); 2433 return false; 2434 } 2435 2436 pull = ndr_pull_init_blob(&blob, r, NULL); 2437 if (pull == NULL) { 2438 talloc_free(r); 2439 return false; 2440 } 2441 2442 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2443 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2444 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2445 talloc_free(r); 2446 return false; 2447 } 2448 2449 if (DEBUGLEVEL >= 10) { 2450 NDR_PRINT_IN_DEBUG(srvsvc_NetPathCanonicalize, r); 2451 } 2452 2453 ZERO_STRUCT(r->out); 2454 r->out.pathtype = r->in.pathtype; 2455 r->out.can_path = talloc_zero_array(r, uint8_t, r->in.maxbuf); 2456 if (r->out.can_path == NULL) { 2457 talloc_free(r); 2458 return false; 2459 } 2460 2461 r->out.result = _srvsvc_NetPathCanonicalize(p, r); 2462 2463 if (p->rng_fault_state) { 2464 talloc_free(r); 2465 /* Return true here, srv_pipe_hnd.c will take care */ 2466 return true; 2467 } 2468 2469 if (DEBUGLEVEL >= 10) { 2470 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCanonicalize, r); 2471 } 2472 2473 push = ndr_push_init_ctx(r, NULL); 2474 if (push == NULL) { 2475 talloc_free(r); 2476 return false; 2477 } 2478 2479 ndr_err = call->ndr_push(push, NDR_OUT, r); 2480 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2481 talloc_free(r); 2482 return false; 2483 } 2484 2485 blob = ndr_push_blob(push); 2486 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2487 talloc_free(r); 2488 return false; 2489 } 2490 2491 talloc_free(r); 2492 2493 return true; 2494} 2495 2496static bool api_srvsvc_NetPathCompare(pipes_struct *p) 2497{ 2498 const struct ndr_interface_call *call; 2499 struct ndr_pull *pull; 2500 struct ndr_push *push; 2501 enum ndr_err_code ndr_err; 2502 DATA_BLOB blob; 2503 struct srvsvc_NetPathCompare *r; 2504 2505 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPATHCOMPARE]; 2506 2507 r = talloc(talloc_tos(), struct srvsvc_NetPathCompare); 2508 if (r == NULL) { 2509 return false; 2510 } 2511 2512 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2513 talloc_free(r); 2514 return false; 2515 } 2516 2517 pull = ndr_pull_init_blob(&blob, r, NULL); 2518 if (pull == NULL) { 2519 talloc_free(r); 2520 return false; 2521 } 2522 2523 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2524 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2525 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2526 talloc_free(r); 2527 return false; 2528 } 2529 2530 if (DEBUGLEVEL >= 10) { 2531 NDR_PRINT_IN_DEBUG(srvsvc_NetPathCompare, r); 2532 } 2533 2534 r->out.result = _srvsvc_NetPathCompare(p, r); 2535 2536 if (p->rng_fault_state) { 2537 talloc_free(r); 2538 /* Return true here, srv_pipe_hnd.c will take care */ 2539 return true; 2540 } 2541 2542 if (DEBUGLEVEL >= 10) { 2543 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCompare, r); 2544 } 2545 2546 push = ndr_push_init_ctx(r, NULL); 2547 if (push == NULL) { 2548 talloc_free(r); 2549 return false; 2550 } 2551 2552 ndr_err = call->ndr_push(push, NDR_OUT, r); 2553 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2554 talloc_free(r); 2555 return false; 2556 } 2557 2558 blob = ndr_push_blob(push); 2559 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2560 talloc_free(r); 2561 return false; 2562 } 2563 2564 talloc_free(r); 2565 2566 return true; 2567} 2568 2569static bool api_srvsvc_NetNameValidate(pipes_struct *p) 2570{ 2571 const struct ndr_interface_call *call; 2572 struct ndr_pull *pull; 2573 struct ndr_push *push; 2574 enum ndr_err_code ndr_err; 2575 DATA_BLOB blob; 2576 struct srvsvc_NetNameValidate *r; 2577 2578 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETNAMEVALIDATE]; 2579 2580 r = talloc(talloc_tos(), struct srvsvc_NetNameValidate); 2581 if (r == NULL) { 2582 return false; 2583 } 2584 2585 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2586 talloc_free(r); 2587 return false; 2588 } 2589 2590 pull = ndr_pull_init_blob(&blob, r, NULL); 2591 if (pull == NULL) { 2592 talloc_free(r); 2593 return false; 2594 } 2595 2596 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2597 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2598 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2599 talloc_free(r); 2600 return false; 2601 } 2602 2603 if (DEBUGLEVEL >= 10) { 2604 NDR_PRINT_IN_DEBUG(srvsvc_NetNameValidate, r); 2605 } 2606 2607 r->out.result = _srvsvc_NetNameValidate(p, r); 2608 2609 if (p->rng_fault_state) { 2610 talloc_free(r); 2611 /* Return true here, srv_pipe_hnd.c will take care */ 2612 return true; 2613 } 2614 2615 if (DEBUGLEVEL >= 10) { 2616 NDR_PRINT_OUT_DEBUG(srvsvc_NetNameValidate, r); 2617 } 2618 2619 push = ndr_push_init_ctx(r, NULL); 2620 if (push == NULL) { 2621 talloc_free(r); 2622 return false; 2623 } 2624 2625 ndr_err = call->ndr_push(push, NDR_OUT, r); 2626 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2627 talloc_free(r); 2628 return false; 2629 } 2630 2631 blob = ndr_push_blob(push); 2632 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2633 talloc_free(r); 2634 return false; 2635 } 2636 2637 talloc_free(r); 2638 2639 return true; 2640} 2641 2642static bool api_srvsvc_NETRPRNAMECANONICALIZE(pipes_struct *p) 2643{ 2644 const struct ndr_interface_call *call; 2645 struct ndr_pull *pull; 2646 struct ndr_push *push; 2647 enum ndr_err_code ndr_err; 2648 DATA_BLOB blob; 2649 struct srvsvc_NETRPRNAMECANONICALIZE *r; 2650 2651 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRPRNAMECANONICALIZE]; 2652 2653 r = talloc(talloc_tos(), struct srvsvc_NETRPRNAMECANONICALIZE); 2654 if (r == NULL) { 2655 return false; 2656 } 2657 2658 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2659 talloc_free(r); 2660 return false; 2661 } 2662 2663 pull = ndr_pull_init_blob(&blob, r, NULL); 2664 if (pull == NULL) { 2665 talloc_free(r); 2666 return false; 2667 } 2668 2669 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2670 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2671 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2672 talloc_free(r); 2673 return false; 2674 } 2675 2676 if (DEBUGLEVEL >= 10) { 2677 NDR_PRINT_IN_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, r); 2678 } 2679 2680 r->out.result = _srvsvc_NETRPRNAMECANONICALIZE(p, r); 2681 2682 if (p->rng_fault_state) { 2683 talloc_free(r); 2684 /* Return true here, srv_pipe_hnd.c will take care */ 2685 return true; 2686 } 2687 2688 if (DEBUGLEVEL >= 10) { 2689 NDR_PRINT_OUT_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, r); 2690 } 2691 2692 push = ndr_push_init_ctx(r, NULL); 2693 if (push == NULL) { 2694 talloc_free(r); 2695 return false; 2696 } 2697 2698 ndr_err = call->ndr_push(push, NDR_OUT, r); 2699 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2700 talloc_free(r); 2701 return false; 2702 } 2703 2704 blob = ndr_push_blob(push); 2705 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2706 talloc_free(r); 2707 return false; 2708 } 2709 2710 talloc_free(r); 2711 2712 return true; 2713} 2714 2715static bool api_srvsvc_NetPRNameCompare(pipes_struct *p) 2716{ 2717 const struct ndr_interface_call *call; 2718 struct ndr_pull *pull; 2719 struct ndr_push *push; 2720 enum ndr_err_code ndr_err; 2721 DATA_BLOB blob; 2722 struct srvsvc_NetPRNameCompare *r; 2723 2724 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPRNAMECOMPARE]; 2725 2726 r = talloc(talloc_tos(), struct srvsvc_NetPRNameCompare); 2727 if (r == NULL) { 2728 return false; 2729 } 2730 2731 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2732 talloc_free(r); 2733 return false; 2734 } 2735 2736 pull = ndr_pull_init_blob(&blob, r, NULL); 2737 if (pull == NULL) { 2738 talloc_free(r); 2739 return false; 2740 } 2741 2742 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2743 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2744 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2745 talloc_free(r); 2746 return false; 2747 } 2748 2749 if (DEBUGLEVEL >= 10) { 2750 NDR_PRINT_IN_DEBUG(srvsvc_NetPRNameCompare, r); 2751 } 2752 2753 r->out.result = _srvsvc_NetPRNameCompare(p, r); 2754 2755 if (p->rng_fault_state) { 2756 talloc_free(r); 2757 /* Return true here, srv_pipe_hnd.c will take care */ 2758 return true; 2759 } 2760 2761 if (DEBUGLEVEL >= 10) { 2762 NDR_PRINT_OUT_DEBUG(srvsvc_NetPRNameCompare, r); 2763 } 2764 2765 push = ndr_push_init_ctx(r, NULL); 2766 if (push == NULL) { 2767 talloc_free(r); 2768 return false; 2769 } 2770 2771 ndr_err = call->ndr_push(push, NDR_OUT, r); 2772 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2773 talloc_free(r); 2774 return false; 2775 } 2776 2777 blob = ndr_push_blob(push); 2778 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2779 talloc_free(r); 2780 return false; 2781 } 2782 2783 talloc_free(r); 2784 2785 return true; 2786} 2787 2788static bool api_srvsvc_NetShareEnum(pipes_struct *p) 2789{ 2790 const struct ndr_interface_call *call; 2791 struct ndr_pull *pull; 2792 struct ndr_push *push; 2793 enum ndr_err_code ndr_err; 2794 DATA_BLOB blob; 2795 struct srvsvc_NetShareEnum *r; 2796 2797 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREENUM]; 2798 2799 r = talloc(talloc_tos(), struct srvsvc_NetShareEnum); 2800 if (r == NULL) { 2801 return false; 2802 } 2803 2804 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2805 talloc_free(r); 2806 return false; 2807 } 2808 2809 pull = ndr_pull_init_blob(&blob, r, NULL); 2810 if (pull == NULL) { 2811 talloc_free(r); 2812 return false; 2813 } 2814 2815 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2816 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2817 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2818 talloc_free(r); 2819 return false; 2820 } 2821 2822 if (DEBUGLEVEL >= 10) { 2823 NDR_PRINT_IN_DEBUG(srvsvc_NetShareEnum, r); 2824 } 2825 2826 ZERO_STRUCT(r->out); 2827 r->out.info_ctr = r->in.info_ctr; 2828 r->out.resume_handle = r->in.resume_handle; 2829 r->out.totalentries = talloc_zero(r, uint32_t); 2830 if (r->out.totalentries == NULL) { 2831 talloc_free(r); 2832 return false; 2833 } 2834 2835 r->out.result = _srvsvc_NetShareEnum(p, r); 2836 2837 if (p->rng_fault_state) { 2838 talloc_free(r); 2839 /* Return true here, srv_pipe_hnd.c will take care */ 2840 return true; 2841 } 2842 2843 if (DEBUGLEVEL >= 10) { 2844 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnum, r); 2845 } 2846 2847 push = ndr_push_init_ctx(r, NULL); 2848 if (push == NULL) { 2849 talloc_free(r); 2850 return false; 2851 } 2852 2853 ndr_err = call->ndr_push(push, NDR_OUT, r); 2854 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2855 talloc_free(r); 2856 return false; 2857 } 2858 2859 blob = ndr_push_blob(push); 2860 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2861 talloc_free(r); 2862 return false; 2863 } 2864 2865 talloc_free(r); 2866 2867 return true; 2868} 2869 2870static bool api_srvsvc_NetShareDelStart(pipes_struct *p) 2871{ 2872 const struct ndr_interface_call *call; 2873 struct ndr_pull *pull; 2874 struct ndr_push *push; 2875 enum ndr_err_code ndr_err; 2876 DATA_BLOB blob; 2877 struct srvsvc_NetShareDelStart *r; 2878 2879 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDELSTART]; 2880 2881 r = talloc(talloc_tos(), struct srvsvc_NetShareDelStart); 2882 if (r == NULL) { 2883 return false; 2884 } 2885 2886 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2887 talloc_free(r); 2888 return false; 2889 } 2890 2891 pull = ndr_pull_init_blob(&blob, r, NULL); 2892 if (pull == NULL) { 2893 talloc_free(r); 2894 return false; 2895 } 2896 2897 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2898 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2899 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2900 talloc_free(r); 2901 return false; 2902 } 2903 2904 if (DEBUGLEVEL >= 10) { 2905 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelStart, r); 2906 } 2907 2908 ZERO_STRUCT(r->out); 2909 r->out.hnd = talloc_zero(r, struct policy_handle); 2910 if (r->out.hnd == NULL) { 2911 talloc_free(r); 2912 return false; 2913 } 2914 2915 r->out.result = _srvsvc_NetShareDelStart(p, r); 2916 2917 if (p->rng_fault_state) { 2918 talloc_free(r); 2919 /* Return true here, srv_pipe_hnd.c will take care */ 2920 return true; 2921 } 2922 2923 if (DEBUGLEVEL >= 10) { 2924 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelStart, r); 2925 } 2926 2927 push = ndr_push_init_ctx(r, NULL); 2928 if (push == NULL) { 2929 talloc_free(r); 2930 return false; 2931 } 2932 2933 ndr_err = call->ndr_push(push, NDR_OUT, r); 2934 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2935 talloc_free(r); 2936 return false; 2937 } 2938 2939 blob = ndr_push_blob(push); 2940 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 2941 talloc_free(r); 2942 return false; 2943 } 2944 2945 talloc_free(r); 2946 2947 return true; 2948} 2949 2950static bool api_srvsvc_NetShareDelCommit(pipes_struct *p) 2951{ 2952 const struct ndr_interface_call *call; 2953 struct ndr_pull *pull; 2954 struct ndr_push *push; 2955 enum ndr_err_code ndr_err; 2956 DATA_BLOB blob; 2957 struct srvsvc_NetShareDelCommit *r; 2958 2959 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDELCOMMIT]; 2960 2961 r = talloc(talloc_tos(), struct srvsvc_NetShareDelCommit); 2962 if (r == NULL) { 2963 return false; 2964 } 2965 2966 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 2967 talloc_free(r); 2968 return false; 2969 } 2970 2971 pull = ndr_pull_init_blob(&blob, r, NULL); 2972 if (pull == NULL) { 2973 talloc_free(r); 2974 return false; 2975 } 2976 2977 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 2978 ndr_err = call->ndr_pull(pull, NDR_IN, r); 2979 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 2980 talloc_free(r); 2981 return false; 2982 } 2983 2984 if (DEBUGLEVEL >= 10) { 2985 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelCommit, r); 2986 } 2987 2988 ZERO_STRUCT(r->out); 2989 r->out.hnd = r->in.hnd; 2990 r->out.result = _srvsvc_NetShareDelCommit(p, r); 2991 2992 if (p->rng_fault_state) { 2993 talloc_free(r); 2994 /* Return true here, srv_pipe_hnd.c will take care */ 2995 return true; 2996 } 2997 2998 if (DEBUGLEVEL >= 10) { 2999 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelCommit, r); 3000 } 3001 3002 push = ndr_push_init_ctx(r, NULL); 3003 if (push == NULL) { 3004 talloc_free(r); 3005 return false; 3006 } 3007 3008 ndr_err = call->ndr_push(push, NDR_OUT, r); 3009 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3010 talloc_free(r); 3011 return false; 3012 } 3013 3014 blob = ndr_push_blob(push); 3015 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3016 talloc_free(r); 3017 return false; 3018 } 3019 3020 talloc_free(r); 3021 3022 return true; 3023} 3024 3025static bool api_srvsvc_NetGetFileSecurity(pipes_struct *p) 3026{ 3027 const struct ndr_interface_call *call; 3028 struct ndr_pull *pull; 3029 struct ndr_push *push; 3030 enum ndr_err_code ndr_err; 3031 DATA_BLOB blob; 3032 struct srvsvc_NetGetFileSecurity *r; 3033 3034 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETGETFILESECURITY]; 3035 3036 r = talloc(talloc_tos(), struct srvsvc_NetGetFileSecurity); 3037 if (r == NULL) { 3038 return false; 3039 } 3040 3041 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3042 talloc_free(r); 3043 return false; 3044 } 3045 3046 pull = ndr_pull_init_blob(&blob, r, NULL); 3047 if (pull == NULL) { 3048 talloc_free(r); 3049 return false; 3050 } 3051 3052 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3053 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3054 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3055 talloc_free(r); 3056 return false; 3057 } 3058 3059 if (DEBUGLEVEL >= 10) { 3060 NDR_PRINT_IN_DEBUG(srvsvc_NetGetFileSecurity, r); 3061 } 3062 3063 ZERO_STRUCT(r->out); 3064 r->out.sd_buf = talloc_zero(r, struct sec_desc_buf *); 3065 if (r->out.sd_buf == NULL) { 3066 talloc_free(r); 3067 return false; 3068 } 3069 3070 r->out.result = _srvsvc_NetGetFileSecurity(p, r); 3071 3072 if (p->rng_fault_state) { 3073 talloc_free(r); 3074 /* Return true here, srv_pipe_hnd.c will take care */ 3075 return true; 3076 } 3077 3078 if (DEBUGLEVEL >= 10) { 3079 NDR_PRINT_OUT_DEBUG(srvsvc_NetGetFileSecurity, r); 3080 } 3081 3082 push = ndr_push_init_ctx(r, NULL); 3083 if (push == NULL) { 3084 talloc_free(r); 3085 return false; 3086 } 3087 3088 ndr_err = call->ndr_push(push, NDR_OUT, r); 3089 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3090 talloc_free(r); 3091 return false; 3092 } 3093 3094 blob = ndr_push_blob(push); 3095 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3096 talloc_free(r); 3097 return false; 3098 } 3099 3100 talloc_free(r); 3101 3102 return true; 3103} 3104 3105static bool api_srvsvc_NetSetFileSecurity(pipes_struct *p) 3106{ 3107 const struct ndr_interface_call *call; 3108 struct ndr_pull *pull; 3109 struct ndr_push *push; 3110 enum ndr_err_code ndr_err; 3111 DATA_BLOB blob; 3112 struct srvsvc_NetSetFileSecurity *r; 3113 3114 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSETFILESECURITY]; 3115 3116 r = talloc(talloc_tos(), struct srvsvc_NetSetFileSecurity); 3117 if (r == NULL) { 3118 return false; 3119 } 3120 3121 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3122 talloc_free(r); 3123 return false; 3124 } 3125 3126 pull = ndr_pull_init_blob(&blob, r, NULL); 3127 if (pull == NULL) { 3128 talloc_free(r); 3129 return false; 3130 } 3131 3132 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3133 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3134 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3135 talloc_free(r); 3136 return false; 3137 } 3138 3139 if (DEBUGLEVEL >= 10) { 3140 NDR_PRINT_IN_DEBUG(srvsvc_NetSetFileSecurity, r); 3141 } 3142 3143 r->out.result = _srvsvc_NetSetFileSecurity(p, r); 3144 3145 if (p->rng_fault_state) { 3146 talloc_free(r); 3147 /* Return true here, srv_pipe_hnd.c will take care */ 3148 return true; 3149 } 3150 3151 if (DEBUGLEVEL >= 10) { 3152 NDR_PRINT_OUT_DEBUG(srvsvc_NetSetFileSecurity, r); 3153 } 3154 3155 push = ndr_push_init_ctx(r, NULL); 3156 if (push == NULL) { 3157 talloc_free(r); 3158 return false; 3159 } 3160 3161 ndr_err = call->ndr_push(push, NDR_OUT, r); 3162 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3163 talloc_free(r); 3164 return false; 3165 } 3166 3167 blob = ndr_push_blob(push); 3168 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3169 talloc_free(r); 3170 return false; 3171 } 3172 3173 talloc_free(r); 3174 3175 return true; 3176} 3177 3178static bool api_srvsvc_NetServerTransportAddEx(pipes_struct *p) 3179{ 3180 const struct ndr_interface_call *call; 3181 struct ndr_pull *pull; 3182 struct ndr_push *push; 3183 enum ndr_err_code ndr_err; 3184 DATA_BLOB blob; 3185 struct srvsvc_NetServerTransportAddEx *r; 3186 3187 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSERVERTRANSPORTADDEX]; 3188 3189 r = talloc(talloc_tos(), struct srvsvc_NetServerTransportAddEx); 3190 if (r == NULL) { 3191 return false; 3192 } 3193 3194 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3195 talloc_free(r); 3196 return false; 3197 } 3198 3199 pull = ndr_pull_init_blob(&blob, r, NULL); 3200 if (pull == NULL) { 3201 talloc_free(r); 3202 return false; 3203 } 3204 3205 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3206 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3207 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3208 talloc_free(r); 3209 return false; 3210 } 3211 3212 if (DEBUGLEVEL >= 10) { 3213 NDR_PRINT_IN_DEBUG(srvsvc_NetServerTransportAddEx, r); 3214 } 3215 3216 r->out.result = _srvsvc_NetServerTransportAddEx(p, r); 3217 3218 if (p->rng_fault_state) { 3219 talloc_free(r); 3220 /* Return true here, srv_pipe_hnd.c will take care */ 3221 return true; 3222 } 3223 3224 if (DEBUGLEVEL >= 10) { 3225 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerTransportAddEx, r); 3226 } 3227 3228 push = ndr_push_init_ctx(r, NULL); 3229 if (push == NULL) { 3230 talloc_free(r); 3231 return false; 3232 } 3233 3234 ndr_err = call->ndr_push(push, NDR_OUT, r); 3235 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3236 talloc_free(r); 3237 return false; 3238 } 3239 3240 blob = ndr_push_blob(push); 3241 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3242 talloc_free(r); 3243 return false; 3244 } 3245 3246 talloc_free(r); 3247 3248 return true; 3249} 3250 3251static bool api_srvsvc_NetServerSetServiceBitsEx(pipes_struct *p) 3252{ 3253 const struct ndr_interface_call *call; 3254 struct ndr_pull *pull; 3255 struct ndr_push *push; 3256 enum ndr_err_code ndr_err; 3257 DATA_BLOB blob; 3258 struct srvsvc_NetServerSetServiceBitsEx *r; 3259 3260 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSERVERSETSERVICEBITSEX]; 3261 3262 r = talloc(talloc_tos(), struct srvsvc_NetServerSetServiceBitsEx); 3263 if (r == NULL) { 3264 return false; 3265 } 3266 3267 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3268 talloc_free(r); 3269 return false; 3270 } 3271 3272 pull = ndr_pull_init_blob(&blob, r, NULL); 3273 if (pull == NULL) { 3274 talloc_free(r); 3275 return false; 3276 } 3277 3278 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3279 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3280 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3281 talloc_free(r); 3282 return false; 3283 } 3284 3285 if (DEBUGLEVEL >= 10) { 3286 NDR_PRINT_IN_DEBUG(srvsvc_NetServerSetServiceBitsEx, r); 3287 } 3288 3289 r->out.result = _srvsvc_NetServerSetServiceBitsEx(p, r); 3290 3291 if (p->rng_fault_state) { 3292 talloc_free(r); 3293 /* Return true here, srv_pipe_hnd.c will take care */ 3294 return true; 3295 } 3296 3297 if (DEBUGLEVEL >= 10) { 3298 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerSetServiceBitsEx, r); 3299 } 3300 3301 push = ndr_push_init_ctx(r, NULL); 3302 if (push == NULL) { 3303 talloc_free(r); 3304 return false; 3305 } 3306 3307 ndr_err = call->ndr_push(push, NDR_OUT, r); 3308 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3309 talloc_free(r); 3310 return false; 3311 } 3312 3313 blob = ndr_push_blob(push); 3314 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3315 talloc_free(r); 3316 return false; 3317 } 3318 3319 talloc_free(r); 3320 3321 return true; 3322} 3323 3324static bool api_srvsvc_NETRDFSGETVERSION(pipes_struct *p) 3325{ 3326 const struct ndr_interface_call *call; 3327 struct ndr_pull *pull; 3328 struct ndr_push *push; 3329 enum ndr_err_code ndr_err; 3330 DATA_BLOB blob; 3331 struct srvsvc_NETRDFSGETVERSION *r; 3332 3333 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSGETVERSION]; 3334 3335 r = talloc(talloc_tos(), struct srvsvc_NETRDFSGETVERSION); 3336 if (r == NULL) { 3337 return false; 3338 } 3339 3340 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3341 talloc_free(r); 3342 return false; 3343 } 3344 3345 pull = ndr_pull_init_blob(&blob, r, NULL); 3346 if (pull == NULL) { 3347 talloc_free(r); 3348 return false; 3349 } 3350 3351 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3352 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3353 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3354 talloc_free(r); 3355 return false; 3356 } 3357 3358 if (DEBUGLEVEL >= 10) { 3359 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSGETVERSION, r); 3360 } 3361 3362 r->out.result = _srvsvc_NETRDFSGETVERSION(p, r); 3363 3364 if (p->rng_fault_state) { 3365 talloc_free(r); 3366 /* Return true here, srv_pipe_hnd.c will take care */ 3367 return true; 3368 } 3369 3370 if (DEBUGLEVEL >= 10) { 3371 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSGETVERSION, r); 3372 } 3373 3374 push = ndr_push_init_ctx(r, NULL); 3375 if (push == NULL) { 3376 talloc_free(r); 3377 return false; 3378 } 3379 3380 ndr_err = call->ndr_push(push, NDR_OUT, r); 3381 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3382 talloc_free(r); 3383 return false; 3384 } 3385 3386 blob = ndr_push_blob(push); 3387 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3388 talloc_free(r); 3389 return false; 3390 } 3391 3392 talloc_free(r); 3393 3394 return true; 3395} 3396 3397static bool api_srvsvc_NETRDFSCREATELOCALPARTITION(pipes_struct *p) 3398{ 3399 const struct ndr_interface_call *call; 3400 struct ndr_pull *pull; 3401 struct ndr_push *push; 3402 enum ndr_err_code ndr_err; 3403 DATA_BLOB blob; 3404 struct srvsvc_NETRDFSCREATELOCALPARTITION *r; 3405 3406 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSCREATELOCALPARTITION]; 3407 3408 r = talloc(talloc_tos(), struct srvsvc_NETRDFSCREATELOCALPARTITION); 3409 if (r == NULL) { 3410 return false; 3411 } 3412 3413 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3414 talloc_free(r); 3415 return false; 3416 } 3417 3418 pull = ndr_pull_init_blob(&blob, r, NULL); 3419 if (pull == NULL) { 3420 talloc_free(r); 3421 return false; 3422 } 3423 3424 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3425 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3426 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3427 talloc_free(r); 3428 return false; 3429 } 3430 3431 if (DEBUGLEVEL >= 10) { 3432 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSCREATELOCALPARTITION, r); 3433 } 3434 3435 r->out.result = _srvsvc_NETRDFSCREATELOCALPARTITION(p, r); 3436 3437 if (p->rng_fault_state) { 3438 talloc_free(r); 3439 /* Return true here, srv_pipe_hnd.c will take care */ 3440 return true; 3441 } 3442 3443 if (DEBUGLEVEL >= 10) { 3444 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSCREATELOCALPARTITION, r); 3445 } 3446 3447 push = ndr_push_init_ctx(r, NULL); 3448 if (push == NULL) { 3449 talloc_free(r); 3450 return false; 3451 } 3452 3453 ndr_err = call->ndr_push(push, NDR_OUT, r); 3454 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3455 talloc_free(r); 3456 return false; 3457 } 3458 3459 blob = ndr_push_blob(push); 3460 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3461 talloc_free(r); 3462 return false; 3463 } 3464 3465 talloc_free(r); 3466 3467 return true; 3468} 3469 3470static bool api_srvsvc_NETRDFSDELETELOCALPARTITION(pipes_struct *p) 3471{ 3472 const struct ndr_interface_call *call; 3473 struct ndr_pull *pull; 3474 struct ndr_push *push; 3475 enum ndr_err_code ndr_err; 3476 DATA_BLOB blob; 3477 struct srvsvc_NETRDFSDELETELOCALPARTITION *r; 3478 3479 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSDELETELOCALPARTITION]; 3480 3481 r = talloc(talloc_tos(), struct srvsvc_NETRDFSDELETELOCALPARTITION); 3482 if (r == NULL) { 3483 return false; 3484 } 3485 3486 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3487 talloc_free(r); 3488 return false; 3489 } 3490 3491 pull = ndr_pull_init_blob(&blob, r, NULL); 3492 if (pull == NULL) { 3493 talloc_free(r); 3494 return false; 3495 } 3496 3497 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3498 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3499 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3500 talloc_free(r); 3501 return false; 3502 } 3503 3504 if (DEBUGLEVEL >= 10) { 3505 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSDELETELOCALPARTITION, r); 3506 } 3507 3508 r->out.result = _srvsvc_NETRDFSDELETELOCALPARTITION(p, r); 3509 3510 if (p->rng_fault_state) { 3511 talloc_free(r); 3512 /* Return true here, srv_pipe_hnd.c will take care */ 3513 return true; 3514 } 3515 3516 if (DEBUGLEVEL >= 10) { 3517 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSDELETELOCALPARTITION, r); 3518 } 3519 3520 push = ndr_push_init_ctx(r, NULL); 3521 if (push == NULL) { 3522 talloc_free(r); 3523 return false; 3524 } 3525 3526 ndr_err = call->ndr_push(push, NDR_OUT, r); 3527 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3528 talloc_free(r); 3529 return false; 3530 } 3531 3532 blob = ndr_push_blob(push); 3533 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3534 talloc_free(r); 3535 return false; 3536 } 3537 3538 talloc_free(r); 3539 3540 return true; 3541} 3542 3543static bool api_srvsvc_NETRDFSSETLOCALVOLUMESTATE(pipes_struct *p) 3544{ 3545 const struct ndr_interface_call *call; 3546 struct ndr_pull *pull; 3547 struct ndr_push *push; 3548 enum ndr_err_code ndr_err; 3549 DATA_BLOB blob; 3550 struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r; 3551 3552 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSSETLOCALVOLUMESTATE]; 3553 3554 r = talloc(talloc_tos(), struct srvsvc_NETRDFSSETLOCALVOLUMESTATE); 3555 if (r == NULL) { 3556 return false; 3557 } 3558 3559 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3560 talloc_free(r); 3561 return false; 3562 } 3563 3564 pull = ndr_pull_init_blob(&blob, r, NULL); 3565 if (pull == NULL) { 3566 talloc_free(r); 3567 return false; 3568 } 3569 3570 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3571 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3572 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3573 talloc_free(r); 3574 return false; 3575 } 3576 3577 if (DEBUGLEVEL >= 10) { 3578 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSSETLOCALVOLUMESTATE, r); 3579 } 3580 3581 r->out.result = _srvsvc_NETRDFSSETLOCALVOLUMESTATE(p, r); 3582 3583 if (p->rng_fault_state) { 3584 talloc_free(r); 3585 /* Return true here, srv_pipe_hnd.c will take care */ 3586 return true; 3587 } 3588 3589 if (DEBUGLEVEL >= 10) { 3590 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSSETLOCALVOLUMESTATE, r); 3591 } 3592 3593 push = ndr_push_init_ctx(r, NULL); 3594 if (push == NULL) { 3595 talloc_free(r); 3596 return false; 3597 } 3598 3599 ndr_err = call->ndr_push(push, NDR_OUT, r); 3600 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3601 talloc_free(r); 3602 return false; 3603 } 3604 3605 blob = ndr_push_blob(push); 3606 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3607 talloc_free(r); 3608 return false; 3609 } 3610 3611 talloc_free(r); 3612 3613 return true; 3614} 3615 3616static bool api_srvsvc_NETRDFSSETSERVERINFO(pipes_struct *p) 3617{ 3618 const struct ndr_interface_call *call; 3619 struct ndr_pull *pull; 3620 struct ndr_push *push; 3621 enum ndr_err_code ndr_err; 3622 DATA_BLOB blob; 3623 struct srvsvc_NETRDFSSETSERVERINFO *r; 3624 3625 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSSETSERVERINFO]; 3626 3627 r = talloc(talloc_tos(), struct srvsvc_NETRDFSSETSERVERINFO); 3628 if (r == NULL) { 3629 return false; 3630 } 3631 3632 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3633 talloc_free(r); 3634 return false; 3635 } 3636 3637 pull = ndr_pull_init_blob(&blob, r, NULL); 3638 if (pull == NULL) { 3639 talloc_free(r); 3640 return false; 3641 } 3642 3643 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3644 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3645 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3646 talloc_free(r); 3647 return false; 3648 } 3649 3650 if (DEBUGLEVEL >= 10) { 3651 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSSETSERVERINFO, r); 3652 } 3653 3654 r->out.result = _srvsvc_NETRDFSSETSERVERINFO(p, r); 3655 3656 if (p->rng_fault_state) { 3657 talloc_free(r); 3658 /* Return true here, srv_pipe_hnd.c will take care */ 3659 return true; 3660 } 3661 3662 if (DEBUGLEVEL >= 10) { 3663 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSSETSERVERINFO, r); 3664 } 3665 3666 push = ndr_push_init_ctx(r, NULL); 3667 if (push == NULL) { 3668 talloc_free(r); 3669 return false; 3670 } 3671 3672 ndr_err = call->ndr_push(push, NDR_OUT, r); 3673 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3674 talloc_free(r); 3675 return false; 3676 } 3677 3678 blob = ndr_push_blob(push); 3679 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3680 talloc_free(r); 3681 return false; 3682 } 3683 3684 talloc_free(r); 3685 3686 return true; 3687} 3688 3689static bool api_srvsvc_NETRDFSCREATEEXITPOINT(pipes_struct *p) 3690{ 3691 const struct ndr_interface_call *call; 3692 struct ndr_pull *pull; 3693 struct ndr_push *push; 3694 enum ndr_err_code ndr_err; 3695 DATA_BLOB blob; 3696 struct srvsvc_NETRDFSCREATEEXITPOINT *r; 3697 3698 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSCREATEEXITPOINT]; 3699 3700 r = talloc(talloc_tos(), struct srvsvc_NETRDFSCREATEEXITPOINT); 3701 if (r == NULL) { 3702 return false; 3703 } 3704 3705 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3706 talloc_free(r); 3707 return false; 3708 } 3709 3710 pull = ndr_pull_init_blob(&blob, r, NULL); 3711 if (pull == NULL) { 3712 talloc_free(r); 3713 return false; 3714 } 3715 3716 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3717 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3718 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3719 talloc_free(r); 3720 return false; 3721 } 3722 3723 if (DEBUGLEVEL >= 10) { 3724 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSCREATEEXITPOINT, r); 3725 } 3726 3727 r->out.result = _srvsvc_NETRDFSCREATEEXITPOINT(p, r); 3728 3729 if (p->rng_fault_state) { 3730 talloc_free(r); 3731 /* Return true here, srv_pipe_hnd.c will take care */ 3732 return true; 3733 } 3734 3735 if (DEBUGLEVEL >= 10) { 3736 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSCREATEEXITPOINT, r); 3737 } 3738 3739 push = ndr_push_init_ctx(r, NULL); 3740 if (push == NULL) { 3741 talloc_free(r); 3742 return false; 3743 } 3744 3745 ndr_err = call->ndr_push(push, NDR_OUT, r); 3746 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3747 talloc_free(r); 3748 return false; 3749 } 3750 3751 blob = ndr_push_blob(push); 3752 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3753 talloc_free(r); 3754 return false; 3755 } 3756 3757 talloc_free(r); 3758 3759 return true; 3760} 3761 3762static bool api_srvsvc_NETRDFSDELETEEXITPOINT(pipes_struct *p) 3763{ 3764 const struct ndr_interface_call *call; 3765 struct ndr_pull *pull; 3766 struct ndr_push *push; 3767 enum ndr_err_code ndr_err; 3768 DATA_BLOB blob; 3769 struct srvsvc_NETRDFSDELETEEXITPOINT *r; 3770 3771 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSDELETEEXITPOINT]; 3772 3773 r = talloc(talloc_tos(), struct srvsvc_NETRDFSDELETEEXITPOINT); 3774 if (r == NULL) { 3775 return false; 3776 } 3777 3778 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3779 talloc_free(r); 3780 return false; 3781 } 3782 3783 pull = ndr_pull_init_blob(&blob, r, NULL); 3784 if (pull == NULL) { 3785 talloc_free(r); 3786 return false; 3787 } 3788 3789 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3790 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3791 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3792 talloc_free(r); 3793 return false; 3794 } 3795 3796 if (DEBUGLEVEL >= 10) { 3797 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSDELETEEXITPOINT, r); 3798 } 3799 3800 r->out.result = _srvsvc_NETRDFSDELETEEXITPOINT(p, r); 3801 3802 if (p->rng_fault_state) { 3803 talloc_free(r); 3804 /* Return true here, srv_pipe_hnd.c will take care */ 3805 return true; 3806 } 3807 3808 if (DEBUGLEVEL >= 10) { 3809 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSDELETEEXITPOINT, r); 3810 } 3811 3812 push = ndr_push_init_ctx(r, NULL); 3813 if (push == NULL) { 3814 talloc_free(r); 3815 return false; 3816 } 3817 3818 ndr_err = call->ndr_push(push, NDR_OUT, r); 3819 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3820 talloc_free(r); 3821 return false; 3822 } 3823 3824 blob = ndr_push_blob(push); 3825 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3826 talloc_free(r); 3827 return false; 3828 } 3829 3830 talloc_free(r); 3831 3832 return true; 3833} 3834 3835static bool api_srvsvc_NETRDFSMODIFYPREFIX(pipes_struct *p) 3836{ 3837 const struct ndr_interface_call *call; 3838 struct ndr_pull *pull; 3839 struct ndr_push *push; 3840 enum ndr_err_code ndr_err; 3841 DATA_BLOB blob; 3842 struct srvsvc_NETRDFSMODIFYPREFIX *r; 3843 3844 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSMODIFYPREFIX]; 3845 3846 r = talloc(talloc_tos(), struct srvsvc_NETRDFSMODIFYPREFIX); 3847 if (r == NULL) { 3848 return false; 3849 } 3850 3851 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3852 talloc_free(r); 3853 return false; 3854 } 3855 3856 pull = ndr_pull_init_blob(&blob, r, NULL); 3857 if (pull == NULL) { 3858 talloc_free(r); 3859 return false; 3860 } 3861 3862 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3863 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3864 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3865 talloc_free(r); 3866 return false; 3867 } 3868 3869 if (DEBUGLEVEL >= 10) { 3870 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSMODIFYPREFIX, r); 3871 } 3872 3873 r->out.result = _srvsvc_NETRDFSMODIFYPREFIX(p, r); 3874 3875 if (p->rng_fault_state) { 3876 talloc_free(r); 3877 /* Return true here, srv_pipe_hnd.c will take care */ 3878 return true; 3879 } 3880 3881 if (DEBUGLEVEL >= 10) { 3882 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSMODIFYPREFIX, r); 3883 } 3884 3885 push = ndr_push_init_ctx(r, NULL); 3886 if (push == NULL) { 3887 talloc_free(r); 3888 return false; 3889 } 3890 3891 ndr_err = call->ndr_push(push, NDR_OUT, r); 3892 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3893 talloc_free(r); 3894 return false; 3895 } 3896 3897 blob = ndr_push_blob(push); 3898 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3899 talloc_free(r); 3900 return false; 3901 } 3902 3903 talloc_free(r); 3904 3905 return true; 3906} 3907 3908static bool api_srvsvc_NETRDFSFIXLOCALVOLUME(pipes_struct *p) 3909{ 3910 const struct ndr_interface_call *call; 3911 struct ndr_pull *pull; 3912 struct ndr_push *push; 3913 enum ndr_err_code ndr_err; 3914 DATA_BLOB blob; 3915 struct srvsvc_NETRDFSFIXLOCALVOLUME *r; 3916 3917 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSFIXLOCALVOLUME]; 3918 3919 r = talloc(talloc_tos(), struct srvsvc_NETRDFSFIXLOCALVOLUME); 3920 if (r == NULL) { 3921 return false; 3922 } 3923 3924 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3925 talloc_free(r); 3926 return false; 3927 } 3928 3929 pull = ndr_pull_init_blob(&blob, r, NULL); 3930 if (pull == NULL) { 3931 talloc_free(r); 3932 return false; 3933 } 3934 3935 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 3936 ndr_err = call->ndr_pull(pull, NDR_IN, r); 3937 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3938 talloc_free(r); 3939 return false; 3940 } 3941 3942 if (DEBUGLEVEL >= 10) { 3943 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSFIXLOCALVOLUME, r); 3944 } 3945 3946 r->out.result = _srvsvc_NETRDFSFIXLOCALVOLUME(p, r); 3947 3948 if (p->rng_fault_state) { 3949 talloc_free(r); 3950 /* Return true here, srv_pipe_hnd.c will take care */ 3951 return true; 3952 } 3953 3954 if (DEBUGLEVEL >= 10) { 3955 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSFIXLOCALVOLUME, r); 3956 } 3957 3958 push = ndr_push_init_ctx(r, NULL); 3959 if (push == NULL) { 3960 talloc_free(r); 3961 return false; 3962 } 3963 3964 ndr_err = call->ndr_push(push, NDR_OUT, r); 3965 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 3966 talloc_free(r); 3967 return false; 3968 } 3969 3970 blob = ndr_push_blob(push); 3971 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 3972 talloc_free(r); 3973 return false; 3974 } 3975 3976 talloc_free(r); 3977 3978 return true; 3979} 3980 3981static bool api_srvsvc_NETRDFSMANAGERREPORTSITEINFO(pipes_struct *p) 3982{ 3983 const struct ndr_interface_call *call; 3984 struct ndr_pull *pull; 3985 struct ndr_push *push; 3986 enum ndr_err_code ndr_err; 3987 DATA_BLOB blob; 3988 struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r; 3989 3990 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSMANAGERREPORTSITEINFO]; 3991 3992 r = talloc(talloc_tos(), struct srvsvc_NETRDFSMANAGERREPORTSITEINFO); 3993 if (r == NULL) { 3994 return false; 3995 } 3996 3997 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 3998 talloc_free(r); 3999 return false; 4000 } 4001 4002 pull = ndr_pull_init_blob(&blob, r, NULL); 4003 if (pull == NULL) { 4004 talloc_free(r); 4005 return false; 4006 } 4007 4008 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4009 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4010 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4011 talloc_free(r); 4012 return false; 4013 } 4014 4015 if (DEBUGLEVEL >= 10) { 4016 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSMANAGERREPORTSITEINFO, r); 4017 } 4018 4019 r->out.result = _srvsvc_NETRDFSMANAGERREPORTSITEINFO(p, r); 4020 4021 if (p->rng_fault_state) { 4022 talloc_free(r); 4023 /* Return true here, srv_pipe_hnd.c will take care */ 4024 return true; 4025 } 4026 4027 if (DEBUGLEVEL >= 10) { 4028 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSMANAGERREPORTSITEINFO, r); 4029 } 4030 4031 push = ndr_push_init_ctx(r, NULL); 4032 if (push == NULL) { 4033 talloc_free(r); 4034 return false; 4035 } 4036 4037 ndr_err = call->ndr_push(push, NDR_OUT, r); 4038 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4039 talloc_free(r); 4040 return false; 4041 } 4042 4043 blob = ndr_push_blob(push); 4044 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4045 talloc_free(r); 4046 return false; 4047 } 4048 4049 talloc_free(r); 4050 4051 return true; 4052} 4053 4054static bool api_srvsvc_NETRSERVERTRANSPORTDELEX(pipes_struct *p) 4055{ 4056 const struct ndr_interface_call *call; 4057 struct ndr_pull *pull; 4058 struct ndr_push *push; 4059 enum ndr_err_code ndr_err; 4060 DATA_BLOB blob; 4061 struct srvsvc_NETRSERVERTRANSPORTDELEX *r; 4062 4063 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRSERVERTRANSPORTDELEX]; 4064 4065 r = talloc(talloc_tos(), struct srvsvc_NETRSERVERTRANSPORTDELEX); 4066 if (r == NULL) { 4067 return false; 4068 } 4069 4070 if (!prs_data_blob(&p->in_data.data, &blob, r)) { 4071 talloc_free(r); 4072 return false; 4073 } 4074 4075 pull = ndr_pull_init_blob(&blob, r, NULL); 4076 if (pull == NULL) { 4077 talloc_free(r); 4078 return false; 4079 } 4080 4081 pull->flags |= LIBNDR_FLAG_REF_ALLOC; 4082 ndr_err = call->ndr_pull(pull, NDR_IN, r); 4083 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4084 talloc_free(r); 4085 return false; 4086 } 4087 4088 if (DEBUGLEVEL >= 10) { 4089 NDR_PRINT_IN_DEBUG(srvsvc_NETRSERVERTRANSPORTDELEX, r); 4090 } 4091 4092 r->out.result = _srvsvc_NETRSERVERTRANSPORTDELEX(p, r); 4093 4094 if (p->rng_fault_state) { 4095 talloc_free(r); 4096 /* Return true here, srv_pipe_hnd.c will take care */ 4097 return true; 4098 } 4099 4100 if (DEBUGLEVEL >= 10) { 4101 NDR_PRINT_OUT_DEBUG(srvsvc_NETRSERVERTRANSPORTDELEX, r); 4102 } 4103 4104 push = ndr_push_init_ctx(r, NULL); 4105 if (push == NULL) { 4106 talloc_free(r); 4107 return false; 4108 } 4109 4110 ndr_err = call->ndr_push(push, NDR_OUT, r); 4111 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { 4112 talloc_free(r); 4113 return false; 4114 } 4115 4116 blob = ndr_push_blob(push); 4117 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) { 4118 talloc_free(r); 4119 return false; 4120 } 4121 4122 talloc_free(r); 4123 4124 return true; 4125} 4126 4127 4128/* Tables */ 4129static struct api_struct api_srvsvc_cmds[] = 4130{ 4131 {"SRVSVC_NETCHARDEVENUM", NDR_SRVSVC_NETCHARDEVENUM, api_srvsvc_NetCharDevEnum}, 4132 {"SRVSVC_NETCHARDEVGETINFO", NDR_SRVSVC_NETCHARDEVGETINFO, api_srvsvc_NetCharDevGetInfo}, 4133 {"SRVSVC_NETCHARDEVCONTROL", NDR_SRVSVC_NETCHARDEVCONTROL, api_srvsvc_NetCharDevControl}, 4134 {"SRVSVC_NETCHARDEVQENUM", NDR_SRVSVC_NETCHARDEVQENUM, api_srvsvc_NetCharDevQEnum}, 4135 {"SRVSVC_NETCHARDEVQGETINFO", NDR_SRVSVC_NETCHARDEVQGETINFO, api_srvsvc_NetCharDevQGetInfo}, 4136 {"SRVSVC_NETCHARDEVQSETINFO", NDR_SRVSVC_NETCHARDEVQSETINFO, api_srvsvc_NetCharDevQSetInfo}, 4137 {"SRVSVC_NETCHARDEVQPURGE", NDR_SRVSVC_NETCHARDEVQPURGE, api_srvsvc_NetCharDevQPurge}, 4138 {"SRVSVC_NETCHARDEVQPURGESELF", NDR_SRVSVC_NETCHARDEVQPURGESELF, api_srvsvc_NetCharDevQPurgeSelf}, 4139 {"SRVSVC_NETCONNENUM", NDR_SRVSVC_NETCONNENUM, api_srvsvc_NetConnEnum}, 4140 {"SRVSVC_NETFILEENUM", NDR_SRVSVC_NETFILEENUM, api_srvsvc_NetFileEnum}, 4141 {"SRVSVC_NETFILEGETINFO", NDR_SRVSVC_NETFILEGETINFO, api_srvsvc_NetFileGetInfo}, 4142 {"SRVSVC_NETFILECLOSE", NDR_SRVSVC_NETFILECLOSE, api_srvsvc_NetFileClose}, 4143 {"SRVSVC_NETSESSENUM", NDR_SRVSVC_NETSESSENUM, api_srvsvc_NetSessEnum}, 4144 {"SRVSVC_NETSESSDEL", NDR_SRVSVC_NETSESSDEL, api_srvsvc_NetSessDel}, 4145 {"SRVSVC_NETSHAREADD", NDR_SRVSVC_NETSHAREADD, api_srvsvc_NetShareAdd}, 4146 {"SRVSVC_NETSHAREENUMALL", NDR_SRVSVC_NETSHAREENUMALL, api_srvsvc_NetShareEnumAll}, 4147 {"SRVSVC_NETSHAREGETINFO", NDR_SRVSVC_NETSHAREGETINFO, api_srvsvc_NetShareGetInfo}, 4148 {"SRVSVC_NETSHARESETINFO", NDR_SRVSVC_NETSHARESETINFO, api_srvsvc_NetShareSetInfo}, 4149 {"SRVSVC_NETSHAREDEL", NDR_SRVSVC_NETSHAREDEL, api_srvsvc_NetShareDel}, 4150 {"SRVSVC_NETSHAREDELSTICKY", NDR_SRVSVC_NETSHAREDELSTICKY, api_srvsvc_NetShareDelSticky}, 4151 {"SRVSVC_NETSHARECHECK", NDR_SRVSVC_NETSHARECHECK, api_srvsvc_NetShareCheck}, 4152 {"SRVSVC_NETSRVGETINFO", NDR_SRVSVC_NETSRVGETINFO, api_srvsvc_NetSrvGetInfo}, 4153 {"SRVSVC_NETSRVSETINFO", NDR_SRVSVC_NETSRVSETINFO, api_srvsvc_NetSrvSetInfo}, 4154 {"SRVSVC_NETDISKENUM", NDR_SRVSVC_NETDISKENUM, api_srvsvc_NetDiskEnum}, 4155 {"SRVSVC_NETSERVERSTATISTICSGET", NDR_SRVSVC_NETSERVERSTATISTICSGET, api_srvsvc_NetServerStatisticsGet}, 4156 {"SRVSVC_NETTRANSPORTADD", NDR_SRVSVC_NETTRANSPORTADD, api_srvsvc_NetTransportAdd}, 4157 {"SRVSVC_NETTRANSPORTENUM", NDR_SRVSVC_NETTRANSPORTENUM, api_srvsvc_NetTransportEnum}, 4158 {"SRVSVC_NETTRANSPORTDEL", NDR_SRVSVC_NETTRANSPORTDEL, api_srvsvc_NetTransportDel}, 4159 {"SRVSVC_NETREMOTETOD", NDR_SRVSVC_NETREMOTETOD, api_srvsvc_NetRemoteTOD}, 4160 {"SRVSVC_NETSETSERVICEBITS", NDR_SRVSVC_NETSETSERVICEBITS, api_srvsvc_NetSetServiceBits}, 4161 {"SRVSVC_NETPATHTYPE", NDR_SRVSVC_NETPATHTYPE, api_srvsvc_NetPathType}, 4162 {"SRVSVC_NETPATHCANONICALIZE", NDR_SRVSVC_NETPATHCANONICALIZE, api_srvsvc_NetPathCanonicalize}, 4163 {"SRVSVC_NETPATHCOMPARE", NDR_SRVSVC_NETPATHCOMPARE, api_srvsvc_NetPathCompare}, 4164 {"SRVSVC_NETNAMEVALIDATE", NDR_SRVSVC_NETNAMEVALIDATE, api_srvsvc_NetNameValidate}, 4165 {"SRVSVC_NETRPRNAMECANONICALIZE", NDR_SRVSVC_NETRPRNAMECANONICALIZE, api_srvsvc_NETRPRNAMECANONICALIZE}, 4166 {"SRVSVC_NETPRNAMECOMPARE", NDR_SRVSVC_NETPRNAMECOMPARE, api_srvsvc_NetPRNameCompare}, 4167 {"SRVSVC_NETSHAREENUM", NDR_SRVSVC_NETSHAREENUM, api_srvsvc_NetShareEnum}, 4168 {"SRVSVC_NETSHAREDELSTART", NDR_SRVSVC_NETSHAREDELSTART, api_srvsvc_NetShareDelStart}, 4169 {"SRVSVC_NETSHAREDELCOMMIT", NDR_SRVSVC_NETSHAREDELCOMMIT, api_srvsvc_NetShareDelCommit}, 4170 {"SRVSVC_NETGETFILESECURITY", NDR_SRVSVC_NETGETFILESECURITY, api_srvsvc_NetGetFileSecurity}, 4171 {"SRVSVC_NETSETFILESECURITY", NDR_SRVSVC_NETSETFILESECURITY, api_srvsvc_NetSetFileSecurity}, 4172 {"SRVSVC_NETSERVERTRANSPORTADDEX", NDR_SRVSVC_NETSERVERTRANSPORTADDEX, api_srvsvc_NetServerTransportAddEx}, 4173 {"SRVSVC_NETSERVERSETSERVICEBITSEX", NDR_SRVSVC_NETSERVERSETSERVICEBITSEX, api_srvsvc_NetServerSetServiceBitsEx}, 4174 {"SRVSVC_NETRDFSGETVERSION", NDR_SRVSVC_NETRDFSGETVERSION, api_srvsvc_NETRDFSGETVERSION}, 4175 {"SRVSVC_NETRDFSCREATELOCALPARTITION", NDR_SRVSVC_NETRDFSCREATELOCALPARTITION, api_srvsvc_NETRDFSCREATELOCALPARTITION}, 4176 {"SRVSVC_NETRDFSDELETELOCALPARTITION", NDR_SRVSVC_NETRDFSDELETELOCALPARTITION, api_srvsvc_NETRDFSDELETELOCALPARTITION}, 4177 {"SRVSVC_NETRDFSSETLOCALVOLUMESTATE", NDR_SRVSVC_NETRDFSSETLOCALVOLUMESTATE, api_srvsvc_NETRDFSSETLOCALVOLUMESTATE}, 4178 {"SRVSVC_NETRDFSSETSERVERINFO", NDR_SRVSVC_NETRDFSSETSERVERINFO, api_srvsvc_NETRDFSSETSERVERINFO}, 4179 {"SRVSVC_NETRDFSCREATEEXITPOINT", NDR_SRVSVC_NETRDFSCREATEEXITPOINT, api_srvsvc_NETRDFSCREATEEXITPOINT}, 4180 {"SRVSVC_NETRDFSDELETEEXITPOINT", NDR_SRVSVC_NETRDFSDELETEEXITPOINT, api_srvsvc_NETRDFSDELETEEXITPOINT}, 4181 {"SRVSVC_NETRDFSMODIFYPREFIX", NDR_SRVSVC_NETRDFSMODIFYPREFIX, api_srvsvc_NETRDFSMODIFYPREFIX}, 4182 {"SRVSVC_NETRDFSFIXLOCALVOLUME", NDR_SRVSVC_NETRDFSFIXLOCALVOLUME, api_srvsvc_NETRDFSFIXLOCALVOLUME}, 4183 {"SRVSVC_NETRDFSMANAGERREPORTSITEINFO", NDR_SRVSVC_NETRDFSMANAGERREPORTSITEINFO, api_srvsvc_NETRDFSMANAGERREPORTSITEINFO}, 4184 {"SRVSVC_NETRSERVERTRANSPORTDELEX", NDR_SRVSVC_NETRSERVERTRANSPORTDELEX, api_srvsvc_NETRSERVERTRANSPORTDELEX}, 4185}; 4186 4187void srvsvc_get_pipe_fns(struct api_struct **fns, int *n_fns) 4188{ 4189 *fns = api_srvsvc_cmds; 4190 *n_fns = sizeof(api_srvsvc_cmds) / sizeof(struct api_struct); 4191} 4192 4193NTSTATUS rpc_srvsvc_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r) 4194{ 4195 if (cli->pipes_struct == NULL) { 4196 return NT_STATUS_INVALID_PARAMETER; 4197 } 4198 4199 switch (opnum) 4200 { 4201 case NDR_SRVSVC_NETCHARDEVENUM: { 4202 struct srvsvc_NetCharDevEnum *r = (struct srvsvc_NetCharDevEnum *)_r; 4203 ZERO_STRUCT(r->out); 4204 r->out.info_ctr = r->in.info_ctr; 4205 r->out.resume_handle = r->in.resume_handle; 4206 r->out.totalentries = talloc_zero(mem_ctx, uint32_t); 4207 if (r->out.totalentries == NULL) { 4208 return NT_STATUS_NO_MEMORY; 4209 } 4210 4211 r->out.result = _srvsvc_NetCharDevEnum(cli->pipes_struct, r); 4212 return NT_STATUS_OK; 4213 } 4214 4215 case NDR_SRVSVC_NETCHARDEVGETINFO: { 4216 struct srvsvc_NetCharDevGetInfo *r = (struct srvsvc_NetCharDevGetInfo *)_r; 4217 ZERO_STRUCT(r->out); 4218 r->out.info = talloc_zero(mem_ctx, union srvsvc_NetCharDevInfo); 4219 if (r->out.info == NULL) { 4220 return NT_STATUS_NO_MEMORY; 4221 } 4222 4223 r->out.result = _srvsvc_NetCharDevGetInfo(cli->pipes_struct, r); 4224 return NT_STATUS_OK; 4225 } 4226 4227 case NDR_SRVSVC_NETCHARDEVCONTROL: { 4228 struct srvsvc_NetCharDevControl *r = (struct srvsvc_NetCharDevControl *)_r; 4229 r->out.result = _srvsvc_NetCharDevControl(cli->pipes_struct, r); 4230 return NT_STATUS_OK; 4231 } 4232 4233 case NDR_SRVSVC_NETCHARDEVQENUM: { 4234 struct srvsvc_NetCharDevQEnum *r = (struct srvsvc_NetCharDevQEnum *)_r; 4235 ZERO_STRUCT(r->out); 4236 r->out.info_ctr = r->in.info_ctr; 4237 r->out.resume_handle = r->in.resume_handle; 4238 r->out.totalentries = talloc_zero(mem_ctx, uint32_t); 4239 if (r->out.totalentries == NULL) { 4240 return NT_STATUS_NO_MEMORY; 4241 } 4242 4243 r->out.result = _srvsvc_NetCharDevQEnum(cli->pipes_struct, r); 4244 return NT_STATUS_OK; 4245 } 4246 4247 case NDR_SRVSVC_NETCHARDEVQGETINFO: { 4248 struct srvsvc_NetCharDevQGetInfo *r = (struct srvsvc_NetCharDevQGetInfo *)_r; 4249 ZERO_STRUCT(r->out); 4250 r->out.info = talloc_zero(mem_ctx, union srvsvc_NetCharDevQInfo); 4251 if (r->out.info == NULL) { 4252 return NT_STATUS_NO_MEMORY; 4253 } 4254 4255 r->out.result = _srvsvc_NetCharDevQGetInfo(cli->pipes_struct, r); 4256 return NT_STATUS_OK; 4257 } 4258 4259 case NDR_SRVSVC_NETCHARDEVQSETINFO: { 4260 struct srvsvc_NetCharDevQSetInfo *r = (struct srvsvc_NetCharDevQSetInfo *)_r; 4261 ZERO_STRUCT(r->out); 4262 r->out.parm_error = r->in.parm_error; 4263 r->out.result = _srvsvc_NetCharDevQSetInfo(cli->pipes_struct, r); 4264 return NT_STATUS_OK; 4265 } 4266 4267 case NDR_SRVSVC_NETCHARDEVQPURGE: { 4268 struct srvsvc_NetCharDevQPurge *r = (struct srvsvc_NetCharDevQPurge *)_r; 4269 r->out.result = _srvsvc_NetCharDevQPurge(cli->pipes_struct, r); 4270 return NT_STATUS_OK; 4271 } 4272 4273 case NDR_SRVSVC_NETCHARDEVQPURGESELF: { 4274 struct srvsvc_NetCharDevQPurgeSelf *r = (struct srvsvc_NetCharDevQPurgeSelf *)_r; 4275 r->out.result = _srvsvc_NetCharDevQPurgeSelf(cli->pipes_struct, r); 4276 return NT_STATUS_OK; 4277 } 4278 4279 case NDR_SRVSVC_NETCONNENUM: { 4280 struct srvsvc_NetConnEnum *r = (struct srvsvc_NetConnEnum *)_r; 4281 ZERO_STRUCT(r->out); 4282 r->out.info_ctr = r->in.info_ctr; 4283 r->out.resume_handle = r->in.resume_handle; 4284 r->out.totalentries = talloc_zero(mem_ctx, uint32_t); 4285 if (r->out.totalentries == NULL) { 4286 return NT_STATUS_NO_MEMORY; 4287 } 4288 4289 r->out.result = _srvsvc_NetConnEnum(cli->pipes_struct, r); 4290 return NT_STATUS_OK; 4291 } 4292 4293 case NDR_SRVSVC_NETFILEENUM: { 4294 struct srvsvc_NetFileEnum *r = (struct srvsvc_NetFileEnum *)_r; 4295 ZERO_STRUCT(r->out); 4296 r->out.info_ctr = r->in.info_ctr; 4297 r->out.resume_handle = r->in.resume_handle; 4298 r->out.totalentries = talloc_zero(mem_ctx, uint32_t); 4299 if (r->out.totalentries == NULL) { 4300 return NT_STATUS_NO_MEMORY; 4301 } 4302 4303 r->out.result = _srvsvc_NetFileEnum(cli->pipes_struct, r); 4304 return NT_STATUS_OK; 4305 } 4306 4307 case NDR_SRVSVC_NETFILEGETINFO: { 4308 struct srvsvc_NetFileGetInfo *r = (struct srvsvc_NetFileGetInfo *)_r; 4309 ZERO_STRUCT(r->out); 4310 r->out.info = talloc_zero(mem_ctx, union srvsvc_NetFileInfo); 4311 if (r->out.info == NULL) { 4312 return NT_STATUS_NO_MEMORY; 4313 } 4314 4315 r->out.result = _srvsvc_NetFileGetInfo(cli->pipes_struct, r); 4316 return NT_STATUS_OK; 4317 } 4318 4319 case NDR_SRVSVC_NETFILECLOSE: { 4320 struct srvsvc_NetFileClose *r = (struct srvsvc_NetFileClose *)_r; 4321 r->out.result = _srvsvc_NetFileClose(cli->pipes_struct, r); 4322 return NT_STATUS_OK; 4323 } 4324 4325 case NDR_SRVSVC_NETSESSENUM: { 4326 struct srvsvc_NetSessEnum *r = (struct srvsvc_NetSessEnum *)_r; 4327 ZERO_STRUCT(r->out); 4328 r->out.info_ctr = r->in.info_ctr; 4329 r->out.resume_handle = r->in.resume_handle; 4330 r->out.totalentries = talloc_zero(mem_ctx, uint32_t); 4331 if (r->out.totalentries == NULL) { 4332 return NT_STATUS_NO_MEMORY; 4333 } 4334 4335 r->out.result = _srvsvc_NetSessEnum(cli->pipes_struct, r); 4336 return NT_STATUS_OK; 4337 } 4338 4339 case NDR_SRVSVC_NETSESSDEL: { 4340 struct srvsvc_NetSessDel *r = (struct srvsvc_NetSessDel *)_r; 4341 r->out.result = _srvsvc_NetSessDel(cli->pipes_struct, r); 4342 return NT_STATUS_OK; 4343 } 4344 4345 case NDR_SRVSVC_NETSHAREADD: { 4346 struct srvsvc_NetShareAdd *r = (struct srvsvc_NetShareAdd *)_r; 4347 ZERO_STRUCT(r->out); 4348 r->out.parm_error = r->in.parm_error; 4349 r->out.result = _srvsvc_NetShareAdd(cli->pipes_struct, r); 4350 return NT_STATUS_OK; 4351 } 4352 4353 case NDR_SRVSVC_NETSHAREENUMALL: { 4354 struct srvsvc_NetShareEnumAll *r = (struct srvsvc_NetShareEnumAll *)_r; 4355 ZERO_STRUCT(r->out); 4356 r->out.info_ctr = r->in.info_ctr; 4357 r->out.resume_handle = r->in.resume_handle; 4358 r->out.totalentries = talloc_zero(mem_ctx, uint32_t); 4359 if (r->out.totalentries == NULL) { 4360 return NT_STATUS_NO_MEMORY; 4361 } 4362 4363 r->out.result = _srvsvc_NetShareEnumAll(cli->pipes_struct, r); 4364 return NT_STATUS_OK; 4365 } 4366 4367 case NDR_SRVSVC_NETSHAREGETINFO: { 4368 struct srvsvc_NetShareGetInfo *r = (struct srvsvc_NetShareGetInfo *)_r; 4369 ZERO_STRUCT(r->out); 4370 r->out.info = talloc_zero(mem_ctx, union srvsvc_NetShareInfo); 4371 if (r->out.info == NULL) { 4372 return NT_STATUS_NO_MEMORY; 4373 } 4374 4375 r->out.result = _srvsvc_NetShareGetInfo(cli->pipes_struct, r); 4376 return NT_STATUS_OK; 4377 } 4378 4379 case NDR_SRVSVC_NETSHARESETINFO: { 4380 struct srvsvc_NetShareSetInfo *r = (struct srvsvc_NetShareSetInfo *)_r; 4381 ZERO_STRUCT(r->out); 4382 r->out.parm_error = r->in.parm_error; 4383 r->out.result = _srvsvc_NetShareSetInfo(cli->pipes_struct, r); 4384 return NT_STATUS_OK; 4385 } 4386 4387 case NDR_SRVSVC_NETSHAREDEL: { 4388 struct srvsvc_NetShareDel *r = (struct srvsvc_NetShareDel *)_r; 4389 r->out.result = _srvsvc_NetShareDel(cli->pipes_struct, r); 4390 return NT_STATUS_OK; 4391 } 4392 4393 case NDR_SRVSVC_NETSHAREDELSTICKY: { 4394 struct srvsvc_NetShareDelSticky *r = (struct srvsvc_NetShareDelSticky *)_r; 4395 r->out.result = _srvsvc_NetShareDelSticky(cli->pipes_struct, r); 4396 return NT_STATUS_OK; 4397 } 4398 4399 case NDR_SRVSVC_NETSHARECHECK: { 4400 struct srvsvc_NetShareCheck *r = (struct srvsvc_NetShareCheck *)_r; 4401 ZERO_STRUCT(r->out); 4402 r->out.type = talloc_zero(mem_ctx, enum srvsvc_ShareType); 4403 if (r->out.type == NULL) { 4404 return NT_STATUS_NO_MEMORY; 4405 } 4406 4407 r->out.result = _srvsvc_NetShareCheck(cli->pipes_struct, r); 4408 return NT_STATUS_OK; 4409 } 4410 4411 case NDR_SRVSVC_NETSRVGETINFO: { 4412 struct srvsvc_NetSrvGetInfo *r = (struct srvsvc_NetSrvGetInfo *)_r; 4413 ZERO_STRUCT(r->out); 4414 r->out.info = talloc_zero(mem_ctx, union srvsvc_NetSrvInfo); 4415 if (r->out.info == NULL) { 4416 return NT_STATUS_NO_MEMORY; 4417 } 4418 4419 r->out.result = _srvsvc_NetSrvGetInfo(cli->pipes_struct, r); 4420 return NT_STATUS_OK; 4421 } 4422 4423 case NDR_SRVSVC_NETSRVSETINFO: { 4424 struct srvsvc_NetSrvSetInfo *r = (struct srvsvc_NetSrvSetInfo *)_r; 4425 ZERO_STRUCT(r->out); 4426 r->out.parm_error = r->in.parm_error; 4427 r->out.result = _srvsvc_NetSrvSetInfo(cli->pipes_struct, r); 4428 return NT_STATUS_OK; 4429 } 4430 4431 case NDR_SRVSVC_NETDISKENUM: { 4432 struct srvsvc_NetDiskEnum *r = (struct srvsvc_NetDiskEnum *)_r; 4433 ZERO_STRUCT(r->out); 4434 r->out.info = r->in.info; 4435 r->out.resume_handle = r->in.resume_handle; 4436 r->out.totalentries = talloc_zero(mem_ctx, uint32_t); 4437 if (r->out.totalentries == NULL) { 4438 return NT_STATUS_NO_MEMORY; 4439 } 4440 4441 r->out.result = _srvsvc_NetDiskEnum(cli->pipes_struct, r); 4442 return NT_STATUS_OK; 4443 } 4444 4445 case NDR_SRVSVC_NETSERVERSTATISTICSGET: { 4446 struct srvsvc_NetServerStatisticsGet *r = (struct srvsvc_NetServerStatisticsGet *)_r; 4447 ZERO_STRUCT(r->out); 4448 r->out.stats = talloc_zero(mem_ctx, struct srvsvc_Statistics *); 4449 if (r->out.stats == NULL) { 4450 return NT_STATUS_NO_MEMORY; 4451 } 4452 4453 r->out.result = _srvsvc_NetServerStatisticsGet(cli->pipes_struct, r); 4454 return NT_STATUS_OK; 4455 } 4456 4457 case NDR_SRVSVC_NETTRANSPORTADD: { 4458 struct srvsvc_NetTransportAdd *r = (struct srvsvc_NetTransportAdd *)_r; 4459 r->out.result = _srvsvc_NetTransportAdd(cli->pipes_struct, r); 4460 return NT_STATUS_OK; 4461 } 4462 4463 case NDR_SRVSVC_NETTRANSPORTENUM: { 4464 struct srvsvc_NetTransportEnum *r = (struct srvsvc_NetTransportEnum *)_r; 4465 ZERO_STRUCT(r->out); 4466 r->out.transports = r->in.transports; 4467 r->out.resume_handle = r->in.resume_handle; 4468 r->out.totalentries = talloc_zero(mem_ctx, uint32_t); 4469 if (r->out.totalentries == NULL) { 4470 return NT_STATUS_NO_MEMORY; 4471 } 4472 4473 r->out.result = _srvsvc_NetTransportEnum(cli->pipes_struct, r); 4474 return NT_STATUS_OK; 4475 } 4476 4477 case NDR_SRVSVC_NETTRANSPORTDEL: { 4478 struct srvsvc_NetTransportDel *r = (struct srvsvc_NetTransportDel *)_r; 4479 r->out.result = _srvsvc_NetTransportDel(cli->pipes_struct, r); 4480 return NT_STATUS_OK; 4481 } 4482 4483 case NDR_SRVSVC_NETREMOTETOD: { 4484 struct srvsvc_NetRemoteTOD *r = (struct srvsvc_NetRemoteTOD *)_r; 4485 ZERO_STRUCT(r->out); 4486 r->out.info = talloc_zero(mem_ctx, struct srvsvc_NetRemoteTODInfo *); 4487 if (r->out.info == NULL) { 4488 return NT_STATUS_NO_MEMORY; 4489 } 4490 4491 r->out.result = _srvsvc_NetRemoteTOD(cli->pipes_struct, r); 4492 return NT_STATUS_OK; 4493 } 4494 4495 case NDR_SRVSVC_NETSETSERVICEBITS: { 4496 struct srvsvc_NetSetServiceBits *r = (struct srvsvc_NetSetServiceBits *)_r; 4497 r->out.result = _srvsvc_NetSetServiceBits(cli->pipes_struct, r); 4498 return NT_STATUS_OK; 4499 } 4500 4501 case NDR_SRVSVC_NETPATHTYPE: { 4502 struct srvsvc_NetPathType *r = (struct srvsvc_NetPathType *)_r; 4503 ZERO_STRUCT(r->out); 4504 r->out.pathtype = talloc_zero(mem_ctx, uint32_t); 4505 if (r->out.pathtype == NULL) { 4506 return NT_STATUS_NO_MEMORY; 4507 } 4508 4509 r->out.result = _srvsvc_NetPathType(cli->pipes_struct, r); 4510 return NT_STATUS_OK; 4511 } 4512 4513 case NDR_SRVSVC_NETPATHCANONICALIZE: { 4514 struct srvsvc_NetPathCanonicalize *r = (struct srvsvc_NetPathCanonicalize *)_r; 4515 ZERO_STRUCT(r->out); 4516 r->out.pathtype = r->in.pathtype; 4517 r->out.can_path = talloc_zero_array(mem_ctx, uint8_t, r->in.maxbuf); 4518 if (r->out.can_path == NULL) { 4519 return NT_STATUS_NO_MEMORY; 4520 } 4521 4522 r->out.result = _srvsvc_NetPathCanonicalize(cli->pipes_struct, r); 4523 return NT_STATUS_OK; 4524 } 4525 4526 case NDR_SRVSVC_NETPATHCOMPARE: { 4527 struct srvsvc_NetPathCompare *r = (struct srvsvc_NetPathCompare *)_r; 4528 r->out.result = _srvsvc_NetPathCompare(cli->pipes_struct, r); 4529 return NT_STATUS_OK; 4530 } 4531 4532 case NDR_SRVSVC_NETNAMEVALIDATE: { 4533 struct srvsvc_NetNameValidate *r = (struct srvsvc_NetNameValidate *)_r; 4534 r->out.result = _srvsvc_NetNameValidate(cli->pipes_struct, r); 4535 return NT_STATUS_OK; 4536 } 4537 4538 case NDR_SRVSVC_NETRPRNAMECANONICALIZE: { 4539 struct srvsvc_NETRPRNAMECANONICALIZE *r = (struct srvsvc_NETRPRNAMECANONICALIZE *)_r; 4540 r->out.result = _srvsvc_NETRPRNAMECANONICALIZE(cli->pipes_struct, r); 4541 return NT_STATUS_OK; 4542 } 4543 4544 case NDR_SRVSVC_NETPRNAMECOMPARE: { 4545 struct srvsvc_NetPRNameCompare *r = (struct srvsvc_NetPRNameCompare *)_r; 4546 r->out.result = _srvsvc_NetPRNameCompare(cli->pipes_struct, r); 4547 return NT_STATUS_OK; 4548 } 4549 4550 case NDR_SRVSVC_NETSHAREENUM: { 4551 struct srvsvc_NetShareEnum *r = (struct srvsvc_NetShareEnum *)_r; 4552 ZERO_STRUCT(r->out); 4553 r->out.info_ctr = r->in.info_ctr; 4554 r->out.resume_handle = r->in.resume_handle; 4555 r->out.totalentries = talloc_zero(mem_ctx, uint32_t); 4556 if (r->out.totalentries == NULL) { 4557 return NT_STATUS_NO_MEMORY; 4558 } 4559 4560 r->out.result = _srvsvc_NetShareEnum(cli->pipes_struct, r); 4561 return NT_STATUS_OK; 4562 } 4563 4564 case NDR_SRVSVC_NETSHAREDELSTART: { 4565 struct srvsvc_NetShareDelStart *r = (struct srvsvc_NetShareDelStart *)_r; 4566 ZERO_STRUCT(r->out); 4567 r->out.hnd = talloc_zero(mem_ctx, struct policy_handle); 4568 if (r->out.hnd == NULL) { 4569 return NT_STATUS_NO_MEMORY; 4570 } 4571 4572 r->out.result = _srvsvc_NetShareDelStart(cli->pipes_struct, r); 4573 return NT_STATUS_OK; 4574 } 4575 4576 case NDR_SRVSVC_NETSHAREDELCOMMIT: { 4577 struct srvsvc_NetShareDelCommit *r = (struct srvsvc_NetShareDelCommit *)_r; 4578 ZERO_STRUCT(r->out); 4579 r->out.hnd = r->in.hnd; 4580 r->out.result = _srvsvc_NetShareDelCommit(cli->pipes_struct, r); 4581 return NT_STATUS_OK; 4582 } 4583 4584 case NDR_SRVSVC_NETGETFILESECURITY: { 4585 struct srvsvc_NetGetFileSecurity *r = (struct srvsvc_NetGetFileSecurity *)_r; 4586 ZERO_STRUCT(r->out); 4587 r->out.sd_buf = talloc_zero(mem_ctx, struct sec_desc_buf *); 4588 if (r->out.sd_buf == NULL) { 4589 return NT_STATUS_NO_MEMORY; 4590 } 4591 4592 r->out.result = _srvsvc_NetGetFileSecurity(cli->pipes_struct, r); 4593 return NT_STATUS_OK; 4594 } 4595 4596 case NDR_SRVSVC_NETSETFILESECURITY: { 4597 struct srvsvc_NetSetFileSecurity *r = (struct srvsvc_NetSetFileSecurity *)_r; 4598 r->out.result = _srvsvc_NetSetFileSecurity(cli->pipes_struct, r); 4599 return NT_STATUS_OK; 4600 } 4601 4602 case NDR_SRVSVC_NETSERVERTRANSPORTADDEX: { 4603 struct srvsvc_NetServerTransportAddEx *r = (struct srvsvc_NetServerTransportAddEx *)_r; 4604 r->out.result = _srvsvc_NetServerTransportAddEx(cli->pipes_struct, r); 4605 return NT_STATUS_OK; 4606 } 4607 4608 case NDR_SRVSVC_NETSERVERSETSERVICEBITSEX: { 4609 struct srvsvc_NetServerSetServiceBitsEx *r = (struct srvsvc_NetServerSetServiceBitsEx *)_r; 4610 r->out.result = _srvsvc_NetServerSetServiceBitsEx(cli->pipes_struct, r); 4611 return NT_STATUS_OK; 4612 } 4613 4614 case NDR_SRVSVC_NETRDFSGETVERSION: { 4615 struct srvsvc_NETRDFSGETVERSION *r = (struct srvsvc_NETRDFSGETVERSION *)_r; 4616 r->out.result = _srvsvc_NETRDFSGETVERSION(cli->pipes_struct, r); 4617 return NT_STATUS_OK; 4618 } 4619 4620 case NDR_SRVSVC_NETRDFSCREATELOCALPARTITION: { 4621 struct srvsvc_NETRDFSCREATELOCALPARTITION *r = (struct srvsvc_NETRDFSCREATELOCALPARTITION *)_r; 4622 r->out.result = _srvsvc_NETRDFSCREATELOCALPARTITION(cli->pipes_struct, r); 4623 return NT_STATUS_OK; 4624 } 4625 4626 case NDR_SRVSVC_NETRDFSDELETELOCALPARTITION: { 4627 struct srvsvc_NETRDFSDELETELOCALPARTITION *r = (struct srvsvc_NETRDFSDELETELOCALPARTITION *)_r; 4628 r->out.result = _srvsvc_NETRDFSDELETELOCALPARTITION(cli->pipes_struct, r); 4629 return NT_STATUS_OK; 4630 } 4631 4632 case NDR_SRVSVC_NETRDFSSETLOCALVOLUMESTATE: { 4633 struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r = (struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *)_r; 4634 r->out.result = _srvsvc_NETRDFSSETLOCALVOLUMESTATE(cli->pipes_struct, r); 4635 return NT_STATUS_OK; 4636 } 4637 4638 case NDR_SRVSVC_NETRDFSSETSERVERINFO: { 4639 struct srvsvc_NETRDFSSETSERVERINFO *r = (struct srvsvc_NETRDFSSETSERVERINFO *)_r; 4640 r->out.result = _srvsvc_NETRDFSSETSERVERINFO(cli->pipes_struct, r); 4641 return NT_STATUS_OK; 4642 } 4643 4644 case NDR_SRVSVC_NETRDFSCREATEEXITPOINT: { 4645 struct srvsvc_NETRDFSCREATEEXITPOINT *r = (struct srvsvc_NETRDFSCREATEEXITPOINT *)_r; 4646 r->out.result = _srvsvc_NETRDFSCREATEEXITPOINT(cli->pipes_struct, r); 4647 return NT_STATUS_OK; 4648 } 4649 4650 case NDR_SRVSVC_NETRDFSDELETEEXITPOINT: { 4651 struct srvsvc_NETRDFSDELETEEXITPOINT *r = (struct srvsvc_NETRDFSDELETEEXITPOINT *)_r; 4652 r->out.result = _srvsvc_NETRDFSDELETEEXITPOINT(cli->pipes_struct, r); 4653 return NT_STATUS_OK; 4654 } 4655 4656 case NDR_SRVSVC_NETRDFSMODIFYPREFIX: { 4657 struct srvsvc_NETRDFSMODIFYPREFIX *r = (struct srvsvc_NETRDFSMODIFYPREFIX *)_r; 4658 r->out.result = _srvsvc_NETRDFSMODIFYPREFIX(cli->pipes_struct, r); 4659 return NT_STATUS_OK; 4660 } 4661 4662 case NDR_SRVSVC_NETRDFSFIXLOCALVOLUME: { 4663 struct srvsvc_NETRDFSFIXLOCALVOLUME *r = (struct srvsvc_NETRDFSFIXLOCALVOLUME *)_r; 4664 r->out.result = _srvsvc_NETRDFSFIXLOCALVOLUME(cli->pipes_struct, r); 4665 return NT_STATUS_OK; 4666 } 4667 4668 case NDR_SRVSVC_NETRDFSMANAGERREPORTSITEINFO: { 4669 struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r = (struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *)_r; 4670 r->out.result = _srvsvc_NETRDFSMANAGERREPORTSITEINFO(cli->pipes_struct, r); 4671 return NT_STATUS_OK; 4672 } 4673 4674 case NDR_SRVSVC_NETRSERVERTRANSPORTDELEX: { 4675 struct srvsvc_NETRSERVERTRANSPORTDELEX *r = (struct srvsvc_NETRSERVERTRANSPORTDELEX *)_r; 4676 r->out.result = _srvsvc_NETRSERVERTRANSPORTDELEX(cli->pipes_struct, r); 4677 return NT_STATUS_OK; 4678 } 4679 4680 default: 4681 return NT_STATUS_NOT_IMPLEMENTED; 4682 } 4683} 4684 4685NTSTATUS rpc_srvsvc_init(void) 4686{ 4687 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "srvsvc", "srvsvc", &ndr_table_srvsvc, api_srvsvc_cmds, sizeof(api_srvsvc_cmds) / sizeof(struct api_struct)); 4688} 4689