reactos/lib/kernel32/process/proc.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS system libraries
   4  * FILE:            lib/kernel32/proc/proc.c
   5  * PURPOSE:         Process functions
   6  * PROGRAMMER:      Ariadne ( ariadne@xs4all.nl)
   7  * UPDATE HISTORY:
   8  *                  Created 01/11/98
   9  */
  10
  11 /* INCLUDES ****************************************************************/
  12
  13 #define UNICODE
  14 #include <windows.h>
  15 #include <kernel32/proc.h>
  16 #include <kernel32/thread.h>
  17 #include <wchar.h>
  18 #include <string.h>
  19 #include <internal/i386/segment.h>
  20 #include <internal/teb.h>
  21
  22 #define NDEBUG
  23 #include <kernel32/kernel32.h>
  24
  25 /* TYPES *********************************************************************/
  26
  27 typedef struct _WSTARTUPINFO {
  28   DWORD   cb;
  29   LPWSTR  lpReserved;
  30   LPWSTR  lpDesktop;
  31   LPWSTR  lpTitle;
  32   DWORD   dwX;
  33   DWORD   dwY;
  34   DWORD   dwXSize;
  35   DWORD   dwYSize;
  36   DWORD   dwXCountChars;
  37   DWORD   dwYCountChars;
  38   DWORD   dwFillAttribute;
  39   DWORD   dwFlags;
  40   WORD    wShowWindow;
  41   WORD    cbReserved2;
  42   LPBYTE  lpReserved2;
  43   HANDLE  hStdInput;
  44   HANDLE  hStdOutput;
  45   HANDLE  hStdError;
  46 } WSTARTUPINFO, *LPWSTARTUPINFO;
  47
  48 /* GLOBALS *******************************************************************/
  49
  50 WaitForInputIdleType  lpfnGlobalRegisterWaitForInputIdle;
  51
  52 VOID RegisterWaitForInputIdle(WaitForInputIdleType  lpfnRegisterWaitForInputIdle);
  53
  54 /* FUNCTIONS ****************************************************************/
  55
  56 WINBOOL STDCALL GetProcessId(HANDLE hProcess, LPDWORD lpProcessId);
  57
  58 FARPROC GetProcAddress(HMODULE hModule, LPCSTR lpProcName)
  59 {
  60    UNIMPLEMENTED;
  61    return(NULL);
  62 }
  63
  64 WINBOOL STDCALL GetProcessTimes(HANDLE hProcess,
  65                                 LPFILETIME lpCreationTime,
  66                                 LPFILETIME lpExitTime,
  67                                 LPFILETIME lpKernelTime,
  68                                 LPFILETIME lpUserTime)
  69 {
  70    dprintf("GetProcessTimes is unimplemented\n");
  71    return(FALSE);
  72 }
  73
  74 HANDLE STDCALL GetCurrentProcess(VOID)
  75 {
  76         return (HANDLE)NtCurrentProcess();
  77 }
  78
  79 HANDLE STDCALL GetCurrentThread(VOID)
  80 {
  81         return (HANDLE)NtCurrentThread();
  82 }
  83
  84 DWORD STDCALL GetCurrentProcessId(VOID)
  85 {
  86         return (DWORD)(GetTeb()->Cid).UniqueProcess;
  87 }
  88
  89 WINBOOL STDCALL GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode)
  90 {
  91    NTSTATUS errCode;
  92    PROCESS_BASIC_INFORMATION ProcessBasic;
  93    ULONG BytesWritten;
  94
  95    errCode = NtQueryInformationProcess(hProcess,
  96                                        ProcessBasicInformation,
  97                                        &ProcessBasic,
  98                                        sizeof(PROCESS_BASIC_INFORMATION),
  99                                        &BytesWritten);
 100    if (!NT_SUCCESS(errCode))
 101      {
 102         SetLastError(RtlNtStatusToDosError(errCode));
 103         return FALSE;
 104      }
 105    memcpy(lpExitCode, &ProcessBasic.ExitStatus, sizeof(DWORD));
 106    return TRUE;
 107 }
 108
 109 WINBOOL STDCALL GetProcessId(HANDLE hProcess, LPDWORD lpProcessId )
 110 {
 111    NTSTATUS errCode;
 112    PROCESS_BASIC_INFORMATION ProcessBasic;
 113    ULONG BytesWritten;
 114
 115    errCode = NtQueryInformationProcess(hProcess,
 116                                        ProcessBasicInformation,
 117                                        &ProcessBasic,
 118                                        sizeof(PROCESS_BASIC_INFORMATION),
 119                                        &BytesWritten);
 120    if (!NT_SUCCESS(errCode))
 121      {
 122         SetLastError(RtlNtStatusToDosError(errCode));
 123         return FALSE;
 124      }
 125    memcpy( lpProcessId ,&ProcessBasic.UniqueProcessId,sizeof(DWORD));
 126    return TRUE;
 127 }
 128
 129 PWSTR InternalAnsiToUnicode(PWSTR Out, LPCSTR In, ULONG MaxLength)
 130 {
 131    ULONG i;
 132
 133    if (In == NULL)
 134      {
 135         return(NULL);
 136      }
 137    else
 138      {
 139         i = 0;
 140         while ((*In)!=0 && i < MaxLength)
 141           {
 142              Out[i] = *In;
 143              In++;
 144              i++;
 145           }
 146         Out[i] = 0;
 147         return(Out);
 148      }
 149 }
 150
 151 HANDLE STDCALL OpenProcess(DWORD dwDesiredAccess,
 152                            WINBOOL bInheritHandle,
 153                            DWORD dwProcessId)
 154 {
 155    NTSTATUS errCode;
 156    HANDLE ProcessHandle;
 157    OBJECT_ATTRIBUTES ObjectAttributes;
 158    CLIENT_ID ClientId ;
 159
 160    ClientId.UniqueProcess = (HANDLE)dwProcessId;
 161    ObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES);
 162    ObjectAttributes.RootDirectory = (HANDLE)NULL;
 163    ObjectAttributes.SecurityDescriptor = NULL;
 164    ObjectAttributes.SecurityQualityOfService = NULL;
 165
 166    if ( bInheritHandle == TRUE )
 167      ObjectAttributes.Attributes = OBJ_INHERIT;
 168    else
 169      ObjectAttributes.Attributes = 0;
 170
 171    errCode = NtOpenProcess(&ProcessHandle,
 172                            dwDesiredAccess,
 173                            &ObjectAttributes,
 174                            &ClientId);
 175    if (!NT_SUCCESS(errCode))
 176      {
 177         SetLastError(RtlNtStatusToDosError(errCode));
 178         return NULL;
 179      }
 180    return ProcessHandle;
 181 }
 182
 183 UINT WinExec (LPCSTR lpCmdLine, UINT uCmdShow)
 184 {
 185    STARTUPINFO StartupInfo;
 186    PROCESS_INFORMATION  ProcessInformation;
 187    HINSTANCE hInst;
 188    DWORD dosErr;
 189
 190    StartupInfo.cb = sizeof(STARTUPINFO);
 191    StartupInfo.wShowWindow = uCmdShow ;
 192    StartupInfo.dwFlags = 0;
 193
 194    hInst = (HINSTANCE)CreateProcessA(NULL,
 195                                      (PVOID)lpCmdLine,
 196                                      NULL,
 197                                      NULL,
 198                                      FALSE,
 199                                      0,
 200                                      NULL,
 201                                      NULL,
 202                                      &StartupInfo,
 203                                      &ProcessInformation);
 204    if ( hInst == NULL )
 205      {
 206         dosErr = GetLastError();
 207         return dosErr;
 208      }
 209    if ( lpfnGlobalRegisterWaitForInputIdle != NULL )
 210      lpfnGlobalRegisterWaitForInputIdle(ProcessInformation.hProcess,10000);
 211    NtClose(ProcessInformation.hProcess);
 212    NtClose(ProcessInformation.hThread);
 213    return 0;
 214 }
 215
 216
 217
 218 VOID RegisterWaitForInputIdle(WaitForInputIdleType
 219                               lpfnRegisterWaitForInputIdle)
 220 {
 221    lpfnGlobalRegisterWaitForInputIdle = lpfnRegisterWaitForInputIdle;
 222    return;
 223 }
 224
 225 DWORD STDCALL WaitForInputIdle(HANDLE hProcess,
 226                                DWORD dwMilliseconds)
 227 {
 228    return 0;
 229 }
 230
 231 VOID STDCALL Sleep(DWORD dwMilliseconds)
 232 {
 233    SleepEx(dwMilliseconds,FALSE);
 234    return;
 235 }
 236
 237 DWORD STDCALL SleepEx(DWORD dwMilliseconds, BOOL bAlertable)
 238 {
 239         TIME Interval;
 240         NTSTATUS errCode;
 241
 242         Interval.QuadPart = dwMilliseconds * 1000;
 243
 244         errCode = NtDelayExecution(bAlertable,&Interval);
 245         if ( !NT_SUCCESS(errCode) ) {
 246                 SetLastError(RtlNtStatusToDosError(errCode));
 247                 return -1;
 248         }
 249         return 0;
 250 }
 251
 252 VOID STDCALL GetStartupInfoW(LPSTARTUPINFO _lpStartupInfo)
 253 {
 254    NT_PEB *pPeb = NtCurrentPeb();
 255    LPWSTARTUPINFO lpStartupInfo = (LPWSTARTUPINFO)_lpStartupInfo;
 256
 257    if (lpStartupInfo == NULL)
 258      {
 259         SetLastError(ERROR_INVALID_PARAMETER);
 260         return;
 261      }
 262
 263    lpStartupInfo->cb = sizeof(STARTUPINFO);
 264 //   lstrcpyW(lpStartupInfo->lpDesktop, pPeb->StartupInfo->Desktop);
 265 //   lstrcpyW(lpStartupInfo->lpTitle, pPeb->StartupInfo->Title);
 266    lpStartupInfo->dwX = pPeb->StartupInfo->dwX;
 267    lpStartupInfo->dwY = pPeb->StartupInfo->dwY;
 268    lpStartupInfo->dwXSize = pPeb->StartupInfo->dwXSize;
 269    lpStartupInfo->dwYSize = pPeb->StartupInfo->dwYSize;
 270    lpStartupInfo->dwXCountChars = pPeb->StartupInfo->dwXCountChars;
 271    lpStartupInfo->dwYCountChars = pPeb->StartupInfo->dwYCountChars;
 272    lpStartupInfo->dwFillAttribute = pPeb->StartupInfo->dwFillAttribute;
 273    lpStartupInfo->dwFlags = pPeb->StartupInfo->dwFlags;
 274    lpStartupInfo->wShowWindow = pPeb->StartupInfo->wShowWindow;
 275    //lpStartupInfo->cbReserved2 = pPeb->StartupInfo->cbReserved;
 276    //lpStartupInfo->lpReserved = pPeb->StartupInfo->lpReserved1;
 277    //lpStartupInfo->lpReserved2 = pPeb->StartupInfo->lpReserved2;
 278
 279         lpStartupInfo->cb = sizeof(STARTUPINFO);
 280         lstrcpyW(lpStartupInfo->lpDesktop, pPeb->StartupInfo->Desktop);
 281         lstrcpyW(lpStartupInfo->lpTitle, pPeb->StartupInfo->Title);
 282         lpStartupInfo->dwX = pPeb->StartupInfo->dwX;
 283         lpStartupInfo->dwY = pPeb->StartupInfo->dwY;
 284         lpStartupInfo->dwXSize = pPeb->StartupInfo->dwXSize;
 285         lpStartupInfo->dwYSize = pPeb->StartupInfo->dwYSize;
 286         lpStartupInfo->dwXCountChars = pPeb->StartupInfo->dwXCountChars;
 287         lpStartupInfo->dwYCountChars = pPeb->StartupInfo->dwYCountChars;
 288         lpStartupInfo->dwFillAttribute = pPeb->StartupInfo->dwFillAttribute;
 289         lpStartupInfo->dwFlags = pPeb->StartupInfo->dwFlags;
 290         lpStartupInfo->wShowWindow = pPeb->StartupInfo->wShowWindow;
 291         //lpStartupInfo->cbReserved2 = pPeb->StartupInfo->cbReserved;
 292         //lpStartupInfo->lpReserved = pPeb->StartupInfo->lpReserved1;
 293         //lpStartupInfo->lpReserved2 = pPeb->StartupInfo->lpReserved2;
 294
 295         lpStartupInfo->hStdInput = pPeb->StartupInfo->hStdInput;
 296         lpStartupInfo->hStdOutput = pPeb->StartupInfo->hStdOutput;
 297         lpStartupInfo->hStdError = pPeb->StartupInfo->hStdError;
 298
 299
 300
 301         return;
 302 }
 303
 304
 305 VOID STDCALL GetStartupInfoA(LPSTARTUPINFO lpStartupInfo)
 306 {
 307    NT_PEB *pPeb = NtCurrentPeb();
 308    ULONG i = 0;
 309
 310    if (lpStartupInfo == NULL)
 311      {
 312         SetLastError(ERROR_INVALID_PARAMETER);
 313         return;
 314      }
 315
 316    lpStartupInfo->cb = sizeof(STARTUPINFO);
 317    i = 0;
 318
 319    while ((pPeb->StartupInfo->Desktop[i])!=0 && i < MAX_PATH)
 320      {
 321         lpStartupInfo->lpDesktop[i] = (unsigned char)
 322           pPeb->StartupInfo->Desktop[i];
 323         i++;
 324      }
 325    lpStartupInfo->lpDesktop[i] = 0;
 326
 327    i = 0;
 328    while ((pPeb->StartupInfo->Title[i])!=0 && i < MAX_PATH)
 329      {
 330         lpStartupInfo->lpTitle[i] = (unsigned char)pPeb->StartupInfo->Title[i];
 331         i++;
 332      }
 333    lpStartupInfo->lpTitle[i] = 0;
 334
 335    lpStartupInfo->dwX = pPeb->StartupInfo->dwX;
 336    lpStartupInfo->dwY = pPeb->StartupInfo->dwY;
 337    lpStartupInfo->dwXSize = pPeb->StartupInfo->dwXSize;
 338    lpStartupInfo->dwYSize = pPeb->StartupInfo->dwYSize;
 339    lpStartupInfo->dwXCountChars = pPeb->StartupInfo->dwXCountChars;
 340    lpStartupInfo->dwYCountChars = pPeb->StartupInfo->dwYCountChars;
 341    lpStartupInfo->dwFillAttribute = pPeb->StartupInfo->dwFillAttribute;
 342    lpStartupInfo->dwFlags = pPeb->StartupInfo->dwFlags;
 343    lpStartupInfo->wShowWindow = pPeb->StartupInfo->wShowWindow;
 344    //lpStartupInfo->cbReserved2 = pPeb->StartupInfo->cbReserved;
 345    //lpStartupInfo->lpReserved = pPeb->StartupInfo->lpReserved1;
 346    //lpStartupInfo->lpReserved2 = pPeb->StartupInfo->lpReserved2;
 347
 348    lpStartupInfo->hStdInput = pPeb->StartupInfo->hStdInput;
 349    lpStartupInfo->hStdOutput = pPeb->StartupInfo->hStdOutput;
 350    lpStartupInfo->hStdError = pPeb->StartupInfo->hStdError;
 351
 352    return;
 353 }
 354
 355 BOOL STDCALL FlushInstructionCache(HANDLE hProcess,
 356                                    LPCVOID lpBaseAddress,
 357                                    DWORD dwSize)
 358 {
 359    NTSTATUS errCode;
 360    errCode = NtFlushInstructionCache(hProcess,(PVOID)lpBaseAddress,dwSize);
 361    if (!NT_SUCCESS(errCode))
 362      {
 363         SetLastError(RtlNtStatusToDosError(errCode));
 364         return FALSE;
 365      }
 366    return TRUE;
 367 }
 368
 369 VOID STDCALL ExitProcess(UINT uExitCode)
 370 {
 371    NtTerminateProcess(NtCurrentProcess(), uExitCode);
 372 }
 373
 374 WINBOOL STDCALL TerminateProcess(HANDLE hProcess, UINT uExitCode)
 375 {
 376    NTSTATUS errCode;
 377    errCode = NtTerminateProcess(hProcess, uExitCode);
 378    if (!NT_SUCCESS(errCode))
 379      {
 380         SetLastError(RtlNtStatusToDosError(errCode));
 381         return FALSE;
 382      }
 383    return TRUE;
 384 }
 385
 386 VOID STDCALL FatalAppExitA(UINT uAction, LPCSTR lpMessageText)
 387 {
 388    WCHAR MessageTextW[MAX_PATH];
 389    UINT i;
 390    i = 0;
 391    while ((*lpMessageText)!=0 && i < 35)
 392      {
 393         MessageTextW[i] = *lpMessageText;
 394         lpMessageText++;
 395         i++;
 396      }
 397    MessageTextW[i] = 0;
 398
 399    return FatalAppExitW(uAction,MessageTextW);
 400 }
 401
 402
 403
 404 VOID STDCALL FatalAppExitW(UINT uAction, LPCWSTR lpMessageText)
 405 {
 406    return;
 407 }