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