From 1145a26d92b93e828f31205808041e553dd6af45 Mon Sep 17 00:00:00 2001 From: Eric Kohl Date: Sat, 9 Jan 2010 20:51:33 +0000 Subject: [PATCH] Fix indentation and coding style. No code changes. svn path=/trunk/; revision=45018 --- reactos/dll/win32/kernel32/process/cmdline.c | 99 +- reactos/dll/win32/kernel32/process/job.c | 525 ++++++----- reactos/dll/win32/kernel32/process/proc.c | 937 ++++++++++--------- reactos/dll/win32/kernel32/process/procsup.c | 31 +- reactos/dll/win32/kernel32/process/session.c | 103 +- reactos/dll/win32/kernel32/synch/critical.c | 5 +- reactos/dll/win32/kernel32/synch/event.c | 4 +- reactos/dll/win32/kernel32/synch/mutex.c | 6 +- reactos/dll/win32/kernel32/synch/sem.c | 6 +- reactos/dll/win32/kernel32/synch/timer.c | 9 +- reactos/dll/win32/kernel32/synch/wait.c | 6 +- reactos/dll/win32/kernel32/thread/fiber.c | 32 +- reactos/dll/win32/kernel32/thread/fls.c | 104 +- reactos/dll/win32/kernel32/thread/tls.c | 2 +- 14 files changed, 983 insertions(+), 886 deletions(-) diff --git a/reactos/dll/win32/kernel32/process/cmdline.c b/reactos/dll/win32/kernel32/process/cmdline.c index 0301de14eda..9b84ab92a74 100644 --- a/reactos/dll/win32/kernel32/process/cmdline.c +++ b/reactos/dll/win32/kernel32/process/cmdline.c @@ -27,80 +27,85 @@ static BOOL bCommandLineInitialized = FALSE; /* FUNCTIONS ****************************************************************/ -static VOID -InitCommandLines (VOID) +static +VOID +InitCommandLines(VOID) { - PRTL_USER_PROCESS_PARAMETERS Params; + PRTL_USER_PROCESS_PARAMETERS Params; - /* FIXME - not thread-safe! */ + /* FIXME - not thread-safe! */ - // get command line - Params = NtCurrentPeb()->ProcessParameters; - RtlNormalizeProcessParams (Params); + // get command line + Params = NtCurrentPeb()->ProcessParameters; + RtlNormalizeProcessParams (Params); - // initialize command line buffers - CommandLineStringW.Length = Params->CommandLine.Length; - CommandLineStringW.MaximumLength = CommandLineStringW.Length + sizeof(WCHAR); - CommandLineStringW.Buffer = RtlAllocateHeap(GetProcessHeap(), - HEAP_GENERATE_EXCEPTIONS|HEAP_ZERO_MEMORY, - CommandLineStringW.MaximumLength); - if (CommandLineStringW.Buffer == NULL) - { - return; - } + // initialize command line buffers + CommandLineStringW.Length = Params->CommandLine.Length; + CommandLineStringW.MaximumLength = CommandLineStringW.Length + sizeof(WCHAR); + CommandLineStringW.Buffer = RtlAllocateHeap(GetProcessHeap(), + HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY, + CommandLineStringW.MaximumLength); + if (CommandLineStringW.Buffer == NULL) + { + return; + } - RtlInitAnsiString(&CommandLineStringA, NULL); + RtlInitAnsiString(&CommandLineStringA, NULL); - // copy command line - RtlCopyUnicodeString (&CommandLineStringW, - &(Params->CommandLine)); - CommandLineStringW.Buffer[CommandLineStringW.Length / sizeof(WCHAR)] = 0; + /* Copy command line */ + RtlCopyUnicodeString(&CommandLineStringW, + &(Params->CommandLine)); + CommandLineStringW.Buffer[CommandLineStringW.Length / sizeof(WCHAR)] = 0; - /* convert unicode string to ansi (or oem) */ - if (bIsFileApiAnsi) - RtlUnicodeStringToAnsiString (&CommandLineStringA, - &CommandLineStringW, - TRUE); - else - RtlUnicodeStringToOemString (&CommandLineStringA, - &CommandLineStringW, - TRUE); + /* convert unicode string to ansi (or oem) */ + if (bIsFileApiAnsi) + RtlUnicodeStringToAnsiString(&CommandLineStringA, + &CommandLineStringW, + TRUE); + else + RtlUnicodeStringToOemString(&CommandLineStringA, + &CommandLineStringW, + TRUE); - CommandLineStringA.Buffer[CommandLineStringA.Length] = 0; + CommandLineStringA.Buffer[CommandLineStringA.Length] = 0; - bCommandLineInitialized = TRUE; + bCommandLineInitialized = TRUE; } /* * @implemented */ -LPSTR WINAPI GetCommandLineA(VOID) +LPSTR +WINAPI +GetCommandLineA(VOID) { - if (bCommandLineInitialized == FALSE) - { - InitCommandLines (); - } + if (bCommandLineInitialized == FALSE) + { + InitCommandLines(); + } - DPRINT ("CommandLine \'%s\'\n", CommandLineStringA.Buffer); + DPRINT("CommandLine \'%s\'\n", CommandLineStringA.Buffer); - return(CommandLineStringA.Buffer); + return CommandLineStringA.Buffer; } /* * @implemented */ -LPWSTR WINAPI GetCommandLineW (VOID) +LPWSTR +WINAPI +GetCommandLineW(VOID) { - if (bCommandLineInitialized == FALSE) - { - InitCommandLines (); - } + if (bCommandLineInitialized == FALSE) + { + InitCommandLines(); + } - DPRINT ("CommandLine \'%S\'\n", CommandLineStringW.Buffer); + DPRINT("CommandLine \'%S\'\n", CommandLineStringW.Buffer); - return(CommandLineStringW.Buffer); + return CommandLineStringW.Buffer; } /* EOF */ diff --git a/reactos/dll/win32/kernel32/process/job.c b/reactos/dll/win32/kernel32/process/job.c index 4a066ef5eb8..43a77c905f9 100644 --- a/reactos/dll/win32/kernel32/process/job.c +++ b/reactos/dll/win32/kernel32/process/job.c @@ -27,31 +27,32 @@ WINAPI CreateJobObjectA(LPSECURITY_ATTRIBUTES lpJobAttributes, LPCSTR lpName) { - HANDLE hJob; - ANSI_STRING AnsiName; - UNICODE_STRING UnicodeName; + HANDLE hJob; + ANSI_STRING AnsiName; + UNICODE_STRING UnicodeName; - if(lpName != NULL) - { - NTSTATUS Status; - - RtlInitAnsiString(&AnsiName, lpName); - Status = RtlAnsiStringToUnicodeString(&UnicodeName, &AnsiName, TRUE); - if(!NT_SUCCESS(Status)) + if (lpName != NULL) { - SetLastErrorByStatus(Status); - return FALSE; + NTSTATUS Status; + + RtlInitAnsiString(&AnsiName, lpName); + Status = RtlAnsiStringToUnicodeString(&UnicodeName, &AnsiName, TRUE); + if (!NT_SUCCESS(Status)) + { + SetLastErrorByStatus(Status); + return FALSE; + } } - } - hJob = CreateJobObjectW(lpJobAttributes, - ((lpName != NULL) ? UnicodeName.Buffer : NULL)); + hJob = CreateJobObjectW(lpJobAttributes, + ((lpName != NULL) ? UnicodeName.Buffer : NULL)); - if(lpName != NULL) - { - RtlFreeUnicodeString(&UnicodeName); - } - return hJob; + if (lpName != NULL) + { + RtlFreeUnicodeString(&UnicodeName); + } + + return hJob; } @@ -63,47 +64,48 @@ WINAPI CreateJobObjectW(LPSECURITY_ATTRIBUTES lpJobAttributes, LPCWSTR lpName) { - UNICODE_STRING JobName; - OBJECT_ATTRIBUTES ObjectAttributes; - ULONG Attributes = 0; - PVOID SecurityDescriptor; - HANDLE hJob; - NTSTATUS Status; + UNICODE_STRING JobName; + OBJECT_ATTRIBUTES ObjectAttributes; + ULONG Attributes = 0; + PVOID SecurityDescriptor; + HANDLE hJob; + NTSTATUS Status; - if(lpName != NULL) - { - RtlInitUnicodeString(&JobName, lpName); - } - - if(lpJobAttributes != NULL) - { - if(lpJobAttributes->bInheritHandle) + if (lpName != NULL) { - Attributes |= OBJ_INHERIT; + RtlInitUnicodeString(&JobName, lpName); } - SecurityDescriptor = lpJobAttributes->lpSecurityDescriptor; - } - else - { - SecurityDescriptor = NULL; - } - InitializeObjectAttributes(&ObjectAttributes, - ((lpName != NULL) ? &JobName : NULL), - Attributes, - NULL, - SecurityDescriptor); + if (lpJobAttributes != NULL) + { + if (lpJobAttributes->bInheritHandle) + { + Attributes |= OBJ_INHERIT; + } - Status = NtCreateJobObject(&hJob, - JOB_OBJECT_ALL_ACCESS, - &ObjectAttributes); - if(!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return NULL; - } + SecurityDescriptor = lpJobAttributes->lpSecurityDescriptor; + } + else + { + SecurityDescriptor = NULL; + } - return hJob; + InitializeObjectAttributes(&ObjectAttributes, + ((lpName != NULL) ? &JobName : NULL), + Attributes, + NULL, + SecurityDescriptor); + + Status = NtCreateJobObject(&hJob, + JOB_OBJECT_ALL_ACCESS, + &ObjectAttributes); + if (!NT_SUCCESS(Status)) + { + SetLastErrorByStatus(Status); + return NULL; + } + + return hJob; } @@ -116,36 +118,35 @@ OpenJobObjectW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName) { - OBJECT_ATTRIBUTES ObjectAttributes; - UNICODE_STRING JobName; - HANDLE hJob; - NTSTATUS Status; + OBJECT_ATTRIBUTES ObjectAttributes; + UNICODE_STRING JobName; + HANDLE hJob; + NTSTATUS Status; - if(lpName == NULL) - { - SetLastError(ERROR_INVALID_PARAMETER); - return NULL; - } + if (lpName == NULL) + { + SetLastError(ERROR_INVALID_PARAMETER); + return NULL; + } - RtlInitUnicodeString(&JobName, lpName); + RtlInitUnicodeString(&JobName, lpName); - InitializeObjectAttributes(&ObjectAttributes, - &JobName, - (bInheritHandle ? OBJ_INHERIT : 0), - NULL, - NULL); + InitializeObjectAttributes(&ObjectAttributes, + &JobName, + (bInheritHandle ? OBJ_INHERIT : 0), + NULL, + NULL); - Status = NtOpenJobObject(&hJob, - dwDesiredAccess, - &ObjectAttributes); + Status = NtOpenJobObject(&hJob, + dwDesiredAccess, + &ObjectAttributes); + if (!NT_SUCCESS(Status)) + { + SetLastErrorByStatus(Status); + return NULL; + } - if(!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return NULL; - } - - return hJob; + return hJob; } @@ -158,31 +159,31 @@ OpenJobObjectA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName) { - ANSI_STRING AnsiName; - UNICODE_STRING UnicodeName; - HANDLE hJob; - NTSTATUS Status; + ANSI_STRING AnsiName; + UNICODE_STRING UnicodeName; + HANDLE hJob; + NTSTATUS Status; - if(lpName == NULL) - { - SetLastError(ERROR_INVALID_PARAMETER); - return NULL; - } + if (lpName == NULL) + { + SetLastError(ERROR_INVALID_PARAMETER); + return NULL; + } - RtlInitAnsiString(&AnsiName, lpName); - Status = RtlAnsiStringToUnicodeString(&UnicodeName, &AnsiName, TRUE); - if(!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return FALSE; - } + RtlInitAnsiString(&AnsiName, lpName); + Status = RtlAnsiStringToUnicodeString(&UnicodeName, &AnsiName, TRUE); + if (!NT_SUCCESS(Status)) + { + SetLastErrorByStatus(Status); + return FALSE; + } - hJob = OpenJobObjectW(dwDesiredAccess, - bInheritHandle, - UnicodeName.Buffer); + hJob = OpenJobObjectW(dwDesiredAccess, + bInheritHandle, + UnicodeName.Buffer); - RtlFreeUnicodeString(&UnicodeName); - return hJob; + RtlFreeUnicodeString(&UnicodeName); + return hJob; } @@ -195,17 +196,17 @@ IsProcessInJob(HANDLE ProcessHandle, HANDLE JobHandle, PBOOL Result) { - NTSTATUS Status; + NTSTATUS Status; - Status = NtIsProcessInJob(ProcessHandle, JobHandle); - if(NT_SUCCESS(Status)) - { - *Result = (Status == STATUS_PROCESS_IN_JOB); - return TRUE; - } + Status = NtIsProcessInJob(ProcessHandle, JobHandle); + if (NT_SUCCESS(Status)) + { + *Result = (Status == STATUS_PROCESS_IN_JOB); + return TRUE; + } - SetLastErrorByStatus(Status); - return FALSE; + SetLastErrorByStatus(Status); + return FALSE; } @@ -217,15 +218,16 @@ WINAPI AssignProcessToJobObject(HANDLE hJob, HANDLE hProcess) { - NTSTATUS Status; + NTSTATUS Status; - Status = NtAssignProcessToJobObject(hJob, hProcess); - if(!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return FALSE; - } - return TRUE; + Status = NtAssignProcessToJobObject(hJob, hProcess); + if (!NT_SUCCESS(Status)) + { + SetLastErrorByStatus(Status); + return FALSE; + } + + return TRUE; } @@ -240,66 +242,74 @@ QueryInformationJobObject(HANDLE hJob, DWORD cbJobObjectInformationLength, LPDWORD lpReturnLength) { - NTSTATUS Status; + NTSTATUS Status; - Status = NtQueryInformationJobObject(hJob, - JobObjectInformationClass, - lpJobObjectInformation, - cbJobObjectInformationLength, - lpReturnLength); - if(NT_SUCCESS(Status)) - { - PJOBOBJECT_BASIC_LIMIT_INFORMATION BasicInfo; - switch(JobObjectInformationClass) + Status = NtQueryInformationJobObject(hJob, + JobObjectInformationClass, + lpJobObjectInformation, + cbJobObjectInformationLength, + lpReturnLength); + if (NT_SUCCESS(Status)) { - case JobObjectBasicLimitInformation: - BasicInfo = (PJOBOBJECT_BASIC_LIMIT_INFORMATION)lpJobObjectInformation; - break; - case JobObjectExtendedLimitInformation: - BasicInfo = &((PJOBOBJECT_EXTENDED_LIMIT_INFORMATION)lpJobObjectInformation)->BasicLimitInformation; - break; + PJOBOBJECT_BASIC_LIMIT_INFORMATION BasicInfo; - default: - BasicInfo = NULL; - break; + switch (JobObjectInformationClass) + { + case JobObjectBasicLimitInformation: + BasicInfo = (PJOBOBJECT_BASIC_LIMIT_INFORMATION)lpJobObjectInformation; + break; + + case JobObjectExtendedLimitInformation: + BasicInfo = &((PJOBOBJECT_EXTENDED_LIMIT_INFORMATION)lpJobObjectInformation)->BasicLimitInformation; + break; + + default: + BasicInfo = NULL; + break; + } + + if (BasicInfo != NULL) + { + /* we need to convert the process priority classes in the + JOBOBJECT_BASIC_LIMIT_INFORMATION structure the same way as + GetPriorityClass() converts it! */ + switch (BasicInfo->PriorityClass) + { + case PROCESS_PRIORITY_CLASS_IDLE: + BasicInfo->PriorityClass = IDLE_PRIORITY_CLASS; + break; + + case PROCESS_PRIORITY_CLASS_BELOW_NORMAL: + BasicInfo->PriorityClass = BELOW_NORMAL_PRIORITY_CLASS; + break; + + case PROCESS_PRIORITY_CLASS_NORMAL: + BasicInfo->PriorityClass = NORMAL_PRIORITY_CLASS; + break; + + case PROCESS_PRIORITY_CLASS_ABOVE_NORMAL: + BasicInfo->PriorityClass = ABOVE_NORMAL_PRIORITY_CLASS; + break; + + case PROCESS_PRIORITY_CLASS_HIGH: + BasicInfo->PriorityClass = HIGH_PRIORITY_CLASS; + break; + + case PROCESS_PRIORITY_CLASS_REALTIME: + BasicInfo->PriorityClass = REALTIME_PRIORITY_CLASS; + break; + + default: + BasicInfo->PriorityClass = NORMAL_PRIORITY_CLASS; + break; + } + } + + return TRUE; } - if(BasicInfo != NULL) - { - /* we need to convert the process priority classes in the - JOBOBJECT_BASIC_LIMIT_INFORMATION structure the same way as - GetPriorityClass() converts it! */ - switch(BasicInfo->PriorityClass) - { - case PROCESS_PRIORITY_CLASS_IDLE: - BasicInfo->PriorityClass = IDLE_PRIORITY_CLASS; - break; - case PROCESS_PRIORITY_CLASS_BELOW_NORMAL: - BasicInfo->PriorityClass = BELOW_NORMAL_PRIORITY_CLASS; - break; - case PROCESS_PRIORITY_CLASS_NORMAL: - BasicInfo->PriorityClass = NORMAL_PRIORITY_CLASS; - break; - case PROCESS_PRIORITY_CLASS_ABOVE_NORMAL: - BasicInfo->PriorityClass = ABOVE_NORMAL_PRIORITY_CLASS; - break; - case PROCESS_PRIORITY_CLASS_HIGH: - BasicInfo->PriorityClass = HIGH_PRIORITY_CLASS; - break; - case PROCESS_PRIORITY_CLASS_REALTIME: - BasicInfo->PriorityClass = REALTIME_PRIORITY_CLASS; - break; - default: - BasicInfo->PriorityClass = NORMAL_PRIORITY_CLASS; - break; - } - } - - return TRUE; - } - - SetLastErrorByStatus(Status); - return FALSE; + SetLastErrorByStatus(Status); + return FALSE; } @@ -313,83 +323,91 @@ SetInformationJobObject(HANDLE hJob, LPVOID lpJobObjectInformation, DWORD cbJobObjectInformationLength) { - JOBOBJECT_EXTENDED_LIMIT_INFORMATION ExtendedLimitInfo; - PJOBOBJECT_BASIC_LIMIT_INFORMATION BasicInfo; - PVOID ObjectInfo; - NTSTATUS Status; + JOBOBJECT_EXTENDED_LIMIT_INFORMATION ExtendedLimitInfo; + PJOBOBJECT_BASIC_LIMIT_INFORMATION BasicInfo; + PVOID ObjectInfo; + NTSTATUS Status; - switch(JobObjectInformationClass) - { - case JobObjectBasicLimitInformation: - if(cbJobObjectInformationLength != sizeof(JOBOBJECT_BASIC_LIMIT_INFORMATION)) - { - SetLastError(ERROR_BAD_LENGTH); - return FALSE; - } - ObjectInfo = &ExtendedLimitInfo.BasicLimitInformation; - BasicInfo = (PJOBOBJECT_BASIC_LIMIT_INFORMATION)ObjectInfo; - RtlCopyMemory(ObjectInfo, lpJobObjectInformation, cbJobObjectInformationLength); - break; - - case JobObjectExtendedLimitInformation: - if(cbJobObjectInformationLength != sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION)) - { - SetLastError(ERROR_BAD_LENGTH); - return FALSE; - } - ObjectInfo = &ExtendedLimitInfo; - BasicInfo = &ExtendedLimitInfo.BasicLimitInformation; - RtlCopyMemory(ObjectInfo, lpJobObjectInformation, cbJobObjectInformationLength); - break; - - default: - ObjectInfo = lpJobObjectInformation; - BasicInfo = NULL; - break; - } - - if(BasicInfo != NULL) - { - /* we need to convert the process priority classes in the - JOBOBJECT_BASIC_LIMIT_INFORMATION structure the same way as - SetPriorityClass() converts it! */ - switch(BasicInfo->PriorityClass) + switch (JobObjectInformationClass) { - case IDLE_PRIORITY_CLASS: - BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_IDLE; - break; - case BELOW_NORMAL_PRIORITY_CLASS: - BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_BELOW_NORMAL; - break; - case NORMAL_PRIORITY_CLASS: - BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL; - break; - case ABOVE_NORMAL_PRIORITY_CLASS: - BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_ABOVE_NORMAL; - break; - case HIGH_PRIORITY_CLASS: - BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_HIGH; - break; - case REALTIME_PRIORITY_CLASS: - BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_REALTIME; - break; - default: - BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL; - break; + case JobObjectBasicLimitInformation: + if (cbJobObjectInformationLength != sizeof(JOBOBJECT_BASIC_LIMIT_INFORMATION)) + { + SetLastError(ERROR_BAD_LENGTH); + return FALSE; + } + + ObjectInfo = &ExtendedLimitInfo.BasicLimitInformation; + BasicInfo = (PJOBOBJECT_BASIC_LIMIT_INFORMATION)ObjectInfo; + RtlCopyMemory(ObjectInfo, lpJobObjectInformation, cbJobObjectInformationLength); + break; + + case JobObjectExtendedLimitInformation: + if (cbJobObjectInformationLength != sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION)) + { + SetLastError(ERROR_BAD_LENGTH); + return FALSE; + } + + ObjectInfo = &ExtendedLimitInfo; + BasicInfo = &ExtendedLimitInfo.BasicLimitInformation; + RtlCopyMemory(ObjectInfo, lpJobObjectInformation, cbJobObjectInformationLength); + break; + + default: + ObjectInfo = lpJobObjectInformation; + BasicInfo = NULL; + break; } - } - Status = NtSetInformationJobObject(hJob, - JobObjectInformationClass, - ObjectInfo, - cbJobObjectInformationLength); - if(!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return FALSE; - } + if (BasicInfo != NULL) + { + /* we need to convert the process priority classes in the + JOBOBJECT_BASIC_LIMIT_INFORMATION structure the same way as + SetPriorityClass() converts it! */ + switch(BasicInfo->PriorityClass) + { + case IDLE_PRIORITY_CLASS: + BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_IDLE; + break; - return TRUE; + case BELOW_NORMAL_PRIORITY_CLASS: + BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_BELOW_NORMAL; + break; + + case NORMAL_PRIORITY_CLASS: + BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL; + break; + + case ABOVE_NORMAL_PRIORITY_CLASS: + BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_ABOVE_NORMAL; + break; + + case HIGH_PRIORITY_CLASS: + BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_HIGH; + break; + + case REALTIME_PRIORITY_CLASS: + BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_REALTIME; + break; + + default: + BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL; + break; + } + } + + Status = NtSetInformationJobObject(hJob, + JobObjectInformationClass, + ObjectInfo, + cbJobObjectInformationLength); + if (!NT_SUCCESS(Status)) + { + SetLastErrorByStatus(Status); + return FALSE; + } + + return TRUE; } @@ -401,17 +419,16 @@ WINAPI TerminateJobObject(HANDLE hJob, UINT uExitCode) { - NTSTATUS Status; + NTSTATUS Status; - Status = NtTerminateJobObject(hJob, uExitCode); - if(!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return FALSE; - } + Status = NtTerminateJobObject(hJob, uExitCode); + if (!NT_SUCCESS(Status)) + { + SetLastErrorByStatus(Status); + return FALSE; + } - return TRUE; + return TRUE; } - /* EOF */ diff --git a/reactos/dll/win32/kernel32/process/proc.c b/reactos/dll/win32/kernel32/process/proc.c index 65fd6bba8b7..d6055a6aa97 100644 --- a/reactos/dll/win32/kernel32/process/proc.c +++ b/reactos/dll/win32/kernel32/process/proc.c @@ -33,275 +33,286 @@ RegisterWaitForInputIdle(WaitForInputIdleType lpfnRegisterWaitForInputIdle); /* * @implemented */ -BOOL WINAPI -GetProcessAffinityMask (HANDLE hProcess, - LPDWORD lpProcessAffinityMask, - LPDWORD lpSystemAffinityMask) +BOOL +WINAPI +GetProcessAffinityMask(HANDLE hProcess, + LPDWORD lpProcessAffinityMask, + LPDWORD lpSystemAffinityMask) { - PROCESS_BASIC_INFORMATION ProcessInfo; - SYSTEM_BASIC_INFORMATION SystemInfo; - NTSTATUS Status; + PROCESS_BASIC_INFORMATION ProcessInfo; + SYSTEM_BASIC_INFORMATION SystemInfo; + NTSTATUS Status; - Status = NtQuerySystemInformation(SystemBasicInformation, - &SystemInfo, - sizeof(SystemInfo), - NULL); - if (!NT_SUCCESS(Status)) + Status = NtQuerySystemInformation(SystemBasicInformation, + &SystemInfo, + sizeof(SystemInfo), + NULL); + if (!NT_SUCCESS(Status)) { - SetLastErrorByStatus (Status); - return FALSE; + SetLastErrorByStatus(Status); + return FALSE; } - Status = NtQueryInformationProcess (hProcess, - ProcessBasicInformation, - (PVOID)&ProcessInfo, - sizeof(PROCESS_BASIC_INFORMATION), - NULL); - if (!NT_SUCCESS(Status)) + Status = NtQueryInformationProcess(hProcess, + ProcessBasicInformation, + (PVOID)&ProcessInfo, + sizeof(PROCESS_BASIC_INFORMATION), + NULL); + if (!NT_SUCCESS(Status)) { - SetLastErrorByStatus (Status); - return FALSE; + SetLastErrorByStatus(Status); + return FALSE; } - *lpProcessAffinityMask = (DWORD)ProcessInfo.AffinityMask; - *lpSystemAffinityMask = (DWORD)SystemInfo.ActiveProcessorsAffinityMask; + *lpProcessAffinityMask = (DWORD)ProcessInfo.AffinityMask; + *lpSystemAffinityMask = (DWORD)SystemInfo.ActiveProcessorsAffinityMask; - return TRUE; + return TRUE; } /* * @implemented */ -BOOL WINAPI -SetProcessAffinityMask (HANDLE hProcess, - DWORD dwProcessAffinityMask) +BOOL +WINAPI +SetProcessAffinityMask(HANDLE hProcess, + DWORD dwProcessAffinityMask) { - NTSTATUS Status; + NTSTATUS Status; - Status = NtSetInformationProcess (hProcess, - ProcessAffinityMask, - (PVOID)&dwProcessAffinityMask, - sizeof(DWORD)); - if (!NT_SUCCESS(Status)) + Status = NtSetInformationProcess(hProcess, + ProcessAffinityMask, + (PVOID)&dwProcessAffinityMask, + sizeof(DWORD)); + if (!NT_SUCCESS(Status)) { - SetLastErrorByStatus (Status); - return FALSE; + SetLastErrorByStatus(Status); + return FALSE; } - return TRUE; + return TRUE; } /* * @implemented */ -BOOL WINAPI -GetProcessShutdownParameters (LPDWORD lpdwLevel, - LPDWORD lpdwFlags) +BOOL +WINAPI +GetProcessShutdownParameters(LPDWORD lpdwLevel, + LPDWORD lpdwFlags) { - CSR_API_MESSAGE CsrRequest; - ULONG Request; - NTSTATUS Status; + CSR_API_MESSAGE CsrRequest; + ULONG Request; + NTSTATUS Status; - Request = GET_SHUTDOWN_PARAMETERS; - Status = CsrClientCallServer(&CsrRequest, - NULL, - MAKE_CSR_API(Request, CSR_NATIVE), - sizeof(CSR_API_MESSAGE)); - if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status)) + Request = GET_SHUTDOWN_PARAMETERS; + Status = CsrClientCallServer(&CsrRequest, + NULL, + MAKE_CSR_API(Request, CSR_NATIVE), + sizeof(CSR_API_MESSAGE)); + if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status)) { - SetLastErrorByStatus (Status); - return(FALSE); + SetLastErrorByStatus(Status); + return FALSE; } - *lpdwLevel = CsrRequest.Data.GetShutdownParametersRequest.Level; - *lpdwFlags = CsrRequest.Data.GetShutdownParametersRequest.Flags; + *lpdwLevel = CsrRequest.Data.GetShutdownParametersRequest.Level; + *lpdwFlags = CsrRequest.Data.GetShutdownParametersRequest.Flags; - return(TRUE); + return TRUE; } /* * @implemented */ -BOOL WINAPI -SetProcessShutdownParameters (DWORD dwLevel, - DWORD dwFlags) +BOOL +WINAPI +SetProcessShutdownParameters(DWORD dwLevel, + DWORD dwFlags) { - CSR_API_MESSAGE CsrRequest; - ULONG Request; - NTSTATUS Status; + CSR_API_MESSAGE CsrRequest; + ULONG Request; + NTSTATUS Status; - CsrRequest.Data.SetShutdownParametersRequest.Level = dwLevel; - CsrRequest.Data.SetShutdownParametersRequest.Flags = dwFlags; + CsrRequest.Data.SetShutdownParametersRequest.Level = dwLevel; + CsrRequest.Data.SetShutdownParametersRequest.Flags = dwFlags; - Request = SET_SHUTDOWN_PARAMETERS; - Status = CsrClientCallServer(&CsrRequest, - NULL, - MAKE_CSR_API(Request, CSR_NATIVE), - sizeof(CSR_API_MESSAGE)); - if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status)) + Request = SET_SHUTDOWN_PARAMETERS; + Status = CsrClientCallServer(&CsrRequest, + NULL, + MAKE_CSR_API(Request, CSR_NATIVE), + sizeof(CSR_API_MESSAGE)); + if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status)) { - SetLastErrorByStatus (Status); - return(FALSE); + SetLastErrorByStatus(Status); + return FALSE; } - return(TRUE); + return TRUE; } /* * @implemented */ -BOOL WINAPI -GetProcessWorkingSetSize (HANDLE hProcess, - PSIZE_T lpMinimumWorkingSetSize, - PSIZE_T lpMaximumWorkingSetSize) +BOOL +WINAPI +GetProcessWorkingSetSize(HANDLE hProcess, + PSIZE_T lpMinimumWorkingSetSize, + PSIZE_T lpMaximumWorkingSetSize) { - QUOTA_LIMITS QuotaLimits; - NTSTATUS Status; + QUOTA_LIMITS QuotaLimits; + NTSTATUS Status; - Status = NtQueryInformationProcess(hProcess, - ProcessQuotaLimits, - &QuotaLimits, - sizeof(QUOTA_LIMITS), - NULL); - if (!NT_SUCCESS(Status)) + Status = NtQueryInformationProcess(hProcess, + ProcessQuotaLimits, + &QuotaLimits, + sizeof(QUOTA_LIMITS), + NULL); + if (!NT_SUCCESS(Status)) { - SetLastErrorByStatus(Status); - return(FALSE); + SetLastErrorByStatus(Status); + return FALSE; } - *lpMinimumWorkingSetSize = QuotaLimits.MinimumWorkingSetSize; - *lpMaximumWorkingSetSize = QuotaLimits.MaximumWorkingSetSize; + *lpMinimumWorkingSetSize = QuotaLimits.MinimumWorkingSetSize; + *lpMaximumWorkingSetSize = QuotaLimits.MaximumWorkingSetSize; - return(TRUE); + return TRUE; } /* * @implemented */ -BOOL WINAPI +BOOL +WINAPI SetProcessWorkingSetSize(HANDLE hProcess, - SIZE_T dwMinimumWorkingSetSize, - SIZE_T dwMaximumWorkingSetSize) + SIZE_T dwMinimumWorkingSetSize, + SIZE_T dwMaximumWorkingSetSize) { - QUOTA_LIMITS QuotaLimits; - NTSTATUS Status; + QUOTA_LIMITS QuotaLimits; + NTSTATUS Status; - QuotaLimits.MinimumWorkingSetSize = dwMinimumWorkingSetSize; - QuotaLimits.MaximumWorkingSetSize = dwMaximumWorkingSetSize; + QuotaLimits.MinimumWorkingSetSize = dwMinimumWorkingSetSize; + QuotaLimits.MaximumWorkingSetSize = dwMaximumWorkingSetSize; - Status = NtSetInformationProcess(hProcess, - ProcessQuotaLimits, - &QuotaLimits, - sizeof(QUOTA_LIMITS)); - if (!NT_SUCCESS(Status)) + Status = NtSetInformationProcess(hProcess, + ProcessQuotaLimits, + &QuotaLimits, + sizeof(QUOTA_LIMITS)); + if (!NT_SUCCESS(Status)) { - SetLastErrorByStatus(Status); - return(FALSE); + SetLastErrorByStatus(Status); + return FALSE; } - return(TRUE); + return TRUE; } /* * @implemented */ -BOOL WINAPI +BOOL +WINAPI GetProcessTimes(HANDLE hProcess, - LPFILETIME lpCreationTime, - LPFILETIME lpExitTime, - LPFILETIME lpKernelTime, - LPFILETIME lpUserTime) + LPFILETIME lpCreationTime, + LPFILETIME lpExitTime, + LPFILETIME lpKernelTime, + LPFILETIME lpUserTime) { - KERNEL_USER_TIMES Kut; - NTSTATUS Status; + KERNEL_USER_TIMES Kut; + NTSTATUS Status; - Status = NtQueryInformationProcess(hProcess, - ProcessTimes, - &Kut, - sizeof(Kut), - NULL); - if (!NT_SUCCESS(Status)) + Status = NtQueryInformationProcess(hProcess, + ProcessTimes, + &Kut, + sizeof(Kut), + NULL); + if (!NT_SUCCESS(Status)) { - SetLastErrorByStatus(Status); - return(FALSE); + SetLastErrorByStatus(Status); + return FALSE; } - lpCreationTime->dwLowDateTime = Kut.CreateTime.u.LowPart; - lpCreationTime->dwHighDateTime = Kut.CreateTime.u.HighPart; + lpCreationTime->dwLowDateTime = Kut.CreateTime.u.LowPart; + lpCreationTime->dwHighDateTime = Kut.CreateTime.u.HighPart; - lpExitTime->dwLowDateTime = Kut.ExitTime.u.LowPart; - lpExitTime->dwHighDateTime = Kut.ExitTime.u.HighPart; + lpExitTime->dwLowDateTime = Kut.ExitTime.u.LowPart; + lpExitTime->dwHighDateTime = Kut.ExitTime.u.HighPart; - lpKernelTime->dwLowDateTime = Kut.KernelTime.u.LowPart; - lpKernelTime->dwHighDateTime = Kut.KernelTime.u.HighPart; + lpKernelTime->dwLowDateTime = Kut.KernelTime.u.LowPart; + lpKernelTime->dwHighDateTime = Kut.KernelTime.u.HighPart; - lpUserTime->dwLowDateTime = Kut.UserTime.u.LowPart; - lpUserTime->dwHighDateTime = Kut.UserTime.u.HighPart; + lpUserTime->dwLowDateTime = Kut.UserTime.u.LowPart; + lpUserTime->dwHighDateTime = Kut.UserTime.u.HighPart; - return(TRUE); + return TRUE; } /* * @implemented */ -HANDLE WINAPI +HANDLE +WINAPI GetCurrentProcess(VOID) { - return((HANDLE)NtCurrentProcess()); + return (HANDLE)NtCurrentProcess(); } /* * @implemented */ -HANDLE WINAPI +HANDLE +WINAPI GetCurrentThread(VOID) { - return((HANDLE)NtCurrentThread()); + return (HANDLE)NtCurrentThread(); } /* * @implemented */ -DWORD WINAPI +DWORD +WINAPI GetCurrentProcessId(VOID) { - return((DWORD)GetTeb()->ClientId.UniqueProcess); + return (DWORD)GetTeb()->ClientId.UniqueProcess; } /* * @implemented */ -BOOL WINAPI +BOOL +WINAPI GetExitCodeProcess(HANDLE hProcess, - LPDWORD lpExitCode) + LPDWORD lpExitCode) { - PROCESS_BASIC_INFORMATION ProcessBasic; - NTSTATUS Status; + PROCESS_BASIC_INFORMATION ProcessBasic; + NTSTATUS Status; - Status = NtQueryInformationProcess(hProcess, - ProcessBasicInformation, - &ProcessBasic, - sizeof(PROCESS_BASIC_INFORMATION), - NULL); - if (!NT_SUCCESS(Status)) + Status = NtQueryInformationProcess(hProcess, + ProcessBasicInformation, + &ProcessBasic, + sizeof(PROCESS_BASIC_INFORMATION), + NULL); + if (!NT_SUCCESS(Status)) { - SetLastErrorByStatus(Status); - return(FALSE); - } + SetLastErrorByStatus(Status); + return FALSE; + } - *lpExitCode = (DWORD)ProcessBasic.ExitStatus; + *lpExitCode = (DWORD)ProcessBasic.ExitStatus; - return(TRUE); + return TRUE; } @@ -312,226 +323,230 @@ DWORD WINAPI GetProcessId(HANDLE Process) { - PROCESS_BASIC_INFORMATION ProcessBasic; - NTSTATUS Status; + PROCESS_BASIC_INFORMATION ProcessBasic; + NTSTATUS Status; - Status = NtQueryInformationProcess(Process, - ProcessBasicInformation, - &ProcessBasic, - sizeof(PROCESS_BASIC_INFORMATION), - NULL); - if (!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return 0; - } + Status = NtQueryInformationProcess(Process, + ProcessBasicInformation, + &ProcessBasic, + sizeof(PROCESS_BASIC_INFORMATION), + NULL); + if (!NT_SUCCESS(Status)) + { + SetLastErrorByStatus(Status); + return 0; + } - return (DWORD)ProcessBasic.UniqueProcessId; + return (DWORD)ProcessBasic.UniqueProcessId; } /* * @implemented */ -HANDLE WINAPI +HANDLE +WINAPI OpenProcess(DWORD dwDesiredAccess, - BOOL bInheritHandle, - DWORD dwProcessId) + BOOL bInheritHandle, + DWORD dwProcessId) { - NTSTATUS errCode; - HANDLE ProcessHandle; - OBJECT_ATTRIBUTES ObjectAttributes; - CLIENT_ID ClientId; + NTSTATUS errCode; + HANDLE ProcessHandle; + OBJECT_ATTRIBUTES ObjectAttributes; + CLIENT_ID ClientId; - ClientId.UniqueProcess = (HANDLE)dwProcessId; - ClientId.UniqueThread = 0; + ClientId.UniqueProcess = (HANDLE)dwProcessId; + ClientId.UniqueThread = 0; - InitializeObjectAttributes(&ObjectAttributes, - NULL, - (bInheritHandle ? OBJ_INHERIT : 0), - NULL, - NULL); + InitializeObjectAttributes(&ObjectAttributes, + NULL, + (bInheritHandle ? OBJ_INHERIT : 0), + NULL, + NULL); - errCode = NtOpenProcess(&ProcessHandle, - dwDesiredAccess, - &ObjectAttributes, - &ClientId); - if (!NT_SUCCESS(errCode)) - { - SetLastErrorByStatus (errCode); - return NULL; - } - return ProcessHandle; + errCode = NtOpenProcess(&ProcessHandle, + dwDesiredAccess, + &ObjectAttributes, + &ClientId); + if (!NT_SUCCESS(errCode)) + { + SetLastErrorByStatus(errCode); + return NULL; + } + + return ProcessHandle; } /* * @implemented */ -UINT WINAPI +UINT +WINAPI WinExec(LPCSTR lpCmdLine, - UINT uCmdShow) + UINT uCmdShow) { - STARTUPINFOA StartupInfo; - PROCESS_INFORMATION ProcessInformation; - DWORD dosErr; + STARTUPINFOA StartupInfo; + PROCESS_INFORMATION ProcessInformation; + DWORD dosErr; - RtlZeroMemory(&StartupInfo, sizeof(StartupInfo)); - StartupInfo.cb = sizeof(STARTUPINFOA); - StartupInfo.wShowWindow = (WORD)uCmdShow; - StartupInfo.dwFlags = 0; + RtlZeroMemory(&StartupInfo, sizeof(StartupInfo)); + StartupInfo.cb = sizeof(STARTUPINFOA); + StartupInfo.wShowWindow = (WORD)uCmdShow; + StartupInfo.dwFlags = 0; - if (! CreateProcessA(NULL, - (PVOID)lpCmdLine, - NULL, - NULL, - FALSE, - 0, - NULL, - NULL, - &StartupInfo, - &ProcessInformation)) - { - dosErr = GetLastError(); - return dosErr < 32 ? dosErr : ERROR_BAD_FORMAT; - } - if (NULL != lpfnGlobalRegisterWaitForInputIdle) - { - lpfnGlobalRegisterWaitForInputIdle ( - ProcessInformation.hProcess, - 10000 - ); - } - NtClose(ProcessInformation.hProcess); - NtClose(ProcessInformation.hThread); + if (!CreateProcessA(NULL, + (PVOID)lpCmdLine, + NULL, + NULL, + FALSE, + 0, + NULL, + NULL, + &StartupInfo, + &ProcessInformation)) + { + dosErr = GetLastError(); + return dosErr < 32 ? dosErr : ERROR_BAD_FORMAT; + } - return 33; /* Something bigger than 31 means success. */ + if (NULL != lpfnGlobalRegisterWaitForInputIdle) + { + lpfnGlobalRegisterWaitForInputIdle(ProcessInformation.hProcess, + 10000); + } + + NtClose(ProcessInformation.hProcess); + NtClose(ProcessInformation.hThread); + + return 33; /* Something bigger than 31 means success. */ } /* * @implemented */ -VOID WINAPI -RegisterWaitForInputIdle ( - WaitForInputIdleType lpfnRegisterWaitForInputIdle - ) +VOID +WINAPI +RegisterWaitForInputIdle(WaitForInputIdleType lpfnRegisterWaitForInputIdle) { - lpfnGlobalRegisterWaitForInputIdle = lpfnRegisterWaitForInputIdle; - return; + lpfnGlobalRegisterWaitForInputIdle = lpfnRegisterWaitForInputIdle; + return; } /* * @implemented */ -VOID WINAPI +VOID +WINAPI GetStartupInfoW(LPSTARTUPINFOW lpStartupInfo) { - PRTL_USER_PROCESS_PARAMETERS Params; + PRTL_USER_PROCESS_PARAMETERS Params; - if (lpStartupInfo == NULL) + if (lpStartupInfo == NULL) { - SetLastError(ERROR_INVALID_PARAMETER); - return; + SetLastError(ERROR_INVALID_PARAMETER); + return; } - Params = NtCurrentPeb()->ProcessParameters; + Params = NtCurrentPeb()->ProcessParameters; - lpStartupInfo->cb = sizeof(STARTUPINFOW); - lpStartupInfo->lpDesktop = Params->DesktopInfo.Buffer; - lpStartupInfo->lpTitle = Params->WindowTitle.Buffer; - lpStartupInfo->dwX = Params->StartingX; - lpStartupInfo->dwY = Params->StartingY; - lpStartupInfo->dwXSize = Params->CountX; - lpStartupInfo->dwYSize = Params->CountY; - lpStartupInfo->dwXCountChars = Params->CountCharsX; - lpStartupInfo->dwYCountChars = Params->CountCharsY; - lpStartupInfo->dwFillAttribute = Params->FillAttribute; - lpStartupInfo->dwFlags = Params->WindowFlags; - lpStartupInfo->wShowWindow = (WORD)Params->ShowWindowFlags; - lpStartupInfo->cbReserved2 = Params->RuntimeData.Length; - lpStartupInfo->lpReserved2 = (LPBYTE)Params->RuntimeData.Buffer; - - lpStartupInfo->hStdInput = Params->StandardInput; - lpStartupInfo->hStdOutput = Params->StandardOutput; - lpStartupInfo->hStdError = Params->StandardError; + lpStartupInfo->cb = sizeof(STARTUPINFOW); + lpStartupInfo->lpDesktop = Params->DesktopInfo.Buffer; + lpStartupInfo->lpTitle = Params->WindowTitle.Buffer; + lpStartupInfo->dwX = Params->StartingX; + lpStartupInfo->dwY = Params->StartingY; + lpStartupInfo->dwXSize = Params->CountX; + lpStartupInfo->dwYSize = Params->CountY; + lpStartupInfo->dwXCountChars = Params->CountCharsX; + lpStartupInfo->dwYCountChars = Params->CountCharsY; + lpStartupInfo->dwFillAttribute = Params->FillAttribute; + lpStartupInfo->dwFlags = Params->WindowFlags; + lpStartupInfo->wShowWindow = (WORD)Params->ShowWindowFlags; + lpStartupInfo->cbReserved2 = Params->RuntimeData.Length; + lpStartupInfo->lpReserved2 = (LPBYTE)Params->RuntimeData.Buffer; + + lpStartupInfo->hStdInput = Params->StandardInput; + lpStartupInfo->hStdOutput = Params->StandardOutput; + lpStartupInfo->hStdError = Params->StandardError; } /* * @implemented */ -VOID WINAPI +VOID +WINAPI GetStartupInfoA(LPSTARTUPINFOA lpStartupInfo) { - PRTL_USER_PROCESS_PARAMETERS Params; - ANSI_STRING AnsiString; + PRTL_USER_PROCESS_PARAMETERS Params; + ANSI_STRING AnsiString; - if (lpStartupInfo == NULL) + if (lpStartupInfo == NULL) { - SetLastError(ERROR_INVALID_PARAMETER); - return; + SetLastError(ERROR_INVALID_PARAMETER); + return; } - Params = NtCurrentPeb ()->ProcessParameters; + Params = NtCurrentPeb ()->ProcessParameters; - RtlAcquirePebLock (); + RtlAcquirePebLock (); - /* FIXME - not thread-safe */ - if (lpLocalStartupInfo == NULL) + /* FIXME - not thread-safe */ + if (lpLocalStartupInfo == NULL) { - /* create new local startup info (ansi) */ - lpLocalStartupInfo = RtlAllocateHeap (RtlGetProcessHeap (), - 0, - sizeof(STARTUPINFOA)); + /* create new local startup info (ansi) */ + lpLocalStartupInfo = RtlAllocateHeap(RtlGetProcessHeap(), + 0, + sizeof(STARTUPINFOA)); if (lpLocalStartupInfo == NULL) { - RtlReleasePebLock (); + RtlReleasePebLock(); SetLastError(ERROR_NOT_ENOUGH_MEMORY); return; } - lpLocalStartupInfo->cb = sizeof(STARTUPINFOA); + lpLocalStartupInfo->cb = sizeof(STARTUPINFOA); - /* copy window title string */ - RtlUnicodeStringToAnsiString (&AnsiString, - &Params->WindowTitle, - TRUE); - lpLocalStartupInfo->lpTitle = AnsiString.Buffer; + /* copy window title string */ + RtlUnicodeStringToAnsiString(&AnsiString, + &Params->WindowTitle, + TRUE); + lpLocalStartupInfo->lpTitle = AnsiString.Buffer; - /* copy desktop info string */ - RtlUnicodeStringToAnsiString (&AnsiString, - &Params->DesktopInfo, - TRUE); - lpLocalStartupInfo->lpDesktop = AnsiString.Buffer; + /* copy desktop info string */ + RtlUnicodeStringToAnsiString(&AnsiString, + &Params->DesktopInfo, + TRUE); + lpLocalStartupInfo->lpDesktop = AnsiString.Buffer; - /* copy shell info string */ - RtlUnicodeStringToAnsiString (&AnsiString, - &Params->ShellInfo, - TRUE); - lpLocalStartupInfo->lpReserved = AnsiString.Buffer; + /* copy shell info string */ + RtlUnicodeStringToAnsiString(&AnsiString, + &Params->ShellInfo, + TRUE); + lpLocalStartupInfo->lpReserved = AnsiString.Buffer; - lpLocalStartupInfo->dwX = Params->StartingX; - lpLocalStartupInfo->dwY = Params->StartingY; - lpLocalStartupInfo->dwXSize = Params->CountX; - lpLocalStartupInfo->dwYSize = Params->CountY; - lpLocalStartupInfo->dwXCountChars = Params->CountCharsX; - lpLocalStartupInfo->dwYCountChars = Params->CountCharsY; - lpLocalStartupInfo->dwFillAttribute = Params->FillAttribute; - lpLocalStartupInfo->dwFlags = Params->WindowFlags; - lpLocalStartupInfo->wShowWindow = (WORD)Params->ShowWindowFlags; - lpLocalStartupInfo->cbReserved2 = Params->RuntimeData.Length; - lpLocalStartupInfo->lpReserved2 = (LPBYTE)Params->RuntimeData.Buffer; + lpLocalStartupInfo->dwX = Params->StartingX; + lpLocalStartupInfo->dwY = Params->StartingY; + lpLocalStartupInfo->dwXSize = Params->CountX; + lpLocalStartupInfo->dwYSize = Params->CountY; + lpLocalStartupInfo->dwXCountChars = Params->CountCharsX; + lpLocalStartupInfo->dwYCountChars = Params->CountCharsY; + lpLocalStartupInfo->dwFillAttribute = Params->FillAttribute; + lpLocalStartupInfo->dwFlags = Params->WindowFlags; + lpLocalStartupInfo->wShowWindow = (WORD)Params->ShowWindowFlags; + lpLocalStartupInfo->cbReserved2 = Params->RuntimeData.Length; + lpLocalStartupInfo->lpReserved2 = (LPBYTE)Params->RuntimeData.Buffer; - lpLocalStartupInfo->hStdInput = Params->StandardInput; - lpLocalStartupInfo->hStdOutput = Params->StandardOutput; - lpLocalStartupInfo->hStdError = Params->StandardError; - } + lpLocalStartupInfo->hStdInput = Params->StandardInput; + lpLocalStartupInfo->hStdOutput = Params->StandardOutput; + lpLocalStartupInfo->hStdError = Params->StandardError; + } - RtlReleasePebLock (); + RtlReleasePebLock(); - /* copy local startup info data to external startup info */ - memcpy (lpStartupInfo, + /* copy local startup info data to external startup info */ + memcpy(lpStartupInfo, lpLocalStartupInfo, sizeof(STARTUPINFOA)); } @@ -540,112 +555,118 @@ GetStartupInfoA(LPSTARTUPINFOA lpStartupInfo) /* * @implemented */ -BOOL WINAPI -FlushInstructionCache (HANDLE hProcess, - LPCVOID lpBaseAddress, - DWORD dwSize) +BOOL +WINAPI +FlushInstructionCache(HANDLE hProcess, + LPCVOID lpBaseAddress, + DWORD dwSize) { - NTSTATUS Status; + NTSTATUS Status; - Status = NtFlushInstructionCache(hProcess, - (PVOID)lpBaseAddress, - dwSize); - if (!NT_SUCCESS(Status)) + Status = NtFlushInstructionCache(hProcess, + (PVOID)lpBaseAddress, + dwSize); + if (!NT_SUCCESS(Status)) { - SetLastErrorByStatus(Status); - return FALSE; + SetLastErrorByStatus(Status); + return FALSE; } - return TRUE; + + return TRUE; } /* * @implemented */ -VOID WINAPI +VOID +WINAPI ExitProcess(UINT uExitCode) { - CSR_API_MESSAGE CsrRequest; - ULONG Request; - NTSTATUS Status; + CSR_API_MESSAGE CsrRequest; + ULONG Request; + NTSTATUS Status; - /* kill sibling threads ... we want to be alone at this point */ - NtTerminateProcess (NULL, 0); + /* kill sibling threads ... we want to be alone at this point */ + NtTerminateProcess(NULL, 0); - /* unload all dll's */ - LdrShutdownProcess (); + /* unload all dll's */ + LdrShutdownProcess(); - /* notify csrss of process termination */ - Request = TERMINATE_PROCESS; - Status = CsrClientCallServer(&CsrRequest, - NULL, - MAKE_CSR_API(Request, CSR_NATIVE), - sizeof(CSR_API_MESSAGE)); - if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status)) + /* notify csrss of process termination */ + Request = TERMINATE_PROCESS; + Status = CsrClientCallServer(&CsrRequest, + NULL, + MAKE_CSR_API(Request, CSR_NATIVE), + sizeof(CSR_API_MESSAGE)); + if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status)) { - DPRINT("Failed to tell csrss about terminating process\n"); + DPRINT("Failed to tell csrss about terminating process\n"); } + NtTerminateProcess(NtCurrentProcess (), + uExitCode); - NtTerminateProcess (NtCurrentProcess (), - uExitCode); - - /* should never get here */ - ASSERT(0); - while(1); + /* should never get here */ + ASSERT(0); + while(1); } /* * @implemented */ -BOOL WINAPI -TerminateProcess (HANDLE hProcess, - UINT uExitCode) +BOOL +WINAPI +TerminateProcess(HANDLE hProcess, + UINT uExitCode) { - NTSTATUS Status; + NTSTATUS Status; - if (hProcess == NULL) + if (hProcess == NULL) { return FALSE; } - Status = NtTerminateProcess (hProcess, uExitCode); - if (NT_SUCCESS(Status)) + Status = NtTerminateProcess(hProcess, uExitCode); + if (NT_SUCCESS(Status)) { - return TRUE; + return TRUE; } - SetLastErrorByStatus (Status); - return FALSE; + + SetLastErrorByStatus(Status); + return FALSE; } /* * @unimplemented */ -VOID WINAPI +VOID +WINAPI FatalAppExitA(UINT uAction, - LPCSTR lpMessageText) + LPCSTR lpMessageText) { - UNICODE_STRING MessageTextU; - ANSI_STRING MessageText; + UNICODE_STRING MessageTextU; + ANSI_STRING MessageText; - RtlInitAnsiString (&MessageText, (LPSTR) lpMessageText); + RtlInitAnsiString(&MessageText, (LPSTR)lpMessageText); - RtlAnsiStringToUnicodeString (&MessageTextU, - &MessageText, - TRUE); + RtlAnsiStringToUnicodeString(&MessageTextU, + &MessageText, + TRUE); - FatalAppExitW (uAction, MessageTextU.Buffer); + FatalAppExitW(uAction, MessageTextU.Buffer); - RtlFreeUnicodeString (&MessageTextU); + RtlFreeUnicodeString(&MessageTextU); } /* * @unimplemented */ -VOID WINAPI +VOID +WINAPI FatalAppExitW(UINT uAction, LPCWSTR lpMessageText) { @@ -657,7 +678,7 @@ FatalAppExitW(UINT uAction, DPRINT1("AppExit\n"); if (hModule) - pMessageBoxW = (MessageBoxW_Proc) GetProcAddress(hModule, "MessageBoxW"); + pMessageBoxW = (MessageBoxW_Proc)GetProcAddress(hModule, "MessageBoxW"); if (pMessageBoxW) pMessageBoxW(0, lpMessageText, NULL, MB_SYSTEMMODAL | MB_OK); @@ -671,18 +692,20 @@ FatalAppExitW(UINT uAction, /* * @implemented */ -VOID WINAPI -FatalExit (int ExitCode) +VOID +WINAPI +FatalExit(int ExitCode) { - ExitProcess(ExitCode); + ExitProcess(ExitCode); } /* * @implemented */ -DWORD WINAPI -GetPriorityClass (HANDLE hProcess) +DWORD +WINAPI +GetPriorityClass(HANDLE hProcess) { NTSTATUS Status; PROCESS_PRIORITY_CLASS PriorityClass; @@ -727,65 +750,66 @@ GetPriorityClass (HANDLE hProcess) /* * @implemented */ -BOOL WINAPI -SetPriorityClass (HANDLE hProcess, - DWORD dwPriorityClass) +BOOL +WINAPI +SetPriorityClass(HANDLE hProcess, + DWORD dwPriorityClass) { - NTSTATUS Status; - PROCESS_PRIORITY_CLASS PriorityClass; + NTSTATUS Status; + PROCESS_PRIORITY_CLASS PriorityClass; - switch(dwPriorityClass) - { - case IDLE_PRIORITY_CLASS: - PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_IDLE; - break; + switch (dwPriorityClass) + { + case IDLE_PRIORITY_CLASS: + PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_IDLE; + break; - case BELOW_NORMAL_PRIORITY_CLASS: - PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_BELOW_NORMAL; - break; + case BELOW_NORMAL_PRIORITY_CLASS: + PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_BELOW_NORMAL; + break; - case NORMAL_PRIORITY_CLASS: - PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL; - break; + case NORMAL_PRIORITY_CLASS: + PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL; + break; - case ABOVE_NORMAL_PRIORITY_CLASS: - PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_ABOVE_NORMAL; - break; + case ABOVE_NORMAL_PRIORITY_CLASS: + PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_ABOVE_NORMAL; + break; - case HIGH_PRIORITY_CLASS: - PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_HIGH; - break; + case HIGH_PRIORITY_CLASS: + PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_HIGH; + break; - case REALTIME_PRIORITY_CLASS: - PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_REALTIME; - break; + case REALTIME_PRIORITY_CLASS: + PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_REALTIME; + break; - default: - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } + default: + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } - PriorityClass.Foreground = FALSE; + PriorityClass.Foreground = FALSE; - Status = NtSetInformationProcess(hProcess, - ProcessPriorityClass, - &PriorityClass, - sizeof(PROCESS_PRIORITY_CLASS)); + Status = NtSetInformationProcess(hProcess, + ProcessPriorityClass, + &PriorityClass, + sizeof(PROCESS_PRIORITY_CLASS)); + if (!NT_SUCCESS(Status)) + { + SetLastErrorByStatus(Status); + return FALSE; + } - if(!NT_SUCCESS(Status)) - { - SetLastErrorByStatus(Status); - return FALSE; - } - - return TRUE; + return TRUE; } /* * @implemented */ -DWORD WINAPI +DWORD +WINAPI GetProcessVersion(DWORD ProcessId) { DWORD Version = 0; @@ -801,17 +825,18 @@ GetProcessVersion(DWORD ProcessId) _SEH2_TRY { - /* Caller's */ if (0 == ProcessId || GetCurrentProcessId() == ProcessId) { + /* Caller's */ BaseAddress = (PVOID) NtCurrentPeb()->ImageBaseAddress; NtHeader = RtlImageNtHeader(BaseAddress); Version = (NtHeader->OptionalHeader.MajorOperatingSystemVersion << 16) | (NtHeader->OptionalHeader.MinorOperatingSystemVersion); } - else /* other process */ + else { + /* Other process */ ProcessHandle = OpenProcess(PROCESS_VM_READ | PROCESS_QUERY_INFORMATION, FALSE, ProcessId); @@ -823,14 +848,16 @@ GetProcessVersion(DWORD ProcessId) &ProcessBasicInfo, sizeof(ProcessBasicInfo), NULL); - if (!NT_SUCCESS(Status)) goto Error; + if (!NT_SUCCESS(Status)) + goto Error; Status = NtReadVirtualMemory(ProcessHandle, ProcessBasicInfo.PebBaseAddress, &Peb, sizeof(Peb), &Count); - if (!NT_SUCCESS(Status) || Count != sizeof(Peb)) goto Error; + if (!NT_SUCCESS(Status) || Count != sizeof(Peb)) + goto Error; memset(&DosHeader, 0, sizeof(DosHeader)); Status = NtReadVirtualMemory(ProcessHandle, @@ -839,8 +866,11 @@ GetProcessVersion(DWORD ProcessId) sizeof(DosHeader), &Count); - if (!NT_SUCCESS(Status) || Count != sizeof(DosHeader)) goto Error; - if (DosHeader.e_magic != IMAGE_DOS_SIGNATURE) goto Error; + if (!NT_SUCCESS(Status) || Count != sizeof(DosHeader)) + goto Error; + + if (DosHeader.e_magic != IMAGE_DOS_SIGNATURE) + goto Error; memset(&NtHeaders, 0, sizeof(NtHeaders)); Status = NtReadVirtualMemory(ProcessHandle, @@ -849,8 +879,11 @@ GetProcessVersion(DWORD ProcessId) sizeof(NtHeaders), &Count); - if (!NT_SUCCESS(Status) || Count != sizeof(NtHeaders)) goto Error; - if (NtHeaders.Signature != IMAGE_NT_SIGNATURE) goto Error; + if (!NT_SUCCESS(Status) || Count != sizeof(NtHeaders)) + goto Error; + + if (NtHeaders.Signature != IMAGE_NT_SIGNATURE) + goto Error; Version = MAKELONG(NtHeaders.OptionalHeader.MinorSubsystemVersion, NtHeaders.OptionalHeader.MajorSubsystemVersion); @@ -864,7 +897,8 @@ Error: } _SEH2_FINALLY { - if (ProcessHandle) CloseHandle(ProcessHandle); + if (ProcessHandle) + CloseHandle(ProcessHandle); } _SEH2_END; @@ -877,24 +911,23 @@ Error: */ BOOL WINAPI -GetProcessIoCounters( - HANDLE hProcess, - PIO_COUNTERS lpIoCounters) +GetProcessIoCounters(HANDLE hProcess, + PIO_COUNTERS lpIoCounters) { - NTSTATUS Status; + NTSTATUS Status; - Status = NtQueryInformationProcess(hProcess, - ProcessIoCounters, - lpIoCounters, - sizeof(IO_COUNTERS), - NULL); - if (!NT_SUCCESS(Status)) + Status = NtQueryInformationProcess(hProcess, + ProcessIoCounters, + lpIoCounters, + sizeof(IO_COUNTERS), + NULL); + if (!NT_SUCCESS(Status)) { - SetLastErrorByStatus(Status); - return(FALSE); + SetLastErrorByStatus(Status); + return FALSE; } - return TRUE; + return TRUE; } @@ -906,22 +939,22 @@ WINAPI GetProcessPriorityBoost(HANDLE hProcess, PBOOL pDisablePriorityBoost) { - NTSTATUS Status; - ULONG PriorityBoost; + NTSTATUS Status; + ULONG PriorityBoost; - Status = NtQueryInformationProcess(hProcess, - ProcessPriorityBoost, - &PriorityBoost, - sizeof(ULONG), - NULL); - if (NT_SUCCESS(Status)) + Status = NtQueryInformationProcess(hProcess, + ProcessPriorityBoost, + &PriorityBoost, + sizeof(ULONG), + NULL); + if (NT_SUCCESS(Status)) { - *pDisablePriorityBoost = PriorityBoost; - return TRUE; + *pDisablePriorityBoost = PriorityBoost; + return TRUE; } - SetLastErrorByStatus(Status); - return FALSE; + SetLastErrorByStatus(Status); + return FALSE; } @@ -933,20 +966,20 @@ WINAPI SetProcessPriorityBoost(HANDLE hProcess, BOOL bDisablePriorityBoost) { - NTSTATUS Status; - ULONG PriorityBoost = (bDisablePriorityBoost ? TRUE : FALSE); /* prevent setting values other than 1 and 0 */ + NTSTATUS Status; + ULONG PriorityBoost = (bDisablePriorityBoost ? TRUE : FALSE); /* prevent setting values other than 1 and 0 */ - Status = NtSetInformationProcess(hProcess, - ProcessPriorityBoost, - &PriorityBoost, - sizeof(ULONG)); - if (!NT_SUCCESS(Status)) + Status = NtSetInformationProcess(hProcess, + ProcessPriorityBoost, + &PriorityBoost, + sizeof(ULONG)); + if (!NT_SUCCESS(Status)) { - SetLastErrorByStatus(Status); - return FALSE; + SetLastErrorByStatus(Status); + return FALSE; } - return TRUE; + return TRUE; } @@ -982,10 +1015,8 @@ GetProcessHandleCount(HANDLE hProcess, */ BOOL WINAPI -IsWow64Process( - HANDLE hProcess, - PBOOL Wow64Process - ) +IsWow64Process(HANDLE hProcess, + PBOOL Wow64Process) { ULONG pbi; NTSTATUS Status; @@ -995,7 +1026,6 @@ IsWow64Process( &pbi, sizeof(pbi), NULL); - if (!NT_SUCCESS(Status)) { SetLastError(RtlNtStatusToDosError(Status)); @@ -1003,6 +1033,7 @@ IsWow64Process( } *Wow64Process = (pbi != 0); + return TRUE; } @@ -1044,9 +1075,11 @@ QueryFullProcessImageNameW(HANDLE hProcess, &Needed); Result = DynamicBuffer; } - else Result = (PUNICODE_STRING)Buffer; + else + Result = (PUNICODE_STRING)Buffer; - if (!NT_SUCCESS(Status)) goto Cleanup; + if (!NT_SUCCESS(Status)) + goto Cleanup; if (Result->Length / sizeof(WCHAR) + 1 > *pdwSize) { @@ -1065,6 +1098,7 @@ Cleanup: { SetLastErrorByStatus(Status); } + return !Status; } @@ -1101,6 +1135,7 @@ QueryFullProcessImageNameA(HANDLE hProcess, lpExeName, *pdwSize, NULL, NULL)); + if (Result) *pdwSize = strlen(lpExeName); diff --git a/reactos/dll/win32/kernel32/process/procsup.c b/reactos/dll/win32/kernel32/process/procsup.c index 843dc1f9ba4..137b4a9f690 100644 --- a/reactos/dll/win32/kernel32/process/procsup.c +++ b/reactos/dll/win32/kernel32/process/procsup.c @@ -294,7 +294,8 @@ BasepDuplicateAndWriteHandle(IN HANDLE ProcessHandle, "Address: %p\n", ProcessHandle, StandardHandle, Address); /* Don't touch Console Handles */ - if (IsConsoleHandle(StandardHandle)) return; + if (IsConsoleHandle(StandardHandle)) + return; /* Duplicate the handle */ Status = NtDuplicateObject(NtCurrentProcess(), @@ -1017,7 +1018,8 @@ GetAppName: CmdLineLength = wcslen(CMD_STRING) + wcslen(lpCommandLine) + 1; /* If we found quotes, then add them into the length size */ - if (CmdLineIsAppName || FoundQuotes) CmdLineLength += 2; + if (CmdLineIsAppName || FoundQuotes) + CmdLineLength += 2; CmdLineLength *= sizeof(WCHAR); /* Allocate space for the new command line */ @@ -1177,7 +1179,7 @@ GetAppName: hSection, hDebug, NULL); - if(!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { DPRINT1("Unable to create process, status 0x%x\n", Status); SetLastErrorByStatus(Status); @@ -1311,7 +1313,8 @@ GetAppName: if(lpEnvironment && !(dwCreationFlags & CREATE_UNICODE_ENVIRONMENT)) { lpEnvironment = BasepConvertUnicodeEnvironment(&EnvSize, lpEnvironment); - if (!lpEnvironment) goto Cleanup; + if (!lpEnvironment) + goto Cleanup; } /* Create Process Environment */ @@ -1419,21 +1422,31 @@ GetAppName: Cleanup: /* De-allocate heap strings */ - if (NameBuffer) RtlFreeHeap(RtlGetProcessHeap(), 0, NameBuffer); + if (NameBuffer) + RtlFreeHeap(RtlGetProcessHeap(), 0, NameBuffer); + if (ApplicationName.Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, ApplicationName.Buffer); - if (CurrentDirectory) RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentDirectory); - if (QuotedCmdLine) RtlFreeHeap(RtlGetProcessHeap(), 0, QuotedCmdLine); + + if (CurrentDirectory) + RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentDirectory); + + if (QuotedCmdLine) + RtlFreeHeap(RtlGetProcessHeap(), 0, QuotedCmdLine); /* Kill any handles still alive */ - if (hSection) NtClose(hSection); + if (hSection) + NtClose(hSection); + if (hThread) { /* We don't know any more details then this */ NtTerminateProcess(hProcess, STATUS_UNSUCCESSFUL); NtClose(hThread); } - if (hProcess) NtClose(hProcess); + + if (hProcess) + NtClose(hProcess); /* Return Success */ return Ret; diff --git a/reactos/dll/win32/kernel32/process/session.c b/reactos/dll/win32/kernel32/process/session.c index 75959b59f66..b006e3cbd74 100644 --- a/reactos/dll/win32/kernel32/process/session.c +++ b/reactos/dll/win32/kernel32/process/session.c @@ -19,11 +19,14 @@ DWORD ActiveConsoleSessionId = 0; /* * @unimplemented */ -DWORD WINAPI -DosPathToSessionPathW (DWORD SessionID, LPWSTR InPath, LPWSTR * OutPath) +DWORD +WINAPI +DosPathToSessionPathW(DWORD SessionID, + LPWSTR InPath, + LPWSTR *OutPath) { UNIMPLEMENTED; - return 0; + return 0; } /* @@ -39,68 +42,74 @@ DosPathToSessionPathW (DWORD SessionID, LPWSTR InPath, LPWSTR * OutPath) * * @unimplemented */ -DWORD WINAPI -DosPathToSessionPathA (DWORD SessionId, LPSTR InPath, LPSTR * OutPath) +DWORD +WINAPI +DosPathToSessionPathA(DWORD SessionId, + LPSTR InPath, + LPSTR *OutPath) { - //DosPathToSessionPathW (SessionId,InPathW,OutPathW); + //DosPathToSessionPathW (SessionId,InPathW,OutPathW); UNIMPLEMENTED; - return 0; + return 0; } /* * @implemented */ -BOOL WINAPI ProcessIdToSessionId (IN DWORD dwProcessId, - OUT DWORD* pSessionId) +BOOL +WINAPI +ProcessIdToSessionId(IN DWORD dwProcessId, + OUT DWORD *pSessionId) { - PROCESS_SESSION_INFORMATION SessionInformation; - OBJECT_ATTRIBUTES ObjectAttributes; - CLIENT_ID ClientId; - HANDLE ProcessHandle; - NTSTATUS Status; + PROCESS_SESSION_INFORMATION SessionInformation; + OBJECT_ATTRIBUTES ObjectAttributes; + CLIENT_ID ClientId; + HANDLE ProcessHandle; + NTSTATUS Status; - if(IsBadWritePtr(pSessionId, sizeof(DWORD))) - { - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } - - ClientId.UniqueProcess = (HANDLE)dwProcessId; - ClientId.UniqueThread = 0; - - InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL); - - Status = NtOpenProcess(&ProcessHandle, - PROCESS_QUERY_INFORMATION, - &ObjectAttributes, - &ClientId); - if(NT_SUCCESS(Status)) - { - Status = NtQueryInformationProcess(ProcessHandle, - ProcessSessionInformation, - &SessionInformation, - sizeof(SessionInformation), - NULL); - NtClose(ProcessHandle); - - if(NT_SUCCESS(Status)) + if (IsBadWritePtr(pSessionId, sizeof(DWORD))) { - *pSessionId = SessionInformation.SessionId; - return TRUE; + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; } - } - SetLastErrorByStatus(Status); - return FALSE; + ClientId.UniqueProcess = (HANDLE)dwProcessId; + ClientId.UniqueThread = 0; + + InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL); + + Status = NtOpenProcess(&ProcessHandle, + PROCESS_QUERY_INFORMATION, + &ObjectAttributes, + &ClientId); + if (NT_SUCCESS(Status)) + { + Status = NtQueryInformationProcess(ProcessHandle, + ProcessSessionInformation, + &SessionInformation, + sizeof(SessionInformation), + NULL); + NtClose(ProcessHandle); + + if (NT_SUCCESS(Status)) + { + *pSessionId = SessionInformation.SessionId; + return TRUE; + } + } + + SetLastErrorByStatus(Status); + return FALSE; } /* * @implemented */ -DWORD WINAPI -WTSGetActiveConsoleSessionId (VOID) +DWORD +WINAPI +WTSGetActiveConsoleSessionId(VOID) { - return ActiveConsoleSessionId; + return ActiveConsoleSessionId; } /* EOF */ diff --git a/reactos/dll/win32/kernel32/synch/critical.c b/reactos/dll/win32/kernel32/synch/critical.c index 474a5d6c543..4335a3f083c 100644 --- a/reactos/dll/win32/kernel32/synch/critical.c +++ b/reactos/dll/win32/kernel32/synch/critical.c @@ -26,8 +26,9 @@ InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection) /* Initialize the critical section and raise an exception if we failed */ Status = RtlInitializeCriticalSection( - (PRTL_CRITICAL_SECTION)lpCriticalSection); - if (!NT_SUCCESS(Status)) RtlRaiseStatus(Status); + (PRTL_CRITICAL_SECTION)lpCriticalSection); + if (!NT_SUCCESS(Status)) + RtlRaiseStatus(Status); } /* diff --git a/reactos/dll/win32/kernel32/synch/event.c b/reactos/dll/win32/kernel32/synch/event.c index d39c0aaccc5..3f1d7951350 100644 --- a/reactos/dll/win32/kernel32/synch/event.c +++ b/reactos/dll/win32/kernel32/synch/event.c @@ -72,10 +72,10 @@ CreateEventExW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, /* Now check if we got a name */ if (lpName) RtlInitUnicodeString(&ObjectName, lpName); - /* Check for invalid flags */ + /* Check for invalid flags */ if (dwFlags & ~(CREATE_EVENT_INITIAL_SET | CREATE_EVENT_MANUAL_RESET)) { - /* Fail */ + /* Fail */ SetLastError(ERROR_INVALID_PARAMETER); return NULL; } diff --git a/reactos/dll/win32/kernel32/synch/mutex.c b/reactos/dll/win32/kernel32/synch/mutex.c index 69dca56555c..2708fe5717a 100644 --- a/reactos/dll/win32/kernel32/synch/mutex.c +++ b/reactos/dll/win32/kernel32/synch/mutex.c @@ -75,7 +75,8 @@ CreateMutexExW(IN LPSECURITY_ATTRIBUTES lpMutexAttributes OPTIONAL, BOOLEAN InitialOwner; /* Now check if we got a name */ - if (lpName) RtlInitUnicodeString(&ObjectName, lpName); + if (lpName) + RtlInitUnicodeString(&ObjectName, lpName); if (dwFlags & ~(CREATE_MUTEX_INITIAL_OWNER)) { @@ -257,7 +258,8 @@ ReleaseMutex(IN HANDLE hMutex) /* Release the mutant */ Status = NtReleaseMutant(hMutex, NULL); - if (NT_SUCCESS(Status)) return TRUE; + if (NT_SUCCESS(Status)) + return TRUE; /* If we got here, then we failed */ SetLastErrorByStatus(Status); diff --git a/reactos/dll/win32/kernel32/synch/sem.c b/reactos/dll/win32/kernel32/synch/sem.c index 6b859311f4f..f1ceb536b13 100644 --- a/reactos/dll/win32/kernel32/synch/sem.c +++ b/reactos/dll/win32/kernel32/synch/sem.c @@ -80,7 +80,8 @@ CreateSemaphoreExW(IN LPSECURITY_ATTRIBUTES lpSemaphoreAttributes OPTIONAL, UNICODE_STRING ObjectName; /* Now check if we got a name */ - if (lpName) RtlInitUnicodeString(&ObjectName, lpName); + if (lpName) + RtlInitUnicodeString(&ObjectName, lpName); if (dwFlags != 0) { @@ -260,7 +261,8 @@ ReleaseSemaphore(IN HANDLE hSemaphore, /* Release the semaphore */ Status = NtReleaseSemaphore(hSemaphore, lReleaseCount, lpPreviousCount); - if (NT_SUCCESS(Status)) return TRUE; + if (NT_SUCCESS(Status)) + return TRUE; /* If we got here, then we failed */ SetLastErrorByStatus(Status); diff --git a/reactos/dll/win32/kernel32/synch/timer.c b/reactos/dll/win32/kernel32/synch/timer.c index fd21a1be57f..bf99dedc773 100644 --- a/reactos/dll/win32/kernel32/synch/timer.c +++ b/reactos/dll/win32/kernel32/synch/timer.c @@ -75,7 +75,8 @@ CreateWaitableTimerExW(IN LPSECURITY_ATTRIBUTES lpTimerAttributes OPTIONAL, TIMER_TYPE TimerType; /* Now check if we got a name */ - if (lpTimerName) RtlInitUnicodeString(&ObjectName, lpTimerName); + if (lpTimerName) + RtlInitUnicodeString(&ObjectName, lpTimerName); if (dwFlags & ~(CREATE_WAITABLE_TIMER_MANUAL_RESET)) { @@ -268,7 +269,8 @@ SetWaitableTimer(IN HANDLE hTimer, (BOOLEAN)fResume, lPeriod, NULL); - if (NT_SUCCESS(Status)) return TRUE; + if (NT_SUCCESS(Status)) + return TRUE; /* If we got here, then we failed */ SetLastErrorByStatus(Status); @@ -286,7 +288,8 @@ CancelWaitableTimer(IN HANDLE hTimer) /* Cancel the timer */ Status = NtCancelTimer(hTimer, NULL); - if (NT_SUCCESS(Status)) return TRUE; + if (NT_SUCCESS(Status)) + return TRUE; /* If we got here, then we failed */ SetLastErrorByStatus(Status); diff --git a/reactos/dll/win32/kernel32/synch/wait.c b/reactos/dll/win32/kernel32/synch/wait.c index 6fea3011a05..a471b83ce51 100644 --- a/reactos/dll/win32/kernel32/synch/wait.c +++ b/reactos/dll/win32/kernel32/synch/wait.c @@ -36,9 +36,9 @@ WaitForSingleObjectEx(IN HANDLE hHandle, IN DWORD dwMilliseconds, IN BOOL bAlertable) { - PLARGE_INTEGER TimePtr; - LARGE_INTEGER Time; - NTSTATUS Status; + PLARGE_INTEGER TimePtr; + LARGE_INTEGER Time; + NTSTATUS Status; /* Get real handle */ hHandle = TranslateStdHandle(hHandle); diff --git a/reactos/dll/win32/kernel32/thread/fiber.c b/reactos/dll/win32/kernel32/thread/fiber.c index cd516dd5e71..6be7ad47f78 100644 --- a/reactos/dll/win32/kernel32/thread/fiber.c +++ b/reactos/dll/win32/kernel32/thread/fiber.c @@ -37,7 +37,7 @@ ConvertFiberToThread(VOID) DPRINT1("Converting Fiber to Thread\n"); /* the current thread isn't running a fiber: failure */ - if(!pTeb->HasFiberData) + if (!pTeb->HasFiberData) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; @@ -47,7 +47,7 @@ ConvertFiberToThread(VOID) pTeb->HasFiberData = FALSE; /* free the fiber */ - if(pTeb->Tib.FiberData != NULL) + if (pTeb->Tib.FiberData != NULL) { RtlFreeHeap(GetProcessHeap(), 0, pTeb->Tib.FiberData); } @@ -69,7 +69,8 @@ ConvertThreadToFiberEx(LPVOID lpParameter, DPRINT1("Converting Thread to Fiber\n"); /* the current thread is already a fiber */ - if(pTeb->HasFiberData && pTeb->Tib.FiberData) return pTeb->Tib.FiberData; + if (pTeb->HasFiberData && pTeb->Tib.FiberData) + return pTeb->Tib.FiberData; /* allocate the fiber */ pfCurFiber = (PFIBER)RtlAllocateHeap(GetProcessHeap(), @@ -77,7 +78,7 @@ ConvertThreadToFiberEx(LPVOID lpParameter, sizeof(FIBER)); /* failure */ - if(pfCurFiber == NULL) + if (pfCurFiber == NULL) { SetLastError(ERROR_NOT_ENOUGH_MEMORY); return NULL; @@ -93,7 +94,7 @@ ConvertThreadToFiberEx(LPVOID lpParameter, pfCurFiber->GuaranteedStackBytes = pTeb->GuaranteedStackBytes; pfCurFiber->ActivationContextStack = pTeb->ActivationContextStackPointer; pfCurFiber->Context.ContextFlags = CONTEXT_FULL; - + /* Save FPU State if requsted */ if (dwFlags & FIBER_FLAG_FLOAT_SWITCH) { @@ -150,17 +151,17 @@ CreateFiberEx(SIZE_T dwStackCommitSize, PVOID ActivationContextStack = NULL; DPRINT1("Creating Fiber\n"); - #ifdef SXS_SUPPORT_ENABLED +#ifdef SXS_SUPPORT_ENABLED /* Allocate the Activation Context Stack */ nErrCode = RtlAllocateActivationContextStack(&ActivationContextStack); - #endif - +#endif + /* Allocate the fiber */ pfCurFiber = (PFIBER)RtlAllocateHeap(GetProcessHeap(), 0, sizeof(FIBER)); /* Failure */ - if(pfCurFiber == NULL) + if (pfCurFiber == NULL) { SetLastError(ERROR_NOT_ENOUGH_MEMORY); return NULL; @@ -181,10 +182,10 @@ CreateFiberEx(SIZE_T dwStackCommitSize, SetLastErrorByStatus(nErrCode); return NULL; } - + /* Clear the context */ RtlZeroMemory(&pfCurFiber->Context, sizeof(CONTEXT)); - + /* copy the data into the fiber */ pfCurFiber->StackBase = usFiberInitialTeb.StackBase; pfCurFiber->StackLimit = usFiberInitialTeb.StackLimit; @@ -195,20 +196,20 @@ CreateFiberEx(SIZE_T dwStackCommitSize, pfCurFiber->FlsData = NULL; pfCurFiber->ActivationContextStack = ActivationContextStack; pfCurFiber->Context.ContextFlags = CONTEXT_FULL; - + /* Save FPU State if requsted */ if (dwFlags & FIBER_FLAG_FLOAT_SWITCH) { pfCurFiber->Context.ContextFlags |= CONTEXT_FLOATING_POINT; } - + /* initialize the context for the fiber */ BasepInitializeContext(&ctxFiberContext, lpParameter, lpStartAddress, usFiberInitialTeb.StackBase, 2); - + /* Return the Fiber */ return pfCurFiber; } @@ -227,7 +228,8 @@ DeleteFiber(LPVOID lpFiber) RtlFreeHeap(GetProcessHeap(), 0, lpFiber); /* the fiber is deleting itself: let the system deallocate the stack */ - if(NtCurrentTeb()->Tib.FiberData == lpFiber) ExitThread(1); + if (NtCurrentTeb()->Tib.FiberData == lpFiber) + ExitThread(1); /* deallocate the stack */ NtFreeVirtualMemory(NtCurrentProcess(), diff --git a/reactos/dll/win32/kernel32/thread/fls.c b/reactos/dll/win32/kernel32/thread/fls.c index 255707ad4cf..f538e84f404 100644 --- a/reactos/dll/win32/kernel32/thread/fls.c +++ b/reactos/dll/win32/kernel32/thread/fls.c @@ -18,101 +18,109 @@ /* * @unimplemented */ -DWORD WINAPI FlsAlloc(PFLS_CALLBACK_FUNCTION lpCallback) +DWORD +WINAPI +FlsAlloc(PFLS_CALLBACK_FUNCTION lpCallback) { - (void)lpCallback; + (void)lpCallback; - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FLS_OUT_OF_INDEXES; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FLS_OUT_OF_INDEXES; } /* * @unimplemented */ -BOOL WINAPI FlsFree(DWORD dwFlsIndex) +BOOL +WINAPI +FlsFree(DWORD dwFlsIndex) { - (void)dwFlsIndex; + (void)dwFlsIndex; - UNIMPLEMENTED; - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + UNIMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; } /* * @implemented */ -PVOID WINAPI FlsGetValue(DWORD dwFlsIndex) +PVOID +WINAPI +FlsGetValue(DWORD dwFlsIndex) { - PVOID * ppFlsSlots; - PVOID pRetVal; + PVOID *ppFlsSlots; + PVOID pRetVal; - if(dwFlsIndex >= 128) goto l_InvalidParam; + if (dwFlsIndex >= 128) + goto l_InvalidParam; - ppFlsSlots = NtCurrentTeb()->FlsData; + ppFlsSlots = NtCurrentTeb()->FlsData; - if(ppFlsSlots == NULL) goto l_InvalidParam; + if (ppFlsSlots == NULL) + goto l_InvalidParam; - SetLastError(0); - pRetVal = ppFlsSlots[dwFlsIndex + 2]; + SetLastError(0); + pRetVal = ppFlsSlots[dwFlsIndex + 2]; - return pRetVal; + return pRetVal; l_InvalidParam: - SetLastError(ERROR_INVALID_PARAMETER); - return NULL; + SetLastError(ERROR_INVALID_PARAMETER); + return NULL; } /* * @implemented */ -BOOL WINAPI FlsSetValue(DWORD dwFlsIndex, PVOID lpFlsData) +BOOL +WINAPI +FlsSetValue(DWORD dwFlsIndex, PVOID lpFlsData) { - PVOID * ppFlsSlots; - TEB * pTeb = NtCurrentTeb(); + PVOID *ppFlsSlots; + TEB *pTeb = NtCurrentTeb(); - if(dwFlsIndex >= 128) goto l_InvalidParam; + if (dwFlsIndex >= 128) + goto l_InvalidParam; - ppFlsSlots = pTeb->FlsData; + ppFlsSlots = pTeb->FlsData; - if(ppFlsSlots == NULL) - { - PEB * pPeb = pTeb->ProcessEnvironmentBlock; + if (ppFlsSlots == NULL) + { + PEB *pPeb = pTeb->ProcessEnvironmentBlock; - ppFlsSlots = RtlAllocateHeap - ( - pPeb->ProcessHeap, - HEAP_ZERO_MEMORY, - (128 + 2) * sizeof(PVOID) - ); + ppFlsSlots = RtlAllocateHeap(pPeb->ProcessHeap, + HEAP_ZERO_MEMORY, + (128 + 2) * sizeof(PVOID)); + if (ppFlsSlots == NULL) + goto l_OutOfMemory; - if(ppFlsSlots == NULL) goto l_OutOfMemory; + pTeb->FlsData = ppFlsSlots; - pTeb->FlsData = ppFlsSlots; + RtlAcquirePebLock(); - RtlAcquirePebLock(); + /* TODO: initialization */ - /* TODO: initialization */ + RtlReleasePebLock(); + } - RtlReleasePebLock(); - } + ppFlsSlots[dwFlsIndex + 2] = lpFlsData; - ppFlsSlots[dwFlsIndex + 2] = lpFlsData; - - return TRUE; + return TRUE; l_OutOfMemory: - SetLastError(ERROR_NOT_ENOUGH_MEMORY); - goto l_Fail; + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + goto l_Fail; l_InvalidParam: - SetLastError(ERROR_INVALID_PARAMETER); + SetLastError(ERROR_INVALID_PARAMETER); l_Fail: - return FALSE; + return FALSE; } /* EOF */ diff --git a/reactos/dll/win32/kernel32/thread/tls.c b/reactos/dll/win32/kernel32/thread/tls.c index b6fc73d8b00..be7fa0217b7 100644 --- a/reactos/dll/win32/kernel32/thread/tls.c +++ b/reactos/dll/win32/kernel32/thread/tls.c @@ -82,7 +82,7 @@ WINAPI TlsFree(DWORD Index) { BOOL BitSet; - + if (Index >= TLS_EXPANSION_SLOTS + TLS_MINIMUM_AVAILABLE) { SetLastErrorByStatus(STATUS_INVALID_PARAMETER);