dlls/ntdll/process.c

   1 /*
   2  * NT basis DLL
   3  *
   4  * This file contains the Nt* API functions of NTDLL.DLL.
   5  * In the original ntdll.dll they all seem to just call int 0x2e (down to the NTOSKRNL)
   6  *
   7  * Copyright 1996-1998 Marcus Meissner
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <time.h>
  31 #ifdef HAVE_UNISTD_H
  32 # include <unistd.h>
  33 #endif
  34
  35 #include "ntstatus.h"
  36 #define WIN32_NO_STATUS
  37 #include "wine/debug.h"
  38 #include "windef.h"
  39 #include "winternl.h"
  40 #include "ntdll_misc.h"
  41 #include "wine/server.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  44
  45 static ULONG execute_flags = MEM_EXECUTE_OPTION_DISABLE;
  46
  47 /*
  48  *      Process object
  49  */
  50
  51 /******************************************************************************
  52  *  NtTerminateProcess                  [NTDLL.@]
  53  *
  54  *  Native applications must kill themselves when done
  55  */
  56 NTSTATUS WINAPI NtTerminateProcess( HANDLE handle, LONG exit_code )
  57 {
  58     NTSTATUS ret;
  59     BOOL self;
  60     SERVER_START_REQ( terminate_process )
  61     {
  62         req->handle    = wine_server_obj_handle( handle );
  63         req->exit_code = exit_code;
  64         ret = wine_server_call( req );
  65         self = !ret && reply->self;
  66     }
  67     SERVER_END_REQ;
  68     if (self && handle) _exit( exit_code );
  69     return ret;
  70 }
  71
  72 /******************************************************************************
  73  *  RtlGetCurrentPeb  [NTDLL.@]
  74  *
  75  */
  76 PEB * WINAPI RtlGetCurrentPeb(void)
  77 {
  78     return NtCurrentTeb()->Peb;
  79 }
  80
  81 /***********************************************************************
  82  *           __wine_make_process_system   (NTDLL.@)
  83  *
  84  * Mark the current process as a system process.
  85  * Returns the event that is signaled when all non-system processes have exited.
  86  */
  87 HANDLE CDECL __wine_make_process_system(void)
  88 {
  89     HANDLE ret = 0;
  90     SERVER_START_REQ( make_process_system )
  91     {
  92         if (!wine_server_call( req )) ret = wine_server_ptr_handle( reply->event );
  93     }
  94     SERVER_END_REQ;
  95     return ret;
  96 }
  97
  98 static UINT process_error_mode;
  99
 100 #define UNIMPLEMENTED_INFO_CLASS(c) \
 101     case c: \
 102         FIXME("(process=%p) Unimplemented information class: " #c "\n", ProcessHandle); \
 103         ret = STATUS_INVALID_INFO_CLASS; \
 104         break
 105
 106 ULONG_PTR get_system_affinity_mask(void)
 107 {
 108     ULONG num_cpus = NtCurrentTeb()->Peb->NumberOfProcessors;
 109     if (num_cpus >= sizeof(ULONG_PTR) * 8) return ~(ULONG_PTR)0;
 110     return ((ULONG_PTR)1 << num_cpus) - 1;
 111 }
 112
 113 /******************************************************************************
 114 *  NtQueryInformationProcess            [NTDLL.@]
 115 *  ZwQueryInformationProcess            [NTDLL.@]
 116 *
 117 */
 118 NTSTATUS WINAPI NtQueryInformationProcess(
 119         IN HANDLE ProcessHandle,
 120         IN PROCESSINFOCLASS ProcessInformationClass,
 121         OUT PVOID ProcessInformation,
 122         IN ULONG ProcessInformationLength,
 123         OUT PULONG ReturnLength)
 124 {
 125     NTSTATUS ret = STATUS_SUCCESS;
 126     ULONG len = 0;
 127
 128     TRACE("(%p,0x%08x,%p,0x%08x,%p)\n",
 129           ProcessHandle,ProcessInformationClass,
 130           ProcessInformation,ProcessInformationLength,
 131           ReturnLength);
 132
 133     switch (ProcessInformationClass)
 134     {
 135     UNIMPLEMENTED_INFO_CLASS(ProcessQuotaLimits);
 136     UNIMPLEMENTED_INFO_CLASS(ProcessBasePriority);
 137     UNIMPLEMENTED_INFO_CLASS(ProcessRaisePriority);
 138     UNIMPLEMENTED_INFO_CLASS(ProcessExceptionPort);
 139     UNIMPLEMENTED_INFO_CLASS(ProcessAccessToken);
 140     UNIMPLEMENTED_INFO_CLASS(ProcessLdtInformation);
 141     UNIMPLEMENTED_INFO_CLASS(ProcessLdtSize);
 142     UNIMPLEMENTED_INFO_CLASS(ProcessIoPortHandlers);
 143     UNIMPLEMENTED_INFO_CLASS(ProcessPooledUsageAndLimits);
 144     UNIMPLEMENTED_INFO_CLASS(ProcessWorkingSetWatch);
 145     UNIMPLEMENTED_INFO_CLASS(ProcessUserModeIOPL);
 146     UNIMPLEMENTED_INFO_CLASS(ProcessEnableAlignmentFaultFixup);
 147     UNIMPLEMENTED_INFO_CLASS(ProcessPriorityClass);
 148     UNIMPLEMENTED_INFO_CLASS(ProcessWx86Information);
 149     UNIMPLEMENTED_INFO_CLASS(ProcessPriorityBoost);
 150     UNIMPLEMENTED_INFO_CLASS(ProcessDeviceMap);
 151     UNIMPLEMENTED_INFO_CLASS(ProcessSessionInformation);
 152     UNIMPLEMENTED_INFO_CLASS(ProcessForegroundInformation);
 153     UNIMPLEMENTED_INFO_CLASS(ProcessLUIDDeviceMapsEnabled);
 154     UNIMPLEMENTED_INFO_CLASS(ProcessBreakOnTermination);
 155     UNIMPLEMENTED_INFO_CLASS(ProcessHandleTracing);
 156
 157     case ProcessBasicInformation:
 158         {
 159             PROCESS_BASIC_INFORMATION pbi;
 160             const ULONG_PTR affinity_mask = get_system_affinity_mask();
 161
 162             if (ProcessInformationLength >= sizeof(PROCESS_BASIC_INFORMATION))
 163             {
 164                 if (!ProcessInformation)
 165                     ret = STATUS_ACCESS_VIOLATION;
 166                 else if (!ProcessHandle)
 167                     ret = STATUS_INVALID_HANDLE;
 168                 else
 169                 {
 170                     SERVER_START_REQ(get_process_info)
 171                     {
 172                         req->handle = wine_server_obj_handle( ProcessHandle );
 173                         if ((ret = wine_server_call( req )) == STATUS_SUCCESS)
 174                         {
 175                             pbi.ExitStatus = reply->exit_code;
 176                             pbi.PebBaseAddress = wine_server_get_ptr( reply->peb );
 177                             pbi.AffinityMask = reply->affinity & affinity_mask;
 178                             pbi.BasePriority = reply->priority;
 179                             pbi.UniqueProcessId = reply->pid;
 180                             pbi.InheritedFromUniqueProcessId = reply->ppid;
 181                         }
 182                     }
 183                     SERVER_END_REQ;
 184
 185                     memcpy(ProcessInformation, &pbi, sizeof(PROCESS_BASIC_INFORMATION));
 186
 187                     len = sizeof(PROCESS_BASIC_INFORMATION);
 188                 }
 189
 190                 if (ProcessInformationLength > sizeof(PROCESS_BASIC_INFORMATION))
 191                     ret = STATUS_INFO_LENGTH_MISMATCH;
 192             }
 193             else
 194             {
 195                 len = sizeof(PROCESS_BASIC_INFORMATION);
 196                 ret = STATUS_INFO_LENGTH_MISMATCH;
 197             }
 198         }
 199         break;
 200     case ProcessIoCounters:
 201         {
 202             IO_COUNTERS pii;
 203
 204             if (ProcessInformationLength >= sizeof(IO_COUNTERS))
 205             {
 206                 if (!ProcessInformation)
 207                     ret = STATUS_ACCESS_VIOLATION;
 208                 else if (!ProcessHandle)
 209                     ret = STATUS_INVALID_HANDLE;
 210                 else
 211                 {
 212                     /* FIXME : real data */
 213                     memset(&pii, 0 , sizeof(IO_COUNTERS));
 214
 215                     memcpy(ProcessInformation, &pii, sizeof(IO_COUNTERS));
 216
 217                     len = sizeof(IO_COUNTERS);
 218                 }
 219
 220                 if (ProcessInformationLength > sizeof(IO_COUNTERS))
 221                     ret = STATUS_INFO_LENGTH_MISMATCH;
 222             }
 223             else
 224             {
 225                 len = sizeof(IO_COUNTERS);
 226                 ret = STATUS_INFO_LENGTH_MISMATCH;
 227             }
 228         }
 229         break;
 230     case ProcessVmCounters:
 231         {
 232             VM_COUNTERS pvmi;
 233
 234             /* older Windows versions don't have the PrivatePageCount field */
 235             if (ProcessInformationLength >= FIELD_OFFSET(VM_COUNTERS,PrivatePageCount))
 236             {
 237                 if (!ProcessInformation)
 238                     ret = STATUS_ACCESS_VIOLATION;
 239                 else if (!ProcessHandle)
 240                     ret = STATUS_INVALID_HANDLE;
 241                 else
 242                 {
 243                     /* FIXME : real data */
 244                     memset(&pvmi, 0 , sizeof(VM_COUNTERS));
 245
 246                     len = ProcessInformationLength;
 247                     if (len != FIELD_OFFSET(VM_COUNTERS,PrivatePageCount)) len = sizeof(VM_COUNTERS);
 248
 249                     memcpy(ProcessInformation, &pvmi, min(ProcessInformationLength,sizeof(VM_COUNTERS)));
 250                 }
 251
 252                 if (ProcessInformationLength != FIELD_OFFSET(VM_COUNTERS,PrivatePageCount) &&
 253                     ProcessInformationLength != sizeof(VM_COUNTERS))
 254                     ret = STATUS_INFO_LENGTH_MISMATCH;
 255             }
 256             else
 257             {
 258                 len = sizeof(pvmi);
 259                 ret = STATUS_INFO_LENGTH_MISMATCH;
 260             }
 261         }
 262         break;
 263     case ProcessTimes:
 264         {
 265             KERNEL_USER_TIMES pti;
 266
 267             if (ProcessInformationLength >= sizeof(KERNEL_USER_TIMES))
 268             {
 269                 if (!ProcessInformation)
 270                     ret = STATUS_ACCESS_VIOLATION;
 271                 else if (!ProcessHandle)
 272                     ret = STATUS_INVALID_HANDLE;
 273                 else
 274                 {
 275                     /* FIXME : User- and KernelTime have to be implemented */
 276                     memset(&pti, 0, sizeof(KERNEL_USER_TIMES));
 277
 278                     SERVER_START_REQ(get_process_info)
 279                     {
 280                       req->handle = wine_server_obj_handle( ProcessHandle );
 281                       if ((ret = wine_server_call( req )) == STATUS_SUCCESS)
 282                       {
 283                           pti.CreateTime.QuadPart = reply->start_time;
 284                           pti.ExitTime.QuadPart = reply->end_time;
 285                       }
 286                     }
 287                     SERVER_END_REQ;
 288
 289                     memcpy(ProcessInformation, &pti, sizeof(KERNEL_USER_TIMES));
 290                     len = sizeof(KERNEL_USER_TIMES);
 291                 }
 292
 293                 if (ProcessInformationLength > sizeof(KERNEL_USER_TIMES))
 294                     ret = STATUS_INFO_LENGTH_MISMATCH;
 295             }
 296             else
 297             {
 298                 len = sizeof(KERNEL_USER_TIMES);
 299                 ret = STATUS_INFO_LENGTH_MISMATCH;
 300             }
 301         }
 302         break;
 303     case ProcessDebugPort:
 304         len = sizeof(DWORD_PTR);
 305         if (ProcessInformationLength == len)
 306         {
 307             if (!ProcessInformation)
 308                 ret = STATUS_ACCESS_VIOLATION;
 309             else if (!ProcessHandle)
 310                 ret = STATUS_INVALID_HANDLE;
 311             else
 312             {
 313                 SERVER_START_REQ(get_process_info)
 314                 {
 315                     req->handle = wine_server_obj_handle( ProcessHandle );
 316                     if ((ret = wine_server_call( req )) == STATUS_SUCCESS)
 317                     {
 318                         *(DWORD_PTR *)ProcessInformation = reply->debugger_present ? ~(DWORD_PTR)0 : 0;
 319                     }
 320                 }
 321                 SERVER_END_REQ;
 322             }
 323         }
 324         else
 325             ret = STATUS_INFO_LENGTH_MISMATCH;
 326         break;
 327     case ProcessDebugFlags:
 328         len = sizeof(DWORD);
 329         if (ProcessInformationLength == len)
 330         {
 331             if (!ProcessInformation)
 332                 ret = STATUS_ACCESS_VIOLATION;
 333             else if (!ProcessHandle)
 334                 ret = STATUS_INVALID_HANDLE;
 335             else
 336             {
 337                 SERVER_START_REQ(get_process_info)
 338                 {
 339                     req->handle = wine_server_obj_handle( ProcessHandle );
 340                     if ((ret = wine_server_call( req )) == STATUS_SUCCESS)
 341                     {
 342                         *(DWORD *)ProcessInformation = reply->debug_children;
 343                     }
 344                 }
 345                 SERVER_END_REQ;
 346             }
 347         }
 348         else
 349             ret = STATUS_INFO_LENGTH_MISMATCH;
 350         break;
 351     case ProcessDefaultHardErrorMode:
 352         len = sizeof(process_error_mode);
 353         if (ProcessInformationLength == len)
 354             memcpy(ProcessInformation, &process_error_mode, len);
 355         else
 356             ret = STATUS_INFO_LENGTH_MISMATCH;
 357         break;
 358     case ProcessDebugObjectHandle:
 359         /* "These are not the debuggers you are looking for." *
 360          * set it to 0 aka "no debugger" to satisfy copy protections */
 361         len = sizeof(HANDLE);
 362         if (ProcessInformationLength == len)
 363         {
 364             if (!ProcessInformation)
 365                 ret = STATUS_ACCESS_VIOLATION;
 366             else if (!ProcessHandle)
 367                 ret = STATUS_INVALID_HANDLE;
 368             else
 369             {
 370                 memset(ProcessInformation, 0, ProcessInformationLength);
 371                 ret = STATUS_PORT_NOT_SET;
 372             }
 373         }
 374         else
 375             ret = STATUS_INFO_LENGTH_MISMATCH;
 376         break;
 377     case ProcessHandleCount:
 378         if (ProcessInformationLength >= 4)
 379         {
 380             if (!ProcessInformation)
 381                 ret = STATUS_ACCESS_VIOLATION;
 382             else if (!ProcessHandle)
 383                 ret = STATUS_INVALID_HANDLE;
 384             else
 385             {
 386                 memset(ProcessInformation, 0, 4);
 387                 len = 4;
 388             }
 389
 390             if (ProcessInformationLength > 4)
 391                 ret = STATUS_INFO_LENGTH_MISMATCH;
 392         }
 393         else
 394         {
 395             len = 4;
 396             ret = STATUS_INFO_LENGTH_MISMATCH;
 397         }
 398         break;
 399
 400     case ProcessAffinityMask:
 401         len = sizeof(ULONG_PTR);
 402         if (ProcessInformationLength == len)
 403         {
 404             const ULONG_PTR system_mask = get_system_affinity_mask();
 405
 406             SERVER_START_REQ(get_process_info)
 407             {
 408                 req->handle = wine_server_obj_handle( ProcessHandle );
 409                 if (!(ret = wine_server_call( req )))
 410                     *(ULONG_PTR *)ProcessInformation = reply->affinity & system_mask;
 411             }
 412             SERVER_END_REQ;
 413         }
 414         else ret = STATUS_INFO_LENGTH_MISMATCH;
 415         break;
 416
 417     case ProcessWow64Information:
 418         len = sizeof(ULONG_PTR);
 419         if (ProcessInformationLength != len) ret = STATUS_INFO_LENGTH_MISMATCH;
 420         else if (!ProcessInformation) ret = STATUS_ACCESS_VIOLATION;
 421         else if(!ProcessHandle) ret = STATUS_INVALID_HANDLE;
 422         else
 423         {
 424             ULONG_PTR val = 0;
 425
 426             if (ProcessHandle == GetCurrentProcess()) val = is_wow64;
 427             else if (server_cpus & ((1 << CPU_x86_64) | (1 << CPU_ARM64)))
 428             {
 429                 SERVER_START_REQ( get_process_info )
 430                 {
 431                     req->handle = wine_server_obj_handle( ProcessHandle );
 432                     if (!(ret = wine_server_call( req )))
 433                         val = (reply->cpu != CPU_x86_64 && reply->cpu != CPU_ARM64);
 434                 }
 435                 SERVER_END_REQ;
 436             }
 437             *(ULONG_PTR *)ProcessInformation = val;
 438         }
 439         break;
 440     case ProcessImageFileName:
 441         /* FIXME: this will return a DOS path. Windows returns an NT path. Changing this would require also changing kernel32.QueryFullProcessImageName.
 442          * The latter may be harder because of the lack of RtlNtPathNameToDosPathName. */
 443         SERVER_START_REQ(get_dll_info)
 444         {
 445             UNICODE_STRING *image_file_name_str = ProcessInformation;
 446
 447             req->handle = wine_server_obj_handle( ProcessHandle );
 448             req->base_address = 0; /* main module */
 449             wine_server_set_reply( req, image_file_name_str ? image_file_name_str + 1 : NULL,
 450                                    ProcessInformationLength > sizeof(UNICODE_STRING) ? ProcessInformationLength - sizeof(UNICODE_STRING) : 0 );
 451             ret = wine_server_call( req );
 452             if (ret == STATUS_BUFFER_TOO_SMALL) ret = STATUS_INFO_LENGTH_MISMATCH;
 453
 454             len = sizeof(UNICODE_STRING) + reply->filename_len;
 455             if (ret == STATUS_SUCCESS)
 456             {
 457                 image_file_name_str->MaximumLength = image_file_name_str->Length = reply->filename_len;
 458                 image_file_name_str->Buffer = (PWSTR)(image_file_name_str + 1);
 459             }
 460         }
 461         SERVER_END_REQ;
 462         break;
 463     case ProcessExecuteFlags:
 464         len = sizeof(ULONG);
 465         if (ProcessInformationLength == len)
 466             *(ULONG *)ProcessInformation = execute_flags;
 467         else
 468             ret = STATUS_INFO_LENGTH_MISMATCH;
 469         break;
 470     default:
 471         FIXME("(%p,info_class=%d,%p,0x%08x,%p) Unknown information class\n",
 472               ProcessHandle,ProcessInformationClass,
 473               ProcessInformation,ProcessInformationLength,
 474               ReturnLength);
 475         ret = STATUS_INVALID_INFO_CLASS;
 476         break;
 477     }
 478
 479     if (ReturnLength) *ReturnLength = len;
 480
 481     return ret;
 482 }
 483
 484 /******************************************************************************
 485  * NtSetInformationProcess [NTDLL.@]
 486  * ZwSetInformationProcess [NTDLL.@]
 487  */
 488 NTSTATUS WINAPI NtSetInformationProcess(
 489         IN HANDLE ProcessHandle,
 490         IN PROCESSINFOCLASS ProcessInformationClass,
 491         IN PVOID ProcessInformation,
 492         IN ULONG ProcessInformationLength)
 493 {
 494     NTSTATUS ret = STATUS_SUCCESS;
 495
 496     switch (ProcessInformationClass)
 497     {
 498     case ProcessDefaultHardErrorMode:
 499         if (ProcessInformationLength != sizeof(UINT)) return STATUS_INVALID_PARAMETER;
 500         process_error_mode = *(UINT *)ProcessInformation;
 501         break;
 502     case ProcessAffinityMask:
 503     {
 504         const ULONG_PTR system_mask = get_system_affinity_mask();
 505
 506         if (ProcessInformationLength != sizeof(DWORD_PTR)) return STATUS_INVALID_PARAMETER;
 507         if (*(PDWORD_PTR)ProcessInformation & ~system_mask)
 508             return STATUS_INVALID_PARAMETER;
 509         if (!*(PDWORD_PTR)ProcessInformation)
 510             return STATUS_INVALID_PARAMETER;
 511         SERVER_START_REQ( set_process_info )
 512         {
 513             req->handle   = wine_server_obj_handle( ProcessHandle );
 514             req->affinity = *(PDWORD_PTR)ProcessInformation;
 515             req->mask     = SET_PROCESS_INFO_AFFINITY;
 516             ret = wine_server_call( req );
 517         }
 518         SERVER_END_REQ;
 519         break;
 520     }
 521     case ProcessPriorityClass:
 522         if (ProcessInformationLength != sizeof(PROCESS_PRIORITY_CLASS))
 523             return STATUS_INVALID_PARAMETER;
 524         else
 525         {
 526             PROCESS_PRIORITY_CLASS* ppc = ProcessInformation;
 527
 528             SERVER_START_REQ( set_process_info )
 529             {
 530                 req->handle   = wine_server_obj_handle( ProcessHandle );
 531                 /* FIXME Foreground isn't used */
 532                 req->priority = ppc->PriorityClass;
 533                 req->mask     = SET_PROCESS_INFO_PRIORITY;
 534                 ret = wine_server_call( req );
 535             }
 536             SERVER_END_REQ;
 537         }
 538         break;
 539
 540     case ProcessExecuteFlags:
 541         if (ProcessInformationLength != sizeof(ULONG))
 542             return STATUS_INVALID_PARAMETER;
 543         else if (execute_flags & MEM_EXECUTE_OPTION_PERMANENT)
 544             return STATUS_ACCESS_DENIED;
 545         else
 546         {
 547             BOOL enable;
 548             switch (*(ULONG *)ProcessInformation & (MEM_EXECUTE_OPTION_ENABLE|MEM_EXECUTE_OPTION_DISABLE))
 549             {
 550             case MEM_EXECUTE_OPTION_ENABLE:
 551                 enable = TRUE;
 552                 break;
 553             case MEM_EXECUTE_OPTION_DISABLE:
 554                 enable = FALSE;
 555                 break;
 556             default:
 557                 return STATUS_INVALID_PARAMETER;
 558             }
 559             execute_flags = *(ULONG *)ProcessInformation;
 560             VIRTUAL_SetForceExec( enable );
 561         }
 562         break;
 563
 564     default:
 565         FIXME("(%p,0x%08x,%p,0x%08x) stub\n",
 566               ProcessHandle,ProcessInformationClass,ProcessInformation,
 567               ProcessInformationLength);
 568         ret = STATUS_NOT_IMPLEMENTED;
 569         break;
 570     }
 571     return ret;
 572 }
 573
 574 /******************************************************************************
 575  * NtFlushInstructionCache [NTDLL.@]
 576  * ZwFlushInstructionCache [NTDLL.@]
 577  */
 578 NTSTATUS WINAPI NtFlushInstructionCache(
 579         IN HANDLE ProcessHandle,
 580         IN LPCVOID BaseAddress,
 581         IN SIZE_T Size)
 582 {
 583     static int once;
 584     if (!once++)
 585     {
 586 #if defined(__x86_64__) || defined(__i386__)
 587         TRACE("%p %p %ld - no-op on x86 and x86_64\n", ProcessHandle, BaseAddress, Size );
 588 #else
 589         FIXME("%p %p %ld\n", ProcessHandle, BaseAddress, Size );
 590 #endif
 591     }
 592     return STATUS_SUCCESS;
 593 }
 594
 595 /******************************************************************
 596  *              NtOpenProcess [NTDLL.@]
 597  *              ZwOpenProcess [NTDLL.@]
 598  */
 599 NTSTATUS  WINAPI NtOpenProcess(PHANDLE handle, ACCESS_MASK access,
 600                                const OBJECT_ATTRIBUTES* attr, const CLIENT_ID* cid)
 601 {
 602     NTSTATUS    status;
 603
 604     SERVER_START_REQ( open_process )
 605     {
 606         req->pid        = HandleToULong(cid->UniqueProcess);
 607         req->access     = access;
 608         req->attributes = attr ? attr->Attributes : 0;
 609         status = wine_server_call( req );
 610         if (!status) *handle = wine_server_ptr_handle( reply->handle );
 611     }
 612     SERVER_END_REQ;
 613     return status;
 614 }