ntdll/tests: Make sure we can enumerate the directory.
[wine] / dlls / ntdll / sync.c
1 /*
2  *      Process synchronisation
3  *
4  * Copyright 1996, 1997, 1998 Marcus Meissner
5  * Copyright 1997, 1999 Alexandre Julliard
6  * Copyright 1999, 2000 Juergen Schmied
7  * Copyright 2003 Eric Pouech
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  */
23
24 #include "config.h"
25
26 #include <assert.h>
27 #include <errno.h>
28 #include <signal.h>
29 #ifdef HAVE_SYS_TIME_H
30 # include <sys/time.h>
31 #endif
32 #ifdef HAVE_POLL_H
33 #include <poll.h>
34 #endif
35 #ifdef HAVE_SYS_POLL_H
36 # include <sys/poll.h>
37 #endif
38 #ifdef HAVE_UNISTD_H
39 # include <unistd.h>
40 #endif
41 #ifdef HAVE_SCHED_H
42 # include <sched.h>
43 #endif
44 #include <string.h>
45 #include <stdarg.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <time.h>
49
50 #define NONAMELESSUNION
51 #define NONAMELESSSTRUCT
52
53 #include "ntstatus.h"
54 #define WIN32_NO_STATUS
55 #include "windef.h"
56 #include "winternl.h"
57 #include "wine/server.h"
58 #include "wine/debug.h"
59 #include "ntdll_misc.h"
60
61 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
62
63 /* creates a struct security_descriptor and contained information in one contiguous piece of memory */
64 NTSTATUS NTDLL_create_struct_sd(PSECURITY_DESCRIPTOR nt_sd, struct security_descriptor **server_sd,
65                                 data_size_t *server_sd_len)
66 {
67     unsigned int len;
68     PSID owner, group;
69     ACL *dacl, *sacl;
70     BOOLEAN owner_present, group_present, dacl_present, sacl_present;
71     BOOLEAN defaulted;
72     NTSTATUS status;
73     unsigned char *ptr;
74
75     if (!nt_sd)
76     {
77         *server_sd = NULL;
78         *server_sd_len = 0;
79         return STATUS_SUCCESS;
80     }
81
82     len = sizeof(struct security_descriptor);
83
84     status = RtlGetOwnerSecurityDescriptor(nt_sd, &owner, &owner_present);
85     if (status != STATUS_SUCCESS) return status;
86     status = RtlGetGroupSecurityDescriptor(nt_sd, &group, &group_present);
87     if (status != STATUS_SUCCESS) return status;
88     status = RtlGetSaclSecurityDescriptor(nt_sd, &sacl_present, &sacl, &defaulted);
89     if (status != STATUS_SUCCESS) return status;
90     status = RtlGetDaclSecurityDescriptor(nt_sd, &dacl_present, &dacl, &defaulted);
91     if (status != STATUS_SUCCESS) return status;
92
93     if (owner_present)
94         len += RtlLengthSid(owner);
95     if (group_present)
96         len += RtlLengthSid(group);
97     if (sacl_present && sacl)
98         len += sacl->AclSize;
99     if (dacl_present && dacl)
100         len += dacl->AclSize;
101
102     /* fix alignment for the Unicode name that follows the structure */
103     len = (len + sizeof(WCHAR) - 1) & ~(sizeof(WCHAR) - 1);
104     *server_sd = RtlAllocateHeap(GetProcessHeap(), 0, len);
105     if (!*server_sd) return STATUS_NO_MEMORY;
106
107     (*server_sd)->control = ((SECURITY_DESCRIPTOR *)nt_sd)->Control & ~SE_SELF_RELATIVE;
108     (*server_sd)->owner_len = owner_present ? RtlLengthSid(owner) : 0;
109     (*server_sd)->group_len = group_present ? RtlLengthSid(group) : 0;
110     (*server_sd)->sacl_len = (sacl_present && sacl) ? sacl->AclSize : 0;
111     (*server_sd)->dacl_len = (dacl_present && dacl) ? dacl->AclSize : 0;
112
113     ptr = (unsigned char *)(*server_sd + 1);
114     memcpy(ptr, owner, (*server_sd)->owner_len);
115     ptr += (*server_sd)->owner_len;
116     memcpy(ptr, group, (*server_sd)->group_len);
117     ptr += (*server_sd)->group_len;
118     memcpy(ptr, sacl, (*server_sd)->sacl_len);
119     ptr += (*server_sd)->sacl_len;
120     memcpy(ptr, dacl, (*server_sd)->dacl_len);
121
122     *server_sd_len = len;
123
124     return STATUS_SUCCESS;
125 }
126
127 /* frees a struct security_descriptor allocated by NTDLL_create_struct_sd */
128 void NTDLL_free_struct_sd(struct security_descriptor *server_sd)
129 {
130     RtlFreeHeap(GetProcessHeap(), 0, server_sd);
131 }
132
133 /*
134  *      Semaphores
135  */
136
137 /******************************************************************************
138  *  NtCreateSemaphore (NTDLL.@)
139  */
140 NTSTATUS WINAPI NtCreateSemaphore( OUT PHANDLE SemaphoreHandle,
141                                    IN ACCESS_MASK access,
142                                    IN const OBJECT_ATTRIBUTES *attr OPTIONAL,
143                                    IN LONG InitialCount,
144                                    IN LONG MaximumCount )
145 {
146     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
147     NTSTATUS ret;
148     struct object_attributes objattr;
149     struct security_descriptor *sd = NULL;
150
151     if (MaximumCount <= 0 || InitialCount < 0 || InitialCount > MaximumCount)
152         return STATUS_INVALID_PARAMETER;
153     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
154
155     objattr.rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
156     objattr.sd_len = 0;
157     objattr.name_len = len;
158     if (attr)
159     {
160         ret = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
161         if (ret != STATUS_SUCCESS) return ret;
162     }
163
164     SERVER_START_REQ( create_semaphore )
165     {
166         req->access  = access;
167         req->attributes = (attr) ? attr->Attributes : 0;
168         req->initial = InitialCount;
169         req->max     = MaximumCount;
170         wine_server_add_data( req, &objattr, sizeof(objattr) );
171         if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
172         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
173         ret = wine_server_call( req );
174         *SemaphoreHandle = wine_server_ptr_handle( reply->handle );
175     }
176     SERVER_END_REQ;
177
178     NTDLL_free_struct_sd( sd );
179
180     return ret;
181 }
182
183 /******************************************************************************
184  *  NtOpenSemaphore (NTDLL.@)
185  */
186 NTSTATUS WINAPI NtOpenSemaphore( OUT PHANDLE SemaphoreHandle,
187                                  IN ACCESS_MASK access,
188                                  IN const OBJECT_ATTRIBUTES *attr )
189 {
190     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
191     NTSTATUS ret;
192
193     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
194
195     SERVER_START_REQ( open_semaphore )
196     {
197         req->access  = access;
198         req->attributes = (attr) ? attr->Attributes : 0;
199         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
200         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
201         ret = wine_server_call( req );
202         *SemaphoreHandle = wine_server_ptr_handle( reply->handle );
203     }
204     SERVER_END_REQ;
205     return ret;
206 }
207
208 /******************************************************************************
209  *  NtQuerySemaphore (NTDLL.@)
210  */
211 NTSTATUS WINAPI NtQuerySemaphore(
212         HANDLE SemaphoreHandle,
213         SEMAPHORE_INFORMATION_CLASS SemaphoreInformationClass,
214         PVOID SemaphoreInformation,
215         ULONG Length,
216         PULONG ReturnLength)
217 {
218         FIXME("(%p,%d,%p,0x%08x,%p) stub!\n",
219         SemaphoreHandle, SemaphoreInformationClass, SemaphoreInformation, Length, ReturnLength);
220         return STATUS_SUCCESS;
221 }
222
223 /******************************************************************************
224  *  NtReleaseSemaphore (NTDLL.@)
225  */
226 NTSTATUS WINAPI NtReleaseSemaphore( HANDLE handle, ULONG count, PULONG previous )
227 {
228     NTSTATUS ret;
229     SERVER_START_REQ( release_semaphore )
230     {
231         req->handle = wine_server_obj_handle( handle );
232         req->count  = count;
233         if (!(ret = wine_server_call( req )))
234         {
235             if (previous) *previous = reply->prev_count;
236         }
237     }
238     SERVER_END_REQ;
239     return ret;
240 }
241
242 /*
243  *      Events
244  */
245
246 /**************************************************************************
247  * NtCreateEvent (NTDLL.@)
248  * ZwCreateEvent (NTDLL.@)
249  */
250 NTSTATUS WINAPI NtCreateEvent( PHANDLE EventHandle, ACCESS_MASK DesiredAccess,
251                                const OBJECT_ATTRIBUTES *attr, EVENT_TYPE type, BOOLEAN InitialState)
252 {
253     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
254     NTSTATUS ret;
255     struct security_descriptor *sd = NULL;
256     struct object_attributes objattr;
257
258     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
259
260     objattr.rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
261     objattr.sd_len = 0;
262     objattr.name_len = len;
263     if (attr)
264     {
265         ret = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
266         if (ret != STATUS_SUCCESS) return ret;
267     }
268
269     SERVER_START_REQ( create_event )
270     {
271         req->access = DesiredAccess;
272         req->attributes = (attr) ? attr->Attributes : 0;
273         req->manual_reset = (type == NotificationEvent);
274         req->initial_state = InitialState;
275         wine_server_add_data( req, &objattr, sizeof(objattr) );
276         if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
277         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
278         ret = wine_server_call( req );
279         *EventHandle = wine_server_ptr_handle( reply->handle );
280     }
281     SERVER_END_REQ;
282
283     NTDLL_free_struct_sd( sd );
284
285     return ret;
286 }
287
288 /******************************************************************************
289  *  NtOpenEvent (NTDLL.@)
290  *  ZwOpenEvent (NTDLL.@)
291  */
292 NTSTATUS WINAPI NtOpenEvent(
293         OUT PHANDLE EventHandle,
294         IN ACCESS_MASK DesiredAccess,
295         IN const OBJECT_ATTRIBUTES *attr )
296 {
297     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
298     NTSTATUS ret;
299
300     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
301
302     SERVER_START_REQ( open_event )
303     {
304         req->access  = DesiredAccess;
305         req->attributes = (attr) ? attr->Attributes : 0;
306         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
307         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
308         ret = wine_server_call( req );
309         *EventHandle = wine_server_ptr_handle( reply->handle );
310     }
311     SERVER_END_REQ;
312     return ret;
313 }
314
315
316 /******************************************************************************
317  *  NtSetEvent (NTDLL.@)
318  *  ZwSetEvent (NTDLL.@)
319  */
320 NTSTATUS WINAPI NtSetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
321 {
322     NTSTATUS ret;
323
324     /* FIXME: set NumberOfThreadsReleased */
325
326     SERVER_START_REQ( event_op )
327     {
328         req->handle = wine_server_obj_handle( handle );
329         req->op     = SET_EVENT;
330         ret = wine_server_call( req );
331     }
332     SERVER_END_REQ;
333     return ret;
334 }
335
336 /******************************************************************************
337  *  NtResetEvent (NTDLL.@)
338  */
339 NTSTATUS WINAPI NtResetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
340 {
341     NTSTATUS ret;
342
343     /* resetting an event can't release any thread... */
344     if (NumberOfThreadsReleased) *NumberOfThreadsReleased = 0;
345
346     SERVER_START_REQ( event_op )
347     {
348         req->handle = wine_server_obj_handle( handle );
349         req->op     = RESET_EVENT;
350         ret = wine_server_call( req );
351     }
352     SERVER_END_REQ;
353     return ret;
354 }
355
356 /******************************************************************************
357  *  NtClearEvent (NTDLL.@)
358  *
359  * FIXME
360  *   same as NtResetEvent ???
361  */
362 NTSTATUS WINAPI NtClearEvent ( HANDLE handle )
363 {
364     return NtResetEvent( handle, NULL );
365 }
366
367 /******************************************************************************
368  *  NtPulseEvent (NTDLL.@)
369  *
370  * FIXME
371  *   PulseCount
372  */
373 NTSTATUS WINAPI NtPulseEvent( HANDLE handle, PULONG PulseCount )
374 {
375     NTSTATUS ret;
376
377     if (PulseCount)
378       FIXME("(%p,%d)\n", handle, *PulseCount);
379
380     SERVER_START_REQ( event_op )
381     {
382         req->handle = wine_server_obj_handle( handle );
383         req->op     = PULSE_EVENT;
384         ret = wine_server_call( req );
385     }
386     SERVER_END_REQ;
387     return ret;
388 }
389
390 /******************************************************************************
391  *  NtQueryEvent (NTDLL.@)
392  */
393 NTSTATUS WINAPI NtQueryEvent (
394         IN  HANDLE EventHandle,
395         IN  EVENT_INFORMATION_CLASS EventInformationClass,
396         OUT PVOID EventInformation,
397         IN  ULONG EventInformationLength,
398         OUT PULONG  ReturnLength)
399 {
400         FIXME("(%p)\n", EventHandle);
401         return STATUS_NOT_IMPLEMENTED;
402 }
403
404 /*
405  *      Mutants (known as Mutexes in Kernel32)
406  */
407
408 /******************************************************************************
409  *              NtCreateMutant                          [NTDLL.@]
410  *              ZwCreateMutant                          [NTDLL.@]
411  */
412 NTSTATUS WINAPI NtCreateMutant(OUT HANDLE* MutantHandle,
413                                IN ACCESS_MASK access,
414                                IN const OBJECT_ATTRIBUTES* attr OPTIONAL,
415                                IN BOOLEAN InitialOwner)
416 {
417     NTSTATUS status;
418     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
419     struct security_descriptor *sd = NULL;
420     struct object_attributes objattr;
421
422     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
423
424     objattr.rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
425     objattr.sd_len = 0;
426     objattr.name_len = len;
427     if (attr)
428     {
429         status = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
430         if (status != STATUS_SUCCESS) return status;
431     }
432
433     SERVER_START_REQ( create_mutex )
434     {
435         req->access  = access;
436         req->attributes = (attr) ? attr->Attributes : 0;
437         req->owned   = InitialOwner;
438         wine_server_add_data( req, &objattr, sizeof(objattr) );
439         if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
440         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
441         status = wine_server_call( req );
442         *MutantHandle = wine_server_ptr_handle( reply->handle );
443     }
444     SERVER_END_REQ;
445
446     NTDLL_free_struct_sd( sd );
447
448     return status;
449 }
450
451 /**************************************************************************
452  *              NtOpenMutant                            [NTDLL.@]
453  *              ZwOpenMutant                            [NTDLL.@]
454  */
455 NTSTATUS WINAPI NtOpenMutant(OUT HANDLE* MutantHandle, 
456                              IN ACCESS_MASK access, 
457                              IN const OBJECT_ATTRIBUTES* attr )
458 {
459     NTSTATUS    status;
460     DWORD       len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
461
462     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
463
464     SERVER_START_REQ( open_mutex )
465     {
466         req->access  = access;
467         req->attributes = (attr) ? attr->Attributes : 0;
468         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
469         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
470         status = wine_server_call( req );
471         *MutantHandle = wine_server_ptr_handle( reply->handle );
472     }
473     SERVER_END_REQ;
474     return status;
475 }
476
477 /**************************************************************************
478  *              NtReleaseMutant                         [NTDLL.@]
479  *              ZwReleaseMutant                         [NTDLL.@]
480  */
481 NTSTATUS WINAPI NtReleaseMutant( IN HANDLE handle, OUT PLONG prev_count OPTIONAL)
482 {
483     NTSTATUS    status;
484
485     SERVER_START_REQ( release_mutex )
486     {
487         req->handle = wine_server_obj_handle( handle );
488         status = wine_server_call( req );
489         if (prev_count) *prev_count = reply->prev_count;
490     }
491     SERVER_END_REQ;
492     return status;
493 }
494
495 /******************************************************************
496  *              NtQueryMutant                   [NTDLL.@]
497  *              ZwQueryMutant                   [NTDLL.@]
498  */
499 NTSTATUS WINAPI NtQueryMutant(IN HANDLE handle, 
500                               IN MUTANT_INFORMATION_CLASS MutantInformationClass, 
501                               OUT PVOID MutantInformation, 
502                               IN ULONG MutantInformationLength, 
503                               OUT PULONG ResultLength OPTIONAL )
504 {
505     FIXME("(%p %u %p %u %p): stub!\n", 
506           handle, MutantInformationClass, MutantInformation, MutantInformationLength, ResultLength);
507     return STATUS_NOT_IMPLEMENTED;
508 }
509
510 /*
511  *      Jobs
512  */
513
514 /******************************************************************************
515  *              NtCreateJobObject   [NTDLL.@]
516  *              ZwCreateJobObject   [NTDLL.@]
517  */
518 NTSTATUS WINAPI NtCreateJobObject( PHANDLE handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
519 {
520     FIXME( "stub: %p %x %s\n", handle, access, attr ? debugstr_us(attr->ObjectName) : "" );
521     *handle = (HANDLE)0xdead;
522     return STATUS_SUCCESS;
523 }
524
525 /******************************************************************************
526  *              NtOpenJobObject   [NTDLL.@]
527  *              ZwOpenJobObject   [NTDLL.@]
528  */
529 NTSTATUS WINAPI NtOpenJobObject( PHANDLE handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
530 {
531     FIXME( "stub: %p %x %s\n", handle, access, attr ? debugstr_us(attr->ObjectName) : "" );
532     return STATUS_NOT_IMPLEMENTED;
533 }
534
535 /******************************************************************************
536  *              NtTerminateJobObject   [NTDLL.@]
537  *              ZwTerminateJobObject   [NTDLL.@]
538  */
539 NTSTATUS WINAPI NtTerminateJobObject( HANDLE handle, NTSTATUS status )
540 {
541     FIXME( "stub: %p %x\n", handle, status );
542     return STATUS_SUCCESS;
543 }
544
545 /******************************************************************************
546  *              NtQueryInformationJobObject   [NTDLL.@]
547  *              ZwQueryInformationJobObject   [NTDLL.@]
548  */
549 NTSTATUS WINAPI NtQueryInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, PVOID info,
550                                              ULONG len, PULONG ret_len )
551 {
552     FIXME( "stub: %p %u %p %u %p\n", handle, class, info, len, ret_len );
553     return STATUS_NOT_IMPLEMENTED;
554 }
555
556 /******************************************************************************
557  *              NtSetInformationJobObject   [NTDLL.@]
558  *              ZwSetInformationJobObject   [NTDLL.@]
559  */
560 NTSTATUS WINAPI NtSetInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, PVOID info, ULONG len )
561 {
562     FIXME( "stub: %p %u %p %u\n", handle, class, info, len );
563     return STATUS_SUCCESS;
564 }
565
566 /******************************************************************************
567  *              NtIsProcessInJob   [NTDLL.@]
568  *              ZwIsProcessInJob   [NTDLL.@]
569  */
570 NTSTATUS WINAPI NtIsProcessInJob( HANDLE process, HANDLE job )
571 {
572     FIXME( "stub: %p %p\n", process, job );
573     return STATUS_PROCESS_NOT_IN_JOB;
574 }
575
576 /******************************************************************************
577  *              NtAssignProcessToJobObject   [NTDLL.@]
578  *              ZwAssignProcessToJobObject   [NTDLL.@]
579  */
580 NTSTATUS WINAPI NtAssignProcessToJobObject( HANDLE job, HANDLE process )
581 {
582     FIXME( "stub: %p %p\n", job, process );
583     return STATUS_SUCCESS;
584 }
585
586 /*
587  *      Timers
588  */
589
590 /**************************************************************************
591  *              NtCreateTimer                           [NTDLL.@]
592  *              ZwCreateTimer                           [NTDLL.@]
593  */
594 NTSTATUS WINAPI NtCreateTimer(OUT HANDLE *handle,
595                               IN ACCESS_MASK access,
596                               IN const OBJECT_ATTRIBUTES *attr OPTIONAL,
597                               IN TIMER_TYPE timer_type)
598 {
599     DWORD       len = (attr && attr->ObjectName) ? attr->ObjectName->Length : 0;
600     NTSTATUS    status;
601
602     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
603
604     if (timer_type != NotificationTimer && timer_type != SynchronizationTimer)
605         return STATUS_INVALID_PARAMETER;
606
607     SERVER_START_REQ( create_timer )
608     {
609         req->access  = access;
610         req->attributes = (attr) ? attr->Attributes : 0;
611         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
612         req->manual  = (timer_type == NotificationTimer) ? TRUE : FALSE;
613         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
614         status = wine_server_call( req );
615         *handle = wine_server_ptr_handle( reply->handle );
616     }
617     SERVER_END_REQ;
618     return status;
619
620 }
621
622 /**************************************************************************
623  *              NtOpenTimer                             [NTDLL.@]
624  *              ZwOpenTimer                             [NTDLL.@]
625  */
626 NTSTATUS WINAPI NtOpenTimer(OUT PHANDLE handle,
627                             IN ACCESS_MASK access,
628                             IN const OBJECT_ATTRIBUTES* attr )
629 {
630     DWORD       len = (attr && attr->ObjectName) ? attr->ObjectName->Length : 0;
631     NTSTATUS    status;
632
633     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
634
635     SERVER_START_REQ( open_timer )
636     {
637         req->access  = access;
638         req->attributes = (attr) ? attr->Attributes : 0;
639         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
640         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
641         status = wine_server_call( req );
642         *handle = wine_server_ptr_handle( reply->handle );
643     }
644     SERVER_END_REQ;
645     return status;
646 }
647
648 /**************************************************************************
649  *              NtSetTimer                              [NTDLL.@]
650  *              ZwSetTimer                              [NTDLL.@]
651  */
652 NTSTATUS WINAPI NtSetTimer(IN HANDLE handle,
653                            IN const LARGE_INTEGER* when,
654                            IN PTIMER_APC_ROUTINE callback,
655                            IN PVOID callback_arg,
656                            IN BOOLEAN resume,
657                            IN ULONG period OPTIONAL,
658                            OUT PBOOLEAN state OPTIONAL)
659 {
660     NTSTATUS    status = STATUS_SUCCESS;
661
662     TRACE("(%p,%p,%p,%p,%08x,0x%08x,%p) stub\n",
663           handle, when, callback, callback_arg, resume, period, state);
664
665     SERVER_START_REQ( set_timer )
666     {
667         req->handle   = wine_server_obj_handle( handle );
668         req->period   = period;
669         req->expire   = when->QuadPart;
670         req->callback = wine_server_client_ptr( callback );
671         req->arg      = wine_server_client_ptr( callback_arg );
672         status = wine_server_call( req );
673         if (state) *state = reply->signaled;
674     }
675     SERVER_END_REQ;
676
677     /* set error but can still succeed */
678     if (resume && status == STATUS_SUCCESS) return STATUS_TIMER_RESUME_IGNORED;
679     return status;
680 }
681
682 /**************************************************************************
683  *              NtCancelTimer                           [NTDLL.@]
684  *              ZwCancelTimer                           [NTDLL.@]
685  */
686 NTSTATUS WINAPI NtCancelTimer(IN HANDLE handle, OUT BOOLEAN* state)
687 {
688     NTSTATUS    status;
689
690     SERVER_START_REQ( cancel_timer )
691     {
692         req->handle = wine_server_obj_handle( handle );
693         status = wine_server_call( req );
694         if (state) *state = reply->signaled;
695     }
696     SERVER_END_REQ;
697     return status;
698 }
699
700 /******************************************************************************
701  *  NtQueryTimer (NTDLL.@)
702  *
703  * Retrieves information about a timer.
704  *
705  * PARAMS
706  *  TimerHandle           [I] The timer to retrieve information about.
707  *  TimerInformationClass [I] The type of information to retrieve.
708  *  TimerInformation      [O] Pointer to buffer to store information in.
709  *  Length                [I] The length of the buffer pointed to by TimerInformation.
710  *  ReturnLength          [O] Optional. The size of buffer actually used.
711  *
712  * RETURNS
713  *  Success: STATUS_SUCCESS
714  *  Failure: STATUS_INFO_LENGTH_MISMATCH, if Length doesn't match the required data
715  *           size for the class specified.
716  *           STATUS_INVALID_INFO_CLASS, if an invalid TimerInformationClass was specified.
717  *           STATUS_ACCESS_DENIED, if TimerHandle does not have TIMER_QUERY_STATE access
718  *           to the timer.
719  */
720 NTSTATUS WINAPI NtQueryTimer(
721     HANDLE TimerHandle,
722     TIMER_INFORMATION_CLASS TimerInformationClass,
723     PVOID TimerInformation,
724     ULONG Length,
725     PULONG ReturnLength)
726 {
727     TIMER_BASIC_INFORMATION * basic_info = TimerInformation;
728     NTSTATUS status;
729     LARGE_INTEGER now;
730
731     TRACE("(%p,%d,%p,0x%08x,%p)\n", TimerHandle, TimerInformationClass,
732        TimerInformation, Length, ReturnLength);
733
734     switch (TimerInformationClass)
735     {
736     case TimerBasicInformation:
737         if (Length < sizeof(TIMER_BASIC_INFORMATION))
738             return STATUS_INFO_LENGTH_MISMATCH;
739
740         SERVER_START_REQ(get_timer_info)
741         {
742             req->handle = wine_server_obj_handle( TimerHandle );
743             status = wine_server_call(req);
744
745             /* convert server time to absolute NTDLL time */
746             basic_info->RemainingTime.QuadPart = reply->when;
747             basic_info->TimerState = reply->signaled;
748         }
749         SERVER_END_REQ;
750
751         /* convert from absolute into relative time */
752         NtQuerySystemTime(&now);
753         if (now.QuadPart > basic_info->RemainingTime.QuadPart)
754             basic_info->RemainingTime.QuadPart = 0;
755         else
756             basic_info->RemainingTime.QuadPart -= now.QuadPart;
757
758         if (ReturnLength) *ReturnLength = sizeof(TIMER_BASIC_INFORMATION);
759
760         return status;
761     }
762
763     FIXME("Unhandled class %d\n", TimerInformationClass);
764     return STATUS_INVALID_INFO_CLASS;
765 }
766
767
768 /******************************************************************************
769  * NtQueryTimerResolution [NTDLL.@]
770  */
771 NTSTATUS WINAPI NtQueryTimerResolution(OUT ULONG* min_resolution,
772                                        OUT ULONG* max_resolution,
773                                        OUT ULONG* current_resolution)
774 {
775     FIXME("(%p,%p,%p), stub!\n",
776           min_resolution, max_resolution, current_resolution);
777
778     return STATUS_NOT_IMPLEMENTED;
779 }
780
781 /******************************************************************************
782  * NtSetTimerResolution [NTDLL.@]
783  */
784 NTSTATUS WINAPI NtSetTimerResolution(IN ULONG resolution,
785                                      IN BOOLEAN set_resolution,
786                                      OUT ULONG* current_resolution )
787 {
788     FIXME("(%u,%u,%p), stub!\n",
789           resolution, set_resolution, current_resolution);
790
791     return STATUS_NOT_IMPLEMENTED;
792 }
793
794
795 /***********************************************************************
796  *              wait_reply
797  *
798  * Wait for a reply on the waiting pipe of the current thread.
799  */
800 static int wait_reply( void *cookie )
801 {
802     int signaled;
803     struct wake_up_reply reply;
804     for (;;)
805     {
806         int ret;
807         ret = read( ntdll_get_thread_data()->wait_fd[0], &reply, sizeof(reply) );
808         if (ret == sizeof(reply))
809         {
810             if (!reply.cookie) break;  /* thread got killed */
811             if (wine_server_get_ptr(reply.cookie) == cookie) return reply.signaled;
812             /* we stole another reply, wait for the real one */
813             signaled = wait_reply( cookie );
814             /* and now put the wrong one back in the pipe */
815             for (;;)
816             {
817                 ret = write( ntdll_get_thread_data()->wait_fd[1], &reply, sizeof(reply) );
818                 if (ret == sizeof(reply)) break;
819                 if (ret >= 0) server_protocol_error( "partial wakeup write %d\n", ret );
820                 if (errno == EINTR) continue;
821                 server_protocol_perror("wakeup write");
822             }
823             return signaled;
824         }
825         if (ret >= 0) server_protocol_error( "partial wakeup read %d\n", ret );
826         if (errno == EINTR) continue;
827         server_protocol_perror("wakeup read");
828     }
829     /* the server closed the connection; time to die... */
830     abort_thread(0);
831 }
832
833
834 /***********************************************************************
835  *              invoke_apc
836  *
837  * Invoke a single APC. Return TRUE if a user APC has been run.
838  */
839 static BOOL invoke_apc( const apc_call_t *call, apc_result_t *result )
840 {
841     BOOL user_apc = FALSE;
842     SIZE_T size;
843     void *addr;
844
845     memset( result, 0, sizeof(*result) );
846
847     switch (call->type)
848     {
849     case APC_NONE:
850         break;
851     case APC_USER:
852     {
853         void (WINAPI *func)(ULONG_PTR,ULONG_PTR,ULONG_PTR) = wine_server_get_ptr( call->user.func );
854         func( call->user.args[0], call->user.args[1], call->user.args[2] );
855         user_apc = TRUE;
856         break;
857     }
858     case APC_TIMER:
859     {
860         void (WINAPI *func)(void*, unsigned int, unsigned int) = wine_server_get_ptr( call->timer.func );
861         func( wine_server_get_ptr( call->timer.arg ),
862               (DWORD)call->timer.time, (DWORD)(call->timer.time >> 32) );
863         user_apc = TRUE;
864         break;
865     }
866     case APC_ASYNC_IO:
867     {
868         void *apc = NULL;
869         IO_STATUS_BLOCK *iosb = wine_server_get_ptr( call->async_io.sb );
870         NTSTATUS (*func)(void *, IO_STATUS_BLOCK *, NTSTATUS, void **) = wine_server_get_ptr( call->async_io.func );
871         result->type = call->type;
872         result->async_io.status = func( wine_server_get_ptr( call->async_io.user ),
873                                         iosb, call->async_io.status, &apc );
874         if (result->async_io.status != STATUS_PENDING)
875         {
876             result->async_io.total = iosb->Information;
877             result->async_io.apc   = wine_server_client_ptr( apc );
878         }
879         break;
880     }
881     case APC_VIRTUAL_ALLOC:
882         result->type = call->type;
883         addr = wine_server_get_ptr( call->virtual_alloc.addr );
884         size = call->virtual_alloc.size;
885         if ((ULONG_PTR)addr == call->virtual_alloc.addr && size == call->virtual_alloc.size)
886         {
887             result->virtual_alloc.status = NtAllocateVirtualMemory( NtCurrentProcess(), &addr,
888                                                                     call->virtual_alloc.zero_bits, &size,
889                                                                     call->virtual_alloc.op_type,
890                                                                     call->virtual_alloc.prot );
891             result->virtual_alloc.addr = wine_server_client_ptr( addr );
892             result->virtual_alloc.size = size;
893         }
894         else result->virtual_alloc.status = STATUS_WORKING_SET_LIMIT_RANGE;
895         break;
896     case APC_VIRTUAL_FREE:
897         result->type = call->type;
898         addr = wine_server_get_ptr( call->virtual_free.addr );
899         size = call->virtual_free.size;
900         if ((ULONG_PTR)addr == call->virtual_free.addr && size == call->virtual_free.size)
901         {
902             result->virtual_free.status = NtFreeVirtualMemory( NtCurrentProcess(), &addr, &size,
903                                                                call->virtual_free.op_type );
904             result->virtual_free.addr = wine_server_client_ptr( addr );
905             result->virtual_free.size = size;
906         }
907         else result->virtual_free.status = STATUS_INVALID_PARAMETER;
908         break;
909     case APC_VIRTUAL_QUERY:
910     {
911         MEMORY_BASIC_INFORMATION info;
912         result->type = call->type;
913         addr = wine_server_get_ptr( call->virtual_query.addr );
914         if ((ULONG_PTR)addr == call->virtual_query.addr)
915             result->virtual_query.status = NtQueryVirtualMemory( NtCurrentProcess(),
916                                                                  addr, MemoryBasicInformation, &info,
917                                                                  sizeof(info), NULL );
918         else
919             result->virtual_query.status = STATUS_WORKING_SET_LIMIT_RANGE;
920
921         if (result->virtual_query.status == STATUS_SUCCESS)
922         {
923             result->virtual_query.base       = wine_server_client_ptr( info.BaseAddress );
924             result->virtual_query.alloc_base = wine_server_client_ptr( info.AllocationBase );
925             result->virtual_query.size       = info.RegionSize;
926             result->virtual_query.prot       = info.Protect;
927             result->virtual_query.alloc_prot = info.AllocationProtect;
928             result->virtual_query.state      = info.State >> 12;
929             result->virtual_query.alloc_type = info.Type >> 16;
930         }
931         break;
932     }
933     case APC_VIRTUAL_PROTECT:
934         result->type = call->type;
935         addr = wine_server_get_ptr( call->virtual_protect.addr );
936         size = call->virtual_protect.size;
937         if ((ULONG_PTR)addr == call->virtual_protect.addr && size == call->virtual_protect.size)
938         {
939             result->virtual_protect.status = NtProtectVirtualMemory( NtCurrentProcess(), &addr, &size,
940                                                                      call->virtual_protect.prot,
941                                                                      &result->virtual_protect.prot );
942             result->virtual_protect.addr = wine_server_client_ptr( addr );
943             result->virtual_protect.size = size;
944         }
945         else result->virtual_protect.status = STATUS_INVALID_PARAMETER;
946         break;
947     case APC_VIRTUAL_FLUSH:
948         result->type = call->type;
949         addr = wine_server_get_ptr( call->virtual_flush.addr );
950         size = call->virtual_flush.size;
951         if ((ULONG_PTR)addr == call->virtual_flush.addr && size == call->virtual_flush.size)
952         {
953             result->virtual_flush.status = NtFlushVirtualMemory( NtCurrentProcess(),
954                                                                  (const void **)&addr, &size, 0 );
955             result->virtual_flush.addr = wine_server_client_ptr( addr );
956             result->virtual_flush.size = size;
957         }
958         else result->virtual_flush.status = STATUS_INVALID_PARAMETER;
959         break;
960     case APC_VIRTUAL_LOCK:
961         result->type = call->type;
962         addr = wine_server_get_ptr( call->virtual_lock.addr );
963         size = call->virtual_lock.size;
964         if ((ULONG_PTR)addr == call->virtual_lock.addr && size == call->virtual_lock.size)
965         {
966             result->virtual_lock.status = NtLockVirtualMemory( NtCurrentProcess(), &addr, &size, 0 );
967             result->virtual_lock.addr = wine_server_client_ptr( addr );
968             result->virtual_lock.size = size;
969         }
970         else result->virtual_lock.status = STATUS_INVALID_PARAMETER;
971         break;
972     case APC_VIRTUAL_UNLOCK:
973         result->type = call->type;
974         addr = wine_server_get_ptr( call->virtual_unlock.addr );
975         size = call->virtual_unlock.size;
976         if ((ULONG_PTR)addr == call->virtual_unlock.addr && size == call->virtual_unlock.size)
977         {
978             result->virtual_unlock.status = NtUnlockVirtualMemory( NtCurrentProcess(), &addr, &size, 0 );
979             result->virtual_unlock.addr = wine_server_client_ptr( addr );
980             result->virtual_unlock.size = size;
981         }
982         else result->virtual_unlock.status = STATUS_INVALID_PARAMETER;
983         break;
984     case APC_MAP_VIEW:
985         result->type = call->type;
986         addr = wine_server_get_ptr( call->map_view.addr );
987         size = call->map_view.size;
988         if ((ULONG_PTR)addr == call->map_view.addr && size == call->map_view.size)
989         {
990             LARGE_INTEGER offset;
991             offset.QuadPart = call->map_view.offset;
992             result->map_view.status = NtMapViewOfSection( wine_server_ptr_handle(call->map_view.handle),
993                                                           NtCurrentProcess(), &addr,
994                                                           call->map_view.zero_bits, 0,
995                                                           &offset, &size, ViewShare,
996                                                           call->map_view.alloc_type, call->map_view.prot );
997             result->map_view.addr = wine_server_client_ptr( addr );
998             result->map_view.size = size;
999         }
1000         else result->map_view.status = STATUS_INVALID_PARAMETER;
1001         NtClose( wine_server_ptr_handle(call->map_view.handle) );
1002         break;
1003     case APC_UNMAP_VIEW:
1004         result->type = call->type;
1005         addr = wine_server_get_ptr( call->unmap_view.addr );
1006         if ((ULONG_PTR)addr == call->unmap_view.addr)
1007             result->unmap_view.status = NtUnmapViewOfSection( NtCurrentProcess(), addr );
1008         else
1009             result->unmap_view.status = STATUS_INVALID_PARAMETER;
1010         break;
1011     case APC_CREATE_THREAD:
1012     {
1013         CLIENT_ID id;
1014         HANDLE handle;
1015         SIZE_T reserve = call->create_thread.reserve;
1016         SIZE_T commit = call->create_thread.commit;
1017         void *func = wine_server_get_ptr( call->create_thread.func );
1018         void *arg  = wine_server_get_ptr( call->create_thread.arg );
1019
1020         result->type = call->type;
1021         if (reserve == call->create_thread.reserve && commit == call->create_thread.commit &&
1022             (ULONG_PTR)func == call->create_thread.func && (ULONG_PTR)arg == call->create_thread.arg)
1023         {
1024             result->create_thread.status = RtlCreateUserThread( NtCurrentProcess(), NULL,
1025                                                                 call->create_thread.suspend, NULL,
1026                                                                 reserve, commit, func, arg, &handle, &id );
1027             result->create_thread.handle = wine_server_obj_handle( handle );
1028             result->create_thread.tid = HandleToULong(id.UniqueThread);
1029         }
1030         else result->create_thread.status = STATUS_INVALID_PARAMETER;
1031         break;
1032     }
1033     default:
1034         server_protocol_error( "get_apc_request: bad type %d\n", call->type );
1035         break;
1036     }
1037     return user_apc;
1038 }
1039
1040 /***********************************************************************
1041  *           NTDLL_queue_process_apc
1042  */
1043 NTSTATUS NTDLL_queue_process_apc( HANDLE process, const apc_call_t *call, apc_result_t *result )
1044 {
1045     for (;;)
1046     {
1047         NTSTATUS ret;
1048         HANDLE handle = 0;
1049         BOOL self = FALSE;
1050
1051         SERVER_START_REQ( queue_apc )
1052         {
1053             req->handle = wine_server_obj_handle( process );
1054             req->call = *call;
1055             if (!(ret = wine_server_call( req )))
1056             {
1057                 handle = wine_server_ptr_handle( reply->handle );
1058                 self = reply->self;
1059             }
1060         }
1061         SERVER_END_REQ;
1062         if (ret != STATUS_SUCCESS) return ret;
1063
1064         if (self)
1065         {
1066             invoke_apc( call, result );
1067         }
1068         else
1069         {
1070             NtWaitForSingleObject( handle, FALSE, NULL );
1071
1072             SERVER_START_REQ( get_apc_result )
1073             {
1074                 req->handle = wine_server_obj_handle( handle );
1075                 if (!(ret = wine_server_call( req ))) *result = reply->result;
1076             }
1077             SERVER_END_REQ;
1078
1079             if (!ret && result->type == APC_NONE) continue;  /* APC didn't run, try again */
1080             if (ret) NtClose( handle );
1081         }
1082         return ret;
1083     }
1084 }
1085
1086
1087 /***********************************************************************
1088  *              NTDLL_wait_for_multiple_objects
1089  *
1090  * Implementation of NtWaitForMultipleObjects
1091  */
1092 NTSTATUS NTDLL_wait_for_multiple_objects( UINT count, const HANDLE *handles, UINT flags,
1093                                           const LARGE_INTEGER *timeout, HANDLE signal_object )
1094 {
1095     NTSTATUS ret;
1096     int i, cookie;
1097     BOOL user_apc = FALSE;
1098     obj_handle_t obj_handles[MAXIMUM_WAIT_OBJECTS];
1099     obj_handle_t apc_handle = 0;
1100     apc_call_t call;
1101     apc_result_t result;
1102     timeout_t abs_timeout = timeout ? timeout->QuadPart : TIMEOUT_INFINITE;
1103
1104     memset( &result, 0, sizeof(result) );
1105     for (i = 0; i < count; i++) obj_handles[i] = wine_server_obj_handle( handles[i] );
1106
1107     for (;;)
1108     {
1109         SERVER_START_REQ( select )
1110         {
1111             req->flags    = flags;
1112             req->cookie   = wine_server_client_ptr( &cookie );
1113             req->signal   = wine_server_obj_handle( signal_object );
1114             req->prev_apc = apc_handle;
1115             req->timeout  = abs_timeout;
1116             wine_server_add_data( req, &result, sizeof(result) );
1117             wine_server_add_data( req, obj_handles, count * sizeof(*obj_handles) );
1118             ret = wine_server_call( req );
1119             abs_timeout = reply->timeout;
1120             apc_handle  = reply->apc_handle;
1121             call        = reply->call;
1122         }
1123         SERVER_END_REQ;
1124         if (ret == STATUS_PENDING) ret = wait_reply( &cookie );
1125         if (ret != STATUS_USER_APC) break;
1126         if (invoke_apc( &call, &result ))
1127         {
1128             /* if we ran a user apc we have to check once more if an object got signaled,
1129              * but we don't want to wait */
1130             abs_timeout = 0;
1131             user_apc = TRUE;
1132         }
1133         signal_object = 0;  /* don't signal it multiple times */
1134     }
1135
1136     if (ret == STATUS_TIMEOUT && user_apc) ret = STATUS_USER_APC;
1137
1138     /* A test on Windows 2000 shows that Windows always yields during
1139        a wait, but a wait that is hit by an event gets a priority
1140        boost as well.  This seems to model that behavior the closest.  */
1141     if (ret == STATUS_TIMEOUT) NtYieldExecution();
1142
1143     return ret;
1144 }
1145
1146
1147 /* wait operations */
1148
1149 /******************************************************************
1150  *              NtWaitForMultipleObjects (NTDLL.@)
1151  */
1152 NTSTATUS WINAPI NtWaitForMultipleObjects( DWORD count, const HANDLE *handles,
1153                                           BOOLEAN wait_all, BOOLEAN alertable,
1154                                           const LARGE_INTEGER *timeout )
1155 {
1156     UINT flags = SELECT_INTERRUPTIBLE;
1157
1158     if (!count || count > MAXIMUM_WAIT_OBJECTS) return STATUS_INVALID_PARAMETER_1;
1159
1160     if (wait_all) flags |= SELECT_ALL;
1161     if (alertable) flags |= SELECT_ALERTABLE;
1162     return NTDLL_wait_for_multiple_objects( count, handles, flags, timeout, 0 );
1163 }
1164
1165
1166 /******************************************************************
1167  *              NtWaitForSingleObject (NTDLL.@)
1168  */
1169 NTSTATUS WINAPI NtWaitForSingleObject(HANDLE handle, BOOLEAN alertable, const LARGE_INTEGER *timeout )
1170 {
1171     return NtWaitForMultipleObjects( 1, &handle, FALSE, alertable, timeout );
1172 }
1173
1174
1175 /******************************************************************
1176  *              NtSignalAndWaitForSingleObject (NTDLL.@)
1177  */
1178 NTSTATUS WINAPI NtSignalAndWaitForSingleObject( HANDLE hSignalObject, HANDLE hWaitObject,
1179                                                 BOOLEAN alertable, const LARGE_INTEGER *timeout )
1180 {
1181     UINT flags = SELECT_INTERRUPTIBLE;
1182
1183     if (!hSignalObject) return STATUS_INVALID_HANDLE;
1184     if (alertable) flags |= SELECT_ALERTABLE;
1185     return NTDLL_wait_for_multiple_objects( 1, &hWaitObject, flags, timeout, hSignalObject );
1186 }
1187
1188
1189 /******************************************************************
1190  *              NtYieldExecution (NTDLL.@)
1191  */
1192 NTSTATUS WINAPI NtYieldExecution(void)
1193 {
1194 #ifdef HAVE_SCHED_YIELD
1195     sched_yield();
1196     return STATUS_SUCCESS;
1197 #else
1198     return STATUS_NO_YIELD_PERFORMED;
1199 #endif
1200 }
1201
1202
1203 /******************************************************************
1204  *              NtDelayExecution (NTDLL.@)
1205  */
1206 NTSTATUS WINAPI NtDelayExecution( BOOLEAN alertable, const LARGE_INTEGER *timeout )
1207 {
1208     /* if alertable, we need to query the server */
1209     if (alertable)
1210         return NTDLL_wait_for_multiple_objects( 0, NULL, SELECT_INTERRUPTIBLE | SELECT_ALERTABLE,
1211                                                 timeout, 0 );
1212
1213     if (!timeout || timeout->QuadPart == TIMEOUT_INFINITE)  /* sleep forever */
1214     {
1215         for (;;) select( 0, NULL, NULL, NULL, NULL );
1216     }
1217     else
1218     {
1219         LARGE_INTEGER now;
1220         timeout_t when, diff;
1221
1222         if ((when = timeout->QuadPart) < 0)
1223         {
1224             NtQuerySystemTime( &now );
1225             when = now.QuadPart - when;
1226         }
1227
1228         /* Note that we yield after establishing the desired timeout */
1229         NtYieldExecution();
1230         if (!when) return STATUS_SUCCESS;
1231
1232         for (;;)
1233         {
1234             struct timeval tv;
1235             NtQuerySystemTime( &now );
1236             diff = (when - now.QuadPart + 9) / 10;
1237             if (diff <= 0) break;
1238             tv.tv_sec  = diff / 1000000;
1239             tv.tv_usec = diff % 1000000;
1240             if (select( 0, NULL, NULL, NULL, &tv ) != -1) break;
1241         }
1242     }
1243     return STATUS_SUCCESS;
1244 }
1245
1246 /******************************************************************
1247  *              NtCreateIoCompletion (NTDLL.@)
1248  *              ZwCreateIoCompletion (NTDLL.@)
1249  *
1250  * Creates I/O completion object.
1251  *
1252  * PARAMS
1253  *      CompletionPort            [O] created completion object handle will be placed there
1254  *      DesiredAccess             [I] desired access to a handle (combination of IO_COMPLETION_*)
1255  *      ObjectAttributes          [I] completion object attributes
1256  *      NumberOfConcurrentThreads [I] desired number of concurrent active worker threads
1257  *
1258  */
1259 NTSTATUS WINAPI NtCreateIoCompletion( PHANDLE CompletionPort, ACCESS_MASK DesiredAccess,
1260                                       POBJECT_ATTRIBUTES ObjectAttributes, ULONG NumberOfConcurrentThreads )
1261 {
1262     NTSTATUS status;
1263
1264     TRACE("(%p, %x, %p, %d)\n", CompletionPort, DesiredAccess,
1265           ObjectAttributes, NumberOfConcurrentThreads);
1266
1267     if (!CompletionPort)
1268         return STATUS_INVALID_PARAMETER;
1269
1270     SERVER_START_REQ( create_completion )
1271     {
1272         req->access     = DesiredAccess;
1273         req->attributes = ObjectAttributes ? ObjectAttributes->Attributes : 0;
1274         req->rootdir    = wine_server_obj_handle( ObjectAttributes ? ObjectAttributes->RootDirectory : 0 );
1275         req->concurrent = NumberOfConcurrentThreads;
1276         if (ObjectAttributes && ObjectAttributes->ObjectName)
1277             wine_server_add_data( req, ObjectAttributes->ObjectName->Buffer,
1278                                        ObjectAttributes->ObjectName->Length );
1279         if (!(status = wine_server_call( req )))
1280             *CompletionPort = wine_server_ptr_handle( reply->handle );
1281     }
1282     SERVER_END_REQ;
1283     return status;
1284 }
1285
1286 /******************************************************************
1287  *              NtSetIoCompletion (NTDLL.@)
1288  *              ZwSetIoCompletion (NTDLL.@)
1289  *
1290  * Inserts completion message into queue
1291  *
1292  * PARAMS
1293  *      CompletionPort           [I] HANDLE to completion object
1294  *      CompletionKey            [I] completion key
1295  *      CompletionValue          [I] completion value (usually pointer to OVERLAPPED)
1296  *      Status                   [I] operation status
1297  *      NumberOfBytesTransferred [I] number of bytes transferred
1298  */
1299 NTSTATUS WINAPI NtSetIoCompletion( HANDLE CompletionPort, ULONG_PTR CompletionKey,
1300                                    ULONG_PTR CompletionValue, NTSTATUS Status,
1301                                    ULONG NumberOfBytesTransferred )
1302 {
1303     NTSTATUS status;
1304
1305     TRACE("(%p, %lx, %lx, %x, %d)\n", CompletionPort, CompletionKey,
1306           CompletionValue, Status, NumberOfBytesTransferred);
1307
1308     SERVER_START_REQ( add_completion )
1309     {
1310         req->handle      = wine_server_obj_handle( CompletionPort );
1311         req->ckey        = CompletionKey;
1312         req->cvalue      = CompletionValue;
1313         req->status      = Status;
1314         req->information = NumberOfBytesTransferred;
1315         status = wine_server_call( req );
1316     }
1317     SERVER_END_REQ;
1318     return status;
1319 }
1320
1321 /******************************************************************
1322  *              NtRemoveIoCompletion (NTDLL.@)
1323  *              ZwRemoveIoCompletion (NTDLL.@)
1324  *
1325  * (Wait for and) retrieve first completion message from completion object's queue
1326  *
1327  * PARAMS
1328  *      CompletionPort  [I] HANDLE to I/O completion object
1329  *      CompletionKey   [O] completion key
1330  *      CompletionValue [O] Completion value given in NtSetIoCompletion or in async operation
1331  *      iosb            [O] IO_STATUS_BLOCK of completed asynchronous operation
1332  *      WaitTime        [I] optional wait time in NTDLL format
1333  *
1334  */
1335 NTSTATUS WINAPI NtRemoveIoCompletion( HANDLE CompletionPort, PULONG_PTR CompletionKey,
1336                                       PULONG_PTR CompletionValue, PIO_STATUS_BLOCK iosb,
1337                                       PLARGE_INTEGER WaitTime )
1338 {
1339     NTSTATUS status;
1340
1341     TRACE("(%p, %p, %p, %p, %p)\n", CompletionPort, CompletionKey,
1342           CompletionValue, iosb, WaitTime);
1343
1344     for(;;)
1345     {
1346         SERVER_START_REQ( remove_completion )
1347         {
1348             req->handle = wine_server_obj_handle( CompletionPort );
1349             if (!(status = wine_server_call( req )))
1350             {
1351                 *CompletionKey    = reply->ckey;
1352                 *CompletionValue  = reply->cvalue;
1353                 iosb->Information = reply->information;
1354                 iosb->u.Status    = reply->status;
1355             }
1356         }
1357         SERVER_END_REQ;
1358         if (status != STATUS_PENDING) break;
1359
1360         status = NtWaitForSingleObject( CompletionPort, FALSE, WaitTime );
1361         if (status != WAIT_OBJECT_0) break;
1362     }
1363     return status;
1364 }
1365
1366 /******************************************************************
1367  *              NtOpenIoCompletion (NTDLL.@)
1368  *              ZwOpenIoCompletion (NTDLL.@)
1369  *
1370  * Opens I/O completion object
1371  *
1372  * PARAMS
1373  *      CompletionPort     [O] completion object handle will be placed there
1374  *      DesiredAccess      [I] desired access to a handle (combination of IO_COMPLETION_*)
1375  *      ObjectAttributes   [I] completion object name
1376  *
1377  */
1378 NTSTATUS WINAPI NtOpenIoCompletion( PHANDLE CompletionPort, ACCESS_MASK DesiredAccess,
1379                                     POBJECT_ATTRIBUTES ObjectAttributes )
1380 {
1381     NTSTATUS status;
1382
1383     TRACE("(%p, 0x%x, %p)\n", CompletionPort, DesiredAccess, ObjectAttributes);
1384
1385     if (!CompletionPort || !ObjectAttributes || !ObjectAttributes->ObjectName)
1386         return STATUS_INVALID_PARAMETER;
1387
1388     SERVER_START_REQ( open_completion )
1389     {
1390         req->access     = DesiredAccess;
1391         req->rootdir    = wine_server_obj_handle( ObjectAttributes->RootDirectory );
1392         wine_server_add_data( req, ObjectAttributes->ObjectName->Buffer,
1393                                    ObjectAttributes->ObjectName->Length );
1394         if (!(status = wine_server_call( req )))
1395             *CompletionPort = wine_server_ptr_handle( reply->handle );
1396     }
1397     SERVER_END_REQ;
1398     return status;
1399 }
1400
1401 /******************************************************************
1402  *              NtQueryIoCompletion (NTDLL.@)
1403  *              ZwQueryIoCompletion (NTDLL.@)
1404  *
1405  * Requests information about given I/O completion object
1406  *
1407  * PARAMS
1408  *      CompletionPort        [I] HANDLE to completion port to request
1409  *      InformationClass      [I] information class
1410  *      CompletionInformation [O] user-provided buffer for data
1411  *      BufferLength          [I] buffer length
1412  *      RequiredLength        [O] required buffer length
1413  *
1414  */
1415 NTSTATUS WINAPI NtQueryIoCompletion( HANDLE CompletionPort, IO_COMPLETION_INFORMATION_CLASS InformationClass,
1416                                      PVOID CompletionInformation, ULONG BufferLength, PULONG RequiredLength )
1417 {
1418     NTSTATUS status;
1419
1420     TRACE("(%p, %d, %p, 0x%x, %p)\n", CompletionPort, InformationClass, CompletionInformation,
1421           BufferLength, RequiredLength);
1422
1423     if (!CompletionInformation) return STATUS_INVALID_PARAMETER;
1424     switch( InformationClass )
1425     {
1426         case IoCompletionBasicInformation:
1427             {
1428                 ULONG *info = CompletionInformation;
1429
1430                 if (RequiredLength) *RequiredLength = sizeof(*info);
1431                 if (BufferLength != sizeof(*info))
1432                     status = STATUS_INFO_LENGTH_MISMATCH;
1433                 else
1434                 {
1435                     SERVER_START_REQ( query_completion )
1436                     {
1437                         req->handle = wine_server_obj_handle( CompletionPort );
1438                         if (!(status = wine_server_call( req )))
1439                             *info = reply->depth;
1440                     }
1441                     SERVER_END_REQ;
1442                 }
1443             }
1444             break;
1445         default:
1446             status = STATUS_INVALID_PARAMETER;
1447             break;
1448     }
1449     return status;
1450 }
1451
1452 NTSTATUS NTDLL_AddCompletion( HANDLE hFile, ULONG_PTR CompletionValue,
1453                               NTSTATUS CompletionStatus, ULONG Information )
1454 {
1455     NTSTATUS status;
1456
1457     SERVER_START_REQ( add_fd_completion )
1458     {
1459         req->handle      = wine_server_obj_handle( hFile );
1460         req->cvalue      = CompletionValue;
1461         req->status      = CompletionStatus;
1462         req->information = Information;
1463         status = wine_server_call( req );
1464     }
1465     SERVER_END_REQ;
1466     return status;
1467 }