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 BOOL
 160 WINAPI
 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 WINAPI
 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 WINAPI
 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 WINAPI
 220 RegisterWowBaseHandlers (
 221     DWORD   Unknown0
 222     )
 223 {
 224     STUB;
 225     return FALSE;
 226 }
 227
 228
 229 /*
 230  * @unimplemented
 231  */
 232 BOOL
 233 WINAPI
 234 RegisterWowExec (
 235     DWORD   Unknown0
 236     )
 237 {
 238     STUB;
 239     return FALSE;
 240 }
 241
 242
 243 /*
 244  * @unimplemented
 245  */
 246 BOOL WINAPI
 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 WINAPI
 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 WINAPI
 277 TrimVirtualBuffer (
 278     DWORD   Unknown0
 279     )
 280 {
 281     STUB;
 282     return 0;
 283 }
 284
 285
 286 /*
 287  * @unimplemented
 288  */
 289 DWORD
 290 WINAPI
 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 WINAPI
 306 VDMOperationStarted (
 307     DWORD   Unknown0
 308     )
 309 {
 310     STUB;
 311     return 0;
 312 }
 313
 314 /*
 315  * @unimplemented
 316  */
 317 DWORD
 318 WINAPI
 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 WINAPI
 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 WINAPI
 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                                         (PIO_APC_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 WINAPI
 375 CancelDeviceWakeupRequest(
 376     HANDLE hDevice
 377     )
 378 {
 379     STUB;
 380     return 0;
 381 }
 382
 383 /*
 384  * @unimplemented
 385  */
 386 BOOL
 387 WINAPI
 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 WINAPI
 402 FindVolumeMountPointClose(
 403     HANDLE hFindVolumeMountPoint
 404     )
 405 {
 406     STUB;
 407     return 0;
 408 }
 409
 410 /*
 411  * @unimplemented
 412  */
 413 BOOL
 414 WINAPI
 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 WINAPI
 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 WINAPI
 445 GetNumaHighestNodeNumber(
 446     PULONG HighestNodeNumber
 447     )
 448 {
 449     STUB;
 450     return 0;
 451 }
 452
 453 /*
 454  * @unimplemented
 455  */
 456 BOOL
 457 WINAPI
 458 GetNumaNodeProcessorMask(
 459     UCHAR Node,
 460     PULONGLONG ProcessorMask
 461     )
 462 {
 463     STUB;
 464     return 0;
 465 }
 466
 467 /*
 468  * @unimplemented
 469  */
 470 BOOL
 471 WINAPI
 472 GetNumaProcessorNode(
 473     UCHAR Processor,
 474     PUCHAR NodeNumber
 475     )
 476 {
 477     STUB;
 478     return 0;
 479 }
 480
 481 /*
 482  * @unimplemented
 483  */
 484 UINT
 485 WINAPI
 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 WINAPI
 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 WINAPI
 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 WINAPI
 537 IsSystemResumeAutomatic(
 538     VOID
 539     )
 540 {
 541     STUB;
 542     return 0;
 543 }
 544
 545 /*
 546  * @unimplemented
 547  */
 548 BOOL
 549 WINAPI
 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 WINAPI
 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 WINAPI
 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 WINAPI
 622 RemoveVectoredExceptionHandler(
 623     PVOID VectoredHandlerHandle
 624     )
 625 {
 626     STUB;
 627     return 0;
 628 }
 629
 630 /*
 631  * @unimplemented
 632  */
 633 BOOL
 634 WINAPI
 635 RequestDeviceWakeup(
 636     HANDLE hDevice
 637     )
 638 {
 639     STUB;
 640     return 0;
 641 }
 642
 643 /*
 644  * @unimplemented
 645  */
 646 BOOL
 647 WINAPI
 648 RequestWakeupLatency(
 649     LATENCY_TIME latency
 650     )
 651 {
 652     STUB;
 653     return 0;
 654 }
 655
 656 /*
 657  * @unimplemented
 658  */
 659 UINT
 660 WINAPI
 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 WINAPI
 675 RestoreLastError(
 676     DWORD dwErrCode
 677     )
 678 {
 679     STUB;
 680 }
 681
 682 /*
 683  * @unimplemented
 684  */
 685 BOOL
 686 WINAPI
 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 WINAPI
 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 WINAPI
 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 WINAPI
 763 DeleteVolumeMountPointW(
 764     LPCWSTR lpszVolumeMountPoint
 765     )
 766 {
 767     STUB;
 768     return 0;
 769 }
 770
 771 /*
 772  * @unimplemented
 773  */
 774 HANDLE
 775 WINAPI
 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 WINAPI
 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 WINAPI
 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 WINAPI
 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 WINAPI
 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 WINAPI
 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 WINAPI
 891 SetFirmwareEnvironmentVariableW(
 892     LPCWSTR lpName,
 893     LPCWSTR lpGuid,
 894     PVOID    pValue,
 895     DWORD    nSize
 896     )
 897 {
 898     STUB;
 899     return 0;
 900 }
 901
 902 /*
 903  * @unimplemented
 904  */
 905 BOOL
 906 WINAPI
 907 SetVolumeMountPointW(
 908     LPCWSTR lpszVolumeMountPoint,
 909     LPCWSTR lpszVolumeName
 910     )
 911 {
 912     STUB;
 913     return 0;
 914 }
 915
 916 /*
 917  * @unimplemented
 918  */
 919 BOOL
 920 WINAPI
 921 DeleteVolumeMountPointA(
 922     LPCSTR lpszVolumeMountPoint
 923     )
 924 {
 925     STUB;
 926     return 0;
 927 }
 928
 929 /*
 930  * @unimplemented
 931  */
 932 HANDLE
 933 WINAPI
 934 FindFirstVolumeMountPointA(
 935     LPCSTR lpszRootPathName,
 936     LPSTR lpszVolumeMountPoint,
 937     DWORD cchBufferLength
 938     )
 939 {
 940     STUB;
 941     return 0;
 942 }
 943
 944 /*
 945  * @implemented
 946  */
 947 BOOL
 948 WINAPI
 949 FindNextVolumeA(HANDLE handle,
 950                 LPSTR volume,
 951                 DWORD len)
 952 {
 953     WCHAR *buffer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 954     BOOL ret;
 955
 956     if ((ret = FindNextVolumeW( handle, buffer, len )))
 957     {
 958         if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, volume, len, NULL, NULL )) ret = FALSE;
 959     }
 960
 961     HeapFree( GetProcessHeap(), 0, buffer );
 962     return ret;
 963 }
 964
 965 /*
 966  * @unimplemented
 967  */
 968 BOOL
 969 WINAPI
 970 FindNextVolumeMountPointA(
 971     HANDLE hFindVolumeMountPoint,
 972     LPSTR lpszVolumeMountPoint,
 973     DWORD cchBufferLength
 974     )
 975 {
 976     STUB;
 977     return 0;
 978 }
 979
 980 /*
 981  * @unimplemented
 982  */
 983 DWORD
 984 WINAPI
 985 GetFirmwareEnvironmentVariableA(
 986     LPCSTR lpName,
 987     LPCSTR lpGuid,
 988     PVOID   pBuffer,
 989     DWORD    nSize
 990     )
 991 {
 992     STUB;
 993     return 0;
 994 }
 995
 996 /*
 997  * @unimplemented
 998  */
 999 BOOL
1000 WINAPI
1001 GetVolumePathNameA(
1002     LPCSTR lpszFileName,
1003     LPSTR lpszVolumePathName,
1004     DWORD cchBufferLength
1005     )
1006 {
1007     STUB;
1008     return 0;
1009 }
1010
1011 /*
1012  * @unimplemented
1013  */
1014 BOOL
1015 WINAPI
1016 GetVolumePathNamesForVolumeNameA(
1017     LPCSTR lpszVolumeName,
1018     LPSTR lpszVolumePathNames,
1019     DWORD cchBufferLength,
1020     PDWORD lpcchReturnLength
1021     )
1022 {
1023     STUB;
1024     return 0;
1025 }
1026
1027 /*
1028  * @unimplemented
1029  */
1030 BOOL
1031 WINAPI
1032 SetFirmwareEnvironmentVariableA(
1033     LPCSTR lpName,
1034     LPCSTR lpGuid,
1035     PVOID    pValue,
1036     DWORD    nSize
1037     )
1038 {
1039     STUB;
1040     return 0;
1041 }
1042
1043 /*
1044  * @unimplemented
1045  */
1046 BOOL
1047 WINAPI
1048 SetVolumeMountPointA(
1049     LPCSTR lpszVolumeMountPoint,
1050     LPCSTR lpszVolumeName
1051     )
1052 {
1053     STUB;
1054     return 0;
1055 }
1056
1057 /*
1058  * @unimplemented
1059  */
1060 BOOL WINAPI GetConsoleKeyboardLayoutNameA(LPSTR name)
1061 {
1062     STUB;
1063     return 0;
1064 }
1065
1066 /*
1067  * @unimplemented
1068  */
1069 BOOL WINAPI GetConsoleKeyboardLayoutNameW(LPWSTR name)
1070 {
1071     STUB;
1072     return 0;
1073 }
1074
1075 /*
1076  * @unimplemented
1077  */
1078 DWORD WINAPI GetHandleContext(HANDLE hnd)
1079 {
1080     STUB;
1081     return 0;
1082 }
1083
1084 /*
1085  * @unimplemented
1086  */
1087 HANDLE WINAPI CreateSocketHandle(VOID)
1088 {
1089     STUB;
1090     return 0;
1091 }
1092
1093 /*
1094  * @unimplemented
1095  */
1096 BOOL WINAPI SetHandleContext(HANDLE hnd,DWORD context)
1097 {
1098     STUB;
1099     return 0;
1100 }
1101
1102 /*
1103  * @unimplemented
1104  */
1105 BOOL WINAPI UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
1106                         LPSTR lpszInitName, LPSTR lpszProcName,
1107                         FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
1108                         LPVOID lpBuff )
1109 {
1110     STUB;
1111     return 0;
1112 }
1113
1114 /*
1115  * @unimplemented
1116  */
1117 VOID WINAPI UTUnRegister( HMODULE hModule )
1118 {
1119     STUB;
1120 }
1121
1122 /*
1123  * @unimplemented
1124  */
1125 #if 0
1126 FARPROC WINAPI DelayLoadFailureHook(unsigned int dliNotify, PDelayLoadInfo pdli)
1127 #else
1128 FARPROC WINAPI DelayLoadFailureHook(unsigned int dliNotify, PVOID pdli)
1129 #endif
1130 {
1131     STUB;
1132     return 0;
1133 }
1134
1135 /*
1136  * @unimplemented
1137  */
1138 NTSTATUS WINAPI CreateNlsSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,ULONG Size,ULONG AccessMask)
1139 {
1140     STUB;
1141     return 0;
1142 }
1143
1144 /*
1145  * @unimplemented
1146  */
1147 BOOL WINAPI IsValidUILanguage(LANGID langid)
1148 {
1149     STUB;
1150     return 0;
1151 }
1152
1153 /*
1154  * @unimplemented
1155  */
1156 VOID WINAPI NlsConvertIntegerToString(ULONG Value,ULONG Base,ULONG strsize, LPWSTR str, ULONG strsize2)
1157 {
1158     STUB;
1159 }
1160
1161 /*
1162  * @unimplemented
1163  */
1164 UINT WINAPI SetCPGlobal(UINT CodePage)
1165 {
1166     STUB;
1167     return 0;
1168 }
1169
1170 /*
1171  * @unimplemented
1172  */
1173 BOOL
1174 WINAPI
1175 SetClientTimeZoneInformation(
1176     CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation)
1177 {
1178     STUB;
1179     return 0;
1180 }
1181
1182 ULONG
1183 WINAPI
1184 NlsGetCacheUpdateCount(VOID)
1185 {
1186     STUB;
1187     return 0;
1188 }
1189
1190 BOOL
1191 WINAPI
1192 Wow64EnableWow64FsRedirection (BOOL Wow64EnableWow64FsRedirection)
1193 {
1194     STUB;
1195     return FALSE;
1196 }
1197
1198 BOOL
1199 WINAPI
1200 Wow64DisableWow64FsRedirection (VOID ** pv)
1201 {
1202     STUB;
1203     return FALSE;
1204 }
1205
1206 BOOL
1207 WINAPI
1208 Wow64RevertWow64FsRedirection (VOID * pv)
1209 {
1210     STUB;
1211     return FALSE;
1212 }
1213
1214 UINT
1215 WINAPI
1216 EnumSystemFirmwareTables(IN DWORD FirmwareTableProviderSignature,
1217                          OUT PVOID pFirmwareTableBuffer,
1218                          IN DWORD BufferSize)
1219 {
1220     STUB;
1221     return 0;
1222 }
1223
1224 BOOL
1225 WINAPI
1226 GetSystemFileCacheSize(OUT PSIZE_T lpMinimumFileCacheSize,
1227                        OUT PSIZE_T lpMaximumFileCacheSize,
1228                        OUT PDWORD lpFlags)
1229 {
1230     STUB;
1231     return FALSE;
1232 }
1233
1234 UINT
1235 WINAPI
1236 GetSystemFirmwareTable(IN DWORD FirmwareTableProviderSignature,
1237                        IN DWORD FirmwareTableID,
1238                        OUT PVOID pFirmwareTableBuffer,
1239                        IN DWORD BufferSize)
1240 {
1241     STUB;
1242     return 0;
1243 }
1244
1245 BOOL
1246 WINAPI
1247 SetSystemFileCacheSize(IN SIZE_T MinimumFileCacheSize,
1248                        IN SIZE_T MaximumFileCacheSize,
1249                        IN DWORD Flags)
1250 {
1251     STUB;
1252     return FALSE;
1253 }
1254
1255 BOOL
1256 WINAPI
1257 SetThreadStackGuarantee(IN OUT PULONG StackSizeInBytes)
1258 {
1259     STUB;
1260     return FALSE;
1261 }
1262
1263 HANDLE
1264 WINAPI
1265 ReOpenFile(IN HANDLE hOriginalFile,
1266            IN DWORD dwDesiredAccess,
1267            IN DWORD dwShareMode,
1268            IN DWORD dwFlags)
1269 {
1270     STUB;
1271     return INVALID_HANDLE_VALUE;
1272 }
1273
1274 BOOL
1275 WINAPI
1276 SetProcessWorkingSetSizeEx(IN HANDLE hProcess,
1277                            IN SIZE_T dwMinimumWorkingSetSize,
1278                            IN SIZE_T dwMaximumWorkingSetSize,
1279                            IN DWORD Flags)
1280 {
1281     STUB;
1282     return FALSE;
1283 }
1284
1285
1286 BOOL
1287 WINAPI
1288 GetProcessWorkingSetSizeEx(IN HANDLE hProcess,
1289                            OUT PSIZE_T lpMinimumWorkingSetSize,
1290                            OUT PSIZE_T lpMaximumWorkingSetSize,
1291                            OUT PDWORD Flags)
1292 {
1293     STUB;
1294     return FALSE;
1295 }
1296
1297 BOOL
1298 WINAPI
1299 GetLogicalProcessorInformation(OUT PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer,
1300                                IN OUT PDWORD ReturnLength)
1301 {
1302     STUB;
1303     return FALSE;
1304 }
1305
1306 BOOL
1307 WINAPI
1308 GetNumaAvailableMemoryNode(IN UCHAR Node,
1309                            OUT PULONGLONG AvailableBytes)
1310 {
1311     STUB;
1312     return FALSE;
1313 }