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 %u %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_NtClearPowerRequest
 174  */
 175 NTSTATUS WINAPI wow64_NtClearPowerRequest( UINT *args )
 176 {
 177     HANDLE handle = get_handle( &args );
 178     POWER_REQUEST_TYPE type = get_ulong( &args );
 179
 180     return NtClearPowerRequest( handle, type );
 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_NtCreatePowerRequest
 385  */
 386 NTSTATUS WINAPI wow64_NtCreatePowerRequest( UINT *args )
 387 {
 388     ULONG *handle_ptr = get_ptr( &args );
 389     COUNTED_REASON_CONTEXT *context = get_ptr( &args );
 390
 391     FIXME( "%p %p: stub\n", handle_ptr, context );
 392     return STATUS_NOT_IMPLEMENTED;
 393 }
 394
 395
 396 /**********************************************************************
 397  *           wow64_NtCreateSection
 398  */
 399 NTSTATUS WINAPI wow64_NtCreateSection( UINT *args )
 400 {
 401     ULONG *handle_ptr = get_ptr( &args );
 402     ACCESS_MASK access = get_ulong( &args );
 403     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 404     const LARGE_INTEGER *size = get_ptr( &args );
 405     ULONG protect = get_ulong( &args );
 406     ULONG flags = get_ulong( &args );
 407     HANDLE file = get_handle( &args );
 408
 409     struct object_attr64 attr;
 410     HANDLE handle = 0;
 411     NTSTATUS status;
 412
 413     *handle_ptr = 0;
 414     status = NtCreateSection( &handle, access, objattr_32to64( &attr, attr32 ), size, protect, flags, file );
 415     put_handle( handle_ptr, handle );
 416     return status;
 417 }
 418
 419
 420 /**********************************************************************
 421  *           wow64_NtCreateSemaphore
 422  */
 423 NTSTATUS WINAPI wow64_NtCreateSemaphore( UINT *args )
 424 {
 425     ULONG *handle_ptr = get_ptr( &args );
 426     ACCESS_MASK access = get_ulong( &args );
 427     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 428     LONG initial = get_ulong( &args );
 429     LONG max = get_ulong( &args );
 430
 431     struct object_attr64 attr;
 432     HANDLE handle = 0;
 433     NTSTATUS status;
 434
 435     *handle_ptr = 0;
 436     status = NtCreateSemaphore( &handle, access, objattr_32to64( &attr, attr32 ), initial, max );
 437     put_handle( handle_ptr, handle );
 438     return status;
 439 }
 440
 441
 442 /**********************************************************************
 443  *           wow64_NtCreateSymbolicLinkObject
 444  */
 445 NTSTATUS WINAPI wow64_NtCreateSymbolicLinkObject( UINT *args )
 446 {
 447     ULONG *handle_ptr = get_ptr( &args );
 448     ACCESS_MASK access = get_ulong( &args );
 449     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 450     UNICODE_STRING32 *target32 = get_ptr( &args );
 451
 452     struct object_attr64 attr;
 453     UNICODE_STRING target;
 454     HANDLE handle = 0;
 455     NTSTATUS status;
 456
 457     *handle_ptr = 0;
 458     status = NtCreateSymbolicLinkObject( &handle, access, objattr_32to64( &attr, attr32 ),
 459                                          unicode_str_32to64( &target, target32 ));
 460     put_handle( handle_ptr, handle );
 461     return status;
 462 }
 463
 464
 465 /**********************************************************************
 466  *           wow64_NtCreateTimer
 467  */
 468 NTSTATUS WINAPI wow64_NtCreateTimer( UINT *args )
 469 {
 470     ULONG *handle_ptr = get_ptr( &args );
 471     ACCESS_MASK access = get_ulong( &args );
 472     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 473     TIMER_TYPE type = get_ulong( &args );
 474
 475     struct object_attr64 attr;
 476     HANDLE handle = 0;
 477     NTSTATUS status;
 478
 479     *handle_ptr = 0;
 480     status = NtCreateTimer( &handle, access, objattr_32to64( &attr, attr32 ), type );
 481     put_handle( handle_ptr, handle );
 482     return status;
 483 }
 484
 485
 486 /**********************************************************************
 487  *           wow64_NtDebugContinue
 488  */
 489 NTSTATUS WINAPI wow64_NtDebugContinue( UINT *args )
 490 {
 491     HANDLE handle = get_handle( &args );
 492     CLIENT_ID32 *id32 = get_ptr( &args );
 493     NTSTATUS status = get_ulong( &args );
 494
 495     CLIENT_ID id;
 496
 497     return NtDebugContinue( handle, client_id_32to64( &id, id32 ), status );
 498 }
 499
 500
 501 /**********************************************************************
 502  *           wow64_NtDelayExecution
 503  */
 504 NTSTATUS WINAPI wow64_NtDelayExecution( UINT *args )
 505 {
 506     BOOLEAN alertable = get_ulong( &args );
 507     const LARGE_INTEGER *timeout = get_ptr( &args );
 508
 509     return NtDelayExecution( alertable, timeout );
 510 }
 511
 512
 513 /**********************************************************************
 514  *           wow64_NtDuplicateObject
 515  */
 516 NTSTATUS WINAPI wow64_NtDuplicateObject( UINT *args )
 517 {
 518     HANDLE source_process = get_handle( &args );
 519     HANDLE source_handle = get_handle( &args );
 520     HANDLE dest_process = get_handle( &args );
 521     ULONG *handle_ptr = get_ptr( &args );
 522     ACCESS_MASK access = get_ulong( &args );
 523     ULONG attributes = get_ulong( &args );
 524     ULONG options = get_ulong( &args );
 525
 526     HANDLE handle = 0;
 527     NTSTATUS status;
 528
 529     if (handle_ptr) *handle_ptr = 0;
 530     status = NtDuplicateObject( source_process, source_handle, dest_process, &handle,
 531                                 access, attributes, options );
 532     if (handle_ptr) put_handle( handle_ptr, handle );
 533     return status;
 534 }
 535
 536
 537 /**********************************************************************
 538  *           wow64_NtListenPort
 539  */
 540 NTSTATUS WINAPI wow64_NtListenPort( UINT *args )
 541 {
 542     HANDLE handle = get_handle( &args );
 543     LPC_MESSAGE *msg = get_ptr( &args );
 544
 545     FIXME( "%p %p: stub\n", handle, msg );
 546     return STATUS_NOT_IMPLEMENTED;
 547 }
 548
 549
 550 /**********************************************************************
 551  *           wow64_NtMakeTemporaryObject
 552  */
 553 NTSTATUS WINAPI wow64_NtMakeTemporaryObject( UINT *args )
 554 {
 555     HANDLE handle = get_handle( &args );
 556
 557     return NtMakeTemporaryObject( handle );
 558 }
 559
 560
 561 /**********************************************************************
 562  *           wow64_NtOpenDirectoryObject
 563  */
 564 NTSTATUS WINAPI wow64_NtOpenDirectoryObject( UINT *args )
 565 {
 566     ULONG *handle_ptr = get_ptr( &args );
 567     ACCESS_MASK access = get_ulong( &args );
 568     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 569
 570     struct object_attr64 attr;
 571     HANDLE handle = 0;
 572     NTSTATUS status;
 573
 574     *handle_ptr = 0;
 575     status = NtOpenDirectoryObject( &handle, access, objattr_32to64( &attr, attr32 ));
 576     put_handle( handle_ptr, handle );
 577     return status;
 578 }
 579
 580
 581 /**********************************************************************
 582  *           wow64_NtOpenEvent
 583  */
 584 NTSTATUS WINAPI wow64_NtOpenEvent( UINT *args )
 585 {
 586     ULONG *handle_ptr = get_ptr( &args );
 587     ACCESS_MASK access = get_ulong( &args );
 588     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 589
 590     struct object_attr64 attr;
 591     HANDLE handle = 0;
 592     NTSTATUS status;
 593
 594     *handle_ptr = 0;
 595     status = NtOpenEvent( &handle, access, objattr_32to64( &attr, attr32 ));
 596     put_handle( handle_ptr, handle );
 597     return status;
 598 }
 599
 600
 601 /**********************************************************************
 602  *           wow64_NtOpenIoCompletion
 603  */
 604 NTSTATUS WINAPI wow64_NtOpenIoCompletion( UINT *args )
 605 {
 606     ULONG *handle_ptr = get_ptr( &args );
 607     ACCESS_MASK access = get_ulong( &args );
 608     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 609
 610     struct object_attr64 attr;
 611     HANDLE handle = 0;
 612     NTSTATUS status;
 613
 614     *handle_ptr = 0;
 615     status = NtOpenIoCompletion( &handle, access, objattr_32to64( &attr, attr32 ));
 616     put_handle( handle_ptr, handle );
 617     return status;
 618 }
 619
 620
 621 /**********************************************************************
 622  *           wow64_NtOpenJobObject
 623  */
 624 NTSTATUS WINAPI wow64_NtOpenJobObject( UINT *args )
 625 {
 626     ULONG *handle_ptr = get_ptr( &args );
 627     ACCESS_MASK access = get_ulong( &args );
 628     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 629
 630     struct object_attr64 attr;
 631     HANDLE handle = 0;
 632     NTSTATUS status;
 633
 634     *handle_ptr = 0;
 635     status = NtOpenJobObject( &handle, access, objattr_32to64( &attr, attr32 ));
 636     put_handle( handle_ptr, handle );
 637     return status;
 638 }
 639
 640
 641 /**********************************************************************
 642  *           wow64_NtOpenKeyedEvent
 643  */
 644 NTSTATUS WINAPI wow64_NtOpenKeyedEvent( UINT *args )
 645 {
 646     ULONG *handle_ptr = get_ptr( &args );
 647     ACCESS_MASK access = get_ulong( &args );
 648     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 649
 650     struct object_attr64 attr;
 651     HANDLE handle = 0;
 652     NTSTATUS status;
 653
 654     *handle_ptr = 0;
 655     status = NtOpenKeyedEvent( &handle, access, objattr_32to64( &attr, attr32 ));
 656     put_handle( handle_ptr, handle );
 657     return status;
 658 }
 659
 660
 661 /**********************************************************************
 662  *           wow64_NtOpenMutant
 663  */
 664 NTSTATUS WINAPI wow64_NtOpenMutant( UINT *args )
 665 {
 666     ULONG *handle_ptr = get_ptr( &args );
 667     ACCESS_MASK access = get_ulong( &args );
 668     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 669
 670     struct object_attr64 attr;
 671     HANDLE handle = 0;
 672     NTSTATUS status;
 673
 674     *handle_ptr = 0;
 675     status = NtOpenMutant( &handle, access, objattr_32to64( &attr, attr32 ));
 676     put_handle( handle_ptr, handle );
 677     return status;
 678 }
 679
 680
 681 /**********************************************************************
 682  *           wow64_NtOpenSection
 683  */
 684 NTSTATUS WINAPI wow64_NtOpenSection( UINT *args )
 685 {
 686     ULONG *handle_ptr = get_ptr( &args );
 687     ACCESS_MASK access = get_ulong( &args );
 688     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 689
 690     struct object_attr64 attr;
 691     HANDLE handle = 0;
 692     NTSTATUS status;
 693
 694     *handle_ptr = 0;
 695     status = NtOpenSection( &handle, access, objattr_32to64( &attr, attr32 ));
 696     put_handle( handle_ptr, handle );
 697     return status;
 698 }
 699
 700
 701 /**********************************************************************
 702  *           wow64_NtOpenSemaphore
 703  */
 704 NTSTATUS WINAPI wow64_NtOpenSemaphore( UINT *args )
 705 {
 706     ULONG *handle_ptr = get_ptr( &args );
 707     ACCESS_MASK access = get_ulong( &args );
 708     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 709
 710     struct object_attr64 attr;
 711     HANDLE handle = 0;
 712     NTSTATUS status;
 713
 714     *handle_ptr = 0;
 715     status = NtOpenSemaphore( &handle, access, objattr_32to64( &attr, attr32 ));
 716     put_handle( handle_ptr, handle );
 717     return status;
 718 }
 719
 720
 721 /**********************************************************************
 722  *           wow64_NtOpenSymbolicLinkObject
 723  */
 724 NTSTATUS WINAPI wow64_NtOpenSymbolicLinkObject( UINT *args )
 725 {
 726     ULONG *handle_ptr = get_ptr( &args );
 727     ACCESS_MASK access = get_ulong( &args );
 728     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 729
 730     struct object_attr64 attr;
 731     HANDLE handle = 0;
 732     NTSTATUS status;
 733
 734     *handle_ptr = 0;
 735     status = NtOpenSymbolicLinkObject( &handle, access, objattr_32to64( &attr, attr32 ));
 736     put_handle( handle_ptr, handle );
 737     return status;
 738 }
 739
 740
 741 /**********************************************************************
 742  *           wow64_NtOpenTimer
 743  */
 744 NTSTATUS WINAPI wow64_NtOpenTimer( UINT *args )
 745 {
 746     ULONG *handle_ptr = get_ptr( &args );
 747     ACCESS_MASK access = get_ulong( &args );
 748     OBJECT_ATTRIBUTES32 *attr32 = get_ptr( &args );
 749
 750     struct object_attr64 attr;
 751     HANDLE handle = 0;
 752     NTSTATUS status;
 753
 754     *handle_ptr = 0;
 755     status = NtOpenTimer( &handle, access, objattr_32to64( &attr, attr32 ));
 756     put_handle( handle_ptr, handle );
 757     return status;
 758 }
 759
 760
 761 /**********************************************************************
 762  *           wow64_NtPulseEvent
 763  */
 764 NTSTATUS WINAPI wow64_NtPulseEvent( UINT *args )
 765 {
 766     HANDLE handle = get_handle( &args );
 767     LONG *prev_state = get_ptr( &args );
 768
 769     return NtPulseEvent( handle, prev_state );
 770 }
 771
 772
 773 /**********************************************************************
 774  *           wow64_NtQueryDirectoryObject
 775  */
 776 NTSTATUS WINAPI wow64_NtQueryDirectoryObject( UINT *args )
 777 {
 778     HANDLE handle = get_handle( &args );
 779     DIRECTORY_BASIC_INFORMATION32 *info32 = get_ptr( &args );
 780     ULONG size32 = get_ulong( &args );
 781     BOOLEAN single_entry = get_ulong( &args );
 782     BOOLEAN restart = get_ulong( &args );
 783     ULONG *context = get_ptr( &args );
 784     ULONG *retlen = get_ptr( &args );
 785
 786     NTSTATUS status;
 787     DIRECTORY_BASIC_INFORMATION *info;
 788     ULONG size = size32 + sizeof(*info) - sizeof(*info32);
 789
 790     if (!single_entry) FIXME( "not implemented\n" );
 791     info = Wow64AllocateTemp( size );
 792     status = NtQueryDirectoryObject( handle, info, size, single_entry, restart, context, NULL );
 793     if (!status)
 794     {
 795         info32->ObjectName.Buffer            = PtrToUlong( info32 + 1 );
 796         info32->ObjectName.Length            = info->ObjectName.Length;
 797         info32->ObjectName.MaximumLength     = info->ObjectName.MaximumLength;
 798         info32->ObjectTypeName.Buffer        = info32->ObjectName.Buffer + info->ObjectName.MaximumLength;
 799         info32->ObjectTypeName.Length        = info->ObjectTypeName.Length;
 800         info32->ObjectTypeName.MaximumLength = info->ObjectTypeName.MaximumLength;
 801         size = info->ObjectName.MaximumLength + info->ObjectTypeName.MaximumLength;
 802         memcpy( info32 + 1, info + 1, size );
 803         if (retlen) *retlen = sizeof(*info32) + size;
 804     }
 805     return status;
 806 }
 807
 808
 809 /**********************************************************************
 810  *           wow64_NtQueryEvent
 811  */
 812 NTSTATUS WINAPI wow64_NtQueryEvent( UINT *args )
 813 {
 814     HANDLE handle = get_handle( &args );
 815     EVENT_INFORMATION_CLASS class = get_ulong( &args );
 816     void *info = get_ptr( &args );
 817     ULONG len = get_ulong( &args );
 818     ULONG *retlen = get_ptr( &args );
 819
 820     return NtQueryEvent( handle, class, info, len, retlen );
 821 }
 822
 823
 824 /**********************************************************************
 825  *           wow64_NtQueryInformationJobObject
 826  */
 827 NTSTATUS WINAPI wow64_NtQueryInformationJobObject( UINT *args )
 828 {
 829     HANDLE handle = get_handle( &args );
 830     JOBOBJECTINFOCLASS class = get_ulong( &args );
 831     void *ptr = get_ptr( &args );
 832     ULONG len = get_ulong( &args );
 833     ULONG *retlen = get_ptr( &args );
 834
 835     NTSTATUS status;
 836
 837     switch (class)
 838     {
 839     case JobObjectBasicAccountingInformation:   /* JOBOBJECT_BASIC_ACCOUNTING_INFORMATION */
 840         return NtQueryInformationJobObject( handle, class, ptr, len, retlen );
 841
 842     case JobObjectBasicLimitInformation:   /* JOBOBJECT_BASIC_LIMIT_INFORMATION */
 843         if (len >= sizeof(JOBOBJECT_BASIC_LIMIT_INFORMATION32))
 844         {
 845             JOBOBJECT_BASIC_LIMIT_INFORMATION32 *info32 = ptr;
 846             JOBOBJECT_BASIC_LIMIT_INFORMATION info;
 847
 848             status = NtQueryInformationJobObject( handle, class, &info, sizeof(info), NULL );
 849             if (!status) put_job_basic_limit_info( info32, &info );
 850             if (retlen) *retlen = sizeof(*info32);
 851             return status;
 852         }
 853         else return STATUS_INFO_LENGTH_MISMATCH;
 854
 855     case JobObjectBasicProcessIdList:   /* JOBOBJECT_BASIC_PROCESS_ID_LIST */
 856         if (len >= sizeof(JOBOBJECT_BASIC_PROCESS_ID_LIST32))
 857         {
 858             JOBOBJECT_BASIC_PROCESS_ID_LIST32 *info32 = ptr;
 859             JOBOBJECT_BASIC_PROCESS_ID_LIST *info;
 860             ULONG i, count, size;
 861
 862             count = (len - offsetof( JOBOBJECT_BASIC_PROCESS_ID_LIST32, ProcessIdList )) / sizeof(info32->ProcessIdList[0]);
 863             size = offsetof( JOBOBJECT_BASIC_PROCESS_ID_LIST, ProcessIdList[count] );
 864             info = Wow64AllocateTemp( size );
 865             status = NtQueryInformationJobObject( handle, class, info, size, NULL );
 866             if (!status)
 867             {
 868                 info32->NumberOfAssignedProcesses = info->NumberOfAssignedProcesses;
 869                 info32->NumberOfProcessIdsInList  = info->NumberOfProcessIdsInList;
 870                 for (i = 0; i < info->NumberOfProcessIdsInList; i++)
 871                     info32->ProcessIdList[i] = info->ProcessIdList[i];
 872                 if (retlen) *retlen = offsetof( JOBOBJECT_BASIC_PROCESS_ID_LIST32, ProcessIdList[i] );
 873             }
 874             return status;
 875         }
 876         else return STATUS_INFO_LENGTH_MISMATCH;
 877
 878     case JobObjectExtendedLimitInformation:   /* JOBOBJECT_EXTENDED_LIMIT_INFORMATION */
 879         if (len >= sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION32))
 880         {
 881             JOBOBJECT_EXTENDED_LIMIT_INFORMATION32 *info32 = ptr;
 882             JOBOBJECT_EXTENDED_LIMIT_INFORMATION info;
 883
 884             status = NtQueryInformationJobObject( handle, class, &info, sizeof(info), NULL );
 885             if (!status)
 886             {
 887                 put_job_basic_limit_info( &info32->BasicLimitInformation, &info.BasicLimitInformation );
 888                 info32->IoInfo                = info.IoInfo;
 889                 info32->ProcessMemoryLimit    = info.ProcessMemoryLimit;
 890                 info32->JobMemoryLimit        = info.JobMemoryLimit;
 891                 info32->PeakProcessMemoryUsed = info.PeakProcessMemoryUsed;
 892                 info32->PeakJobMemoryUsed     = info.PeakJobMemoryUsed;
 893             }
 894             if (retlen) *retlen = sizeof(*info32);
 895             return status;
 896         }
 897         else return STATUS_INFO_LENGTH_MISMATCH;
 898
 899     default:
 900         if (class >= MaxJobObjectInfoClass) return STATUS_INVALID_PARAMETER;
 901         FIXME( "unsupported class %u\n", class );
 902         return STATUS_NOT_IMPLEMENTED;
 903     }
 904 }
 905
 906
 907 /**********************************************************************
 908  *           wow64_NtQueryIoCompletion
 909  */
 910 NTSTATUS WINAPI wow64_NtQueryIoCompletion( UINT *args )
 911 {
 912     HANDLE handle = get_handle( &args );
 913     IO_COMPLETION_INFORMATION_CLASS class = get_ulong( &args );
 914     void *info = get_ptr( &args );
 915     ULONG len = get_ulong( &args );
 916     ULONG *retlen = get_ptr( &args );
 917
 918     return NtQueryIoCompletion( handle, class, info, len, retlen );
 919 }
 920
 921
 922 /**********************************************************************
 923  *           wow64_NtQueryMutant
 924  */
 925 NTSTATUS WINAPI wow64_NtQueryMutant( UINT *args )
 926 {
 927     HANDLE handle = get_handle( &args );
 928     MUTANT_INFORMATION_CLASS class = get_ulong( &args );
 929     void *info = get_ptr( &args );
 930     ULONG len = get_ulong( &args );
 931     ULONG *retlen = get_ptr( &args );
 932
 933     return NtQueryMutant( handle, class, info, len, retlen );
 934 }
 935
 936
 937 /**********************************************************************
 938  *           wow64_NtQueryObject
 939  */
 940 NTSTATUS WINAPI wow64_NtQueryObject( UINT *args )
 941 {
 942     HANDLE handle = get_handle( &args );
 943     OBJECT_INFORMATION_CLASS class = get_ulong( &args );
 944     void *ptr = get_ptr( &args );
 945     ULONG len = get_ulong( &args );
 946     ULONG *retlen = get_ptr( &args );
 947
 948     NTSTATUS status;
 949     ULONG ret_size;
 950
 951     switch (class)
 952     {
 953     case ObjectBasicInformation:   /* OBJECT_BASIC_INFORMATION */
 954     case ObjectDataInformation:   /* OBJECT_DATA_INFORMATION */
 955         return NtQueryObject( handle, class, ptr, len, retlen );
 956
 957     case ObjectNameInformation:   /* OBJECT_NAME_INFORMATION */
 958     {
 959         ULONG size = len + sizeof(OBJECT_NAME_INFORMATION) - sizeof(OBJECT_NAME_INFORMATION32);
 960         OBJECT_NAME_INFORMATION32 *info32 = ptr;
 961         OBJECT_NAME_INFORMATION *info = Wow64AllocateTemp( size );
 962
 963         if (!(status = NtQueryObject( handle, class, info, size, &ret_size )))
 964         {
 965             if (len >= sizeof(*info32) + info->Name.MaximumLength)
 966             {
 967                 if (info->Name.Length)
 968                 {
 969                     memcpy( info32 + 1, info->Name.Buffer, info->Name.Length + sizeof(WCHAR) );
 970                     info32->Name.Length = info->Name.Length;
 971                     info32->Name.MaximumLength = info->Name.Length + sizeof(WCHAR);
 972                     info32->Name.Buffer = PtrToUlong( info32 + 1 );
 973                 }
 974                 else memset( &info32->Name, 0, sizeof(info32->Name) );
 975             }
 976             else status = STATUS_INFO_LENGTH_MISMATCH;
 977             if (retlen) *retlen = sizeof(*info32) + info->Name.MaximumLength;
 978         }
 979         else if (status == STATUS_INFO_LENGTH_MISMATCH || status == STATUS_BUFFER_OVERFLOW)
 980         {
 981             if (retlen) *retlen = ret_size - sizeof(*info) + sizeof(*info32);
 982         }
 983         return status;
 984     }
 985
 986     case ObjectTypeInformation:   /* OBJECT_TYPE_INFORMATION */
 987     {
 988         ULONG_PTR buffer[(sizeof(OBJECT_TYPE_INFORMATION) + 64) / sizeof(ULONG_PTR)];
 989         OBJECT_TYPE_INFORMATION *info = (OBJECT_TYPE_INFORMATION *)buffer;
 990         OBJECT_TYPE_INFORMATION32 *info32 = ptr;
 991
 992         if (!(status = NtQueryObject( handle, class, info, sizeof(buffer), NULL )))
 993         {
 994             if (len >= sizeof(*info32) + info->TypeName.MaximumLength)
 995                 put_object_type_info( info32, info );
 996             else
 997                 status = STATUS_INFO_LENGTH_MISMATCH;
 998             if (retlen) *retlen = sizeof(*info32) + info->TypeName.Length + sizeof(WCHAR);
 999         }
1000         return status;
1001     }
1002
1003     case ObjectTypesInformation:   /* OBJECT_TYPES_INFORMATION */
1004     {
1005         OBJECT_TYPES_INFORMATION *info, *info32 = ptr;
1006         /* assume at most 32 types, with an average 16-char name */
1007         ULONG ret_size, size = 32 * (sizeof(OBJECT_TYPE_INFORMATION) + 16 * sizeof(WCHAR));
1008
1009         info = Wow64AllocateTemp( size );
1010         if (!(status = NtQueryObject( handle, class, info, size, &ret_size )))
1011         {
1012             OBJECT_TYPE_INFORMATION *type;
1013             OBJECT_TYPE_INFORMATION32 *type32;
1014             ULONG align = TYPE_ALIGNMENT( OBJECT_TYPE_INFORMATION ) - 1;
1015             ULONG align32 = TYPE_ALIGNMENT( OBJECT_TYPE_INFORMATION32 ) - 1;
1016             ULONG i, pos = (sizeof(*info) + align) & ~align, pos32 = (sizeof(*info32) + align32) & ~align32;
1017
1018             if (pos32 <= len) info32->NumberOfTypes = info->NumberOfTypes;
1019             for (i = 0; i < info->NumberOfTypes; i++)
1020             {
1021                 type = (OBJECT_TYPE_INFORMATION *)((char *)info + pos);
1022                 type32 = (OBJECT_TYPE_INFORMATION32 *)((char *)ptr + pos32);
1023                 pos += sizeof(*type) + ((type->TypeName.MaximumLength + align) & ~align);
1024                 pos32 += sizeof(*type32) + ((type->TypeName.MaximumLength + align32) & ~align32);
1025                 if (pos32 <= len) put_object_type_info( type32, type );
1026             }
1027             if (pos32 > len) status = STATUS_INFO_LENGTH_MISMATCH;
1028             if (retlen) *retlen = pos32;
1029         }
1030         return status;
1031     }
1032
1033     default:
1034         FIXME( "unsupported class %u\n", class );
1035         return STATUS_NOT_IMPLEMENTED;
1036     }
1037 }
1038
1039
1040 /**********************************************************************
1041  *           wow64_NtQueryPerformanceCounter
1042  */
1043 NTSTATUS WINAPI wow64_NtQueryPerformanceCounter( UINT *args )
1044 {
1045     LARGE_INTEGER *counter = get_ptr( &args );
1046     LARGE_INTEGER *frequency = get_ptr( &args );
1047
1048     return NtQueryPerformanceCounter( counter, frequency );
1049 }
1050
1051
1052 /**********************************************************************
1053  *           wow64_NtQuerySection
1054  */
1055 NTSTATUS WINAPI wow64_NtQuerySection( UINT *args )
1056 {
1057     HANDLE handle = get_handle( &args );
1058     SECTION_INFORMATION_CLASS class = get_ulong( &args );
1059     void *ptr = get_ptr( &args );
1060     SIZE_T size = get_ulong( &args );
1061     ULONG *ret_ptr = get_ptr( &args );
1062
1063     NTSTATUS status;
1064     SIZE_T ret_size = 0;
1065
1066     switch (class)
1067     {
1068     case SectionBasicInformation:
1069     {
1070         SECTION_BASIC_INFORMATION info;
1071         SECTION_BASIC_INFORMATION32 *info32 = ptr;
1072
1073         if (size < sizeof(*info32)) return STATUS_INFO_LENGTH_MISMATCH;
1074         if (!(status = NtQuerySection( handle, class, &info, sizeof(info), &ret_size )))
1075         {
1076             info32->BaseAddress = PtrToUlong( info.BaseAddress );
1077             info32->Attributes  = info.Attributes;
1078             info32->Size        = info.Size;
1079             ret_size = sizeof(*info32);
1080         }
1081         break;
1082     }
1083     case SectionImageInformation:
1084     {
1085         SECTION_IMAGE_INFORMATION info;
1086         SECTION_IMAGE_INFORMATION32 *info32 = ptr;
1087
1088         if (size < sizeof(*info32)) return STATUS_INFO_LENGTH_MISMATCH;
1089         if (!(status = NtQuerySection( handle, class, &info, sizeof(info), &ret_size )))
1090         {
1091             put_section_image_info( info32, &info );
1092             ret_size = sizeof(*info32);
1093         }
1094         break;
1095     }
1096     default:
1097         FIXME( "class %u not implemented\n", class );
1098         return STATUS_NOT_IMPLEMENTED;
1099     }
1100     put_size( ret_ptr, ret_size );
1101     return status;
1102 }
1103
1104
1105 /**********************************************************************
1106  *           wow64_NtQuerySemaphore
1107  */
1108 NTSTATUS WINAPI wow64_NtQuerySemaphore( UINT *args )
1109 {
1110     HANDLE handle = get_handle( &args );
1111     SEMAPHORE_INFORMATION_CLASS class = get_ulong( &args );
1112     void *info = get_ptr( &args );
1113     ULONG len = get_ulong( &args );
1114     ULONG *retlen = get_ptr( &args );
1115
1116     return NtQuerySemaphore( handle, class, info, len, retlen );
1117 }
1118
1119
1120 /**********************************************************************
1121  *           wow64_NtQuerySymbolicLinkObject
1122  */
1123 NTSTATUS WINAPI wow64_NtQuerySymbolicLinkObject( UINT *args )
1124 {
1125     HANDLE handle = get_handle( &args );
1126     UNICODE_STRING32 *target32 = get_ptr( &args );
1127     ULONG *retlen = get_ptr( &args );
1128
1129     UNICODE_STRING target;
1130     NTSTATUS status;
1131
1132     status = NtQuerySymbolicLinkObject( handle, unicode_str_32to64( &target, target32 ), retlen );
1133     if (!status) target32->Length = target.Length;
1134     return status;
1135 }
1136
1137
1138 /**********************************************************************
1139  *           wow64_NtQueryTimer
1140  */
1141 NTSTATUS WINAPI wow64_NtQueryTimer( UINT *args )
1142 {
1143     HANDLE handle = get_handle( &args );
1144     TIMER_INFORMATION_CLASS class = get_ulong( &args );
1145     void *info = get_ptr( &args );
1146     ULONG len = get_ulong( &args );
1147     ULONG *retlen = get_ptr( &args );
1148
1149     return NtQueryTimer( handle, class, info, len, retlen );
1150 }
1151
1152
1153 /**********************************************************************
1154  *           wow64_NtQueryTimerResolution
1155  */
1156 NTSTATUS WINAPI wow64_NtQueryTimerResolution( UINT *args )
1157 {
1158     ULONG *min_res = get_ptr( &args );
1159     ULONG *max_res = get_ptr( &args );
1160     ULONG *current_res = get_ptr( &args );
1161
1162     return NtQueryTimerResolution( min_res, max_res, current_res );
1163 }
1164
1165
1166 /**********************************************************************
1167  *           wow64_NtRegisterThreadTerminatePort
1168  */
1169 NTSTATUS WINAPI wow64_NtRegisterThreadTerminatePort( UINT *args )
1170 {
1171     HANDLE handle = get_handle( &args );
1172
1173     return NtRegisterThreadTerminatePort( handle );
1174 }
1175
1176
1177 /**********************************************************************
1178  *           wow64_NtReleaseKeyedEvent
1179  */
1180 NTSTATUS WINAPI wow64_NtReleaseKeyedEvent( UINT *args )
1181 {
1182     HANDLE handle = get_handle( &args );
1183     void *key = get_ptr( &args );
1184     BOOLEAN alertable = get_ulong( &args );
1185     const LARGE_INTEGER *timeout = get_ptr( &args );
1186
1187     return NtReleaseKeyedEvent( handle, key, alertable, timeout );
1188 }
1189
1190
1191 /**********************************************************************
1192  *           wow64_NtReleaseMutant
1193  */
1194 NTSTATUS WINAPI wow64_NtReleaseMutant( UINT *args )
1195 {
1196     HANDLE handle = get_handle( &args );
1197     LONG *prev_count = get_ptr( &args );
1198
1199     return NtReleaseMutant( handle, prev_count );
1200 }
1201
1202
1203 /**********************************************************************
1204  *           wow64_NtReleaseSemaphore
1205  */
1206 NTSTATUS WINAPI wow64_NtReleaseSemaphore( UINT *args )
1207 {
1208     HANDLE handle = get_handle( &args );
1209     ULONG count = get_ulong( &args );
1210     ULONG *previous = get_ptr( &args );
1211
1212     return NtReleaseSemaphore( handle, count, previous );
1213 }
1214
1215
1216 /**********************************************************************
1217  *           wow64_NtReplyWaitReceivePort
1218  */
1219 NTSTATUS WINAPI wow64_NtReplyWaitReceivePort( UINT *args )
1220 {
1221     HANDLE handle = get_handle( &args );
1222     ULONG *id = get_ptr( &args );
1223     LPC_MESSAGE *reply = get_ptr( &args );
1224     LPC_MESSAGE *msg = get_ptr( &args );
1225
1226     FIXME( "%p %p %p %p: stub\n", handle, id, reply, msg );
1227     return STATUS_NOT_IMPLEMENTED;
1228 }
1229
1230
1231 /**********************************************************************
1232  *           wow64_NtRequestWaitReplyPort
1233  */
1234 NTSTATUS WINAPI wow64_NtRequestWaitReplyPort( UINT *args )
1235 {
1236     HANDLE handle = get_handle( &args );
1237     LPC_MESSAGE *msg_in = get_ptr( &args );
1238     LPC_MESSAGE *msg_out = get_ptr( &args );
1239
1240     FIXME( "%p %p %p: stub\n", handle, msg_in, msg_out );
1241     return STATUS_NOT_IMPLEMENTED;
1242 }
1243
1244
1245 /**********************************************************************
1246  *           wow64_NtResetEvent
1247  */
1248 NTSTATUS WINAPI wow64_NtResetEvent( UINT *args )
1249 {
1250     HANDLE handle = get_handle( &args );
1251     LONG *prev_state = get_ptr( &args );
1252
1253     return NtResetEvent( handle, prev_state );
1254 }
1255
1256
1257 /**********************************************************************
1258  *           wow64_NtSecureConnectPort
1259  */
1260 NTSTATUS WINAPI wow64_NtSecureConnectPort( UINT *args )
1261 {
1262     ULONG *handle_ptr = get_ptr( &args );
1263     UNICODE_STRING32 *name32 = get_ptr( &args );
1264     SECURITY_QUALITY_OF_SERVICE *qos = get_ptr( &args );
1265     LPC_SECTION_WRITE *write = get_ptr( &args );
1266     SID *sid = get_ptr( &args );
1267     LPC_SECTION_READ *read = get_ptr( &args );
1268     ULONG *max_len = get_ptr( &args );
1269     void *info = get_ptr( &args );
1270     ULONG *info_len = get_ptr( &args );
1271
1272     FIXME( "%p %p %p %p %p %p %p %p %p: stub\n",
1273            handle_ptr, name32, qos, write, sid, read, max_len, info, info_len );
1274     return STATUS_NOT_IMPLEMENTED;
1275 }
1276
1277
1278 /**********************************************************************
1279  *           wow64_NtSetEvent
1280  */
1281 NTSTATUS WINAPI wow64_NtSetEvent( UINT *args )
1282 {
1283     HANDLE handle = get_handle( &args );
1284     LONG *prev_state = get_ptr( &args );
1285
1286     return NtSetEvent( handle, prev_state );
1287 }
1288
1289
1290 /**********************************************************************
1291  *           wow64_NtSetInformationDebugObject
1292  */
1293 NTSTATUS WINAPI wow64_NtSetInformationDebugObject( UINT *args )
1294 {
1295     HANDLE handle = get_handle( &args );
1296     DEBUGOBJECTINFOCLASS class = get_ulong( &args );
1297     void *ptr = get_ptr( &args );
1298     ULONG len = get_ulong( &args );
1299     ULONG *retlen = get_ptr( &args );
1300
1301     return NtSetInformationDebugObject( handle, class, ptr, len, retlen );
1302 }
1303
1304
1305 /**********************************************************************
1306  *           wow64_NtSetInformationJobObject
1307  */
1308 NTSTATUS WINAPI wow64_NtSetInformationJobObject( UINT *args )
1309 {
1310     HANDLE handle = get_handle( &args );
1311     JOBOBJECTINFOCLASS class = get_ulong( &args );
1312     void *ptr = get_ptr( &args );
1313     ULONG len = get_ulong( &args );
1314
1315     switch (class)
1316     {
1317     case JobObjectBasicLimitInformation:   /* JOBOBJECT_BASIC_LIMIT_INFORMATION */
1318         if (len == sizeof(JOBOBJECT_BASIC_LIMIT_INFORMATION32))
1319         {
1320             JOBOBJECT_BASIC_LIMIT_INFORMATION info;
1321
1322             return NtSetInformationJobObject( handle, class, job_basic_limit_info_32to64( &info, ptr ),
1323                                               sizeof(info) );
1324         }
1325         else return STATUS_INVALID_PARAMETER;
1326
1327     case JobObjectBasicUIRestrictions:
1328         FIXME( "unsupported class JobObjectBasicUIRestrictions\n" );
1329         return STATUS_SUCCESS;
1330
1331     case JobObjectAssociateCompletionPortInformation:   /* JOBOBJECT_ASSOCIATE_COMPLETION_PORT */
1332         if (len == sizeof(JOBOBJECT_ASSOCIATE_COMPLETION_PORT32))
1333         {
1334             JOBOBJECT_ASSOCIATE_COMPLETION_PORT32 *info32 = ptr;
1335             JOBOBJECT_ASSOCIATE_COMPLETION_PORT info;
1336
1337             info.CompletionKey  = ULongToPtr( info32->CompletionKey );
1338             info.CompletionPort = LongToHandle( info32->CompletionPort );
1339             return NtSetInformationJobObject( handle, class, &info, sizeof(info) );
1340         }
1341         else return STATUS_INVALID_PARAMETER;
1342
1343     case JobObjectExtendedLimitInformation:   /* JOBOBJECT_EXTENDED_LIMIT_INFORMATION */
1344         if (len == sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION32))
1345         {
1346             JOBOBJECT_EXTENDED_LIMIT_INFORMATION32 *info32 = ptr;
1347             JOBOBJECT_EXTENDED_LIMIT_INFORMATION info;
1348
1349             info.IoInfo                = info32->IoInfo;
1350             info.ProcessMemoryLimit    = info32->ProcessMemoryLimit;
1351             info.JobMemoryLimit        = info32->JobMemoryLimit;
1352             info.PeakProcessMemoryUsed = info32->PeakProcessMemoryUsed;
1353             info.PeakJobMemoryUsed     = info32->PeakJobMemoryUsed;
1354             return NtSetInformationJobObject( handle, class,
1355                                               job_basic_limit_info_32to64( &info.BasicLimitInformation,
1356                                                                            &info32->BasicLimitInformation ),
1357                                               sizeof(info) );
1358         }
1359         else return STATUS_INVALID_PARAMETER;
1360
1361     default:
1362         if (class >= MaxJobObjectInfoClass) return STATUS_INVALID_PARAMETER;
1363         FIXME( "unsupported class %u\n", class );
1364         return STATUS_NOT_IMPLEMENTED;
1365     }
1366 }
1367
1368
1369 /**********************************************************************
1370  *           wow64_NtSetInformationObject
1371  */
1372 NTSTATUS WINAPI wow64_NtSetInformationObject( UINT *args )
1373 {
1374     HANDLE handle = get_handle( &args );
1375     OBJECT_INFORMATION_CLASS class = get_ulong( &args );
1376     void *ptr = get_ptr( &args );
1377     ULONG len = get_ulong( &args );
1378
1379     switch (class)
1380     {
1381     case ObjectDataInformation:   /* OBJECT_DATA_INFORMATION */
1382         return NtSetInformationObject( handle, class, ptr, len );
1383
1384     default:
1385         FIXME( "unsupported class %u\n", class );
1386         return STATUS_NOT_IMPLEMENTED;
1387     }
1388 }
1389
1390
1391 /**********************************************************************
1392  *           wow64_NtSetIoCompletion
1393  */
1394 NTSTATUS WINAPI wow64_NtSetIoCompletion( UINT *args )
1395 {
1396     HANDLE handle = get_handle( &args );
1397     ULONG_PTR key = get_ulong( &args );
1398     ULONG_PTR value = get_ulong( &args );
1399     NTSTATUS status = get_ulong( &args );
1400     SIZE_T count = get_ulong( &args );
1401
1402     return NtSetIoCompletion( handle, key, value, status, count );
1403 }
1404
1405
1406 /**********************************************************************
1407  *           wow64_NtSetPowerRequest
1408  */
1409 NTSTATUS WINAPI wow64_NtSetPowerRequest( UINT *args )
1410 {
1411     HANDLE handle = get_handle( &args );
1412     POWER_REQUEST_TYPE type = get_ulong( &args );
1413
1414     return NtSetPowerRequest( handle, type );
1415 }
1416
1417
1418 /**********************************************************************
1419  *           wow64_NtSetTimer
1420  */
1421 NTSTATUS WINAPI wow64_NtSetTimer( UINT *args )
1422 {
1423     HANDLE handle = get_handle( &args );
1424     LARGE_INTEGER *when = get_ptr( &args );
1425     ULONG apc = get_ulong( &args );
1426     ULONG apc_param = get_ulong( &args );
1427     BOOLEAN resume = get_ulong( &args );
1428     ULONG period = get_ulong( &args );
1429     BOOLEAN *state = get_ptr( &args );
1430
1431     return NtSetTimer( handle, when, apc_32to64( apc ), apc_param_32to64( apc, apc_param ),
1432                        resume, period, state );
1433 }
1434
1435
1436 /**********************************************************************
1437  *           wow64_NtSetTimerResolution
1438  */
1439 NTSTATUS WINAPI wow64_NtSetTimerResolution( UINT *args )
1440 {
1441     ULONG res = get_ulong( &args );
1442     BOOLEAN set = get_ulong( &args );
1443     ULONG *current_res = get_ptr( &args );
1444
1445     return NtSetTimerResolution( res, set, current_res );
1446 }
1447
1448
1449 /**********************************************************************
1450  *           wow64_NtSignalAndWaitForSingleObject
1451  */
1452 NTSTATUS WINAPI wow64_NtSignalAndWaitForSingleObject( UINT *args )
1453 {
1454     HANDLE signal = get_handle( &args );
1455     HANDLE wait = get_handle( &args );
1456     BOOLEAN alertable = get_ulong( &args );
1457     const LARGE_INTEGER *timeout = get_ptr( &args );
1458
1459     return NtSignalAndWaitForSingleObject( signal, wait, alertable, timeout );
1460 }
1461
1462
1463 /**********************************************************************
1464  *           wow64_NtTerminateJobObject
1465  */
1466 NTSTATUS WINAPI wow64_NtTerminateJobObject( UINT *args )
1467 {
1468     HANDLE handle = get_handle( &args );
1469     NTSTATUS status = get_ulong( &args );
1470
1471     return NtTerminateJobObject( handle, status );
1472 }
1473
1474
1475 /**********************************************************************
1476  *           wow64_NtTestAlert
1477  */
1478 NTSTATUS WINAPI wow64_NtTestAlert( UINT *args )
1479 {
1480     return NtTestAlert();
1481 }
1482
1483
1484 /**********************************************************************
1485  *           wow64_NtWaitForDebugEvent
1486  */
1487 NTSTATUS WINAPI wow64_NtWaitForDebugEvent( UINT *args )
1488 {
1489     HANDLE handle = get_handle( &args );
1490     BOOLEAN alertable = get_ulong( &args );
1491     LARGE_INTEGER *timeout = get_ptr( &args );
1492     DBGUI_WAIT_STATE_CHANGE32 *state32 = get_ptr( &args );
1493
1494     ULONG i;
1495     DBGUI_WAIT_STATE_CHANGE state;
1496     NTSTATUS status = NtWaitForDebugEvent( handle, alertable, timeout, &state );
1497
1498     if (!status)
1499     {
1500         state32->NewState = state.NewState;
1501         state32->AppClientId.UniqueProcess = HandleToULong( state.AppClientId.UniqueProcess );
1502         state32->AppClientId.UniqueThread = HandleToULong( state.AppClientId.UniqueThread );
1503         switch (state.NewState)
1504         {
1505 #define COPY_ULONG(field) state32->StateInfo.field = state.StateInfo.field
1506 #define COPY_PTR(field)   state32->StateInfo.field = PtrToUlong( state.StateInfo.field )
1507         case DbgCreateThreadStateChange:
1508             COPY_PTR( CreateThread.HandleToThread );
1509             COPY_PTR( CreateThread.NewThread.StartAddress );
1510             COPY_ULONG( CreateThread.NewThread.SubSystemKey );
1511             break;
1512         case DbgCreateProcessStateChange:
1513             COPY_PTR( CreateProcessInfo.HandleToProcess );
1514             COPY_PTR( CreateProcessInfo.HandleToThread );
1515             COPY_PTR( CreateProcessInfo.NewProcess.FileHandle );
1516             COPY_PTR( CreateProcessInfo.NewProcess.BaseOfImage );
1517             COPY_PTR( CreateProcessInfo.NewProcess.InitialThread.StartAddress );
1518             COPY_ULONG( CreateProcessInfo.NewProcess.InitialThread.SubSystemKey );
1519             COPY_ULONG( CreateProcessInfo.NewProcess.DebugInfoFileOffset );
1520             COPY_ULONG( CreateProcessInfo.NewProcess.DebugInfoSize );
1521             break;
1522         case DbgExitThreadStateChange:
1523         case DbgExitProcessStateChange:
1524             COPY_ULONG( ExitThread.ExitStatus );
1525             break;
1526         case DbgExceptionStateChange:
1527         case DbgBreakpointStateChange:
1528         case DbgSingleStepStateChange:
1529             COPY_ULONG( Exception.FirstChance );
1530             COPY_ULONG( Exception.ExceptionRecord.ExceptionCode );
1531             COPY_ULONG( Exception.ExceptionRecord.ExceptionFlags );
1532             COPY_ULONG( Exception.ExceptionRecord.NumberParameters );
1533             COPY_PTR( Exception.ExceptionRecord.ExceptionRecord );
1534             COPY_PTR( Exception.ExceptionRecord.ExceptionAddress );
1535             for (i = 0; i < state.StateInfo.Exception.ExceptionRecord.NumberParameters; i++)
1536                 COPY_ULONG( Exception.ExceptionRecord.ExceptionInformation[i] );
1537             break;
1538         case DbgLoadDllStateChange:
1539             COPY_PTR( LoadDll.FileHandle );
1540             COPY_PTR( LoadDll.BaseOfDll );
1541             COPY_ULONG( LoadDll.DebugInfoFileOffset );
1542             COPY_ULONG( LoadDll.DebugInfoSize );
1543             COPY_PTR( LoadDll.NamePointer );
1544             break;
1545         case DbgUnloadDllStateChange:
1546             COPY_PTR( UnloadDll.BaseAddress );
1547             break;
1548         default:
1549             break;
1550         }
1551 #undef COPY_ULONG
1552 #undef COPY_PTR
1553     }
1554     return status;
1555 }
1556
1557
1558 /**********************************************************************
1559  *           wow64_NtWaitForKeyedEvent
1560  */
1561 NTSTATUS WINAPI wow64_NtWaitForKeyedEvent( UINT *args )
1562 {
1563     HANDLE handle = get_handle( &args );
1564     const void *key = get_ptr( &args );
1565     BOOLEAN alertable = get_ulong( &args );
1566     const LARGE_INTEGER *timeout = get_ptr( &args );
1567
1568     return NtWaitForKeyedEvent( handle, key, alertable, timeout );
1569 }
1570
1571
1572 /**********************************************************************
1573  *           wow64_NtWaitForMultipleObjects
1574  */
1575 NTSTATUS WINAPI wow64_NtWaitForMultipleObjects( UINT *args )
1576 {
1577     DWORD count = get_ulong( &args );
1578     LONG *handles_ptr = get_ptr( &args );
1579     BOOLEAN wait_any = get_ulong( &args );
1580     BOOLEAN alertable = get_ulong( &args );
1581     const LARGE_INTEGER *timeout = get_ptr( &args );
1582
1583     HANDLE handles[MAXIMUM_WAIT_OBJECTS];
1584     DWORD i;
1585
1586     for (i = 0; i < count && i < MAXIMUM_WAIT_OBJECTS; i++) handles[i] = LongToHandle( handles_ptr[i] );
1587     return NtWaitForMultipleObjects( count, handles, wait_any, alertable, timeout );
1588 }
1589
1590
1591 /**********************************************************************
1592  *           wow64_NtWaitForSingleObject
1593  */
1594 NTSTATUS WINAPI wow64_NtWaitForSingleObject( UINT *args )
1595 {
1596     HANDLE handle = get_handle( &args );
1597     BOOLEAN alertable = get_ulong( &args );
1598     const LARGE_INTEGER *timeout = get_ptr( &args );
1599
1600     return NtWaitForSingleObject( handle, alertable, timeout );
1601 }
1602
1603
1604 /**********************************************************************
1605  *           wow64_NtYieldExecution
1606  */
1607 NTSTATUS WINAPI wow64_NtYieldExecution( UINT *args )
1608 {
1609     return NtYieldExecution();
1610 }