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 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     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 967     return 0;
 968 }
 969
 970 /*
 971  * @unimplemented
 972  */
 973 BOOL
 974 STDCALL
 975 GetVolumePathNamesForVolumeNameW(
 976     LPCWSTR lpszVolumeName,
 977     LPWSTR lpszVolumePathNames,
 978     DWORD cchBufferLength,
 979     PDWORD lpcchReturnLength
 980     )
 981 {
 982     STUB;
 983     return 0;
 984 }
 985
 986 /*
 987  * @unimplemented
 988  */
 989 BOOL
 990 STDCALL
 991 ReplaceFileW(
 992     LPCWSTR lpReplacedFileName,
 993     LPCWSTR lpReplacementFileName,
 994     LPCWSTR lpBackupFileName,
 995     DWORD   dwReplaceFlags,
 996     LPVOID  lpExclude,
 997     LPVOID  lpReserved
 998     )
 999 {
1000     STUB;
1001     return 0;
1002 }
1003
1004 /*
1005  * @unimplemented
1006  */
1007 BOOL
1008 STDCALL
1009 SetFirmwareEnvironmentVariableW(
1010     LPCWSTR lpName,
1011     LPCWSTR lpGuid,
1012     PVOID    pValue,
1013     DWORD    nSize
1014     )
1015 {
1016     STUB;
1017     return 0;
1018 }
1019
1020 /*
1021  * @unimplemented
1022  */
1023 BOOL
1024 STDCALL
1025 SetVolumeMountPointW(
1026     LPCWSTR lpszVolumeMountPoint,
1027     LPCWSTR lpszVolumeName
1028     )
1029 {
1030     STUB;
1031     return 0;
1032 }
1033
1034 /*
1035  * @unimplemented
1036  */
1037 BOOL
1038 STDCALL
1039 DeleteVolumeMountPointA(
1040     LPCSTR lpszVolumeMountPoint
1041     )
1042 {
1043     STUB;
1044     return 0;
1045 }
1046
1047 /*
1048  * @unimplemented
1049  */
1050 BOOL
1051 STDCALL
1052 DnsHostnameToComputerNameA (
1053     LPCSTR Hostname,
1054     LPSTR ComputerName,
1055     LPDWORD nSize
1056     )
1057 {
1058     STUB;
1059     return 0;
1060 }
1061
1062 /*
1063  * @implemented
1064  */
1065 HANDLE
1066 STDCALL
1067 FindFirstVolumeA(
1068         LPSTR volume,
1069         DWORD len
1070     )
1071 {
1072     WCHAR *buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1073     HANDLE handle = FindFirstVolumeW( buffer, len );
1074
1075     if (handle != INVALID_HANDLE_VALUE)
1076     {
1077         if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, volume, len, NULL, NULL ))
1078         {
1079             FindVolumeClose( handle );
1080             handle = INVALID_HANDLE_VALUE;
1081         }
1082     }
1083     HeapFree( GetProcessHeap(), 0, buffer );
1084     return handle;
1085 }
1086
1087 /*
1088  * @unimplemented
1089  */
1090 HANDLE
1091 STDCALL
1092 FindFirstVolumeMountPointA(
1093     LPCSTR lpszRootPathName,
1094     LPSTR lpszVolumeMountPoint,
1095     DWORD cchBufferLength
1096     )
1097 {
1098     STUB;
1099     return 0;
1100 }
1101
1102 /*
1103  * @unimplemented
1104  */
1105 BOOL
1106 STDCALL
1107 FindNextVolumeA(
1108         HANDLE handle,
1109         LPSTR volume,
1110         DWORD len
1111     )
1112 {
1113     WCHAR *buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1114     BOOL ret;
1115
1116     if ((ret = FindNextVolumeW( handle, buffer, len )))
1117     {
1118         if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, volume, len, NULL, NULL )) ret = FALSE;
1119     }
1120     HeapFree( GetProcessHeap(), 0, buffer );
1121     return ret;
1122 }
1123
1124 /*
1125  * @unimplemented
1126  */
1127 BOOL
1128 STDCALL
1129 FindNextVolumeMountPointA(
1130     HANDLE hFindVolumeMountPoint,
1131     LPSTR lpszVolumeMountPoint,
1132     DWORD cchBufferLength
1133     )
1134 {
1135     STUB;
1136     return 0;
1137 }
1138
1139 /*
1140  * @unimplemented
1141  */
1142 DWORD
1143 STDCALL
1144 GetFirmwareEnvironmentVariableA(
1145     LPCSTR lpName,
1146     LPCSTR lpGuid,
1147     PVOID   pBuffer,
1148     DWORD    nSize
1149     )
1150 {
1151     STUB;
1152     return 0;
1153 }
1154
1155 /*
1156  * @unimplemented
1157  */
1158 BOOL
1159 STDCALL
1160 GetVolumeNameForVolumeMountPointA(
1161     LPCSTR lpszVolumeMountPoint,
1162     LPSTR lpszVolumeName,
1163     DWORD cchBufferLength
1164     )
1165 {
1166     STUB;
1167     return 0;
1168 }
1169
1170 /*
1171  * @unimplemented
1172  */
1173 BOOL
1174 STDCALL
1175 GetVolumePathNameA(
1176     LPCSTR lpszFileName,
1177     LPSTR lpszVolumePathName,
1178     DWORD cchBufferLength
1179     )
1180 {
1181     STUB;
1182     return 0;
1183 }
1184
1185 /*
1186  * @unimplemented
1187  */
1188 BOOL
1189 STDCALL
1190 GetVolumePathNamesForVolumeNameA(
1191     LPCSTR lpszVolumeName,
1192     LPSTR lpszVolumePathNames,
1193     DWORD cchBufferLength,
1194     PDWORD lpcchReturnLength
1195     )
1196 {
1197     STUB;
1198     return 0;
1199 }
1200
1201 /*
1202  * @unimplemented
1203  */
1204 BOOL
1205 STDCALL
1206 ReplaceFileA(
1207     LPCSTR  lpReplacedFileName,
1208     LPCSTR  lpReplacementFileName,
1209     LPCSTR  lpBackupFileName,
1210     DWORD   dwReplaceFlags,
1211     LPVOID  lpExclude,
1212     LPVOID  lpReserved
1213     )
1214 {
1215     STUB;
1216     return 0;
1217 }
1218
1219 /*
1220  * @unimplemented
1221  */
1222 BOOL
1223 STDCALL
1224 SetFirmwareEnvironmentVariableA(
1225     LPCSTR lpName,
1226     LPCSTR lpGuid,
1227     PVOID    pValue,
1228     DWORD    nSize
1229     )
1230 {
1231     STUB;
1232     return 0;
1233 }
1234
1235 /*
1236  * @unimplemented
1237  */
1238 BOOL
1239 STDCALL
1240 SetVolumeMountPointA(
1241     LPCSTR lpszVolumeMountPoint,
1242     LPCSTR lpszVolumeName
1243     )
1244 {
1245     STUB;
1246     return 0;
1247 }
1248
1249 /*
1250  * @unimplemented
1251  */
1252 BOOL STDCALL GetConsoleKeyboardLayoutNameA(LPSTR name)
1253 {
1254     STUB;
1255     return 0;
1256 }
1257
1258 /*
1259  * @unimplemented
1260  */
1261 BOOL STDCALL GetConsoleKeyboardLayoutNameW(LPWSTR name)
1262 {
1263     STUB;
1264     return 0;
1265 }
1266
1267 /*
1268  * @unimplemented
1269  */
1270 DWORD STDCALL GetHandleContext(HANDLE hnd)
1271 {
1272     STUB;
1273     return 0;
1274 }
1275
1276 /*
1277  * @unimplemented
1278  */
1279 HANDLE STDCALL CreateSocketHandle(VOID)
1280 {
1281     STUB;
1282     return 0;
1283 }
1284
1285 /*
1286  * @unimplemented
1287  */
1288 BOOL STDCALL SetHandleContext(HANDLE hnd,DWORD context)
1289 {
1290     STUB;
1291     return 0;
1292 }
1293
1294 /*
1295  * @unimplemented
1296  */
1297 BOOL STDCALL UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
1298                         LPSTR lpszInitName, LPSTR lpszProcName,
1299                         FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
1300                         LPVOID lpBuff )
1301 {
1302     STUB;
1303     return 0;
1304 }
1305
1306 /*
1307  * @unimplemented
1308  */
1309 VOID STDCALL UTUnRegister( HMODULE hModule )
1310 {
1311     STUB;
1312 }
1313
1314 /*
1315  * @unimplemented
1316  */
1317 #if 0
1318 FARPROC STDCALL DelayLoadFailureHook(unsigned int dliNotify, PDelayLoadInfo pdli)
1319 #else
1320 FARPROC STDCALL DelayLoadFailureHook(unsigned int dliNotify, PVOID pdli)
1321 #endif
1322 {
1323     STUB;
1324     return 0;
1325 }
1326
1327 /*
1328  * @unimplemented
1329  */
1330 NTSTATUS STDCALL CreateNlsSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,ULONG Size,ULONG AccessMask)
1331 {
1332     STUB;
1333     return 0;
1334 }
1335
1336 /*
1337  * @unimplemented
1338  */
1339 BOOL STDCALL IsValidUILanguage(LANGID langid)
1340 {
1341     STUB;
1342     return 0;
1343 }
1344
1345 /*
1346  * @unimplemented
1347  */
1348 VOID STDCALL NlsConvertIntegerToString(ULONG Value,ULONG Base,ULONG strsize, LPWSTR str, ULONG strsize2)
1349 {
1350     STUB;
1351 }
1352
1353 /*
1354  * @unimplemented
1355  */
1356 UINT STDCALL SetCPGlobal(UINT CodePage)
1357 {
1358     STUB;
1359     return 0;
1360 }
1361
1362 /*
1363  * @unimplemented
1364  */
1365 BOOL
1366 STDCALL
1367 SetClientTimeZoneInformation(
1368     CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation)
1369 {
1370     STUB;
1371     return 0;
1372 }
1373
1374 ULONG
1375 WINAPI
1376 NlsGetCacheUpdateCount(VOID)
1377 {
1378     STUB;
1379     return 0;
1380 }
1381
1382 BOOL
1383 STDCALL
1384 Wow64EnableWow64FsRedirection (BOOL Wow64EnableWow64FsRedirection)
1385 {
1386     STUB;
1387     return FALSE;
1388 }
1389
1390 BOOL
1391 STDCALL
1392 Wow64DisableWow64FsRedirection (VOID ** pv)
1393 {
1394     STUB;
1395     return FALSE;
1396 }
1397
1398 BOOL
1399 STDCALL
1400 Wow64RevertWow64FsRedirection (VOID * pv)
1401 {
1402     STUB;
1403     return FALSE;
1404 }
1405
1406 UINT
1407 WINAPI
1408 EnumSystemFirmwareTables(IN DWORD FirmwareTableProviderSignature,
1409                          OUT PVOID pFirmwareTableBuffer,
1410                          IN DWORD BufferSize)
1411 {
1412     STUB;
1413     return 0;
1414 }
1415
1416 BOOL
1417 WINAPI
1418 GetSystemFileCacheSize(OUT PSIZE_T lpMinimumFileCacheSize,
1419                        OUT PSIZE_T lpMaximumFileCacheSize,
1420                        OUT PDWORD lpFlags)
1421 {
1422     STUB;
1423     return FALSE;
1424 }
1425
1426 UINT
1427 WINAPI
1428 GetSystemFirmwareTable(IN DWORD FirmwareTableProviderSignature,
1429                        IN DWORD FirmwareTableID,
1430                        OUT PVOID pFirmwareTableBuffer,
1431                        IN DWORD BufferSize)
1432 {
1433     STUB;
1434     return 0;
1435 }
1436
1437 BOOL
1438 WINAPI
1439 SetSystemFileCacheSize(IN SIZE_T MinimumFileCacheSize,
1440                        IN SIZE_T MaximumFileCacheSize,
1441                        IN DWORD Flags)
1442 {
1443     STUB;
1444     return FALSE;
1445 }
1446
1447 BOOL
1448 WINAPI
1449 SetThreadStackGuarantee(IN OUT PULONG StackSizeInBytes)
1450 {
1451     STUB;
1452     return FALSE;
1453 }
1454
1455 HANDLE
1456 WINAPI
1457 ReOpenFile(IN HANDLE hOriginalFile,
1458            IN DWORD dwDesiredAccess,
1459            IN DWORD dwShareMode,
1460            IN DWORD dwFlags)
1461 {
1462     STUB;
1463     return INVALID_HANDLE_VALUE;
1464 }
1465
1466 BOOL
1467 WINAPI
1468 SetProcessWorkingSetSizeEx(IN HANDLE hProcess,
1469                            IN SIZE_T dwMinimumWorkingSetSize,
1470                            IN SIZE_T dwMaximumWorkingSetSize,
1471                            IN DWORD Flags)
1472 {
1473     STUB;
1474     return FALSE;
1475 }
1476
1477
1478 BOOL
1479 WINAPI
1480 GetProcessWorkingSetSizeEx(IN HANDLE hProcess,
1481                            OUT PSIZE_T lpMinimumWorkingSetSize,
1482                            OUT PSIZE_T lpMaximumWorkingSetSize,
1483                            OUT PDWORD Flags)
1484 {
1485     STUB;
1486     return FALSE;
1487 }
1488
1489 BOOL
1490 WINAPI
1491 GetLogicalProcessorInformation(OUT PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer,
1492                                IN OUT PDWORD ReturnLength)
1493 {
1494     STUB;
1495     return FALSE;
1496 }
1497
1498 BOOL
1499 WINAPI
1500 GetNumaAvailableMemoryNode(IN UCHAR Node,
1501                            OUT PULONGLONG AvailableBytes)
1502 {
1503     STUB;
1504     return FALSE;
1505 }