urlmon: Correctly handle BINDF_NO_UI in handle_http_error.
[wine/multimedia.git] / dlls / kernel32 / thread.c
blobbdaaee806c017cf674721e1759b482bcc6cdf573
1 /*
2 * Win32 threads
4 * Copyright 1996 Alexandre Julliard
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.
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.
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
21 #include "config.h"
22 #include "wine/port.h"
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
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/exception.h"
39 #include "wine/library.h"
40 #include "wine/server.h"
41 #include "wine/debug.h"
43 #include "kernel_private.h"
45 WINE_DEFAULT_DEBUG_CHANNEL(thread);
48 /***********************************************************************
49 * CreateThread (KERNEL32.@)
51 HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread( SECURITY_ATTRIBUTES *sa, SIZE_T stack, LPTHREAD_START_ROUTINE start,
52 LPVOID param, DWORD flags, LPDWORD id )
54 return CreateRemoteThread( GetCurrentProcess(),
55 sa, stack, start, param, flags, id );
59 /***************************************************************************
60 * CreateRemoteThread (KERNEL32.@)
62 * Creates a thread that runs in the address space of another process
64 * PARAMS
66 * RETURNS
67 * Success: Handle to the new thread.
68 * Failure: NULL. Use GetLastError() to find the error cause.
70 * BUGS
71 * Improper memory allocation: there's no ability to free new_thread_info
72 * in other process.
73 * Bad start address for RtlCreateUserThread because the library
74 * may be loaded at different address in other process.
76 HANDLE WINAPI CreateRemoteThread( HANDLE hProcess, SECURITY_ATTRIBUTES *sa, SIZE_T stack,
77 LPTHREAD_START_ROUTINE start, LPVOID param,
78 DWORD flags, LPDWORD id )
80 HANDLE handle;
81 CLIENT_ID client_id;
82 NTSTATUS status;
83 SIZE_T stack_reserve = 0, stack_commit = 0;
85 if (flags & STACK_SIZE_PARAM_IS_A_RESERVATION) stack_reserve = stack;
86 else stack_commit = stack;
88 status = RtlCreateUserThread( hProcess, NULL, TRUE,
89 NULL, stack_reserve, stack_commit,
90 (PRTL_THREAD_START_ROUTINE)start, param, &handle, &client_id );
91 if (status == STATUS_SUCCESS)
93 if (id) *id = HandleToULong(client_id.UniqueThread);
94 if (sa && (sa->nLength >= sizeof(*sa)) && sa->bInheritHandle)
95 SetHandleInformation( handle, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT );
96 if (!(flags & CREATE_SUSPENDED))
98 ULONG ret;
99 if (NtResumeThread( handle, &ret ))
101 NtClose( handle );
102 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
103 handle = 0;
107 else
109 SetLastError( RtlNtStatusToDosError(status) );
110 handle = 0;
112 return handle;
116 /***********************************************************************
117 * OpenThread [KERNEL32.@] Retrieves a handle to a thread from its thread id
119 HANDLE WINAPI OpenThread( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwThreadId )
121 NTSTATUS status;
122 HANDLE handle;
123 OBJECT_ATTRIBUTES attr;
124 CLIENT_ID cid;
126 attr.Length = sizeof(attr);
127 attr.RootDirectory = 0;
128 attr.Attributes = bInheritHandle ? OBJ_INHERIT : 0;
129 attr.ObjectName = NULL;
130 attr.SecurityDescriptor = NULL;
131 attr.SecurityQualityOfService = NULL;
133 cid.UniqueProcess = 0; /* FIXME */
134 cid.UniqueThread = ULongToHandle(dwThreadId);
135 status = NtOpenThread( &handle, dwDesiredAccess, &attr, &cid );
136 if (status)
138 SetLastError( RtlNtStatusToDosError(status) );
139 handle = 0;
141 return handle;
145 /***********************************************************************
146 * ExitThread [KERNEL32.@] Ends a thread
148 * RETURNS
149 * None
151 void WINAPI ExitThread( DWORD code ) /* [in] Exit code for this thread */
153 RtlFreeThreadActivationContextStack();
154 RtlExitUserThread( code );
158 /**********************************************************************
159 * TerminateThread [KERNEL32.@] Terminates a thread
161 * RETURNS
162 * Success: TRUE
163 * Failure: FALSE
165 BOOL WINAPI TerminateThread( HANDLE handle, /* [in] Handle to thread */
166 DWORD exit_code) /* [in] Exit code for thread */
168 NTSTATUS status = NtTerminateThread( handle, exit_code );
169 if (status) SetLastError( RtlNtStatusToDosError(status) );
170 return !status;
174 /***********************************************************************
175 * FreeLibraryAndExitThread (KERNEL32.@)
177 void WINAPI FreeLibraryAndExitThread(HINSTANCE hLibModule, DWORD dwExitCode)
179 FreeLibrary(hLibModule);
180 ExitThread(dwExitCode);
184 /**********************************************************************
185 * GetExitCodeThread (KERNEL32.@)
187 * Gets termination status of thread.
189 * RETURNS
190 * Success: TRUE
191 * Failure: FALSE
193 BOOL WINAPI GetExitCodeThread(
194 HANDLE hthread, /* [in] Handle to thread */
195 LPDWORD exitcode) /* [out] Address to receive termination status */
197 THREAD_BASIC_INFORMATION info;
198 NTSTATUS status = NtQueryInformationThread( hthread, ThreadBasicInformation,
199 &info, sizeof(info), NULL );
201 if (status)
203 SetLastError( RtlNtStatusToDosError(status) );
204 return FALSE;
206 if (exitcode) *exitcode = info.ExitStatus;
207 return TRUE;
211 /***********************************************************************
212 * SetThreadContext [KERNEL32.@] Sets context of thread.
214 * RETURNS
215 * Success: TRUE
216 * Failure: FALSE
218 BOOL WINAPI SetThreadContext( HANDLE handle, /* [in] Handle to thread with context */
219 const CONTEXT *context ) /* [in] Address of context structure */
221 NTSTATUS status = NtSetContextThread( handle, context );
222 if (status) SetLastError( RtlNtStatusToDosError(status) );
223 return !status;
227 /***********************************************************************
228 * GetThreadContext [KERNEL32.@] Retrieves context of thread.
230 * RETURNS
231 * Success: TRUE
232 * Failure: FALSE
234 BOOL WINAPI GetThreadContext( HANDLE handle, /* [in] Handle to thread with context */
235 CONTEXT *context ) /* [out] Address of context structure */
237 NTSTATUS status = NtGetContextThread( handle, context );
238 if (status) SetLastError( RtlNtStatusToDosError(status) );
239 return !status;
243 /**********************************************************************
244 * SuspendThread [KERNEL32.@] Suspends a thread.
246 * RETURNS
247 * Success: Previous suspend count
248 * Failure: 0xFFFFFFFF
250 DWORD WINAPI SuspendThread( HANDLE hthread ) /* [in] Handle to the thread */
252 DWORD ret;
253 NTSTATUS status = NtSuspendThread( hthread, &ret );
255 if (status)
257 ret = ~0U;
258 SetLastError( RtlNtStatusToDosError(status) );
260 return ret;
264 /**********************************************************************
265 * ResumeThread [KERNEL32.@] Resumes a thread.
267 * Decrements a thread's suspend count. When count is zero, the
268 * execution of the thread is resumed.
270 * RETURNS
271 * Success: Previous suspend count
272 * Failure: 0xFFFFFFFF
273 * Already running: 0
275 DWORD WINAPI ResumeThread( HANDLE hthread ) /* [in] Identifies thread to restart */
277 DWORD ret;
278 NTSTATUS status = NtResumeThread( hthread, &ret );
280 if (status)
282 ret = ~0U;
283 SetLastError( RtlNtStatusToDosError(status) );
285 return ret;
289 /**********************************************************************
290 * GetThreadPriority [KERNEL32.@] Returns priority for thread.
292 * RETURNS
293 * Success: Thread's priority level.
294 * Failure: THREAD_PRIORITY_ERROR_RETURN
296 INT WINAPI GetThreadPriority(
297 HANDLE hthread) /* [in] Handle to thread */
299 THREAD_BASIC_INFORMATION info;
300 NTSTATUS status = NtQueryInformationThread( hthread, ThreadBasicInformation,
301 &info, sizeof(info), NULL );
303 if (status)
305 SetLastError( RtlNtStatusToDosError(status) );
306 return THREAD_PRIORITY_ERROR_RETURN;
308 return info.Priority;
312 /**********************************************************************
313 * SetThreadPriority [KERNEL32.@] Sets priority for thread.
315 * RETURNS
316 * Success: TRUE
317 * Failure: FALSE
319 BOOL WINAPI SetThreadPriority(
320 HANDLE hthread, /* [in] Handle to thread */
321 INT priority) /* [in] Thread priority level */
323 DWORD prio = priority;
324 NTSTATUS status;
326 status = NtSetInformationThread(hthread, ThreadBasePriority,
327 &prio, sizeof(prio));
329 if (status)
331 SetLastError( RtlNtStatusToDosError(status) );
332 return FALSE;
335 return TRUE;
339 /**********************************************************************
340 * GetThreadPriorityBoost [KERNEL32.@] Returns priority boost for thread.
342 * Always reports that priority boost is disabled.
344 * RETURNS
345 * Success: TRUE.
346 * Failure: FALSE
348 BOOL WINAPI GetThreadPriorityBoost(
349 HANDLE hthread, /* [in] Handle to thread */
350 PBOOL pstate) /* [out] pointer to var that receives the boost state */
352 if (pstate) *pstate = FALSE;
353 return TRUE;
357 /**********************************************************************
358 * SetThreadPriorityBoost [KERNEL32.@] Sets priority boost for thread.
360 * Priority boost is not implemented. This function always returns
361 * FALSE and sets last error to ERROR_CALL_NOT_IMPLEMENTED
363 * RETURNS
364 * Always returns FALSE to indicate a failure
366 BOOL WINAPI SetThreadPriorityBoost(
367 HANDLE hthread, /* [in] Handle to thread */
368 BOOL disable) /* [in] TRUE to disable priority boost */
370 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
371 return FALSE;
375 /**********************************************************************
376 * SetThreadStackGuarantee (KERNEL32.@)
378 BOOL WINAPI SetThreadStackGuarantee(PULONG stacksize)
380 FIXME("(%p): stub\n", stacksize);
381 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
382 return FALSE;
385 /**********************************************************************
386 * SetThreadAffinityMask (KERNEL32.@)
388 DWORD_PTR WINAPI SetThreadAffinityMask( HANDLE hThread, DWORD_PTR dwThreadAffinityMask )
390 NTSTATUS status;
391 THREAD_BASIC_INFORMATION tbi;
393 status = NtQueryInformationThread( hThread, ThreadBasicInformation,
394 &tbi, sizeof(tbi), NULL );
395 if (status)
397 SetLastError( RtlNtStatusToDosError(status) );
398 return 0;
400 status = NtSetInformationThread( hThread, ThreadAffinityMask,
401 &dwThreadAffinityMask,
402 sizeof(dwThreadAffinityMask));
403 if (status)
405 SetLastError( RtlNtStatusToDosError(status) );
406 return 0;
408 return tbi.AffinityMask;
412 /**********************************************************************
413 * SetThreadIdealProcessor [KERNEL32.@] Sets preferred processor for thread.
415 * RETURNS
416 * Success: Value of last call to SetThreadIdealProcessor
417 * Failure: -1
419 DWORD WINAPI SetThreadIdealProcessor(
420 HANDLE hThread, /* [in] Specifies the thread of interest */
421 DWORD dwIdealProcessor) /* [in] Specifies the new preferred processor */
423 FIXME("(%p): stub\n",hThread);
424 if (dwIdealProcessor > MAXIMUM_PROCESSORS)
426 SetLastError(ERROR_INVALID_PARAMETER);
427 return ~0u;
429 return 0;
433 /***********************************************************************
434 * GetThreadSelectorEntry (KERNEL32.@)
436 BOOL WINAPI GetThreadSelectorEntry( HANDLE hthread, DWORD sel, LPLDT_ENTRY ldtent )
438 THREAD_DESCRIPTOR_INFORMATION tdi;
439 NTSTATUS status;
441 tdi.Selector = sel;
442 status = NtQueryInformationThread( hthread, ThreadDescriptorTableEntry, &tdi, sizeof(tdi), NULL);
443 if (status)
445 SetLastError( RtlNtStatusToDosError(status) );
446 return FALSE;
448 *ldtent = tdi.Entry;
449 return TRUE;
453 /* callback for QueueUserAPC */
454 static void CALLBACK call_user_apc( ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3 )
456 PAPCFUNC func = (PAPCFUNC)arg1;
457 func( arg2 );
460 /***********************************************************************
461 * QueueUserAPC (KERNEL32.@)
463 DWORD WINAPI QueueUserAPC( PAPCFUNC func, HANDLE hthread, ULONG_PTR data )
465 NTSTATUS status = NtQueueApcThread( hthread, call_user_apc, (ULONG_PTR)func, data, 0 );
467 if (status) SetLastError( RtlNtStatusToDosError(status) );
468 return !status;
471 /***********************************************************************
472 * QueueUserWorkItem (KERNEL32.@)
474 BOOL WINAPI QueueUserWorkItem( LPTHREAD_START_ROUTINE Function, PVOID Context, ULONG Flags )
476 NTSTATUS status;
478 TRACE("(%p,%p,0x%08x)\n", Function, Context, Flags);
480 status = RtlQueueWorkItem( Function, Context, Flags );
482 if (status) SetLastError( RtlNtStatusToDosError(status) );
483 return !status;
486 /**********************************************************************
487 * GetThreadTimes [KERNEL32.@] Obtains timing information.
489 * RETURNS
490 * Success: TRUE
491 * Failure: FALSE
493 BOOL WINAPI GetThreadTimes(
494 HANDLE thread, /* [in] Specifies the thread of interest */
495 LPFILETIME creationtime, /* [out] When the thread was created */
496 LPFILETIME exittime, /* [out] When the thread was destroyed */
497 LPFILETIME kerneltime, /* [out] Time thread spent in kernel mode */
498 LPFILETIME usertime) /* [out] Time thread spent in user mode */
500 KERNEL_USER_TIMES kusrt;
501 NTSTATUS status;
503 status = NtQueryInformationThread(thread, ThreadTimes, &kusrt,
504 sizeof(kusrt), NULL);
505 if (status)
507 SetLastError( RtlNtStatusToDosError(status) );
508 return FALSE;
510 if (creationtime)
512 creationtime->dwLowDateTime = kusrt.CreateTime.u.LowPart;
513 creationtime->dwHighDateTime = kusrt.CreateTime.u.HighPart;
515 if (exittime)
517 exittime->dwLowDateTime = kusrt.ExitTime.u.LowPart;
518 exittime->dwHighDateTime = kusrt.ExitTime.u.HighPart;
520 if (kerneltime)
522 kerneltime->dwLowDateTime = kusrt.KernelTime.u.LowPart;
523 kerneltime->dwHighDateTime = kusrt.KernelTime.u.HighPart;
525 if (usertime)
527 usertime->dwLowDateTime = kusrt.UserTime.u.LowPart;
528 usertime->dwHighDateTime = kusrt.UserTime.u.HighPart;
531 return TRUE;
534 /**********************************************************************
535 * GetThreadId [KERNEL32.@]
537 * Retrieve the identifier of a thread.
539 * PARAMS
540 * Thread [I] The thread to retrieve the identifier of.
542 * RETURNS
543 * Success: Identifier of the target thread.
544 * Failure: 0
546 DWORD WINAPI GetThreadId(HANDLE Thread)
548 THREAD_BASIC_INFORMATION tbi;
549 NTSTATUS status;
551 TRACE("(%p)\n", Thread);
553 status = NtQueryInformationThread(Thread, ThreadBasicInformation, &tbi,
554 sizeof(tbi), NULL);
555 if (status)
557 SetLastError( RtlNtStatusToDosError(status) );
558 return 0;
561 return HandleToULong(tbi.ClientId.UniqueThread);
565 /***********************************************************************
566 * GetCurrentThread [KERNEL32.@] Gets pseudohandle for current thread
568 * RETURNS
569 * Pseudohandle for the current thread
571 #undef GetCurrentThread
572 HANDLE WINAPI GetCurrentThread(void)
574 return (HANDLE)~(ULONG_PTR)1;
578 #ifdef __i386__
580 /***********************************************************************
581 * SetLastError (KERNEL32.@)
583 /* void WINAPI SetLastError( DWORD error ); */
584 __ASM_STDCALL_FUNC( SetLastError, 4,
585 "movl 4(%esp),%eax\n\t"
586 ".byte 0x64\n\t"
587 "movl %eax,0x34\n\t"
588 "ret $4" )
590 /***********************************************************************
591 * GetLastError (KERNEL32.@)
593 /* DWORD WINAPI GetLastError(void); */
594 __ASM_STDCALL_FUNC( GetLastError, 0, ".byte 0x64\n\tmovl 0x34,%eax\n\tret" )
596 /***********************************************************************
597 * GetCurrentProcessId (KERNEL32.@)
599 /* DWORD WINAPI GetCurrentProcessId(void) */
600 __ASM_STDCALL_FUNC( GetCurrentProcessId, 0, ".byte 0x64\n\tmovl 0x20,%eax\n\tret" )
602 /***********************************************************************
603 * GetCurrentThreadId (KERNEL32.@)
605 /* DWORD WINAPI GetCurrentThreadId(void) */
606 __ASM_STDCALL_FUNC( GetCurrentThreadId, 0, ".byte 0x64\n\tmovl 0x24,%eax\n\tret" )
608 /***********************************************************************
609 * GetProcessHeap (KERNEL32.@)
611 /* HANDLE WINAPI GetProcessHeap(void) */
612 __ASM_STDCALL_FUNC( GetProcessHeap, 0, ".byte 0x64\n\tmovl 0x30,%eax\n\tmovl 0x18(%eax),%eax\n\tret");
614 #elif defined(__x86_64__)
616 /***********************************************************************
617 * SetLastError (KERNEL32.@)
619 /* void WINAPI SetLastError( DWORD error ); */
620 __ASM_STDCALL_FUNC( SetLastError, 8, ".byte 0x65\n\tmovl %ecx,0x68\n\tret" );
622 /***********************************************************************
623 * GetLastError (KERNEL32.@)
625 /* DWORD WINAPI GetLastError(void); */
626 __ASM_STDCALL_FUNC( GetLastError, 0, ".byte 0x65\n\tmovl 0x68,%eax\n\tret" );
628 /***********************************************************************
629 * GetCurrentProcessId (KERNEL32.@)
631 /* DWORD WINAPI GetCurrentProcessId(void) */
632 __ASM_STDCALL_FUNC( GetCurrentProcessId, 0, ".byte 0x65\n\tmovl 0x40,%eax\n\tret" );
634 /***********************************************************************
635 * GetCurrentThreadId (KERNEL32.@)
637 /* DWORD WINAPI GetCurrentThreadId(void) */
638 __ASM_STDCALL_FUNC( GetCurrentThreadId, 0, ".byte 0x65\n\tmovl 0x48,%eax\n\tret" );
640 /***********************************************************************
641 * GetProcessHeap (KERNEL32.@)
643 /* HANDLE WINAPI GetProcessHeap(void) */
644 __ASM_STDCALL_FUNC( GetProcessHeap, 0, ".byte 0x65\n\tmovq 0x60,%rax\n\tmovq 0x30(%rax),%rax\n\tret");
646 #else /* __x86_64__ */
648 /**********************************************************************
649 * SetLastError (KERNEL32.@)
651 * Sets the last-error code.
653 * RETURNS
654 * Nothing.
656 void WINAPI SetLastError( DWORD error ) /* [in] Per-thread error code */
658 NtCurrentTeb()->LastErrorValue = error;
661 /**********************************************************************
662 * GetLastError (KERNEL32.@)
664 * Get the last-error code.
666 * RETURNS
667 * last-error code.
669 DWORD WINAPI GetLastError(void)
671 return NtCurrentTeb()->LastErrorValue;
674 /***********************************************************************
675 * GetCurrentProcessId (KERNEL32.@)
677 * Get the current process identifier.
679 * RETURNS
680 * current process identifier
682 DWORD WINAPI GetCurrentProcessId(void)
684 return HandleToULong(NtCurrentTeb()->ClientId.UniqueProcess);
687 /***********************************************************************
688 * GetCurrentThreadId (KERNEL32.@)
690 * Get the current thread identifier.
692 * RETURNS
693 * current thread identifier
695 DWORD WINAPI GetCurrentThreadId(void)
697 return HandleToULong(NtCurrentTeb()->ClientId.UniqueThread);
700 /***********************************************************************
701 * GetProcessHeap (KERNEL32.@)
703 HANDLE WINAPI GetProcessHeap(void)
705 return NtCurrentTeb()->Peb->ProcessHeap;
708 #endif /* __i386__ */
710 /*************************************************************************
711 * rtlmode_to_win32mode
713 static DWORD rtlmode_to_win32mode( DWORD rtlmode )
715 DWORD win32mode = 0;
717 if (rtlmode & 0x10)
718 win32mode |= SEM_FAILCRITICALERRORS;
719 if (rtlmode & 0x20)
720 win32mode |= SEM_NOGPFAULTERRORBOX;
721 if (rtlmode & 0x40)
722 win32mode |= SEM_NOOPENFILEERRORBOX;
724 return win32mode;
727 /***********************************************************************
728 * SetThreadErrorMode (KERNEL32.@)
730 * Set the thread local error mode.
732 * PARAMS
733 * mode [I] The new error mode, a bitwise or of SEM_FAILCRITICALERRORS,
734 * SEM_NOGPFAULTERRORBOX and SEM_NOOPENFILEERRORBOX.
735 * oldmode [O] Destination of the old error mode (may be NULL)
737 * RETURNS
738 * Success: TRUE
739 * Failure: FALSE, check GetLastError
741 BOOL WINAPI SetThreadErrorMode( DWORD mode, LPDWORD oldmode )
743 NTSTATUS status;
744 DWORD tmp = 0;
746 if (mode & ~(SEM_FAILCRITICALERRORS |
747 SEM_NOGPFAULTERRORBOX |
748 SEM_NOOPENFILEERRORBOX))
750 SetLastError( ERROR_INVALID_PARAMETER );
751 return FALSE;
754 if (mode & SEM_FAILCRITICALERRORS)
755 tmp |= 0x10;
756 if (mode & SEM_NOGPFAULTERRORBOX)
757 tmp |= 0x20;
758 if (mode & SEM_NOOPENFILEERRORBOX)
759 tmp |= 0x40;
761 status = RtlSetThreadErrorMode( tmp, oldmode );
762 if (status)
764 SetLastError( RtlNtStatusToDosError(status) );
765 return FALSE;
768 if (oldmode)
769 *oldmode = rtlmode_to_win32mode(*oldmode);
771 return TRUE;
774 /***********************************************************************
775 * GetThreadErrorMode (KERNEL32.@)
777 * Get the thread local error mode.
779 * PARAMS
780 * None.
782 * RETURNS
783 * The current thread local error mode.
785 DWORD WINAPI GetThreadErrorMode( void )
787 return rtlmode_to_win32mode( RtlGetThreadErrorMode() );
790 /***********************************************************************
791 * GetThreadUILanguage (KERNEL32.@)
793 * Get the current thread's language identifier.
795 * PARAMS
796 * None.
798 * RETURNS
799 * The current thread's language identifier.
801 LANGID WINAPI GetThreadUILanguage( void )
803 LANGID lang;
804 NtQueryDefaultUILanguage( &lang );
805 FIXME(": stub, returning default language.\n");
806 return lang;
809 /***********************************************************************
810 * GetThreadIOPendingFlag (KERNEL32.@)
812 BOOL WINAPI GetThreadIOPendingFlag( HANDLE thread, PBOOL io_pending )
814 FIXME("%p, %p\n", thread, io_pending);
815 *io_pending = FALSE;
816 return TRUE;
819 /***********************************************************************
820 * SetThreadPreferredUILanguages (KERNEL32.@)
822 BOOL WINAPI SetThreadPreferredUILanguages( DWORD flags, PCZZWSTR buffer, PULONG count )
824 FIXME( "%u, %p, %p\n", flags, buffer, count );
825 return TRUE;
828 /***********************************************************************
829 * GetThreadPreferredUILanguages (KERNEL32.@)
831 BOOL WINAPI GetThreadPreferredUILanguages( DWORD flags, PULONG count, PCZZWSTR buffer, PULONG buffersize )
833 FIXME( "%u, %p, %p %p\n", flags, count, buffer, buffersize );
834 *count = 0;
835 *buffersize = 0;
836 return TRUE;
839 /***********************************************************************
840 * InitializeSRWLock (KERNEL32.@)
842 VOID WINAPI InitializeSRWLock( PSRWLOCK srwlock )
844 FIXME( "(%p): stub\n", srwlock );
847 /***********************************************************************
848 * AcquireSRWLockExclusive (KERNEL32.@)
850 VOID WINAPI AcquireSRWLockExclusive( PSRWLOCK srwlock )
852 FIXME( "(%p): stub\n", srwlock );
855 /***********************************************************************
856 * ReleaseSRWLockExclusive (KERNEL32.@)
858 VOID WINAPI ReleaseSRWLockExclusive( PSRWLOCK srwlock )
860 FIXME( "(%p): stub\n", srwlock );
863 /***********************************************************************
864 * AcquireSRWLockShared (KERNEL32.@)
866 VOID WINAPI AcquireSRWLockShared( PSRWLOCK srwlock )
868 FIXME( "(%p): stub\n", srwlock );
871 /***********************************************************************
872 * ReleaseSRWLockShared (KERNEL32.@)
874 VOID WINAPI ReleaseSRWLockShared( PSRWLOCK srwlock )
876 FIXME( "(%p): stub\n", srwlock );