4a066ef5eb80e59357acfa8f633077074b9b7cd8
[reactos.git] / reactos / dll / win32 / kernel32 / process / job.c
1 /* $Id$
2 *
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS system libraries
5 * FILE: lib/kernel32/process/job.c
6 * PURPOSE: Job functions
7 * PROGRAMMER: Thomas Weidenmueller <w3seek@reactos.com>
8 * UPDATE HISTORY:
9 * Created 9/23/2004
10 */
11
12 /* INCLUDES ****************************************************************/
13
14 #include <k32.h>
15
16 #define NDEBUG
17 #include <debug.h>
18
19 /* FUNCTIONS ****************************************************************/
20
21
22 /*
23 * @implemented
24 */
25 HANDLE
26 WINAPI
27 CreateJobObjectA(LPSECURITY_ATTRIBUTES lpJobAttributes,
28 LPCSTR lpName)
29 {
30 HANDLE hJob;
31 ANSI_STRING AnsiName;
32 UNICODE_STRING UnicodeName;
33
34 if(lpName != NULL)
35 {
36 NTSTATUS Status;
37
38 RtlInitAnsiString(&AnsiName, lpName);
39 Status = RtlAnsiStringToUnicodeString(&UnicodeName, &AnsiName, TRUE);
40 if(!NT_SUCCESS(Status))
41 {
42 SetLastErrorByStatus(Status);
43 return FALSE;
44 }
45 }
46
47 hJob = CreateJobObjectW(lpJobAttributes,
48 ((lpName != NULL) ? UnicodeName.Buffer : NULL));
49
50 if(lpName != NULL)
51 {
52 RtlFreeUnicodeString(&UnicodeName);
53 }
54 return hJob;
55 }
56
57
58 /*
59 * @implemented
60 */
61 HANDLE
62 WINAPI
63 CreateJobObjectW(LPSECURITY_ATTRIBUTES lpJobAttributes,
64 LPCWSTR lpName)
65 {
66 UNICODE_STRING JobName;
67 OBJECT_ATTRIBUTES ObjectAttributes;
68 ULONG Attributes = 0;
69 PVOID SecurityDescriptor;
70 HANDLE hJob;
71 NTSTATUS Status;
72
73 if(lpName != NULL)
74 {
75 RtlInitUnicodeString(&JobName, lpName);
76 }
77
78 if(lpJobAttributes != NULL)
79 {
80 if(lpJobAttributes->bInheritHandle)
81 {
82 Attributes |= OBJ_INHERIT;
83 }
84 SecurityDescriptor = lpJobAttributes->lpSecurityDescriptor;
85 }
86 else
87 {
88 SecurityDescriptor = NULL;
89 }
90
91 InitializeObjectAttributes(&ObjectAttributes,
92 ((lpName != NULL) ? &JobName : NULL),
93 Attributes,
94 NULL,
95 SecurityDescriptor);
96
97 Status = NtCreateJobObject(&hJob,
98 JOB_OBJECT_ALL_ACCESS,
99 &ObjectAttributes);
100 if(!NT_SUCCESS(Status))
101 {
102 SetLastErrorByStatus(Status);
103 return NULL;
104 }
105
106 return hJob;
107 }
108
109
110 /*
111 * @implemented
112 */
113 HANDLE
114 WINAPI
115 OpenJobObjectW(DWORD dwDesiredAccess,
116 BOOL bInheritHandle,
117 LPCWSTR lpName)
118 {
119 OBJECT_ATTRIBUTES ObjectAttributes;
120 UNICODE_STRING JobName;
121 HANDLE hJob;
122 NTSTATUS Status;
123
124 if(lpName == NULL)
125 {
126 SetLastError(ERROR_INVALID_PARAMETER);
127 return NULL;
128 }
129
130 RtlInitUnicodeString(&JobName, lpName);
131
132 InitializeObjectAttributes(&ObjectAttributes,
133 &JobName,
134 (bInheritHandle ? OBJ_INHERIT : 0),
135 NULL,
136 NULL);
137
138 Status = NtOpenJobObject(&hJob,
139 dwDesiredAccess,
140 &ObjectAttributes);
141
142 if(!NT_SUCCESS(Status))
143 {
144 SetLastErrorByStatus(Status);
145 return NULL;
146 }
147
148 return hJob;
149 }
150
151
152 /*
153 * @implemented
154 */
155 HANDLE
156 WINAPI
157 OpenJobObjectA(DWORD dwDesiredAccess,
158 BOOL bInheritHandle,
159 LPCSTR lpName)
160 {
161 ANSI_STRING AnsiName;
162 UNICODE_STRING UnicodeName;
163 HANDLE hJob;
164 NTSTATUS Status;
165
166 if(lpName == NULL)
167 {
168 SetLastError(ERROR_INVALID_PARAMETER);
169 return NULL;
170 }
171
172 RtlInitAnsiString(&AnsiName, lpName);
173 Status = RtlAnsiStringToUnicodeString(&UnicodeName, &AnsiName, TRUE);
174 if(!NT_SUCCESS(Status))
175 {
176 SetLastErrorByStatus(Status);
177 return FALSE;
178 }
179
180 hJob = OpenJobObjectW(dwDesiredAccess,
181 bInheritHandle,
182 UnicodeName.Buffer);
183
184 RtlFreeUnicodeString(&UnicodeName);
185 return hJob;
186 }
187
188
189 /*
190 * @implemented
191 */
192 BOOL
193 WINAPI
194 IsProcessInJob(HANDLE ProcessHandle,
195 HANDLE JobHandle,
196 PBOOL Result)
197 {
198 NTSTATUS Status;
199
200 Status = NtIsProcessInJob(ProcessHandle, JobHandle);
201 if(NT_SUCCESS(Status))
202 {
203 *Result = (Status == STATUS_PROCESS_IN_JOB);
204 return TRUE;
205 }
206
207 SetLastErrorByStatus(Status);
208 return FALSE;
209 }
210
211
212 /*
213 * @implemented
214 */
215 BOOL
216 WINAPI
217 AssignProcessToJobObject(HANDLE hJob,
218 HANDLE hProcess)
219 {
220 NTSTATUS Status;
221
222 Status = NtAssignProcessToJobObject(hJob, hProcess);
223 if(!NT_SUCCESS(Status))
224 {
225 SetLastErrorByStatus(Status);
226 return FALSE;
227 }
228 return TRUE;
229 }
230
231
232 /*
233 * @implemented
234 */
235 BOOL
236 WINAPI
237 QueryInformationJobObject(HANDLE hJob,
238 JOBOBJECTINFOCLASS JobObjectInformationClass,
239 LPVOID lpJobObjectInformation,
240 DWORD cbJobObjectInformationLength,
241 LPDWORD lpReturnLength)
242 {
243 NTSTATUS Status;
244
245 Status = NtQueryInformationJobObject(hJob,
246 JobObjectInformationClass,
247 lpJobObjectInformation,
248 cbJobObjectInformationLength,
249 lpReturnLength);
250 if(NT_SUCCESS(Status))
251 {
252 PJOBOBJECT_BASIC_LIMIT_INFORMATION BasicInfo;
253 switch(JobObjectInformationClass)
254 {
255 case JobObjectBasicLimitInformation:
256 BasicInfo = (PJOBOBJECT_BASIC_LIMIT_INFORMATION)lpJobObjectInformation;
257 break;
258 case JobObjectExtendedLimitInformation:
259 BasicInfo = &((PJOBOBJECT_EXTENDED_LIMIT_INFORMATION)lpJobObjectInformation)->BasicLimitInformation;
260 break;
261
262 default:
263 BasicInfo = NULL;
264 break;
265 }
266
267 if(BasicInfo != NULL)
268 {
269 /* we need to convert the process priority classes in the
270 JOBOBJECT_BASIC_LIMIT_INFORMATION structure the same way as
271 GetPriorityClass() converts it! */
272 switch(BasicInfo->PriorityClass)
273 {
274 case PROCESS_PRIORITY_CLASS_IDLE:
275 BasicInfo->PriorityClass = IDLE_PRIORITY_CLASS;
276 break;
277 case PROCESS_PRIORITY_CLASS_BELOW_NORMAL:
278 BasicInfo->PriorityClass = BELOW_NORMAL_PRIORITY_CLASS;
279 break;
280 case PROCESS_PRIORITY_CLASS_NORMAL:
281 BasicInfo->PriorityClass = NORMAL_PRIORITY_CLASS;
282 break;
283 case PROCESS_PRIORITY_CLASS_ABOVE_NORMAL:
284 BasicInfo->PriorityClass = ABOVE_NORMAL_PRIORITY_CLASS;
285 break;
286 case PROCESS_PRIORITY_CLASS_HIGH:
287 BasicInfo->PriorityClass = HIGH_PRIORITY_CLASS;
288 break;
289 case PROCESS_PRIORITY_CLASS_REALTIME:
290 BasicInfo->PriorityClass = REALTIME_PRIORITY_CLASS;
291 break;
292 default:
293 BasicInfo->PriorityClass = NORMAL_PRIORITY_CLASS;
294 break;
295 }
296 }
297
298 return TRUE;
299 }
300
301 SetLastErrorByStatus(Status);
302 return FALSE;
303 }
304
305
306 /*
307 * @implemented
308 */
309 BOOL
310 WINAPI
311 SetInformationJobObject(HANDLE hJob,
312 JOBOBJECTINFOCLASS JobObjectInformationClass,
313 LPVOID lpJobObjectInformation,
314 DWORD cbJobObjectInformationLength)
315 {
316 JOBOBJECT_EXTENDED_LIMIT_INFORMATION ExtendedLimitInfo;
317 PJOBOBJECT_BASIC_LIMIT_INFORMATION BasicInfo;
318 PVOID ObjectInfo;
319 NTSTATUS Status;
320
321 switch(JobObjectInformationClass)
322 {
323 case JobObjectBasicLimitInformation:
324 if(cbJobObjectInformationLength != sizeof(JOBOBJECT_BASIC_LIMIT_INFORMATION))
325 {
326 SetLastError(ERROR_BAD_LENGTH);
327 return FALSE;
328 }
329 ObjectInfo = &ExtendedLimitInfo.BasicLimitInformation;
330 BasicInfo = (PJOBOBJECT_BASIC_LIMIT_INFORMATION)ObjectInfo;
331 RtlCopyMemory(ObjectInfo, lpJobObjectInformation, cbJobObjectInformationLength);
332 break;
333
334 case JobObjectExtendedLimitInformation:
335 if(cbJobObjectInformationLength != sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION))
336 {
337 SetLastError(ERROR_BAD_LENGTH);
338 return FALSE;
339 }
340 ObjectInfo = &ExtendedLimitInfo;
341 BasicInfo = &ExtendedLimitInfo.BasicLimitInformation;
342 RtlCopyMemory(ObjectInfo, lpJobObjectInformation, cbJobObjectInformationLength);
343 break;
344
345 default:
346 ObjectInfo = lpJobObjectInformation;
347 BasicInfo = NULL;
348 break;
349 }
350
351 if(BasicInfo != NULL)
352 {
353 /* we need to convert the process priority classes in the
354 JOBOBJECT_BASIC_LIMIT_INFORMATION structure the same way as
355 SetPriorityClass() converts it! */
356 switch(BasicInfo->PriorityClass)
357 {
358 case IDLE_PRIORITY_CLASS:
359 BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_IDLE;
360 break;
361 case BELOW_NORMAL_PRIORITY_CLASS:
362 BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_BELOW_NORMAL;
363 break;
364 case NORMAL_PRIORITY_CLASS:
365 BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL;
366 break;
367 case ABOVE_NORMAL_PRIORITY_CLASS:
368 BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_ABOVE_NORMAL;
369 break;
370 case HIGH_PRIORITY_CLASS:
371 BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_HIGH;
372 break;
373 case REALTIME_PRIORITY_CLASS:
374 BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_REALTIME;
375 break;
376 default:
377 BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL;
378 break;
379 }
380 }
381
382 Status = NtSetInformationJobObject(hJob,
383 JobObjectInformationClass,
384 ObjectInfo,
385 cbJobObjectInformationLength);
386 if(!NT_SUCCESS(Status))
387 {
388 SetLastErrorByStatus(Status);
389 return FALSE;
390 }
391
392 return TRUE;
393 }
394
395
396 /*
397 * @implemented
398 */
399 BOOL
400 WINAPI
401 TerminateJobObject(HANDLE hJob,
402 UINT uExitCode)
403 {
404 NTSTATUS Status;
405
406 Status = NtTerminateJobObject(hJob, uExitCode);
407 if(!NT_SUCCESS(Status))
408 {
409 SetLastErrorByStatus(Status);
410 return FALSE;
411 }
412
413 return TRUE;
414 }
415
416
417 /* EOF */