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     WORD groups;
 613     DWORD size = 0;
 614     SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *info;
 615
 616     TRACE("()\n");
 617
 618     if (!GetLogicalProcessorInformationEx(RelationGroup, NULL, &size)) return 0;
 619     if (!(info = HeapAlloc(GetProcessHeap(), 0, size))) return 0;
 620     if (!GetLogicalProcessorInformationEx(RelationGroup, info, &size))
 621     {
 622         HeapFree(GetProcessHeap(), 0, info);
 623         return 0;
 624     }
 625
 626     groups = info->Group.ActiveGroupCount;
 627
 628     HeapFree(GetProcessHeap(), 0, info);
 629     return groups;
 630 }
 631
 632 /***********************************************************************
 633  *           GetActiveProcessorCount (KERNEL32.@)
 634  */
 635 DWORD WINAPI GetActiveProcessorCount(WORD group)
 636 {
 637     DWORD cpus = 0;
 638     DWORD size = 0;
 639     SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *info;
 640
 641     TRACE("(0x%x)\n", group);
 642
 643     if (!GetLogicalProcessorInformationEx(RelationGroup, NULL, &size)) return 0;
 644     if (!(info = HeapAlloc(GetProcessHeap(), 0, size))) return 0;
 645     if (!GetLogicalProcessorInformationEx(RelationGroup, info, &size))
 646     {
 647         HeapFree(GetProcessHeap(), 0, info);
 648         return 0;
 649     }
 650
 651     if (group == ALL_PROCESSOR_GROUPS)
 652     {
 653         for (group = 0; group < info->Group.ActiveGroupCount; group++)
 654             cpus += info->Group.GroupInfo[group].ActiveProcessorCount;
 655     }
 656     else
 657     {
 658         if (group < info->Group.ActiveGroupCount)
 659             cpus = info->Group.GroupInfo[group].ActiveProcessorCount;
 660     }
 661
 662     HeapFree(GetProcessHeap(), 0, info);
 663     return cpus;
 664 }
 665
 666 /***********************************************************************
 667  *           GetMaximumProcessorCount (KERNEL32.@)
 668  */
 669 DWORD WINAPI GetMaximumProcessorCount(WORD group)
 670 {
 671     DWORD cpus = 0;
 672     DWORD size = 0;
 673     SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *info;
 674
 675     TRACE("(0x%x)\n", group);
 676
 677     if (!GetLogicalProcessorInformationEx(RelationGroup, NULL, &size)) return 0;
 678     if (!(info = HeapAlloc(GetProcessHeap(), 0, size))) return 0;
 679     if (!GetLogicalProcessorInformationEx(RelationGroup, info, &size))
 680     {
 681         HeapFree(GetProcessHeap(), 0, info);
 682         return 0;
 683     }
 684
 685     if (group == ALL_PROCESSOR_GROUPS)
 686     {
 687         for (group = 0; group < info->Group.ActiveGroupCount; group++)
 688             cpus += info->Group.GroupInfo[group].MaximumProcessorCount;
 689     }
 690     else
 691     {
 692         if (group < info->Group.ActiveGroupCount)
 693             cpus = info->Group.GroupInfo[group].MaximumProcessorCount;
 694     }
 695
 696     HeapFree(GetProcessHeap(), 0, info);
 697     return cpus;
 698 }
 699
 700 /***********************************************************************
 701  *           GetMaximumProcessorGroupCount (KERNEL32.@)
 702  */
 703 WORD WINAPI GetMaximumProcessorGroupCount(void)
 704 {
 705     FIXME("semi-stub, always returning 1\n");
 706     return 1;
 707 }
 708
 709 /***********************************************************************
 710  *           GetFirmwareEnvironmentVariableA     (KERNEL32.@)
 711  */
 712 DWORD WINAPI GetFirmwareEnvironmentVariableA(LPCSTR name, LPCSTR guid, PVOID buffer, DWORD size)
 713 {
 714     FIXME("stub: %s %s %p %u\n", debugstr_a(name), debugstr_a(guid), buffer, size);
 715     SetLastError(ERROR_INVALID_FUNCTION);
 716     return 0;
 717 }
 718
 719 /***********************************************************************
 720  *           GetFirmwareEnvironmentVariableW     (KERNEL32.@)
 721  */
 722 DWORD WINAPI GetFirmwareEnvironmentVariableW(LPCWSTR name, LPCWSTR guid, PVOID buffer, DWORD size)
 723 {
 724     FIXME("stub: %s %s %p %u\n", debugstr_w(name), debugstr_w(guid), buffer, size);
 725     SetLastError(ERROR_INVALID_FUNCTION);
 726     return 0;
 727 }
 728
 729 /***********************************************************************
 730  *           SetFirmwareEnvironmentVariableW     (KERNEL32.@)
 731  */
 732 BOOL WINAPI SetFirmwareEnvironmentVariableW(const WCHAR *name, const WCHAR *guid, void *buffer, DWORD size)
 733 {
 734     FIXME("stub: %s %s %p %u\n", debugstr_w(name), debugstr_w(guid), buffer, size);
 735     SetLastError(ERROR_INVALID_FUNCTION);
 736     return FALSE;
 737 }
 738
 739 /**********************************************************************
 740  *           GetNumaNodeProcessorMask     (KERNEL32.@)
 741  */
 742 BOOL WINAPI GetNumaNodeProcessorMask(UCHAR node, PULONGLONG mask)
 743 {
 744     FIXME("(%c %p): stub\n", node, mask);
 745     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 746     return FALSE;
 747 }
 748
 749 /**********************************************************************
 750  *           GetNumaAvailableMemoryNode     (KERNEL32.@)
 751  */
 752 BOOL WINAPI GetNumaAvailableMemoryNode(UCHAR node, PULONGLONG available_bytes)
 753 {
 754     FIXME("(%c %p): stub\n", node, available_bytes);
 755     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 756     return FALSE;
 757 }
 758
 759 /**********************************************************************
 760  *           GetNumaAvailableMemoryNodeEx     (KERNEL32.@)
 761  */
 762 BOOL WINAPI GetNumaAvailableMemoryNodeEx(USHORT node, PULONGLONG available_bytes)
 763 {
 764     FIXME("(%hu %p): stub\n", node, available_bytes);
 765     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 766     return FALSE;
 767 }
 768
 769 /***********************************************************************
 770  *           GetNumaProcessorNode (KERNEL32.@)
 771  */
 772 BOOL WINAPI GetNumaProcessorNode(UCHAR processor, PUCHAR node)
 773 {
 774     TRACE("(%d, %p)\n", processor, node);
 775
 776     if (processor < system_info.NumberOfProcessors)
 777     {
 778         *node = 0;
 779         return TRUE;
 780     }
 781
 782     *node = 0xFF;
 783     SetLastError(ERROR_INVALID_PARAMETER);
 784     return FALSE;
 785 }
 786
 787 /***********************************************************************
 788  *           GetNumaProcessorNodeEx (KERNEL32.@)
 789  */
 790 BOOL WINAPI GetNumaProcessorNodeEx(PPROCESSOR_NUMBER processor, PUSHORT node_number)
 791 {
 792     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 793     return FALSE;
 794 }
 795
 796 /***********************************************************************
 797  *           GetNumaProximityNode (KERNEL32.@)
 798  */
 799 BOOL WINAPI GetNumaProximityNode(ULONG  proximity_id, PUCHAR node_number)
 800 {
 801     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 802     return FALSE;
 803 }
 804
 805 /**********************************************************************
 806  *           GetProcessDEPPolicy     (KERNEL32.@)
 807  */
 808 BOOL WINAPI GetProcessDEPPolicy(HANDLE process, LPDWORD flags, PBOOL permanent)
 809 {
 810     ULONG dep_flags;
 811
 812     TRACE("(%p %p %p)\n", process, flags, permanent);
 813
 814     if (!set_ntstatus( NtQueryInformationProcess( GetCurrentProcess(), ProcessExecuteFlags,
 815                                                   &dep_flags, sizeof(dep_flags), NULL )))
 816         return FALSE;
 817
 818     if (flags)
 819     {
 820         *flags = 0;
 821         if (dep_flags & MEM_EXECUTE_OPTION_DISABLE)
 822             *flags |= PROCESS_DEP_ENABLE;
 823         if (dep_flags & MEM_EXECUTE_OPTION_DISABLE_THUNK_EMULATION)
 824             *flags |= PROCESS_DEP_DISABLE_ATL_THUNK_EMULATION;
 825     }
 826
 827     if (permanent) *permanent = (dep_flags & MEM_EXECUTE_OPTION_PERMANENT) != 0;
 828     return TRUE;
 829 }
 830
 831 /***********************************************************************
 832  *           UnregisterApplicationRestart       (KERNEL32.@)
 833  */
 834 HRESULT WINAPI UnregisterApplicationRestart(void)
 835 {
 836     FIXME(": stub\n");
 837     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 838     return S_OK;
 839 }
 840
 841 /***********************************************************************
 842  *           CreateUmsCompletionList   (KERNEL32.@)
 843  */
 844 BOOL WINAPI CreateUmsCompletionList(PUMS_COMPLETION_LIST *list)
 845 {
 846     FIXME( "%p: stub\n", list );
 847     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 848     return FALSE;
 849 }
 850
 851 /***********************************************************************
 852  *           CreateUmsThreadContext   (KERNEL32.@)
 853  */
 854 BOOL WINAPI CreateUmsThreadContext(PUMS_CONTEXT *ctx)
 855 {
 856     FIXME( "%p: stub\n", ctx );
 857     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 858     return FALSE;
 859 }
 860
 861 /***********************************************************************
 862  *           DeleteUmsCompletionList   (KERNEL32.@)
 863  */
 864 BOOL WINAPI DeleteUmsCompletionList(PUMS_COMPLETION_LIST list)
 865 {
 866     FIXME( "%p: stub\n", list );
 867     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 868     return FALSE;
 869 }
 870
 871 /***********************************************************************
 872  *           DeleteUmsThreadContext   (KERNEL32.@)
 873  */
 874 BOOL WINAPI DeleteUmsThreadContext(PUMS_CONTEXT ctx)
 875 {
 876     FIXME( "%p: stub\n", ctx );
 877     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 878     return FALSE;
 879 }
 880
 881 /***********************************************************************
 882  *           DequeueUmsCompletionListItems   (KERNEL32.@)
 883  */
 884 BOOL WINAPI DequeueUmsCompletionListItems(void *list, DWORD timeout, PUMS_CONTEXT *ctx)
 885 {
 886     FIXME( "%p,%08x,%p: stub\n", list, timeout, ctx );
 887     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 888     return FALSE;
 889 }
 890
 891 /***********************************************************************
 892  *           EnterUmsSchedulingMode   (KERNEL32.@)
 893  */
 894 BOOL WINAPI EnterUmsSchedulingMode(UMS_SCHEDULER_STARTUP_INFO *info)
 895 {
 896     FIXME( "%p: stub\n", info );
 897     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 898     return FALSE;
 899 }
 900
 901 /***********************************************************************
 902  *           ExecuteUmsThread   (KERNEL32.@)
 903  */
 904 BOOL WINAPI ExecuteUmsThread(PUMS_CONTEXT ctx)
 905 {
 906     FIXME( "%p: stub\n", ctx );
 907     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 908     return FALSE;
 909 }
 910
 911 /***********************************************************************
 912  *           GetCurrentUmsThread   (KERNEL32.@)
 913  */
 914 PUMS_CONTEXT WINAPI GetCurrentUmsThread(void)
 915 {
 916     FIXME( "stub\n" );
 917     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 918     return FALSE;
 919 }
 920
 921 /***********************************************************************
 922  *           GetNextUmsListItem   (KERNEL32.@)
 923  */
 924 PUMS_CONTEXT WINAPI GetNextUmsListItem(PUMS_CONTEXT ctx)
 925 {
 926     FIXME( "%p: stub\n", ctx );
 927     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 928     return NULL;
 929 }
 930
 931 /***********************************************************************
 932  *           GetUmsCompletionListEvent   (KERNEL32.@)
 933  */
 934 BOOL WINAPI GetUmsCompletionListEvent(PUMS_COMPLETION_LIST list, HANDLE *event)
 935 {
 936     FIXME( "%p,%p: stub\n", list, event );
 937     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 938     return FALSE;
 939 }
 940
 941 /***********************************************************************
 942  *           QueryUmsThreadInformation   (KERNEL32.@)
 943  */
 944 BOOL WINAPI QueryUmsThreadInformation(PUMS_CONTEXT ctx, UMS_THREAD_INFO_CLASS class,
 945                                        void *buf, ULONG length, ULONG *ret_length)
 946 {
 947     FIXME( "%p,%08x,%p,%08x,%p: stub\n", ctx, class, buf, length, ret_length );
 948     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 949     return FALSE;
 950 }
 951
 952 /***********************************************************************
 953  *           SetUmsThreadInformation   (KERNEL32.@)
 954  */
 955 BOOL WINAPI SetUmsThreadInformation(PUMS_CONTEXT ctx, UMS_THREAD_INFO_CLASS class,
 956                                      void *buf, ULONG length)
 957 {
 958     FIXME( "%p,%08x,%p,%08x: stub\n", ctx, class, buf, length );
 959     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 960     return FALSE;
 961 }
 962
 963 /***********************************************************************
 964  *           UmsThreadYield   (KERNEL32.@)
 965  */
 966 BOOL WINAPI UmsThreadYield(void *param)
 967 {
 968     FIXME( "%p: stub\n", param );
 969     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 970     return FALSE;
 971 }