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