PVOID
WINAPI
MemAlloc(IN HANDLE Heap,
IN PVOID Ptr,
IN ULONG Size)
{
PVOID pBuf = NULL;
if(Size == 0 && Ptr == NULL)
{
return NULL;
}
if(Heap == NULL)
{
Heap = NtCurrentPeb()->ProcessHeap;
}
if(Size > 0)
{
if(Ptr == NULL)
/* malloc */
pBuf = RtlAllocateHeap(Heap, 0, Size);
else
/* realloc */
pBuf = RtlReAllocateHeap(Heap, 0, Ptr, Size);
}
else
/* free */
RtlFreeHeap(Heap, 0, Ptr);
return pBuf;
}
/*
* @implemented
*/
BOOL
WINAPI
ConvertFiberToThread(VOID)
{
PTEB Teb;
PFIBER FiberData;
DPRINT1("Converting Fiber to Thread\n");
/* Check if the thread is already not a fiber */
Teb = NtCurrentTeb();
if (!Teb->HasFiberData)
{
/* Fail */
SetLastError(ERROR_ALREADY_THREAD);
return FALSE;
}
/* this thread won't run a fiber anymore */
Teb->HasFiberData = FALSE;
FiberData = Teb->NtTib.FiberData;
Teb->NtTib.FiberData = NULL;
/* Free the fiber */
ASSERT(FiberData != NULL);
RtlFreeHeap(GetProcessHeap(), 0, FiberData);
/* success */
return TRUE;
}
/*
* @implemented
*/
NTSTATUS
NTAPI
RtlDestroyProcessParameters(IN PRTL_USER_PROCESS_PARAMETERS ProcessParameters)
{
RtlFreeHeap(RtlGetProcessHeap(), 0, ProcessParameters);
return STATUS_SUCCESS;
}
/*
* @implemented
*/
NTSTATUS
WINAPI
LsaFreeMemory(IN PVOID Buffer)
{
TRACE("(%p)\n", Buffer);
return RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
}
/*
* @implemented
*/
VOID
WINAPI
DeleteFiber(LPVOID lpFiber)
{
SIZE_T Size = 0;
PFIBER Fiber = (PFIBER)lpFiber;
PTEB Teb;
/* First, exit the thread */
Teb = NtCurrentTeb();
if ((Teb->HasFiberData) && (Teb->NtTib.FiberData == Fiber)) ExitThread(1);
/* Now de-allocate the stack */
NtFreeVirtualMemory(NtCurrentProcess(),
&Fiber->DeallocationStack,
&Size,
MEM_RELEASE);
/* Get rid of FLS */
if (Fiber->FlsData) BaseRundownFls(Fiber->FlsData);
/* Get rid of the activation stack */
DPRINT1("Leaking activation stack because nobody implemented free");
//RtlFreeActivationContextStack(Fiber->ActivationContextStack);
/* Free the fiber data */
RtlFreeHeap(GetProcessHeap(), 0, lpFiber);
}
/*
* @implemented (Wine 13 sep 2008)
*/
HANDLE
WINAPI
FindFirstVolumeA(IN LPSTR volume,
IN DWORD len)
{
WCHAR *buffer = NULL;
HANDLE handle;
buffer = RtlAllocateHeap( RtlGetProcessHeap(), 0, len * sizeof(WCHAR) );
if (!buffer)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return INVALID_HANDLE_VALUE;
}
handle = FindFirstVolumeW( buffer, len );
if (handle != INVALID_HANDLE_VALUE)
{
if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, volume, len, NULL, NULL ))
{
FindVolumeClose( handle );
handle = INVALID_HANDLE_VALUE;
}
}
RtlFreeHeap( RtlGetProcessHeap(), 0, buffer );
return handle;
}
VOID
LsapFreeLsaHeap (
IN PVOID Base
)
/*++
Routine Description:
This function free previously allocated heap space.
Arguments:
Base - Provides the address of the previously allocated heap
space to deallocate.
Return Value:
None.
--*/
{
RtlFreeHeap( LsapHeap, 0, Base );
return;
}
/*
* @implemented
*/
BOOL
WINAPI
SetVolumeLabelA(IN LPCSTR lpRootPathName,
IN LPCSTR lpVolumeName OPTIONAL) /* NULL if deleting label */
{
PWCHAR RootPathNameW;
PWCHAR VolumeNameW = NULL;
BOOL Result;
if (!(RootPathNameW = FilenameA2W(lpRootPathName, FALSE)))
return FALSE;
if (lpVolumeName)
{
if (!(VolumeNameW = FilenameA2W(lpVolumeName, TRUE)))
return FALSE;
}
Result = SetVolumeLabelW (RootPathNameW,
VolumeNameW);
if (VolumeNameW)
{
RtlFreeHeap (RtlGetProcessHeap (),
0,
VolumeNameW );
}
return Result;
}
NTSTATUS
LsarSetAuditEvents(PLSA_DB_OBJECT PolicyObject,
PLSAPR_POLICY_AUDIT_EVENTS_INFO Info)
{
PLSAP_POLICY_AUDIT_EVENTS_DATA AuditData = NULL;
ULONG AttributeSize;
NTSTATUS Status = STATUS_SUCCESS;
TRACE("(%p %p)\n", PolicyObject, Info);
AttributeSize = sizeof(LSAP_POLICY_AUDIT_EVENTS_DATA) +
Info->MaximumAuditEventCount * sizeof(DWORD);
AuditData = RtlAllocateHeap(RtlGetProcessHeap(),
HEAP_ZERO_MEMORY,
AttributeSize);
if (AuditData == NULL)
return STATUS_INSUFFICIENT_RESOURCES;
AuditData->AuditingMode = Info->AuditingMode;
AuditData->MaximumAuditEventCount = Info->MaximumAuditEventCount;
memcpy(&(AuditData->AuditEvents[0]),
Info->EventAuditingOptions,
Info->MaximumAuditEventCount * sizeof(DWORD));
Status = LsapSetObjectAttribute(PolicyObject,
L"PolAdtEv",
AuditData,
AttributeSize);
RtlFreeHeap(RtlGetProcessHeap(), 0, AuditData);
return Status;
}
/* delete the disk device for a given drive */
static void delete_dos_device( struct dos_drive *drive )
{
list_remove( &drive->entry );
if (drive->mount) delete_mount_point( drive->mount );
release_volume( drive->volume );
RtlFreeHeap( GetProcessHeap(), 0, drive );
}
NTSTATUS
LsapCloseDbObject(PLSA_DB_OBJECT DbObject)
{
PLSA_DB_OBJECT ParentObject = NULL;
NTSTATUS Status = STATUS_SUCCESS;
DbObject->RefCount--;
if (DbObject->RefCount > 0)
return STATUS_SUCCESS;
if (DbObject->KeyHandle != NULL)
NtClose(DbObject->KeyHandle);
if (DbObject->ParentObject != NULL)
ParentObject = DbObject->ParentObject;
RtlFreeHeap(RtlGetProcessHeap(), 0, DbObject);
if (ParentObject != NULL)
{
ParentObject->RefCount--;
if (ParentObject->RefCount == 0)
Status = LsapCloseDbObject(ParentObject);
}
return Status;
}
VOID
RtlpFreeAtomTable(PRTL_ATOM_TABLE AtomTable)
{
RtlFreeHeap(RtlGetProcessHeap(),
0,
AtomTable);
}
/*
* @implemented
*/
INT
WINAPI
GetClipboardFormatNameA(UINT format,
LPSTR lpszFormatName,
int cchMaxCount)
{
LPWSTR lpBuffer;
INT Length;
lpBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, cchMaxCount * sizeof(WCHAR));
if (!lpBuffer)
{
SetLastError(ERROR_OUTOFMEMORY);
return 0;
}
/* we need a UNICODE string */
Length = NtUserGetClipboardFormatName(format, lpBuffer, cchMaxCount);
if (Length != 0)
{
if (!WideCharToMultiByte(CP_ACP, 0, lpBuffer, Length, lpszFormatName, cchMaxCount, NULL, NULL))
{
/* clear result string */
Length = 0;
}
lpszFormatName[Length] = '\0';
}
RtlFreeHeap(RtlGetProcessHeap(), 0, lpBuffer);
return Length;
}
BOOL
add_entry(
LPINT ac,
LPSTR **arg,
LPCSTR entry)
{
LPSTR q;
LPSTR *oldarg;
q = RtlAllocateHeap(ProcessHeap, 0, strlen(entry) + 1);
if (q == NULL)
return FALSE;
strcpy(q, entry);
oldarg = *arg;
*arg = RtlReAllocateHeap(ProcessHeap, 0, oldarg, (*ac + 2) * sizeof(LPSTR));
if (*arg == NULL)
{
RtlFreeHeap(ProcessHeap, 0, q);
*arg = oldarg;
return FALSE;
}
/* save new entry */
(*arg)[*ac] = q;
(*arg)[++(*ac)] = NULL;
return TRUE;
}
static
VOID
freep(
LPSTR *p)
{
LPSTR *q;
if (!p)
return;
q = p;
while (*q)
RtlFreeHeap(ProcessHeap, 0, *q++);
RtlFreeHeap(ProcessHeap, 0, p);
}
/*
* @implemented
*/
HBRUSH WINAPI
CreateDIBPatternBrush(
HGLOBAL hglbDIBPacked,
UINT fuColorSpec)
{
PVOID lpPackedDIB;
HBRUSH hBrush = NULL;
PBITMAPINFO pConvertedInfo;
UINT ConvertedInfoSize;
lpPackedDIB = GlobalLock(hglbDIBPacked);
if (lpPackedDIB == NULL)
return 0;
pConvertedInfo = ConvertBitmapInfo((PBITMAPINFO)lpPackedDIB, fuColorSpec,
&ConvertedInfoSize, TRUE);
if (pConvertedInfo)
{
hBrush = NtGdiCreateDIBBrush(pConvertedInfo, fuColorSpec,
ConvertedInfoSize, FALSE, FALSE, lpPackedDIB);
if ((PBITMAPINFO)lpPackedDIB != pConvertedInfo)
RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
}
GlobalUnlock(hglbDIBPacked);
return hBrush;
}
PCATALOG_ENTRY
CreateCatalogEntry(LPWSTR LibraryName)
{
PCATALOG_ENTRY Provider;
WS_DbgPrint(MAX_TRACE, ("LibraryName (%S).\n", LibraryName));
Provider = HeapAlloc(GlobalHeap, 0, sizeof(CATALOG_ENTRY));
if (!Provider)
return NULL;
ZeroMemory(Provider, sizeof(CATALOG_ENTRY));
if (!RtlCreateUnicodeString(&Provider->LibraryName, LibraryName))
{
RtlFreeHeap(GlobalHeap, 0, Provider);
return NULL;
}
Provider->ReferenceCount = 1;
InitializeCriticalSection(&Provider->Lock);
Provider->hModule = NULL;
Provider->Mapping = NULL;
//EnterCriticalSection(&CatalogLock);
InsertTailList(&CatalogListHead, &Provider->ListEntry);
//LeaveCriticalSection(&CatalogLock);
return Provider;
}
VOID
WINAPI
CloseAllProcessHandles(IN DWORD dwProcessId)
{
PDBGSS_THREAD_DATA *ThreadData;
PDBGSS_THREAD_DATA ThisData;
/* Loop all thread data events */
ThreadData = (PDBGSS_THREAD_DATA*)NtCurrentTeb()->DbgSsReserved;
ThisData = *ThreadData;
while(ThisData)
{
/* Check if this one matches */
if (ThisData->ProcessId == dwProcessId)
{
/* Close open handles */
if (ThisData->ThreadHandle) CloseHandle(ThisData->ThreadHandle);
if (ThisData->ProcessHandle) CloseHandle(ThisData->ProcessHandle);
/* Unlink the thread data */
*ThreadData = ThisData->Next;
/* Free it*/
RtlFreeHeap(RtlGetProcessHeap(), 0, ThisData);
}
else
{
/* Move to the next one */
ThreadData = &ThisData->Next;
}
ThisData = *ThreadData;
}
}
/***************************************************************************
* get_load_order (internal)
*
* Return the loadorder of a module.
* The system directory and '.dll' extension is stripped from the path.
*/
enum loadorder get_load_order( const WCHAR *app_name, const WCHAR *path )
{
enum loadorder ret = LO_INVALID;
HANDLE std_key, app_key = 0;
WCHAR *module, *basename;
UNICODE_STRING path_str;
int len;
if (!init_done) init_load_order();
std_key = get_standard_key();
if (app_name) app_key = get_app_key( app_name );
TRACE("looking for %s\n", debugstr_w(path));
/* Strip path information if the module resides in the system directory
*/
RtlInitUnicodeString( &path_str, path );
if (RtlPrefixUnicodeString( &system_dir, &path_str, TRUE ))
{
const WCHAR *p = path + system_dir.Length / sizeof(WCHAR);
while (*p == '\\' || *p == '/') p++;
if (!strchrW( p, '\\' ) && !strchrW( p, '/' )) path = p;
}
if (!(len = strlenW(path))) return ret;
if (!(module = RtlAllocateHeap( GetProcessHeap(), 0, (len + 2) * sizeof(WCHAR) ))) return ret;
strcpyW( module+1, path ); /* reserve module[0] for the wildcard char */
basename = (WCHAR *)get_basename( module+1 );
if (len >= 4) remove_dll_ext( module + 1 + len - 4 );
/* first explicit module name */
if ((ret = get_load_order_value( std_key, app_key, module+1 )) != LO_INVALID)
goto done;
/* then module basename preceded by '*' */
basename[-1] = '*';
if ((ret = get_load_order_value( std_key, app_key, basename-1 )) != LO_INVALID)
goto done;
/* then module basename without '*' (only if explicit path) */
if (basename != module+1 && ((ret = get_load_order_value( std_key, app_key, basename )) != LO_INVALID))
goto done;
/* if loading the main exe with an explicit path, try native first */
if (!app_name && basename != module+1)
{
ret = LO_NATIVE_BUILTIN;
TRACE( "got main exe default %s for %s\n", debugstr_loadorder(ret), debugstr_w(path) );
goto done;
}
/* and last the hard-coded default */
ret = LO_DEFAULT;
TRACE( "got hardcoded %s for %s\n", debugstr_loadorder(ret), debugstr_w(path) );
done:
RtlFreeHeap( GetProcessHeap(), 0, module );
return ret;
}
NTSTATUS NTAPI RtlCreateUserThread(HANDLE ProcessHandle, /*PSECURITY_DESCRIPTOR*/ PVOID SecurityDescriptor,
BOOLEAN CreateSuspended, ULONG StackZeroBits, PULONG StackReserved, PULONG StackCommit,
PVOID StartAddress, PVOID StartParameter, PHANDLE ThreadHandle, PCLIENT_ID ClientID)
{
char desc[1024];
HANDLE th;
CHECK_POINTER(ProcessHandle);
CHECK_POINTER(StartAddress);
CHECK_POINTER(ThreadHandle);
snprintf(desc, sizeof(desc), "ThreadProc @%p - param @%p", StartAddress, StartParameter);
__CreateHandle(th, HANDLE_TH, desc);
th->thread.StartAddress = StartAddress;
th->thread.StartParameter = StartParameter;
th->thread.ExitStatus = -1;
#ifdef THREADED
if (pthread_create(&th->thread.tid, NULL, thread_start, (void *) th))
{
RtlFreeHeap(HANDLE_HEAP, 0, th);
return STATUS_UNSUCCESSFUL;
}
#else
if (!setjmp(env))
thread_start(th);
#endif
*ThreadHandle = th;
return STATUS_SUCCESS;
}
// vlddelete - Local helper function that actually frees memory back to VLD's
// private heap.
//
// - block (IN): Pointer to a memory block being freed.
//
// Return Value:
//
// None.
//
void vlddelete (void *block)
{
if (block == NULL)
return;
BOOL freed;
vldblockheader_t *header = VLDBLOCKHEADER((LPVOID)block);
// Unlink the block from the block list.
g_vldHeapLock.Enter();
if (header->prev) {
header->prev->next = header->next;
}
else {
g_vldBlockList = header->next;
}
if (header->next) {
header->next->prev = header->prev;
}
g_vldHeapLock.Leave();
// Free the block.
freed = RtlFreeHeap(g_vldHeap, 0x0, header);
assert(freed != FALSE);
}
// PELF_FREE_ROUTINE
static
VOID NTAPI
LogfpFree(IN PVOID Ptr,
IN ULONG Flags)
{
RtlFreeHeap(GetProcessHeap(), Flags, Ptr);
}
VOID
RtlpFreeAtomTableEntry(PRTL_ATOM_TABLE_ENTRY Entry)
{
RtlFreeHeap(RtlGetProcessHeap(),
0,
Entry);
}
/* create the disk device for a given volume */
static NTSTATUS create_dos_device( struct volume *volume, const char *udi, int letter,
enum device_type type, struct dos_drive **drive_ret )
{
struct dos_drive *drive;
NTSTATUS status;
if (!(drive = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*drive) ))) return STATUS_NO_MEMORY;
drive->drive = letter;
drive->mount = NULL;
if (volume)
{
if (udi) set_volume_udi( volume, udi );
drive->volume = grab_volume( volume );
status = STATUS_SUCCESS;
}
else status = create_volume( udi, type, &drive->volume );
if (status == STATUS_SUCCESS)
{
list_add_tail( &drives_list, &drive->entry );
*drive_ret = drive;
}
else RtlFreeHeap( GetProcessHeap(), 0, drive );
return status;
}
/* delete the disk device for a given drive */
static void delete_disk_device( struct dos_drive *drive )
{
TRACE( "deleting device %s\n", debugstr_w(drive->name.Buffer) );
list_remove( &drive->entry );
if (drive->dosdev) delete_mount_point( drive->dosdev );
if (drive->volume) delete_mount_point( drive->volume );
if (drive->symlink.Buffer)
{
IoDeleteSymbolicLink( &drive->symlink );
RtlFreeUnicodeString( &drive->symlink );
}
RtlFreeHeap( GetProcessHeap(), 0, drive->unix_device );
RtlFreeHeap( GetProcessHeap(), 0, drive->unix_mount );
RtlFreeHeap( GetProcessHeap(), 0, drive->udi );
RtlFreeUnicodeString( &drive->name );
IoDeleteDevice( drive->device );
}
void ext2_free_group_desc(PEXT2_FILESYS Ext2Sys)
{
if (Ext2Sys->group_desc)
{
RtlFreeHeap(RtlGetProcessHeap(), 0, Ext2Sys->group_desc);
Ext2Sys->group_desc = NULL;
}
}
static
PINICACHESECTION
IniCacheAddSection(
PINICACHE Cache,
PCHAR Name,
ULONG NameLength)
{
PINICACHESECTION Section = NULL;
ULONG i;
if (Cache == NULL || Name == NULL || NameLength == 0)
{
DPRINT("Invalid parameter\n");
return NULL;
}
Section = (PINICACHESECTION)RtlAllocateHeap(ProcessHeap,
HEAP_ZERO_MEMORY,
sizeof(INICACHESECTION));
if (Section == NULL)
{
DPRINT("RtlAllocateHeap() failed\n");
return NULL;
}
/* Allocate and initialize section name */
Section->Name = (WCHAR*)RtlAllocateHeap(ProcessHeap,
0,
(NameLength + 1) * sizeof(WCHAR));
if (Section->Name == NULL)
{
DPRINT("RtlAllocateHeap() failed\n");
RtlFreeHeap(ProcessHeap, 0, Section);
return NULL;
}
/* Copy section name */
for (i = 0; i < NameLength; i++)
{
Section->Name[i] = (WCHAR)Name[i];
}
Section->Name[NameLength] = 0;
/* Append section */
if (Cache->FirstSection == NULL)
{
Cache->FirstSection = Section;
Cache->LastSection = Section;
}
else
{
Cache->LastSection->Next = Section;
Section->Prev = Cache->LastSection;
Cache->LastSection = Section;
}
return Section;
}
/*
* @implemented
*/
BOOL
WINAPI
QueryFullProcessImageNameW(HANDLE hProcess,
DWORD dwFlags,
LPWSTR lpExeName,
PDWORD pdwSize)
{
BYTE Buffer[sizeof(UNICODE_STRING) + MAX_PATH * sizeof(WCHAR)];
UNICODE_STRING *DynamicBuffer = NULL;
UNICODE_STRING *Result = NULL;
NTSTATUS Status;
DWORD Needed;
Status = NtQueryInformationProcess(hProcess,
ProcessImageFileName,
Buffer,
sizeof(Buffer) - sizeof(WCHAR),
&Needed);
if (Status == STATUS_INFO_LENGTH_MISMATCH)
{
DynamicBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, Needed + sizeof(WCHAR));
if (!DynamicBuffer)
{
BaseSetLastNTError(STATUS_NO_MEMORY);
return FALSE;
}
Status = NtQueryInformationProcess(hProcess,
ProcessImageFileName,
(LPBYTE)DynamicBuffer,
Needed,
&Needed);
Result = DynamicBuffer;
}
else Result = (PUNICODE_STRING)Buffer;
if (!NT_SUCCESS(Status)) goto Cleanup;
if (Result->Length / sizeof(WCHAR) + 1 > *pdwSize)
{
Status = STATUS_BUFFER_TOO_SMALL;
goto Cleanup;
}
*pdwSize = Result->Length / sizeof(WCHAR);
memcpy(lpExeName, Result->Buffer, Result->Length);
lpExeName[*pdwSize] = 0;
Cleanup:
RtlFreeHeap(RtlGetProcessHeap(), 0, DynamicBuffer);
if (!NT_SUCCESS(Status))
{
BaseSetLastNTError(Status);
}
return !Status;
}
NTSTATUS
LsapDeleteDbObject(IN PLSA_DB_OBJECT DbObject)
{
PLSA_DB_OBJECT ParentObject = NULL;
WCHAR KeyName[64];
ULONG Index;
NTSTATUS Status = STATUS_SUCCESS;
DbObject->RefCount--;
if (DbObject->RefCount > 0)
return STATUS_SUCCESS;
if (DbObject->KeyHandle != NULL)
{
Index = 0;
while (TRUE)
{
Status = LsapRegEnumerateSubKey(DbObject->KeyHandle,
Index,
64 * sizeof(WCHAR),
KeyName);
if (!NT_SUCCESS(Status))
break;
TRACE("Index: %lu\n", Index);
TRACE("Key name: %S\n", KeyName);
Status = LsapRegDeleteSubKey(DbObject->KeyHandle,
KeyName);
if (!NT_SUCCESS(Status))
break;
}
if (Status == STATUS_NO_MORE_ENTRIES)
Status = STATUS_SUCCESS;
LsapRegDeleteKey(DbObject->KeyHandle);
NtClose(DbObject->KeyHandle);
}
if (DbObject->ParentObject != NULL)
ParentObject = DbObject->ParentObject;
RtlFreeHeap(RtlGetProcessHeap(), 0, DbObject);
if (ParentObject != NULL)
{
ParentObject->RefCount--;
if (ParentObject->RefCount == 0)
Status = LsapCloseDbObject(ParentObject);
}
return Status;
}
/***********************************************************************
* exit_thread
*/
void exit_thread( int status )
{
static void *prev_teb;
TEB *teb;
if (status) /* send the exit code to the server (0 is already the default) */
{
SERVER_START_REQ( terminate_thread )
{
req->handle = wine_server_obj_handle( GetCurrentThread() );
req->exit_code = status;
wine_server_call( req );
}
SERVER_END_REQ;
}
if (interlocked_xchg_add( &nb_threads, -1 ) <= 1)
{
LdrShutdownProcess();
exit( status );
}
LdrShutdownThread();
RtlAcquirePebLock();
RemoveEntryList( &NtCurrentTeb()->TlsLinks );
RtlReleasePebLock();
RtlFreeHeap( GetProcessHeap(), 0, NtCurrentTeb()->FlsSlots );
RtlFreeHeap( GetProcessHeap(), 0, NtCurrentTeb()->TlsExpansionSlots );
pthread_sigmask( SIG_BLOCK, &server_block_set, NULL );
if ((teb = interlocked_xchg_ptr( &prev_teb, NtCurrentTeb() )))
{
struct ntdll_thread_data *thread_data = (struct ntdll_thread_data *)teb->SpareBytes1;
pthread_join( thread_data->pthread_id, NULL );
signal_free_thread( teb );
}
close( ntdll_get_thread_data()->wait_fd[0] );
close( ntdll_get_thread_data()->wait_fd[1] );
close( ntdll_get_thread_data()->reply_fd );
close( ntdll_get_thread_data()->request_fd );
pthread_exit( UIntToPtr(status) );
}