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 WINAPI
  20 BaseAttachCompleteThunk (VOID)
  21 {
  22     STUB;
  23     return FALSE;
  24 }
  25
  26 /*
  27  * @unimplemented
  28  */
  29 VOID WINAPI
  30 BaseDumpAppcompatCache(VOID)
  31 {
  32     STUB;
  33 }
  34
  35 /*
  36  * @unimplemented
  37  */
  38 VOID WINAPI
  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 WINAPI
  63 BaseUpdateAppcompatCache(ULONG Unknown1, ULONG Unknown2, ULONG Unknown3)
  64 {
  65     STUB;
  66 }
  67
  68 /*
  69  * @unimplemented
  70  */
  71 BOOL
  72 WINAPI
  73 CmdBatNotification (
  74     DWORD   Unknown
  75     )
  76 {
  77     STUB;
  78     return FALSE;
  79 }
  80
  81
  82 /*
  83  * @unimplemented
  84  */
  85 DWORD
  86 WINAPI
  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 WINAPI
 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 WINAPI
 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 WINAPI
 133 FreeVirtualBuffer (
 134     HANDLE  hVirtualBuffer
 135     )
 136 {
 137     STUB;
 138     return FALSE;
 139 }
 140
 141
 142 /*
 143  * @unimplemented
 144  */
 145 DWORD
 146 WINAPI
 147 GetNextVDMCommand (
 148     DWORD   Unknown0
 149     )
 150 {
 151     STUB;
 152     return 0;
 153 }
 154
 155
 156 /*
 157  * @unimplemented
 158  */
 159 DWORD
 160 WINAPI
 161 GetVDMCurrentDirectories (
 162     DWORD   Unknown0,
 163     DWORD   Unknown1
 164     )
 165 {
 166     STUB;
 167     return 0;
 168 }
 169
 170
 171 /*
 172  * @unimplemented
 173  */
 174 BOOL
 175 WINAPI
 176 RegisterConsoleVDM (
 177     DWORD   Unknown0,
 178     DWORD   Unknown1,
 179     DWORD   Unknown2,
 180     DWORD   Unknown3,
 181     DWORD   Unknown4,
 182     DWORD   Unknown5,
 183     DWORD   Unknown6,
 184     DWORD   Unknown7,
 185     DWORD   Unknown8,
 186     DWORD   Unknown9,
 187     DWORD   Unknown10
 188     )
 189 {
 190     STUB;
 191     return FALSE;
 192 }
 193
 194
 195 /*
 196  * @unimplemented
 197  */
 198 BOOL
 199 WINAPI
 200 RegisterWowBaseHandlers (
 201     DWORD   Unknown0
 202     )
 203 {
 204     STUB;
 205     return FALSE;
 206 }
 207
 208
 209 /*
 210  * @unimplemented
 211  */
 212 BOOL
 213 WINAPI
 214 RegisterWowExec (
 215     DWORD   Unknown0
 216     )
 217 {
 218     STUB;
 219     return FALSE;
 220 }
 221
 222
 223 /*
 224  * @unimplemented
 225  */
 226 BOOL
 227 WINAPI
 228 SetVDMCurrentDirectories (
 229     DWORD   Unknown0,
 230     DWORD   Unknown1
 231     )
 232 {
 233     STUB;
 234     return FALSE;
 235 }
 236
 237
 238 /*
 239  * @unimplemented
 240  */
 241 DWORD
 242 WINAPI
 243 TrimVirtualBuffer (
 244     DWORD   Unknown0
 245     )
 246 {
 247     STUB;
 248     return 0;
 249 }
 250
 251
 252 /*
 253  * @unimplemented
 254  */
 255 DWORD
 256 WINAPI
 257 VDMConsoleOperation (
 258     DWORD   Unknown0,
 259     DWORD   Unknown1
 260     )
 261 {
 262     STUB;
 263     return 0;
 264 }
 265
 266
 267 /*
 268  * @unimplemented
 269  */
 270 DWORD
 271 WINAPI
 272 VDMOperationStarted (
 273     DWORD   Unknown0
 274     )
 275 {
 276     STUB;
 277     return 0;
 278 }
 279
 280 /*
 281  * @unimplemented
 282  */
 283 DWORD
 284 WINAPI
 285 VirtualBufferExceptionHandler (
 286     DWORD   Unknown0,
 287     DWORD   Unknown1,
 288     DWORD   Unknown2
 289     )
 290 {
 291     STUB;
 292     return 0;
 293 }
 294
 295 /*
 296  * @implemented
 297  */
 298 BOOL
 299 WINAPI
 300 BindIoCompletionCallback(HANDLE FileHandle,
 301                          LPOVERLAPPED_COMPLETION_ROUTINE Function,
 302                          ULONG Flags)
 303 {
 304     NTSTATUS Status = 0;
 305
 306     DPRINT("(%p, %p, %d)\n", FileHandle, Function, Flags);
 307
 308     Status = RtlSetIoCompletionCallback(FileHandle,
 309                                         (PIO_APC_ROUTINE)Function,
 310                                         Flags);
 311
 312     if (!NT_SUCCESS(Status))
 313     {
 314         SetLastError(RtlNtStatusToDosError(Status));
 315         return FALSE;
 316     }
 317
 318     return TRUE;
 319 }
 320
 321 /*
 322  * @unimplemented
 323  */
 324 BOOL
 325 WINAPI
 326 CreateJobSet (
 327     ULONG NumJob,
 328     PJOB_SET_ARRAY UserJobSet,
 329     ULONG Flags)
 330 {
 331     STUB;
 332     return 0;
 333 }
 334
 335 /*
 336  * @unimplemented
 337  */
 338 BOOL
 339 WINAPI
 340 FindVolumeMountPointClose(
 341     HANDLE hFindVolumeMountPoint
 342     )
 343 {
 344     STUB;
 345     return 0;
 346 }
 347
 348 /*
 349  * @unimplemented
 350  */
 351 BOOL
 352 WINAPI
 353 GetNumaHighestNodeNumber(
 354     PULONG HighestNodeNumber
 355     )
 356 {
 357     STUB;
 358     return 0;
 359 }
 360
 361 /*
 362  * @unimplemented
 363  */
 364 BOOL
 365 WINAPI
 366 GetNumaNodeProcessorMask(
 367     UCHAR Node,
 368     PULONGLONG ProcessorMask
 369     )
 370 {
 371     STUB;
 372     return 0;
 373 }
 374
 375 /*
 376  * @unimplemented
 377  */
 378 BOOL
 379 WINAPI
 380 GetNumaProcessorNode(
 381     UCHAR Processor,
 382     PUCHAR NodeNumber
 383     )
 384 {
 385     STUB;
 386     return 0;
 387 }
 388
 389 /*
 390  * @unimplemented
 391  */
 392 BOOL
 393 WINAPI
 394 HeapQueryInformation (
 395     HANDLE HeapHandle,
 396     HEAP_INFORMATION_CLASS HeapInformationClass,
 397     PVOID HeapInformation OPTIONAL,
 398     SIZE_T HeapInformationLength OPTIONAL,
 399     PSIZE_T ReturnLength OPTIONAL
 400     )
 401 {
 402     STUB;
 403     return 0;
 404 }
 405
 406 /*
 407  * @unimplemented
 408  */
 409 BOOL
 410 WINAPI
 411 HeapSetInformation (
 412     HANDLE HeapHandle,
 413     HEAP_INFORMATION_CLASS HeapInformationClass,
 414     PVOID HeapInformation OPTIONAL,
 415     SIZE_T HeapInformationLength OPTIONAL
 416     )
 417 {
 418     STUB;
 419     return 0;
 420 }
 421
 422 /*
 423  * @implemented
 424  */
 425 BOOL
 426 WINAPI
 427 ReadFileScatter(HANDLE hFile,
 428                 FILE_SEGMENT_ELEMENT aSegmentArray[],
 429                 DWORD nNumberOfBytesToRead,
 430                 LPDWORD lpReserved,
 431                 LPOVERLAPPED lpOverlapped)
 432 {
 433     PIO_STATUS_BLOCK pIOStatus;
 434     LARGE_INTEGER Offset;
 435     NTSTATUS Status;
 436
 437     DPRINT("(%p %p %u %p)\n", hFile, aSegmentArray, nNumberOfBytesToRead, lpOverlapped);
 438
 439     Offset.LowPart  = lpOverlapped->Offset;
 440     Offset.HighPart = lpOverlapped->OffsetHigh;
 441     pIOStatus = (PIO_STATUS_BLOCK) lpOverlapped;
 442     pIOStatus->Status = STATUS_PENDING;
 443     pIOStatus->Information = 0;
 444
 445     Status = NtReadFileScatter(hFile,
 446                                NULL,
 447                                NULL,
 448                                NULL,
 449                                pIOStatus,
 450                                aSegmentArray,
 451                                nNumberOfBytesToRead,
 452                                &Offset,
 453                                NULL);
 454
 455     if (!NT_SUCCESS(Status))
 456     {
 457         SetLastError(RtlNtStatusToDosError(Status));
 458         return FALSE;
 459     }
 460
 461     return TRUE;
 462 }
 463
 464 /*
 465  * @unimplemented
 466  */
 467 ULONG
 468 WINAPI
 469 RemoveVectoredExceptionHandler(
 470     PVOID VectoredHandlerHandle
 471     )
 472 {
 473     STUB;
 474     return 0;
 475 }
 476
 477 /*
 478  * @unimplemented
 479  */
 480 VOID
 481 WINAPI
 482 RestoreLastError(
 483     DWORD dwErrCode
 484     )
 485 {
 486     STUB;
 487 }
 488
 489 /*
 490  * @implemented
 491  */
 492 BOOL
 493 WINAPI
 494 WriteFileGather(HANDLE hFile,
 495                 FILE_SEGMENT_ELEMENT aSegmentArray[],
 496                 DWORD nNumberOfBytesToWrite,
 497                 LPDWORD lpReserved,
 498                 LPOVERLAPPED lpOverlapped)
 499 {
 500     PIO_STATUS_BLOCK IOStatus;
 501     LARGE_INTEGER Offset;
 502     NTSTATUS Status;
 503
 504     DPRINT("%p %p %u %p\n", hFile, aSegmentArray, nNumberOfBytesToWrite, lpOverlapped);
 505
 506     Offset.LowPart = lpOverlapped->Offset;
 507     Offset.HighPart = lpOverlapped->OffsetHigh;
 508     IOStatus = (PIO_STATUS_BLOCK) lpOverlapped;
 509     IOStatus->Status = STATUS_PENDING;
 510     IOStatus->Information = 0;
 511
 512     Status = NtWriteFileGather(hFile,
 513                                NULL,
 514                                NULL,
 515                                NULL,
 516                                IOStatus,
 517                                aSegmentArray,
 518                                nNumberOfBytesToWrite,
 519                                &Offset,
 520                                NULL);
 521
 522     if (!NT_SUCCESS(Status))
 523     {
 524         SetLastError(RtlNtStatusToDosError(Status));
 525         return FALSE;
 526     }
 527
 528     return TRUE;
 529 }
 530
 531 /*
 532  * @unimplemented
 533  */
 534 BOOL
 535 WINAPI
 536 DeleteVolumeMountPointW(
 537     LPCWSTR lpszVolumeMountPoint
 538     )
 539 {
 540     STUB;
 541     return 0;
 542 }
 543
 544 /*
 545  * @unimplemented
 546  */
 547 HANDLE
 548 WINAPI
 549 FindFirstVolumeMountPointW(
 550     LPCWSTR lpszRootPathName,
 551     LPWSTR lpszVolumeMountPoint,
 552     DWORD cchBufferLength
 553     )
 554 {
 555     STUB;
 556     return 0;
 557 }
 558
 559 /*
 560  * @implemented
 561  */
 562 BOOL
 563 WINAPI
 564 FindNextVolumeW(
 565         HANDLE handle,
 566         LPWSTR volume,
 567         DWORD len
 568     )
 569 {
 570     MOUNTMGR_MOUNT_POINTS *data = handle;
 571
 572     while (data->Size < data->NumberOfMountPoints)
 573     {
 574         static const WCHAR volumeW[] = {'\\','?','?','\\','V','o','l','u','m','e','{',};
 575         WCHAR *link = (WCHAR *)((char *)data + data->MountPoints[data->Size].SymbolicLinkNameOffset);
 576         DWORD size = data->MountPoints[data->Size].SymbolicLinkNameLength;
 577         data->Size++;
 578         /* skip non-volumes */
 579         if (size < sizeof(volumeW) || memcmp( link, volumeW, sizeof(volumeW) )) continue;
 580         if (size + sizeof(WCHAR) >= len * sizeof(WCHAR))
 581         {
 582             SetLastError( ERROR_FILENAME_EXCED_RANGE );
 583             return FALSE;
 584         }
 585         memcpy( volume, link, size );
 586         volume[1] = '\\';  /* map \??\ to \\?\ */
 587         volume[size / sizeof(WCHAR)] = '\\';  /* Windows appends a backslash */
 588         volume[size / sizeof(WCHAR) + 1] = 0;
 589         DPRINT( "returning entry %u %s\n", data->Size - 1, volume );
 590         return TRUE;
 591     }
 592     SetLastError( ERROR_NO_MORE_FILES );
 593     return FALSE;
 594 }
 595
 596 /*
 597  * @unimplemented
 598  */
 599 BOOL
 600 WINAPI
 601 FindNextVolumeMountPointW(
 602     HANDLE hFindVolumeMountPoint,
 603     LPWSTR lpszVolumeMountPoint,
 604     DWORD cchBufferLength
 605     )
 606 {
 607     STUB;
 608     return 0;
 609 }
 610
 611 /*
 612  * @unimplemented
 613  */
 614 DWORD
 615 WINAPI
 616 GetFirmwareEnvironmentVariableW(
 617     LPCWSTR lpName,
 618     LPCWSTR lpGuid,
 619     PVOID   pBuffer,
 620     DWORD    nSize
 621     )
 622 {
 623     STUB;
 624     return 0;
 625 }
 626
 627 /*
 628  * @unimplemented
 629  */
 630 BOOL
 631 WINAPI
 632 GetVolumePathNamesForVolumeNameW(
 633     LPCWSTR lpszVolumeName,
 634     LPWSTR lpszVolumePathNames,
 635     DWORD cchBufferLength,
 636     PDWORD lpcchReturnLength
 637     )
 638 {
 639     STUB;
 640     return 0;
 641 }
 642
 643 /*
 644  * @unimplemented
 645  */
 646 BOOL
 647 WINAPI
 648 SetFirmwareEnvironmentVariableW(
 649     LPCWSTR lpName,
 650     LPCWSTR lpGuid,
 651     PVOID    pValue,
 652     DWORD    nSize
 653     )
 654 {
 655     STUB;
 656     return 0;
 657 }
 658
 659 /*
 660  * @unimplemented
 661  */
 662 BOOL
 663 WINAPI
 664 SetVolumeMountPointW(
 665     LPCWSTR lpszVolumeMountPoint,
 666     LPCWSTR lpszVolumeName
 667     )
 668 {
 669     STUB;
 670     return 0;
 671 }
 672
 673 /*
 674  * @unimplemented
 675  */
 676 BOOL
 677 WINAPI
 678 DeleteVolumeMountPointA(
 679     LPCSTR lpszVolumeMountPoint
 680     )
 681 {
 682     STUB;
 683     return 0;
 684 }
 685
 686 /*
 687  * @unimplemented
 688  */
 689 HANDLE
 690 WINAPI
 691 FindFirstVolumeMountPointA(
 692     LPCSTR lpszRootPathName,
 693     LPSTR lpszVolumeMountPoint,
 694     DWORD cchBufferLength
 695     )
 696 {
 697     STUB;
 698     return 0;
 699 }
 700
 701 /*
 702  * @implemented
 703  */
 704 BOOL
 705 WINAPI
 706 FindNextVolumeA(HANDLE handle,
 707                 LPSTR volume,
 708                 DWORD len)
 709 {
 710     WCHAR *buffer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 711     BOOL ret;
 712
 713     if ((ret = FindNextVolumeW( handle, buffer, len )))
 714     {
 715         if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, volume, len, NULL, NULL )) ret = FALSE;
 716     }
 717
 718     HeapFree( GetProcessHeap(), 0, buffer );
 719     return ret;
 720 }
 721
 722 /*
 723  * @unimplemented
 724  */
 725 BOOL
 726 WINAPI
 727 FindNextVolumeMountPointA(
 728     HANDLE hFindVolumeMountPoint,
 729     LPSTR lpszVolumeMountPoint,
 730     DWORD cchBufferLength
 731     )
 732 {
 733     STUB;
 734     return 0;
 735 }
 736
 737 /*
 738  * @unimplemented
 739  */
 740 DWORD
 741 WINAPI
 742 GetFirmwareEnvironmentVariableA(
 743     LPCSTR lpName,
 744     LPCSTR lpGuid,
 745     PVOID   pBuffer,
 746     DWORD    nSize
 747     )
 748 {
 749     STUB;
 750     return 0;
 751 }
 752
 753 /*
 754  * @unimplemented
 755  */
 756 BOOL
 757 WINAPI
 758 GetVolumePathNamesForVolumeNameA(
 759     LPCSTR lpszVolumeName,
 760     LPSTR lpszVolumePathNames,
 761     DWORD cchBufferLength,
 762     PDWORD lpcchReturnLength
 763     )
 764 {
 765     STUB;
 766     return 0;
 767 }
 768
 769 /*
 770  * @unimplemented
 771  */
 772 BOOL
 773 WINAPI
 774 SetFirmwareEnvironmentVariableA(
 775     LPCSTR lpName,
 776     LPCSTR lpGuid,
 777     PVOID    pValue,
 778     DWORD    nSize
 779     )
 780 {
 781     STUB;
 782     return 0;
 783 }
 784
 785 /*
 786  * @unimplemented
 787  */
 788 BOOL
 789 WINAPI
 790 SetVolumeMountPointA(
 791     LPCSTR lpszVolumeMountPoint,
 792     LPCSTR lpszVolumeName
 793     )
 794 {
 795     STUB;
 796     return 0;
 797 }
 798
 799 /*
 800  * @unimplemented
 801  */
 802 BOOL WINAPI GetConsoleKeyboardLayoutNameA(LPSTR name)
 803 {
 804     STUB;
 805     return 0;
 806 }
 807
 808 /*
 809  * @unimplemented
 810  */
 811 BOOL WINAPI GetConsoleKeyboardLayoutNameW(LPWSTR name)
 812 {
 813     STUB;
 814     return 0;
 815 }
 816
 817 /*
 818  * @unimplemented
 819  */
 820 DWORD WINAPI GetHandleContext(HANDLE hnd)
 821 {
 822     STUB;
 823     return 0;
 824 }
 825
 826 /*
 827  * @unimplemented
 828  */
 829 HANDLE WINAPI CreateSocketHandle(VOID)
 830 {
 831     STUB;
 832     return INVALID_HANDLE_VALUE;
 833 }
 834
 835 /*
 836  * @unimplemented
 837  */
 838 BOOL WINAPI SetHandleContext(HANDLE hnd,DWORD context)
 839 {
 840     STUB;
 841     return 0;
 842 }
 843
 844 /*
 845  * @unimplemented
 846  */
 847 BOOL WINAPI UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
 848                         LPSTR lpszInitName, LPSTR lpszProcName,
 849                         FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
 850                         LPVOID lpBuff )
 851 {
 852     STUB;
 853     return 0;
 854 }
 855
 856 /*
 857  * @unimplemented
 858  */
 859 VOID WINAPI UTUnRegister( HMODULE hModule )
 860 {
 861     STUB;
 862 }
 863
 864 /*
 865  * @unimplemented
 866  */
 867 FARPROC WINAPI DelayLoadFailureHook(LPCSTR pszDllName, LPCSTR pszProcName)
 868 {
 869     STUB;
 870     return NULL;
 871 }
 872
 873 /*
 874  * @unimplemented
 875  */
 876 NTSTATUS WINAPI CreateNlsSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,ULONG Size,ULONG AccessMask)
 877 {
 878     STUB;
 879     return 0;
 880 }
 881
 882 /*
 883  * @unimplemented
 884  */
 885 BOOL WINAPI IsValidUILanguage(LANGID langid)
 886 {
 887     STUB;
 888     return 0;
 889 }
 890
 891 /*
 892  * @unimplemented
 893  */
 894 VOID WINAPI NlsConvertIntegerToString(ULONG Value,ULONG Base,ULONG strsize, LPWSTR str, ULONG strsize2)
 895 {
 896     STUB;
 897 }
 898
 899 /*
 900  * @unimplemented
 901  */
 902 UINT WINAPI SetCPGlobal(UINT CodePage)
 903 {
 904     STUB;
 905     return 0;
 906 }
 907
 908 /*
 909  * @unimplemented
 910  */
 911 BOOL
 912 WINAPI
 913 SetClientTimeZoneInformation(
 914     CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation)
 915 {
 916     STUB;
 917     return 0;
 918 }
 919
 920 ULONG
 921 WINAPI
 922 NlsGetCacheUpdateCount(VOID)
 923 {
 924     STUB;
 925     return 0;
 926 }
 927
 928 BOOL
 929 WINAPI
 930 Wow64EnableWow64FsRedirection (BOOL Wow64EnableWow64FsRedirection)
 931 {
 932     STUB;
 933     return FALSE;
 934 }
 935
 936 BOOL
 937 WINAPI
 938 Wow64DisableWow64FsRedirection (VOID ** pv)
 939 {
 940     STUB;
 941     return FALSE;
 942 }
 943
 944 BOOL
 945 WINAPI
 946 Wow64RevertWow64FsRedirection (VOID * pv)
 947 {
 948     STUB;
 949     return FALSE;
 950 }
 951
 952 UINT
 953 WINAPI
 954 EnumSystemFirmwareTables(IN DWORD FirmwareTableProviderSignature,
 955                          OUT PVOID pFirmwareTableBuffer,
 956                          IN DWORD BufferSize)
 957 {
 958     STUB;
 959     return 0;
 960 }
 961
 962 BOOL
 963 WINAPI
 964 GetSystemFileCacheSize(OUT PSIZE_T lpMinimumFileCacheSize,
 965                        OUT PSIZE_T lpMaximumFileCacheSize,
 966                        OUT PDWORD lpFlags)
 967 {
 968     STUB;
 969     return FALSE;
 970 }
 971
 972 UINT
 973 WINAPI
 974 GetSystemFirmwareTable(IN DWORD FirmwareTableProviderSignature,
 975                        IN DWORD FirmwareTableID,
 976                        OUT PVOID pFirmwareTableBuffer,
 977                        IN DWORD BufferSize)
 978 {
 979     STUB;
 980     return 0;
 981 }
 982
 983 BOOL
 984 WINAPI
 985 SetSystemFileCacheSize(IN SIZE_T MinimumFileCacheSize,
 986                        IN SIZE_T MaximumFileCacheSize,
 987                        IN DWORD Flags)
 988 {
 989     STUB;
 990     return FALSE;
 991 }
 992
 993 BOOL
 994 WINAPI
 995 SetThreadStackGuarantee(IN OUT PULONG StackSizeInBytes)
 996 {
 997     STUB;
 998     return FALSE;
 999 }
1000
1001 HANDLE
1002 WINAPI
1003 ReOpenFile(IN HANDLE hOriginalFile,
1004            IN DWORD dwDesiredAccess,
1005            IN DWORD dwShareMode,
1006            IN DWORD dwFlags)
1007 {
1008     STUB;
1009     return INVALID_HANDLE_VALUE;
1010 }
1011
1012 BOOL
1013 WINAPI
1014 SetProcessWorkingSetSizeEx(IN HANDLE hProcess,
1015                            IN SIZE_T dwMinimumWorkingSetSize,
1016                            IN SIZE_T dwMaximumWorkingSetSize,
1017                            IN DWORD Flags)
1018 {
1019     STUB;
1020     return FALSE;
1021 }
1022
1023
1024 BOOL
1025 WINAPI
1026 GetProcessWorkingSetSizeEx(IN HANDLE hProcess,
1027                            OUT PSIZE_T lpMinimumWorkingSetSize,
1028                            OUT PSIZE_T lpMaximumWorkingSetSize,
1029                            OUT PDWORD Flags)
1030 {
1031     STUB;
1032     return FALSE;
1033 }
1034
1035 BOOL
1036 WINAPI
1037 GetLogicalProcessorInformation(OUT PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer,
1038                                IN OUT PDWORD ReturnLength)
1039 {
1040     STUB;
1041     return FALSE;
1042 }
1043
1044 BOOL
1045 WINAPI
1046 GetNumaAvailableMemoryNode(IN UCHAR Node,
1047                            OUT PULONGLONG AvailableBytes)
1048 {
1049     STUB;
1050     return FALSE;
1051 }
1052
1053 BOOL
1054 WINAPI
1055 NlsResetProcessLocale(VOID)
1056 {
1057     STUB;
1058     return TRUE;
1059 }