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