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 /* GLOBALS *****************************************************************/
  26
  27 WaitForInputIdleType  lpfnGlobalRegisterWaitForInputIdle;
  28
  29 VOID RegisterWaitForInputIdle(WaitForInputIdleType  lpfnRegisterWaitForInputIdle);
  30
  31 /* FUNCTIONS ****************************************************************/
  32
  33 WINBOOL STDCALL GetProcessId(HANDLE hProcess, LPDWORD lpProcessId);
  34
  35 FARPROC GetProcAddress(HMODULE hModule, LPCSTR lpProcName)
  36 {
  37    dprintf("GetProcAddress is unimplemented\n");
  38 }
  39
  40 WINBOOL STDCALL GetProcessTimes(HANDLE hProcess,
  41                                 LPFILETIME lpCreationTime,
  42                                 LPFILETIME lpExitTime,
  43                                 LPFILETIME lpKernelTime,
  44                                 LPFILETIME lpUserTime)
  45 {
  46    dprintf("GetProcessTimes is unimplemented\n");
  47    return(FALSE);
  48 }
  49
  50 HANDLE STDCALL GetCurrentProcess(VOID)
  51 {
  52         return (HANDLE)NtCurrentProcess();
  53 }
  54
  55 HANDLE STDCALL GetCurrentThread(VOID)
  56 {
  57         return (HANDLE)NtCurrentThread();
  58 }
  59
  60 DWORD STDCALL GetCurrentProcessId(VOID)
  61 {
  62         return (DWORD)(GetTeb()->Cid).UniqueProcess;
  63 }
  64
  65 WINBOOL STDCALL GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode )
  66 {
  67    NTSTATUS errCode;
  68    PROCESS_BASIC_INFORMATION ProcessBasic;
  69    ULONG BytesWritten;
  70
  71    errCode = NtQueryInformationProcess(hProcess,
  72                                        ProcessBasicInformation,
  73                                        &ProcessBasic,
  74                                        sizeof(PROCESS_BASIC_INFORMATION),
  75                                        &BytesWritten);
  76    if (!NT_SUCCESS(errCode))
  77      {
  78         SetLastError(RtlNtStatusToDosError(errCode));
  79         return FALSE;
  80      }
  81    memcpy( lpExitCode ,&ProcessBasic.ExitStatus,sizeof(DWORD));
  82    return TRUE;
  83 }
  84
  85 WINBOOL STDCALL GetProcessId(HANDLE hProcess, LPDWORD lpProcessId )
  86 {
  87    NTSTATUS errCode;
  88    PROCESS_BASIC_INFORMATION ProcessBasic;
  89    ULONG BytesWritten;
  90
  91    errCode = NtQueryInformationProcess(hProcess,
  92                                        ProcessBasicInformation,
  93                                        &ProcessBasic,
  94                                        sizeof(PROCESS_BASIC_INFORMATION),
  95                                        &BytesWritten);
  96    if (!NT_SUCCESS(errCode))
  97      {
  98         SetLastError(RtlNtStatusToDosError(errCode));
  99         return FALSE;
 100      }
 101    memcpy( lpProcessId ,&ProcessBasic.UniqueProcessId,sizeof(DWORD));
 102    return TRUE;
 103 }
 104
 105 PWSTR InternalAnsiToUnicode(PWSTR Out, LPCSTR In, ULONG MaxLength)
 106 {
 107    ULONG i;
 108
 109    if (In == NULL)
 110      {
 111         return(NULL);
 112      }
 113    else
 114      {
 115         i = 0;
 116         while ((*In)!=0 && i < MaxLength)
 117           {
 118              Out[i] = *In;
 119              In++;
 120              i++;
 121           }
 122         Out[i] = 0;
 123         return(Out);
 124      }
 125 }
 126
 127 HANDLE STDCALL OpenProcess(DWORD dwDesiredAccess,
 128                            WINBOOL bInheritHandle,
 129                            DWORD dwProcessId)
 130 {
 131    NTSTATUS errCode;
 132    HANDLE ProcessHandle;
 133    OBJECT_ATTRIBUTES ObjectAttributes;
 134    CLIENT_ID ClientId ;
 135
 136    ClientId.UniqueProcess = (HANDLE)dwProcessId;
 137    ObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES);
 138    ObjectAttributes.RootDirectory = (HANDLE)NULL;
 139    ObjectAttributes.SecurityDescriptor = NULL;
 140    ObjectAttributes.SecurityQualityOfService = NULL;
 141
 142    if ( bInheritHandle == TRUE )
 143      ObjectAttributes.Attributes = OBJ_INHERIT;
 144    else
 145      ObjectAttributes.Attributes = 0;
 146
 147    errCode = NtOpenProcess(&ProcessHandle,
 148                            dwDesiredAccess,
 149                            &ObjectAttributes,
 150                            &ClientId);
 151    if (!NT_SUCCESS(errCode))
 152      {
 153         SetLastError(RtlNtStatusToDosError(errCode));
 154         return NULL;
 155      }
 156    return ProcessHandle;
 157 }
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171 UINT WinExec (LPCSTR  lpCmdLine, UINT  uCmdShow)
 172 {
 173    STARTUPINFO StartupInfo;
 174    PROCESS_INFORMATION  ProcessInformation;
 175    HINSTANCE hInst;
 176    DWORD dosErr;
 177
 178    StartupInfo.cb = sizeof(STARTUPINFO);
 179    StartupInfo.wShowWindow = uCmdShow ;
 180    StartupInfo.dwFlags = 0;
 181
 182    hInst = (HINSTANCE)CreateProcessA(NULL,
 183                                      (PVOID)lpCmdLine,
 184                                      NULL,
 185                                      NULL,
 186                                      FALSE,
 187                                      0,
 188                                      NULL,
 189                                      NULL,
 190                                      &StartupInfo,
 191                                      &ProcessInformation);
 192    if ( hInst == NULL )
 193      {
 194         dosErr = GetLastError();
 195         return dosErr;
 196      }
 197    if ( lpfnGlobalRegisterWaitForInputIdle != NULL )
 198      lpfnGlobalRegisterWaitForInputIdle(ProcessInformation.hProcess,10000);
 199    NtClose(ProcessInformation.hProcess);
 200    NtClose(ProcessInformation.hThread);
 201    return 0;
 202 }
 203
 204
 205
 206 VOID RegisterWaitForInputIdle(WaitForInputIdleType  lpfnRegisterWaitForInputIdle)
 207 {
 208         lpfnGlobalRegisterWaitForInputIdle = lpfnRegisterWaitForInputIdle;
 209         return;
 210 }
 211
 212 DWORD STDCALL WaitForInputIdle(HANDLE hProcess,
 213                                DWORD dwMilliseconds)
 214 {
 215    return 0;
 216 }
 217
 218 VOID
 219 STDCALL
 220 Sleep(
 221     DWORD dwMilliseconds
 222    )
 223 {
 224         SleepEx(dwMilliseconds,FALSE);
 225         return;
 226 }
 227
 228 DWORD
 229 STDCALL
 230 SleepEx(
 231     DWORD dwMilliseconds,
 232     BOOL bAlertable
 233    )
 234 {
 235         TIME Interval;
 236         NTSTATUS errCode;
 237
 238         Interval.LowPart = dwMilliseconds * 1000;
 239         Interval.HighPart = 0;
 240
 241         errCode = NtDelayExecution(bAlertable,&Interval);
 242         if ( !NT_SUCCESS(errCode) ) {
 243                 SetLastError(RtlNtStatusToDosError(errCode));
 244                 return -1;
 245         }
 246         return 0;
 247 }
 248
 249
 250
 251
 252
 253 VOID STDCALL GetStartupInfoW(LPSTARTUPINFO lpStartupInfo)
 254 {
 255    NT_PEB *pPeb = NtCurrentPeb();
 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->hStdInput = pPeb->StartupInfo->hStdInput;
 280         lpStartupInfo->hStdOutput = pPeb->StartupInfo->hStdOutput;
 281         lpStartupInfo->hStdError = pPeb->StartupInfo->hStdError;
 282
 283
 284
 285         return;
 286
 287
 288
 289 }
 290
 291
 292 VOID STDCALL GetStartupInfoA(LPSTARTUPINFO lpStartupInfo)
 293 {
 294    NT_PEB *pPeb = NtCurrentPeb();
 295    ULONG i = 0;
 296
 297    if (lpStartupInfo == NULL)
 298      {
 299         SetLastError(ERROR_INVALID_PARAMETER);
 300         return;
 301      }
 302
 303    lpStartupInfo->cb = sizeof(STARTUPINFO);
 304    i = 0;
 305
 306    while ((pPeb->StartupInfo->Desktop[i])!=0 && i < MAX_PATH)
 307      {
 308         lpStartupInfo->lpDesktop[i] = (unsigned char)pPeb->StartupInfo->Desktop[i];
 309         i++;
 310      }
 311    lpStartupInfo->lpDesktop[i] = 0;
 312
 313    i = 0;
 314    while ((pPeb->StartupInfo->Title[i])!=0 && i < MAX_PATH)
 315      {
 316         lpStartupInfo->lpTitle[i] = (unsigned char)pPeb->StartupInfo->Title[i];
 317         i++;
 318      }
 319    lpStartupInfo->lpTitle[i] = 0;
 320
 321    lpStartupInfo->dwX = pPeb->StartupInfo->dwX;
 322    lpStartupInfo->dwY = pPeb->StartupInfo->dwY;
 323    lpStartupInfo->dwXSize = pPeb->StartupInfo->dwXSize;
 324    lpStartupInfo->dwYSize = pPeb->StartupInfo->dwYSize;
 325    lpStartupInfo->dwXCountChars = pPeb->StartupInfo->dwXCountChars;
 326    lpStartupInfo->dwYCountChars = pPeb->StartupInfo->dwYCountChars;
 327    lpStartupInfo->dwFillAttribute = pPeb->StartupInfo->dwFillAttribute;
 328    lpStartupInfo->dwFlags = pPeb->StartupInfo->dwFlags;
 329    lpStartupInfo->wShowWindow = pPeb->StartupInfo->wShowWindow;
 330    //lpStartupInfo->cbReserved2 = pPeb->StartupInfo->cbReserved;
 331    //lpStartupInfo->lpReserved = pPeb->StartupInfo->lpReserved1;
 332    //lpStartupInfo->lpReserved2 = pPeb->StartupInfo->lpReserved2;
 333
 334    lpStartupInfo->hStdInput = pPeb->StartupInfo->hStdInput;
 335    lpStartupInfo->hStdOutput = pPeb->StartupInfo->hStdOutput;
 336    lpStartupInfo->hStdError = pPeb->StartupInfo->hStdError;
 337
 338    return;
 339 }
 340
 341 BOOL STDCALL FlushInstructionCache(HANDLE hProcess,
 342                                    LPCVOID lpBaseAddress,
 343                                    DWORD dwSize)
 344 {
 345    NTSTATUS errCode;
 346    errCode = NtFlushInstructionCache(hProcess,(PVOID)lpBaseAddress,dwSize);
 347    if (!NT_SUCCESS(errCode))
 348      {
 349         SetLastError(RtlNtStatusToDosError(errCode));
 350         return FALSE;
 351      }
 352    return TRUE;
 353 }
 354
 355 VOID STDCALL ExitProcess(UINT uExitCode)
 356 {
 357    NtTerminateProcess(NtCurrentProcess() ,uExitCode);
 358 }
 359
 360 VOID STDCALL FatalAppExitA(UINT uAction, LPCSTR lpMessageText)
 361 {
 362    WCHAR MessageTextW[MAX_PATH];
 363    UINT i;
 364    i = 0;
 365    while ((*lpMessageText)!=0 && i < 35)
 366      {
 367         MessageTextW[i] = *lpMessageText;
 368         lpMessageText++;
 369         i++;
 370      }
 371    MessageTextW[i] = 0;
 372
 373    return FatalAppExitW(uAction,MessageTextW);
 374 }
 375
 376
 377
 378 VOID STDCALL FatalAppExitW(UINT uAction, LPCWSTR lpMessageText)
 379 {
 380    return;
 381 }
 382
 383