crypt32: Implement CertGetNameStringW for CERT_NAME_EMAIL_TYPE.
[wine] / dlls / kernel32 / thread.c
1 /*
2  * Win32 threads
3  *
4  * Copyright 1996 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <fcntl.h>
26 #include <stdarg.h>
27 #include <sys/types.h>
28 #ifdef HAVE_UNISTD_H
29 # include <unistd.h>
30 #endif
31
32 #include "ntstatus.h"
33 #define WIN32_NO_STATUS
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winerror.h"
37 #include "winternl.h"
38 #include "wine/winbase16.h"
39 #include "wine/exception.h"
40 #include "wine/library.h"
41 #include "wine/server.h"
42 #include "wine/debug.h"
43
44 #include "kernel_private.h"
45
46 WINE_DEFAULT_DEBUG_CHANNEL(thread);
47
48
49 /***********************************************************************
50  *           CreateThread   (KERNEL32.@)
51  */
52 HANDLE WINAPI CreateThread( SECURITY_ATTRIBUTES *sa, SIZE_T stack,
53                             LPTHREAD_START_ROUTINE start, LPVOID param,
54                             DWORD flags, LPDWORD id )
55 {
56      return CreateRemoteThread( GetCurrentProcess(),
57                                 sa, stack, start, param, flags, id );
58 }
59
60
61 /***************************************************************************
62  *                  CreateRemoteThread   (KERNEL32.@)
63  *
64  * Creates a thread that runs in the address space of another process
65  *
66  * PARAMS
67  *
68  * RETURNS
69  *   Success: Handle to the new thread.
70  *   Failure: NULL. Use GetLastError() to find the error cause.
71  *
72  * BUGS
73  *   Improper memory allocation: there's no ability to free new_thread_info
74  *   in other process.
75  *   Bad start address for RtlCreateUserThread because the library
76  *   may be loaded at different address in other process.
77  */
78 HANDLE WINAPI CreateRemoteThread( HANDLE hProcess, SECURITY_ATTRIBUTES *sa, SIZE_T stack,
79                                   LPTHREAD_START_ROUTINE start, LPVOID param,
80                                   DWORD flags, LPDWORD id )
81 {
82     HANDLE handle;
83     CLIENT_ID client_id;
84     NTSTATUS status;
85     SIZE_T stack_reserve = 0, stack_commit = 0;
86
87     if (flags & STACK_SIZE_PARAM_IS_A_RESERVATION) stack_reserve = stack;
88     else stack_commit = stack;
89
90     status = RtlCreateUserThread( hProcess, NULL, TRUE,
91                                   NULL, stack_reserve, stack_commit,
92                                   (PRTL_THREAD_START_ROUTINE)start, param, &handle, &client_id );
93     if (status == STATUS_SUCCESS)
94     {
95         if (id) *id = HandleToULong(client_id.UniqueThread);
96         if (sa && (sa->nLength >= sizeof(*sa)) && sa->bInheritHandle)
97             SetHandleInformation( handle, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT );
98         if (!(flags & CREATE_SUSPENDED))
99         {
100             ULONG ret;
101             if (NtResumeThread( handle, &ret ))
102             {
103                 NtClose( handle );
104                 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
105                 handle = 0;
106             }
107         }
108     }
109     else
110     {
111         SetLastError( RtlNtStatusToDosError(status) );
112         handle = 0;
113     }
114     return handle;
115 }
116
117
118 /***********************************************************************
119  * OpenThread  [KERNEL32.@]   Retrieves a handle to a thread from its thread id
120  */
121 HANDLE WINAPI OpenThread( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwThreadId )
122 {
123     NTSTATUS status;
124     HANDLE handle;
125     OBJECT_ATTRIBUTES attr;
126     CLIENT_ID cid;
127
128     attr.Length = sizeof(attr);
129     attr.RootDirectory = 0;
130     attr.Attributes = bInheritHandle ? OBJ_INHERIT : 0;
131     attr.ObjectName = NULL;
132     attr.SecurityDescriptor = NULL;
133     attr.SecurityQualityOfService = NULL;
134
135     cid.UniqueProcess = 0; /* FIXME */
136     cid.UniqueThread = ULongToHandle(dwThreadId);
137     status = NtOpenThread( &handle, dwDesiredAccess, &attr, &cid );
138     if (status)
139     {
140         SetLastError( RtlNtStatusToDosError(status) );
141         handle = 0;
142     }
143     return handle;
144 }
145
146
147 /***********************************************************************
148  * ExitThread [KERNEL32.@]  Ends a thread
149  *
150  * RETURNS
151  *    None
152  */
153 void WINAPI ExitThread( DWORD code ) /* [in] Exit code for this thread */
154 {
155     RtlFreeThreadActivationContextStack();
156     RtlExitUserThread( code );
157 }
158
159
160 /**********************************************************************
161  * TerminateThread [KERNEL32.@]  Terminates a thread
162  *
163  * RETURNS
164  *    Success: TRUE
165  *    Failure: FALSE
166  */
167 BOOL WINAPI TerminateThread( HANDLE handle,    /* [in] Handle to thread */
168                              DWORD exit_code)  /* [in] Exit code for thread */
169 {
170     NTSTATUS status = NtTerminateThread( handle, exit_code );
171     if (status) SetLastError( RtlNtStatusToDosError(status) );
172     return !status;
173 }
174
175
176 /***********************************************************************
177  *           FreeLibraryAndExitThread (KERNEL32.@)
178  */
179 void WINAPI FreeLibraryAndExitThread(HINSTANCE hLibModule, DWORD dwExitCode)
180 {
181     FreeLibrary(hLibModule);
182     ExitThread(dwExitCode);
183 }
184
185
186 /**********************************************************************
187  *              GetExitCodeThread (KERNEL32.@)
188  *
189  * Gets termination status of thread.
190  *
191  * RETURNS
192  *    Success: TRUE
193  *    Failure: FALSE
194  */
195 BOOL WINAPI GetExitCodeThread(
196     HANDLE hthread, /* [in]  Handle to thread */
197     LPDWORD exitcode) /* [out] Address to receive termination status */
198 {
199     THREAD_BASIC_INFORMATION info;
200     NTSTATUS status = NtQueryInformationThread( hthread, ThreadBasicInformation,
201                                                 &info, sizeof(info), NULL );
202
203     if (status)
204     {
205         SetLastError( RtlNtStatusToDosError(status) );
206         return FALSE;
207     }
208     if (exitcode) *exitcode = info.ExitStatus;
209     return TRUE;
210 }
211
212
213 /***********************************************************************
214  * SetThreadContext [KERNEL32.@]  Sets context of thread.
215  *
216  * RETURNS
217  *    Success: TRUE
218  *    Failure: FALSE
219  */
220 BOOL WINAPI SetThreadContext( HANDLE handle,           /* [in]  Handle to thread with context */
221                               const CONTEXT *context ) /* [in] Address of context structure */
222 {
223     NTSTATUS status = NtSetContextThread( handle, context );
224     if (status) SetLastError( RtlNtStatusToDosError(status) );
225     return !status;
226 }
227
228
229 /***********************************************************************
230  * GetThreadContext [KERNEL32.@]  Retrieves context of thread.
231  *
232  * RETURNS
233  *    Success: TRUE
234  *    Failure: FALSE
235  */
236 BOOL WINAPI GetThreadContext( HANDLE handle,     /* [in]  Handle to thread with context */
237                               CONTEXT *context ) /* [out] Address of context structure */
238 {
239     NTSTATUS status = NtGetContextThread( handle, context );
240     if (status) SetLastError( RtlNtStatusToDosError(status) );
241     return !status;
242 }
243
244
245 /**********************************************************************
246  * SuspendThread [KERNEL32.@]  Suspends a thread.
247  *
248  * RETURNS
249  *    Success: Previous suspend count
250  *    Failure: 0xFFFFFFFF
251  */
252 DWORD WINAPI SuspendThread( HANDLE hthread ) /* [in] Handle to the thread */
253 {
254     DWORD ret;
255     NTSTATUS status = NtSuspendThread( hthread, &ret );
256
257     if (status)
258     {
259         ret = ~0U;
260         SetLastError( RtlNtStatusToDosError(status) );
261     }
262     return ret;
263 }
264
265
266 /**********************************************************************
267  * ResumeThread [KERNEL32.@]  Resumes a thread.
268  *
269  * Decrements a thread's suspend count.  When count is zero, the
270  * execution of the thread is resumed.
271  *
272  * RETURNS
273  *    Success: Previous suspend count
274  *    Failure: 0xFFFFFFFF
275  *    Already running: 0
276  */
277 DWORD WINAPI ResumeThread( HANDLE hthread ) /* [in] Identifies thread to restart */
278 {
279     DWORD ret;
280     NTSTATUS status = NtResumeThread( hthread, &ret );
281
282     if (status)
283     {
284         ret = ~0U;
285         SetLastError( RtlNtStatusToDosError(status) );
286     }
287     return ret;
288 }
289
290
291 /**********************************************************************
292  * GetThreadPriority [KERNEL32.@]  Returns priority for thread.
293  *
294  * RETURNS
295  *    Success: Thread's priority level.
296  *    Failure: THREAD_PRIORITY_ERROR_RETURN
297  */
298 INT WINAPI GetThreadPriority(
299     HANDLE hthread) /* [in] Handle to thread */
300 {
301     THREAD_BASIC_INFORMATION info;
302     NTSTATUS status = NtQueryInformationThread( hthread, ThreadBasicInformation,
303                                                 &info, sizeof(info), NULL );
304
305     if (status)
306     {
307         SetLastError( RtlNtStatusToDosError(status) );
308         return THREAD_PRIORITY_ERROR_RETURN;
309     }
310     return info.Priority;
311 }
312
313
314 /**********************************************************************
315  * SetThreadPriority [KERNEL32.@]  Sets priority for thread.
316  *
317  * RETURNS
318  *    Success: TRUE
319  *    Failure: FALSE
320  */
321 BOOL WINAPI SetThreadPriority(
322     HANDLE hthread, /* [in] Handle to thread */
323     INT priority)   /* [in] Thread priority level */
324 {
325     DWORD       prio = priority;
326     NTSTATUS    status;
327
328     status = NtSetInformationThread(hthread, ThreadBasePriority,
329                                     &prio, sizeof(prio));
330
331     if (status)
332     {
333         SetLastError( RtlNtStatusToDosError(status) );
334         return FALSE;
335     }
336
337     return TRUE;
338 }
339
340
341 /**********************************************************************
342  * GetThreadPriorityBoost [KERNEL32.@]  Returns priority boost for thread.
343  *
344  * Always reports that priority boost is disabled.
345  *
346  * RETURNS
347  *    Success: TRUE.
348  *    Failure: FALSE
349  */
350 BOOL WINAPI GetThreadPriorityBoost(
351     HANDLE hthread, /* [in] Handle to thread */
352     PBOOL pstate)   /* [out] pointer to var that receives the boost state */
353 {
354     if (pstate) *pstate = FALSE;
355     return TRUE;
356 }
357
358
359 /**********************************************************************
360  * SetThreadPriorityBoost [KERNEL32.@]  Sets priority boost for thread.
361  *
362  * Priority boost is not implemented. This function always returns
363  * FALSE and sets last error to ERROR_CALL_NOT_IMPLEMENTED
364  *
365  * RETURNS
366  *    Always returns FALSE to indicate a failure
367  */
368 BOOL WINAPI SetThreadPriorityBoost(
369     HANDLE hthread, /* [in] Handle to thread */
370     BOOL disable)   /* [in] TRUE to disable priority boost */
371 {
372     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
373     return FALSE;
374 }
375
376
377 /**********************************************************************
378  *           SetThreadAffinityMask   (KERNEL32.@)
379  */
380 DWORD_PTR WINAPI SetThreadAffinityMask( HANDLE hThread, DWORD_PTR dwThreadAffinityMask )
381 {
382     NTSTATUS                    status;
383     THREAD_BASIC_INFORMATION    tbi;
384
385     status = NtQueryInformationThread( hThread, ThreadBasicInformation, 
386                                        &tbi, sizeof(tbi), NULL );
387     if (status)
388     {
389         SetLastError( RtlNtStatusToDosError(status) );
390         return 0;
391     }
392     status = NtSetInformationThread( hThread, ThreadAffinityMask, 
393                                      &dwThreadAffinityMask,
394                                      sizeof(dwThreadAffinityMask));
395     if (status)
396     {
397         SetLastError( RtlNtStatusToDosError(status) );
398         return 0;
399     }
400     return tbi.AffinityMask;
401 }
402
403
404 /**********************************************************************
405  * SetThreadIdealProcessor [KERNEL32.@]  Sets preferred processor for thread.
406  *
407  * RETURNS
408  *    Success: Value of last call to SetThreadIdealProcessor
409  *    Failure: -1
410  */
411 DWORD WINAPI SetThreadIdealProcessor(
412     HANDLE hThread,          /* [in] Specifies the thread of interest */
413     DWORD dwIdealProcessor)  /* [in] Specifies the new preferred processor */
414 {
415     FIXME("(%p): stub\n",hThread);
416     if (dwIdealProcessor > MAXIMUM_PROCESSORS)
417     {
418         SetLastError(ERROR_INVALID_PARAMETER);
419         return ~0u;
420     }
421     return 0;
422 }
423
424
425 /* callback for QueueUserAPC */
426 static void CALLBACK call_user_apc( ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3 )
427 {
428     PAPCFUNC func = (PAPCFUNC)arg1;
429     func( arg2 );
430 }
431
432 /***********************************************************************
433  *              QueueUserAPC  (KERNEL32.@)
434  */
435 DWORD WINAPI QueueUserAPC( PAPCFUNC func, HANDLE hthread, ULONG_PTR data )
436 {
437     NTSTATUS status = NtQueueApcThread( hthread, call_user_apc, (ULONG_PTR)func, data, 0 );
438
439     if (status) SetLastError( RtlNtStatusToDosError(status) );
440     return !status;
441 }
442
443 /***********************************************************************
444  *              QueueUserWorkItem  (KERNEL32.@)
445  */
446 BOOL WINAPI QueueUserWorkItem( LPTHREAD_START_ROUTINE Function, PVOID Context, ULONG Flags )
447 {
448     NTSTATUS status;
449
450     TRACE("(%p,%p,0x%08x)\n", Function, Context, Flags);
451
452     status = RtlQueueWorkItem( Function, Context, Flags );
453
454     if (status) SetLastError( RtlNtStatusToDosError(status) );
455     return !status;
456 }
457
458 /**********************************************************************
459  * GetThreadTimes [KERNEL32.@]  Obtains timing information.
460  *
461  * RETURNS
462  *    Success: TRUE
463  *    Failure: FALSE
464  */
465 BOOL WINAPI GetThreadTimes(
466     HANDLE thread,         /* [in]  Specifies the thread of interest */
467     LPFILETIME creationtime, /* [out] When the thread was created */
468     LPFILETIME exittime,     /* [out] When the thread was destroyed */
469     LPFILETIME kerneltime,   /* [out] Time thread spent in kernel mode */
470     LPFILETIME usertime)     /* [out] Time thread spent in user mode */
471 {
472     KERNEL_USER_TIMES   kusrt;
473     NTSTATUS            status;
474
475     status = NtQueryInformationThread(thread, ThreadTimes, &kusrt,
476                                       sizeof(kusrt), NULL);
477     if (status)
478     {
479         SetLastError( RtlNtStatusToDosError(status) );
480         return FALSE;
481     }
482     if (creationtime)
483     {
484         creationtime->dwLowDateTime = kusrt.CreateTime.u.LowPart;
485         creationtime->dwHighDateTime = kusrt.CreateTime.u.HighPart;
486     }
487     if (exittime)
488     {
489         exittime->dwLowDateTime = kusrt.ExitTime.u.LowPart;
490         exittime->dwHighDateTime = kusrt.ExitTime.u.HighPart;
491     }
492     if (kerneltime)
493     {
494         kerneltime->dwLowDateTime = kusrt.KernelTime.u.LowPart;
495         kerneltime->dwHighDateTime = kusrt.KernelTime.u.HighPart;
496     }
497     if (usertime)
498     {
499         usertime->dwLowDateTime = kusrt.UserTime.u.LowPart;
500         usertime->dwHighDateTime = kusrt.UserTime.u.HighPart;
501     }
502     
503     return TRUE;
504 }
505
506 /**********************************************************************
507  * GetThreadId [KERNEL32.@]
508  *
509  * Retrieve the identifier of a thread.
510  *
511  * PARAMS
512  *  Thread [I] The thread to retrieve the identifier of.
513  *
514  * RETURNS
515  *    Success: Identifier of the target thread.
516  *    Failure: 0
517  */
518 DWORD WINAPI GetThreadId(HANDLE Thread)
519 {
520     THREAD_BASIC_INFORMATION tbi;
521     NTSTATUS status;
522
523     TRACE("(%p)\n", Thread);
524
525     status = NtQueryInformationThread(Thread, ThreadBasicInformation, &tbi,
526                                       sizeof(tbi), NULL);
527     if (status)
528     {
529         SetLastError( RtlNtStatusToDosError(status) );
530         return 0;
531     }
532
533     return HandleToULong(tbi.ClientId.UniqueThread);
534 }
535
536
537 /**********************************************************************
538  * VWin32_BoostThreadGroup [KERNEL.535]
539  */
540 VOID WINAPI VWin32_BoostThreadGroup( DWORD threadId, INT boost )
541 {
542     FIXME("(0x%08x,%d): stub\n", threadId, boost);
543 }
544
545
546 /**********************************************************************
547  * VWin32_BoostThreadStatic [KERNEL.536]
548  */
549 VOID WINAPI VWin32_BoostThreadStatic( DWORD threadId, INT boost )
550 {
551     FIXME("(0x%08x,%d): stub\n", threadId, boost);
552 }
553
554
555 /***********************************************************************
556  * GetCurrentThread [KERNEL32.@]  Gets pseudohandle for current thread
557  *
558  * RETURNS
559  *    Pseudohandle for the current thread
560  */
561 #undef GetCurrentThread
562 HANDLE WINAPI GetCurrentThread(void)
563 {
564     return (HANDLE)~(ULONG_PTR)1;
565 }
566
567
568 #ifdef __i386__
569
570 /***********************************************************************
571  *              SetLastError (KERNEL.147)
572  *              SetLastError (KERNEL32.@)
573  */
574 /* void WINAPI SetLastError( DWORD error ); */
575 __ASM_STDCALL_FUNC( SetLastError, 4,
576                    "movl 4(%esp),%eax\n\t"
577                    ".byte 0x64\n\t"
578                    "movl %eax,0x34\n\t"
579                    "ret $4" )
580
581 /***********************************************************************
582  *              GetLastError (KERNEL.148)
583  *              GetLastError (KERNEL32.@)
584  */
585 /* DWORD WINAPI GetLastError(void); */
586 __ASM_STDCALL_FUNC( GetLastError, 0, ".byte 0x64\n\tmovl 0x34,%eax\n\tret" )
587
588 /***********************************************************************
589  *              GetCurrentProcessId (KERNEL.471)
590  *              GetCurrentProcessId (KERNEL32.@)
591  */
592 /* DWORD WINAPI GetCurrentProcessId(void) */
593 __ASM_STDCALL_FUNC( GetCurrentProcessId, 0, ".byte 0x64\n\tmovl 0x20,%eax\n\tret" )
594
595 /***********************************************************************
596  *              GetCurrentThreadId (KERNEL.462)
597  *              GetCurrentThreadId (KERNEL32.@)
598  */
599 /* DWORD WINAPI GetCurrentThreadId(void) */
600 __ASM_STDCALL_FUNC( GetCurrentThreadId, 0, ".byte 0x64\n\tmovl 0x24,%eax\n\tret" )
601
602 #else  /* __i386__ */
603
604 /**********************************************************************
605  *              SetLastError (KERNEL.147)
606  *              SetLastError (KERNEL32.@)
607  *
608  * Sets the last-error code.
609  *
610  * RETURNS
611  * Nothing.
612  */
613 void WINAPI SetLastError( DWORD error ) /* [in] Per-thread error code */
614 {
615     NtCurrentTeb()->LastErrorValue = error;
616 }
617
618 /**********************************************************************
619  *              GetLastError (KERNEL.148)
620  *              GetLastError (KERNEL32.@)
621  *
622  * Get the last-error code.
623  *
624  * RETURNS
625  *  last-error code.
626  */
627 DWORD WINAPI GetLastError(void)
628 {
629     return NtCurrentTeb()->LastErrorValue;
630 }
631
632 /***********************************************************************
633  *              GetCurrentProcessId (KERNEL.471)
634  *              GetCurrentProcessId (KERNEL32.@)
635  *
636  * Get the current process identifier.
637  *
638  * RETURNS
639  *  current process identifier
640  */
641 DWORD WINAPI GetCurrentProcessId(void)
642 {
643     return HandleToULong(NtCurrentTeb()->ClientId.UniqueProcess);
644 }
645
646 /***********************************************************************
647  *              GetCurrentThreadId (KERNEL.462)
648  *              GetCurrentThreadId (KERNEL32.@)
649  *
650  * Get the current thread identifier.
651  *
652  * RETURNS
653  *  current thread identifier
654  */
655 DWORD WINAPI GetCurrentThreadId(void)
656 {
657     return HandleToULong(NtCurrentTeb()->ClientId.UniqueThread);
658 }
659
660 #endif  /* __i386__ */