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