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(
 251         OUT PHANDLE EventHandle,
 252         IN ACCESS_MASK DesiredAccess,
 253         IN const OBJECT_ATTRIBUTES *attr,
 254         IN BOOLEAN ManualReset,
 255         IN BOOLEAN InitialState)
 256 {
 257     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 258     NTSTATUS ret;
 259     struct security_descriptor *sd = NULL;
 260     struct object_attributes objattr;
 261
 262     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 263
 264     objattr.rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 265     objattr.sd_len = 0;
 266     objattr.name_len = len;
 267     if (attr)
 268     {
 269         ret = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
 270         if (ret != STATUS_SUCCESS) return ret;
 271     }
 272
 273     SERVER_START_REQ( create_event )
 274     {
 275         req->access = DesiredAccess;
 276         req->attributes = (attr) ? attr->Attributes : 0;
 277         req->manual_reset = ManualReset;
 278         req->initial_state = InitialState;
 279         wine_server_add_data( req, &objattr, sizeof(objattr) );
 280         if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
 281         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 282         ret = wine_server_call( req );
 283         *EventHandle = wine_server_ptr_handle( reply->handle );
 284     }
 285     SERVER_END_REQ;
 286
 287     NTDLL_free_struct_sd( sd );
 288
 289     return ret;
 290 }
 291
 292 /******************************************************************************
 293  *  NtOpenEvent (NTDLL.@)
 294  *  ZwOpenEvent (NTDLL.@)
 295  */
 296 NTSTATUS WINAPI NtOpenEvent(
 297         OUT PHANDLE EventHandle,
 298         IN ACCESS_MASK DesiredAccess,
 299         IN const OBJECT_ATTRIBUTES *attr )
 300 {
 301     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 302     NTSTATUS ret;
 303
 304     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 305
 306     SERVER_START_REQ( open_event )
 307     {
 308         req->access  = DesiredAccess;
 309         req->attributes = (attr) ? attr->Attributes : 0;
 310         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 311         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 312         ret = wine_server_call( req );
 313         *EventHandle = wine_server_ptr_handle( reply->handle );
 314     }
 315     SERVER_END_REQ;
 316     return ret;
 317 }
 318
 319
 320 /******************************************************************************
 321  *  NtSetEvent (NTDLL.@)
 322  *  ZwSetEvent (NTDLL.@)
 323  */
 324 NTSTATUS WINAPI NtSetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 325 {
 326     NTSTATUS ret;
 327
 328     /* FIXME: set NumberOfThreadsReleased */
 329
 330     SERVER_START_REQ( event_op )
 331     {
 332         req->handle = wine_server_obj_handle( handle );
 333         req->op     = SET_EVENT;
 334         ret = wine_server_call( req );
 335     }
 336     SERVER_END_REQ;
 337     return ret;
 338 }
 339
 340 /******************************************************************************
 341  *  NtResetEvent (NTDLL.@)
 342  */
 343 NTSTATUS WINAPI NtResetEvent( HANDLE handle, PULONG NumberOfThreadsReleased )
 344 {
 345     NTSTATUS ret;
 346
 347     /* resetting an event can't release any thread... */
 348     if (NumberOfThreadsReleased) *NumberOfThreadsReleased = 0;
 349
 350     SERVER_START_REQ( event_op )
 351     {
 352         req->handle = wine_server_obj_handle( handle );
 353         req->op     = RESET_EVENT;
 354         ret = wine_server_call( req );
 355     }
 356     SERVER_END_REQ;
 357     return ret;
 358 }
 359
 360 /******************************************************************************
 361  *  NtClearEvent (NTDLL.@)
 362  *
 363  * FIXME
 364  *   same as NtResetEvent ???
 365  */
 366 NTSTATUS WINAPI NtClearEvent ( HANDLE handle )
 367 {
 368     return NtResetEvent( handle, NULL );
 369 }
 370
 371 /******************************************************************************
 372  *  NtPulseEvent (NTDLL.@)
 373  *
 374  * FIXME
 375  *   PulseCount
 376  */
 377 NTSTATUS WINAPI NtPulseEvent( HANDLE handle, PULONG PulseCount )
 378 {
 379     NTSTATUS ret;
 380
 381     if (PulseCount)
 382       FIXME("(%p,%d)\n", handle, *PulseCount);
 383
 384     SERVER_START_REQ( event_op )
 385     {
 386         req->handle = wine_server_obj_handle( handle );
 387         req->op     = PULSE_EVENT;
 388         ret = wine_server_call( req );
 389     }
 390     SERVER_END_REQ;
 391     return ret;
 392 }
 393
 394 /******************************************************************************
 395  *  NtQueryEvent (NTDLL.@)
 396  */
 397 NTSTATUS WINAPI NtQueryEvent (
 398         IN  HANDLE EventHandle,
 399         IN  EVENT_INFORMATION_CLASS EventInformationClass,
 400         OUT PVOID EventInformation,
 401         IN  ULONG EventInformationLength,
 402         OUT PULONG  ReturnLength)
 403 {
 404         FIXME("(%p)\n", EventHandle);
 405         return STATUS_SUCCESS;
 406 }
 407
 408 /*
 409  *      Mutants (known as Mutexes in Kernel32)
 410  */
 411
 412 /******************************************************************************
 413  *              NtCreateMutant                          [NTDLL.@]
 414  *              ZwCreateMutant                          [NTDLL.@]
 415  */
 416 NTSTATUS WINAPI NtCreateMutant(OUT HANDLE* MutantHandle,
 417                                IN ACCESS_MASK access,
 418                                IN const OBJECT_ATTRIBUTES* attr OPTIONAL,
 419                                IN BOOLEAN InitialOwner)
 420 {
 421     NTSTATUS status;
 422     DWORD len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 423     struct security_descriptor *sd = NULL;
 424     struct object_attributes objattr;
 425
 426     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 427
 428     objattr.rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 429     objattr.sd_len = 0;
 430     objattr.name_len = len;
 431     if (attr)
 432     {
 433         status = NTDLL_create_struct_sd( attr->SecurityDescriptor, &sd, &objattr.sd_len );
 434         if (status != STATUS_SUCCESS) return status;
 435     }
 436
 437     SERVER_START_REQ( create_mutex )
 438     {
 439         req->access  = access;
 440         req->attributes = (attr) ? attr->Attributes : 0;
 441         req->owned   = InitialOwner;
 442         wine_server_add_data( req, &objattr, sizeof(objattr) );
 443         if (objattr.sd_len) wine_server_add_data( req, sd, objattr.sd_len );
 444         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 445         status = wine_server_call( req );
 446         *MutantHandle = wine_server_ptr_handle( reply->handle );
 447     }
 448     SERVER_END_REQ;
 449
 450     NTDLL_free_struct_sd( sd );
 451
 452     return status;
 453 }
 454
 455 /**************************************************************************
 456  *              NtOpenMutant                            [NTDLL.@]
 457  *              ZwOpenMutant                            [NTDLL.@]
 458  */
 459 NTSTATUS WINAPI NtOpenMutant(OUT HANDLE* MutantHandle,
 460                              IN ACCESS_MASK access,
 461                              IN const OBJECT_ATTRIBUTES* attr )
 462 {
 463     NTSTATUS    status;
 464     DWORD       len = attr && attr->ObjectName ? attr->ObjectName->Length : 0;
 465
 466     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 467
 468     SERVER_START_REQ( open_mutex )
 469     {
 470         req->access  = access;
 471         req->attributes = (attr) ? attr->Attributes : 0;
 472         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 473         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 474         status = wine_server_call( req );
 475         *MutantHandle = wine_server_ptr_handle( reply->handle );
 476     }
 477     SERVER_END_REQ;
 478     return status;
 479 }
 480
 481 /**************************************************************************
 482  *              NtReleaseMutant                         [NTDLL.@]
 483  *              ZwReleaseMutant                         [NTDLL.@]
 484  */
 485 NTSTATUS WINAPI NtReleaseMutant( IN HANDLE handle, OUT PLONG prev_count OPTIONAL)
 486 {
 487     NTSTATUS    status;
 488
 489     SERVER_START_REQ( release_mutex )
 490     {
 491         req->handle = wine_server_obj_handle( handle );
 492         status = wine_server_call( req );
 493         if (prev_count) *prev_count = reply->prev_count;
 494     }
 495     SERVER_END_REQ;
 496     return status;
 497 }
 498
 499 /******************************************************************
 500  *              NtQueryMutant                   [NTDLL.@]
 501  *              ZwQueryMutant                   [NTDLL.@]
 502  */
 503 NTSTATUS WINAPI NtQueryMutant(IN HANDLE handle,
 504                               IN MUTANT_INFORMATION_CLASS MutantInformationClass,
 505                               OUT PVOID MutantInformation,
 506                               IN ULONG MutantInformationLength,
 507                               OUT PULONG ResultLength OPTIONAL )
 508 {
 509     FIXME("(%p %u %p %u %p): stub!\n",
 510           handle, MutantInformationClass, MutantInformation, MutantInformationLength, ResultLength);
 511     return STATUS_NOT_IMPLEMENTED;
 512 }
 513
 514 /*
 515  *      Jobs
 516  */
 517
 518 /******************************************************************************
 519  *              NtCreateJobObject   [NTDLL.@]
 520  *              ZwCreateJobObject   [NTDLL.@]
 521  */
 522 NTSTATUS WINAPI NtCreateJobObject( PHANDLE handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 523 {
 524     FIXME( "stub: %p %x %s\n", handle, access, attr ? debugstr_us(attr->ObjectName) : "" );
 525     *handle = (HANDLE)0xdead;
 526     return STATUS_SUCCESS;
 527 }
 528
 529 /******************************************************************************
 530  *              NtOpenJobObject   [NTDLL.@]
 531  *              ZwOpenJobObject   [NTDLL.@]
 532  */
 533 NTSTATUS WINAPI NtOpenJobObject( PHANDLE handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 534 {
 535     FIXME( "stub: %p %x %s\n", handle, access, attr ? debugstr_us(attr->ObjectName) : "" );
 536     return STATUS_NOT_IMPLEMENTED;
 537 }
 538
 539 /******************************************************************************
 540  *              NtTerminateJobObject   [NTDLL.@]
 541  *              ZwTerminateJobObject   [NTDLL.@]
 542  */
 543 NTSTATUS WINAPI NtTerminateJobObject( HANDLE handle, NTSTATUS status )
 544 {
 545     FIXME( "stub: %p %x\n", handle, status );
 546     return STATUS_SUCCESS;
 547 }
 548
 549 /******************************************************************************
 550  *              NtQueryInformationJobObject   [NTDLL.@]
 551  *              ZwQueryInformationJobObject   [NTDLL.@]
 552  */
 553 NTSTATUS WINAPI NtQueryInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, PVOID info,
 554                                              ULONG len, PULONG ret_len )
 555 {
 556     FIXME( "stub: %p %u %p %u %p\n", handle, class, info, len, ret_len );
 557     return STATUS_NOT_IMPLEMENTED;
 558 }
 559
 560 /******************************************************************************
 561  *              NtSetInformationJobObject   [NTDLL.@]
 562  *              ZwSetInformationJobObject   [NTDLL.@]
 563  */
 564 NTSTATUS WINAPI NtSetInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, PVOID info, ULONG len )
 565 {
 566     FIXME( "stub: %p %u %p %u\n", handle, class, info, len );
 567     return STATUS_SUCCESS;
 568 }
 569
 570 /******************************************************************************
 571  *              NtIsProcessInJob   [NTDLL.@]
 572  *              ZwIsProcessInJob   [NTDLL.@]
 573  */
 574 NTSTATUS WINAPI NtIsProcessInJob( HANDLE process, HANDLE job )
 575 {
 576     FIXME( "stub: %p %p\n", process, job );
 577     return STATUS_PROCESS_NOT_IN_JOB;
 578 }
 579
 580 /******************************************************************************
 581  *              NtAssignProcessToJobObject   [NTDLL.@]
 582  *              ZwAssignProcessToJobObject   [NTDLL.@]
 583  */
 584 NTSTATUS WINAPI NtAssignProcessToJobObject( HANDLE job, HANDLE process )
 585 {
 586     FIXME( "stub: %p %p\n", job, process );
 587     return STATUS_SUCCESS;
 588 }
 589
 590 /*
 591  *      Timers
 592  */
 593
 594 /**************************************************************************
 595  *              NtCreateTimer                           [NTDLL.@]
 596  *              ZwCreateTimer                           [NTDLL.@]
 597  */
 598 NTSTATUS WINAPI NtCreateTimer(OUT HANDLE *handle,
 599                               IN ACCESS_MASK access,
 600                               IN const OBJECT_ATTRIBUTES *attr OPTIONAL,
 601                               IN TIMER_TYPE timer_type)
 602 {
 603     DWORD       len = (attr && attr->ObjectName) ? attr->ObjectName->Length : 0;
 604     NTSTATUS    status;
 605
 606     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 607
 608     if (timer_type != NotificationTimer && timer_type != SynchronizationTimer)
 609         return STATUS_INVALID_PARAMETER;
 610
 611     SERVER_START_REQ( create_timer )
 612     {
 613         req->access  = access;
 614         req->attributes = (attr) ? attr->Attributes : 0;
 615         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 616         req->manual  = (timer_type == NotificationTimer) ? TRUE : FALSE;
 617         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 618         status = wine_server_call( req );
 619         *handle = wine_server_ptr_handle( reply->handle );
 620     }
 621     SERVER_END_REQ;
 622     return status;
 623
 624 }
 625
 626 /**************************************************************************
 627  *              NtOpenTimer                             [NTDLL.@]
 628  *              ZwOpenTimer                             [NTDLL.@]
 629  */
 630 NTSTATUS WINAPI NtOpenTimer(OUT PHANDLE handle,
 631                             IN ACCESS_MASK access,
 632                             IN const OBJECT_ATTRIBUTES* attr )
 633 {
 634     DWORD       len = (attr && attr->ObjectName) ? attr->ObjectName->Length : 0;
 635     NTSTATUS    status;
 636
 637     if (len >= MAX_PATH * sizeof(WCHAR)) return STATUS_NAME_TOO_LONG;
 638
 639     SERVER_START_REQ( open_timer )
 640     {
 641         req->access  = access;
 642         req->attributes = (attr) ? attr->Attributes : 0;
 643         req->rootdir = wine_server_obj_handle( attr ? attr->RootDirectory : 0 );
 644         if (len) wine_server_add_data( req, attr->ObjectName->Buffer, len );
 645         status = wine_server_call( req );
 646         *handle = wine_server_ptr_handle( reply->handle );
 647     }
 648     SERVER_END_REQ;
 649     return status;
 650 }
 651
 652 /**************************************************************************
 653  *              NtSetTimer                              [NTDLL.@]
 654  *              ZwSetTimer                              [NTDLL.@]
 655  */
 656 NTSTATUS WINAPI NtSetTimer(IN HANDLE handle,
 657                            IN const LARGE_INTEGER* when,
 658                            IN PTIMER_APC_ROUTINE callback,
 659                            IN PVOID callback_arg,
 660                            IN BOOLEAN resume,
 661                            IN ULONG period OPTIONAL,
 662                            OUT PBOOLEAN state OPTIONAL)
 663 {
 664     NTSTATUS    status = STATUS_SUCCESS;
 665
 666     TRACE("(%p,%p,%p,%p,%08x,0x%08x,%p) stub\n",
 667           handle, when, callback, callback_arg, resume, period, state);
 668
 669     SERVER_START_REQ( set_timer )
 670     {
 671         req->handle   = wine_server_obj_handle( handle );
 672         req->period   = period;
 673         req->expire   = when->QuadPart;
 674         req->callback = callback;
 675         req->arg      = callback_arg;
 676         status = wine_server_call( req );
 677         if (state) *state = reply->signaled;
 678     }
 679     SERVER_END_REQ;
 680
 681     /* set error but can still succeed */
 682     if (resume && status == STATUS_SUCCESS) return STATUS_TIMER_RESUME_IGNORED;
 683     return status;
 684 }
 685
 686 /**************************************************************************
 687  *              NtCancelTimer                           [NTDLL.@]
 688  *              ZwCancelTimer                           [NTDLL.@]
 689  */
 690 NTSTATUS WINAPI NtCancelTimer(IN HANDLE handle, OUT BOOLEAN* state)
 691 {
 692     NTSTATUS    status;
 693
 694     SERVER_START_REQ( cancel_timer )
 695     {
 696         req->handle = wine_server_obj_handle( handle );
 697         status = wine_server_call( req );
 698         if (state) *state = reply->signaled;
 699     }
 700     SERVER_END_REQ;
 701     return status;
 702 }
 703
 704 /******************************************************************************
 705  *  NtQueryTimer (NTDLL.@)
 706  *
 707  * Retrieves information about a timer.
 708  *
 709  * PARAMS
 710  *  TimerHandle           [I] The timer to retrieve information about.
 711  *  TimerInformationClass [I] The type of information to retrieve.
 712  *  TimerInformation      [O] Pointer to buffer to store information in.
 713  *  Length                [I] The length of the buffer pointed to by TimerInformation.
 714  *  ReturnLength          [O] Optional. The size of buffer actually used.
 715  *
 716  * RETURNS
 717  *  Success: STATUS_SUCCESS
 718  *  Failure: STATUS_INFO_LENGTH_MISMATCH, if Length doesn't match the required data
 719  *           size for the class specified.
 720  *           STATUS_INVALID_INFO_CLASS, if an invalid TimerInformationClass was specified.
 721  *           STATUS_ACCESS_DENIED, if TimerHandle does not have TIMER_QUERY_STATE access
 722  *           to the timer.
 723  */
 724 NTSTATUS WINAPI NtQueryTimer(
 725     HANDLE TimerHandle,
 726     TIMER_INFORMATION_CLASS TimerInformationClass,
 727     PVOID TimerInformation,
 728     ULONG Length,
 729     PULONG ReturnLength)
 730 {
 731     TIMER_BASIC_INFORMATION * basic_info = (TIMER_BASIC_INFORMATION *)TimerInformation;
 732     NTSTATUS status;
 733     LARGE_INTEGER now;
 734
 735     TRACE("(%p,%d,%p,0x%08x,%p)\n", TimerHandle, TimerInformationClass,
 736        TimerInformation, Length, ReturnLength);
 737
 738     switch (TimerInformationClass)
 739     {
 740     case TimerBasicInformation:
 741         if (Length < sizeof(TIMER_BASIC_INFORMATION))
 742             return STATUS_INFO_LENGTH_MISMATCH;
 743
 744         SERVER_START_REQ(get_timer_info)
 745         {
 746             req->handle = wine_server_obj_handle( TimerHandle );
 747             status = wine_server_call(req);
 748
 749             /* convert server time to absolute NTDLL time */
 750             basic_info->RemainingTime.QuadPart = reply->when;
 751             basic_info->TimerState = reply->signaled;
 752         }
 753         SERVER_END_REQ;
 754
 755         /* convert from absolute into relative time */
 756         NtQuerySystemTime(&now);
 757         if (now.QuadPart > basic_info->RemainingTime.QuadPart)
 758             basic_info->RemainingTime.QuadPart = 0;
 759         else
 760             basic_info->RemainingTime.QuadPart -= now.QuadPart;
 761
 762         if (ReturnLength) *ReturnLength = sizeof(TIMER_BASIC_INFORMATION);
 763
 764         return status;
 765     }
 766
 767     FIXME("Unhandled class %d\n", TimerInformationClass);
 768     return STATUS_INVALID_INFO_CLASS;
 769 }
 770
 771
 772 /******************************************************************************
 773  * NtQueryTimerResolution [NTDLL.@]
 774  */
 775 NTSTATUS WINAPI NtQueryTimerResolution(OUT ULONG* min_resolution,
 776                                        OUT ULONG* max_resolution,
 777                                        OUT ULONG* current_resolution)
 778 {
 779     FIXME("(%p,%p,%p), stub!\n",
 780           min_resolution, max_resolution, current_resolution);
 781
 782     return STATUS_NOT_IMPLEMENTED;
 783 }
 784
 785 /******************************************************************************
 786  * NtSetTimerResolution [NTDLL.@]
 787  */
 788 NTSTATUS WINAPI NtSetTimerResolution(IN ULONG resolution,
 789                                      IN BOOLEAN set_resolution,
 790                                      OUT ULONG* current_resolution )
 791 {
 792     FIXME("(%u,%u,%p), stub!\n",
 793           resolution, set_resolution, current_resolution);
 794
 795     return STATUS_NOT_IMPLEMENTED;
 796 }
 797
 798
 799 /***********************************************************************
 800  *              wait_reply
 801  *
 802  * Wait for a reply on the waiting pipe of the current thread.
 803  */
 804 static int wait_reply( void *cookie )
 805 {
 806     int signaled;
 807     struct wake_up_reply reply;
 808     for (;;)
 809     {
 810         int ret;
 811         ret = read( ntdll_get_thread_data()->wait_fd[0], &reply, sizeof(reply) );
 812         if (ret == sizeof(reply))
 813         {
 814             if (!reply.cookie) break;  /* thread got killed */
 815             if (reply.cookie == cookie) return reply.signaled;
 816             /* we stole another reply, wait for the real one */
 817             signaled = wait_reply( cookie );
 818             /* and now put the wrong one back in the pipe */
 819             for (;;)
 820             {
 821                 ret = write( ntdll_get_thread_data()->wait_fd[1], &reply, sizeof(reply) );
 822                 if (ret == sizeof(reply)) break;
 823                 if (ret >= 0) server_protocol_error( "partial wakeup write %d\n", ret );
 824                 if (errno == EINTR) continue;
 825                 server_protocol_perror("wakeup write");
 826             }
 827             return signaled;
 828         }
 829         if (ret >= 0) server_protocol_error( "partial wakeup read %d\n", ret );
 830         if (errno == EINTR) continue;
 831         server_protocol_perror("wakeup read");
 832     }
 833     /* the server closed the connection; time to die... */
 834     server_abort_thread(0);
 835 }
 836
 837
 838 /***********************************************************************
 839  *              invoke_apc
 840  *
 841  * Invoke a single APC. Return TRUE if a user APC has been run.
 842  */
 843 static BOOL invoke_apc( const apc_call_t *call, apc_result_t *result )
 844 {
 845     BOOL user_apc = FALSE;
 846     SIZE_T size;
 847
 848     memset( result, 0, sizeof(*result) );
 849
 850     switch (call->type)
 851     {
 852     case APC_NONE:
 853         break;
 854     case APC_USER:
 855         call->user.func( call->user.args[0], call->user.args[1], call->user.args[2] );
 856         user_apc = TRUE;
 857         break;
 858     case APC_TIMER:
 859         call->timer.func( call->timer.arg, (DWORD)call->timer.time, (DWORD)(call->timer.time >> 32) );
 860         user_apc = TRUE;
 861         break;
 862     case APC_ASYNC_IO:
 863         result->type = call->type;
 864         result->async_io.status = call->async_io.func( call->async_io.user,
 865                                                        call->async_io.sb,
 866                                                        call->async_io.status,
 867                                                        &result->async_io.total );
 868         break;
 869     case APC_VIRTUAL_ALLOC:
 870         result->type = call->type;
 871         result->virtual_alloc.addr = call->virtual_alloc.addr;
 872         size = call->virtual_alloc.size;
 873         if (size == call->virtual_alloc.size)  /* not truncated */
 874         {
 875             result->virtual_alloc.status = NtAllocateVirtualMemory( NtCurrentProcess(),
 876                                                                     &result->virtual_alloc.addr,
 877                                                                     call->virtual_alloc.zero_bits,
 878                                                                     &size,
 879                                                                     call->virtual_alloc.op_type,
 880                                                                     call->virtual_alloc.prot );
 881             result->virtual_alloc.size = size;
 882         }
 883         else result->virtual_alloc.status = STATUS_WORKING_SET_LIMIT_RANGE;
 884         break;
 885     case APC_VIRTUAL_FREE:
 886         result->type = call->type;
 887         result->virtual_free.addr = call->virtual_free.addr;
 888         size = call->virtual_free.size;
 889         if (size == call->virtual_free.size)  /* not truncated */
 890         {
 891             result->virtual_free.status = NtFreeVirtualMemory( NtCurrentProcess(),
 892                                                                &result->virtual_free.addr, &size,
 893                                                                call->virtual_free.op_type );
 894             result->virtual_free.size = size;
 895         }
 896         else result->virtual_free.status = STATUS_INVALID_PARAMETER;
 897         break;
 898     case APC_VIRTUAL_QUERY:
 899     {
 900         MEMORY_BASIC_INFORMATION info;
 901         result->type = call->type;
 902         result->virtual_query.status = NtQueryVirtualMemory( NtCurrentProcess(),
 903                                                              call->virtual_query.addr,
 904                                                              MemoryBasicInformation, &info,
 905                                                              sizeof(info), NULL );
 906         if (result->virtual_query.status == STATUS_SUCCESS)
 907         {
 908             result->virtual_query.base       = info.BaseAddress;
 909             result->virtual_query.alloc_base = info.AllocationBase;
 910             result->virtual_query.size       = info.RegionSize;
 911             result->virtual_query.state      = info.State;
 912             result->virtual_query.prot       = info.Protect;
 913             result->virtual_query.alloc_prot = info.AllocationProtect;
 914             result->virtual_query.alloc_type = info.Type;
 915         }
 916         break;
 917     }
 918     case APC_VIRTUAL_PROTECT:
 919         result->type = call->type;
 920         result->virtual_protect.addr = call->virtual_protect.addr;
 921         size = call->virtual_protect.size;
 922         if (size == call->virtual_protect.size)  /* not truncated */
 923         {
 924             result->virtual_protect.status = NtProtectVirtualMemory( NtCurrentProcess(),
 925                                                                      &result->virtual_protect.addr,
 926                                                                      &size,
 927                                                                      call->virtual_protect.prot,
 928                                                                      &result->virtual_protect.prot );
 929             result->virtual_protect.size = size;
 930         }
 931         else result->virtual_protect.status = STATUS_INVALID_PARAMETER;
 932         break;
 933     case APC_VIRTUAL_FLUSH:
 934         result->type = call->type;
 935         result->virtual_flush.addr = call->virtual_flush.addr;
 936         size = call->virtual_flush.size;
 937         if (size == call->virtual_flush.size)  /* not truncated */
 938         {
 939             result->virtual_flush.status = NtFlushVirtualMemory( NtCurrentProcess(),
 940                                                                  &result->virtual_flush.addr, &size, 0 );
 941             result->virtual_flush.size = size;
 942         }
 943         else result->virtual_flush.status = STATUS_INVALID_PARAMETER;
 944         break;
 945     case APC_VIRTUAL_LOCK:
 946         result->type = call->type;
 947         result->virtual_lock.addr = call->virtual_lock.addr;
 948         size = call->virtual_lock.size;
 949         if (size == call->virtual_lock.size)  /* not truncated */
 950         {
 951             result->virtual_lock.status = NtLockVirtualMemory( NtCurrentProcess(),
 952                                                                &result->virtual_lock.addr, &size, 0 );
 953             result->virtual_lock.size = size;
 954         }
 955         else result->virtual_lock.status = STATUS_INVALID_PARAMETER;
 956         break;
 957     case APC_VIRTUAL_UNLOCK:
 958         result->type = call->type;
 959         result->virtual_unlock.addr = call->virtual_unlock.addr;
 960         size = call->virtual_unlock.size;
 961         if (size == call->virtual_unlock.size)  /* not truncated */
 962         {
 963             result->virtual_unlock.status = NtUnlockVirtualMemory( NtCurrentProcess(),
 964                                                                    &result->virtual_unlock.addr, &size, 0 );
 965             result->virtual_unlock.size = size;
 966         }
 967         else result->virtual_unlock.status = STATUS_INVALID_PARAMETER;
 968         break;
 969     case APC_MAP_VIEW:
 970     {
 971         LARGE_INTEGER offset;
 972         result->type = call->type;
 973         result->map_view.addr   = call->map_view.addr;
 974         offset.QuadPart         = call->map_view.offset;
 975         size = call->map_view.size;
 976         if (size == call->map_view.size)  /* not truncated */
 977         {
 978             result->map_view.status = NtMapViewOfSection( wine_server_ptr_handle(call->map_view.handle),
 979                                                           NtCurrentProcess(), &result->map_view.addr,
 980                                                           call->map_view.zero_bits, 0,
 981                                                           &offset, &size, ViewShare,
 982                                                           call->map_view.alloc_type, call->map_view.prot );
 983             result->map_view.size   = size;
 984         }
 985         else result->map_view.status = STATUS_INVALID_PARAMETER;
 986         NtClose( wine_server_ptr_handle(call->map_view.handle) );
 987         break;
 988     }
 989     case APC_UNMAP_VIEW:
 990         result->type = call->type;
 991         result->unmap_view.status = NtUnmapViewOfSection( NtCurrentProcess(), call->unmap_view.addr );
 992         break;
 993     case APC_CREATE_THREAD:
 994     {
 995         CLIENT_ID id;
 996         HANDLE handle;
 997         SIZE_T reserve = call->create_thread.reserve;
 998         SIZE_T commit = call->create_thread.commit;
 999
1000         result->type = call->type;
1001         if (reserve == call->create_thread.reserve && commit == call->create_thread.commit)
1002         {
1003             result->create_thread.status = RtlCreateUserThread( NtCurrentProcess(), NULL,
1004                                                                 call->create_thread.suspend, NULL,
1005                                                                 reserve, commit,
1006                                                                 call->create_thread.func,
1007                                                                 call->create_thread.arg,
1008                                                                 &handle, &id );
1009             result->create_thread.handle = wine_server_obj_handle( handle );
1010             result->create_thread.tid = HandleToULong(id.UniqueThread);
1011         }
1012         else result->create_thread.status = STATUS_INVALID_PARAMETER;
1013         break;
1014     }
1015     default:
1016         server_protocol_error( "get_apc_request: bad type %d\n", call->type );
1017         break;
1018     }
1019     return user_apc;
1020 }
1021
1022 /***********************************************************************
1023  *           NTDLL_queue_process_apc
1024  */
1025 NTSTATUS NTDLL_queue_process_apc( HANDLE process, const apc_call_t *call, apc_result_t *result )
1026 {
1027     for (;;)
1028     {
1029         NTSTATUS ret;
1030         HANDLE handle = 0;
1031         BOOL self = FALSE;
1032
1033         SERVER_START_REQ( queue_apc )
1034         {
1035             req->process = wine_server_obj_handle( process );
1036             req->call = *call;
1037             if (!(ret = wine_server_call( req )))
1038             {
1039                 handle = wine_server_ptr_handle( reply->handle );
1040                 self = reply->self;
1041             }
1042         }
1043         SERVER_END_REQ;
1044         if (ret != STATUS_SUCCESS) return ret;
1045
1046         if (self)
1047         {
1048             invoke_apc( call, result );
1049         }
1050         else
1051         {
1052             NtWaitForSingleObject( handle, FALSE, NULL );
1053
1054             SERVER_START_REQ( get_apc_result )
1055             {
1056                 req->handle = wine_server_obj_handle( handle );
1057                 if (!(ret = wine_server_call( req ))) *result = reply->result;
1058             }
1059             SERVER_END_REQ;
1060
1061             if (!ret && result->type == APC_NONE) continue;  /* APC didn't run, try again */
1062             if (ret) NtClose( handle );
1063         }
1064         return ret;
1065     }
1066 }
1067
1068
1069 /***********************************************************************
1070  *              NTDLL_wait_for_multiple_objects
1071  *
1072  * Implementation of NtWaitForMultipleObjects
1073  */
1074 NTSTATUS NTDLL_wait_for_multiple_objects( UINT count, const HANDLE *handles, UINT flags,
1075                                           const LARGE_INTEGER *timeout, HANDLE signal_object )
1076 {
1077     NTSTATUS ret;
1078     int i, cookie;
1079     BOOL user_apc = FALSE;
1080     obj_handle_t obj_handles[MAXIMUM_WAIT_OBJECTS];
1081     obj_handle_t apc_handle = 0;
1082     apc_call_t call;
1083     apc_result_t result;
1084     timeout_t abs_timeout = timeout ? timeout->QuadPart : TIMEOUT_INFINITE;
1085
1086     memset( &result, 0, sizeof(result) );
1087     for (i = 0; i < count; i++) obj_handles[i] = wine_server_obj_handle( handles[i] );
1088
1089     for (;;)
1090     {
1091         SERVER_START_REQ( select )
1092         {
1093             req->flags    = flags;
1094             req->cookie   = &cookie;
1095             req->signal   = wine_server_obj_handle( signal_object );
1096             req->prev_apc = apc_handle;
1097             req->timeout  = abs_timeout;
1098             wine_server_add_data( req, &result, sizeof(result) );
1099             wine_server_add_data( req, obj_handles, count * sizeof(*obj_handles) );
1100             ret = wine_server_call( req );
1101             abs_timeout = reply->timeout;
1102             apc_handle  = reply->apc_handle;
1103             call        = reply->call;
1104         }
1105         SERVER_END_REQ;
1106         if (ret == STATUS_PENDING) ret = wait_reply( &cookie );
1107         if (ret != STATUS_USER_APC) break;
1108         if (invoke_apc( &call, &result ))
1109         {
1110             /* if we ran a user apc we have to check once more if an object got signaled,
1111              * but we don't want to wait */
1112             abs_timeout = 0;
1113             user_apc = TRUE;
1114         }
1115         signal_object = 0;  /* don't signal it multiple times */
1116     }
1117
1118     if (ret == STATUS_TIMEOUT && user_apc) ret = STATUS_USER_APC;
1119
1120     /* A test on Windows 2000 shows that Windows always yields during
1121        a wait, but a wait that is hit by an event gets a priority
1122        boost as well.  This seems to model that behavior the closest.  */
1123     if (ret == STATUS_TIMEOUT) NtYieldExecution();
1124
1125     return ret;
1126 }
1127
1128
1129 /* wait operations */
1130
1131 /******************************************************************
1132  *              NtWaitForMultipleObjects (NTDLL.@)
1133  */
1134 NTSTATUS WINAPI NtWaitForMultipleObjects( DWORD count, const HANDLE *handles,
1135                                           BOOLEAN wait_all, BOOLEAN alertable,
1136                                           const LARGE_INTEGER *timeout )
1137 {
1138     UINT flags = SELECT_INTERRUPTIBLE;
1139
1140     if (!count || count > MAXIMUM_WAIT_OBJECTS) return STATUS_INVALID_PARAMETER_1;
1141
1142     if (wait_all) flags |= SELECT_ALL;
1143     if (alertable) flags |= SELECT_ALERTABLE;
1144     return NTDLL_wait_for_multiple_objects( count, handles, flags, timeout, 0 );
1145 }
1146
1147
1148 /******************************************************************
1149  *              NtWaitForSingleObject (NTDLL.@)
1150  */
1151 NTSTATUS WINAPI NtWaitForSingleObject(HANDLE handle, BOOLEAN alertable, const LARGE_INTEGER *timeout )
1152 {
1153     return NtWaitForMultipleObjects( 1, &handle, FALSE, alertable, timeout );
1154 }
1155
1156
1157 /******************************************************************
1158  *              NtSignalAndWaitForSingleObject (NTDLL.@)
1159  */
1160 NTSTATUS WINAPI NtSignalAndWaitForSingleObject( HANDLE hSignalObject, HANDLE hWaitObject,
1161                                                 BOOLEAN alertable, const LARGE_INTEGER *timeout )
1162 {
1163     UINT flags = SELECT_INTERRUPTIBLE;
1164
1165     if (!hSignalObject) return STATUS_INVALID_HANDLE;
1166     if (alertable) flags |= SELECT_ALERTABLE;
1167     return NTDLL_wait_for_multiple_objects( 1, &hWaitObject, flags, timeout, hSignalObject );
1168 }
1169
1170
1171 /******************************************************************
1172  *              NtYieldExecution (NTDLL.@)
1173  */
1174 NTSTATUS WINAPI NtYieldExecution(void)
1175 {
1176 #ifdef HAVE_SCHED_YIELD
1177     sched_yield();
1178     return STATUS_SUCCESS;
1179 #else
1180     return STATUS_NO_YIELD_PERFORMED;
1181 #endif
1182 }
1183
1184
1185 /******************************************************************
1186  *              NtDelayExecution (NTDLL.@)
1187  */
1188 NTSTATUS WINAPI NtDelayExecution( BOOLEAN alertable, const LARGE_INTEGER *timeout )
1189 {
1190     /* if alertable, we need to query the server */
1191     if (alertable)
1192         return NTDLL_wait_for_multiple_objects( 0, NULL, SELECT_INTERRUPTIBLE | SELECT_ALERTABLE,
1193                                                 timeout, 0 );
1194
1195     if (!timeout || timeout->QuadPart == TIMEOUT_INFINITE)  /* sleep forever */
1196     {
1197         for (;;) select( 0, NULL, NULL, NULL, NULL );
1198     }
1199     else
1200     {
1201         LARGE_INTEGER now;
1202         timeout_t when, diff;
1203
1204         if ((when = timeout->QuadPart) < 0)
1205         {
1206             NtQuerySystemTime( &now );
1207             when = now.QuadPart - when;
1208         }
1209
1210         /* Note that we yield after establishing the desired timeout */
1211         NtYieldExecution();
1212         if (!when) return STATUS_SUCCESS;
1213
1214         for (;;)
1215         {
1216             struct timeval tv;
1217             NtQuerySystemTime( &now );
1218             diff = (when - now.QuadPart + 9) / 10;
1219             if (diff <= 0) break;
1220             tv.tv_sec  = diff / 1000000;
1221             tv.tv_usec = diff % 1000000;
1222             if (select( 0, NULL, NULL, NULL, &tv ) != -1) break;
1223         }
1224     }
1225     return STATUS_SUCCESS;
1226 }
1227
1228 /******************************************************************
1229  *              NtCreateIoCompletion (NTDLL.@)
1230  *              ZwCreateIoCompletion (NTDLL.@)
1231  *
1232  * Creates I/O completion object.
1233  *
1234  * PARAMS
1235  *      CompletionPort            [O] created completion object handle will be placed there
1236  *      DesiredAccess             [I] desired access to a handle (combination of IO_COMPLETION_*)
1237  *      ObjectAttributes          [I] completion object attributes
1238  *      NumberOfConcurrentThreads [I] desired number of concurrent active worker threads
1239  *
1240  */
1241 NTSTATUS WINAPI NtCreateIoCompletion( PHANDLE CompletionPort, ACCESS_MASK DesiredAccess,
1242                                       POBJECT_ATTRIBUTES ObjectAttributes, ULONG NumberOfConcurrentThreads )
1243 {
1244     NTSTATUS status;
1245
1246     TRACE("(%p, %x, %p, %d)\n", CompletionPort, DesiredAccess,
1247           ObjectAttributes, NumberOfConcurrentThreads);
1248
1249     if (!CompletionPort)
1250         return STATUS_INVALID_PARAMETER;
1251
1252     SERVER_START_REQ( create_completion )
1253     {
1254         req->access     = DesiredAccess;
1255         req->attributes = ObjectAttributes ? ObjectAttributes->Attributes : 0;
1256         req->rootdir    = wine_server_obj_handle( ObjectAttributes ? ObjectAttributes->RootDirectory : 0 );
1257         req->concurrent = NumberOfConcurrentThreads;
1258         if (ObjectAttributes && ObjectAttributes->ObjectName)
1259             wine_server_add_data( req, ObjectAttributes->ObjectName->Buffer,
1260                                        ObjectAttributes->ObjectName->Length );
1261         if (!(status = wine_server_call( req )))
1262             *CompletionPort = wine_server_ptr_handle( reply->handle );
1263     }
1264     SERVER_END_REQ;
1265     return status;
1266 }
1267
1268 /******************************************************************
1269  *              NtSetIoCompletion (NTDLL.@)
1270  *              ZwSetIoCompletion (NTDLL.@)
1271  *
1272  * Inserts completion message into queue
1273  *
1274  * PARAMS
1275  *      CompletionPort           [I] HANDLE to completion object
1276  *      CompletionKey            [I] completion key
1277  *      CompletionValue          [I] completion value (usually pointer to OVERLAPPED)
1278  *      Status                   [I] operation status
1279  *      NumberOfBytesTransferred [I] number of bytes transferred
1280  */
1281 NTSTATUS WINAPI NtSetIoCompletion( HANDLE CompletionPort, ULONG_PTR CompletionKey,
1282                                    ULONG_PTR CompletionValue, NTSTATUS Status,
1283                                    ULONG NumberOfBytesTransferred )
1284 {
1285     NTSTATUS status;
1286
1287     TRACE("(%p, %lx, %lx, %x, %d)\n", CompletionPort, CompletionKey,
1288           CompletionValue, Status, NumberOfBytesTransferred);
1289
1290     SERVER_START_REQ( add_completion )
1291     {
1292         req->handle      = wine_server_obj_handle( CompletionPort );
1293         req->ckey        = CompletionKey;
1294         req->cvalue      = CompletionValue;
1295         req->status      = Status;
1296         req->information = NumberOfBytesTransferred;
1297         status = wine_server_call( req );
1298     }
1299     SERVER_END_REQ;
1300     return status;
1301 }
1302
1303 /******************************************************************
1304  *              NtRemoveIoCompletion (NTDLL.@)
1305  *              ZwRemoveIoCompletion (NTDLL.@)
1306  *
1307  * (Wait for and) retrieve first completion message from completion object's queue
1308  *
1309  * PARAMS
1310  *      CompletionPort  [I] HANDLE to I/O completion object
1311  *      CompletionKey   [O] completion key
1312  *      CompletionValue [O] Completion value given in NtSetIoCompletion or in async operation
1313  *      iosb            [O] IO_STATUS_BLOCK of completed asynchronous operation
1314  *      WaitTime        [I] optional wait time in NTDLL format
1315  *
1316  */
1317 NTSTATUS WINAPI NtRemoveIoCompletion( HANDLE CompletionPort, PULONG_PTR CompletionKey,
1318                                       PULONG_PTR CompletionValue, PIO_STATUS_BLOCK iosb,
1319                                       PLARGE_INTEGER WaitTime )
1320 {
1321     NTSTATUS status;
1322
1323     TRACE("(%p, %p, %p, %p, %p)\n", CompletionPort, CompletionKey,
1324           CompletionValue, iosb, WaitTime);
1325
1326     for(;;)
1327     {
1328         SERVER_START_REQ( remove_completion )
1329         {
1330             req->handle = wine_server_obj_handle( CompletionPort );
1331             if (!(status = wine_server_call( req )))
1332             {
1333                 *CompletionKey    = reply->ckey;
1334                 *CompletionValue  = reply->cvalue;
1335                 iosb->Information = reply->information;
1336                 iosb->u.Status    = reply->status;
1337             }
1338         }
1339         SERVER_END_REQ;
1340         if (status != STATUS_PENDING) break;
1341
1342         status = NtWaitForSingleObject( CompletionPort, FALSE, WaitTime );
1343         if (status != WAIT_OBJECT_0) break;
1344     }
1345     return status;
1346 }
1347
1348 /******************************************************************
1349  *              NtOpenIoCompletion (NTDLL.@)
1350  *              ZwOpenIoCompletion (NTDLL.@)
1351  *
1352  * Opens I/O completion object
1353  *
1354  * PARAMS
1355  *      CompletionPort     [O] completion object handle will be placed there
1356  *      DesiredAccess      [I] desired access to a handle (combination of IO_COMPLETION_*)
1357  *      ObjectAttributes   [I] completion object name
1358  *
1359  */
1360 NTSTATUS WINAPI NtOpenIoCompletion( PHANDLE CompletionPort, ACCESS_MASK DesiredAccess,
1361                                     POBJECT_ATTRIBUTES ObjectAttributes )
1362 {
1363     NTSTATUS status;
1364
1365     TRACE("(%p, 0x%x, %p)\n", CompletionPort, DesiredAccess, ObjectAttributes);
1366
1367     if (!CompletionPort || !ObjectAttributes || !ObjectAttributes->ObjectName)
1368         return STATUS_INVALID_PARAMETER;
1369
1370     SERVER_START_REQ( open_completion )
1371     {
1372         req->access     = DesiredAccess;
1373         req->rootdir    = wine_server_obj_handle( ObjectAttributes->RootDirectory );
1374         wine_server_add_data( req, ObjectAttributes->ObjectName->Buffer,
1375                                    ObjectAttributes->ObjectName->Length );
1376         if (!(status = wine_server_call( req )))
1377             *CompletionPort = wine_server_ptr_handle( reply->handle );
1378     }
1379     SERVER_END_REQ;
1380     return status;
1381 }
1382
1383 /******************************************************************
1384  *              NtQueryIoCompletion (NTDLL.@)
1385  *              ZwQueryIoCompletion (NTDLL.@)
1386  *
1387  * Requests information about given I/O completion object
1388  *
1389  * PARAMS
1390  *      CompletionPort        [I] HANDLE to completion port to request
1391  *      InformationClass      [I] information class
1392  *      CompletionInformation [O] user-provided buffer for data
1393  *      BufferLength          [I] buffer length
1394  *      RequiredLength        [O] required buffer length
1395  *
1396  */
1397 NTSTATUS WINAPI NtQueryIoCompletion( HANDLE CompletionPort, IO_COMPLETION_INFORMATION_CLASS InformationClass,
1398                                      PVOID CompletionInformation, ULONG BufferLength, PULONG RequiredLength )
1399 {
1400     NTSTATUS status;
1401
1402     TRACE("(%p, %d, %p, 0x%x, %p)\n", CompletionPort, InformationClass, CompletionInformation,
1403           BufferLength, RequiredLength);
1404
1405     if (!CompletionInformation) return STATUS_INVALID_PARAMETER;
1406     switch( InformationClass )
1407     {
1408         case IoCompletionBasicInformation:
1409             {
1410                 ULONG *info = (ULONG *)CompletionInformation;
1411
1412                 if (RequiredLength) *RequiredLength = sizeof(*info);
1413                 if (BufferLength != sizeof(*info))
1414                     status = STATUS_INFO_LENGTH_MISMATCH;
1415                 else
1416                 {
1417                     SERVER_START_REQ( query_completion )
1418                     {
1419                         req->handle = wine_server_obj_handle( CompletionPort );
1420                         if (!(status = wine_server_call( req )))
1421                             *info = reply->depth;
1422                     }
1423                     SERVER_END_REQ;
1424                 }
1425             }
1426             break;
1427         default:
1428             status = STATUS_INVALID_PARAMETER;
1429             break;
1430     }
1431     return status;
1432 }
1433
1434 NTSTATUS NTDLL_AddCompletion( HANDLE hFile, ULONG_PTR CompletionValue,
1435                               NTSTATUS CompletionStatus, ULONG Information )
1436 {
1437     NTSTATUS status;
1438
1439     SERVER_START_REQ( add_fd_completion )
1440     {
1441         req->handle      = wine_server_obj_handle( hFile );
1442         req->cvalue      = CompletionValue;
1443         req->status      = CompletionStatus;
1444         req->information = Information;
1445         status = wine_server_call( req );
1446     }
1447     SERVER_END_REQ;
1448     return status;
1449 }