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 FindVolumeMountPointClose(
 428     HANDLE hFindVolumeMountPoint
 429     )
 430 {
 431     STUB;
 432     return 0;
 433 }
 434
 435 /*
 436  * @unimplemented
 437  */
 438 BOOL
 439 STDCALL
 440 FreeUserPhysicalPages(
 441     HANDLE hProcess,
 442     PULONG_PTR NumberOfPages,
 443     PULONG_PTR PageArray
 444     )
 445 {
 446     STUB;
 447     return 0;
 448 }
 449
 450 /*
 451  * @unimplemented
 452  */
 453 BOOL
 454 STDCALL
 455 GetDevicePowerState(
 456     HANDLE hDevice,
 457     BOOL *pfOn
 458     )
 459 {
 460     STUB;
 461     return 0;
 462 }
 463
 464
 465 /*
 466  * @unimplemented
 467  */
 468 BOOL
 469 STDCALL
 470 GetNumaHighestNodeNumber(
 471     PULONG HighestNodeNumber
 472     )
 473 {
 474     STUB;
 475     return 0;
 476 }
 477
 478 /*
 479  * @unimplemented
 480  */
 481 BOOL
 482 STDCALL
 483 GetNumaNodeProcessorMask(
 484     UCHAR Node,
 485     PULONGLONG ProcessorMask
 486     )
 487 {
 488     STUB;
 489     return 0;
 490 }
 491
 492 /*
 493  * @unimplemented
 494  */
 495 BOOL
 496 STDCALL
 497 GetNumaProcessorNode(
 498     UCHAR Processor,
 499     PUCHAR NodeNumber
 500     )
 501 {
 502     STUB;
 503     return 0;
 504 }
 505
 506 /*
 507  * @unimplemented
 508  */
 509 UINT
 510 STDCALL
 511 GetWriteWatch(
 512     DWORD  dwFlags,
 513     PVOID  lpBaseAddress,
 514     SIZE_T dwRegionSize,
 515     PVOID *lpAddresses,
 516     PULONG_PTR lpdwCount,
 517     PULONG lpdwGranularity
 518     )
 519 {
 520     STUB;
 521     return 0;
 522 }
 523
 524 /*
 525  * @unimplemented
 526  */
 527 BOOL
 528 STDCALL
 529 HeapQueryInformation (
 530     HANDLE HeapHandle,
 531     HEAP_INFORMATION_CLASS HeapInformationClass,
 532     PVOID HeapInformation OPTIONAL,
 533     SIZE_T HeapInformationLength OPTIONAL,
 534     PSIZE_T ReturnLength OPTIONAL
 535     )
 536 {
 537     STUB;
 538     return 0;
 539 }
 540
 541 /*
 542  * @unimplemented
 543  */
 544 BOOL
 545 STDCALL
 546 HeapSetInformation (
 547     HANDLE HeapHandle,
 548     HEAP_INFORMATION_CLASS HeapInformationClass,
 549     PVOID HeapInformation OPTIONAL,
 550     SIZE_T HeapInformationLength OPTIONAL
 551     )
 552 {
 553     STUB;
 554     return 0;
 555 }
 556
 557 /*
 558  * @unimplemented
 559  */
 560 BOOL
 561 STDCALL
 562 IsSystemResumeAutomatic(
 563     VOID
 564     )
 565 {
 566     STUB;
 567     return 0;
 568 }
 569
 570 /*
 571  * @unimplemented
 572  */
 573 BOOL
 574 STDCALL
 575 IsWow64Process(
 576     HANDLE hProcess,
 577     PBOOL Wow64Process
 578     )
 579 {
 580     STUB;
 581     *Wow64Process = FALSE;
 582     return TRUE;
 583 }
 584
 585 /*
 586  * @unimplemented
 587  */
 588 BOOL
 589 STDCALL
 590 MapUserPhysicalPages(
 591     PVOID VirtualAddress,
 592     ULONG_PTR NumberOfPages,
 593     PULONG_PTR PageArray  OPTIONAL
 594     )
 595 {
 596     STUB;
 597     return 0;
 598 }
 599
 600 /*
 601  * @unimplemented
 602  */
 603 BOOL
 604 STDCALL
 605 MapUserPhysicalPagesScatter(
 606     PVOID *VirtualAddresses,
 607     ULONG_PTR NumberOfPages,
 608     PULONG_PTR PageArray  OPTIONAL
 609     )
 610 {
 611     STUB;
 612     return 0;
 613 }
 614
 615 /*
 616  * @unimplemented
 617  */
 618 BOOL
 619 STDCALL
 620 ReadFileScatter(
 621     HANDLE hFile,
 622     FILE_SEGMENT_ELEMENT aSegmentArray[],
 623     DWORD nNumberOfBytesToRead,
 624     LPDWORD lpReserved,
 625     LPOVERLAPPED lpOverlapped
 626     )
 627 {
 628     STUB;
 629     return 0;
 630 }
 631
 632 /*
 633  * @unimplemented
 634  */
 635 ULONG
 636 STDCALL
 637 RemoveVectoredExceptionHandler(
 638     PVOID VectoredHandlerHandle
 639     )
 640 {
 641     STUB;
 642     return 0;
 643 }
 644
 645 /*
 646  * @unimplemented
 647  */
 648 BOOL
 649 STDCALL
 650 RequestDeviceWakeup(
 651     HANDLE hDevice
 652     )
 653 {
 654     STUB;
 655     return 0;
 656 }
 657
 658 /*
 659  * @unimplemented
 660  */
 661 BOOL
 662 STDCALL
 663 RequestWakeupLatency(
 664     LATENCY_TIME latency
 665     )
 666 {
 667     STUB;
 668     return 0;
 669 }
 670
 671 /*
 672  * @unimplemented
 673  */
 674 UINT
 675 STDCALL
 676 ResetWriteWatch(
 677     LPVOID lpBaseAddress,
 678     SIZE_T dwRegionSize
 679     )
 680 {
 681     STUB;
 682     return 0;
 683 }
 684
 685 /*
 686  * @unimplemented
 687  */
 688 VOID
 689 STDCALL
 690 RestoreLastError(
 691     DWORD dwErrCode
 692     )
 693 {
 694     STUB;
 695 }
 696
 697 /*
 698  * @unimplemented
 699  */
 700 BOOL
 701 STDCALL
 702 SetMessageWaitingIndicator(
 703     HANDLE hMsgIndicator,
 704     ULONG ulMsgCount
 705     )
 706 {
 707     STUB;
 708     return 0;
 709 }
 710
 711 /*
 712  * @unimplemented
 713  */
 714 EXECUTION_STATE
 715 STDCALL
 716 SetThreadExecutionState(
 717     EXECUTION_STATE esFlags
 718     )
 719 {
 720     static EXECUTION_STATE current =
 721         ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED | ES_USER_PRESENT;
 722     EXECUTION_STATE old = current;
 723
 724     DPRINT1("(0x%x): stub, harmless.\n", esFlags);
 725
 726     if (!(current & ES_CONTINUOUS) || (esFlags & ES_CONTINUOUS))
 727         current = esFlags;
 728     return old;
 729 }
 730
 731 /*
 732  * @unimplemented
 733  */
 734 BOOL
 735 STDCALL
 736 WriteFileGather(
 737     HANDLE hFile,
 738     FILE_SEGMENT_ELEMENT aSegmentArray[],
 739     DWORD nNumberOfBytesToWrite,
 740     LPDWORD lpReserved,
 741     LPOVERLAPPED lpOverlapped
 742     )
 743 {
 744     STUB;
 745     return 0;
 746 }
 747
 748 /*
 749  * @unimplemented
 750  */
 751 BOOL
 752 STDCALL
 753 DeleteVolumeMountPointW(
 754     LPCWSTR lpszVolumeMountPoint
 755     )
 756 {
 757     STUB;
 758     return 0;
 759 }
 760
 761 /*
 762  * @unimplemented
 763  */
 764 BOOL
 765 STDCALL
 766 DnsHostnameToComputerNameW (
 767         LPCWSTR hostname,
 768     LPWSTR computername,
 769         LPDWORD size
 770     )
 771 {
 772     DWORD len;
 773
 774     DPRINT("(%s, %p, %p): stub\n", hostname, computername, size);
 775
 776     if (!hostname || !size) return FALSE;
 777     len = lstrlenW(hostname);
 778
 779     if (len > MAX_COMPUTERNAME_LENGTH)
 780         len = MAX_COMPUTERNAME_LENGTH;
 781
 782     if (*size < len)
 783     {
 784         *size = len;
 785         return FALSE;
 786     }
 787     if (!computername) return FALSE;
 788
 789     memcpy( computername, hostname, len * sizeof(WCHAR) );
 790     computername[len + 1] = 0;
 791     return TRUE;
 792 }
 793
 794 /*
 795  * @unimplemented
 796  */
 797 HANDLE
 798 STDCALL
 799 FindFirstVolumeMountPointW(
 800     LPCWSTR lpszRootPathName,
 801     LPWSTR lpszVolumeMountPoint,
 802     DWORD cchBufferLength
 803     )
 804 {
 805     STUB;
 806     return 0;
 807 }
 808
 809 /*
 810  * @implemented
 811  */
 812 BOOL
 813 STDCALL
 814 FindNextVolumeW(
 815         HANDLE handle,
 816         LPWSTR volume,
 817         DWORD len
 818     )
 819 {
 820     MOUNTMGR_MOUNT_POINTS *data = handle;
 821
 822     while (data->Size < data->NumberOfMountPoints)
 823     {
 824         static const WCHAR volumeW[] = {'\\','?','?','\\','V','o','l','u','m','e','{',};
 825         WCHAR *link = (WCHAR *)((char *)data + data->MountPoints[data->Size].SymbolicLinkNameOffset);
 826         DWORD size = data->MountPoints[data->Size].SymbolicLinkNameLength;
 827         data->Size++;
 828         /* skip non-volumes */
 829         if (size < sizeof(volumeW) || memcmp( link, volumeW, sizeof(volumeW) )) continue;
 830         if (size + sizeof(WCHAR) >= len * sizeof(WCHAR))
 831         {
 832             SetLastError( ERROR_FILENAME_EXCED_RANGE );
 833             return FALSE;
 834         }
 835         memcpy( volume, link, size );
 836         volume[1] = '\\';  /* map \??\ to \\?\ */
 837         volume[size / sizeof(WCHAR)] = '\\';  /* Windows appends a backslash */
 838         volume[size / sizeof(WCHAR) + 1] = 0;
 839         DPRINT( "returning entry %u %s\n", data->Size - 1, volume );
 840         return TRUE;
 841     }
 842     SetLastError( ERROR_NO_MORE_FILES );
 843     return FALSE;
 844 }
 845
 846 /*
 847  * @unimplemented
 848  */
 849 BOOL
 850 STDCALL
 851 FindNextVolumeMountPointW(
 852     HANDLE hFindVolumeMountPoint,
 853     LPWSTR lpszVolumeMountPoint,
 854     DWORD cchBufferLength
 855     )
 856 {
 857     STUB;
 858     return 0;
 859 }
 860
 861 /*
 862  * @unimplemented
 863  */
 864 DWORD
 865 STDCALL
 866 GetFirmwareEnvironmentVariableW(
 867     LPCWSTR lpName,
 868     LPCWSTR lpGuid,
 869     PVOID   pBuffer,
 870     DWORD    nSize
 871     )
 872 {
 873     STUB;
 874     return 0;
 875 }
 876
 877 /*
 878  * @unimplemented
 879  */
 880 BOOL
 881 STDCALL
 882 GetVolumePathNameW(
 883     LPCWSTR lpszFileName,
 884     LPWSTR lpszVolumePathName,
 885     DWORD cchBufferLength
 886     )
 887 {
 888     STUB;
 889     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 890     return 0;
 891 }
 892
 893 /*
 894  * @unimplemented
 895  */
 896 BOOL
 897 STDCALL
 898 GetVolumePathNamesForVolumeNameW(
 899     LPCWSTR lpszVolumeName,
 900     LPWSTR lpszVolumePathNames,
 901     DWORD cchBufferLength,
 902     PDWORD lpcchReturnLength
 903     )
 904 {
 905     STUB;
 906     return 0;
 907 }
 908
 909 /*
 910  * @unimplemented
 911  */
 912 BOOL
 913 STDCALL
 914 ReplaceFileW(
 915     LPCWSTR lpReplacedFileName,
 916     LPCWSTR lpReplacementFileName,
 917     LPCWSTR lpBackupFileName,
 918     DWORD   dwReplaceFlags,
 919     LPVOID  lpExclude,
 920     LPVOID  lpReserved
 921     )
 922 {
 923     STUB;
 924     return 0;
 925 }
 926
 927 /*
 928  * @unimplemented
 929  */
 930 BOOL
 931 STDCALL
 932 SetFirmwareEnvironmentVariableW(
 933     LPCWSTR lpName,
 934     LPCWSTR lpGuid,
 935     PVOID    pValue,
 936     DWORD    nSize
 937     )
 938 {
 939     STUB;
 940     return 0;
 941 }
 942
 943 /*
 944  * @unimplemented
 945  */
 946 BOOL
 947 STDCALL
 948 SetVolumeMountPointW(
 949     LPCWSTR lpszVolumeMountPoint,
 950     LPCWSTR lpszVolumeName
 951     )
 952 {
 953     STUB;
 954     return 0;
 955 }
 956
 957 /*
 958  * @unimplemented
 959  */
 960 BOOL
 961 STDCALL
 962 DeleteVolumeMountPointA(
 963     LPCSTR lpszVolumeMountPoint
 964     )
 965 {
 966     STUB;
 967     return 0;
 968 }
 969
 970 /*
 971  * @unimplemented
 972  */
 973 BOOL
 974 STDCALL
 975 DnsHostnameToComputerNameA (
 976     LPCSTR Hostname,
 977     LPSTR ComputerName,
 978     LPDWORD nSize
 979     )
 980 {
 981     STUB;
 982     return 0;
 983 }
 984
 985 /*
 986  * @unimplemented
 987  */
 988 HANDLE
 989 STDCALL
 990 FindFirstVolumeMountPointA(
 991     LPCSTR lpszRootPathName,
 992     LPSTR lpszVolumeMountPoint,
 993     DWORD cchBufferLength
 994     )
 995 {
 996     STUB;
 997     return 0;
 998 }
 999
1000 /*
1001  * @unimplemented
1002  */
1003 BOOL
1004 STDCALL
1005 FindNextVolumeA(
1006         HANDLE handle,
1007         LPSTR volume,
1008         DWORD len
1009     )
1010 {
1011     WCHAR *buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1012     BOOL ret;
1013
1014     if ((ret = FindNextVolumeW( handle, buffer, len )))
1015     {
1016         if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, volume, len, NULL, NULL )) ret = FALSE;
1017     }
1018     HeapFree( GetProcessHeap(), 0, buffer );
1019     return ret;
1020 }
1021
1022 /*
1023  * @unimplemented
1024  */
1025 BOOL
1026 STDCALL
1027 FindNextVolumeMountPointA(
1028     HANDLE hFindVolumeMountPoint,
1029     LPSTR lpszVolumeMountPoint,
1030     DWORD cchBufferLength
1031     )
1032 {
1033     STUB;
1034     return 0;
1035 }
1036
1037 /*
1038  * @unimplemented
1039  */
1040 DWORD
1041 STDCALL
1042 GetFirmwareEnvironmentVariableA(
1043     LPCSTR lpName,
1044     LPCSTR lpGuid,
1045     PVOID   pBuffer,
1046     DWORD    nSize
1047     )
1048 {
1049     STUB;
1050     return 0;
1051 }
1052
1053 /*
1054  * @unimplemented
1055  */
1056 BOOL
1057 STDCALL
1058 GetVolumePathNameA(
1059     LPCSTR lpszFileName,
1060     LPSTR lpszVolumePathName,
1061     DWORD cchBufferLength
1062     )
1063 {
1064     STUB;
1065     return 0;
1066 }
1067
1068 /*
1069  * @unimplemented
1070  */
1071 BOOL
1072 STDCALL
1073 GetVolumePathNamesForVolumeNameA(
1074     LPCSTR lpszVolumeName,
1075     LPSTR lpszVolumePathNames,
1076     DWORD cchBufferLength,
1077     PDWORD lpcchReturnLength
1078     )
1079 {
1080     STUB;
1081     return 0;
1082 }
1083
1084 /*
1085  * @unimplemented
1086  */
1087 BOOL
1088 STDCALL
1089 ReplaceFileA(
1090     LPCSTR  lpReplacedFileName,
1091     LPCSTR  lpReplacementFileName,
1092     LPCSTR  lpBackupFileName,
1093     DWORD   dwReplaceFlags,
1094     LPVOID  lpExclude,
1095     LPVOID  lpReserved
1096     )
1097 {
1098     STUB;
1099     return 0;
1100 }
1101
1102 /*
1103  * @unimplemented
1104  */
1105 BOOL
1106 STDCALL
1107 SetFirmwareEnvironmentVariableA(
1108     LPCSTR lpName,
1109     LPCSTR lpGuid,
1110     PVOID    pValue,
1111     DWORD    nSize
1112     )
1113 {
1114     STUB;
1115     return 0;
1116 }
1117
1118 /*
1119  * @unimplemented
1120  */
1121 BOOL
1122 STDCALL
1123 SetVolumeMountPointA(
1124     LPCSTR lpszVolumeMountPoint,
1125     LPCSTR lpszVolumeName
1126     )
1127 {
1128     STUB;
1129     return 0;
1130 }
1131
1132 /*
1133  * @unimplemented
1134  */
1135 BOOL STDCALL GetConsoleKeyboardLayoutNameA(LPSTR name)
1136 {
1137     STUB;
1138     return 0;
1139 }
1140
1141 /*
1142  * @unimplemented
1143  */
1144 BOOL STDCALL GetConsoleKeyboardLayoutNameW(LPWSTR name)
1145 {
1146     STUB;
1147     return 0;
1148 }
1149
1150 /*
1151  * @unimplemented
1152  */
1153 DWORD STDCALL GetHandleContext(HANDLE hnd)
1154 {
1155     STUB;
1156     return 0;
1157 }
1158
1159 /*
1160  * @unimplemented
1161  */
1162 HANDLE STDCALL CreateSocketHandle(VOID)
1163 {
1164     STUB;
1165     return 0;
1166 }
1167
1168 /*
1169  * @unimplemented
1170  */
1171 BOOL STDCALL SetHandleContext(HANDLE hnd,DWORD context)
1172 {
1173     STUB;
1174     return 0;
1175 }
1176
1177 /*
1178  * @unimplemented
1179  */
1180 BOOL STDCALL UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
1181                         LPSTR lpszInitName, LPSTR lpszProcName,
1182                         FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
1183                         LPVOID lpBuff )
1184 {
1185     STUB;
1186     return 0;
1187 }
1188
1189 /*
1190  * @unimplemented
1191  */
1192 VOID STDCALL UTUnRegister( HMODULE hModule )
1193 {
1194     STUB;
1195 }
1196
1197 /*
1198  * @unimplemented
1199  */
1200 #if 0
1201 FARPROC STDCALL DelayLoadFailureHook(unsigned int dliNotify, PDelayLoadInfo pdli)
1202 #else
1203 FARPROC STDCALL DelayLoadFailureHook(unsigned int dliNotify, PVOID pdli)
1204 #endif
1205 {
1206     STUB;
1207     return 0;
1208 }
1209
1210 /*
1211  * @unimplemented
1212  */
1213 NTSTATUS STDCALL CreateNlsSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,ULONG Size,ULONG AccessMask)
1214 {
1215     STUB;
1216     return 0;
1217 }
1218
1219 /*
1220  * @unimplemented
1221  */
1222 BOOL STDCALL IsValidUILanguage(LANGID langid)
1223 {
1224     STUB;
1225     return 0;
1226 }
1227
1228 /*
1229  * @unimplemented
1230  */
1231 VOID STDCALL NlsConvertIntegerToString(ULONG Value,ULONG Base,ULONG strsize, LPWSTR str, ULONG strsize2)
1232 {
1233     STUB;
1234 }
1235
1236 /*
1237  * @unimplemented
1238  */
1239 UINT STDCALL SetCPGlobal(UINT CodePage)
1240 {
1241     STUB;
1242     return 0;
1243 }
1244
1245 /*
1246  * @unimplemented
1247  */
1248 BOOL
1249 STDCALL
1250 SetClientTimeZoneInformation(
1251     CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation)
1252 {
1253     STUB;
1254     return 0;
1255 }
1256
1257 ULONG
1258 WINAPI
1259 NlsGetCacheUpdateCount(VOID)
1260 {
1261     STUB;
1262     return 0;
1263 }
1264
1265 BOOL
1266 STDCALL
1267 Wow64EnableWow64FsRedirection (BOOL Wow64EnableWow64FsRedirection)
1268 {
1269     STUB;
1270     return FALSE;
1271 }
1272
1273 BOOL
1274 STDCALL
1275 Wow64DisableWow64FsRedirection (VOID ** pv)
1276 {
1277     STUB;
1278     return FALSE;
1279 }
1280
1281 BOOL
1282 STDCALL
1283 Wow64RevertWow64FsRedirection (VOID * pv)
1284 {
1285     STUB;
1286     return FALSE;
1287 }
1288
1289 UINT
1290 WINAPI
1291 EnumSystemFirmwareTables(IN DWORD FirmwareTableProviderSignature,
1292                          OUT PVOID pFirmwareTableBuffer,
1293                          IN DWORD BufferSize)
1294 {
1295     STUB;
1296     return 0;
1297 }
1298
1299 BOOL
1300 WINAPI
1301 GetSystemFileCacheSize(OUT PSIZE_T lpMinimumFileCacheSize,
1302                        OUT PSIZE_T lpMaximumFileCacheSize,
1303                        OUT PDWORD lpFlags)
1304 {
1305     STUB;
1306     return FALSE;
1307 }
1308
1309 UINT
1310 WINAPI
1311 GetSystemFirmwareTable(IN DWORD FirmwareTableProviderSignature,
1312                        IN DWORD FirmwareTableID,
1313                        OUT PVOID pFirmwareTableBuffer,
1314                        IN DWORD BufferSize)
1315 {
1316     STUB;
1317     return 0;
1318 }
1319
1320 BOOL
1321 WINAPI
1322 SetSystemFileCacheSize(IN SIZE_T MinimumFileCacheSize,
1323                        IN SIZE_T MaximumFileCacheSize,
1324                        IN DWORD Flags)
1325 {
1326     STUB;
1327     return FALSE;
1328 }
1329
1330 BOOL
1331 WINAPI
1332 SetThreadStackGuarantee(IN OUT PULONG StackSizeInBytes)
1333 {
1334     STUB;
1335     return FALSE;
1336 }
1337
1338 HANDLE
1339 WINAPI
1340 ReOpenFile(IN HANDLE hOriginalFile,
1341            IN DWORD dwDesiredAccess,
1342            IN DWORD dwShareMode,
1343            IN DWORD dwFlags)
1344 {
1345     STUB;
1346     return INVALID_HANDLE_VALUE;
1347 }
1348
1349 BOOL
1350 WINAPI
1351 SetProcessWorkingSetSizeEx(IN HANDLE hProcess,
1352                            IN SIZE_T dwMinimumWorkingSetSize,
1353                            IN SIZE_T dwMaximumWorkingSetSize,
1354                            IN DWORD Flags)
1355 {
1356     STUB;
1357     return FALSE;
1358 }
1359
1360
1361 BOOL
1362 WINAPI
1363 GetProcessWorkingSetSizeEx(IN HANDLE hProcess,
1364                            OUT PSIZE_T lpMinimumWorkingSetSize,
1365                            OUT PSIZE_T lpMaximumWorkingSetSize,
1366                            OUT PDWORD Flags)
1367 {
1368     STUB;
1369     return FALSE;
1370 }
1371
1372 BOOL
1373 WINAPI
1374 GetLogicalProcessorInformation(OUT PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer,
1375                                IN OUT PDWORD ReturnLength)
1376 {
1377     STUB;
1378     return FALSE;
1379 }
1380
1381 BOOL
1382 WINAPI
1383 GetNumaAvailableMemoryNode(IN UCHAR Node,
1384                            OUT PULONGLONG AvailableBytes)
1385 {
1386     STUB;
1387     return FALSE;
1388 }
1389
1390 BOOL WINAPI TermsrvAppInstallMode(void)
1391 {
1392      STUB;
1393      return FALSE;
1394 }
1395
1396 DWORD WINAPI SetTermsrvAppInstallMode(BOOL bInstallMode)
1397 {
1398     STUB;
1399     return 0;
1400 }
1401