reactos/dll/win32/kernel32/misc/stubs.c

   1 /*
   2  * KERNEL32.DLL stubs (STUB functions)
   3  * Remove from this file, if you implement them.
   4  */
   5
   6 #include <k32.h>
   7
   8 #define NDEBUG
   9 #include <debug.h>
  10
  11 #define STUB \
  12   SetLastError(ERROR_CALL_NOT_IMPLEMENTED); \
  13   DPRINT1("%s() is UNIMPLEMENTED!\n", __FUNCTION__)
  14
  15 /*
  16  * @unimplemented
  17  */
  18 BOOL
  19 STDCALL
  20 BaseAttachCompleteThunk (VOID)
  21 {
  22     STUB;
  23     return FALSE;
  24 }
  25
  26 /*
  27  * @unimplemented
  28  */
  29 VOID STDCALL
  30 BaseDumpAppcompatCache(VOID)
  31 {
  32     STUB;
  33 }
  34
  35 /*
  36  * @unimplemented
  37  */
  38 VOID STDCALL
  39 BaseFlushAppcompatCache(VOID)
  40 {
  41     STUB;
  42 }
  43
  44 /*
  45  * @unimplemented
  46  */
  47 BOOL
  48 WINAPI
  49 BaseCheckAppcompatCache(ULONG Unknown1,
  50                         ULONG Unknown2,
  51                         ULONG Unknown3,
  52                         PULONG Unknown4)
  53 {
  54     STUB;
  55     if (Unknown4) *Unknown4 = 0;
  56     return TRUE;
  57 }
  58
  59 /*
  60  * @unimplemented
  61  */
  62 VOID STDCALL
  63 BaseUpdateAppcompatCache(ULONG Unknown1, ULONG Unknown2, ULONG Unknown3)
  64 {
  65     STUB;
  66 }
  67
  68 /*
  69  * @unimplemented
  70  */
  71 BOOL
  72 STDCALL
  73 CmdBatNotification (
  74     DWORD   Unknown
  75     )
  76 {
  77     STUB;
  78     return FALSE;
  79 }
  80
  81
  82 /*
  83  * @unimplemented
  84  */
  85 DWORD
  86 STDCALL
  87 CreateVirtualBuffer (
  88     DWORD   Unknown0,
  89     DWORD   Unknown1,
  90     DWORD   Unknown2
  91     )
  92 {
  93     STUB;
  94     return 0;
  95 }
  96
  97
  98 /*
  99  * @unimplemented
 100  */
 101 DWORD
 102 STDCALL
 103 ExitVDM (
 104     DWORD   Unknown0,
 105     DWORD   Unknown1
 106     )
 107 {
 108     STUB;
 109     return 0;
 110 }
 111
 112
 113 /*
 114  * @unimplemented
 115  */
 116 BOOL
 117 STDCALL
 118 ExtendVirtualBuffer (
 119     DWORD   Unknown0,
 120     DWORD   Unknown1
 121     )
 122 {
 123     STUB;
 124     return FALSE;
 125 }
 126
 127
 128 /*
 129  * @unimplemented
 130  */
 131 BOOL
 132 STDCALL
 133 FreeVirtualBuffer (
 134     HANDLE  hVirtualBuffer
 135     )
 136 {
 137     STUB;
 138     return FALSE;
 139 }
 140
 141
 142 /*
 143  * @unimplemented
 144  */
 145 DWORD
 146 STDCALL
 147 GetNextVDMCommand (
 148     DWORD   Unknown0
 149     )
 150 {
 151     STUB;
 152     return 0;
 153 }
 154
 155
 156 /*
 157  * @unimplemented
 158  */
 159 BOOL
 160 STDCALL
 161 GetSystemPowerStatus (
 162     LPSYSTEM_POWER_STATUS PowerStatus
 163     )
 164 {
 165     STUB;
 166     PowerStatus->ACLineStatus = 1;
 167     PowerStatus->BatteryFlag = 128;
 168     PowerStatus->BatteryLifePercent = 255;
 169     PowerStatus->Reserved1 = 0;
 170     PowerStatus->BatteryLifeTime = -1;
 171     PowerStatus->BatteryFullLifeTime = -1;
 172     return TRUE;
 173 }
 174
 175
 176 /*
 177  * @unimplemented
 178  */
 179 DWORD
 180 STDCALL
 181 GetVDMCurrentDirectories (
 182     DWORD   Unknown0,
 183     DWORD   Unknown1
 184     )
 185 {
 186     STUB;
 187     return 0;
 188 }
 189
 190
 191 /*
 192  * @unimplemented
 193  */
 194 BOOL
 195 STDCALL
 196 RegisterConsoleVDM (
 197     DWORD   Unknown0,
 198     DWORD   Unknown1,
 199     DWORD   Unknown2,
 200     DWORD   Unknown3,
 201     DWORD   Unknown4,
 202     DWORD   Unknown5,
 203     DWORD   Unknown6,
 204     DWORD   Unknown7,
 205     DWORD   Unknown8,
 206     DWORD   Unknown9,
 207     DWORD   Unknown10
 208     )
 209 {
 210     STUB;
 211     return FALSE;
 212 }
 213
 214
 215 /*
 216  * @unimplemented
 217  */
 218 BOOL
 219 STDCALL
 220 RegisterWowBaseHandlers (
 221     DWORD   Unknown0
 222     )
 223 {
 224     STUB;
 225     return FALSE;
 226 }
 227
 228
 229 /*
 230  * @unimplemented
 231  */
 232 BOOL
 233 STDCALL
 234 RegisterWowExec (
 235     DWORD   Unknown0
 236     )
 237 {
 238     STUB;
 239     return FALSE;
 240 }
 241
 242
 243 /*
 244  * @unimplemented
 245  */
 246 BOOL STDCALL
 247 SetSystemPowerState (
 248     BOOL fSuspend,
 249     BOOL fForce
 250     )
 251 {
 252     STUB;
 253     return FALSE;
 254 }
 255
 256
 257 /*
 258  * @unimplemented
 259  */
 260 BOOL
 261 STDCALL
 262 SetVDMCurrentDirectories (
 263     DWORD   Unknown0,
 264     DWORD   Unknown1
 265     )
 266 {
 267     STUB;
 268     return FALSE;
 269 }
 270
 271
 272 /*
 273  * @unimplemented
 274  */
 275 DWORD
 276 STDCALL
 277 TrimVirtualBuffer (
 278     DWORD   Unknown0
 279     )
 280 {
 281     STUB;
 282     return 0;
 283 }
 284
 285
 286 /*
 287  * @unimplemented
 288  */
 289 DWORD
 290 STDCALL
 291 VDMConsoleOperation (
 292     DWORD   Unknown0,
 293     DWORD   Unknown1
 294     )
 295 {
 296     STUB;
 297     return 0;
 298 }
 299
 300
 301 /*
 302  * @unimplemented
 303  */
 304 DWORD
 305 STDCALL
 306 VDMOperationStarted (
 307     DWORD   Unknown0
 308     )
 309 {
 310     STUB;
 311     return 0;
 312 }
 313
 314 /*
 315  * @unimplemented
 316  */
 317 DWORD
 318 STDCALL
 319 VirtualBufferExceptionHandler (
 320     DWORD   Unknown0,
 321     DWORD   Unknown1,
 322     DWORD   Unknown2
 323     )
 324 {
 325     STUB;
 326     return 0;
 327 }
 328
 329 /*
 330  * @unimplemented
 331  */
 332 BOOL
 333 STDCALL
 334 AllocateUserPhysicalPages(
 335     HANDLE hProcess,
 336     PULONG_PTR NumberOfPages,
 337     PULONG_PTR UserPfnArray
 338     )
 339 {
 340     STUB;
 341     return 0;
 342 }
 343
 344 /*
 345  * @unimplemented
 346  */
 347 BOOL
 348 STDCALL
 349 BindIoCompletionCallback (
 350     HANDLE FileHandle,
 351     LPOVERLAPPED_COMPLETION_ROUTINE Function,
 352     ULONG Flags
 353     )
 354 {
 355     STUB;
 356     return 0;
 357 }
 358
 359 /*
 360  * @unimplemented
 361  */
 362 BOOL
 363 STDCALL
 364 CancelDeviceWakeupRequest(
 365     HANDLE hDevice
 366     )
 367 {
 368     STUB;
 369     return 0;
 370 }
 371
 372 /*
 373  * @unimplemented
 374  */
 375 BOOL
 376 STDCALL
 377 CreateJobSet (
 378     ULONG NumJob,
 379     PJOB_SET_ARRAY UserJobSet,
 380     ULONG Flags)
 381 {
 382     STUB;
 383     return 0;
 384 }
 385
 386 /*
 387  * @unimplemented
 388  */
 389 BOOL
 390 STDCALL
 391 FindVolumeClose(
 392     HANDLE hFindVolume
 393     )
 394 {
 395     STUB;
 396     return HeapFree( GetProcessHeap(), 0, hFindVolume );
 397 }
 398
 399 /*
 400  * @unimplemented
 401  */
 402 BOOL
 403 STDCALL
 404 FindVolumeMountPointClose(
 405     HANDLE hFindVolumeMountPoint
 406     )
 407 {
 408     STUB;
 409     return HeapFree( GetProcessHeap(), 0, hFindVolumeMountPoint );
 410 }
 411
 412 /*
 413  * @unimplemented
 414  */
 415 BOOL
 416 STDCALL
 417 FreeUserPhysicalPages(
 418     HANDLE hProcess,
 419     PULONG_PTR NumberOfPages,
 420     PULONG_PTR PageArray
 421     )
 422 {
 423     STUB;
 424     return 0;
 425 }
 426
 427 /*
 428  * @unimplemented
 429  */
 430 BOOL
 431 STDCALL
 432 GetDevicePowerState(
 433     HANDLE hDevice,
 434     BOOL *pfOn
 435     )
 436 {
 437     STUB;
 438     return 0;
 439 }
 440
 441
 442 /*
 443  * @unimplemented
 444  */
 445 BOOL
 446 STDCALL
 447 GetNumaHighestNodeNumber(
 448     PULONG HighestNodeNumber
 449     )
 450 {
 451     STUB;
 452     return 0;
 453 }
 454
 455 /*
 456  * @unimplemented
 457  */
 458 BOOL
 459 STDCALL
 460 GetNumaNodeProcessorMask(
 461     UCHAR Node,
 462     PULONGLONG ProcessorMask
 463     )
 464 {
 465     STUB;
 466     return 0;
 467 }
 468
 469 /*
 470  * @unimplemented
 471  */
 472 BOOL
 473 STDCALL
 474 GetNumaProcessorNode(
 475     UCHAR Processor,
 476     PUCHAR NodeNumber
 477     )
 478 {
 479     STUB;
 480     return 0;
 481 }
 482
 483 /*
 484  * @unimplemented
 485  */
 486 UINT
 487 STDCALL
 488 GetWriteWatch(
 489     DWORD  dwFlags,
 490     PVOID  lpBaseAddress,
 491     SIZE_T dwRegionSize,
 492     PVOID *lpAddresses,
 493     PULONG_PTR lpdwCount,
 494     PULONG lpdwGranularity
 495     )
 496 {
 497     STUB;
 498     return 0;
 499 }
 500
 501 /*
 502  * @unimplemented
 503  */
 504 BOOL
 505 STDCALL
 506 HeapQueryInformation (
 507     HANDLE HeapHandle,
 508     HEAP_INFORMATION_CLASS HeapInformationClass,
 509     PVOID HeapInformation OPTIONAL,
 510     SIZE_T HeapInformationLength OPTIONAL,
 511     PSIZE_T ReturnLength OPTIONAL
 512     )
 513 {
 514     STUB;
 515     return 0;
 516 }
 517
 518 /*
 519  * @unimplemented
 520  */
 521 BOOL
 522 STDCALL
 523 HeapSetInformation (
 524     HANDLE HeapHandle,
 525     HEAP_INFORMATION_CLASS HeapInformationClass,
 526     PVOID HeapInformation OPTIONAL,
 527     SIZE_T HeapInformationLength OPTIONAL
 528     )
 529 {
 530     STUB;
 531     return 0;
 532 }
 533
 534 /*
 535  * @unimplemented
 536  */
 537 BOOL
 538 STDCALL
 539 IsSystemResumeAutomatic(
 540     VOID
 541     )
 542 {
 543     STUB;
 544     return 0;
 545 }
 546
 547 /*
 548  * @unimplemented
 549  */
 550 BOOL
 551 STDCALL
 552 IsWow64Process(
 553     HANDLE hProcess,
 554     PBOOL Wow64Process
 555     )
 556 {
 557     STUB;
 558     *Wow64Process = FALSE;
 559     return TRUE;
 560 }
 561
 562 /*
 563  * @unimplemented
 564  */
 565 BOOL
 566 STDCALL
 567 MapUserPhysicalPages(
 568     PVOID VirtualAddress,
 569     ULONG_PTR NumberOfPages,
 570     PULONG_PTR PageArray  OPTIONAL
 571     )
 572 {
 573     STUB;
 574     return 0;
 575 }
 576
 577 /*
 578  * @unimplemented
 579  */
 580 BOOL
 581 STDCALL
 582 MapUserPhysicalPagesScatter(
 583     PVOID *VirtualAddresses,
 584     ULONG_PTR NumberOfPages,
 585     PULONG_PTR PageArray  OPTIONAL
 586     )
 587 {
 588     STUB;
 589     return 0;
 590 }
 591
 592 /*
 593  * @unimplemented
 594  */
 595 BOOL
 596 STDCALL
 597 ReadFileScatter(
 598     HANDLE hFile,
 599     FILE_SEGMENT_ELEMENT aSegmentArray[],
 600     DWORD nNumberOfBytesToRead,
 601     LPDWORD lpReserved,
 602     LPOVERLAPPED lpOverlapped
 603     )
 604 {
 605     PIO_STATUS_BLOCK io_status;
 606     LARGE_INTEGER offset;
 607     NTSTATUS status;
 608
 609     DPRINT("(%p %p %u %p)\n", hFile, aSegmentArray, nNumberOfBytesToRead, lpOverlapped);
 610
 611     offset.u.LowPart    = lpOverlapped->Offset;
 612     offset.u.HighPart   = lpOverlapped->OffsetHigh;
 613     io_status           = (PIO_STATUS_BLOCK)lpOverlapped;
 614     io_status->Status = STATUS_PENDING;
 615     io_status->Information = 0;
 616
 617     status = NtReadFileScatter(hFile,
 618                                NULL,
 619                                NULL,
 620                                NULL,
 621                                io_status,
 622                                aSegmentArray,
 623                                nNumberOfBytesToRead,
 624                                &offset,
 625                                NULL);
 626
 627     if (status) SetLastError(RtlNtStatusToDosError(status));
 628
 629     return !status;
 630 }
 631
 632 /*
 633  * @unimplemented
 634  */
 635 ULONG
 636 STDCALL
 637 RemoveVectoredExceptionHandler(
 638     PVOID VectoredHandlerHandle
 639     )
 640 {
 641     STUB;
 642     return 0;
 643 }
 644
 645 /*
 646  * @unimplemented
 647  */
 648 BOOL
 649 STDCALL
 650 RequestDeviceWakeup(
 651     HANDLE hDevice
 652     )
 653 {
 654     STUB;
 655     return 0;
 656 }
 657
 658 /*
 659  * @unimplemented
 660  */
 661 BOOL
 662 STDCALL
 663 RequestWakeupLatency(
 664     LATENCY_TIME latency
 665     )
 666 {
 667     STUB;
 668     return 0;
 669 }
 670
 671 /*
 672  * @unimplemented
 673  */
 674 UINT
 675 STDCALL
 676 ResetWriteWatch(
 677     LPVOID lpBaseAddress,
 678     SIZE_T dwRegionSize
 679     )
 680 {
 681     STUB;
 682     return 0;
 683 }
 684
 685 /*
 686  * @unimplemented
 687  */
 688 VOID
 689 STDCALL
 690 RestoreLastError(
 691     DWORD dwErrCode
 692     )
 693 {
 694     STUB;
 695 }
 696
 697 /*
 698  * @unimplemented
 699  */
 700 BOOL
 701 STDCALL
 702 SetMessageWaitingIndicator(
 703     HANDLE hMsgIndicator,
 704     ULONG ulMsgCount
 705     )
 706 {
 707     STUB;
 708     return 0;
 709 }
 710
 711 /*
 712  * @unimplemented
 713  */
 714 EXECUTION_STATE
 715 STDCALL
 716 SetThreadExecutionState(
 717     EXECUTION_STATE esFlags
 718     )
 719 {
 720     static EXECUTION_STATE current =
 721         ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED | ES_USER_PRESENT;
 722     EXECUTION_STATE old = current;
 723
 724     DPRINT1("(0x%x): stub, harmless.\n", esFlags);
 725
 726     if (!(current & ES_CONTINUOUS) || (esFlags & ES_CONTINUOUS))
 727         current = esFlags;
 728     return old;
 729 }
 730
 731
 732 /*
 733  * @implemented
 734  */
 735 BOOL
 736 STDCALL
 737 WriteFileGather(
 738     HANDLE hFile,
 739     FILE_SEGMENT_ELEMENT aSegmentArray[],
 740     DWORD nNumberOfBytesToWrite,
 741     LPDWORD lpReserved,
 742     LPOVERLAPPED lpOverlapped
 743     )
 744 {
 745     PIO_STATUS_BLOCK io_status;
 746     LARGE_INTEGER offset;
 747     NTSTATUS Status;
 748
 749     DPRINT("%p %p %u %p\n", hFile, aSegmentArray, nNumberOfBytesToWrite, lpOverlapped);
 750
 751     offset.u.LowPart  = lpOverlapped->Offset;
 752     offset.u.HighPart = lpOverlapped->OffsetHigh;
 753     io_status         = (PIO_STATUS_BLOCK) lpOverlapped;
 754     io_status->Status = STATUS_PENDING;
 755     io_status->Information = 0;
 756
 757     Status = NtWriteFileGather(hFile,
 758                                NULL,
 759                                NULL,
 760                                NULL,
 761                                io_status,
 762                                aSegmentArray,
 763                                nNumberOfBytesToWrite,
 764                                &offset,
 765                                NULL);
 766
 767     if (Status) SetLastError(RtlNtStatusToDosError(Status));
 768
 769     return !Status;
 770 }
 771
 772 /*
 773  * @unimplemented
 774  */
 775 BOOL
 776 STDCALL
 777 DeleteVolumeMountPointW(
 778     LPCWSTR lpszVolumeMountPoint
 779     )
 780 {
 781     STUB;
 782     return 0;
 783 }
 784
 785 /*
 786  * @implemented
 787  */
 788 HANDLE
 789 STDCALL
 790 FindFirstVolumeW(
 791         LPWSTR volume,
 792         DWORD len
 793     )
 794 {
 795     DWORD size = 1024;
 796     HANDLE mgr = CreateFileW( MOUNTMGR_DOS_DEVICE_NAME, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
 797                               NULL, OPEN_EXISTING, 0, 0 );
 798     if (mgr == INVALID_HANDLE_VALUE) return INVALID_HANDLE_VALUE;
 799
 800     for (;;)
 801     {
 802         MOUNTMGR_MOUNT_POINT input;
 803         MOUNTMGR_MOUNT_POINTS *output;
 804
 805         if (!(output = HeapAlloc( GetProcessHeap(), 0, size )))
 806         {
 807             SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 808             break;
 809         }
 810         memset( &input, 0, sizeof(input) );
 811
 812         if (!DeviceIoControl( mgr, IOCTL_MOUNTMGR_QUERY_POINTS, &input, sizeof(input),
 813                               output, size, NULL, NULL ))
 814         {
 815             if (GetLastError() != ERROR_MORE_DATA) break;
 816             size = output->Size;
 817             HeapFree( GetProcessHeap(), 0, output );
 818             continue;
 819         }
 820         CloseHandle( mgr );
 821         /* abuse the Size field to store the current index */
 822         output->Size = 0;
 823         if (!FindNextVolumeW( output, volume, len ))
 824         {
 825             HeapFree( GetProcessHeap(), 0, output );
 826             return INVALID_HANDLE_VALUE;
 827         }
 828         return (HANDLE)output;
 829     }
 830     CloseHandle( mgr );
 831     return INVALID_HANDLE_VALUE;
 832 }
 833
 834 /*
 835  * @unimplemented
 836  */
 837 HANDLE
 838 STDCALL
 839 FindFirstVolumeMountPointW(
 840     LPCWSTR lpszRootPathName,
 841     LPWSTR lpszVolumeMountPoint,
 842     DWORD cchBufferLength
 843     )
 844 {
 845     STUB;
 846     return 0;
 847 }
 848
 849 /*
 850  * @implemented
 851  */
 852 BOOL
 853 STDCALL
 854 FindNextVolumeW(
 855         HANDLE handle,
 856         LPWSTR volume,
 857         DWORD len
 858     )
 859 {
 860     MOUNTMGR_MOUNT_POINTS *data = handle;
 861
 862     while (data->Size < data->NumberOfMountPoints)
 863     {
 864         static const WCHAR volumeW[] = {'\\','?','?','\\','V','o','l','u','m','e','{',};
 865         WCHAR *link = (WCHAR *)((char *)data + data->MountPoints[data->Size].SymbolicLinkNameOffset);
 866         DWORD size = data->MountPoints[data->Size].SymbolicLinkNameLength;
 867         data->Size++;
 868         /* skip non-volumes */
 869         if (size < sizeof(volumeW) || memcmp( link, volumeW, sizeof(volumeW) )) continue;
 870         if (size + sizeof(WCHAR) >= len * sizeof(WCHAR))
 871         {
 872             SetLastError( ERROR_FILENAME_EXCED_RANGE );
 873             return FALSE;
 874         }
 875         memcpy( volume, link, size );
 876         volume[1] = '\\';  /* map \??\ to \\?\ */
 877         volume[size / sizeof(WCHAR)] = '\\';  /* Windows appends a backslash */
 878         volume[size / sizeof(WCHAR) + 1] = 0;
 879         DPRINT( "returning entry %u %s\n", data->Size - 1, volume );
 880         return TRUE;
 881     }
 882     SetLastError( ERROR_NO_MORE_FILES );
 883     return FALSE;
 884 }
 885
 886 /*
 887  * @unimplemented
 888  */
 889 BOOL
 890 STDCALL
 891 FindNextVolumeMountPointW(
 892     HANDLE hFindVolumeMountPoint,
 893     LPWSTR lpszVolumeMountPoint,
 894     DWORD cchBufferLength
 895     )
 896 {
 897     STUB;
 898     return 0;
 899 }
 900
 901 /*
 902  * @unimplemented
 903  */
 904 DWORD
 905 STDCALL
 906 GetFirmwareEnvironmentVariableW(
 907     LPCWSTR lpName,
 908     LPCWSTR lpGuid,
 909     PVOID   pBuffer,
 910     DWORD    nSize
 911     )
 912 {
 913     STUB;
 914     return 0;
 915 }
 916
 917 /*
 918  * @unimplemented
 919  */
 920 BOOL
 921 STDCALL
 922 GetVolumePathNameW(
 923     LPCWSTR lpszFileName,
 924     LPWSTR lpszVolumePathName,
 925     DWORD cchBufferLength
 926     )
 927 {
 928     STUB;
 929     return 0;
 930 }
 931
 932 /*
 933  * @unimplemented
 934  */
 935 BOOL
 936 STDCALL
 937 GetVolumePathNamesForVolumeNameW(
 938     LPCWSTR lpszVolumeName,
 939     LPWSTR lpszVolumePathNames,
 940     DWORD cchBufferLength,
 941     PDWORD lpcchReturnLength
 942     )
 943 {
 944     STUB;
 945     return 0;
 946 }
 947
 948 /*
 949  * @unimplemented
 950  */
 951 BOOL
 952 STDCALL
 953 SetFirmwareEnvironmentVariableW(
 954     LPCWSTR lpName,
 955     LPCWSTR lpGuid,
 956     PVOID    pValue,
 957     DWORD    nSize
 958     )
 959 {
 960     STUB;
 961     return 0;
 962 }
 963
 964 /*
 965  * @unimplemented
 966  */
 967 BOOL
 968 STDCALL
 969 SetVolumeMountPointW(
 970     LPCWSTR lpszVolumeMountPoint,
 971     LPCWSTR lpszVolumeName
 972     )
 973 {
 974     STUB;
 975     return 0;
 976 }
 977
 978 /*
 979  * @unimplemented
 980  */
 981 BOOL
 982 STDCALL
 983 DeleteVolumeMountPointA(
 984     LPCSTR lpszVolumeMountPoint
 985     )
 986 {
 987     STUB;
 988     return 0;
 989 }
 990
 991 /*
 992  * @implemented
 993  */
 994 HANDLE
 995 STDCALL
 996 FindFirstVolumeA(
 997         LPSTR volume,
 998         DWORD len
 999     )
1000 {
1001     WCHAR *buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1002     HANDLE handle = FindFirstVolumeW( buffer, len );
1003
1004     if (handle != INVALID_HANDLE_VALUE)
1005     {
1006         if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, volume, len, NULL, NULL ))
1007         {
1008             FindVolumeClose( handle );
1009             handle = INVALID_HANDLE_VALUE;
1010         }
1011     }
1012     HeapFree( GetProcessHeap(), 0, buffer );
1013     return handle;
1014 }
1015
1016 /*
1017  * @unimplemented
1018  */
1019 HANDLE
1020 STDCALL
1021 FindFirstVolumeMountPointA(
1022     LPCSTR lpszRootPathName,
1023     LPSTR lpszVolumeMountPoint,
1024     DWORD cchBufferLength
1025     )
1026 {
1027     STUB;
1028     return 0;
1029 }
1030
1031 /*
1032  * @unimplemented
1033  */
1034 BOOL
1035 STDCALL
1036 FindNextVolumeA(
1037         HANDLE handle,
1038         LPSTR volume,
1039         DWORD len
1040     )
1041 {
1042     WCHAR *buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1043     BOOL ret;
1044
1045     if ((ret = FindNextVolumeW( handle, buffer, len )))
1046     {
1047         if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, volume, len, NULL, NULL )) ret = FALSE;
1048     }
1049     HeapFree( GetProcessHeap(), 0, buffer );
1050     return ret;
1051 }
1052
1053 /*
1054  * @unimplemented
1055  */
1056 BOOL
1057 STDCALL
1058 FindNextVolumeMountPointA(
1059     HANDLE hFindVolumeMountPoint,
1060     LPSTR lpszVolumeMountPoint,
1061     DWORD cchBufferLength
1062     )
1063 {
1064     STUB;
1065     return 0;
1066 }
1067
1068 /*
1069  * @unimplemented
1070  */
1071 DWORD
1072 STDCALL
1073 GetFirmwareEnvironmentVariableA(
1074     LPCSTR lpName,
1075     LPCSTR lpGuid,
1076     PVOID   pBuffer,
1077     DWORD    nSize
1078     )
1079 {
1080     STUB;
1081     return 0;
1082 }
1083
1084 /*
1085  * @unimplemented
1086  */
1087 BOOL
1088 STDCALL
1089 GetVolumeNameForVolumeMountPointA(
1090     LPCSTR lpszVolumeMountPoint,
1091     LPSTR lpszVolumeName,
1092     DWORD cchBufferLength
1093     )
1094 {
1095     STUB;
1096     return 0;
1097 }
1098
1099 /*
1100  * @unimplemented
1101  */
1102 BOOL
1103 STDCALL
1104 GetVolumePathNameA(
1105     LPCSTR lpszFileName,
1106     LPSTR lpszVolumePathName,
1107     DWORD cchBufferLength
1108     )
1109 {
1110     STUB;
1111     return 0;
1112 }
1113
1114 /*
1115  * @unimplemented
1116  */
1117 BOOL
1118 STDCALL
1119 GetVolumePathNamesForVolumeNameA(
1120     LPCSTR lpszVolumeName,
1121     LPSTR lpszVolumePathNames,
1122     DWORD cchBufferLength,
1123     PDWORD lpcchReturnLength
1124     )
1125 {
1126     STUB;
1127     return 0;
1128 }
1129
1130 /*
1131  * @unimplemented
1132  */
1133 BOOL
1134 STDCALL
1135 SetFirmwareEnvironmentVariableA(
1136     LPCSTR lpName,
1137     LPCSTR lpGuid,
1138     PVOID    pValue,
1139     DWORD    nSize
1140     )
1141 {
1142     STUB;
1143     return 0;
1144 }
1145
1146 /*
1147  * @unimplemented
1148  */
1149 BOOL
1150 STDCALL
1151 SetVolumeMountPointA(
1152     LPCSTR lpszVolumeMountPoint,
1153     LPCSTR lpszVolumeName
1154     )
1155 {
1156     STUB;
1157     return 0;
1158 }
1159
1160 /*
1161  * @unimplemented
1162  */
1163 BOOL STDCALL GetConsoleKeyboardLayoutNameA(LPSTR name)
1164 {
1165     STUB;
1166     return 0;
1167 }
1168
1169 /*
1170  * @unimplemented
1171  */
1172 BOOL STDCALL GetConsoleKeyboardLayoutNameW(LPWSTR name)
1173 {
1174     STUB;
1175     return 0;
1176 }
1177
1178 /*
1179  * @unimplemented
1180  */
1181 DWORD STDCALL GetHandleContext(HANDLE hnd)
1182 {
1183     STUB;
1184     return 0;
1185 }
1186
1187 /*
1188  * @unimplemented
1189  */
1190 HANDLE STDCALL CreateSocketHandle(VOID)
1191 {
1192     STUB;
1193     return 0;
1194 }
1195
1196 /*
1197  * @unimplemented
1198  */
1199 BOOL STDCALL SetHandleContext(HANDLE hnd,DWORD context)
1200 {
1201     STUB;
1202     return 0;
1203 }
1204
1205 /*
1206  * @unimplemented
1207  */
1208 BOOL STDCALL UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
1209                         LPSTR lpszInitName, LPSTR lpszProcName,
1210                         FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
1211                         LPVOID lpBuff )
1212 {
1213     STUB;
1214     return 0;
1215 }
1216
1217 /*
1218  * @unimplemented
1219  */
1220 VOID STDCALL UTUnRegister( HMODULE hModule )
1221 {
1222     STUB;
1223 }
1224
1225 /*
1226  * @unimplemented
1227  */
1228 #if 0
1229 FARPROC STDCALL DelayLoadFailureHook(unsigned int dliNotify, PDelayLoadInfo pdli)
1230 #else
1231 FARPROC STDCALL DelayLoadFailureHook(unsigned int dliNotify, PVOID pdli)
1232 #endif
1233 {
1234     STUB;
1235     return 0;
1236 }
1237
1238 /*
1239  * @unimplemented
1240  */
1241 NTSTATUS STDCALL CreateNlsSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,ULONG Size,ULONG AccessMask)
1242 {
1243     STUB;
1244     return 0;
1245 }
1246
1247 /*
1248  * @unimplemented
1249  */
1250 BOOL STDCALL IsValidUILanguage(LANGID langid)
1251 {
1252     STUB;
1253     return 0;
1254 }
1255
1256 /*
1257  * @unimplemented
1258  */
1259 VOID STDCALL NlsConvertIntegerToString(ULONG Value, ULONG Base, ULONG strsize, LPWSTR str, ULONG strsize2)
1260 {
1261     STUB;
1262 }
1263
1264 /*
1265  * @unimplemented
1266  */
1267 BOOL
1268 STDCALL
1269 SetClientTimeZoneInformation(
1270     CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation)
1271 {
1272     STUB;
1273     return 0;
1274 }
1275
1276 ULONG
1277 WINAPI
1278 NlsGetCacheUpdateCount(VOID)
1279 {
1280     STUB;
1281     return 0;
1282 }
1283
1284 BOOL
1285 STDCALL
1286 Wow64EnableWow64FsRedirection (BOOL Wow64EnableWow64FsRedirection)
1287 {
1288     STUB;
1289     return FALSE;
1290 }
1291
1292 BOOL
1293 STDCALL
1294 Wow64DisableWow64FsRedirection (VOID ** pv)
1295 {
1296     STUB;
1297     return FALSE;
1298 }
1299
1300 BOOL
1301 STDCALL
1302 Wow64RevertWow64FsRedirection (VOID * pv)
1303 {
1304     STUB;
1305     return FALSE;
1306 }