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