dlls/wow64/sync.c

   1 /*
   2  * WoW64 synchronization objects and functions
   3  *
   4  * Copyright 2021 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #include "ntstatus.h"
  24 #define WIN32_NO_STATUS
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winnt.h"
  28 #include "winternl.h"
  29 #include "wow64_private.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(wow);
  33
  34
  35 static void put_object_type_info( OBJECT_TYPE_INFORMATION32 *info32, const OBJECT_TYPE_INFORMATION *info )
  36 {
  37     if (info->TypeName.Length)
  38     {
  39         memcpy( info32 + 1, info->TypeName.Buffer, info->TypeName.Length + sizeof(WCHAR) );
  40         info32->TypeName.Length        = info->TypeName.Length;
  41         info32->TypeName.MaximumLength = info->TypeName.Length + sizeof(WCHAR);
  42         info32->TypeName.Buffer        = PtrToUlong( info32 + 1 );
  43     }
  44     else memset( &info32->TypeName, 0, sizeof(info32->TypeName) );
  45     info32->TotalNumberOfObjects       = info->TotalNumberOfObjects;
  46     info32->TotalNumberOfHandles       = info->TotalNumberOfHandles;
  47     info32->TotalPagedPoolUsage        = info->TotalPagedPoolUsage;
  48     info32->TotalNonPagedPoolUsage     = info->TotalNonPagedPoolUsage;
  49     info32->TotalNamePoolUsage         = info->TotalNamePoolUsage;
  50     info32->TotalHandleTableUsage      = info->TotalHandleTableUsage;
  51     info32->HighWaterNumberOfObjects   = info->HighWaterNumberOfObjects;
  52     info32->HighWaterNumberOfHandles   = info->HighWaterNumberOfHandles;
  53     info32->HighWaterPagedPoolUsage    = info->HighWaterPagedPoolUsage;
  54     info32->HighWaterNonPagedPoolUsage = info->HighWaterNonPagedPoolUsage;
  55     info32->HighWaterNamePoolUsage     = info->HighWaterNamePoolUsage;
  56     info32->HighWaterHandleTableUsage  = info->HighWaterHandleTableUsage;
  57     info32->InvalidAttributes          = info->InvalidAttributes;
  58     info32->GenericMapping             = info->GenericMapping;
  59     info32->ValidAccessMask            = info->ValidAccessMask;
  60     info32->SecurityRequired           = info->SecurityRequired;
  61     info32->MaintainHandleCount        = info->MaintainHandleCount;
  62     info32->TypeIndex                  = info->TypeIndex;
  63     info32->ReservedByte               = info->ReservedByte;
  64     info32->PoolType                   = info->PoolType;
  65     info32->DefaultPagedPoolCharge     = info->DefaultPagedPoolCharge;
  66     info32->DefaultNonPagedPoolCharge  = info->DefaultNonPagedPoolCharge;
  67 }
  68
  69
  70 static JOBOBJECT_BASIC_LIMIT_INFORMATION *job_basic_limit_info_32to64( JOBOBJECT_BASIC_LIMIT_INFORMATION *out,
  71                                                                        const JOBOBJECT_BASIC_LIMIT_INFORMATION32 *in )
  72 {
  73     out->PerProcessUserTimeLimit = in->PerProcessUserTimeLimit;
  74     out->PerJobUserTimeLimit     = in->PerJobUserTimeLimit;
  75     out->LimitFlags              = in->LimitFlags;
  76     out->MinimumWorkingSetSize   = in->MinimumWorkingSetSize;
  77     out->MaximumWorkingSetSize   = in->MaximumWorkingSetSize;
  78     out->ActiveProcessLimit      = in->ActiveProcessLimit;
  79     out->Affinity                = in->Affinity;
  80     out->PriorityClass           = in->PriorityClass;
  81     out->SchedulingClass         = in->SchedulingClass;
  82     return out;
  83 }
  84
  85
  86 static void put_job_basic_limit_info( JOBOBJECT_BASIC_LIMIT_INFORMATION32 *info32,
  87                                       const JOBOBJECT_BASIC_LIMIT_INFORMATION *info )
  88 {
  89     info32->PerProcessUserTimeLimit = info->PerProcessUserTimeLimit;
  90     info32->PerJobUserTimeLimit     = info->PerJobUserTimeLimit;
  91     info32->LimitFlags              = info->LimitFlags;
  92     info32->MinimumWorkingSetSize   = info->MinimumWorkingSetSize;
  93     info32->MaximumWorkingSetSize   = info->MaximumWorkingSetSize;
  94     info32->ActiveProcessLimit      = info->ActiveProcessLimit;
  95     info32->Affinity                = info->Affinity;
  96     info32->PriorityClass           = info->PriorityClass;
  97     info32->SchedulingClass         = info->SchedulingClass;
  98 }
  99
 100
 101 void put_section_image_info( SECTION_IMAGE_INFORMATION32 *info32, const SECTION_IMAGE_INFORMATION *info )
 102 {
 103     if (info->Machine == IMAGE_FILE_MACHINE_AMD64 || info->Machine == IMAGE_FILE_MACHINE_ARM64)
 104     {
 105         info32->TransferAddress    = 0x81231234;  /* sic */
 106         info32->MaximumStackSize   = 0x100000;
 107         info32->CommittedStackSize = 0x10000;
 108     }
 109     else
 110     {
 111         info32->TransferAddress    = PtrToUlong( info->TransferAddress );
 112         info32->MaximumStackSize   = info->MaximumStackSize;
 113         info32->CommittedStackSize = info->CommittedStackSize;
 114     }
 115     info32->ZeroBits                    = info->ZeroBits;
 116     info32->SubSystemType               = info->SubSystemType;
 117     info32->MinorSubsystemVersion       = info->MinorSubsystemVersion;
 118     info32->MajorSubsystemVersion       = info->MajorSubsystemVersion;
 119     info32->MajorOperatingSystemVersion = info->MajorOperatingSystemVersion;
 120     info32->MinorOperatingSystemVersion = info->MinorOperatingSystemVersion;
 121     info32->ImageCharacteristics        = info->ImageCharacteristics;
 122     info32->DllCharacteristics          = info->DllCharacteristics;
 123     info32->Machine                     = info->Machine;
 124     info32->ImageContainsCode           = info->ImageContainsCode;
 125     info32->ImageFlags                  = info->ImageFlags;
 126     info32->LoaderFlags                 = info->LoaderFlags;
 127     info32->ImageFileSize               = info->ImageFileSize;
 128     info32->CheckSum                    = info->CheckSum;
 129 }
 130
 131
 132 /**********************************************************************
 133  *           wow64_NtAcceptConnectPort
 134  */
 135 NTSTATUS WINAPI wow64_NtAcceptConnectPort( UINT *args )
 136 {
 137     ULONG *handle_ptr = get_ptr( &args );
 138     ULONG id = get_ulong( &args );
 139     LPC_MESSAGE *msg = get_ptr( &args );
 140     BOOLEAN accept = get_ulong( &args );
 141     LPC_SECTION_WRITE *write = get_ptr( &args );
 142     LPC_SECTION_READ *read = get_ptr( &args );
 143
 144     FIXME( "%p %lu %p %u %p %p: stub\n", handle_ptr, id, msg, accept, write, read );
 145     return STATUS_NOT_IMPLEMENTED;
 146 }
 147
 148
 149 /**********************************************************************
 150  *           wow64_NtCancelTimer
 151  */
 152 NTSTATUS WINAPI wow64_NtCancelTimer( UINT *args )
 153 {
 154     HANDLE handle = get_handle( &args );
 155     BOOLEAN *state = get_ptr( &args );
 156
 157     return NtCancelTimer( handle, state );
 158 }
 159
 160
 161 /**********************************************************************
 162  *           wow64_NtClearEvent
 163  */
 164 NTSTATUS WINAPI wow64_NtClearEvent( UINT *args )
 165 {
 166     HANDLE handle = get_handle( &args );
 167
 168     return NtClearEvent( handle );
 169 }
 170
 171
 172 /**********************************************************************
 173  *           wow64_NtCompareObjects
 174  */
 175 NTSTATUS WINAPI wow64_NtCompareObjects( UINT *args )
 176 {
 177     HANDLE first = get_handle( &args );
 178     HANDLE second = get_handle( &args );
 179
 180     return NtCompareObjects( first, second );
 181 }
 182
 183
 184 /**********************************************************************
 185  *           wow64_NtCompleteConnectPort
 186  */
 187 NTSTATUS WINAPI wow64_NtCompleteConnectPort( UINT *args )
 188 {
 189     HANDLE handle = get_handle( &args );
 190
 191     return NtCompleteConnectPort( handle );
 192 }
 193
 194
 195 /**********************************************************************
 196  *           wow64_NtConnectPort
 197  */
 198 NTSTATUS WINAPI wow64_NtConnectPort( UINT *args )
 199 {
 200     ULONG *handle_ptr = get_ptr( &args );
 201     UNICODE_STRING32 *name32 = get_ptr( &args );
 202     SECURITY_QUALITY_OF_SERVICE *qos = get_ptr( &args );
 203     LPC_SECTION_WRITE *write = get_ptr( &args );
 204     LPC_SECTION_READ *read = get_ptr( &args );
 205     ULONG *max_len = get_ptr( &args );
 206     void *info = get_ptr( &args );
 207     ULONG *info_len = get_ptr( &args );
 208
 209     FIXME( "%p %p %p %p %p %p %p %p: stub\n",
 210            handle_ptr, name32, qos, write, read, max_len, info, info_len );
 211     return STATUS_NOT_IMPLEMENTED;
 212 }
 213
 214
 215 /**********************************************************************
 216  *           wow64_NtCreateDebugObject
 217  */
 218 NTSTATUS WINAPI wow64_NtCreateDebugObject( UINT *args )
 219 {
 220     ULONG *handle_ptr = get_ptr( &args );
 221     ACCESS_MASK access = get_ulong( &args );
 222     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 223     ULONG flags = get_ulong( &args );
 224
 225     struct object_attr64 attr;
 226     HANDLE handle = 0;
 227     NTSTATUS status;
 228
 229     *handle_ptr = 0;
 230     status = NtCreateDebugObject( &handle, access, objattr_32to64( &attr, attr32 ), flags );
 231     put_handle( handle_ptr, handle );
 232     return status;
 233 }
 234
 235
 236 /**********************************************************************
 237  *           wow64_NtCreateDirectoryObject
 238  */
 239 NTSTATUS WINAPI wow64_NtCreateDirectoryObject( UINT *args )
 240 {
 241     ULONG *handle_ptr = get_ptr( &args );
 242     ACCESS_MASK access = get_ulong( &args );
 243     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 244
 245     struct object_attr64 attr;
 246     HANDLE handle = 0;
 247     NTSTATUS status;
 248
 249     *handle_ptr = 0;
 250     status = NtCreateDirectoryObject( &handle, access, objattr_32to64( &attr, attr32 ));
 251     put_handle( handle_ptr, handle );
 252     return status;
 253 }
 254
 255
 256 /**********************************************************************
 257  *           wow64_NtCreateEvent
 258  */
 259 NTSTATUS WINAPI wow64_NtCreateEvent( UINT *args )
 260 {
 261     ULONG *handle_ptr = get_ptr( &args );
 262     ACCESS_MASK access = get_ulong( &args );
 263     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 264     EVENT_TYPE type = get_ulong( &args );
 265     BOOLEAN state = get_ulong( &args );
 266
 267     struct object_attr64 attr;
 268     HANDLE handle = 0;
 269     NTSTATUS status;
 270
 271     *handle_ptr = 0;
 272     status = NtCreateEvent( &handle, access, objattr_32to64( &attr, attr32 ), type, state );
 273     put_handle( handle_ptr, handle );
 274     return status;
 275 }
 276
 277
 278 /**********************************************************************
 279  *           wow64_NtCreateIoCompletion
 280  */
 281 NTSTATUS WINAPI wow64_NtCreateIoCompletion( UINT *args )
 282 {
 283     ULONG *handle_ptr = get_ptr( &args );
 284     ACCESS_MASK access = get_ulong( &args );
 285     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 286     ULONG threads = get_ulong( &args );
 287
 288     struct object_attr64 attr;
 289     HANDLE handle = 0;
 290     NTSTATUS status;
 291
 292     *handle_ptr = 0;
 293     status = NtCreateIoCompletion( &handle, access, objattr_32to64( &attr, attr32 ), threads );
 294     put_handle( handle_ptr, handle );
 295     return status;
 296 }
 297
 298
 299 /**********************************************************************
 300  *           wow64_NtCreateJobObject
 301  */
 302 NTSTATUS WINAPI wow64_NtCreateJobObject( UINT *args )
 303 {
 304     ULONG *handle_ptr = get_ptr( &args );
 305     ACCESS_MASK access = get_ulong( &args );
 306     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 307
 308     struct object_attr64 attr;
 309     HANDLE handle = 0;
 310     NTSTATUS status;
 311
 312     *handle_ptr = 0;
 313     status = NtCreateJobObject( &handle, access, objattr_32to64( &attr, attr32 ));
 314     put_handle( handle_ptr, handle );
 315     return status;
 316 }
 317
 318
 319 /**********************************************************************
 320  *           wow64_NtCreateKeyedEvent
 321  */
 322 NTSTATUS WINAPI wow64_NtCreateKeyedEvent( UINT *args )
 323 {
 324     ULONG *handle_ptr = get_ptr( &args );
 325     ACCESS_MASK access = get_ulong( &args );
 326     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 327     ULONG flags = get_ulong( &args );
 328
 329     struct object_attr64 attr;
 330     HANDLE handle = 0;
 331     NTSTATUS status;
 332
 333     *handle_ptr = 0;
 334     status = NtCreateKeyedEvent( &handle, access, objattr_32to64( &attr, attr32 ), flags );
 335     put_handle( handle_ptr, handle );
 336     return status;
 337 }
 338
 339
 340 /**********************************************************************
 341  *           wow64_NtCreateMutant
 342  */
 343 NTSTATUS WINAPI wow64_NtCreateMutant( UINT *args )
 344 {
 345     ULONG *handle_ptr = get_ptr( &args );
 346     ACCESS_MASK access = get_ulong( &args );
 347     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 348     BOOLEAN owned = get_ulong( &args );
 349
 350     struct object_attr64 attr;
 351     HANDLE handle = 0;
 352     NTSTATUS status;
 353
 354     *handle_ptr = 0;
 355     status = NtCreateMutant( &handle, access, objattr_32to64( &attr, attr32 ), owned );
 356     put_handle( handle_ptr, handle );
 357     return status;
 358 }
 359
 360
 361 /**********************************************************************
 362  *           wow64_NtCreatePort
 363  */
 364 NTSTATUS WINAPI wow64_NtCreatePort( UINT *args )
 365 {
 366     ULONG *handle_ptr = get_ptr( &args );
 367     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 368     ULONG info_len = get_ulong( &args );
 369     ULONG data_len = get_ulong( &args );
 370     ULONG *reserved = get_ptr( &args );
 371
 372     struct object_attr64 attr;
 373     HANDLE handle = 0;
 374     NTSTATUS status;
 375
 376     *handle_ptr = 0;
 377     status = NtCreatePort( &handle, objattr_32to64( &attr, attr32 ), info_len, data_len, reserved );
 378     put_handle( handle_ptr, handle );
 379     return status;
 380 }
 381
 382
 383 /**********************************************************************
 384  *           wow64_NtCreateSection
 385  */
 386 NTSTATUS WINAPI wow64_NtCreateSection( UINT *args )
 387 {
 388     ULONG *handle_ptr = get_ptr( &args );
 389     ACCESS_MASK access = get_ulong( &args );
 390     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 391     const LARGE_INTEGER *size = get_ptr( &args );
 392     ULONG protect = get_ulong( &args );
 393     ULONG flags = get_ulong( &args );
 394     HANDLE file = get_handle( &args );
 395
 396     struct object_attr64 attr;
 397     HANDLE handle = 0;
 398     NTSTATUS status;
 399
 400     *handle_ptr = 0;
 401     status = NtCreateSection( &handle, access, objattr_32to64( &attr, attr32 ), size, protect, flags, file );
 402     put_handle( handle_ptr, handle );
 403     return status;
 404 }
 405
 406
 407 /**********************************************************************
 408  *           wow64_NtCreateSemaphore
 409  */
 410 NTSTATUS WINAPI wow64_NtCreateSemaphore( UINT *args )
 411 {
 412     ULONG *handle_ptr = get_ptr( &args );
 413     ACCESS_MASK access = get_ulong( &args );
 414     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 415     LONG initial = get_ulong( &args );
 416     LONG max = get_ulong( &args );
 417
 418     struct object_attr64 attr;
 419     HANDLE handle = 0;
 420     NTSTATUS status;
 421
 422     *handle_ptr = 0;
 423     status = NtCreateSemaphore( &handle, access, objattr_32to64( &attr, attr32 ), initial, max );
 424     put_handle( handle_ptr, handle );
 425     return status;
 426 }
 427
 428
 429 /**********************************************************************
 430  *           wow64_NtCreateSymbolicLinkObject
 431  */
 432 NTSTATUS WINAPI wow64_NtCreateSymbolicLinkObject( UINT *args )
 433 {
 434     ULONG *handle_ptr = get_ptr( &args );
 435     ACCESS_MASK access = get_ulong( &args );
 436     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 437     UNICODE_STRING32 *target32 = get_ptr( &args );
 438
 439     struct object_attr64 attr;
 440     UNICODE_STRING target;
 441     HANDLE handle = 0;
 442     NTSTATUS status;
 443
 444     *handle_ptr = 0;
 445     status = NtCreateSymbolicLinkObject( &handle, access, objattr_32to64( &attr, attr32 ),
 446                                          unicode_str_32to64( &target, target32 ));
 447     put_handle( handle_ptr, handle );
 448     return status;
 449 }
 450
 451
 452 /**********************************************************************
 453  *           wow64_NtCreateTimer
 454  */
 455 NTSTATUS WINAPI wow64_NtCreateTimer( UINT *args )
 456 {
 457     ULONG *handle_ptr = get_ptr( &args );
 458     ACCESS_MASK access = get_ulong( &args );
 459     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 460     TIMER_TYPE type = get_ulong( &args );
 461
 462     struct object_attr64 attr;
 463     HANDLE handle = 0;
 464     NTSTATUS status;
 465
 466     *handle_ptr = 0;
 467     status = NtCreateTimer( &handle, access, objattr_32to64( &attr, attr32 ), type );
 468     put_handle( handle_ptr, handle );
 469     return status;
 470 }
 471
 472
 473 /**********************************************************************
 474  *           wow64_NtDebugContinue
 475  */
 476 NTSTATUS WINAPI wow64_NtDebugContinue( UINT *args )
 477 {
 478     HANDLE handle = get_handle( &args );
 479     CLIENT_ID32 *id32 = get_ptr( &args );
 480     NTSTATUS status = get_ulong( &args );
 481
 482     CLIENT_ID id;
 483
 484     return NtDebugContinue( handle, client_id_32to64( &id, id32 ), status );
 485 }
 486
 487
 488 /**********************************************************************
 489  *           wow64_NtDelayExecution
 490  */
 491 NTSTATUS WINAPI wow64_NtDelayExecution( UINT *args )
 492 {
 493     BOOLEAN alertable = get_ulong( &args );
 494     const LARGE_INTEGER *timeout = get_ptr( &args );
 495
 496     return NtDelayExecution( alertable, timeout );
 497 }
 498
 499
 500 /**********************************************************************
 501  *           wow64_NtDuplicateObject
 502  */
 503 NTSTATUS WINAPI wow64_NtDuplicateObject( UINT *args )
 504 {
 505     HANDLE source_process = get_handle( &args );
 506     HANDLE source_handle = get_handle( &args );
 507     HANDLE dest_process = get_handle( &args );
 508     ULONG *handle_ptr = get_ptr( &args );
 509     ACCESS_MASK access = get_ulong( &args );
 510     ULONG attributes = get_ulong( &args );
 511     ULONG options = get_ulong( &args );
 512
 513     HANDLE handle = 0;
 514     NTSTATUS status;
 515
 516     if (handle_ptr) *handle_ptr = 0;
 517     status = NtDuplicateObject( source_process, source_handle, dest_process, &handle,
 518                                 access, attributes, options );
 519     if (handle_ptr) put_handle( handle_ptr, handle );
 520     return status;
 521 }
 522
 523
 524 /**********************************************************************
 525  *           wow64_NtListenPort
 526  */
 527 NTSTATUS WINAPI wow64_NtListenPort( UINT *args )
 528 {
 529     HANDLE handle = get_handle( &args );
 530     LPC_MESSAGE *msg = get_ptr( &args );
 531
 532     FIXME( "%p %p: stub\n", handle, msg );
 533     return STATUS_NOT_IMPLEMENTED;
 534 }
 535
 536
 537 /**********************************************************************
 538  *           wow64_NtMakeTemporaryObject
 539  */
 540 NTSTATUS WINAPI wow64_NtMakeTemporaryObject( UINT *args )
 541 {
 542     HANDLE handle = get_handle( &args );
 543
 544     return NtMakeTemporaryObject( handle );
 545 }
 546
 547
 548 /**********************************************************************
 549  *           wow64_NtOpenDirectoryObject
 550  */
 551 NTSTATUS WINAPI wow64_NtOpenDirectoryObject( UINT *args )
 552 {
 553     ULONG *handle_ptr = get_ptr( &args );
 554     ACCESS_MASK access = get_ulong( &args );
 555     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 556
 557     struct object_attr64 attr;
 558     HANDLE handle = 0;
 559     NTSTATUS status;
 560
 561     *handle_ptr = 0;
 562     status = NtOpenDirectoryObject( &handle, access, objattr_32to64( &attr, attr32 ));
 563     put_handle( handle_ptr, handle );
 564     return status;
 565 }
 566
 567
 568 /**********************************************************************
 569  *           wow64_NtOpenEvent
 570  */
 571 NTSTATUS WINAPI wow64_NtOpenEvent( UINT *args )
 572 {
 573     ULONG *handle_ptr = get_ptr( &args );
 574     ACCESS_MASK access = get_ulong( &args );
 575     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 576
 577     struct object_attr64 attr;
 578     HANDLE handle = 0;
 579     NTSTATUS status;
 580
 581     *handle_ptr = 0;
 582     status = NtOpenEvent( &handle, access, objattr_32to64( &attr, attr32 ));
 583     put_handle( handle_ptr, handle );
 584     return status;
 585 }
 586
 587
 588 /**********************************************************************
 589  *           wow64_NtOpenIoCompletion
 590  */
 591 NTSTATUS WINAPI wow64_NtOpenIoCompletion( UINT *args )
 592 {
 593     ULONG *handle_ptr = get_ptr( &args );
 594     ACCESS_MASK access = get_ulong( &args );
 595     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 596
 597     struct object_attr64 attr;
 598     HANDLE handle = 0;
 599     NTSTATUS status;
 600
 601     *handle_ptr = 0;
 602     status = NtOpenIoCompletion( &handle, access, objattr_32to64( &attr, attr32 ));
 603     put_handle( handle_ptr, handle );
 604     return status;
 605 }
 606
 607
 608 /**********************************************************************
 609  *           wow64_NtOpenJobObject
 610  */
 611 NTSTATUS WINAPI wow64_NtOpenJobObject( UINT *args )
 612 {
 613     ULONG *handle_ptr = get_ptr( &args );
 614     ACCESS_MASK access = get_ulong( &args );
 615     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 616
 617     struct object_attr64 attr;
 618     HANDLE handle = 0;
 619     NTSTATUS status;
 620
 621     *handle_ptr = 0;
 622     status = NtOpenJobObject( &handle, access, objattr_32to64( &attr, attr32 ));
 623     put_handle( handle_ptr, handle );
 624     return status;
 625 }
 626
 627
 628 /**********************************************************************
 629  *           wow64_NtOpenKeyedEvent
 630  */
 631 NTSTATUS WINAPI wow64_NtOpenKeyedEvent( UINT *args )
 632 {
 633     ULONG *handle_ptr = get_ptr( &args );
 634     ACCESS_MASK access = get_ulong( &args );
 635     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 636
 637     struct object_attr64 attr;
 638     HANDLE handle = 0;
 639     NTSTATUS status;
 640
 641     *handle_ptr = 0;
 642     status = NtOpenKeyedEvent( &handle, access, objattr_32to64( &attr, attr32 ));
 643     put_handle( handle_ptr, handle );
 644     return status;
 645 }
 646
 647
 648 /**********************************************************************
 649  *           wow64_NtOpenMutant
 650  */
 651 NTSTATUS WINAPI wow64_NtOpenMutant( UINT *args )
 652 {
 653     ULONG *handle_ptr = get_ptr( &args );
 654     ACCESS_MASK access = get_ulong( &args );
 655     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 656
 657     struct object_attr64 attr;
 658     HANDLE handle = 0;
 659     NTSTATUS status;
 660
 661     *handle_ptr = 0;
 662     status = NtOpenMutant( &handle, access, objattr_32to64( &attr, attr32 ));
 663     put_handle( handle_ptr, handle );
 664     return status;
 665 }
 666
 667
 668 /**********************************************************************
 669  *           wow64_NtOpenSection
 670  */
 671 NTSTATUS WINAPI wow64_NtOpenSection( UINT *args )
 672 {
 673     ULONG *handle_ptr = get_ptr( &args );
 674     ACCESS_MASK access = get_ulong( &args );
 675     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 676
 677     struct object_attr64 attr;
 678     HANDLE handle = 0;
 679     NTSTATUS status;
 680
 681     *handle_ptr = 0;
 682     status = NtOpenSection( &handle, access, objattr_32to64( &attr, attr32 ));
 683     put_handle( handle_ptr, handle );
 684     return status;
 685 }
 686
 687
 688 /**********************************************************************
 689  *           wow64_NtOpenSemaphore
 690  */
 691 NTSTATUS WINAPI wow64_NtOpenSemaphore( UINT *args )
 692 {
 693     ULONG *handle_ptr = get_ptr( &args );
 694     ACCESS_MASK access = get_ulong( &args );
 695     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 696
 697     struct object_attr64 attr;
 698     HANDLE handle = 0;
 699     NTSTATUS status;
 700
 701     *handle_ptr = 0;
 702     status = NtOpenSemaphore( &handle, access, objattr_32to64( &attr, attr32 ));
 703     put_handle( handle_ptr, handle );
 704     return status;
 705 }
 706
 707
 708 /**********************************************************************
 709  *           wow64_NtOpenSymbolicLinkObject
 710  */
 711 NTSTATUS WINAPI wow64_NtOpenSymbolicLinkObject( UINT *args )
 712 {
 713     ULONG *handle_ptr = get_ptr( &args );
 714     ACCESS_MASK access = get_ulong( &args );
 715     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 716
 717     struct object_attr64 attr;
 718     HANDLE handle = 0;
 719     NTSTATUS status;
 720
 721     *handle_ptr = 0;
 722     status = NtOpenSymbolicLinkObject( &handle, access, objattr_32to64( &attr, attr32 ));
 723     put_handle( handle_ptr, handle );
 724     return status;
 725 }
 726
 727
 728 /**********************************************************************
 729  *           wow64_NtOpenTimer
 730  */
 731 NTSTATUS WINAPI wow64_NtOpenTimer( UINT *args )
 732 {
 733     ULONG *handle_ptr = get_ptr( &args );
 734     ACCESS_MASK access = get_ulong( &args );
 735     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 736
 737     struct object_attr64 attr;
 738     HANDLE handle = 0;
 739     NTSTATUS status;
 740
 741     *handle_ptr = 0;
 742     status = NtOpenTimer( &handle, access, objattr_32to64( &attr, attr32 ));
 743     put_handle( handle_ptr, handle );
 744     return status;
 745 }
 746
 747
 748 /**********************************************************************
 749  *           wow64_NtPulseEvent
 750  */
 751 NTSTATUS WINAPI wow64_NtPulseEvent( UINT *args )
 752 {
 753     HANDLE handle = get_handle( &args );
 754     LONG *prev_state = get_ptr( &args );
 755
 756     return NtPulseEvent( handle, prev_state );
 757 }
 758
 759
 760 /**********************************************************************
 761  *           wow64_NtQueryDirectoryObject
 762  */
 763 NTSTATUS WINAPI wow64_NtQueryDirectoryObject( UINT *args )
 764 {
 765     HANDLE handle = get_handle( &args );
 766     DIRECTORY_BASIC_INFORMATION32 *info32 = get_ptr( &args );
 767     ULONG size32 = get_ulong( &args );
 768     BOOLEAN single_entry = get_ulong( &args );
 769     BOOLEAN restart = get_ulong( &args );
 770     ULONG *context = get_ptr( &args );
 771     ULONG *retlen = get_ptr( &args );
 772     ULONG retsize;
 773
 774     NTSTATUS status;
 775     DIRECTORY_BASIC_INFORMATION *info;
 776     ULONG size = size32 + 2 * sizeof(*info) - 2 * sizeof(*info32);
 777
 778     if (!single_entry) FIXME( "not implemented\n" );
 779     info = Wow64AllocateTemp( size );
 780     status = NtQueryDirectoryObject( handle, info, size, single_entry, restart, context, &retsize );
 781     if (!status)
 782     {
 783         info32->ObjectName.Buffer            = PtrToUlong( info32 + 2 );
 784         info32->ObjectName.Length            = info->ObjectName.Length;
 785         info32->ObjectName.MaximumLength     = info->ObjectName.MaximumLength;
 786         info32->ObjectTypeName.Buffer        = info32->ObjectName.Buffer + info->ObjectName.MaximumLength;
 787         info32->ObjectTypeName.Length        = info->ObjectTypeName.Length;
 788         info32->ObjectTypeName.MaximumLength = info->ObjectTypeName.MaximumLength;
 789         memset( info32 + 1, 0, sizeof(*info32) );
 790         size = info->ObjectName.MaximumLength + info->ObjectTypeName.MaximumLength;
 791         memcpy( info32 + 2, info + 2, size );
 792         if (retlen) *retlen = 2 * sizeof(*info32) + size;
 793     }
 794     else if (retlen && status == STATUS_BUFFER_TOO_SMALL)
 795         *retlen = retsize - 2 * sizeof(*info) + 2 * sizeof(*info32);
 796     else if (retlen && status == STATUS_NO_MORE_ENTRIES)
 797         *retlen = 0;
 798     return status;
 799 }
 800
 801
 802 /**********************************************************************
 803  *           wow64_NtQueryEvent
 804  */
 805 NTSTATUS WINAPI wow64_NtQueryEvent( UINT *args )
 806 {
 807     HANDLE handle = get_handle( &args );
 808     EVENT_INFORMATION_CLASS class = get_ulong( &args );
 809     void *info = get_ptr( &args );
 810     ULONG len = get_ulong( &args );
 811     ULONG *retlen = get_ptr( &args );
 812
 813     return NtQueryEvent( handle, class, info, len, retlen );
 814 }
 815
 816
 817 /**********************************************************************
 818  *           wow64_NtQueryInformationJobObject
 819  */
 820 NTSTATUS WINAPI wow64_NtQueryInformationJobObject( UINT *args )
 821 {
 822     HANDLE handle = get_handle( &args );
 823     JOBOBJECTINFOCLASS class = get_ulong( &args );
 824     void *ptr = get_ptr( &args );
 825     ULONG len = get_ulong( &args );
 826     ULONG *retlen = get_ptr( &args );
 827
 828     NTSTATUS status;
 829
 830     switch (class)
 831     {
 832     case JobObjectBasicAccountingInformation:   /* JOBOBJECT_BASIC_ACCOUNTING_INFORMATION */
 833         return NtQueryInformationJobObject( handle, class, ptr, len, retlen );
 834
 835     case JobObjectBasicLimitInformation:   /* JOBOBJECT_BASIC_LIMIT_INFORMATION */
 836         if (len >= sizeof(JOBOBJECT_BASIC_LIMIT_INFORMATION32))
 837         {
 838             JOBOBJECT_BASIC_LIMIT_INFORMATION32 *info32 = ptr;
 839             JOBOBJECT_BASIC_LIMIT_INFORMATION info;
 840
 841             status = NtQueryInformationJobObject( handle, class, &info, sizeof(info), NULL );
 842             if (!status) put_job_basic_limit_info( info32, &info );
 843             if (retlen) *retlen = sizeof(*info32);
 844             return status;
 845         }
 846         else return STATUS_INFO_LENGTH_MISMATCH;
 847
 848     case JobObjectBasicProcessIdList:   /* JOBOBJECT_BASIC_PROCESS_ID_LIST */
 849         if (len >= sizeof(JOBOBJECT_BASIC_PROCESS_ID_LIST32))
 850         {
 851             JOBOBJECT_BASIC_PROCESS_ID_LIST32 *info32 = ptr;
 852             JOBOBJECT_BASIC_PROCESS_ID_LIST *info;
 853             ULONG i, count, size;
 854
 855             count = (len - offsetof( JOBOBJECT_BASIC_PROCESS_ID_LIST32, ProcessIdList )) / sizeof(info32->ProcessIdList[0]);
 856             size = offsetof( JOBOBJECT_BASIC_PROCESS_ID_LIST, ProcessIdList[count] );
 857             info = Wow64AllocateTemp( size );
 858             status = NtQueryInformationJobObject( handle, class, info, size, NULL );
 859             if (!status)
 860             {
 861                 info32->NumberOfAssignedProcesses = info->NumberOfAssignedProcesses;
 862                 info32->NumberOfProcessIdsInList  = info->NumberOfProcessIdsInList;
 863                 for (i = 0; i < info->NumberOfProcessIdsInList; i++)
 864                     info32->ProcessIdList[i] = info->ProcessIdList[i];
 865                 if (retlen) *retlen = offsetof( JOBOBJECT_BASIC_PROCESS_ID_LIST32, ProcessIdList[i] );
 866             }
 867             return status;
 868         }
 869         else return STATUS_INFO_LENGTH_MISMATCH;
 870
 871     case JobObjectExtendedLimitInformation:   /* JOBOBJECT_EXTENDED_LIMIT_INFORMATION */
 872         if (len >= sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION32))
 873         {
 874             JOBOBJECT_EXTENDED_LIMIT_INFORMATION32 *info32 = ptr;
 875             JOBOBJECT_EXTENDED_LIMIT_INFORMATION info;
 876
 877             status = NtQueryInformationJobObject( handle, class, &info, sizeof(info), NULL );
 878             if (!status)
 879             {
 880                 put_job_basic_limit_info( &info32->BasicLimitInformation, &info.BasicLimitInformation );
 881                 info32->IoInfo                = info.IoInfo;
 882                 info32->ProcessMemoryLimit    = info.ProcessMemoryLimit;
 883                 info32->JobMemoryLimit        = info.JobMemoryLimit;
 884                 info32->PeakProcessMemoryUsed = info.PeakProcessMemoryUsed;
 885                 info32->PeakJobMemoryUsed     = info.PeakJobMemoryUsed;
 886             }
 887             if (retlen) *retlen = sizeof(*info32);
 888             return status;
 889         }
 890         else return STATUS_INFO_LENGTH_MISMATCH;
 891
 892     default:
 893         if (class >= MaxJobObjectInfoClass) return STATUS_INVALID_PARAMETER;
 894         FIXME( "unsupported class %u\n", class );
 895         return STATUS_NOT_IMPLEMENTED;
 896     }
 897 }
 898
 899
 900 /**********************************************************************
 901  *           wow64_NtQueryIoCompletion
 902  */
 903 NTSTATUS WINAPI wow64_NtQueryIoCompletion( UINT *args )
 904 {
 905     HANDLE handle = get_handle( &args );
 906     IO_COMPLETION_INFORMATION_CLASS class = get_ulong( &args );
 907     void *info = get_ptr( &args );
 908     ULONG len = get_ulong( &args );
 909     ULONG *retlen = get_ptr( &args );
 910
 911     return NtQueryIoCompletion( handle, class, info, len, retlen );
 912 }
 913
 914
 915 /**********************************************************************
 916  *           wow64_NtQueryMutant
 917  */
 918 NTSTATUS WINAPI wow64_NtQueryMutant( UINT *args )
 919 {
 920     HANDLE handle = get_handle( &args );
 921     MUTANT_INFORMATION_CLASS class = get_ulong( &args );
 922     void *info = get_ptr( &args );
 923     ULONG len = get_ulong( &args );
 924     ULONG *retlen = get_ptr( &args );
 925
 926     return NtQueryMutant( handle, class, info, len, retlen );
 927 }
 928
 929
 930 /**********************************************************************
 931  *           wow64_NtQueryObject
 932  */
 933 NTSTATUS WINAPI wow64_NtQueryObject( UINT *args )
 934 {
 935     HANDLE handle = get_handle( &args );
 936     OBJECT_INFORMATION_CLASS class = get_ulong( &args );
 937     void *ptr = get_ptr( &args );
 938     ULONG len = get_ulong( &args );
 939     ULONG *retlen = get_ptr( &args );
 940
 941     NTSTATUS status;
 942     ULONG ret_size;
 943
 944     switch (class)
 945     {
 946     case ObjectBasicInformation:   /* OBJECT_BASIC_INFORMATION */
 947     case ObjectHandleFlagInformation:   /* OBJECT_HANDLE_FLAG_INFORMATION */
 948         return NtQueryObject( handle, class, ptr, len, retlen );
 949
 950     case ObjectNameInformation:   /* OBJECT_NAME_INFORMATION */
 951     {
 952         ULONG size = len + sizeof(OBJECT_NAME_INFORMATION) - sizeof(OBJECT_NAME_INFORMATION32);
 953         OBJECT_NAME_INFORMATION32 *info32 = ptr;
 954         OBJECT_NAME_INFORMATION *info = Wow64AllocateTemp( size );
 955
 956         if (!(status = NtQueryObject( handle, class, info, size, &ret_size )))
 957         {
 958             if (len >= sizeof(*info32) + info->Name.MaximumLength)
 959             {
 960                 if (info->Name.Length)
 961                 {
 962                     memcpy( info32 + 1, info->Name.Buffer, info->Name.Length + sizeof(WCHAR) );
 963                     info32->Name.Length = info->Name.Length;
 964                     info32->Name.MaximumLength = info->Name.Length + sizeof(WCHAR);
 965                     info32->Name.Buffer = PtrToUlong( info32 + 1 );
 966                 }
 967                 else memset( &info32->Name, 0, sizeof(info32->Name) );
 968             }
 969             else status = STATUS_INFO_LENGTH_MISMATCH;
 970             if (retlen) *retlen = sizeof(*info32) + info->Name.MaximumLength;
 971         }
 972         else if (status == STATUS_INFO_LENGTH_MISMATCH || status == STATUS_BUFFER_OVERFLOW)
 973         {
 974             if (retlen) *retlen = ret_size - sizeof(*info) + sizeof(*info32);
 975         }
 976         return status;
 977     }
 978
 979     case ObjectTypeInformation:   /* OBJECT_TYPE_INFORMATION */
 980     {
 981         ULONG_PTR buffer[(sizeof(OBJECT_TYPE_INFORMATION) + 64) / sizeof(ULONG_PTR)];
 982         OBJECT_TYPE_INFORMATION *info = (OBJECT_TYPE_INFORMATION *)buffer;
 983         OBJECT_TYPE_INFORMATION32 *info32 = ptr;
 984
 985         if (!(status = NtQueryObject( handle, class, info, sizeof(buffer), NULL )))
 986         {
 987             if (len >= sizeof(*info32) + info->TypeName.MaximumLength)
 988                 put_object_type_info( info32, info );
 989             else
 990                 status = STATUS_INFO_LENGTH_MISMATCH;
 991             if (retlen) *retlen = sizeof(*info32) + info->TypeName.Length + sizeof(WCHAR);
 992         }
 993         return status;
 994     }
 995
 996     case ObjectTypesInformation:   /* OBJECT_TYPES_INFORMATION */
 997     {
 998         OBJECT_TYPES_INFORMATION *info, *info32 = ptr;
 999         /* assume at most 32 types, with an average 16-char name */
1000         ULONG ret_size, size = 32 * (sizeof(OBJECT_TYPE_INFORMATION) + 16 * sizeof(WCHAR));
1001
1002         info = Wow64AllocateTemp( size );
1003         if (!(status = NtQueryObject( handle, class, info, size, &ret_size )))
1004         {
1005             OBJECT_TYPE_INFORMATION *type;
1006             OBJECT_TYPE_INFORMATION32 *type32;
1007             ULONG align = TYPE_ALIGNMENT( OBJECT_TYPE_INFORMATION ) - 1;
1008             ULONG align32 = TYPE_ALIGNMENT( OBJECT_TYPE_INFORMATION32 ) - 1;
1009             ULONG i, pos = (sizeof(*info) + align) & ~align, pos32 = (sizeof(*info32) + align32) & ~align32;
1010
1011             if (pos32 <= len) info32->NumberOfTypes = info->NumberOfTypes;
1012             for (i = 0; i < info->NumberOfTypes; i++)
1013             {
1014                 type = (OBJECT_TYPE_INFORMATION *)((char *)info + pos);
1015                 type32 = (OBJECT_TYPE_INFORMATION32 *)((char *)ptr + pos32);
1016                 pos += sizeof(*type) + ((type->TypeName.MaximumLength + align) & ~align);
1017                 pos32 += sizeof(*type32) + ((type->TypeName.MaximumLength + align32) & ~align32);
1018                 if (pos32 <= len) put_object_type_info( type32, type );
1019             }
1020             if (pos32 > len) status = STATUS_INFO_LENGTH_MISMATCH;
1021             if (retlen) *retlen = pos32;
1022         }
1023         return status;
1024     }
1025
1026     default:
1027         FIXME( "unsupported class %u\n", class );
1028         return STATUS_NOT_IMPLEMENTED;
1029     }
1030 }
1031
1032
1033 /**********************************************************************
1034  *           wow64_NtQueryPerformanceCounter
1035  */
1036 NTSTATUS WINAPI wow64_NtQueryPerformanceCounter( UINT *args )
1037 {
1038     LARGE_INTEGER *counter = get_ptr( &args );
1039     LARGE_INTEGER *frequency = get_ptr( &args );
1040
1041     return NtQueryPerformanceCounter( counter, frequency );
1042 }
1043
1044
1045 /**********************************************************************
1046  *           wow64_NtQuerySection
1047  */
1048 NTSTATUS WINAPI wow64_NtQuerySection( UINT *args )
1049 {
1050     HANDLE handle = get_handle( &args );
1051     SECTION_INFORMATION_CLASS class = get_ulong( &args );
1052     void *ptr = get_ptr( &args );
1053     SIZE_T size = get_ulong( &args );
1054     ULONG *ret_ptr = get_ptr( &args );
1055
1056     NTSTATUS status;
1057     SIZE_T ret_size = 0;
1058
1059     switch (class)
1060     {
1061     case SectionBasicInformation:
1062     {
1063         SECTION_BASIC_INFORMATION info;
1064         SECTION_BASIC_INFORMATION32 *info32 = ptr;
1065
1066         if (size < sizeof(*info32)) return STATUS_INFO_LENGTH_MISMATCH;
1067         if (!(status = NtQuerySection( handle, class, &info, sizeof(info), &ret_size )))
1068         {
1069             info32->BaseAddress = PtrToUlong( info.BaseAddress );
1070             info32->Attributes  = info.Attributes;
1071             info32->Size        = info.Size;
1072             ret_size = sizeof(*info32);
1073         }
1074         break;
1075     }
1076     case SectionImageInformation:
1077     {
1078         SECTION_IMAGE_INFORMATION info;
1079         SECTION_IMAGE_INFORMATION32 *info32 = ptr;
1080
1081         if (size < sizeof(*info32)) return STATUS_INFO_LENGTH_MISMATCH;
1082         if (!(status = NtQuerySection( handle, class, &info, sizeof(info), &ret_size )))
1083         {
1084             put_section_image_info( info32, &info );
1085             ret_size = sizeof(*info32);
1086         }
1087         break;
1088     }
1089     default:
1090         FIXME( "class %u not implemented\n", class );
1091         return STATUS_NOT_IMPLEMENTED;
1092     }
1093     put_size( ret_ptr, ret_size );
1094     return status;
1095 }
1096
1097
1098 /**********************************************************************
1099  *           wow64_NtQuerySemaphore
1100  */
1101 NTSTATUS WINAPI wow64_NtQuerySemaphore( UINT *args )
1102 {
1103     HANDLE handle = get_handle( &args );
1104     SEMAPHORE_INFORMATION_CLASS class = get_ulong( &args );
1105     void *info = get_ptr( &args );
1106     ULONG len = get_ulong( &args );
1107     ULONG *retlen = get_ptr( &args );
1108
1109     return NtQuerySemaphore( handle, class, info, len, retlen );
1110 }
1111
1112
1113 /**********************************************************************
1114  *           wow64_NtQuerySymbolicLinkObject
1115  */
1116 NTSTATUS WINAPI wow64_NtQuerySymbolicLinkObject( UINT *args )
1117 {
1118     HANDLE handle = get_handle( &args );
1119     UNICODE_STRING32 *target32 = get_ptr( &args );
1120     ULONG *retlen = get_ptr( &args );
1121
1122     UNICODE_STRING target;
1123     NTSTATUS status;
1124
1125     status = NtQuerySymbolicLinkObject( handle, unicode_str_32to64( &target, target32 ), retlen );
1126     if (!status) target32->Length = target.Length;
1127     return status;
1128 }
1129
1130
1131 /**********************************************************************
1132  *           wow64_NtQueryTimer
1133  */
1134 NTSTATUS WINAPI wow64_NtQueryTimer( UINT *args )
1135 {
1136     HANDLE handle = get_handle( &args );
1137     TIMER_INFORMATION_CLASS class = get_ulong( &args );
1138     void *info = get_ptr( &args );
1139     ULONG len = get_ulong( &args );
1140     ULONG *retlen = get_ptr( &args );
1141
1142     return NtQueryTimer( handle, class, info, len, retlen );
1143 }
1144
1145
1146 /**********************************************************************
1147  *           wow64_NtQueryTimerResolution
1148  */
1149 NTSTATUS WINAPI wow64_NtQueryTimerResolution( UINT *args )
1150 {
1151     ULONG *min_res = get_ptr( &args );
1152     ULONG *max_res = get_ptr( &args );
1153     ULONG *current_res = get_ptr( &args );
1154
1155     return NtQueryTimerResolution( min_res, max_res, current_res );
1156 }
1157
1158
1159 /**********************************************************************
1160  *           wow64_NtRegisterThreadTerminatePort
1161  */
1162 NTSTATUS WINAPI wow64_NtRegisterThreadTerminatePort( UINT *args )
1163 {
1164     HANDLE handle = get_handle( &args );
1165
1166     return NtRegisterThreadTerminatePort( handle );
1167 }
1168
1169
1170 /**********************************************************************
1171  *           wow64_NtReleaseKeyedEvent
1172  */
1173 NTSTATUS WINAPI wow64_NtReleaseKeyedEvent( UINT *args )
1174 {
1175     HANDLE handle = get_handle( &args );
1176     void *key = get_ptr( &args );
1177     BOOLEAN alertable = get_ulong( &args );
1178     const LARGE_INTEGER *timeout = get_ptr( &args );
1179
1180     return NtReleaseKeyedEvent( handle, key, alertable, timeout );
1181 }
1182
1183
1184 /**********************************************************************
1185  *           wow64_NtReleaseMutant
1186  */
1187 NTSTATUS WINAPI wow64_NtReleaseMutant( UINT *args )
1188 {
1189     HANDLE handle = get_handle( &args );
1190     LONG *prev_count = get_ptr( &args );
1191
1192     return NtReleaseMutant( handle, prev_count );
1193 }
1194
1195
1196 /**********************************************************************
1197  *           wow64_NtReleaseSemaphore
1198  */
1199 NTSTATUS WINAPI wow64_NtReleaseSemaphore( UINT *args )
1200 {
1201     HANDLE handle = get_handle( &args );
1202     ULONG count = get_ulong( &args );
1203     ULONG *previous = get_ptr( &args );
1204
1205     return NtReleaseSemaphore( handle, count, previous );
1206 }
1207
1208
1209 /**********************************************************************
1210  *           wow64_NtReplyWaitReceivePort
1211  */
1212 NTSTATUS WINAPI wow64_NtReplyWaitReceivePort( UINT *args )
1213 {
1214     HANDLE handle = get_handle( &args );
1215     ULONG *id = get_ptr( &args );
1216     LPC_MESSAGE *reply = get_ptr( &args );
1217     LPC_MESSAGE *msg = get_ptr( &args );
1218
1219     FIXME( "%p %p %p %p: stub\n", handle, id, reply, msg );
1220     return STATUS_NOT_IMPLEMENTED;
1221 }
1222
1223
1224 /**********************************************************************
1225  *           wow64_NtRequestWaitReplyPort
1226  */
1227 NTSTATUS WINAPI wow64_NtRequestWaitReplyPort( UINT *args )
1228 {
1229     HANDLE handle = get_handle( &args );
1230     LPC_MESSAGE *msg_in = get_ptr( &args );
1231     LPC_MESSAGE *msg_out = get_ptr( &args );
1232
1233     FIXME( "%p %p %p: stub\n", handle, msg_in, msg_out );
1234     return STATUS_NOT_IMPLEMENTED;
1235 }
1236
1237
1238 /**********************************************************************
1239  *           wow64_NtResetEvent
1240  */
1241 NTSTATUS WINAPI wow64_NtResetEvent( UINT *args )
1242 {
1243     HANDLE handle = get_handle( &args );
1244     LONG *prev_state = get_ptr( &args );
1245
1246     return NtResetEvent( handle, prev_state );
1247 }
1248
1249
1250 /**********************************************************************
1251  *           wow64_NtSecureConnectPort
1252  */
1253 NTSTATUS WINAPI wow64_NtSecureConnectPort( UINT *args )
1254 {
1255     ULONG *handle_ptr = get_ptr( &args );
1256     UNICODE_STRING32 *name32 = get_ptr( &args );
1257     SECURITY_QUALITY_OF_SERVICE *qos = get_ptr( &args );
1258     LPC_SECTION_WRITE *write = get_ptr( &args );
1259     SID *sid = get_ptr( &args );
1260     LPC_SECTION_READ *read = get_ptr( &args );
1261     ULONG *max_len = get_ptr( &args );
1262     void *info = get_ptr( &args );
1263     ULONG *info_len = get_ptr( &args );
1264
1265     FIXME( "%p %p %p %p %p %p %p %p %p: stub\n",
1266            handle_ptr, name32, qos, write, sid, read, max_len, info, info_len );
1267     return STATUS_NOT_IMPLEMENTED;
1268 }
1269
1270
1271 /**********************************************************************
1272  *           wow64_NtSetEvent
1273  */
1274 NTSTATUS WINAPI wow64_NtSetEvent( UINT *args )
1275 {
1276     HANDLE handle = get_handle( &args );
1277     LONG *prev_state = get_ptr( &args );
1278
1279     return NtSetEvent( handle, prev_state );
1280 }
1281
1282
1283 /**********************************************************************
1284  *           wow64_NtSetInformationDebugObject
1285  */
1286 NTSTATUS WINAPI wow64_NtSetInformationDebugObject( UINT *args )
1287 {
1288     HANDLE handle = get_handle( &args );
1289     DEBUGOBJECTINFOCLASS class = get_ulong( &args );
1290     void *ptr = get_ptr( &args );
1291     ULONG len = get_ulong( &args );
1292     ULONG *retlen = get_ptr( &args );
1293
1294     return NtSetInformationDebugObject( handle, class, ptr, len, retlen );
1295 }
1296
1297
1298 /**********************************************************************
1299  *           wow64_NtSetInformationJobObject
1300  */
1301 NTSTATUS WINAPI wow64_NtSetInformationJobObject( UINT *args )
1302 {
1303     HANDLE handle = get_handle( &args );
1304     JOBOBJECTINFOCLASS class = get_ulong( &args );
1305     void *ptr = get_ptr( &args );
1306     ULONG len = get_ulong( &args );
1307
1308     switch (class)
1309     {
1310     case JobObjectBasicLimitInformation:   /* JOBOBJECT_BASIC_LIMIT_INFORMATION */
1311         if (len == sizeof(JOBOBJECT_BASIC_LIMIT_INFORMATION32))
1312         {
1313             JOBOBJECT_BASIC_LIMIT_INFORMATION info;
1314
1315             return NtSetInformationJobObject( handle, class, job_basic_limit_info_32to64( &info, ptr ),
1316                                               sizeof(info) );
1317         }
1318         else return STATUS_INVALID_PARAMETER;
1319
1320     case JobObjectBasicUIRestrictions:
1321         FIXME( "unsupported class JobObjectBasicUIRestrictions\n" );
1322         return STATUS_SUCCESS;
1323
1324     case JobObjectAssociateCompletionPortInformation:   /* JOBOBJECT_ASSOCIATE_COMPLETION_PORT */
1325         if (len == sizeof(JOBOBJECT_ASSOCIATE_COMPLETION_PORT32))
1326         {
1327             JOBOBJECT_ASSOCIATE_COMPLETION_PORT32 *info32 = ptr;
1328             JOBOBJECT_ASSOCIATE_COMPLETION_PORT info;
1329
1330             info.CompletionKey  = ULongToPtr( info32->CompletionKey );
1331             info.CompletionPort = LongToHandle( info32->CompletionPort );
1332             return NtSetInformationJobObject( handle, class, &info, sizeof(info) );
1333         }
1334         else return STATUS_INVALID_PARAMETER;
1335
1336     case JobObjectExtendedLimitInformation:   /* JOBOBJECT_EXTENDED_LIMIT_INFORMATION */
1337         if (len == sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION32))
1338         {
1339             JOBOBJECT_EXTENDED_LIMIT_INFORMATION32 *info32 = ptr;
1340             JOBOBJECT_EXTENDED_LIMIT_INFORMATION info;
1341
1342             info.IoInfo                = info32->IoInfo;
1343             info.ProcessMemoryLimit    = info32->ProcessMemoryLimit;
1344             info.JobMemoryLimit        = info32->JobMemoryLimit;
1345             info.PeakProcessMemoryUsed = info32->PeakProcessMemoryUsed;
1346             info.PeakJobMemoryUsed     = info32->PeakJobMemoryUsed;
1347             return NtSetInformationJobObject( handle, class,
1348                                               job_basic_limit_info_32to64( &info.BasicLimitInformation,
1349                                                                            &info32->BasicLimitInformation ),
1350                                               sizeof(info) );
1351         }
1352         else return STATUS_INVALID_PARAMETER;
1353
1354     default:
1355         if (class >= MaxJobObjectInfoClass) return STATUS_INVALID_PARAMETER;
1356         FIXME( "unsupported class %u\n", class );
1357         return STATUS_NOT_IMPLEMENTED;
1358     }
1359 }
1360
1361
1362 /**********************************************************************
1363  *           wow64_NtSetInformationObject
1364  */
1365 NTSTATUS WINAPI wow64_NtSetInformationObject( UINT *args )
1366 {
1367     HANDLE handle = get_handle( &args );
1368     OBJECT_INFORMATION_CLASS class = get_ulong( &args );
1369     void *ptr = get_ptr( &args );
1370     ULONG len = get_ulong( &args );
1371
1372     switch (class)
1373     {
1374     case ObjectHandleFlagInformation:   /* OBJECT_HANDLE_FLAG_INFORMATION */
1375         return NtSetInformationObject( handle, class, ptr, len );
1376
1377     default:
1378         FIXME( "unsupported class %u\n", class );
1379         return STATUS_NOT_IMPLEMENTED;
1380     }
1381 }
1382
1383
1384 /**********************************************************************
1385  *           wow64_NtSetIoCompletion
1386  */
1387 NTSTATUS WINAPI wow64_NtSetIoCompletion( UINT *args )
1388 {
1389     HANDLE handle = get_handle( &args );
1390     ULONG_PTR key = get_ulong( &args );
1391     ULONG_PTR value = get_ulong( &args );
1392     NTSTATUS status = get_ulong( &args );
1393     SIZE_T count = get_ulong( &args );
1394
1395     return NtSetIoCompletion( handle, key, value, status, count );
1396 }
1397
1398
1399 /**********************************************************************
1400  *           wow64_NtSetTimer
1401  */
1402 NTSTATUS WINAPI wow64_NtSetTimer( UINT *args )
1403 {
1404     HANDLE handle = get_handle( &args );
1405     LARGE_INTEGER *when = get_ptr( &args );
1406     ULONG apc = get_ulong( &args );
1407     ULONG apc_param = get_ulong( &args );
1408     BOOLEAN resume = get_ulong( &args );
1409     ULONG period = get_ulong( &args );
1410     BOOLEAN *state = get_ptr( &args );
1411
1412     return NtSetTimer( handle, when, apc_32to64( apc ), apc_param_32to64( apc, apc_param ),
1413                        resume, period, state );
1414 }
1415
1416
1417 /**********************************************************************
1418  *           wow64_NtSetTimerResolution
1419  */
1420 NTSTATUS WINAPI wow64_NtSetTimerResolution( UINT *args )
1421 {
1422     ULONG res = get_ulong( &args );
1423     BOOLEAN set = get_ulong( &args );
1424     ULONG *current_res = get_ptr( &args );
1425
1426     return NtSetTimerResolution( res, set, current_res );
1427 }
1428
1429
1430 /**********************************************************************
1431  *           wow64_NtSignalAndWaitForSingleObject
1432  */
1433 NTSTATUS WINAPI wow64_NtSignalAndWaitForSingleObject( UINT *args )
1434 {
1435     HANDLE signal = get_handle( &args );
1436     HANDLE wait = get_handle( &args );
1437     BOOLEAN alertable = get_ulong( &args );
1438     const LARGE_INTEGER *timeout = get_ptr( &args );
1439
1440     return NtSignalAndWaitForSingleObject( signal, wait, alertable, timeout );
1441 }
1442
1443
1444 /**********************************************************************
1445  *           wow64_NtTerminateJobObject
1446  */
1447 NTSTATUS WINAPI wow64_NtTerminateJobObject( UINT *args )
1448 {
1449     HANDLE handle = get_handle( &args );
1450     NTSTATUS status = get_ulong( &args );
1451
1452     return NtTerminateJobObject( handle, status );
1453 }
1454
1455
1456 /**********************************************************************
1457  *           wow64_NtTestAlert
1458  */
1459 NTSTATUS WINAPI wow64_NtTestAlert( UINT *args )
1460 {
1461     return NtTestAlert();
1462 }
1463
1464
1465 /**********************************************************************
1466  *           wow64_NtTraceControl
1467  */
1468 NTSTATUS WINAPI wow64_NtTraceControl( UINT *args )
1469 {
1470     ULONG code = get_ulong( &args );
1471     void *inbuf = get_ptr( &args );
1472     ULONG inbuf_len = get_ulong( &args );
1473     void *outbuf = get_ptr( &args );
1474     ULONG outbuf_len = get_ulong( &args );
1475     ULONG *size = get_ptr( &args );
1476
1477     return NtTraceControl( code, inbuf, inbuf_len, outbuf, outbuf_len, size );
1478 }
1479
1480
1481 /**********************************************************************
1482  *           wow64_NtWaitForAlertByThreadId
1483  */
1484 NTSTATUS WINAPI wow64_NtWaitForAlertByThreadId( UINT *args )
1485 {
1486     const void *address = get_ptr( &args );
1487     const LARGE_INTEGER *timeout = get_ptr( &args );
1488
1489     return NtWaitForAlertByThreadId( address, timeout );
1490 }
1491
1492
1493 /* helper to wow64_NtWaitForDebugEvent; retrieve machine from PE image */
1494 static NTSTATUS get_image_machine( HANDLE handle, USHORT *machine )
1495 {
1496     IMAGE_DOS_HEADER dos_hdr;
1497     IMAGE_NT_HEADERS nt_hdr;
1498     IO_STATUS_BLOCK iosb;
1499     LARGE_INTEGER offset;
1500     FILE_POSITION_INFORMATION pos_info;
1501     NTSTATUS status;
1502
1503     offset.QuadPart = 0;
1504     status = NtReadFile( handle, NULL, NULL, NULL,
1505                          &iosb, &dos_hdr, sizeof(dos_hdr), &offset, NULL );
1506     if (!status)
1507     {
1508         offset.QuadPart = dos_hdr.e_lfanew;
1509         status = NtReadFile( handle, NULL, NULL, NULL, &iosb,
1510                              &nt_hdr, FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader), &offset, NULL );
1511         if (!status)
1512             *machine = nt_hdr.FileHeader.Machine;
1513         /* Reset file pos at beginning of file */
1514         pos_info.CurrentByteOffset.QuadPart = 0;
1515         NtSetInformationFile( handle, &iosb, &pos_info, sizeof(pos_info), FilePositionInformation );
1516     }
1517     return status;
1518 }
1519
1520 /* helper to wow64_NtWaitForDebugEvent; only pass debug events for current machine */
1521 static BOOL filter_out_state_change( HANDLE handle, DBGUI_WAIT_STATE_CHANGE *state )
1522 {
1523     BOOL filter_out;
1524
1525     switch (state->NewState)
1526     {
1527     case DbgLoadDllStateChange:
1528         filter_out = ((ULONG64)state->StateInfo.LoadDll.BaseOfDll >> 32) != 0;
1529         if (!filter_out)
1530         {
1531             USHORT machine;
1532             filter_out = !get_image_machine( state->StateInfo.LoadDll.FileHandle, &machine) && machine != current_machine;
1533         }
1534         break;
1535     case DbgUnloadDllStateChange:
1536         filter_out = ((ULONG_PTR)state->StateInfo.UnloadDll.BaseAddress >> 32) != 0;
1537         break;
1538     default:
1539         filter_out = FALSE;
1540         break;
1541     }
1542     if (filter_out)
1543     {
1544         if (state->NewState == DbgLoadDllStateChange)
1545             NtClose( state->StateInfo.LoadDll.FileHandle );
1546         NtDebugContinue( handle, &state->AppClientId, DBG_CONTINUE );
1547     }
1548     return filter_out;
1549 }
1550
1551
1552 /**********************************************************************
1553  *           wow64_NtWaitForDebugEvent
1554  */
1555 NTSTATUS WINAPI wow64_NtWaitForDebugEvent( UINT *args )
1556 {
1557     HANDLE handle = get_handle( &args );
1558     BOOLEAN alertable = get_ulong( &args );
1559     LARGE_INTEGER *timeout = get_ptr( &args );
1560     DBGUI_WAIT_STATE_CHANGE32 *state32 = get_ptr( &args );
1561
1562     ULONG i;
1563     DBGUI_WAIT_STATE_CHANGE state;
1564     NTSTATUS status;
1565
1566     do
1567     {
1568         status = NtWaitForDebugEvent( handle, alertable, timeout, &state );
1569     } while (!status && filter_out_state_change( handle, &state ));
1570
1571     if (!status)
1572     {
1573         state32->NewState = state.NewState;
1574         state32->AppClientId.UniqueProcess = HandleToULong( state.AppClientId.UniqueProcess );
1575         state32->AppClientId.UniqueThread = HandleToULong( state.AppClientId.UniqueThread );
1576         switch (state.NewState)
1577         {
1578 #define COPY_ULONG(field) state32->StateInfo.field = state.StateInfo.field
1579 #define COPY_PTR(field)   state32->StateInfo.field = PtrToUlong( state.StateInfo.field )
1580         case DbgCreateThreadStateChange:
1581             COPY_PTR( CreateThread.HandleToThread );
1582             COPY_PTR( CreateThread.NewThread.StartAddress );
1583             COPY_ULONG( CreateThread.NewThread.SubSystemKey );
1584             break;
1585         case DbgCreateProcessStateChange:
1586             COPY_PTR( CreateProcessInfo.HandleToProcess );
1587             COPY_PTR( CreateProcessInfo.HandleToThread );
1588             COPY_PTR( CreateProcessInfo.NewProcess.FileHandle );
1589             COPY_PTR( CreateProcessInfo.NewProcess.BaseOfImage );
1590             COPY_PTR( CreateProcessInfo.NewProcess.InitialThread.StartAddress );
1591             COPY_ULONG( CreateProcessInfo.NewProcess.InitialThread.SubSystemKey );
1592             COPY_ULONG( CreateProcessInfo.NewProcess.DebugInfoFileOffset );
1593             COPY_ULONG( CreateProcessInfo.NewProcess.DebugInfoSize );
1594             break;
1595         case DbgExitThreadStateChange:
1596         case DbgExitProcessStateChange:
1597             COPY_ULONG( ExitThread.ExitStatus );
1598             break;
1599         case DbgExceptionStateChange:
1600         case DbgBreakpointStateChange:
1601         case DbgSingleStepStateChange:
1602             COPY_ULONG( Exception.FirstChance );
1603             COPY_ULONG( Exception.ExceptionRecord.ExceptionCode );
1604             COPY_ULONG( Exception.ExceptionRecord.ExceptionFlags );
1605             COPY_ULONG( Exception.ExceptionRecord.NumberParameters );
1606             COPY_PTR( Exception.ExceptionRecord.ExceptionRecord );
1607             COPY_PTR( Exception.ExceptionRecord.ExceptionAddress );
1608             for (i = 0; i < state.StateInfo.Exception.ExceptionRecord.NumberParameters; i++)
1609                 COPY_ULONG( Exception.ExceptionRecord.ExceptionInformation[i] );
1610             break;
1611         case DbgLoadDllStateChange:
1612             COPY_PTR( LoadDll.FileHandle );
1613             COPY_PTR( LoadDll.BaseOfDll );
1614             COPY_ULONG( LoadDll.DebugInfoFileOffset );
1615             COPY_ULONG( LoadDll.DebugInfoSize );
1616             COPY_PTR( LoadDll.NamePointer );
1617             break;
1618         case DbgUnloadDllStateChange:
1619             COPY_PTR( UnloadDll.BaseAddress );
1620             break;
1621         default:
1622             break;
1623         }
1624 #undef COPY_ULONG
1625 #undef COPY_PTR
1626     }
1627     return status;
1628 }
1629
1630
1631 /**********************************************************************
1632  *           wow64_NtWaitForKeyedEvent
1633  */
1634 NTSTATUS WINAPI wow64_NtWaitForKeyedEvent( UINT *args )
1635 {
1636     HANDLE handle = get_handle( &args );
1637     const void *key = get_ptr( &args );
1638     BOOLEAN alertable = get_ulong( &args );
1639     const LARGE_INTEGER *timeout = get_ptr( &args );
1640
1641     return NtWaitForKeyedEvent( handle, key, alertable, timeout );
1642 }
1643
1644
1645 /**********************************************************************
1646  *           wow64_NtWaitForMultipleObjects
1647  */
1648 NTSTATUS WINAPI wow64_NtWaitForMultipleObjects( UINT *args )
1649 {
1650     DWORD count = get_ulong( &args );
1651     LONG *handles_ptr = get_ptr( &args );
1652     BOOLEAN wait_any = get_ulong( &args );
1653     BOOLEAN alertable = get_ulong( &args );
1654     const LARGE_INTEGER *timeout = get_ptr( &args );
1655
1656     HANDLE handles[MAXIMUM_WAIT_OBJECTS];
1657     DWORD i;
1658
1659     for (i = 0; i < count && i < MAXIMUM_WAIT_OBJECTS; i++) handles[i] = LongToHandle( handles_ptr[i] );
1660     return NtWaitForMultipleObjects( count, handles, wait_any, alertable, timeout );
1661 }
1662
1663
1664 /**********************************************************************
1665  *           wow64_NtWaitForSingleObject
1666  */
1667 NTSTATUS WINAPI wow64_NtWaitForSingleObject( UINT *args )
1668 {
1669     HANDLE handle = get_handle( &args );
1670     BOOLEAN alertable = get_ulong( &args );
1671     const LARGE_INTEGER *timeout = get_ptr( &args );
1672
1673     return NtWaitForSingleObject( handle, alertable, timeout );
1674 }
1675
1676
1677 /**********************************************************************
1678  *           wow64_NtYieldExecution
1679  */
1680 NTSTATUS WINAPI wow64_NtYieldExecution( UINT *args )
1681 {
1682     return NtYieldExecution();
1683 }
1684
1685
1686 /**********************************************************************
1687  *           wow64_NtCreateTransaction
1688  */
1689 NTSTATUS WINAPI wow64_NtCreateTransaction( UINT *args )
1690 {
1691     ULONG *handle_ptr = get_ptr( &args );
1692     ACCESS_MASK access = get_ulong( &args );
1693     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
1694     GUID *guid = get_ptr( &args );
1695     HANDLE tm = get_handle( &args );
1696     ULONG options = get_ulong( &args );
1697     ULONG isol_level = get_ulong( &args );
1698     ULONG isol_flags = get_ulong( &args );
1699     LARGE_INTEGER *timeout = get_ptr( &args );
1700     UNICODE_STRING32 *desc32 = get_ptr( &args );
1701
1702     struct object_attr64 attr;
1703     UNICODE_STRING desc;
1704     HANDLE handle = 0;
1705     NTSTATUS status;
1706
1707     *handle_ptr = 0;
1708     status = NtCreateTransaction( &handle, access, objattr_32to64( &attr, attr32 ), guid, tm, options,
1709             isol_level, isol_flags, timeout, unicode_str_32to64( &desc, desc32 ));
1710     put_handle( handle_ptr, handle );
1711
1712     return status;
1713 }
1714
1715
1716 /**********************************************************************
1717  *           wow64_NtCommitTransaction
1718  */
1719 NTSTATUS WINAPI wow64_NtCommitTransaction( UINT *args )
1720 {
1721     HANDLE handle = get_handle( &args );
1722     BOOLEAN wait = get_ulong( &args );
1723
1724     return NtCommitTransaction( handle, wait );
1725 }
1726
1727
1728 /**********************************************************************
1729  *           wow64_NtRollbackTransaction
1730  */
1731 NTSTATUS WINAPI wow64_NtRollbackTransaction( UINT *args )
1732 {
1733     HANDLE handle = get_handle( &args );
1734     BOOLEAN wait = get_ulong( &args );
1735
1736     return NtRollbackTransaction( handle, wait );
1737 }