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  * @implemented
 391  */
 392 BOOL
 393 WINAPI
 394 ReadFileScatter(HANDLE hFile,
 395                 FILE_SEGMENT_ELEMENT aSegmentArray[],
 396                 DWORD nNumberOfBytesToRead,
 397                 LPDWORD lpReserved,
 398                 LPOVERLAPPED lpOverlapped)
 399 {
 400     PIO_STATUS_BLOCK pIOStatus;
 401     LARGE_INTEGER Offset;
 402     NTSTATUS Status;
 403
 404     DPRINT("(%p %p %u %p)\n", hFile, aSegmentArray, nNumberOfBytesToRead, lpOverlapped);
 405
 406     Offset.LowPart  = lpOverlapped->Offset;
 407     Offset.HighPart = lpOverlapped->OffsetHigh;
 408     pIOStatus = (PIO_STATUS_BLOCK) lpOverlapped;
 409     pIOStatus->Status = STATUS_PENDING;
 410     pIOStatus->Information = 0;
 411
 412     Status = NtReadFileScatter(hFile,
 413                                NULL,
 414                                NULL,
 415                                NULL,
 416                                pIOStatus,
 417                                aSegmentArray,
 418                                nNumberOfBytesToRead,
 419                                &Offset,
 420                                NULL);
 421
 422     if (!NT_SUCCESS(Status))
 423     {
 424         SetLastError(RtlNtStatusToDosError(Status));
 425         return FALSE;
 426     }
 427
 428     return TRUE;
 429 }
 430
 431 /*
 432  * @unimplemented
 433  */
 434 VOID
 435 WINAPI
 436 RestoreLastError(
 437     DWORD dwErrCode
 438     )
 439 {
 440     STUB;
 441 }
 442
 443 /*
 444  * @implemented
 445  */
 446 BOOL
 447 WINAPI
 448 WriteFileGather(HANDLE hFile,
 449                 FILE_SEGMENT_ELEMENT aSegmentArray[],
 450                 DWORD nNumberOfBytesToWrite,
 451                 LPDWORD lpReserved,
 452                 LPOVERLAPPED lpOverlapped)
 453 {
 454     PIO_STATUS_BLOCK IOStatus;
 455     LARGE_INTEGER Offset;
 456     NTSTATUS Status;
 457
 458     DPRINT("%p %p %u %p\n", hFile, aSegmentArray, nNumberOfBytesToWrite, lpOverlapped);
 459
 460     Offset.LowPart = lpOverlapped->Offset;
 461     Offset.HighPart = lpOverlapped->OffsetHigh;
 462     IOStatus = (PIO_STATUS_BLOCK) lpOverlapped;
 463     IOStatus->Status = STATUS_PENDING;
 464     IOStatus->Information = 0;
 465
 466     Status = NtWriteFileGather(hFile,
 467                                NULL,
 468                                NULL,
 469                                NULL,
 470                                IOStatus,
 471                                aSegmentArray,
 472                                nNumberOfBytesToWrite,
 473                                &Offset,
 474                                NULL);
 475
 476     if (!NT_SUCCESS(Status))
 477     {
 478         SetLastError(RtlNtStatusToDosError(Status));
 479         return FALSE;
 480     }
 481
 482     return TRUE;
 483 }
 484
 485 /*
 486  * @unimplemented
 487  */
 488 BOOL
 489 WINAPI
 490 DeleteVolumeMountPointW(
 491     LPCWSTR lpszVolumeMountPoint
 492     )
 493 {
 494     STUB;
 495     return 0;
 496 }
 497
 498 /*
 499  * @unimplemented
 500  */
 501 HANDLE
 502 WINAPI
 503 FindFirstVolumeMountPointW(
 504     LPCWSTR lpszRootPathName,
 505     LPWSTR lpszVolumeMountPoint,
 506     DWORD cchBufferLength
 507     )
 508 {
 509     STUB;
 510     return 0;
 511 }
 512
 513 /*
 514  * @implemented
 515  */
 516 BOOL
 517 WINAPI
 518 FindNextVolumeW(
 519         HANDLE handle,
 520         LPWSTR volume,
 521         DWORD len
 522     )
 523 {
 524     MOUNTMGR_MOUNT_POINTS *data = handle;
 525
 526     while (data->Size < data->NumberOfMountPoints)
 527     {
 528         static const WCHAR volumeW[] = {'\\','?','?','\\','V','o','l','u','m','e','{',};
 529         WCHAR *link = (WCHAR *)((char *)data + data->MountPoints[data->Size].SymbolicLinkNameOffset);
 530         DWORD size = data->MountPoints[data->Size].SymbolicLinkNameLength;
 531         data->Size++;
 532         /* skip non-volumes */
 533         if (size < sizeof(volumeW) || memcmp( link, volumeW, sizeof(volumeW) )) continue;
 534         if (size + sizeof(WCHAR) >= len * sizeof(WCHAR))
 535         {
 536             SetLastError( ERROR_FILENAME_EXCED_RANGE );
 537             return FALSE;
 538         }
 539         memcpy( volume, link, size );
 540         volume[1] = '\\';  /* map \??\ to \\?\ */
 541         volume[size / sizeof(WCHAR)] = '\\';  /* Windows appends a backslash */
 542         volume[size / sizeof(WCHAR) + 1] = 0;
 543         DPRINT( "returning entry %u %s\n", data->Size - 1, volume );
 544         return TRUE;
 545     }
 546     SetLastError( ERROR_NO_MORE_FILES );
 547     return FALSE;
 548 }
 549
 550 /*
 551  * @unimplemented
 552  */
 553 BOOL
 554 WINAPI
 555 FindNextVolumeMountPointW(
 556     HANDLE hFindVolumeMountPoint,
 557     LPWSTR lpszVolumeMountPoint,
 558     DWORD cchBufferLength
 559     )
 560 {
 561     STUB;
 562     return 0;
 563 }
 564
 565 /*
 566  * @unimplemented
 567  */
 568 DWORD
 569 WINAPI
 570 GetFirmwareEnvironmentVariableW(
 571     LPCWSTR lpName,
 572     LPCWSTR lpGuid,
 573     PVOID   pBuffer,
 574     DWORD    nSize
 575     )
 576 {
 577     STUB;
 578     return 0;
 579 }
 580
 581 /*
 582  * @unimplemented
 583  */
 584 BOOL
 585 WINAPI
 586 GetVolumePathNamesForVolumeNameW(
 587     LPCWSTR lpszVolumeName,
 588     LPWSTR lpszVolumePathNames,
 589     DWORD cchBufferLength,
 590     PDWORD lpcchReturnLength
 591     )
 592 {
 593     STUB;
 594     return 0;
 595 }
 596
 597 /*
 598  * @unimplemented
 599  */
 600 BOOL
 601 WINAPI
 602 SetFirmwareEnvironmentVariableW(
 603     LPCWSTR lpName,
 604     LPCWSTR lpGuid,
 605     PVOID    pValue,
 606     DWORD    nSize
 607     )
 608 {
 609     STUB;
 610     return 0;
 611 }
 612
 613 /*
 614  * @unimplemented
 615  */
 616 BOOL
 617 WINAPI
 618 SetVolumeMountPointW(
 619     LPCWSTR lpszVolumeMountPoint,
 620     LPCWSTR lpszVolumeName
 621     )
 622 {
 623     STUB;
 624     return 0;
 625 }
 626
 627 /*
 628  * @unimplemented
 629  */
 630 BOOL
 631 WINAPI
 632 DeleteVolumeMountPointA(
 633     LPCSTR lpszVolumeMountPoint
 634     )
 635 {
 636     STUB;
 637     return 0;
 638 }
 639
 640 /*
 641  * @unimplemented
 642  */
 643 HANDLE
 644 WINAPI
 645 FindFirstVolumeMountPointA(
 646     LPCSTR lpszRootPathName,
 647     LPSTR lpszVolumeMountPoint,
 648     DWORD cchBufferLength
 649     )
 650 {
 651     STUB;
 652     return 0;
 653 }
 654
 655 /*
 656  * @implemented
 657  */
 658 BOOL
 659 WINAPI
 660 FindNextVolumeA(HANDLE handle,
 661                 LPSTR volume,
 662                 DWORD len)
 663 {
 664     WCHAR *buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, len * sizeof(WCHAR));
 665     BOOL ret;
 666
 667     if (!buffer)
 668     {
 669         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 670         return FALSE;
 671     }
 672
 673     if ((ret = FindNextVolumeW( handle, buffer, len )))
 674     {
 675         if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, volume, len, NULL, NULL )) ret = FALSE;
 676     }
 677
 678     HeapFree( GetProcessHeap(), 0, buffer );
 679     return ret;
 680 }
 681
 682 /*
 683  * @unimplemented
 684  */
 685 BOOL
 686 WINAPI
 687 FindNextVolumeMountPointA(
 688     HANDLE hFindVolumeMountPoint,
 689     LPSTR lpszVolumeMountPoint,
 690     DWORD cchBufferLength
 691     )
 692 {
 693     STUB;
 694     return 0;
 695 }
 696
 697 /*
 698  * @unimplemented
 699  */
 700 DWORD
 701 WINAPI
 702 GetFirmwareEnvironmentVariableA(
 703     LPCSTR lpName,
 704     LPCSTR lpGuid,
 705     PVOID   pBuffer,
 706     DWORD    nSize
 707     )
 708 {
 709     STUB;
 710     return 0;
 711 }
 712
 713 /*
 714  * @unimplemented
 715  */
 716 BOOL
 717 WINAPI
 718 GetVolumePathNamesForVolumeNameA(
 719     LPCSTR lpszVolumeName,
 720     LPSTR lpszVolumePathNames,
 721     DWORD cchBufferLength,
 722     PDWORD lpcchReturnLength
 723     )
 724 {
 725     STUB;
 726     return 0;
 727 }
 728
 729 /*
 730  * @unimplemented
 731  */
 732 BOOL
 733 WINAPI
 734 SetFirmwareEnvironmentVariableA(
 735     LPCSTR lpName,
 736     LPCSTR lpGuid,
 737     PVOID    pValue,
 738     DWORD    nSize
 739     )
 740 {
 741     STUB;
 742     return 0;
 743 }
 744
 745 /*
 746  * @unimplemented
 747  */
 748 BOOL
 749 WINAPI
 750 SetVolumeMountPointA(
 751     LPCSTR lpszVolumeMountPoint,
 752     LPCSTR lpszVolumeName
 753     )
 754 {
 755     STUB;
 756     return 0;
 757 }
 758
 759 /*
 760  * @unimplemented
 761  */
 762 BOOL WINAPI GetConsoleKeyboardLayoutNameA(LPSTR name)
 763 {
 764     STUB;
 765     return 0;
 766 }
 767
 768 /*
 769  * @unimplemented
 770  */
 771 BOOL WINAPI GetConsoleKeyboardLayoutNameW(LPWSTR name)
 772 {
 773     STUB;
 774     return 0;
 775 }
 776
 777 /*
 778  * @unimplemented
 779  */
 780 DWORD WINAPI GetHandleContext(HANDLE hnd)
 781 {
 782     STUB;
 783     return 0;
 784 }
 785
 786 /*
 787  * @unimplemented
 788  */
 789 HANDLE WINAPI CreateSocketHandle(VOID)
 790 {
 791     STUB;
 792     return INVALID_HANDLE_VALUE;
 793 }
 794
 795 /*
 796  * @unimplemented
 797  */
 798 BOOL WINAPI SetHandleContext(HANDLE hnd,DWORD context)
 799 {
 800     STUB;
 801     return 0;
 802 }
 803
 804 /*
 805  * @unimplemented
 806  */
 807 BOOL WINAPI UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
 808                         LPSTR lpszInitName, LPSTR lpszProcName,
 809                         FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
 810                         LPVOID lpBuff )
 811 {
 812     STUB;
 813     return 0;
 814 }
 815
 816 /*
 817  * @unimplemented
 818  */
 819 VOID WINAPI UTUnRegister( HMODULE hModule )
 820 {
 821     STUB;
 822 }
 823
 824 /*
 825  * @unimplemented
 826  */
 827 FARPROC WINAPI DelayLoadFailureHook(LPCSTR pszDllName, LPCSTR pszProcName)
 828 {
 829     STUB;
 830     return NULL;
 831 }
 832
 833 /*
 834  * @unimplemented
 835  */
 836 NTSTATUS WINAPI CreateNlsSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,ULONG Size,ULONG AccessMask)
 837 {
 838     STUB;
 839     return 0;
 840 }
 841
 842 /*
 843  * @unimplemented
 844  */
 845 BOOL WINAPI IsValidUILanguage(LANGID langid)
 846 {
 847     STUB;
 848     return 0;
 849 }
 850
 851 /*
 852  * @unimplemented
 853  */
 854 VOID WINAPI NlsConvertIntegerToString(ULONG Value,ULONG Base,ULONG strsize, LPWSTR str, ULONG strsize2)
 855 {
 856     STUB;
 857 }
 858
 859 /*
 860  * @unimplemented
 861  */
 862 UINT WINAPI SetCPGlobal(UINT CodePage)
 863 {
 864     STUB;
 865     return 0;
 866 }
 867
 868 /*
 869  * @unimplemented
 870  */
 871 BOOL
 872 WINAPI
 873 SetClientTimeZoneInformation(
 874     CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation)
 875 {
 876     STUB;
 877     return 0;
 878 }
 879
 880 ULONG
 881 WINAPI
 882 NlsGetCacheUpdateCount(VOID)
 883 {
 884     STUB;
 885     return 0;
 886 }
 887
 888 BOOL
 889 WINAPI
 890 Wow64EnableWow64FsRedirection (BOOL Wow64EnableWow64FsRedirection)
 891 {
 892     STUB;
 893     return FALSE;
 894 }
 895
 896 BOOL
 897 WINAPI
 898 Wow64DisableWow64FsRedirection (VOID ** pv)
 899 {
 900     STUB;
 901     return FALSE;
 902 }
 903
 904 BOOL
 905 WINAPI
 906 Wow64RevertWow64FsRedirection (VOID * pv)
 907 {
 908     STUB;
 909     return FALSE;
 910 }
 911
 912 UINT
 913 WINAPI
 914 EnumSystemFirmwareTables(IN DWORD FirmwareTableProviderSignature,
 915                          OUT PVOID pFirmwareTableBuffer,
 916                          IN DWORD BufferSize)
 917 {
 918     STUB;
 919     return 0;
 920 }
 921
 922 BOOL
 923 WINAPI
 924 GetSystemFileCacheSize(OUT PSIZE_T lpMinimumFileCacheSize,
 925                        OUT PSIZE_T lpMaximumFileCacheSize,
 926                        OUT PDWORD lpFlags)
 927 {
 928     STUB;
 929     return FALSE;
 930 }
 931
 932 UINT
 933 WINAPI
 934 GetSystemFirmwareTable(IN DWORD FirmwareTableProviderSignature,
 935                        IN DWORD FirmwareTableID,
 936                        OUT PVOID pFirmwareTableBuffer,
 937                        IN DWORD BufferSize)
 938 {
 939     STUB;
 940     return 0;
 941 }
 942
 943 BOOL
 944 WINAPI
 945 SetSystemFileCacheSize(IN SIZE_T MinimumFileCacheSize,
 946                        IN SIZE_T MaximumFileCacheSize,
 947                        IN DWORD Flags)
 948 {
 949     STUB;
 950     return FALSE;
 951 }
 952
 953 BOOL
 954 WINAPI
 955 SetThreadStackGuarantee(IN OUT PULONG StackSizeInBytes)
 956 {
 957     STUB;
 958     return FALSE;
 959 }
 960
 961 HANDLE
 962 WINAPI
 963 ReOpenFile(IN HANDLE hOriginalFile,
 964            IN DWORD dwDesiredAccess,
 965            IN DWORD dwShareMode,
 966            IN DWORD dwFlags)
 967 {
 968     STUB;
 969     return INVALID_HANDLE_VALUE;
 970 }
 971
 972 BOOL
 973 WINAPI
 974 SetProcessWorkingSetSizeEx(IN HANDLE hProcess,
 975                            IN SIZE_T dwMinimumWorkingSetSize,
 976                            IN SIZE_T dwMaximumWorkingSetSize,
 977                            IN DWORD Flags)
 978 {
 979     STUB;
 980     return FALSE;
 981 }
 982
 983
 984 BOOL
 985 WINAPI
 986 GetProcessWorkingSetSizeEx(IN HANDLE hProcess,
 987                            OUT PSIZE_T lpMinimumWorkingSetSize,
 988                            OUT PSIZE_T lpMaximumWorkingSetSize,
 989                            OUT PDWORD Flags)
 990 {
 991     STUB;
 992     return FALSE;
 993 }
 994
 995 BOOL
 996 WINAPI
 997 GetNumaAvailableMemoryNode(IN UCHAR Node,
 998                            OUT PULONGLONG AvailableBytes)
 999 {
1000     STUB;
1001     return FALSE;
1002 }
1003
1004 BOOL
1005 WINAPI
1006 GetNumaAvailableMemory(PVOID lpInfo,
1007                        ULONG Length,
1008                        PULONG ReturnLength)
1009 {
1010     STUB;
1011     return FALSE;
1012 }
1013
1014 BOOL
1015 WINAPI
1016 GetNumaProcessorMap(PVOID lpInfo,
1017                     ULONG Length,
1018                     PULONG ReturnLength)
1019 {
1020     STUB;
1021     return FALSE;
1022 }
1023
1024 BOOL
1025 WINAPI
1026 NlsResetProcessLocale(VOID)
1027 {
1028     STUB;
1029     return TRUE;
1030 }
1031
1032 DWORD
1033 WINAPI
1034 AddLocalAlternateComputerNameA(LPSTR lpName, PNTSTATUS Status)
1035 {
1036     STUB;
1037     return 0;
1038 }
1039
1040 DWORD
1041 WINAPI
1042 AddLocalAlternateComputerNameW(LPWSTR lpName, PNTSTATUS Status)
1043 {
1044     STUB;
1045     return 0;
1046 }
1047
1048 NTSTATUS
1049 WINAPI
1050 BaseCleanupAppcompatCache(VOID)
1051 {
1052     STUB;
1053     return STATUS_NOT_IMPLEMENTED;
1054 }
1055
1056 NTSTATUS
1057 WINAPI
1058 BaseCleanupAppcompatCacheSupport(PVOID pUnknown)
1059 {
1060     STUB;
1061     return STATUS_NOT_IMPLEMENTED;
1062 }
1063
1064 BOOL
1065 WINAPI
1066 BaseInitAppcompatCache(VOID)
1067 {
1068     STUB;
1069     return FALSE;
1070 }
1071
1072 BOOL
1073 WINAPI
1074 BaseInitAppcompatCacheSupport(VOID)
1075 {
1076     STUB;
1077     return FALSE;
1078 }
1079
1080 VOID
1081 WINAPI
1082 CreateProcessInternalWSecure(VOID)
1083 {
1084     STUB;
1085 }
1086
1087 DWORD
1088 WINAPI
1089 EnumerateLocalComputerNamesA(PVOID pUnknown, DWORD Size, LPSTR lpBuffer, LPDWORD lpnSize)
1090 {
1091     STUB;
1092     return ERROR_CALL_NOT_IMPLEMENTED;
1093 }
1094
1095 DWORD
1096 WINAPI
1097 EnumerateLocalComputerNamesW(PVOID pUnknown, DWORD Size, LPWSTR lpBuffer, LPDWORD lpnSize)
1098 {
1099     STUB;
1100     return ERROR_CALL_NOT_IMPLEMENTED;
1101 }
1102
1103 PVOID
1104 WINAPI
1105 GetComPlusPackageInstallStatus(VOID)
1106 {
1107     STUB;
1108     return NULL;
1109 }
1110
1111 BOOL
1112 WINAPI
1113 GetConsoleCharType(HANDLE hConsole, COORD Coord, PDWORD Type)
1114 {
1115     STUB;
1116     return FALSE;
1117 }
1118
1119 BOOL
1120 WINAPI
1121 GetConsoleCursorMode(HANDLE hConsole, PBOOL pUnknown1, PBOOL pUnknown2)
1122 {
1123     STUB;
1124     return FALSE;
1125 }
1126
1127 BOOL
1128 WINAPI
1129 GetConsoleNlsMode(HANDLE hConsole, LPDWORD lpMode)
1130 {
1131     STUB;
1132     return FALSE;
1133 }
1134
1135 VOID
1136 WINAPI
1137 GetDefaultSortkeySize(LPVOID lpUnknown)
1138 {
1139     STUB;
1140     lpUnknown = NULL;
1141 }
1142
1143 VOID
1144 WINAPI
1145 GetLinguistLangSize(LPVOID lpUnknown)
1146 {
1147     STUB;
1148     lpUnknown = NULL;
1149 }
1150
1151 BOOL
1152 WINAPI
1153 OpenDataFile(HANDLE hFile, DWORD dwUnused)
1154 {
1155     STUB;
1156     return FALSE;
1157 }
1158
1159 BOOL
1160 WINAPI
1161 OpenProfileUserMapping(VOID)
1162 {
1163     STUB;
1164     return FALSE;
1165 }
1166
1167 BOOL
1168 WINAPI
1169 PrivMoveFileIdentityW(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3)
1170 {
1171     STUB;
1172     return FALSE;
1173 }
1174
1175 BOOL
1176 WINAPI
1177 ReadConsoleInputExA(HANDLE hConsole, LPVOID lpBuffer, DWORD dwLen, LPDWORD Unknown1, DWORD Unknown2)
1178 {
1179     STUB;
1180     return FALSE;
1181 }
1182
1183 BOOL
1184 WINAPI
1185 ReadConsoleInputExW(HANDLE hConsole, LPVOID lpBuffer, DWORD dwLen, LPDWORD Unknown1, DWORD Unknown2)
1186 {
1187     STUB;
1188     return FALSE;
1189 }
1190
1191 BOOL
1192 WINAPI
1193 RegisterConsoleIME(HWND hWnd, LPDWORD ThreadId)
1194 {
1195     STUB;
1196     return FALSE;
1197 }
1198
1199 BOOL
1200 WINAPI
1201 RegisterConsoleOS2(BOOL bUnknown)
1202 {
1203     STUB;
1204     return FALSE;
1205 }
1206
1207 DWORD
1208 WINAPI
1209 RemoveLocalAlternateComputerNameA(LPSTR lpName, DWORD Unknown)
1210 {
1211     STUB;
1212     return ERROR_CALL_NOT_IMPLEMENTED;
1213 }
1214
1215 DWORD
1216 WINAPI
1217 RemoveLocalAlternateComputerNameW(LPWSTR lpName, DWORD Unknown)
1218 {
1219     STUB;
1220     return ERROR_CALL_NOT_IMPLEMENTED;
1221 }
1222
1223 BOOL
1224 WINAPI
1225 SetComPlusPackageInstallStatus(LPVOID lpInfo)
1226 {
1227     STUB;
1228     return FALSE;
1229 }
1230
1231 BOOL
1232 WINAPI
1233 SetConsoleCursorMode(HANDLE hConsole, BOOL Unknown1, BOOL Unknown2)
1234 {
1235     STUB;
1236     return FALSE;
1237 }
1238
1239 BOOL
1240 WINAPI
1241 SetConsoleLocalEUDC(DWORD Unknown1, DWORD Unknown2, DWORD Unknown3, DWORD Unknown4)
1242 {
1243     STUB;
1244     return FALSE;
1245 }
1246
1247 BOOL
1248 WINAPI
1249 SetConsoleNlsMode(HANDLE hConsole, DWORD dwMode)
1250 {
1251     STUB;
1252     return FALSE;
1253 }
1254
1255 BOOL
1256 WINAPI
1257 SetConsoleOS2OemFormat(BOOL bUnknown)
1258 {
1259     STUB;
1260     return FALSE;
1261 }
1262
1263 BOOL
1264 WINAPI
1265 UnregisterConsoleIME(VOID)
1266 {
1267     STUB;
1268     return FALSE;
1269 }
1270
1271 BOOL WINAPI TermsrvAppInstallMode(void)
1272 {
1273      STUB;
1274      return FALSE;
1275 }
1276
1277 DWORD WINAPI SetTermsrvAppInstallMode(BOOL bInstallMode)
1278 {
1279     STUB;
1280     return 0;
1281 }
1282