1 /* 2 * COPYRIGHT: See COPYING in the top level directory 3 * PROJECT: NetAPI DLL 4 * FILE: reactos/dll/win32/netapi32/wksta_new.c 5 * PURPOSE: Workstation service interface code 6 * 7 * PROGRAMMERS: Eric Kohl 8 */ 9 10 /* INCLUDES ******************************************************************/ 11 12 #include "netapi32.h" 13 #include "wkssvc_c.h" 14 15 WINE_DEFAULT_DEBUG_CHANNEL(netapi32); 16 17 /* FUNCTIONS *****************************************************************/ 18 19 void __RPC_FAR * __RPC_USER midl_user_allocate(SIZE_T len) 20 { 21 return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); 22 } 23 24 25 void __RPC_USER midl_user_free(void __RPC_FAR * ptr) 26 { 27 HeapFree(GetProcessHeap(), 0, ptr); 28 } 29 30 31 handle_t __RPC_USER 32 WKSSVC_IDENTIFY_HANDLE_bind(WKSSVC_IDENTIFY_HANDLE pszSystemName) 33 { 34 handle_t hBinding = NULL; 35 LPWSTR pszStringBinding; 36 RPC_STATUS status; 37 38 TRACE("WKSSVC_IDENTIFY_HANDLE_bind() called\n"); 39 40 status = RpcStringBindingComposeW(NULL, 41 L"ncacn_np", 42 pszSystemName, 43 L"\\pipe\\wkssvc", 44 NULL, 45 &pszStringBinding); 46 if (status) 47 { 48 TRACE("RpcStringBindingCompose returned 0x%x\n", status); 49 return NULL; 50 } 51 52 /* Set the binding handle that will be used to bind to the server. */ 53 status = RpcBindingFromStringBindingW(pszStringBinding, 54 &hBinding); 55 if (status) 56 { 57 TRACE("RpcBindingFromStringBinding returned 0x%x\n", status); 58 } 59 60 status = RpcStringFreeW(&pszStringBinding); 61 if (status) 62 { 63 // TRACE("RpcStringFree returned 0x%x\n", status); 64 } 65 66 return hBinding; 67 } 68 69 70 void __RPC_USER 71 WKSSVC_IDENTIFY_HANDLE_unbind(WKSSVC_IDENTIFY_HANDLE pszSystemName, 72 handle_t hBinding) 73 { 74 RPC_STATUS status; 75 76 TRACE("WKSSVC_IDENTIFY_HANDLE_unbind() called\n"); 77 78 status = RpcBindingFree(&hBinding); 79 if (status) 80 { 81 TRACE("RpcBindingFree returned 0x%x\n", status); 82 } 83 } 84 85 86 handle_t __RPC_USER 87 WKSSVC_IMPERSONATE_HANDLE_bind(WKSSVC_IMPERSONATE_HANDLE pszSystemName) 88 { 89 handle_t hBinding = NULL; 90 LPWSTR pszStringBinding; 91 RPC_STATUS status; 92 93 TRACE("WKSSVC_IMPERSONATE_HANDLE_bind() called\n"); 94 95 status = RpcStringBindingComposeW(NULL, 96 L"ncacn_np", 97 pszSystemName, 98 L"\\pipe\\wkssvc", 99 NULL, 100 &pszStringBinding); 101 if (status) 102 { 103 TRACE("RpcStringBindingCompose returned 0x%x\n", status); 104 return NULL; 105 } 106 107 /* Set the binding handle that will be used to bind to the server. */ 108 status = RpcBindingFromStringBindingW(pszStringBinding, 109 &hBinding); 110 if (status) 111 { 112 TRACE("RpcBindingFromStringBinding returned 0x%x\n", status); 113 } 114 115 status = RpcStringFreeW(&pszStringBinding); 116 if (status) 117 { 118 // TRACE("RpcStringFree returned 0x%x\n", status); 119 } 120 121 return hBinding; 122 } 123 124 125 void __RPC_USER 126 WKSSVC_IMPERSONATE_HANDLE_unbind(WKSSVC_IMPERSONATE_HANDLE pszSystemName, 127 handle_t hBinding) 128 { 129 RPC_STATUS status; 130 131 TRACE("WKSSVC_IMPERSONATE_HANDLE_unbind() called\n"); 132 133 status = RpcBindingFree(&hBinding); 134 if (status) 135 { 136 TRACE("RpcBindingFree returned 0x%x\n", status); 137 } 138 } 139 140 141 NET_API_STATUS 142 NetpBind( 143 LPCWSTR pszServerName, 144 handle_t *pBindingHandle) 145 { 146 handle_t hBinding = NULL; 147 LPWSTR pszStringBinding; 148 RPC_STATUS status; 149 150 FIXME("NetpBind(%S)\n", pszServerName); 151 152 *pBindingHandle = NULL; 153 154 status = RpcStringBindingComposeW(NULL, 155 L"ncacn_np", 156 (LPWSTR)pszServerName, 157 L"\\pipe\\wkssvc", 158 NULL, 159 &pszStringBinding); 160 if (status) 161 { 162 FIXME("RpcStringBindingCompose returned 0x%x\n", status); 163 return NetpNtStatusToApiStatus(status); 164 } 165 166 /* Set the binding handle that will be used to bind to the server. */ 167 status = RpcBindingFromStringBindingW(pszStringBinding, 168 &hBinding); 169 if (status) 170 { 171 FIXME("RpcBindingFromStringBinding returned 0x%x\n", status); 172 } 173 174 status = RpcStringFreeW(&pszStringBinding); 175 if (status) 176 { 177 FIXME("RpcStringFree returned 0x%x\n", status); 178 } 179 180 *pBindingHandle = hBinding; 181 182 return NetpNtStatusToApiStatus(status); 183 } 184 185 186 NET_API_STATUS 187 NetpUnbind( 188 handle_t BindingHandle) 189 { 190 RPC_STATUS status; 191 192 FIXME("NetpUnbind(%p)\n", BindingHandle); 193 194 status = RpcBindingFree(&hBinding); 195 if (status) 196 { 197 TRACE("RpcBindingFree returned 0x%x\n", status); 198 return NetpNtStatusToApiStatus(status); 199 } 200 201 return NERR_Success; 202 } 203 204 205 NET_API_STATUS 206 WINAPI 207 NetAddAlternateComputerName( 208 _In_opt_ LPCWSTR Server, 209 _In_ LPCWSTR AlternateName, 210 _In_opt_ LPCWSTR DomainAccount, 211 _In_opt_ LPCWSTR DomainAccountPassword, 212 _In_ ULONG Reserved) 213 { 214 PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL; 215 handle_t BindingHandle = NULL; 216 NET_API_STATUS status; 217 218 TRACE("NetAddAlternateComputerName(%s %s %s %s 0x%lx)\n", 219 debugstr_w(Server), debugstr_w(AlternateName), debugstr_w(DomainAccount), 220 debugstr_w(DomainAccountPassword), Reserved); 221 222 /* FIXME */ 223 224 status = NetpBind(Server, 225 &BindingHandle); 226 if (status != NERR_Success) 227 { 228 ERR("NetpBind() failed (status 0x%lx)\n", status); 229 return status; 230 } 231 232 RpcTryExcept 233 { 234 status = NetrAddAlternateComputerName(BindingHandle, 235 (PWSTR)Server, 236 (PWSTR)AlternateName, 237 (PWSTR)DomainAccount, 238 EncryptedPassword, 239 Reserved); 240 } 241 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 242 { 243 status = I_RpcMapWin32Status(RpcExceptionCode()); 244 } 245 RpcEndExcept; 246 247 NetpUnbind(BindingHandle); 248 249 return status; 250 } 251 252 253 NET_API_STATUS 254 WINAPI 255 NetEnumerateComputerNames( 256 _In_opt_ LPCWSTR Server, 257 _In_ NET_COMPUTER_NAME_TYPE NameType, 258 _In_ ULONG Reserved, 259 _Out_ PDWORD EntryCount, 260 _Out_ LPWSTR **ComputerNames) 261 { 262 PNET_COMPUTER_NAME_ARRAY ComputerNameArray = NULL; 263 ULONG BufferSize, i; 264 PWSTR *NameBuffer = NULL, Ptr; 265 NET_API_STATUS status; 266 267 TRACE("NetEnumerateComputerNames(%s %lu %lu %p %p)\n", 268 debugstr_w(Server), NameType, Reserved, EntryCount, ComputerNames); 269 270 RpcTryExcept 271 { 272 status = NetrEnumerateComputerNames((PWSTR)Server, 273 NameType, 274 Reserved, 275 &ComputerNameArray); 276 if (status == NERR_Success) 277 { 278 *EntryCount = ComputerNameArray->EntryCount; 279 280 BufferSize = 0; 281 for (i = 0; i < ComputerNameArray->EntryCount; i++) 282 { 283 BufferSize += ComputerNameArray->ComputerNames[i].Length + sizeof(WCHAR) + sizeof(PWSTR); 284 } 285 286 status = NetApiBufferAllocate(BufferSize, (PVOID*)&NameBuffer); 287 if (status == NERR_Success) 288 { 289 ZeroMemory(NameBuffer, BufferSize); 290 291 Ptr = (PWSTR)((ULONG_PTR)NameBuffer + ComputerNameArray->EntryCount * sizeof(PWSTR)); 292 for (i = 0; i < ComputerNameArray->EntryCount; i++) 293 { 294 NameBuffer[i] = Ptr; 295 CopyMemory(Ptr, 296 ComputerNameArray->ComputerNames[i].Buffer, 297 ComputerNameArray->ComputerNames[i].Length); 298 Ptr = (PWSTR)((ULONG_PTR)Ptr + ComputerNameArray->ComputerNames[i].Length + sizeof(WCHAR)); 299 } 300 301 *ComputerNames = NameBuffer; 302 } 303 } 304 } 305 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 306 { 307 status = I_RpcMapWin32Status(RpcExceptionCode()); 308 } 309 RpcEndExcept; 310 311 return status; 312 } 313 314 315 NET_API_STATUS 316 WINAPI 317 NetGetJoinInformation( 318 _In_ LPCWSTR lpServer, 319 _Out_ LPWSTR *lpNameBuffer, 320 _Out_ PNETSETUP_JOIN_STATUS BufferType) 321 { 322 NET_API_STATUS status; 323 324 TRACE("NetGetJoinInformation(%s %p %p)\n", 325 debugstr_w(lpServer), lpNameBuffer, BufferType); 326 327 if (lpNameBuffer == NULL || BufferType == NULL) 328 return ERROR_INVALID_PARAMETER; 329 330 RpcTryExcept 331 { 332 status = NetrGetJoinInformation((LPWSTR)lpServer, 333 lpNameBuffer, 334 BufferType); 335 } 336 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 337 { 338 status = I_RpcMapWin32Status(RpcExceptionCode()); 339 } 340 RpcEndExcept; 341 342 return status; 343 } 344 345 346 NET_API_STATUS 347 WINAPI 348 NetGetJoinableOUs( 349 _In_opt_ LPCWSTR lpServer, 350 _In_ LPCWSTR lpDomain, 351 _In_opt_ LPCWSTR lpAccount, 352 _In_opt_ LPCWSTR lpPassword, 353 _Out_ DWORD *OUCount, 354 _Out_ LPWSTR **OUs) 355 { 356 PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL; 357 handle_t BindingHandle = NULL; 358 NET_API_STATUS status; 359 360 TRACE("NetGetJoinableOUs(%s %s %s %s %p %p)\n", 361 debugstr_w(lpServer), debugstr_w(lpDomain), debugstr_w(lpAccount), 362 debugstr_w(lpPassword), OUCount, OUs); 363 364 /* FIXME */ 365 366 status = NetpBind(lpServer, 367 &BindingHandle); 368 if (status != NERR_Success) 369 { 370 ERR("NetpBind() failed (status 0x%lx)\n", status); 371 return status; 372 } 373 374 RpcTryExcept 375 { 376 status = NetrGetJoinableOUs2(BindingHandle, 377 (PWSTR)lpServer, 378 (PWSTR)lpDomain, 379 (PWSTR)lpAccount, 380 EncryptedPassword, 381 OUCount, 382 OUs); 383 } 384 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 385 { 386 status = I_RpcMapWin32Status(RpcExceptionCode()); 387 } 388 RpcEndExcept; 389 390 NetpUnbind(BindingHandle); 391 392 return status; 393 } 394 395 396 NET_API_STATUS 397 WINAPI 398 NetJoinDomain( 399 _In_opt_ LPCWSTR lpServer, 400 _In_ LPCWSTR lpDomain, 401 _In_opt_ LPCWSTR lpAccountOU, 402 _In_opt_ LPCWSTR lpAccount, 403 _In_opt_ LPCWSTR lpPassword, 404 _In_ DWORD fJoinOptions) 405 { 406 PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL; 407 handle_t BindingHandle = NULL; 408 NET_API_STATUS status; 409 410 FIXME("NetJoinDomain(%s %s %s %s 0x%lx)\n", 411 debugstr_w(lpServer), debugstr_w(lpDomain), debugstr_w(lpAccountOU), 412 debugstr_w(lpAccount), debugstr_w(lpPassword), fJoinOptions); 413 414 /* FIXME */ 415 416 status = NetpBind(lpServer, 417 &BindingHandle); 418 if (status != NERR_Success) 419 { 420 ERR("NetpBind() failed (status 0x%lx)\n", status); 421 return status; 422 } 423 424 RpcTryExcept 425 { 426 status = NetrJoinDomain2(BindingHandle, 427 (PWSTR)lpServer, 428 (PWSTR)lpDomain, 429 (PWSTR)lpAccountOU, 430 (PWSTR)lpAccount, 431 EncryptedPassword, 432 fJoinOptions); 433 } 434 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 435 { 436 RPC_STATUS rpcStatus = RpcExceptionCode(); 437 FIXME("Exception 0x%lx\n", rpcStatus); 438 status = I_RpcMapWin32Status(rpcStatus); 439 } 440 RpcEndExcept; 441 442 NetpUnbind(BindingHandle); 443 444 return status; 445 } 446 447 448 NET_API_STATUS 449 WINAPI 450 NetRemoveAlternateComputerName( 451 _In_opt_ LPCWSTR Server, 452 _In_ LPCWSTR AlternateName, 453 _In_opt_ LPCWSTR DomainAccount, 454 _In_opt_ LPCWSTR DomainAccountPassword, 455 _In_ ULONG Reserved) 456 { 457 PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL; 458 handle_t BindingHandle = NULL; 459 NET_API_STATUS status; 460 461 TRACE("NetRemoveAlternateComputerName(%s %s %s %s 0x%lx)\n", 462 debugstr_w(Server), debugstr_w(AlternateName), debugstr_w(DomainAccount), 463 debugstr_w(DomainAccountPassword), Reserved); 464 465 /* FIXME */ 466 467 status = NetpBind(Server, 468 &BindingHandle); 469 if (status != NERR_Success) 470 { 471 ERR("NetpBind() failed (status 0x%lx)\n", status); 472 return status; 473 } 474 475 RpcTryExcept 476 { 477 status = NetrRemoveAlternateComputerName(BindingHandle, 478 (PWSTR)Server, 479 (PWSTR)AlternateName, 480 (PWSTR)DomainAccount, 481 EncryptedPassword, 482 Reserved); 483 } 484 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 485 { 486 status = I_RpcMapWin32Status(RpcExceptionCode()); 487 } 488 RpcEndExcept; 489 490 NetpUnbind(BindingHandle); 491 492 return status; 493 } 494 495 496 NET_API_STATUS 497 WINAPI 498 NetRenameMachineInDomain( 499 _In_opt_ LPCWSTR lpServer, 500 _In_opt_ LPCWSTR lpNewMachineName, 501 _In_opt_ LPCWSTR lpAccount, 502 _In_opt_ LPCWSTR lpPassword, 503 _In_ DWORD fRenameOptions) 504 { 505 PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL; 506 handle_t BindingHandle = NULL; 507 NET_API_STATUS status; 508 509 TRACE("NetRenameMachineInDomain(%s %s %s %s 0x%lx)\n", 510 debugstr_w(lpServer), debugstr_w(lpNewMachineName), debugstr_w(lpAccount), 511 debugstr_w(lpPassword), fRenameOptions); 512 513 /* FIXME */ 514 515 status = NetpBind(lpServer, 516 &BindingHandle); 517 if (status != NERR_Success) 518 { 519 ERR("NetpBind() failed (status 0x%lx)\n", status); 520 return status; 521 } 522 523 RpcTryExcept 524 { 525 status = NetrRenameMachineInDomain2(BindingHandle, 526 (PWSTR)lpServer, 527 (PWSTR)lpNewMachineName, 528 (PWSTR)lpAccount, 529 EncryptedPassword, 530 fRenameOptions); 531 } 532 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 533 { 534 status = I_RpcMapWin32Status(RpcExceptionCode()); 535 } 536 RpcEndExcept; 537 538 NetpUnbind(BindingHandle); 539 540 return status; 541 } 542 543 544 NET_API_STATUS 545 WINAPI 546 NetSetPrimaryComputerName( 547 _In_opt_ LPCWSTR Server, 548 _In_ LPCWSTR PrimaryName, 549 _In_opt_ LPCWSTR DomainAccount, 550 _In_opt_ LPCWSTR DomainAccountPassword, 551 _In_ ULONG Reserved) 552 { 553 PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL; 554 handle_t BindingHandle = NULL; 555 NET_API_STATUS status; 556 557 TRACE("NetSetPrimaryComputerName(%s %s %s %s %lu)\n", 558 debugstr_w(Server), debugstr_w(PrimaryName), debugstr_w(DomainAccount), 559 debugstr_w(DomainAccountPassword), Reserved); 560 561 /* FIXME */ 562 563 status = NetpBind(Server, 564 &BindingHandle); 565 if (status != NERR_Success) 566 { 567 ERR("NetpBind() failed (status 0x%lx)\n", status); 568 return status; 569 } 570 571 RpcTryExcept 572 { 573 status = NetrSetPrimaryComputerName(BindingHandle, 574 (PWSTR)Server, 575 (PWSTR)PrimaryName, 576 (PWSTR)DomainAccount, 577 EncryptedPassword, 578 Reserved); 579 } 580 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 581 { 582 status = I_RpcMapWin32Status(RpcExceptionCode()); 583 } 584 RpcEndExcept; 585 586 NetpUnbind(BindingHandle); 587 588 return status; 589 } 590 591 592 NET_API_STATUS 593 WINAPI 594 NetUnjoinDomain( 595 _In_opt_ LPCWSTR lpServer, 596 _In_opt_ LPCWSTR lpAccount, 597 _In_opt_ LPCWSTR lpPassword, 598 _In_ DWORD fUnjoinOptions) 599 { 600 PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL; 601 handle_t BindingHandle = NULL; 602 NET_API_STATUS status; 603 604 TRACE("NetUnjoinDomain(%s %s %s %s 0x%lx)\n", 605 debugstr_w(lpServer), debugstr_w(lpAccount), 606 debugstr_w(lpPassword), fUnjoinOptions); 607 608 /* FIXME */ 609 610 status = NetpBind(lpServer, 611 &BindingHandle); 612 if (status != NERR_Success) 613 { 614 ERR("NetpBind() failed (status 0x%lx)\n", status); 615 return status; 616 } 617 618 RpcTryExcept 619 { 620 status = NetrUnjoinDomain2(BindingHandle, 621 (PWSTR)lpServer, 622 (PWSTR)lpAccount, 623 EncryptedPassword, 624 fUnjoinOptions); 625 } 626 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 627 { 628 status = I_RpcMapWin32Status(RpcExceptionCode()); 629 } 630 RpcEndExcept; 631 632 NetpUnbind(BindingHandle); 633 634 return status; 635 } 636 637 638 NET_API_STATUS 639 WINAPI 640 NetUseAdd( 641 _In_ LMSTR UncServerName, 642 _In_ DWORD Level, 643 _In_ LPBYTE Buf, 644 _Out_ LPDWORD ParmError) 645 { 646 NET_API_STATUS status; 647 648 TRACE("NetUseAdd(%s %d %p %p)\n", debugstr_w(UncServerName), 649 Level, Buf, ParmError); 650 651 RpcTryExcept 652 { 653 status = NetrUseAdd(UncServerName, 654 Level, 655 (LPUSE_INFO)Buf, 656 ParmError); 657 } 658 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 659 { 660 status = I_RpcMapWin32Status(RpcExceptionCode()); 661 } 662 RpcEndExcept; 663 664 return status; 665 } 666 667 668 NET_API_STATUS 669 WINAPI 670 NetUseDel( 671 _In_ LMSTR UncServerName, 672 _In_ LMSTR UseName, 673 _In_ DWORD ForceCond) 674 { 675 NET_API_STATUS status; 676 677 TRACE("NetUseDel(%s %s %d)\n", debugstr_w(UncServerName), 678 debugstr_w(UseName), ForceCond); 679 680 RpcTryExcept 681 { 682 status = NetrUseDel(UncServerName, 683 UseName, 684 ForceCond); 685 } 686 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 687 { 688 status = I_RpcMapWin32Status(RpcExceptionCode()); 689 } 690 RpcEndExcept; 691 692 return status; 693 } 694 695 696 NET_API_STATUS 697 WINAPI 698 NetUseEnum( 699 _In_ LMSTR UncServerName, 700 _In_ DWORD Level, 701 _Out_ LPBYTE *BufPtr, 702 _In_ DWORD PreferedMaximumSize, 703 _Out_ LPDWORD EntriesRead, 704 _Out_ LPDWORD TotalEntries, 705 _Inout_ LPDWORD ResumeHandle) 706 { 707 USE_ENUM_STRUCT UseEnumInfo; 708 USE_INFO_0_CONTAINER Container0; 709 USE_INFO_1_CONTAINER Container1; 710 USE_INFO_2_CONTAINER Container2; 711 NET_API_STATUS status; 712 713 TRACE("NetUseEnum(%s, %d, %p, %d, %p, %p, %p)\n", debugstr_w(UncServerName), 714 Level, BufPtr, PreferedMaximumSize, EntriesRead, TotalEntries, ResumeHandle); 715 716 UseEnumInfo.Level = Level; 717 switch (Level) 718 { 719 case 0: 720 UseEnumInfo.UseInfo.Level0 = &Container0; 721 Container0.EntriesRead = 0; 722 Container0.Buffer = NULL; 723 break; 724 725 case 1: 726 UseEnumInfo.UseInfo.Level1 = &Container1; 727 Container1.EntriesRead = 0; 728 Container1.Buffer = NULL; 729 break; 730 731 case 2: 732 UseEnumInfo.UseInfo.Level2 = &Container2; 733 Container2.EntriesRead = 0; 734 Container2.Buffer = NULL; 735 break; 736 737 default: 738 return ERROR_INVALID_PARAMETER; 739 } 740 741 RpcTryExcept 742 { 743 status = NetrUseEnum(UncServerName, 744 &UseEnumInfo, 745 PreferedMaximumSize, 746 TotalEntries, 747 ResumeHandle); 748 if (status == NERR_Success || status == ERROR_MORE_DATA) 749 { 750 switch (Level) 751 { 752 case 0: 753 *BufPtr = (LPBYTE)UseEnumInfo.UseInfo.Level0->Buffer; 754 *EntriesRead = UseEnumInfo.UseInfo.Level0->EntriesRead; 755 break; 756 757 case 1: 758 *BufPtr = (LPBYTE)UseEnumInfo.UseInfo.Level1->Buffer; 759 *EntriesRead = UseEnumInfo.UseInfo.Level1->EntriesRead; 760 break; 761 762 case 2: 763 *BufPtr = (LPBYTE)UseEnumInfo.UseInfo.Level2->Buffer; 764 *EntriesRead = UseEnumInfo.UseInfo.Level2->EntriesRead; 765 break; 766 } 767 } 768 } 769 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 770 { 771 status = I_RpcMapWin32Status(RpcExceptionCode()); 772 } 773 RpcEndExcept; 774 775 return status; 776 } 777 778 779 NET_API_STATUS 780 WINAPI 781 NetUseGetInfo( 782 _In_ LMSTR UncServerName, 783 _In_ LMSTR UseName, 784 _In_ DWORD Level, 785 _Out_ LPBYTE *BufPtr) 786 { 787 NET_API_STATUS status; 788 789 TRACE("NetUseGetInfo(%s, %s, %d, %p)\n", debugstr_w(UncServerName), 790 debugstr_w(UseName), Level, BufPtr); 791 792 *BufPtr = NULL; 793 794 RpcTryExcept 795 { 796 status = NetrUseGetInfo(UncServerName, 797 UseName, 798 Level, 799 (LPUSE_INFO)BufPtr); 800 } 801 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 802 { 803 status = I_RpcMapWin32Status(RpcExceptionCode()); 804 } 805 RpcEndExcept; 806 807 return status; 808 } 809 810 811 NET_API_STATUS 812 WINAPI 813 NetValidateName( 814 _In_opt_ LPCWSTR lpServer, 815 _In_ LPCWSTR lpName, 816 _In_opt_ LPCWSTR lpAccount, 817 _In_opt_ LPCWSTR lpPassword, 818 _In_ NETSETUP_NAME_TYPE NameType) 819 { 820 PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL; 821 handle_t BindingHandle = NULL; 822 NET_API_STATUS status; 823 824 TRACE("NetValidateName(%s %s %s %s %u)\n", 825 debugstr_w(lpServer), debugstr_w(lpName), debugstr_w(lpAccount), 826 debugstr_w(lpPassword), NameType); 827 828 /* FIXME */ 829 830 status = NetpBind(lpServer, 831 &BindingHandle); 832 if (status != NERR_Success) 833 { 834 ERR("NetpBind() failed (status 0x%lx)\n", status); 835 return status; 836 } 837 838 RpcTryExcept 839 { 840 status = NetrValidateName2(BindingHandle, 841 (PWSTR)lpServer, 842 (PWSTR)lpName, 843 (PWSTR)lpAccount, 844 EncryptedPassword, 845 NameType); 846 } 847 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 848 { 849 status = I_RpcMapWin32Status(RpcExceptionCode()); 850 } 851 RpcEndExcept; 852 853 NetpUnbind(BindingHandle); 854 855 return status; 856 } 857 858 859 #if 0 860 NET_API_STATUS 861 WINAPI 862 NetWkstaGetInfo( 863 _In_ LPWSTR servername, 864 _In_ DWORD level, 865 _Out_ LPBYTE *bufptr) 866 { 867 NET_API_STATUS status; 868 869 TRACE("NetWkstaGetInfo(%s, %d, %p)\n", 870 debugstr_w(servername), level, bufptr); 871 872 if (bufptr == NULL) 873 return ERROR_INVALID_PARAMETER; 874 875 *bufptr = NULL; 876 877 RpcTryExcept 878 { 879 status = NetrWkstaGetInfo(servername, 880 level, 881 (LPWKSTA_INFO)bufptr); 882 } 883 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 884 { 885 status = I_RpcMapWin32Status(RpcExceptionCode()); 886 } 887 RpcEndExcept; 888 889 return status; 890 } 891 #endif 892 893 894 NET_API_STATUS 895 WINAPI 896 NetWkstaSetInfo( 897 _In_ LPWSTR servername, 898 _In_ DWORD level, 899 _In_ LPBYTE buffer, 900 _Out_ LPDWORD parm_err) 901 { 902 NET_API_STATUS status; 903 904 TRACE("NetWkstaSetInfo(%s, %d, %p, %p)\n", 905 debugstr_w(servername), level, buffer, parm_err); 906 907 RpcTryExcept 908 { 909 status = NetrWkstaSetInfo(servername, 910 level, 911 (LPWKSTA_INFO)buffer, 912 parm_err); 913 } 914 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 915 { 916 status = I_RpcMapWin32Status(RpcExceptionCode()); 917 } 918 RpcEndExcept; 919 920 return status; 921 } 922 923 924 NET_API_STATUS 925 WINAPI 926 NetWkstaTransportAdd( 927 _In_opt_ LPWSTR servername, 928 _In_ DWORD level, 929 _In_ LPBYTE buf, 930 _Out_ LPDWORD parm_err) 931 { 932 NET_API_STATUS status; 933 934 TRACE("NetWkstaTransportAdd(%s, %d, %p, %p)\n", debugstr_w(servername), 935 level, buf, parm_err); 936 937 RpcTryExcept 938 { 939 status = NetrWkstaTransportAdd(servername, 940 level, 941 (LPWKSTA_TRANSPORT_INFO_0)buf, 942 parm_err); 943 } 944 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 945 { 946 status = I_RpcMapWin32Status(RpcExceptionCode()); 947 } 948 RpcEndExcept; 949 950 return status; 951 } 952 953 954 NET_API_STATUS 955 WINAPI 956 NetWkstaTransportDel( 957 _In_opt_ LPWSTR servername, 958 _In_ LPWSTR transportname, 959 _In_ DWORD ucond) 960 { 961 NET_API_STATUS status; 962 963 TRACE("NetWkstaTransportDel(%s, %s, %d)\n", debugstr_w(servername), 964 debugstr_w(transportname), ucond); 965 966 RpcTryExcept 967 { 968 status = NetrWkstaTransportDel(servername, 969 transportname, 970 ucond); 971 } 972 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 973 { 974 status = I_RpcMapWin32Status(RpcExceptionCode()); 975 } 976 RpcEndExcept; 977 978 return status; 979 } 980 981 982 #if 0 983 NET_API_STATUS 984 WINAPI 985 NetWkstaTransportEnum( 986 _In_opt_ LPWSTR servername, 987 _In_ DWORD level, 988 _Out_ LPBYTE *bufptr, 989 _In_ DWORD prefmaxlen, 990 _Out_ LPDWORD entriesread, 991 _Out_ LPDWORD totalentries, 992 _Inout_ LPDWORD resumehandle) 993 { 994 WKSTA_TRANSPORT_ENUM_STRUCT TransportEnumInfo; 995 WKSTA_TRANSPORT_INFO_0_CONTAINER Container0; 996 NET_API_STATUS status; 997 998 TRACE("NetWkstaTransportEnum(%s, %d, %p, %d, %p, %p, %p)\n", debugstr_w(servername), 999 level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle); 1000 1001 TransportEnumInfo.Level = level; 1002 switch (level) 1003 { 1004 case 0: 1005 TransportEnumInfo.WkstaTransportInfo.Level0 = &Container0; 1006 Container0.EntriesRead = 0; 1007 Container0.Buffer = NULL; 1008 break; 1009 1010 default: 1011 return ERROR_INVALID_PARAMETER; 1012 } 1013 1014 RpcTryExcept 1015 { 1016 status = NetrWkstaTransportEnum(servername, 1017 &TransportEnumInfo, 1018 prefmaxlen, 1019 totalentries, 1020 resumehandle); 1021 if (status == NERR_Success || status == ERROR_MORE_DATA) 1022 { 1023 switch (level) 1024 { 1025 case 0: 1026 *bufptr = (LPBYTE)TransportEnumInfo.WkstaTransportInfo.Level0->Buffer; 1027 *entriesread = TransportEnumInfo.WkstaTransportInfo.Level0->EntriesRead; 1028 break; 1029 } 1030 } 1031 } 1032 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 1033 { 1034 status = I_RpcMapWin32Status(RpcExceptionCode()); 1035 } 1036 RpcEndExcept; 1037 1038 return status; 1039 } 1040 1041 1042 NET_API_STATUS 1043 WINAPI 1044 NetWkstaUserEnum( 1045 _In_ LPWSTR servername, 1046 _In_ DWORD level, 1047 _Out_ LPBYTE *bufptr, 1048 _In_ DWORD prefmaxlen, 1049 _Out_ LPDWORD entriesread, 1050 _Out_ LPDWORD totalentries, 1051 _Inout_ LPDWORD resumehandle) 1052 { 1053 WKSTA_USER_ENUM_STRUCT UserEnumInfo; 1054 WKSTA_USER_INFO_0_CONTAINER Container0; 1055 WKSTA_USER_INFO_1_CONTAINER Container1; 1056 NET_API_STATUS status; 1057 1058 TRACE("NetWkstaUserEnum(%s, %d, %p, %d, %p, %p, %p)\n", debugstr_w(servername), 1059 level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle); 1060 1061 UserEnumInfo.Level = level; 1062 switch (level) 1063 { 1064 case 0: 1065 UserEnumInfo.WkstaUserInfo.Level0 = &Container0; 1066 Container0.EntriesRead = 0; 1067 Container0.Buffer = NULL; 1068 break; 1069 1070 case 1: 1071 UserEnumInfo.WkstaUserInfo.Level1 = &Container1; 1072 Container1.EntriesRead = 0; 1073 Container1.Buffer = NULL; 1074 break; 1075 1076 default: 1077 return ERROR_INVALID_PARAMETER; 1078 } 1079 1080 RpcTryExcept 1081 { 1082 status = NetrWkstaUserEnum(servername, 1083 &UserEnumInfo, 1084 prefmaxlen, 1085 totalentries, 1086 resumehandle); 1087 if (status == NERR_Success || status == ERROR_MORE_DATA) 1088 { 1089 switch (level) 1090 { 1091 case 0: 1092 *bufptr = (LPBYTE)UserEnumInfo.WkstaUserInfo.Level0->Buffer; 1093 *entriesread = UserEnumInfo.WkstaUserInfo.Level0->EntriesRead; 1094 break; 1095 1096 case 1: 1097 *bufptr = (LPBYTE)UserEnumInfo.WkstaUserInfo.Level1->Buffer; 1098 *entriesread = UserEnumInfo.WkstaUserInfo.Level1->EntriesRead; 1099 break; 1100 } 1101 } 1102 } 1103 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 1104 { 1105 status = I_RpcMapWin32Status(RpcExceptionCode()); 1106 } 1107 RpcEndExcept; 1108 1109 return status; 1110 } 1111 1112 1113 NET_API_STATUS 1114 WINAPI 1115 NetWkstaUserGetInfo( 1116 LPWSTR reserved, 1117 _In_ DWORD level, 1118 _Out_ PBYTE *bufptr) 1119 { 1120 NET_API_STATUS status; 1121 1122 TRACE("NetWkstaUserGetInfo(%s, %d, %p)\n", 1123 debugstr_w(reserved), level, bufptr); 1124 1125 if (reserved != NULL) 1126 return ERROR_INVALID_PARAMETER; 1127 1128 *bufptr = NULL; 1129 1130 RpcTryExcept 1131 { 1132 status = NetrWkstaUserGetInfo(NULL, 1133 level, 1134 (LPWKSTA_USER_INFO)bufptr); 1135 } 1136 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 1137 { 1138 status = I_RpcMapWin32Status(RpcExceptionCode()); 1139 } 1140 RpcEndExcept; 1141 1142 return status; 1143 } 1144 #endif 1145 1146 1147 NET_API_STATUS 1148 WINAPI 1149 NetWkstaUserSetInfo( 1150 LPWSTR reserved, 1151 _In_ DWORD level, 1152 _In_ LPBYTE buf, 1153 _Out_ LPDWORD parm_err) 1154 { 1155 NET_API_STATUS status; 1156 1157 TRACE("NetWkstaSetInfo(%s, %d, %p, %p)\n", 1158 debugstr_w(reserved), level, buf, parm_err); 1159 1160 if (reserved != NULL) 1161 return ERROR_INVALID_PARAMETER; 1162 1163 RpcTryExcept 1164 { 1165 status = NetrWkstaUserSetInfo(NULL, 1166 level, 1167 (LPWKSTA_USER_INFO)&buf, 1168 parm_err); 1169 } 1170 RpcExcept(EXCEPTION_EXECUTE_HANDLER) 1171 { 1172 status = I_RpcMapWin32Status(RpcExceptionCode()); 1173 } 1174 RpcEndExcept; 1175 1176 return status; 1177 } 1178 1179 /* EOF */ 1180