dlls/kernel32/process.c

   1 /*
   2  * Win32 processes
   3  *
   4  * Copyright 1996, 1998 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <assert.h>
  22 #include <ctype.h>
  23 #include <errno.h>
  24 #include <signal.h>
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #include <time.h>
  28
  29 #include "ntstatus.h"
  30 #define WIN32_NO_STATUS
  31 #include "winternl.h"
  32 #include "winbase.h"
  33 #include "winnls.h"
  34 #include "wincon.h"
  35 #include "kernel_private.h"
  36 #include "psapi.h"
  37 #include "ddk/wdm.h"
  38 #include "wine/exception.h"
  39 #include "wine/asm.h"
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(process);
  43
  44 static const struct _KUSER_SHARED_DATA *user_shared_data = (struct _KUSER_SHARED_DATA *)0x7ffe0000;
  45
  46 typedef struct
  47 {
  48     LPSTR lpEnvAddress;
  49     LPSTR lpCmdLine;
  50     LPSTR lpCmdShow;
  51     DWORD dwReserved;
  52 } LOADPARMS32;
  53
  54 SYSTEM_BASIC_INFORMATION system_info = { 0 };
  55
  56 /* Process flags */
  57 #define PDB32_DEBUGGED      0x0001  /* Process is being debugged */
  58 #define PDB32_WIN16_PROC    0x0008  /* Win16 process */
  59 #define PDB32_DOS_PROC      0x0010  /* Dos process */
  60 #define PDB32_CONSOLE_PROC  0x0020  /* Console process */
  61 #define PDB32_FILE_APIS_OEM 0x0040  /* File APIs are OEM */
  62 #define PDB32_WIN32S_PROC   0x8000  /* Win32s process */
  63
  64
  65 /***********************************************************************
  66  *           wait_input_idle
  67  *
  68  * Wrapper to call WaitForInputIdle USER function
  69  */
  70 typedef DWORD (WINAPI *WaitForInputIdle_ptr)( HANDLE hProcess, DWORD dwTimeOut );
  71
  72 static DWORD wait_input_idle( HANDLE process, DWORD timeout )
  73 {
  74     HMODULE mod = GetModuleHandleA( "user32.dll" );
  75     if (mod)
  76     {
  77         WaitForInputIdle_ptr ptr = (WaitForInputIdle_ptr)GetProcAddress( mod, "WaitForInputIdle" );
  78         if (ptr) return ptr( process, timeout );
  79     }
  80     return 0;
  81 }
  82
  83
  84 /***********************************************************************
  85  *           WinExec   (KERNEL32.@)
  86  */
  87 UINT WINAPI DECLSPEC_HOTPATCH WinExec( LPCSTR lpCmdLine, UINT nCmdShow )
  88 {
  89     PROCESS_INFORMATION info;
  90     STARTUPINFOA startup;
  91     char *cmdline;
  92     UINT ret;
  93
  94     memset( &startup, 0, sizeof(startup) );
  95     startup.cb = sizeof(startup);
  96     startup.dwFlags = STARTF_USESHOWWINDOW;
  97     startup.wShowWindow = nCmdShow;
  98
  99     /* cmdline needs to be writable for CreateProcess */
 100     if (!(cmdline = HeapAlloc( GetProcessHeap(), 0, strlen(lpCmdLine)+1 ))) return 0;
 101     strcpy( cmdline, lpCmdLine );
 102
 103     if (CreateProcessA( NULL, cmdline, NULL, NULL, FALSE,
 104                         0, NULL, NULL, &startup, &info ))
 105     {
 106         /* Give 30 seconds to the app to come up */
 107         if (wait_input_idle( info.hProcess, 30000 ) == WAIT_FAILED)
 108             WARN("WaitForInputIdle failed: Error %d\n", GetLastError() );
 109         ret = 33;
 110         /* Close off the handles */
 111         CloseHandle( info.hThread );
 112         CloseHandle( info.hProcess );
 113     }
 114     else if ((ret = GetLastError()) >= 32)
 115     {
 116         FIXME("Strange error set by CreateProcess: %d\n", ret );
 117         ret = 11;
 118     }
 119     HeapFree( GetProcessHeap(), 0, cmdline );
 120     return ret;
 121 }
 122
 123
 124 /**********************************************************************
 125  *          LoadModule    (KERNEL32.@)
 126  */
 127 DWORD WINAPI LoadModule( LPCSTR name, LPVOID paramBlock )
 128 {
 129     LOADPARMS32 *params = paramBlock;
 130     PROCESS_INFORMATION info;
 131     STARTUPINFOA startup;
 132     DWORD ret;
 133     LPSTR cmdline, p;
 134     char filename[MAX_PATH];
 135     BYTE len;
 136
 137     if (!name) return ERROR_FILE_NOT_FOUND;
 138
 139     if (!SearchPathA( NULL, name, ".exe", sizeof(filename), filename, NULL ) &&
 140         !SearchPathA( NULL, name, NULL, sizeof(filename), filename, NULL ))
 141         return GetLastError();
 142
 143     len = (BYTE)params->lpCmdLine[0];
 144     if (!(cmdline = HeapAlloc( GetProcessHeap(), 0, strlen(filename) + len + 2 )))
 145         return ERROR_NOT_ENOUGH_MEMORY;
 146
 147     strcpy( cmdline, filename );
 148     p = cmdline + strlen(cmdline);
 149     *p++ = ' ';
 150     memcpy( p, params->lpCmdLine + 1, len );
 151     p[len] = 0;
 152
 153     memset( &startup, 0, sizeof(startup) );
 154     startup.cb = sizeof(startup);
 155     if (params->lpCmdShow)
 156     {
 157         startup.dwFlags = STARTF_USESHOWWINDOW;
 158         startup.wShowWindow = ((WORD *)params->lpCmdShow)[1];
 159     }
 160
 161     if (CreateProcessA( filename, cmdline, NULL, NULL, FALSE, 0,
 162                         params->lpEnvAddress, NULL, &startup, &info ))
 163     {
 164         /* Give 30 seconds to the app to come up */
 165         if (wait_input_idle( info.hProcess, 30000 ) == WAIT_FAILED)
 166             WARN("WaitForInputIdle failed: Error %d\n", GetLastError() );
 167         ret = 33;
 168         /* Close off the handles */
 169         CloseHandle( info.hThread );
 170         CloseHandle( info.hProcess );
 171     }
 172     else if ((ret = GetLastError()) >= 32)
 173     {
 174         FIXME("Strange error set by CreateProcess: %u\n", ret );
 175         ret = 11;
 176     }
 177
 178     HeapFree( GetProcessHeap(), 0, cmdline );
 179     return ret;
 180 }
 181
 182
 183 /***********************************************************************
 184  *           ExitProcess   (KERNEL32.@)
 185  *
 186  * Exits the current process.
 187  *
 188  * PARAMS
 189  *  status [I] Status code to exit with.
 190  *
 191  * RETURNS
 192  *  Nothing.
 193  */
 194 #ifdef __i386__
 195 __ASM_STDCALL_FUNC( ExitProcess, 4, /* Shrinker depend on this particular ExitProcess implementation */
 196                    "pushl %ebp\n\t"
 197                    ".byte 0x8B, 0xEC\n\t" /* movl %esp, %ebp */
 198                    ".byte 0x6A, 0x00\n\t" /* pushl $0 */
 199                    ".byte 0x68, 0x00, 0x00, 0x00, 0x00\n\t" /* pushl $0 - 4 bytes immediate */
 200                    "pushl 8(%ebp)\n\t"
 201                    "call " __ASM_STDCALL("RtlExitUserProcess",4) "\n\t"
 202                    "leave\n\t"
 203                    "ret $4" )
 204 #else
 205
 206 void WINAPI ExitProcess( DWORD status )
 207 {
 208     RtlExitUserProcess( status );
 209 }
 210
 211 #endif
 212
 213 /***********************************************************************
 214  * GetExitCodeProcess           [KERNEL32.@]
 215  *
 216  * Gets termination status of specified process.
 217  *
 218  * PARAMS
 219  *   hProcess   [in]  Handle to the process.
 220  *   lpExitCode [out] Address to receive termination status.
 221  *
 222  * RETURNS
 223  *   Success: TRUE
 224  *   Failure: FALSE
 225  */
 226 BOOL WINAPI GetExitCodeProcess( HANDLE hProcess, LPDWORD lpExitCode )
 227 {
 228     PROCESS_BASIC_INFORMATION pbi;
 229
 230     if (!set_ntstatus( NtQueryInformationProcess( hProcess, ProcessBasicInformation, &pbi, sizeof(pbi), NULL )))
 231         return FALSE;
 232     if (lpExitCode) *lpExitCode = pbi.ExitStatus;
 233     return TRUE;
 234 }
 235
 236
 237 /**************************************************************************
 238  *           FatalExit   (KERNEL32.@)
 239  */
 240 void WINAPI FatalExit( int code )
 241 {
 242     WARN( "FatalExit\n" );
 243     ExitProcess( code );
 244 }
 245
 246
 247 /***********************************************************************
 248  *           GetProcessFlags    (KERNEL32.@)
 249  */
 250 DWORD WINAPI GetProcessFlags( DWORD processid )
 251 {
 252     IMAGE_NT_HEADERS *nt;
 253     DWORD flags = 0;
 254
 255     if (processid && processid != GetCurrentProcessId()) return 0;
 256
 257     if ((nt = RtlImageNtHeader( NtCurrentTeb()->Peb->ImageBaseAddress )))
 258     {
 259         if (nt->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI)
 260             flags |= PDB32_CONSOLE_PROC;
 261     }
 262     if (!AreFileApisANSI()) flags |= PDB32_FILE_APIS_OEM;
 263     if (IsDebuggerPresent()) flags |= PDB32_DEBUGGED;
 264     return flags;
 265 }
 266
 267
 268 /***********************************************************************
 269  *           ConvertToGlobalHandle  (KERNEL32.@)
 270  */
 271 HANDLE WINAPI ConvertToGlobalHandle(HANDLE hSrc)
 272 {
 273     HANDLE ret = INVALID_HANDLE_VALUE;
 274     DuplicateHandle( GetCurrentProcess(), hSrc, GetCurrentProcess(), &ret, 0, FALSE,
 275                      DUPLICATE_MAKE_GLOBAL | DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE );
 276     return ret;
 277 }
 278
 279
 280 /***********************************************************************
 281  *           SetHandleContext   (KERNEL32.@)
 282  */
 283 BOOL WINAPI SetHandleContext(HANDLE hnd,DWORD context)
 284 {
 285     FIXME("(%p,%d), stub. In case this got called by WSOCK32/WS2_32: "
 286           "the external WINSOCK DLLs won't work with WINE, don't use them.\n",hnd,context);
 287     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 288     return FALSE;
 289 }
 290
 291
 292 /***********************************************************************
 293  *           GetHandleContext   (KERNEL32.@)
 294  */
 295 DWORD WINAPI GetHandleContext(HANDLE hnd)
 296 {
 297     FIXME("(%p), stub. In case this got called by WSOCK32/WS2_32: "
 298           "the external WINSOCK DLLs won't work with WINE, don't use them.\n",hnd);
 299     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 300     return 0;
 301 }
 302
 303
 304 /***********************************************************************
 305  *           CreateSocketHandle   (KERNEL32.@)
 306  */
 307 HANDLE WINAPI CreateSocketHandle(void)
 308 {
 309     FIXME("(), stub. In case this got called by WSOCK32/WS2_32: "
 310           "the external WINSOCK DLLs won't work with WINE, don't use them.\n");
 311     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 312     return INVALID_HANDLE_VALUE;
 313 }
 314
 315
 316 /***********************************************************************
 317  *          SetProcessAffinityMask   (KERNEL32.@)
 318  */
 319 BOOL WINAPI SetProcessAffinityMask( HANDLE hProcess, DWORD_PTR affmask )
 320 {
 321     return set_ntstatus( NtSetInformationProcess( hProcess, ProcessAffinityMask,
 322                                                   &affmask, sizeof(DWORD_PTR) ));
 323 }
 324
 325
 326 /**********************************************************************
 327  *          GetProcessAffinityMask    (KERNEL32.@)
 328  */
 329 BOOL WINAPI GetProcessAffinityMask( HANDLE hProcess, PDWORD_PTR process_mask, PDWORD_PTR system_mask )
 330 {
 331     if (process_mask)
 332     {
 333         if (!set_ntstatus( NtQueryInformationProcess( hProcess, ProcessAffinityMask,
 334                                                       process_mask, sizeof(*process_mask), NULL )))
 335             return FALSE;
 336     }
 337     if (system_mask)
 338     {
 339         SYSTEM_BASIC_INFORMATION info;
 340
 341         if (!set_ntstatus( NtQuerySystemInformation( SystemBasicInformation, &info, sizeof(info), NULL )))
 342             return FALSE;
 343         *system_mask = info.ActiveProcessorsAffinityMask;
 344     }
 345     return TRUE;
 346 }
 347
 348
 349 /***********************************************************************
 350  *              SetProcessWorkingSetSize        [KERNEL32.@]
 351  * Sets the min/max working set sizes for a specified process.
 352  *
 353  * PARAMS
 354  *    process  [I] Handle to the process of interest
 355  *    minset   [I] Specifies minimum working set size
 356  *    maxset   [I] Specifies maximum working set size
 357  *
 358  * RETURNS
 359  *  Success: TRUE
 360  *  Failure: FALSE
 361  */
 362 BOOL WINAPI SetProcessWorkingSetSize(HANDLE process, SIZE_T minset, SIZE_T maxset)
 363 {
 364     return SetProcessWorkingSetSizeEx(process, minset, maxset, 0);
 365 }
 366
 367 /***********************************************************************
 368  *           GetProcessWorkingSetSize    (KERNEL32.@)
 369  */
 370 BOOL WINAPI GetProcessWorkingSetSize(HANDLE process, SIZE_T *minset, SIZE_T *maxset)
 371 {
 372     return GetProcessWorkingSetSizeEx(process, minset, maxset, NULL);
 373 }
 374
 375
 376 /******************************************************************
 377  *              GetProcessIoCounters (KERNEL32.@)
 378  */
 379 BOOL WINAPI GetProcessIoCounters(HANDLE hProcess, PIO_COUNTERS ioc)
 380 {
 381     return set_ntstatus( NtQueryInformationProcess(hProcess, ProcessIoCounters, ioc, sizeof(*ioc), NULL ));
 382 }
 383
 384 /***********************************************************************
 385  *              RegisterServiceProcess (KERNEL32.@)
 386  *
 387  * A service process calls this function to ensure that it continues to run
 388  * even after a user logged off.
 389  */
 390 DWORD WINAPI RegisterServiceProcess(DWORD dwProcessId, DWORD dwType)
 391 {
 392     /* I don't think that Wine needs to do anything in this function */
 393     return 1; /* success */
 394 }
 395
 396
 397 /***********************************************************************
 398  *           GetCurrentProcess   (KERNEL32.@)
 399  *
 400  * Get a handle to the current process.
 401  *
 402  * PARAMS
 403  *  None.
 404  *
 405  * RETURNS
 406  *  A handle representing the current process.
 407  */
 408 HANDLE WINAPI KERNEL32_GetCurrentProcess(void)
 409 {
 410     return (HANDLE)~(ULONG_PTR)0;
 411 }
 412
 413
 414 /***********************************************************************
 415  *           CreateActCtxA   (KERNEL32.@)
 416  */
 417 HANDLE WINAPI DECLSPEC_HOTPATCH CreateActCtxA( const ACTCTXA *actctx )
 418 {
 419     ACTCTXW actw;
 420     SIZE_T len;
 421     HANDLE ret = INVALID_HANDLE_VALUE;
 422     LPWSTR src = NULL, assdir = NULL, resname = NULL, appname = NULL;
 423
 424     TRACE("%p %08x\n", actctx, actctx ? actctx->dwFlags : 0);
 425
 426     if (!actctx || actctx->cbSize != sizeof(*actctx))
 427     {
 428         SetLastError(ERROR_INVALID_PARAMETER);
 429         return INVALID_HANDLE_VALUE;
 430     }
 431
 432     actw.cbSize = sizeof(actw);
 433     actw.dwFlags = actctx->dwFlags;
 434     if (actctx->lpSource)
 435     {
 436         len = MultiByteToWideChar(CP_ACP, 0, actctx->lpSource, -1, NULL, 0);
 437         src = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 438         if (!src) return INVALID_HANDLE_VALUE;
 439         MultiByteToWideChar(CP_ACP, 0, actctx->lpSource, -1, src, len);
 440     }
 441     actw.lpSource = src;
 442
 443     if (actw.dwFlags & ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID)
 444         actw.wProcessorArchitecture = actctx->wProcessorArchitecture;
 445     if (actw.dwFlags & ACTCTX_FLAG_LANGID_VALID)
 446         actw.wLangId = actctx->wLangId;
 447     if (actw.dwFlags & ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID)
 448     {
 449         len = MultiByteToWideChar(CP_ACP, 0, actctx->lpAssemblyDirectory, -1, NULL, 0);
 450         assdir = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 451         if (!assdir) goto done;
 452         MultiByteToWideChar(CP_ACP, 0, actctx->lpAssemblyDirectory, -1, assdir, len);
 453         actw.lpAssemblyDirectory = assdir;
 454     }
 455     if (actw.dwFlags & ACTCTX_FLAG_RESOURCE_NAME_VALID)
 456     {
 457         if ((ULONG_PTR)actctx->lpResourceName >> 16)
 458         {
 459             len = MultiByteToWideChar(CP_ACP, 0, actctx->lpResourceName, -1, NULL, 0);
 460             resname = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 461             if (!resname) goto done;
 462             MultiByteToWideChar(CP_ACP, 0, actctx->lpResourceName, -1, resname, len);
 463             actw.lpResourceName = resname;
 464         }
 465         else actw.lpResourceName = (LPCWSTR)actctx->lpResourceName;
 466     }
 467     if (actw.dwFlags & ACTCTX_FLAG_APPLICATION_NAME_VALID)
 468     {
 469         len = MultiByteToWideChar(CP_ACP, 0, actctx->lpApplicationName, -1, NULL, 0);
 470         appname = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 471         if (!appname) goto done;
 472         MultiByteToWideChar(CP_ACP, 0, actctx->lpApplicationName, -1, appname, len);
 473         actw.lpApplicationName = appname;
 474     }
 475     if (actw.dwFlags & ACTCTX_FLAG_HMODULE_VALID)
 476         actw.hModule = actctx->hModule;
 477
 478     ret = CreateActCtxW(&actw);
 479
 480 done:
 481     HeapFree(GetProcessHeap(), 0, src);
 482     HeapFree(GetProcessHeap(), 0, assdir);
 483     HeapFree(GetProcessHeap(), 0, resname);
 484     HeapFree(GetProcessHeap(), 0, appname);
 485     return ret;
 486 }
 487
 488 /***********************************************************************
 489  *           FindActCtxSectionStringA   (KERNEL32.@)
 490  */
 491 BOOL WINAPI FindActCtxSectionStringA( DWORD flags, const GUID *guid, ULONG id, const char *search,
 492                                       ACTCTX_SECTION_KEYED_DATA *info )
 493 {
 494     LPWSTR searchW;
 495     DWORD len;
 496     BOOL ret;
 497
 498     TRACE("%08x %s %u %s %p\n", flags, debugstr_guid(guid), id, debugstr_a(search), info);
 499
 500     if (!search || !info)
 501     {
 502         SetLastError(ERROR_INVALID_PARAMETER);
 503         return FALSE;
 504     }
 505     len = MultiByteToWideChar(CP_ACP, 0, search, -1, NULL, 0);
 506     searchW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 507     MultiByteToWideChar(CP_ACP, 0, search, -1, searchW, len);
 508     ret = FindActCtxSectionStringW( flags, guid, id, searchW, info );
 509     HeapFree(GetProcessHeap(), 0, searchW);
 510     return ret;
 511 }
 512
 513
 514 /***********************************************************************
 515  *           CmdBatNotification   (KERNEL32.@)
 516  *
 517  * Notifies the system that a batch file has started or finished.
 518  *
 519  * PARAMS
 520  *  bBatchRunning [I]  TRUE if a batch file has started or
 521  *                     FALSE if a batch file has finished executing.
 522  *
 523  * RETURNS
 524  *  Unknown.
 525  */
 526 BOOL WINAPI CmdBatNotification( BOOL bBatchRunning )
 527 {
 528     FIXME("%d\n", bBatchRunning);
 529     return FALSE;
 530 }
 531
 532 /***********************************************************************
 533  *           RegisterApplicationRestart       (KERNEL32.@)
 534  */
 535 HRESULT WINAPI RegisterApplicationRestart(PCWSTR pwzCommandLine, DWORD dwFlags)
 536 {
 537     FIXME("(%s,%d)\n", debugstr_w(pwzCommandLine), dwFlags);
 538
 539     return S_OK;
 540 }
 541
 542 /**********************************************************************
 543  *           WTSGetActiveConsoleSessionId     (KERNEL32.@)
 544  */
 545 DWORD WINAPI WTSGetActiveConsoleSessionId(void)
 546 {
 547     static int once;
 548     if (!once++) FIXME("stub\n");
 549     /* Return current session id. */
 550     return NtCurrentTeb()->Peb->SessionId;
 551 }
 552
 553 /**********************************************************************
 554  *           GetSystemDEPPolicy     (KERNEL32.@)
 555  */
 556 DEP_SYSTEM_POLICY_TYPE WINAPI GetSystemDEPPolicy(void)
 557 {
 558     return user_shared_data->NXSupportPolicy;
 559 }
 560
 561 /**********************************************************************
 562  *           SetProcessDEPPolicy     (KERNEL32.@)
 563  */
 564 BOOL WINAPI SetProcessDEPPolicy( DWORD flags )
 565 {
 566     ULONG dep_flags = 0;
 567
 568     TRACE("%#x\n", flags);
 569
 570     if (flags & PROCESS_DEP_ENABLE)
 571         dep_flags |= MEM_EXECUTE_OPTION_DISABLE | MEM_EXECUTE_OPTION_PERMANENT;
 572     if (flags & PROCESS_DEP_DISABLE_ATL_THUNK_EMULATION)
 573         dep_flags |= MEM_EXECUTE_OPTION_DISABLE_THUNK_EMULATION;
 574
 575     return set_ntstatus( NtSetInformationProcess( GetCurrentProcess(), ProcessExecuteFlags,
 576                                                   &dep_flags, sizeof(dep_flags) ) );
 577 }
 578
 579 /**********************************************************************
 580  *           ApplicationRecoveryFinished     (KERNEL32.@)
 581  */
 582 VOID WINAPI ApplicationRecoveryFinished(BOOL success)
 583 {
 584     FIXME(": stub\n");
 585     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 586 }
 587
 588 /**********************************************************************
 589  *           ApplicationRecoveryInProgress     (KERNEL32.@)
 590  */
 591 HRESULT WINAPI ApplicationRecoveryInProgress(PBOOL canceled)
 592 {
 593     FIXME(":%p stub\n", canceled);
 594     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 595     return E_FAIL;
 596 }
 597
 598 /**********************************************************************
 599  *           RegisterApplicationRecoveryCallback     (KERNEL32.@)
 600  */
 601 HRESULT WINAPI RegisterApplicationRecoveryCallback(APPLICATION_RECOVERY_CALLBACK callback, PVOID param, DWORD pingint, DWORD flags)
 602 {
 603     FIXME("%p, %p, %d, %d: stub, faking success\n", callback, param, pingint, flags);
 604     return S_OK;
 605 }
 606
 607 /***********************************************************************
 608  *           GetActiveProcessorGroupCount (KERNEL32.@)
 609  */
 610 WORD WINAPI GetActiveProcessorGroupCount(void)
 611 {
 612     FIXME("semi-stub, always returning 1\n");
 613     return 1;
 614 }
 615
 616 /***********************************************************************
 617  *           GetActiveProcessorCount (KERNEL32.@)
 618  */
 619 DWORD WINAPI GetActiveProcessorCount(WORD group)
 620 {
 621     DWORD cpus = system_info.NumberOfProcessors;
 622
 623     FIXME("semi-stub, returning %u\n", cpus);
 624     return cpus;
 625 }
 626
 627 /***********************************************************************
 628  *           GetMaximumProcessorCount (KERNEL32.@)
 629  */
 630 DWORD WINAPI GetMaximumProcessorCount(WORD group)
 631 {
 632     DWORD cpus = system_info.NumberOfProcessors;
 633
 634     FIXME("semi-stub, returning %u\n", cpus);
 635     return cpus;
 636 }
 637
 638 /***********************************************************************
 639  *           GetFirmwareEnvironmentVariableA     (KERNEL32.@)
 640  */
 641 DWORD WINAPI GetFirmwareEnvironmentVariableA(LPCSTR name, LPCSTR guid, PVOID buffer, DWORD size)
 642 {
 643     FIXME("stub: %s %s %p %u\n", debugstr_a(name), debugstr_a(guid), buffer, size);
 644     SetLastError(ERROR_INVALID_FUNCTION);
 645     return 0;
 646 }
 647
 648 /***********************************************************************
 649  *           GetFirmwareEnvironmentVariableW     (KERNEL32.@)
 650  */
 651 DWORD WINAPI GetFirmwareEnvironmentVariableW(LPCWSTR name, LPCWSTR guid, PVOID buffer, DWORD size)
 652 {
 653     FIXME("stub: %s %s %p %u\n", debugstr_w(name), debugstr_w(guid), buffer, size);
 654     SetLastError(ERROR_INVALID_FUNCTION);
 655     return 0;
 656 }
 657
 658 /***********************************************************************
 659  *           SetFirmwareEnvironmentVariableW     (KERNEL32.@)
 660  */
 661 BOOL WINAPI SetFirmwareEnvironmentVariableW(const WCHAR *name, const WCHAR *guid, void *buffer, DWORD size)
 662 {
 663     FIXME("stub: %s %s %p %u\n", debugstr_w(name), debugstr_w(guid), buffer, size);
 664     SetLastError(ERROR_INVALID_FUNCTION);
 665     return FALSE;
 666 }
 667
 668 /**********************************************************************
 669  *           GetNumaNodeProcessorMask     (KERNEL32.@)
 670  */
 671 BOOL WINAPI GetNumaNodeProcessorMask(UCHAR node, PULONGLONG mask)
 672 {
 673     FIXME("(%c %p): stub\n", node, mask);
 674     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 675     return FALSE;
 676 }
 677
 678 /**********************************************************************
 679  *           GetNumaAvailableMemoryNode     (KERNEL32.@)
 680  */
 681 BOOL WINAPI GetNumaAvailableMemoryNode(UCHAR node, PULONGLONG available_bytes)
 682 {
 683     FIXME("(%c %p): stub\n", node, available_bytes);
 684     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 685     return FALSE;
 686 }
 687
 688 /**********************************************************************
 689  *           GetNumaAvailableMemoryNodeEx     (KERNEL32.@)
 690  */
 691 BOOL WINAPI GetNumaAvailableMemoryNodeEx(USHORT node, PULONGLONG available_bytes)
 692 {
 693     FIXME("(%hu %p): stub\n", node, available_bytes);
 694     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 695     return FALSE;
 696 }
 697
 698 /***********************************************************************
 699  *           GetNumaProcessorNode (KERNEL32.@)
 700  */
 701 BOOL WINAPI GetNumaProcessorNode(UCHAR processor, PUCHAR node)
 702 {
 703     TRACE("(%d, %p)\n", processor, node);
 704
 705     if (processor < system_info.NumberOfProcessors)
 706     {
 707         *node = 0;
 708         return TRUE;
 709     }
 710
 711     *node = 0xFF;
 712     SetLastError(ERROR_INVALID_PARAMETER);
 713     return FALSE;
 714 }
 715
 716 /***********************************************************************
 717  *           GetNumaProcessorNodeEx (KERNEL32.@)
 718  */
 719 BOOL WINAPI GetNumaProcessorNodeEx(PPROCESSOR_NUMBER processor, PUSHORT node_number)
 720 {
 721     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 722     return FALSE;
 723 }
 724
 725 /***********************************************************************
 726  *           GetNumaProximityNode (KERNEL32.@)
 727  */
 728 BOOL WINAPI GetNumaProximityNode(ULONG  proximity_id, PUCHAR node_number)
 729 {
 730     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 731     return FALSE;
 732 }
 733
 734 /**********************************************************************
 735  *           GetProcessDEPPolicy     (KERNEL32.@)
 736  */
 737 BOOL WINAPI GetProcessDEPPolicy(HANDLE process, LPDWORD flags, PBOOL permanent)
 738 {
 739     ULONG dep_flags;
 740
 741     TRACE("(%p %p %p)\n", process, flags, permanent);
 742
 743     if (!set_ntstatus( NtQueryInformationProcess( GetCurrentProcess(), ProcessExecuteFlags,
 744                                                   &dep_flags, sizeof(dep_flags), NULL )))
 745         return FALSE;
 746
 747     if (flags)
 748     {
 749         *flags = 0;
 750         if (dep_flags & MEM_EXECUTE_OPTION_DISABLE)
 751             *flags |= PROCESS_DEP_ENABLE;
 752         if (dep_flags & MEM_EXECUTE_OPTION_DISABLE_THUNK_EMULATION)
 753             *flags |= PROCESS_DEP_DISABLE_ATL_THUNK_EMULATION;
 754     }
 755
 756     if (permanent) *permanent = (dep_flags & MEM_EXECUTE_OPTION_PERMANENT) != 0;
 757     return TRUE;
 758 }
 759
 760 /***********************************************************************
 761  *           UnregisterApplicationRestart       (KERNEL32.@)
 762  */
 763 HRESULT WINAPI UnregisterApplicationRestart(void)
 764 {
 765     FIXME(": stub\n");
 766     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 767     return S_OK;
 768 }
 769
 770 /***********************************************************************
 771  *           CreateUmsCompletionList   (KERNEL32.@)
 772  */
 773 BOOL WINAPI CreateUmsCompletionList(PUMS_COMPLETION_LIST *list)
 774 {
 775     FIXME( "%p: stub\n", list );
 776     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 777     return FALSE;
 778 }
 779
 780 /***********************************************************************
 781  *           CreateUmsThreadContext   (KERNEL32.@)
 782  */
 783 BOOL WINAPI CreateUmsThreadContext(PUMS_CONTEXT *ctx)
 784 {
 785     FIXME( "%p: stub\n", ctx );
 786     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 787     return FALSE;
 788 }
 789
 790 /***********************************************************************
 791  *           DeleteUmsCompletionList   (KERNEL32.@)
 792  */
 793 BOOL WINAPI DeleteUmsCompletionList(PUMS_COMPLETION_LIST list)
 794 {
 795     FIXME( "%p: stub\n", list );
 796     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 797     return FALSE;
 798 }
 799
 800 /***********************************************************************
 801  *           DeleteUmsThreadContext   (KERNEL32.@)
 802  */
 803 BOOL WINAPI DeleteUmsThreadContext(PUMS_CONTEXT ctx)
 804 {
 805     FIXME( "%p: stub\n", ctx );
 806     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 807     return FALSE;
 808 }
 809
 810 /***********************************************************************
 811  *           DequeueUmsCompletionListItems   (KERNEL32.@)
 812  */
 813 BOOL WINAPI DequeueUmsCompletionListItems(void *list, DWORD timeout, PUMS_CONTEXT *ctx)
 814 {
 815     FIXME( "%p,%08x,%p: stub\n", list, timeout, ctx );
 816     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 817     return FALSE;
 818 }
 819
 820 /***********************************************************************
 821  *           EnterUmsSchedulingMode   (KERNEL32.@)
 822  */
 823 BOOL WINAPI EnterUmsSchedulingMode(UMS_SCHEDULER_STARTUP_INFO *info)
 824 {
 825     FIXME( "%p: stub\n", info );
 826     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 827     return FALSE;
 828 }
 829
 830 /***********************************************************************
 831  *           ExecuteUmsThread   (KERNEL32.@)
 832  */
 833 BOOL WINAPI ExecuteUmsThread(PUMS_CONTEXT ctx)
 834 {
 835     FIXME( "%p: stub\n", ctx );
 836     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 837     return FALSE;
 838 }
 839
 840 /***********************************************************************
 841  *           GetCurrentUmsThread   (KERNEL32.@)
 842  */
 843 PUMS_CONTEXT WINAPI GetCurrentUmsThread(void)
 844 {
 845     FIXME( "stub\n" );
 846     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 847     return FALSE;
 848 }
 849
 850 /***********************************************************************
 851  *           GetNextUmsListItem   (KERNEL32.@)
 852  */
 853 PUMS_CONTEXT WINAPI GetNextUmsListItem(PUMS_CONTEXT ctx)
 854 {
 855     FIXME( "%p: stub\n", ctx );
 856     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 857     return NULL;
 858 }
 859
 860 /***********************************************************************
 861  *           GetUmsCompletionListEvent   (KERNEL32.@)
 862  */
 863 BOOL WINAPI GetUmsCompletionListEvent(PUMS_COMPLETION_LIST list, HANDLE *event)
 864 {
 865     FIXME( "%p,%p: stub\n", list, event );
 866     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 867     return FALSE;
 868 }
 869
 870 /***********************************************************************
 871  *           QueryUmsThreadInformation   (KERNEL32.@)
 872  */
 873 BOOL WINAPI QueryUmsThreadInformation(PUMS_CONTEXT ctx, UMS_THREAD_INFO_CLASS class,
 874                                        void *buf, ULONG length, ULONG *ret_length)
 875 {
 876     FIXME( "%p,%08x,%p,%08x,%p: stub\n", ctx, class, buf, length, ret_length );
 877     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 878     return FALSE;
 879 }
 880
 881 /***********************************************************************
 882  *           SetUmsThreadInformation   (KERNEL32.@)
 883  */
 884 BOOL WINAPI SetUmsThreadInformation(PUMS_CONTEXT ctx, UMS_THREAD_INFO_CLASS class,
 885                                      void *buf, ULONG length)
 886 {
 887     FIXME( "%p,%08x,%p,%08x: stub\n", ctx, class, buf, length );
 888     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 889     return FALSE;
 890 }
 891
 892 /***********************************************************************
 893  *           UmsThreadYield   (KERNEL32.@)
 894  */
 895 BOOL WINAPI UmsThreadYield(void *param)
 896 {
 897     FIXME( "%p: stub\n", param );
 898     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 899     return FALSE;
 900 }