/* * Win32 processes * * Copyright 1996, 1998 Alexandre Julliard */ #include #include #include #include #include "process.h" #include "module.h" #include "file.h" #include "global.h" #include "heap.h" #include "task.h" #include "ldt.h" #include "syslevel.h" #include "thread.h" #include "winerror.h" #include "pe_image.h" #include "task.h" #include "server.h" #include "debug.h" static void PROCESS_Destroy( K32OBJ *obj ); const K32OBJ_OPS PROCESS_Ops = { PROCESS_Destroy /* destroy */ }; static DWORD PROCESS_InitialProcessID = 0; static PDB32 *PROCESS_PDBList = NULL; static DWORD PROCESS_PDBList_Size = 0; /*********************************************************************** * PROCESS_Current */ PDB32 *PROCESS_Current(void) { return THREAD_Current()->process; } /*********************************************************************** * PROCESS_Initial * * FIXME: This works only while running all processes in the same * address space (or, at least, the initial process is mapped * into all address spaces as is KERNEL32 in Windows 95) * */ PDB32 *PROCESS_Initial(void) { return PROCESS_IdToPDB( PROCESS_InitialProcessID ); } /*********************************************************************** * PROCESS_GetPtr * * Get a process from a handle, incrementing the PDB refcount. */ PDB32 *PROCESS_GetPtr( HANDLE32 handle, DWORD access, int *server_handle ) { return (PDB32 *)HANDLE_GetObjPtr( PROCESS_Current(), handle, K32OBJ_PROCESS, access, server_handle ); } /*********************************************************************** * PROCESS_QueryInfo * * Retrieve information about a process */ static BOOL32 PROCESS_QueryInfo( HANDLE32 handle, struct get_process_info_reply *reply ) { struct get_process_info_request req; req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle, K32OBJ_PROCESS, PROCESS_QUERY_INFORMATION ); CLIENT_SendRequest( REQ_GET_PROCESS_INFO, -1, 1, &req, sizeof(req) ); return !CLIENT_WaitSimpleReply( reply, sizeof(*reply), NULL ); } /*********************************************************************** * PROCESS_IsCurrent * * Check if a handle is to the current process */ BOOL32 PROCESS_IsCurrent( HANDLE32 handle ) { struct get_process_info_reply reply; return (PROCESS_QueryInfo( handle, &reply ) && (reply.pid == PROCESS_Current()->server_pid)); } /*********************************************************************** * PROCESS_IdToPDB * * Convert a process id to a PDB, making sure it is valid. */ PDB32 *PROCESS_IdToPDB( DWORD id ) { PDB32 *pdb; if (!id) return PROCESS_Current(); pdb = PROCESS_ID_TO_PDB( id ); if (!K32OBJ_IsValid( &pdb->header, K32OBJ_PROCESS )) { SetLastError( ERROR_INVALID_PARAMETER ); return NULL; } return pdb; } /*********************************************************************** * PROCESS_BuildEnvDB * * Build the env DB for the initial process */ static BOOL32 PROCESS_BuildEnvDB( PDB32 *pdb ) { /* Allocate the env DB (FIXME: should not be on the system heap) */ if (!(pdb->env_db = HeapAlloc(SystemHeap,HEAP_ZERO_MEMORY,sizeof(ENVDB)))) return FALSE; InitializeCriticalSection( &pdb->env_db->section ); /* Allocate startup info */ if (!(pdb->env_db->startup_info = HeapAlloc( SystemHeap, HEAP_ZERO_MEMORY, sizeof(STARTUPINFO32A) ))) return FALSE; /* Allocate the standard handles */ pdb->env_db->hStdin = FILE_DupUnixHandle( 0, GENERIC_READ ); pdb->env_db->hStdout = FILE_DupUnixHandle( 1, GENERIC_WRITE ); pdb->env_db->hStderr = FILE_DupUnixHandle( 2, GENERIC_WRITE ); /* Build the command-line */ pdb->env_db->cmd_line = HEAP_strdupA( SystemHeap, 0, "kernel32" ); /* Build the environment strings */ return ENV_BuildEnvironment( pdb ); } /*********************************************************************** * PROCESS_InheritEnvDB */ static BOOL32 PROCESS_InheritEnvDB( PDB32 *pdb, LPCSTR cmd_line, LPCSTR env, BOOL32 inherit_handles, STARTUPINFO32A *startup ) { if (!(pdb->env_db = HeapAlloc(pdb->heap, HEAP_ZERO_MEMORY, sizeof(ENVDB)))) return FALSE; InitializeCriticalSection( &pdb->env_db->section ); /* Copy the parent environment */ if (!ENV_InheritEnvironment( pdb, env )) return FALSE; /* Copy the command line */ if (!(pdb->env_db->cmd_line = HEAP_strdupA( pdb->heap, 0, cmd_line ))) return FALSE; /* Remember startup info */ if (!(pdb->env_db->startup_info = HeapAlloc( pdb->heap, HEAP_ZERO_MEMORY, sizeof(STARTUPINFO32A) ))) return FALSE; *pdb->env_db->startup_info = *startup; /* Inherit the standard handles */ if (pdb->env_db->startup_info->dwFlags & STARTF_USESTDHANDLES) { pdb->env_db->hStdin = pdb->env_db->startup_info->hStdInput; pdb->env_db->hStdout = pdb->env_db->startup_info->hStdOutput; pdb->env_db->hStderr = pdb->env_db->startup_info->hStdError; } else if (inherit_handles) { pdb->env_db->hStdin = pdb->parent->env_db->hStdin; pdb->env_db->hStdout = pdb->parent->env_db->hStdout; pdb->env_db->hStderr = pdb->parent->env_db->hStderr; } /* else will be done later on in PROCESS_Create */ return TRUE; } /*********************************************************************** * PROCESS_PDBList_Insert * Insert this PDB into the global PDB list */ static void PROCESS_PDBList_Insert (PDB32 *pdb) { TRACE (process, "Inserting PDB 0x%0lx, #%ld current\n", PDB_TO_PROCESS_ID (pdb), PROCESS_PDBList_Size); SYSTEM_LOCK (); /* FIXME: Do I need to worry about this ? * I.e., could more than one process be * created at once ? */ if (PROCESS_PDBList == NULL) { PROCESS_PDBList = pdb; pdb->list_next = NULL; pdb->list_prev = NULL; } else { PDB32 *first = PROCESS_PDBList, *last = PROCESS_PDBList; if (first->list_prev) last = first->list_prev; PROCESS_PDBList = pdb; pdb->list_next = first; pdb->list_prev = last; last->list_next = pdb; first->list_prev = pdb; } PROCESS_PDBList_Size ++; SYSTEM_UNLOCK (); } /*********************************************************************** * PROCESS_PDBList_Remove * Remove this PDB from the global PDB list */ static void PROCESS_PDBList_Remove (PDB32 *pdb) { PDB32 *next = pdb->list_next, *prev = pdb->list_prev; TRACE (process, "Removing PDB 0x%0lx, #%ld current\n", PDB_TO_PROCESS_ID (pdb), PROCESS_PDBList_Size); SYSTEM_LOCK (); if (prev == next) { next->list_prev = NULL; next->list_next = NULL; } else { if (next) next->list_prev = prev; if (prev) prev->list_next = next; } if (pdb == PROCESS_PDBList) { PROCESS_PDBList = next ? next : prev; } PROCESS_PDBList_Size --; SYSTEM_UNLOCK (); } /*********************************************************************** * PROCESS_PDBList_Getsize * Return the number of items in the global PDB list */ int PROCESS_PDBList_Getsize () { return PROCESS_PDBList_Size; } /*********************************************************************** * PROCESS_PDBList_Getfirst * Return the head of the PDB list */ PDB32* PROCESS_PDBList_Getfirst () { return PROCESS_PDBList; } /*********************************************************************** * PROCESS_PDBList_Getnext * Return the "next" pdb as referenced from the argument. * If at the end of the list, return NULL. */ PDB32* PROCESS_PDBList_Getnext (PDB32 *pdb) { return (pdb->list_next != PROCESS_PDBList) ? pdb->list_next : NULL; } /*********************************************************************** * PROCESS_FreePDB * * Free a PDB and all associated storage. */ static void PROCESS_FreePDB( PDB32 *pdb ) { /* * FIXME: * If this routine is called because PROCESS_CreatePDB fails, the * following call to PROCESS_PDBList_Remove will probably screw * up. */ PROCESS_PDBList_Remove (pdb); pdb->header.type = K32OBJ_UNKNOWN; if (pdb->handle_table) HANDLE_CloseAll( pdb, NULL ); ENV_FreeEnvironment( pdb ); if (pdb->heap && (pdb->heap != pdb->system_heap)) HeapDestroy( pdb->heap ); DeleteCriticalSection( &pdb->crit_section ); HeapFree( SystemHeap, 0, pdb ); } /*********************************************************************** * PROCESS_CreatePDB * * Allocate and fill a PDB structure. * Runs in the context of the parent process. */ static PDB32 *PROCESS_CreatePDB( PDB32 *parent, BOOL32 inherit ) { PDB32 *pdb = HeapAlloc( SystemHeap, HEAP_ZERO_MEMORY, sizeof(PDB32) ); if (!pdb) return NULL; pdb->header.type = K32OBJ_PROCESS; pdb->header.refcount = 1; pdb->exit_code = 0x103; /* STILL_ACTIVE */ pdb->threads = 1; pdb->running_threads = 1; pdb->ring0_threads = 1; pdb->system_heap = SystemHeap; pdb->parent = parent; pdb->group = pdb; pdb->priority = 8; /* Normal */ pdb->heap = pdb->system_heap; /* will be changed later on */ /* Create the handle table */ if (!HANDLE_CreateTable( pdb, inherit )) goto error; PROCESS_PDBList_Insert (pdb); return pdb; error: PROCESS_FreePDB( pdb ); return NULL; } /*********************************************************************** * PROCESS_FinishCreatePDB * * Second part of CreatePDB */ static BOOL32 PROCESS_FinishCreatePDB( PDB32 *pdb ) { InitializeCriticalSection( &pdb->crit_section ); /* Allocate the event */ if (!(pdb->load_done_evt = CreateEvent32A( NULL, TRUE, FALSE, NULL ))) return FALSE; return TRUE; } /*********************************************************************** * PROCESS_Init */ BOOL32 PROCESS_Init(void) { PDB32 *pdb; THDB *thdb; /* Initialize virtual memory management */ if (!VIRTUAL_Init()) return FALSE; /* Create the system heaps */ if (!(SystemHeap = HeapCreate( HEAP_GROWABLE, 0x10000, 0 ))) return FALSE; /* Create the initial process and thread structures */ if (!(pdb = PROCESS_CreatePDB( NULL, FALSE ))) return FALSE; if (!(thdb = THREAD_Create( pdb, 0, FALSE, NULL, NULL, NULL, NULL ))) return FALSE; thdb->unix_pid = getpid(); PROCESS_InitialProcessID = PDB_TO_PROCESS_ID(pdb); /* Remember TEB selector of initial process for emergency use */ SYSLEVEL_EmergencyTeb = thdb->teb_sel; /* Create the environment DB of the first process */ if (!PROCESS_BuildEnvDB( pdb )) return FALSE; /* Initialize the first thread */ if (CLIENT_InitThread()) return FALSE; if (!PROCESS_FinishCreatePDB( pdb )) return FALSE; /* Create the SEGPTR heap */ if (!(SegptrHeap = HeapCreate( HEAP_WINE_SEGPTR, 0, 0 ))) return FALSE; return TRUE; } /*********************************************************************** * PROCESS_Create * * Create a new process database and associated info. */ PDB32 *PROCESS_Create( NE_MODULE *pModule, LPCSTR cmd_line, LPCSTR env, HINSTANCE16 hInstance, HINSTANCE16 hPrevInstance, BOOL32 inherit, STARTUPINFO32A *startup, PROCESS_INFORMATION *info ) { DWORD size, commit; int server_thandle, server_phandle; UINT32 cmdShow = 0; THDB *thdb = NULL; PDB32 *parent = PROCESS_Current(); PDB32 *pdb = PROCESS_CreatePDB( parent, inherit ); TDB *pTask; if (!pdb) return NULL; info->hThread = info->hProcess = INVALID_HANDLE_VALUE32; if (!PROCESS_FinishCreatePDB( pdb )) goto error; /* Create the heap */ if (pModule->module32) { size = PE_HEADER(pModule->module32)->OptionalHeader.SizeOfHeapReserve; commit = PE_HEADER(pModule->module32)->OptionalHeader.SizeOfHeapCommit; } else { size = 0x10000; commit = 0; pdb->flags |= PDB32_WIN16_PROC; /* This is a Win16 process */ } if (!(pdb->heap = HeapCreate( HEAP_GROWABLE, size, commit ))) goto error; pdb->heap_list = pdb->heap; /* Inherit the env DB from the parent */ if (!PROCESS_InheritEnvDB( pdb, cmd_line, env, inherit, startup )) goto error; /* Create the main thread */ if (pModule->module32) size = PE_HEADER(pModule->module32)->OptionalHeader.SizeOfStackReserve; else size = 0; if (!(thdb = THREAD_Create( pdb, size, FALSE, &server_thandle, &server_phandle, NULL, NULL ))) goto error; if ((info->hThread = HANDLE_Alloc( parent, &thdb->header, THREAD_ALL_ACCESS, FALSE, server_thandle )) == INVALID_HANDLE_VALUE32) goto error; if ((info->hProcess = HANDLE_Alloc( parent, &pdb->header, PROCESS_ALL_ACCESS, FALSE, server_phandle )) == INVALID_HANDLE_VALUE32) goto error; info->dwProcessId = PDB_TO_PROCESS_ID(pdb); info->dwThreadId = THDB_TO_THREAD_ID(thdb); #if 0 thdb->unix_pid = getpid(); /* FIXME: wrong here ... */ #else /* All Win16 'threads' have the same unix_pid, no matter by which thread they were created ! */ pTask = (TDB *)GlobalLock16( parent->task ); thdb->unix_pid = pTask? pTask->thdb->unix_pid : THREAD_Current()->unix_pid; #endif /* Duplicate the standard handles */ if ((!(pdb->env_db->startup_info->dwFlags & STARTF_USESTDHANDLES)) && !inherit) { DuplicateHandle( GetCurrentProcess(), pdb->parent->env_db->hStdin, info->hProcess, &pdb->env_db->hStdin, 0, TRUE, DUPLICATE_SAME_ACCESS ); DuplicateHandle( GetCurrentProcess(), pdb->parent->env_db->hStdout, info->hProcess, &pdb->env_db->hStdout, 0, TRUE, DUPLICATE_SAME_ACCESS ); DuplicateHandle( GetCurrentProcess(), pdb->parent->env_db->hStderr, info->hProcess, &pdb->env_db->hStderr, 0, TRUE, DUPLICATE_SAME_ACCESS ); } /* Create a Win16 task for this process */ if (startup->dwFlags & STARTF_USESHOWWINDOW) cmdShow = startup->wShowWindow; pdb->task = TASK_Create( thdb, pModule, hInstance, hPrevInstance, cmdShow); if (!pdb->task) goto error; /* Map system DLLs into this process (from initial process) */ /* FIXME: this is a hack */ pdb->modref_list = PROCESS_Initial()->modref_list; return pdb; error: if (info->hThread != INVALID_HANDLE_VALUE32) CloseHandle( info->hThread ); if (info->hProcess != INVALID_HANDLE_VALUE32) CloseHandle( info->hProcess ); if (thdb) K32OBJ_DecCount( &thdb->header ); PROCESS_FreePDB( pdb ); return NULL; } /*********************************************************************** * PROCESS_Destroy */ static void PROCESS_Destroy( K32OBJ *ptr ) { PDB32 *pdb = (PDB32 *)ptr; assert( ptr->type == K32OBJ_PROCESS ); /* Free everything */ ptr->type = K32OBJ_UNKNOWN; PROCESS_FreePDB( pdb ); } /*********************************************************************** * ExitProcess (KERNEL32.100) */ void WINAPI ExitProcess( DWORD status ) { PDB32 *pdb = PROCESS_Current(); TDB *pTask = (TDB *)GlobalLock16( pdb->task ); if ( pTask ) pTask->nEvents++; if ( pTask && pTask->thdb != THREAD_Current() ) ExitThread( status ); SYSTEM_LOCK(); /* FIXME: should kill all running threads of this process */ pdb->exit_code = status; if (pdb->console) FreeConsole(); SYSTEM_UNLOCK(); __RESTORE_ES; /* Necessary for Pietrek's showseh example program */ TASK_KillCurrentTask( status ); } /****************************************************************************** * TerminateProcess (KERNEL32.684) */ BOOL32 WINAPI TerminateProcess( HANDLE32 handle, DWORD exit_code ) { struct terminate_process_request req; req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle, K32OBJ_PROCESS, PROCESS_TERMINATE ); req.exit_code = exit_code; CLIENT_SendRequest( REQ_TERMINATE_PROCESS, -1, 1, &req, sizeof(req) ); return !CLIENT_WaitReply( NULL, NULL, 0 ); } /*********************************************************************** * GetCurrentProcess (KERNEL32.198) */ HANDLE32 WINAPI GetCurrentProcess(void) { return CURRENT_PROCESS_PSEUDOHANDLE; } /********************************************************************* * OpenProcess (KERNEL32.543) */ HANDLE32 WINAPI OpenProcess( DWORD access, BOOL32 inherit, DWORD id ) { int server_handle; PDB32 *pdb = PROCESS_ID_TO_PDB(id); if (!K32OBJ_IsValid( &pdb->header, K32OBJ_PROCESS )) { SetLastError( ERROR_INVALID_HANDLE ); return 0; } if ((server_handle = CLIENT_OpenProcess( pdb->server_pid, access, inherit )) == -1) { SetLastError( ERROR_INVALID_HANDLE ); return 0; } return HANDLE_Alloc( PROCESS_Current(), &pdb->header, access, inherit, server_handle ); } /*********************************************************************** * GetCurrentProcessId (KERNEL32.199) */ DWORD WINAPI GetCurrentProcessId(void) { PDB32 *pdb = PROCESS_Current(); return PDB_TO_PROCESS_ID( pdb ); } /*********************************************************************** * GetProcessHeap (KERNEL32.259) */ HANDLE32 WINAPI GetProcessHeap(void) { PDB32 *pdb = PROCESS_Current(); return pdb->heap ? pdb->heap : SystemHeap; } /*********************************************************************** * GetThreadLocale (KERNEL32.295) */ LCID WINAPI GetThreadLocale(void) { return PROCESS_Current()->locale; } /*********************************************************************** * SetPriorityClass (KERNEL32.503) */ BOOL32 WINAPI SetPriorityClass( HANDLE32 hprocess, DWORD priorityclass ) { struct set_process_info_request req; req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hprocess, K32OBJ_PROCESS, PROCESS_SET_INFORMATION ); if (req.handle == -1) return FALSE; req.priority = priorityclass; req.mask = SET_PROCESS_INFO_PRIORITY; CLIENT_SendRequest( REQ_SET_PROCESS_INFO, -1, 1, &req, sizeof(req) ); return !CLIENT_WaitReply( NULL, NULL, 0 ); } /*********************************************************************** * GetPriorityClass (KERNEL32.250) */ DWORD WINAPI GetPriorityClass(HANDLE32 hprocess) { struct get_process_info_reply reply; if (!PROCESS_QueryInfo( hprocess, &reply )) return 0; return reply.priority; } /*********************************************************************** * SetProcessAffinityMask (KERNEL32.662) */ BOOL32 WINAPI SetProcessAffinityMask( HANDLE32 hProcess, DWORD affmask ) { struct set_process_info_request req; req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hProcess, K32OBJ_PROCESS, PROCESS_SET_INFORMATION ); if (req.handle == -1) return FALSE; req.affinity = affmask; req.mask = SET_PROCESS_INFO_AFFINITY; CLIENT_SendRequest( REQ_SET_PROCESS_INFO, -1, 1, &req, sizeof(req) ); return !CLIENT_WaitReply( NULL, NULL, 0 ); } /********************************************************************** * GetProcessAffinityMask (KERNEL32.373) */ BOOL32 WINAPI GetProcessAffinityMask( HANDLE32 hProcess, LPDWORD lpProcessAffinityMask, LPDWORD lpSystemAffinityMask ) { struct get_process_info_reply reply; if (!PROCESS_QueryInfo( hProcess, &reply )) return FALSE; if (lpProcessAffinityMask) *lpProcessAffinityMask = reply.process_affinity; if (lpSystemAffinityMask) *lpSystemAffinityMask = reply.system_affinity; return TRUE; } /*********************************************************************** * GetStdHandle (KERNEL32.276) */ HANDLE32 WINAPI GetStdHandle( DWORD std_handle ) { PDB32 *pdb = PROCESS_Current(); switch(std_handle) { case STD_INPUT_HANDLE: return pdb->env_db->hStdin; case STD_OUTPUT_HANDLE: return pdb->env_db->hStdout; case STD_ERROR_HANDLE: return pdb->env_db->hStderr; } SetLastError( ERROR_INVALID_PARAMETER ); return INVALID_HANDLE_VALUE32; } /*********************************************************************** * SetStdHandle (KERNEL32.506) */ BOOL32 WINAPI SetStdHandle( DWORD std_handle, HANDLE32 handle ) { PDB32 *pdb = PROCESS_Current(); /* FIXME: should we close the previous handle? */ switch(std_handle) { case STD_INPUT_HANDLE: pdb->env_db->hStdin = handle; return TRUE; case STD_OUTPUT_HANDLE: pdb->env_db->hStdout = handle; return TRUE; case STD_ERROR_HANDLE: pdb->env_db->hStderr = handle; return TRUE; } SetLastError( ERROR_INVALID_PARAMETER ); return FALSE; } /*********************************************************************** * GetProcessVersion (KERNEL32) */ DWORD WINAPI GetProcessVersion( DWORD processid ) { TDB *pTask; PDB32 *pdb = PROCESS_IdToPDB( processid ); if (!pdb) return 0; if (!(pTask = (TDB *)GlobalLock16( pdb->task ))) return 0; return (pTask->version&0xff) | (((pTask->version >>8) & 0xff)<<16); } /*********************************************************************** * GetProcessFlags (KERNEL32) */ DWORD WINAPI GetProcessFlags( DWORD processid ) { PDB32 *pdb = PROCESS_IdToPDB( processid ); if (!pdb) return 0; return pdb->flags; } /*********************************************************************** * SetProcessWorkingSetSize [KERNEL32.662] * Sets the min/max working set sizes for a specified process. * * PARAMS * hProcess [I] Handle to the process of interest * minset [I] Specifies minimum working set size * maxset [I] Specifies maximum working set size * * RETURNS STD */ BOOL32 WINAPI SetProcessWorkingSetSize(HANDLE32 hProcess,DWORD minset, DWORD maxset) { FIXME(process,"(0x%08x,%ld,%ld): stub - harmless\n",hProcess,minset,maxset); if(( minset == -1) && (maxset == -1)) { /* Trim the working set to zero */ /* Swap the process out of physical RAM */ } return TRUE; } /*********************************************************************** * GetProcessWorkingSetSize (KERNEL32) */ BOOL32 WINAPI GetProcessWorkingSetSize(HANDLE32 hProcess,LPDWORD minset, LPDWORD maxset) { FIXME(process,"(0x%08x,%p,%p): stub\n",hProcess,minset,maxset); /* 32 MB working set size */ if (minset) *minset = 32*1024*1024; if (maxset) *maxset = 32*1024*1024; return TRUE; } /*********************************************************************** * SetProcessShutdownParameters (KERNEL32) * * CHANGED - James Sutherland (JamesSutherland@gmx.de) * Now tracks changes made (but does not act on these changes) * NOTE: the definition for SHUTDOWN_NORETRY was done on guesswork. * It really shouldn't be here, but I'll move it when it's been checked! */ #define SHUTDOWN_NORETRY 1 static unsigned int shutdown_noretry = 0; static unsigned int shutdown_priority = 0x280L; BOOL32 WINAPI SetProcessShutdownParameters(DWORD level,DWORD flags) { if (flags & SHUTDOWN_NORETRY) shutdown_noretry = 1; else shutdown_noretry = 0; if (level > 0x100L && level < 0x3FFL) shutdown_priority = level; else { ERR(process,"invalid priority level 0x%08lx\n", level); return FALSE; } return TRUE; } /*********************************************************************** * GetProcessShutdownParameters (KERNEL32) * */ BOOL32 WINAPI GetProcessShutdownParameters( LPDWORD lpdwLevel, LPDWORD lpdwFlags ) { (*lpdwLevel) = shutdown_priority; (*lpdwFlags) = (shutdown_noretry * SHUTDOWN_NORETRY); return TRUE; } /*********************************************************************** * SetProcessPriorityBoost (KERNEL32) */ BOOL32 WINAPI SetProcessPriorityBoost(HANDLE32 hprocess,BOOL32 disableboost) { FIXME(process,"(%d,%d): stub\n",hprocess,disableboost); /* Say we can do it. I doubt the program will notice that we don't. */ return TRUE; } /*********************************************************************** * ReadProcessMemory (KERNEL32) * FIXME: check this, if we ever run win32 binaries in different addressspaces * ... and add a sizecheck */ BOOL32 WINAPI ReadProcessMemory( HANDLE32 hProcess, LPCVOID lpBaseAddress, LPVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesRead ) { memcpy(lpBuffer,lpBaseAddress,nSize); if (lpNumberOfBytesRead) *lpNumberOfBytesRead = nSize; return TRUE; } /*********************************************************************** * WriteProcessMemory (KERNEL32) * FIXME: check this, if we ever run win32 binaries in different addressspaces * ... and add a sizecheck */ BOOL32 WINAPI WriteProcessMemory(HANDLE32 hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesWritten ) { memcpy(lpBaseAddress,lpBuffer,nSize); if (lpNumberOfBytesWritten) *lpNumberOfBytesWritten = nSize; return TRUE; } /*********************************************************************** * RegisterServiceProcess (KERNEL, KERNEL32) * * A service process calls this function to ensure that it continues to run * even after a user logged off. */ DWORD WINAPI RegisterServiceProcess(DWORD dwProcessId, DWORD dwType) { /* I don't think that Wine needs to do anything in that function */ return 1; /* success */ } /*********************************************************************** * GetExitCodeProcess [KERNEL32.325] * * Gets termination status of specified process * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL32 WINAPI GetExitCodeProcess( HANDLE32 hProcess, /* [I] handle to the process */ LPDWORD lpExitCode) /* [O] address to receive termination status */ { struct get_process_info_reply reply; if (!PROCESS_QueryInfo( hProcess, &reply )) return FALSE; if (lpExitCode) *lpExitCode = reply.exit_code; return TRUE; } /*********************************************************************** * GetProcessHeaps [KERNEL32.376] */ DWORD WINAPI GetProcessHeaps(DWORD nrofheaps,HANDLE32 *heaps) { FIXME(win32,"(%ld,%p), incomplete implementation.\n",nrofheaps,heaps); if (nrofheaps) { heaps[0] = GetProcessHeap(); /* ... probably SystemHeap too ? */ return 1; } /* number of available heaps */ return 1; } /*********************************************************************** * PROCESS_SuspendOtherThreads */ void PROCESS_SuspendOtherThreads(void) { PDB32 *pdb; THREAD_ENTRY *entry; SYSTEM_LOCK(); pdb = PROCESS_Current(); entry = pdb->thread_list->next; for (;;) { if (entry->thread != THREAD_Current() && !THREAD_IsWin16(entry->thread)) { HANDLE32 handle = HANDLE_Alloc( PROCESS_Current(), &entry->thread->header, THREAD_ALL_ACCESS, FALSE, -1 ); SuspendThread(handle); CloseHandle(handle); } if (entry == pdb->thread_list) break; entry = entry->next; } SYSTEM_UNLOCK(); } /*********************************************************************** * PROCESS_ResumeOtherThreads */ void PROCESS_ResumeOtherThreads(void) { PDB32 *pdb; THREAD_ENTRY *entry; SYSTEM_LOCK(); pdb = PROCESS_Current(); entry = pdb->thread_list->next; for (;;) { if (entry->thread != THREAD_Current() && !THREAD_IsWin16(entry->thread)) { HANDLE32 handle = HANDLE_Alloc( PROCESS_Current(), &entry->thread->header, THREAD_ALL_ACCESS, FALSE, -1 ); ResumeThread(handle); CloseHandle(handle); } if (entry == pdb->thread_list) break; entry = entry->next; } SYSTEM_UNLOCK(); }