Commit 96c08d81 authored by Alexandre Julliard's avatar Alexandre Julliard

Use server handles directly for Win32 handles. Removed use of K32OBJ.

parent ee517e86
......@@ -17,12 +17,6 @@
#include "server.h"
#include "debug.h"
/* The change notification object */
typedef struct
{
K32OBJ header;
} CHANGE_OBJECT;
/****************************************************************************
* FindFirstChangeNotification32A (KERNEL32.248)
......@@ -31,7 +25,6 @@ HANDLE WINAPI FindFirstChangeNotificationA( LPCSTR lpPathName,
BOOL bWatchSubtree,
DWORD dwNotifyFilter )
{
CHANGE_OBJECT *change;
struct create_change_notification_request req;
struct create_change_notification_reply reply;
......@@ -39,19 +32,7 @@ HANDLE WINAPI FindFirstChangeNotificationA( LPCSTR lpPathName,
req.filter = dwNotifyFilter;
CLIENT_SendRequest( REQ_CREATE_CHANGE_NOTIFICATION, -1, 1, &req, sizeof(req) );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
if (reply.handle == -1) return INVALID_HANDLE_VALUE;
change = HeapAlloc( SystemHeap, 0, sizeof(CHANGE_OBJECT) );
if (!change)
{
CLIENT_CloseHandle( reply.handle );
return INVALID_HANDLE_VALUE;
}
change->header.type = K32OBJ_CHANGE;
change->header.refcount = 1;
return HANDLE_Alloc( PROCESS_Current(), &change->header,
STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE /*FIXME*/,
FALSE, reply.handle );
return reply.handle;
}
/****************************************************************************
......@@ -73,9 +54,6 @@ HANDLE WINAPI FindFirstChangeNotificationW( LPCWSTR lpPathName,
*/
BOOL WINAPI FindNextChangeNotification( HANDLE handle )
{
if (HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_FILE, 0 ) == -1)
return FALSE;
/* FIXME: do something */
return TRUE;
}
......
......@@ -609,9 +609,7 @@ const DOS_DEVICE *DOSFS_GetDeviceByHandle( HFILE hFile )
struct get_file_info_request req;
struct get_file_info_reply reply;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hFile,
K32OBJ_FILE, 0 )) == -1)
return NULL;
req.handle = hFile;
CLIENT_SendRequest( REQ_GET_FILE_INFO, -1, 1, &req, sizeof(req) );
if (!CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL ) &&
(reply.type == FILE_TYPE_UNKNOWN))
......
......@@ -50,13 +50,6 @@
#define MAP_ANON MAP_ANONYMOUS
#endif
/* The file object */
typedef struct
{
K32OBJ header;
} FILE_OBJECT;
/* Size of per-process table of DOS handles */
#define DOS_TABLE_SIZE 256
......@@ -309,7 +302,6 @@ void FILE_SetDosError(void)
*/
HFILE FILE_DupUnixHandle( int fd, DWORD access )
{
FILE_OBJECT *file;
int unix_handle;
struct create_file_request req;
struct create_file_reply reply;
......@@ -328,18 +320,7 @@ HFILE FILE_DupUnixHandle( int fd, DWORD access )
CLIENT_SendRequest( REQ_CREATE_FILE, unix_handle, 1,
&req, sizeof(req) );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
if (reply.handle == -1) return INVALID_HANDLE_VALUE;
if (!(file = HeapAlloc( SystemHeap, 0, sizeof(FILE_OBJECT) )))
{
CLIENT_CloseHandle( reply.handle );
SetLastError( ERROR_TOO_MANY_OPEN_FILES );
return (HFILE)NULL;
}
file->header.type = K32OBJ_FILE;
file->header.refcount = 0;
return HANDLE_Alloc( PROCESS_Current(), &file->header, req.access,
req.inherit, reply.handle );
return reply.handle;
}
......@@ -352,7 +333,6 @@ HFILE FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
LPSECURITY_ATTRIBUTES sa, DWORD creation,
DWORD attributes, HANDLE template )
{
FILE_OBJECT *file;
struct create_file_request req;
struct create_file_reply reply;
......@@ -382,20 +362,7 @@ HFILE FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
}
}
if (reply.handle == -1) return INVALID_HANDLE_VALUE;
/* Now build the FILE_OBJECT */
if (!(file = HeapAlloc( SystemHeap, 0, sizeof(FILE_OBJECT) )))
{
SetLastError( ERROR_OUTOFMEMORY );
CLIENT_CloseHandle( reply.handle );
return (HFILE)INVALID_HANDLE_VALUE;
}
file->header.type = K32OBJ_FILE;
file->header.refcount = 0;
return HANDLE_Alloc( PROCESS_Current(), &file->header, req.access,
req.inherit, reply.handle );
return reply.handle;
}
......@@ -406,7 +373,6 @@ HFILE FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
*/
HFILE FILE_CreateDevice( int client_id, DWORD access, LPSECURITY_ATTRIBUTES sa )
{
FILE_OBJECT *file;
struct create_device_request req;
struct create_device_reply reply;
......@@ -415,20 +381,7 @@ HFILE FILE_CreateDevice( int client_id, DWORD access, LPSECURITY_ATTRIBUTES sa )
req.id = client_id;
CLIENT_SendRequest( REQ_CREATE_DEVICE, -1, 1, &req, sizeof(req) );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
if (reply.handle == -1) return INVALID_HANDLE_VALUE;
/* Now build the FILE_OBJECT */
if (!(file = HeapAlloc( SystemHeap, 0, sizeof(FILE_OBJECT) )))
{
SetLastError( ERROR_OUTOFMEMORY );
CLIENT_CloseHandle( reply.handle );
return (HFILE)INVALID_HANDLE_VALUE;
}
file->header.type = K32OBJ_FILE;
file->header.refcount = 0;
return HANDLE_Alloc( PROCESS_Current(), &file->header, req.access,
req.inherit, reply.handle );
return reply.handle;
}
......@@ -597,9 +550,7 @@ DWORD WINAPI GetFileInformationByHandle( HFILE hFile,
struct get_file_info_reply reply;
if (!info) return 0;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hFile,
K32OBJ_FILE, 0 )) == -1)
return 0;
req.handle = hFile;
CLIENT_SendRequest( REQ_GET_FILE_INFO, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL ))
return 0;
......@@ -1141,9 +1092,7 @@ BOOL WINAPI ReadFile( HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
if (bytesRead) *bytesRead = 0; /* Do this before anything else */
if (!bytesToRead) return TRUE;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hFile,
K32OBJ_UNKNOWN, GENERIC_READ )) == -1)
return FALSE;
req.handle = hFile;
CLIENT_SendRequest( REQ_GET_READ_FD, -1, 1, &req, sizeof(req) );
CLIENT_WaitReply( NULL, &unix_handle, 0 );
if (unix_handle == -1) return FALSE;
......@@ -1175,9 +1124,7 @@ BOOL WINAPI WriteFile( HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
if (bytesWritten) *bytesWritten = 0; /* Do this before anything else */
if (!bytesToWrite) return TRUE;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hFile,
K32OBJ_UNKNOWN, GENERIC_WRITE )) == -1)
return FALSE;
req.handle = hFile;
CLIENT_SendRequest( REQ_GET_WRITE_FD, -1, 1, &req, sizeof(req) );
CLIENT_WaitReply( NULL, &unix_handle, 0 );
if (unix_handle == -1) return FALSE;
......@@ -1293,9 +1240,7 @@ DWORD WINAPI SetFilePointer( HFILE hFile, LONG distance, LONG *highword,
TRACE(file, "handle %d offset %ld origin %ld\n",
hFile, distance, method );
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hFile,
K32OBJ_FILE, 0 )) == -1)
return 0xffffffff;
req.handle = hFile;
req.low = distance;
req.high = highword ? *highword : 0;
/* FIXME: assumes 1:1 mapping between Windows and Unix seek constants */
......@@ -1493,9 +1438,7 @@ BOOL WINAPI FlushFileBuffers( HFILE hFile )
{
struct flush_file_request req;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hFile,
K32OBJ_FILE, 0 )) == -1)
return FALSE;
req.handle = hFile;
CLIENT_SendRequest( REQ_FLUSH_FILE, -1, 1, &req, sizeof(req) );
return !CLIENT_WaitReply( NULL, NULL, 0 );
}
......@@ -1508,9 +1451,7 @@ BOOL WINAPI SetEndOfFile( HFILE hFile )
{
struct truncate_file_request req;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hFile,
K32OBJ_FILE, 0 )) == -1)
return FALSE;
req.handle = hFile;
CLIENT_SendRequest( REQ_TRUNCATE_FILE, -1, 1, &req, sizeof(req) );
return !CLIENT_WaitReply( NULL, NULL, 0 );
}
......@@ -1667,9 +1608,7 @@ DWORD WINAPI GetFileType( HFILE hFile )
struct get_file_info_request req;
struct get_file_info_reply reply;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hFile,
K32OBJ_UNKNOWN, 0 )) == -1)
return FILE_TYPE_UNKNOWN;
req.handle = hFile;
CLIENT_SendRequest( REQ_GET_FILE_INFO, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL ))
return FILE_TYPE_UNKNOWN;
......@@ -1950,9 +1889,7 @@ BOOL WINAPI SetFileTime( HFILE hFile,
{
struct set_file_time_request req;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hFile,
K32OBJ_FILE, GENERIC_WRITE )) == -1)
return FALSE;
req.handle = hFile;
if (lpLastAccessTime)
req.access_time = DOSFS_FileTimeToUnixTime(lpLastAccessTime, NULL);
else
......@@ -1975,9 +1912,7 @@ BOOL WINAPI LockFile( HFILE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh
{
struct lock_file_request req;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hFile,
K32OBJ_FILE, 0 )) == -1)
return FALSE;
req.handle = hFile;
req.offset_low = dwFileOffsetLow;
req.offset_high = dwFileOffsetHigh;
req.count_low = nNumberOfBytesToLockLow;
......@@ -1995,9 +1930,7 @@ BOOL WINAPI UnlockFile( HFILE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHi
{
struct unlock_file_request req;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hFile,
K32OBJ_FILE, 0 )) == -1)
return FALSE;
req.handle = hFile;
req.offset_low = dwFileOffsetLow;
req.offset_high = dwFileOffsetHigh;
req.count_low = nNumberOfBytesToUnlockLow;
......
......@@ -8,7 +8,7 @@
#define __WINE_FILE_H
#include <time.h> /* time_t */
#include "k32obj.h"
#include "winbase.h"
#define MAX_PATHNAME_LEN 1024
......
/*
* KERNEL32 objects
*
* Copyright 1996, 1998 Alexandre Julliard
*/
#ifndef __WINE_K32OBJ_H
#define __WINE_K32OBJ_H
#include "wintypes.h"
#include "winbase.h" /* SECURITY_ATTRIBUTES */
/* Object types */
typedef enum
{
K32OBJ_UNKNOWN = 0,
K32OBJ_SEMAPHORE,
K32OBJ_EVENT,
K32OBJ_MUTEX,
K32OBJ_CRITICAL_SECTION,
K32OBJ_PROCESS,
K32OBJ_THREAD,
K32OBJ_FILE,
K32OBJ_CHANGE,
K32OBJ_CONSOLE,
K32OBJ_SCREEN_BUFFER,
K32OBJ_MEM_MAPPED_FILE,
K32OBJ_SERIAL,
K32OBJ_DEVICE_IOCTL,
K32OBJ_PIPE,
K32OBJ_MAILSLOT,
K32OBJ_TOOLHELP_SNAPSHOT,
K32OBJ_SOCKET,
K32OBJ_NBOBJECTS
} K32OBJ_TYPE;
/* Kernel object */
typedef struct
{
K32OBJ_TYPE type;
LONG refcount;
} K32OBJ;
/* Kernel object operations */
typedef struct
{
void (*destroy)(K32OBJ *); /* Destroy object on refcount==0 */
} K32OBJ_OPS;
extern const K32OBJ_OPS * const K32OBJ_Ops[K32OBJ_NBOBJECTS];
#define K32OBJ_OPS(obj) (K32OBJ_Ops[(obj)->type])
extern void K32OBJ_IncCount( K32OBJ *ptr );
extern void K32OBJ_DecCount( K32OBJ *ptr );
extern BOOL K32OBJ_IsValid( K32OBJ *ptr, K32OBJ_TYPE type );
extern BOOL K32OBJ_AddName( K32OBJ *obj, LPCSTR name );
extern K32OBJ *K32OBJ_Create( K32OBJ_TYPE type, DWORD size, LPCSTR name,
int server_handle, DWORD access,
SECURITY_ATTRIBUTES *sa, HANDLE *handle );
extern K32OBJ *K32OBJ_FindName( LPCSTR name );
extern K32OBJ *K32OBJ_FindNameType( LPCSTR name, K32OBJ_TYPE type );
#endif /* __WINE_K32OBJ_H */
......@@ -9,26 +9,10 @@
#include "wintypes.h"
#include "module.h"
#include "k32obj.h"
struct _NE_MODULE;
struct _THREAD_ENTRY;
/* Process handle entry */
typedef struct
{
DWORD access; /* Access flags */
K32OBJ *ptr; /* Object ptr */
int server; /* Server handle (FIXME: tmp hack) */
} HANDLE_ENTRY;
/* Process handle table */
typedef struct
{
DWORD count;
HANDLE_ENTRY entries[1];
} HANDLE_TABLE;
/* Current Process pseudo-handle - Returned by GetCurrentProcess*/
#define CURRENT_PROCESS_PSEUDOHANDLE ((HANDLE)0x7fffffff)
......@@ -39,16 +23,16 @@ typedef struct
DWORD unknown1; /* 04 Unknown */
LPSTR cmd_line; /* 08 Command line */
LPSTR cur_dir; /* 0c Current directory */
STARTUPINFOA *startup_info; /* 10 Startup information */
HANDLE hStdin; /* 14 Handle for standard input */
HANDLE hStdout; /* 18 Handle for standard output */
HANDLE hStderr; /* 1c Handle for standard error */
STARTUPINFOA *startup_info; /* 10 Startup information */
HANDLE hStdin; /* 14 Handle for standard input */
HANDLE hStdout; /* 18 Handle for standard output */
HANDLE hStderr; /* 1c Handle for standard error */
DWORD unknown2; /* 20 Unknown */
DWORD inherit_console; /* 24 Inherit console flag */
DWORD break_type; /* 28 Console events flag */
K32OBJ *break_sem; /* 2c SetConsoleCtrlHandler semaphore */
K32OBJ *break_event; /* 30 SetConsoleCtrlHandler event */
K32OBJ *break_thread; /* 34 SetConsoleCtrlHandler thread */
void *break_sem; /* 2c SetConsoleCtrlHandler semaphore */
void *break_event; /* 30 SetConsoleCtrlHandler event */
void *break_thread; /* 34 SetConsoleCtrlHandler thread */
void *break_handlers; /* 38 List of console handlers */
/* The following are Wine-specific fields */
CRITICAL_SECTION section; /* 3c Env DB critical section */
......@@ -59,9 +43,9 @@ typedef struct
/* Win32 process database */
typedef struct _PDB
{
K32OBJ header; /* 00 Kernel object header */
LONG header[2]; /* 00 Kernel object header */
DWORD unknown1; /* 08 Unknown */
K32OBJ *event; /* 0c Pointer to an event object (unused) */
void *event; /* 0c Pointer to an event object (unused) */
DWORD exit_code; /* 10 Process exit code */
DWORD unknown2; /* 14 Unknown */
HANDLE heap; /* 18 Default process heap */
......@@ -78,7 +62,7 @@ typedef struct _PDB
HTASK task; /* 38 Win16 task */
void *mem_map_files; /* 3c Pointer to mem-mapped files */
ENVDB *env_db; /* 40 Environment database */
HANDLE_TABLE *handle_table; /* 44 Handle table */
void *handle_table; /* 44 Handle table */
struct _PDB *parent; /* 48 Parent process */
WINE_MODREF *modref_list; /* 4c MODREF list */
void *thread_list; /* 50 List of threads */
......@@ -87,7 +71,7 @@ typedef struct _PDB
DWORD unknown4; /* 5c Unknown */
CRITICAL_SECTION crit_section; /* 60 Critical section */
DWORD unknown5[3]; /* 78 Unknown */
K32OBJ *console; /* 84 Console */
void *console; /* 84 Console */
DWORD tls_bits[2]; /* 88 TLS in-use bits */
DWORD process_dword; /* 90 Unknown */
struct _PDB *group; /* 94 Process group */
......@@ -97,7 +81,7 @@ typedef struct _PDB
HANDLE heap_list; /* a4 Head of process heap list */
void *heap_handles; /* a8 Head of heap handles list */
DWORD unknown6; /* ac Unknown */
K32OBJ *console_provider; /* b0 Console provider (??) */
void *console_provider; /* b0 Console provider (??) */
WORD env_selector; /* b4 Selector to process environment */
WORD error_mode; /* b6 Error mode */
HANDLE load_done_evt; /* b8 Event for process loading done */
......@@ -122,21 +106,6 @@ extern BOOL ENV_BuildEnvironment( PDB *pdb );
extern BOOL ENV_InheritEnvironment( PDB *pdb, LPCSTR env );
extern void ENV_FreeEnvironment( PDB *pdb );
/* scheduler/handle.c */
extern BOOL HANDLE_CreateTable( PDB *pdb, BOOL inherit );
extern HANDLE HANDLE_Alloc( PDB *pdb, K32OBJ *ptr, DWORD access,
BOOL inherit, int server_handle );
extern int HANDLE_GetServerHandle( PDB *pdb, HANDLE handle,
K32OBJ_TYPE type, DWORD access );
extern void HANDLE_CloseAll( PDB *pdb, K32OBJ *ptr );
/* Global handle macros */
#define HANDLE_OBFUSCATOR ((DWORD)0x544a4def)
#define HANDLE_IS_GLOBAL(h) (((DWORD)(h) ^ HANDLE_OBFUSCATOR) < 0x10000)
#define HANDLE_LOCAL_TO_GLOBAL(h) ((HANDLE)((DWORD)(h) ^ HANDLE_OBFUSCATOR))
#define HANDLE_GLOBAL_TO_LOCAL(h) ((HANDLE)((DWORD)(h) ^ HANDLE_OBFUSCATOR))
/* scheduler/process.c */
extern BOOL PROCESS_Init( void );
extern PDB *PROCESS_Current(void);
......@@ -147,11 +116,9 @@ extern PDB *PROCESS_Create( struct _NE_MODULE *pModule, LPCSTR cmd_line,
LPCSTR env, HINSTANCE16 hInstance,
HINSTANCE16 hPrevInstance, BOOL inherit,
STARTUPINFOA *startup, PROCESS_INFORMATION *info );
extern void PROCESS_FreePDB( PDB *pdb );
extern void PROCESS_SuspendOtherThreads(void);
extern void PROCESS_ResumeOtherThreads(void);
extern int PROCESS_PDBList_Getsize (void);
extern PDB* PROCESS_PDBList_Getfirst (void);
extern PDB* PROCESS_PDBList_Getnext (PDB*);
#endif /* __WINE_PROCESS_H */
......@@ -9,7 +9,6 @@
#include "config.h"
#include "winbase.h"
#include "k32obj.h"
#include "selectors.h" /* for SET_FS */
#ifdef linux
......@@ -58,9 +57,9 @@ typedef struct _TEB
/* Thread database */
typedef struct _THDB
{
K32OBJ header; /* 00 Kernel object header */
struct _PDB *process; /* 08 Process owning this thread */
HANDLE event; /* 0c Thread event */
LONG header[2]; /* 00 Kernel object header */
struct _PDB *process; /* 08 Process owning this thread */
HANDLE event; /* 0c Thread event */
TEB teb; /* 10 Thread exception block */
DWORD flags; /* 44 Flags */
DWORD exit_code; /* 48 Termination status */
......
......@@ -538,8 +538,8 @@ static void TASK_DeleteTask( HTASK16 hTask )
/* Delete the Win32 part of the task */
K32OBJ_DecCount( &pTask->thdb->process->header );
K32OBJ_DecCount( &pTask->thdb->header );
/* PROCESS_FreePDB( pTask->thdb->process ); FIXME */
/* K32OBJ_DecCount( &pTask->thdb->header ); FIXME */
/* Free the selector aliases */
......
......@@ -27,12 +27,6 @@
#define MS_SYNC 0
#endif
/* File mapping */
typedef struct
{
K32OBJ header;
} FILE_MAPPING;
/* File view */
typedef struct _FV
{
......@@ -1055,40 +1049,9 @@ HANDLE WINAPI CreateFileMappingA(
DWORD size_low, /* [in] Low-order 32 bits of object size */
LPCSTR name /* [in] Name of file-mapping object */ )
{
FILE_MAPPING *mapping = NULL;
struct create_mapping_request req;
struct create_mapping_reply reply = { -1 };
HANDLE handle;
struct create_mapping_reply reply;
BYTE vprot;
BOOL inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
/* First search for an object with the same name */
K32OBJ *obj = K32OBJ_FindName( name );
if (obj)
{
if (obj->type == K32OBJ_MEM_MAPPED_FILE)
{
req.handle = -1;
CLIENT_SendRequest( REQ_CREATE_MAPPING, -1, 2,
&req, sizeof(req),
name, name ? strlen(name) + 1 : 0 );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
if (reply.handle == -1) return 0;
if (GetLastError() != ERROR_ALREADY_EXISTS)
return 0; /* not supposed to happen */
handle = HANDLE_Alloc( PROCESS_Current(), obj,
FILE_MAP_ALL_ACCESS /*FIXME*/, inherit, reply.handle );
}
else
{
SetLastError( ERROR_DUP_NAME );
handle = 0;
}
K32OBJ_DecCount( obj );
return handle;
}
/* Check parameters */
......@@ -1107,52 +1070,19 @@ HANDLE WINAPI CreateFileMappingA(
else vprot |= VPROT_COMMITTED;
if (protect & SEC_NOCACHE) vprot |= VPROT_NOCACHE;
/* Compute the size and extend the file if necessary */
if (hFile != INVALID_HANDLE_VALUE) /* We have a file */
{
DWORD access = GENERIC_READ;
if (((protect & 0xff) == PAGE_READWRITE) ||
((protect & 0xff) == PAGE_WRITECOPY) ||
((protect & 0xff) == PAGE_EXECUTE_READWRITE) ||
((protect & 0xff) == PAGE_EXECUTE_WRITECOPY))
access |= GENERIC_WRITE;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hFile,
K32OBJ_FILE, access )) == -1) goto error;
}
else req.handle = -1;
/* Create the server object */
req.handle = hFile;
req.size_high = size_high;
req.size_low = ROUND_SIZE( 0, size_low );
req.size_low = size_low;
req.protect = vprot;
req.inherit = inherit;
req.inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
CLIENT_SendRequest( REQ_CREATE_MAPPING, -1, 2,
&req, sizeof(req),
name, name ? strlen(name) + 1 : 0 );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL ))
goto error;
/* Allocate the mapping object */
if (!(mapping = HeapAlloc( SystemHeap, 0, sizeof(*mapping) ))) goto error;
mapping->header.type = K32OBJ_MEM_MAPPED_FILE;
mapping->header.refcount = 1;
if (!K32OBJ_AddName( &mapping->header, name )) handle = 0;
else handle = HANDLE_Alloc( PROCESS_Current(), &mapping->header,
FILE_MAP_ALL_ACCESS /*FIXME*/, inherit, reply.handle );
K32OBJ_DecCount( &mapping->header );
SetLastError(0); /* Last error value is relevant. (see the start of fun) */
return handle;
error:
if (reply.handle != -1) CLIENT_CloseHandle( reply.handle );
if (mapping) HeapFree( SystemHeap, 0, mapping );
return 0;
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
if (reply.handle == -1) return 0;
return reply.handle;
}
......@@ -1185,8 +1115,6 @@ HANDLE WINAPI OpenFileMappingA(
BOOL inherit, /* [in] Inherit flag */
LPCSTR name ) /* [in] Name of file-mapping object */
{
HANDLE handle = 0;
K32OBJ *obj;
struct open_named_obj_request req;
struct open_named_obj_reply reply;
int len = name ? strlen(name) + 1 : 0;
......@@ -1196,21 +1124,8 @@ HANDLE WINAPI OpenFileMappingA(
req.inherit = inherit;
CLIENT_SendRequest( REQ_OPEN_NAMED_OBJ, -1, 2, &req, sizeof(req), name, len );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
if (reply.handle != -1)
{
SYSTEM_LOCK();
if ((obj = K32OBJ_FindNameType( name, K32OBJ_MEM_MAPPED_FILE )))
{
handle = HANDLE_Alloc( PROCESS_Current(), obj, access, inherit, reply.handle );
K32OBJ_DecCount( obj );
if (handle == INVALID_HANDLE_VALUE)
handle = 0; /* must return 0 on failure, not -1 */
}
else CLIENT_CloseHandle( reply.handle );
SYSTEM_UNLOCK();
}
return handle;
if (reply.handle == -1) return 0; /* must return 0 on failure, not -1 */
return reply.handle;
}
......@@ -1279,8 +1194,7 @@ LPVOID WINAPI MapViewOfFileEx(
return NULL;
}
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_MEM_MAPPED_FILE, 0 /* FIXME */ );
req.handle = handle;
CLIENT_SendRequest( REQ_GET_MAPPING_INFO, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &info, sizeof(info), &unix_handle ))
goto error;
......
......@@ -16,17 +16,10 @@
#include "tlhelp32.h"
#include "toolhelp.h"
#include "heap.h"
#include "k32obj.h"
#include "server.h"
#include "debug.h"
/* The K32 snapshot object object */
typedef struct
{
K32OBJ header;
} SNAPSHOT_OBJECT;
/* FIXME: to make this working, we have to callback all these registered
* functions from all over the WINE code. Someone with more knowledge than
* me please do that. -Marcus
......@@ -121,7 +114,6 @@ FARPROC16 tmp;
*/
HANDLE WINAPI CreateToolhelp32Snapshot( DWORD flags, DWORD process )
{
SNAPSHOT_OBJECT *snapshot;
struct create_snapshot_request req;
struct create_snapshot_reply reply;
......@@ -133,21 +125,13 @@ HANDLE WINAPI CreateToolhelp32Snapshot( DWORD flags, DWORD process )
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
return INVALID_HANDLE_VALUE;
}
/* Now do the snapshot */
if (!(snapshot = HeapAlloc( SystemHeap, 0, sizeof(*snapshot) )))
return INVALID_HANDLE_VALUE;
snapshot->header.type = K32OBJ_TOOLHELP_SNAPSHOT;
snapshot->header.refcount = 1;
/* Now do the snapshot */
req.flags = flags & ~TH32CS_INHERIT;
req.inherit = (flags & TH32CS_INHERIT) != 0;
CLIENT_SendRequest( REQ_CREATE_SNAPSHOT, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL ))
{
HeapFree( SystemHeap, 0, snapshot );
return INVALID_HANDLE_VALUE;
}
return HANDLE_Alloc( PROCESS_Current(), &snapshot->header, 0, req.inherit, reply.handle );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
return reply.handle;
}
......@@ -167,9 +151,7 @@ static BOOL TOOLHELP_Process32Next( HANDLE handle, LPPROCESSENTRY lppe, BOOL fir
ERR (toolhelp, "Result buffer too small\n");
return FALSE;
}
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_TOOLHELP_SNAPSHOT, 0 )) == -1)
return FALSE;
req.handle = handle;
req.reset = first;
CLIENT_SendRequest( REQ_NEXT_PROCESS, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL )) return FALSE;
......
......@@ -10,7 +10,6 @@ C_SRCS = \
critsection.c \
event.c \
handle.c \
k32obj.c \
mutex.c \
pipe.c \
process.c \
......
......@@ -288,9 +288,9 @@ int CLIENT_NewThread( THDB *thdb, int *thandle, int *phandle )
fcntl( fd[0], F_SETFD, 1 ); /* set close on exec flag */
if (thandle) *thandle = reply.thandle;
else if (reply.thandle != -1) CLIENT_CloseHandle( reply.thandle );
else if (reply.thandle != -1) CloseHandle( reply.thandle );
if (phandle) *phandle = reply.phandle;
else if (reply.phandle != -1) CLIENT_CloseHandle( reply.phandle );
else if (reply.phandle != -1) CloseHandle( reply.phandle );
return 0;
error:
......@@ -330,57 +330,3 @@ int CLIENT_SetDebug( int level )
CLIENT_SendRequest( REQ_SET_DEBUG, -1, 1, &level, sizeof(level) );
return CLIENT_WaitReply( NULL, NULL, 0 );
}
/***********************************************************************
* CLIENT_CloseHandle
*
* Send a close handle request. Return 0 if OK.
*/
int CLIENT_CloseHandle( int handle )
{
CLIENT_SendRequest( REQ_CLOSE_HANDLE, -1, 1, &handle, sizeof(handle) );
return CLIENT_WaitReply( NULL, NULL, 0 );
}
/***********************************************************************
* CLIENT_DuplicateHandle
*
* Send a duplicate handle request. Return 0 if OK.
*/
int CLIENT_DuplicateHandle( int src_process, int src_handle, int dst_process, int dst_handle,
DWORD access, BOOL inherit, DWORD options )
{
struct dup_handle_request req;
struct dup_handle_reply reply;
req.src_process = src_process;
req.src_handle = src_handle;
req.dst_process = dst_process;
req.access = access;
req.inherit = inherit;
req.options = options;
CLIENT_SendRequest( REQ_DUP_HANDLE, -1, 1, &req, sizeof(req) );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
return reply.handle;
}
/***********************************************************************
* CLIENT_OpenProcess
*
* Open a handle to a process.
*/
int CLIENT_OpenProcess( void *pid, DWORD access, BOOL inherit )
{
struct open_process_request req;
struct open_process_reply reply;
req.pid = pid;
req.access = access;
req.inherit = inherit;
CLIENT_SendRequest( REQ_OPEN_PROCESS, -1, 1, &req, sizeof(req) );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
return reply.handle;
}
......@@ -8,24 +8,13 @@
#include <errno.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/sem.h>
#include "debug.h"
#include "winerror.h"
#include "winbase.h"
#include "heap.h"
#include "k32obj.h"
#include "debug.h"
#include "thread.h"
/* On some systems this is supposed to be defined in the program */
#ifndef HAVE_UNION_SEMUN
union semun {
int val;
struct semid_ds *buf;
ushort *array;
};
#endif
/***********************************************************************
* InitializeCriticalSection (KERNEL32.472) (NTDLL.406)
......@@ -36,23 +25,8 @@ void WINAPI InitializeCriticalSection( CRITICAL_SECTION *crit )
crit->RecursionCount = 0;
crit->OwningThread = 0;
crit->LockSemaphore = 0;
if (SystemHeap)
{
crit->LockSemaphore = CreateSemaphoreA( NULL, 0, 1, NULL );
crit->Reserved = (DWORD)-1;
}
else
{
union semun val;
crit->Reserved = (DWORD)semget( IPC_PRIVATE, 1, IPC_CREAT | 0777 );
if (crit->Reserved == (DWORD)-1)
{
perror( "semget" );
return;
}
val.val = 0;
semctl( (int)crit->Reserved, 0, SETVAL, val );
}
crit->LockSemaphore = CreateSemaphoreA( NULL, 0, 1, NULL );
crit->Reserved = (DWORD)-1;
}
......@@ -71,10 +45,6 @@ void WINAPI DeleteCriticalSection( CRITICAL_SECTION *crit )
CloseHandle( crit->LockSemaphore );
crit->LockSemaphore = 0;
}
else if (crit->Reserved != (DWORD)-1)
{
semctl( (int)crit->Reserved, 0, IPC_RMID, (union semun)0 );
}
}
......@@ -83,9 +53,8 @@ void WINAPI DeleteCriticalSection( CRITICAL_SECTION *crit )
*/
void WINAPI EnterCriticalSection( CRITICAL_SECTION *crit )
{
if ( (crit->Reserved==-1) && !(crit->LockSemaphore) &&
(crit!=HEAP_SystemLock)
) {
if (!crit->LockSemaphore)
{
FIXME(win32,"entering uninitialized section(%p)?\n",crit);
InitializeCriticalSection(crit);
}
......@@ -97,28 +66,8 @@ void WINAPI EnterCriticalSection( CRITICAL_SECTION *crit )
return;
}
/* Now wait for it */
if (crit->LockSemaphore)
{
/* FIXME: should set a timeout and raise an exception */
WaitForSingleObject( crit->LockSemaphore, INFINITE );
}
else if (crit->Reserved != (DWORD)-1)
{
int ret;
struct sembuf sop;
sop.sem_num = 0;
sop.sem_op = -1;
sop.sem_flg = 0/*SEM_UNDO*/;
do
{
ret = semop( (int)crit->Reserved, &sop, 1 );
} while ((ret == -1) && (errno == EINTR));
}
else
{
MSG( "Uninitialized critical section (%p)\n", crit );
return;
}
/* FIXME: should set a timeout and raise an exception */
WaitForSingleObject( crit->LockSemaphore, INFINITE );
}
crit->OwningThread = GetCurrentThreadId();
crit->RecursionCount = 1;
......@@ -163,18 +112,7 @@ void WINAPI LeaveCriticalSection( CRITICAL_SECTION *crit )
if (InterlockedDecrement( &crit->LockCount ) >= 0)
{
/* Someone is waiting */
if (crit->LockSemaphore)
{
ReleaseSemaphore( crit->LockSemaphore, 1, NULL );
}
else if (crit->Reserved != (DWORD)-1)
{
struct sembuf sop;
sop.sem_num = 0;
sop.sem_op = 1;
sop.sem_flg = 0/*SEM_UNDO*/;
semop( (int)crit->Reserved, &sop, 1 );
}
ReleaseSemaphore( crit->LockSemaphore, 1, NULL );
}
}
......
......@@ -7,19 +7,11 @@
#include <assert.h>
#include <string.h>
#include "winerror.h"
#include "k32obj.h"
#include "process.h"
#include "thread.h"
#include "heap.h"
#include "syslevel.h"
#include "server/request.h"
#include "server.h"
typedef struct
{
K32OBJ header;
} EVENT;
/***********************************************************************
* CreateEvent32A (KERNEL32.156)
......@@ -30,25 +22,14 @@ HANDLE WINAPI CreateEventA( SECURITY_ATTRIBUTES *sa, BOOL manual_reset,
struct create_event_request req;
struct create_event_reply reply;
int len = name ? strlen(name) + 1 : 0;
HANDLE handle;
EVENT *event;
req.manual_reset = manual_reset;
req.initial_state = initial_state;
req.inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
CLIENT_SendRequest( REQ_CREATE_EVENT, -1, 2, &req, sizeof(req), name, len );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
if (reply.handle == -1) return 0;
SYSTEM_LOCK();
event = (EVENT *)K32OBJ_Create( K32OBJ_EVENT, sizeof(*event), name,
reply.handle, EVENT_ALL_ACCESS, sa, &handle );
if (event)
K32OBJ_DecCount( &event->header );
SYSTEM_UNLOCK();
if (handle == INVALID_HANDLE_VALUE) handle = 0;
return handle;
return reply.handle;
}
......@@ -78,8 +59,6 @@ HANDLE WINAPI WIN16_CreateEvent( BOOL manual_reset, BOOL initial_state )
*/
HANDLE WINAPI OpenEventA( DWORD access, BOOL inherit, LPCSTR name )
{
HANDLE handle = 0;
K32OBJ *obj;
struct open_named_obj_request req;
struct open_named_obj_reply reply;
int len = name ? strlen(name) + 1 : 0;
......@@ -89,20 +68,8 @@ HANDLE WINAPI OpenEventA( DWORD access, BOOL inherit, LPCSTR name )
req.inherit = inherit;
CLIENT_SendRequest( REQ_OPEN_NAMED_OBJ, -1, 2, &req, sizeof(req), name, len );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
if (reply.handle != -1)
{
SYSTEM_LOCK();
if ((obj = K32OBJ_FindNameType( name, K32OBJ_EVENT )) != NULL)
{
handle = HANDLE_Alloc( PROCESS_Current(), obj, access, inherit, reply.handle );
K32OBJ_DecCount( obj );
if (handle == INVALID_HANDLE_VALUE)
handle = 0; /* must return 0 on failure, not -1 */
}
else CLIENT_CloseHandle( reply.handle );
SYSTEM_UNLOCK();
}
return handle;
if (reply.handle == -1) return 0; /* must return 0 on failure, not -1 */
return (HANDLE)reply.handle;
}
......@@ -127,10 +94,8 @@ static BOOL EVENT_Operation( HANDLE handle, enum event_op op )
{
struct event_op_request req;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_EVENT, EVENT_MODIFY_STATE );
if (req.handle == -1) return FALSE;
req.op = op;
req.handle = handle;
req.op = op;
CLIENT_SendRequest( REQ_EVENT_OP, -1, 1, &req, sizeof(req) );
return !CLIENT_WaitReply( NULL, NULL, 0 );
}
......
/*
* KERNEL32 objects
*
* Copyright 1996 Alexandre Julliard
*/
#include <assert.h>
#include <string.h>
#include "winerror.h"
#include "k32obj.h"
#include "heap.h"
#include "process.h"
#include "server.h"
/* The declarations are here to avoid including a lot of unnecessary files */
extern const K32OBJ_OPS PROCESS_Ops;
extern const K32OBJ_OPS THREAD_Ops;
static const K32OBJ_OPS K32OBJ_NullOps =
{
NULL /* destroy */
};
static void K32OBJ_Destroy( K32OBJ *obj );
static const K32OBJ_OPS K32OBJ_DefaultOps =
{
K32OBJ_Destroy /* destroy */
};
const K32OBJ_OPS * const K32OBJ_Ops[K32OBJ_NBOBJECTS] =
{
NULL,
&K32OBJ_DefaultOps, /* K32OBJ_SEMAPHORE */
&K32OBJ_DefaultOps, /* K32OBJ_EVENT */
&K32OBJ_DefaultOps, /* K32OBJ_MUTEX */
&K32OBJ_NullOps, /* K32OBJ_CRITICAL_SECTION */
&PROCESS_Ops, /* K32OBJ_PROCESS */
&THREAD_Ops, /* K32OBJ_THREAD */
&K32OBJ_DefaultOps, /* K32OBJ_FILE */
&K32OBJ_DefaultOps, /* K32OBJ_CHANGE */
&K32OBJ_DefaultOps, /* K32OBJ_CONSOLE */
&K32OBJ_NullOps, /* K32OBJ_SCREEN_BUFFER */
&K32OBJ_DefaultOps, /* K32OBJ_MEM_MAPPED_FILE */
&K32OBJ_NullOps, /* K32OBJ_SERIAL */
&K32OBJ_NullOps, /* K32OBJ_DEVICE_IOCTL */
&K32OBJ_DefaultOps, /* K32OBJ_PIPE */
&K32OBJ_NullOps, /* K32OBJ_MAILSLOT */
&K32OBJ_DefaultOps, /* K32OBJ_TOOLHELP_SNAPSHOT */
&K32OBJ_NullOps /* K32OBJ_SOCKET */
};
typedef struct _NE
{
struct _NE *next;
K32OBJ *obj;
UINT len;
char name[1];
} NAME_ENTRY;
static NAME_ENTRY *K32OBJ_FirstEntry = NULL;
/***********************************************************************
* K32OBJ_IncCount
*/
void K32OBJ_IncCount( K32OBJ *ptr )
{
assert( ptr->type && ((unsigned)ptr->type < K32OBJ_NBOBJECTS) );
SYSTEM_LOCK();
ptr->refcount++;
SYSTEM_UNLOCK();
assert( ptr->refcount > 0 ); /* No wrap-around allowed */
}
/***********************************************************************
* K32OBJ_DecCount
*/
void K32OBJ_DecCount( K32OBJ *ptr )
{
NAME_ENTRY **pptr;
assert( ptr->type && ((unsigned)ptr->type < K32OBJ_NBOBJECTS) );
assert( ptr->refcount > 0 );
SYSTEM_LOCK();
if (--ptr->refcount)
{
SYSTEM_UNLOCK();
return;
}
/* Check if the object has a name entry and free it */
pptr = &K32OBJ_FirstEntry;
while (*pptr && ((*pptr)->obj != ptr)) pptr = &(*pptr)->next;
if (*pptr)
{
NAME_ENTRY *entry = *pptr;
*pptr = entry->next;
HeapFree( SystemHeap, 0, entry );
}
/* Free the object */
if (K32OBJ_Ops[ptr->type]->destroy) K32OBJ_Ops[ptr->type]->destroy( ptr );
SYSTEM_UNLOCK();
}
/***********************************************************************
* K32OBJ_Destroy
*
* Generic destroy functions for objects that don't need any special treatment.
*/
static void K32OBJ_Destroy( K32OBJ *obj )
{
obj->type = K32OBJ_UNKNOWN;
HeapFree( SystemHeap, 0, obj );
}
/***********************************************************************
* K32OBJ_IsValid
*
* Check if a pointer is a valid kernel object
*/
BOOL K32OBJ_IsValid( K32OBJ *ptr, K32OBJ_TYPE type )
{
if (IsBadReadPtr( ptr, sizeof(*ptr) )) return FALSE;
return (ptr->type == type);
}
/***********************************************************************
* K32OBJ_AddName
*
* Add a name entry for an object. We don't check for duplicates here.
* FIXME: should use some sort of hashing.
*/
BOOL K32OBJ_AddName( K32OBJ *obj, LPCSTR name )
{
NAME_ENTRY *entry;
UINT len;
if (!name) return TRUE; /* Anonymous object */
len = strlen( name );
SYSTEM_LOCK();
if (!(entry = HeapAlloc( SystemHeap, 0, sizeof(NAME_ENTRY) + len )))
{
SYSTEM_UNLOCK();
SetLastError( ERROR_OUTOFMEMORY );
return FALSE;
}
entry->next = K32OBJ_FirstEntry;
entry->obj = obj;
entry->len = len;
lstrcpyA( entry->name, name );
K32OBJ_FirstEntry = entry;
SYSTEM_UNLOCK();
return TRUE;
}
/***********************************************************************
* K32OBJ_Create
*
* Create a named kernel object.
* Returns NULL if there was an error _or_ if the object already existed.
* The refcount of the object must be decremented once it is initialized.
*/
K32OBJ *K32OBJ_Create( K32OBJ_TYPE type, DWORD size, LPCSTR name, int server_handle,
DWORD access, SECURITY_ATTRIBUTES *sa, HANDLE *handle)
{
BOOL inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
/* Check if the name already exists */
K32OBJ *obj = K32OBJ_FindName( name );
if (obj)
{
if (obj->type == type)
{
SetLastError( ERROR_ALREADY_EXISTS );
*handle = HANDLE_Alloc( PROCESS_Current(), obj, access, inherit, server_handle );
}
else
{
SetLastError( ERROR_DUP_NAME );
*handle = INVALID_HANDLE_VALUE;
if (server_handle != -1) CLIENT_CloseHandle( server_handle );
}
K32OBJ_DecCount( obj );
return NULL;
}
/* Create the object */
SYSTEM_LOCK();
if (!(obj = HeapAlloc( SystemHeap, 0, size )))
{
SYSTEM_UNLOCK();
*handle = INVALID_HANDLE_VALUE;
if (server_handle != -1) CLIENT_CloseHandle( server_handle );
return NULL;
}
obj->type = type;
obj->refcount = 1;
/* Add a name for it */
if (!K32OBJ_AddName( obj, name ))
{
/* Don't call the destroy function, as the object wasn't
* initialized properly */
HeapFree( SystemHeap, 0, obj );
SYSTEM_UNLOCK();
*handle = INVALID_HANDLE_VALUE;
if (server_handle != -1) CLIENT_CloseHandle( server_handle );
return NULL;
}
/* Allocate a handle */
*handle = HANDLE_Alloc( PROCESS_Current(), obj, access, inherit, server_handle );
SYSTEM_UNLOCK();
return obj;
}
/***********************************************************************
* K32OBJ_FindName
*
* Find the object referenced by a given name.
* The reference count is incremented.
*/
K32OBJ *K32OBJ_FindName( LPCSTR name )
{
NAME_ENTRY *entry;
UINT len;
if (!name) return NULL; /* Anonymous object */
len = strlen( name );
SYSTEM_LOCK();
entry = K32OBJ_FirstEntry;
while (entry)
{
if ((len == entry->len) && !strcmp( name, entry->name))
{
K32OBJ *obj = entry->obj;
K32OBJ_IncCount( obj );
SYSTEM_UNLOCK();
return entry->obj;
}
entry = entry->next;
}
SYSTEM_UNLOCK();
return NULL;
}
/***********************************************************************
* K32OBJ_FindNameType
*
* Find an object by name and check its type.
* The reference count is incremented.
*/
K32OBJ *K32OBJ_FindNameType( LPCSTR name, K32OBJ_TYPE type )
{
K32OBJ *obj = K32OBJ_FindName( name );
if (!obj) return NULL;
if (obj->type == type) return obj;
SetLastError( ERROR_DUP_NAME );
K32OBJ_DecCount( obj );
return NULL;
}
......@@ -7,18 +7,10 @@
#include <assert.h>
#include <string.h>
#include "winerror.h"
#include "k32obj.h"
#include "process.h"
#include "thread.h"
#include "heap.h"
#include "server/request.h"
#include "server.h"
typedef struct _MUTEX
{
K32OBJ header;
} MUTEX;
/***********************************************************************
* CreateMutex32A (KERNEL32.166)
......@@ -29,24 +21,13 @@ HANDLE WINAPI CreateMutexA( SECURITY_ATTRIBUTES *sa, BOOL owner,
struct create_mutex_request req;
struct create_mutex_reply reply;
int len = name ? strlen(name) + 1 : 0;
HANDLE handle;
MUTEX *mutex;
req.owned = owner;
req.inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
CLIENT_SendRequest( REQ_CREATE_MUTEX, -1, 2, &req, sizeof(req), name, len );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
if (reply.handle == -1) return 0;
SYSTEM_LOCK();
mutex = (MUTEX *)K32OBJ_Create( K32OBJ_MUTEX, sizeof(*mutex),
name, reply.handle, MUTEX_ALL_ACCESS,
sa, &handle );
if (mutex) K32OBJ_DecCount( &mutex->header );
if (handle == INVALID_HANDLE_VALUE) handle = 0;
SYSTEM_UNLOCK();
return handle;
return reply.handle;
}
......@@ -68,8 +49,6 @@ HANDLE WINAPI CreateMutexW( SECURITY_ATTRIBUTES *sa, BOOL owner,
*/
HANDLE WINAPI OpenMutexA( DWORD access, BOOL inherit, LPCSTR name )
{
HANDLE handle = 0;
K32OBJ *obj;
struct open_named_obj_request req;
struct open_named_obj_reply reply;
int len = name ? strlen(name) + 1 : 0;
......@@ -79,20 +58,8 @@ HANDLE WINAPI OpenMutexA( DWORD access, BOOL inherit, LPCSTR name )
req.inherit = inherit;
CLIENT_SendRequest( REQ_OPEN_NAMED_OBJ, -1, 2, &req, sizeof(req), name, len );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
if (reply.handle != -1)
{
SYSTEM_LOCK();
if ((obj = K32OBJ_FindNameType( name, K32OBJ_MUTEX )) != NULL)
{
handle = HANDLE_Alloc( PROCESS_Current(), obj, access, inherit, reply.handle );
K32OBJ_DecCount( obj );
if (handle == INVALID_HANDLE_VALUE)
handle = 0; /* must return 0 on failure, not -1 */
}
else CLIENT_CloseHandle( reply.handle );
SYSTEM_UNLOCK();
}
return handle;
if (reply.handle == -1) return 0; /* must return 0 on failure, not -1 */
return reply.handle;
}
......@@ -115,9 +82,7 @@ BOOL WINAPI ReleaseMutex( HANDLE handle )
{
struct release_mutex_request req;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_MUTEX, MUTEX_MODIFY_STATE );
if (req.handle == -1) return FALSE;
req.handle = handle;
CLIENT_SendRequest( REQ_RELEASE_MUTEX, -1, 1, &req, sizeof(req) );
return !CLIENT_WaitReply( NULL, NULL, 0 );
}
......@@ -6,18 +6,10 @@
#include <assert.h>
#include "winerror.h"
#include "k32obj.h"
#include "process.h"
#include "thread.h"
#include "heap.h"
#include "winbase.h"
#include "server/request.h"
#include "server.h"
typedef struct _PIPE
{
K32OBJ header;
} PIPE;
/***********************************************************************
* CreatePipe (KERNEL32.170)
......@@ -27,39 +19,13 @@ BOOL WINAPI CreatePipe( PHANDLE hReadPipe, PHANDLE hWritePipe,
{
struct create_pipe_request req;
struct create_pipe_reply reply;
PIPE *read_pipe, *write_pipe;
int len;
req.inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
CLIENT_SendRequest( REQ_CREATE_PIPE, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitReply( &len, NULL, 1, &reply, sizeof(reply) ) != ERROR_SUCCESS)
return FALSE;
SYSTEM_LOCK();
if (!(read_pipe = (PIPE *)K32OBJ_Create( K32OBJ_PIPE, sizeof(*read_pipe),
NULL, reply.handle_read,
STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|GENERIC_READ,
sa, hReadPipe )))
{
CLIENT_CloseHandle( reply.handle_write );
/* handle_read already closed by K32OBJ_Create */
SYSTEM_UNLOCK();
return FALSE;
}
K32OBJ_DecCount( &read_pipe->header );
if (!(write_pipe = (PIPE *)K32OBJ_Create( K32OBJ_PIPE, sizeof(*write_pipe),
NULL, reply.handle_write,
STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|GENERIC_WRITE,
sa, hWritePipe )))
{
CloseHandle( *hReadPipe );
*hReadPipe = INVALID_HANDLE_VALUE;
SYSTEM_UNLOCK();
return FALSE;
}
/* everything OK */
K32OBJ_DecCount( &write_pipe->header );
SetLastError(0); /* FIXME */
SYSTEM_UNLOCK();
*hReadPipe = reply.handle_read;
*hWritePipe = reply.handle_write;
return TRUE;
}
......@@ -24,12 +24,6 @@
#include "server.h"
#include "debug.h"
static void PROCESS_Destroy( K32OBJ *obj );
const K32OBJ_OPS PROCESS_Ops =
{
PROCESS_Destroy /* destroy */
};
/* The initial process PDB */
static PDB initial_pdb;
......@@ -66,8 +60,7 @@ static BOOL PROCESS_QueryInfo( HANDLE handle,
struct get_process_info_reply *reply )
{
struct get_process_info_request req;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_PROCESS, PROCESS_QUERY_INFORMATION );
req.handle = handle;
CLIENT_SendRequest( REQ_GET_PROCESS_INFO, -1, 1, &req, sizeof(req) );
return !CLIENT_WaitSimpleReply( reply, sizeof(*reply), NULL );
}
......@@ -190,12 +183,10 @@ static BOOL PROCESS_InheritEnvDB( PDB *pdb, LPCSTR cmd_line, LPCSTR env,
*
* Free a PDB and all associated storage.
*/
static void PROCESS_FreePDB( PDB *pdb )
void PROCESS_FreePDB( PDB *pdb )
{
PDB **pptr = &PROCESS_First;
pdb->header.type = K32OBJ_UNKNOWN;
if (pdb->handle_table) HANDLE_CloseAll( pdb, NULL );
ENV_FreeEnvironment( pdb );
while (*pptr && (*pptr != pdb)) pptr = &(*pptr)->next;
if (*pptr) *pptr = pdb->next;
......@@ -216,8 +207,6 @@ static PDB *PROCESS_CreatePDB( PDB *parent, BOOL inherit )
PDB *pdb = HeapAlloc( SystemHeap, HEAP_ZERO_MEMORY, sizeof(PDB) );
if (!pdb) return NULL;
pdb->header.type = K32OBJ_PROCESS;
pdb->header.refcount = 1;
pdb->exit_code = 0x103; /* STILL_ACTIVE */
pdb->threads = 1;
pdb->running_threads = 1;
......@@ -229,15 +218,7 @@ static PDB *PROCESS_CreatePDB( PDB *parent, BOOL inherit )
pdb->heap = pdb->system_heap; /* will be changed later on */
pdb->next = PROCESS_First;
PROCESS_First = pdb;
/* Create the handle table */
if (!HANDLE_CreateTable( pdb, inherit )) goto error;
return pdb;
error:
PROCESS_FreePDB( pdb );
return NULL;
}
......@@ -264,8 +245,6 @@ BOOL PROCESS_Init(void)
THDB *thdb;
/* Fill the initial process structure */
initial_pdb.header.type = K32OBJ_PROCESS;
initial_pdb.header.refcount = 1;
initial_pdb.exit_code = 0x103; /* STILL_ACTIVE */
initial_pdb.threads = 1;
initial_pdb.running_threads = 1;
......@@ -276,17 +255,16 @@ BOOL PROCESS_Init(void)
/* Initialize virtual memory management */
if (!VIRTUAL_Init()) return FALSE;
/* Create the system heap */
if (!(SystemHeap = HeapCreate( HEAP_GROWABLE, 0x10000, 0 ))) return FALSE;
initial_pdb.system_heap = initial_pdb.heap = SystemHeap;
/* Create the initial process and thread structures */
if (!HANDLE_CreateTable( &initial_pdb, FALSE )) return FALSE;
/* Create the initial thread structure */
if (!(thdb = THREAD_CreateInitialThread( &initial_pdb ))) return FALSE;
/* Remember TEB selector of initial process for emergency use */
SYSLEVEL_EmergencyTeb = thdb->teb_sel;
/* Create the system heap */
if (!(SystemHeap = HeapCreate( HEAP_GROWABLE, 0x10000, 0 ))) return FALSE;
initial_pdb.system_heap = initial_pdb.heap = SystemHeap;
/* Create the environment DB of the first process */
if (!PROCESS_BuildEnvDB( &initial_pdb )) return FALSE;
......@@ -351,12 +329,8 @@ PDB *PROCESS_Create( NE_MODULE *pModule, LPCSTR cmd_line, LPCSTR env,
if (!(thdb = THREAD_Create( pdb, size, hInstance == 0,
&server_thandle, &server_phandle, NULL, NULL )))
goto error;
if ((info->hThread = HANDLE_Alloc( parent, &thdb->header, THREAD_ALL_ACCESS,
FALSE, server_thandle )) == INVALID_HANDLE_VALUE)
goto error;
if ((info->hProcess = HANDLE_Alloc( parent, &pdb->header, PROCESS_ALL_ACCESS,
FALSE, server_phandle )) == INVALID_HANDLE_VALUE)
goto error;
info->hThread = server_thandle;
info->hProcess = server_phandle;
info->dwProcessId = (DWORD)pdb->server_pid;
info->dwThreadId = (DWORD)thdb->server_tid;
......@@ -391,28 +365,12 @@ PDB *PROCESS_Create( NE_MODULE *pModule, LPCSTR cmd_line, LPCSTR env,
error:
if (info->hThread != INVALID_HANDLE_VALUE) CloseHandle( info->hThread );
if (info->hProcess != INVALID_HANDLE_VALUE) CloseHandle( info->hProcess );
if (thdb) K32OBJ_DecCount( &thdb->header );
PROCESS_FreePDB( pdb );
return NULL;
}
/***********************************************************************
* PROCESS_Destroy
*/
static void PROCESS_Destroy( K32OBJ *ptr )
{
PDB *pdb = (PDB *)ptr;
assert( ptr->type == K32OBJ_PROCESS );
/* Free everything */
ptr->type = K32OBJ_UNKNOWN;
PROCESS_FreePDB( pdb );
}
/***********************************************************************
* ExitProcess (KERNEL32.100)
*/
void WINAPI ExitProcess( DWORD status )
......@@ -424,11 +382,9 @@ void WINAPI ExitProcess( DWORD status )
if ( pTask && pTask->thdb != THREAD_Current() )
ExitThread( status );
SYSTEM_LOCK();
/* FIXME: should kill all running threads of this process */
pdb->exit_code = status;
if (pdb->console) FreeConsole();
SYSTEM_UNLOCK();
FreeConsole();
__RESTORE_ES; /* Necessary for Pietrek's showseh example program */
TASK_KillCurrentTask( status );
......@@ -441,9 +397,7 @@ void WINAPI ExitProcess( DWORD status )
BOOL WINAPI TerminateProcess( HANDLE handle, DWORD exit_code )
{
struct terminate_process_request req;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_PROCESS, PROCESS_TERMINATE );
req.handle = handle;
req.exit_code = exit_code;
CLIENT_SendRequest( REQ_TERMINATE_PROCESS, -1, 1, &req, sizeof(req) );
return !CLIENT_WaitReply( NULL, NULL, 0 );
......@@ -463,18 +417,15 @@ HANDLE WINAPI GetCurrentProcess(void)
*/
HANDLE WINAPI OpenProcess( DWORD access, BOOL inherit, DWORD id )
{
PDB *pdb;
struct open_process_request req;
struct open_process_reply reply;
if (!(pdb = PROCESS_IdToPDB( id ))) return 0;
req.pid = (void *)id;
req.access = access;
req.inherit = inherit;
CLIENT_SendRequest( REQ_OPEN_PROCESS, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL )) return 0;
return HANDLE_Alloc( PROCESS_Current(), &pdb->header, access,
inherit, reply.handle );
return reply.handle;
}
......@@ -512,9 +463,7 @@ LCID WINAPI GetThreadLocale(void)
BOOL WINAPI SetPriorityClass( HANDLE hprocess, DWORD priorityclass )
{
struct set_process_info_request req;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hprocess,
K32OBJ_PROCESS, PROCESS_SET_INFORMATION );
if (req.handle == -1) return FALSE;
req.handle = hprocess;
req.priority = priorityclass;
req.mask = SET_PROCESS_INFO_PRIORITY;
CLIENT_SendRequest( REQ_SET_PROCESS_INFO, -1, 1, &req, sizeof(req) );
......@@ -539,9 +488,7 @@ DWORD WINAPI GetPriorityClass(HANDLE hprocess)
BOOL WINAPI SetProcessAffinityMask( HANDLE hProcess, DWORD affmask )
{
struct set_process_info_request req;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hProcess,
K32OBJ_PROCESS, PROCESS_SET_INFORMATION );
if (req.handle == -1) return FALSE;
req.handle = hProcess;
req.affinity = affmask;
req.mask = SET_PROCESS_INFO_AFFINITY;
CLIENT_SendRequest( REQ_SET_PROCESS_INFO, -1, 1, &req, sizeof(req) );
......
......@@ -7,18 +7,10 @@
#include <assert.h>
#include <string.h>
#include "winerror.h"
#include "k32obj.h"
#include "process.h"
#include "thread.h"
#include "heap.h"
#include "server/request.h"
#include "server.h"
typedef struct
{
K32OBJ header;
} SEMAPHORE;
/***********************************************************************
* CreateSemaphore32A (KERNEL32.174)
......@@ -29,8 +21,6 @@ HANDLE WINAPI CreateSemaphoreA( SECURITY_ATTRIBUTES *sa, LONG initial,
struct create_semaphore_request req;
struct create_semaphore_reply reply;
int len = name ? strlen(name) + 1 : 0;
HANDLE handle;
SEMAPHORE *sem;
/* Check parameters */
......@@ -47,15 +37,7 @@ HANDLE WINAPI CreateSemaphoreA( SECURITY_ATTRIBUTES *sa, LONG initial,
CLIENT_SendRequest( REQ_CREATE_SEMAPHORE, -1, 2, &req, sizeof(req), name, len );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
if (reply.handle == -1) return 0;
SYSTEM_LOCK();
sem = (SEMAPHORE *)K32OBJ_Create( K32OBJ_SEMAPHORE, sizeof(*sem),
name, reply.handle, SEMAPHORE_ALL_ACCESS,
sa, &handle);
if (sem) K32OBJ_DecCount( &sem->header );
SYSTEM_UNLOCK();
if (handle == INVALID_HANDLE_VALUE) handle = 0;
return handle;
return reply.handle;
}
......@@ -77,8 +59,6 @@ HANDLE WINAPI CreateSemaphoreW( SECURITY_ATTRIBUTES *sa, LONG initial,
*/
HANDLE WINAPI OpenSemaphoreA( DWORD access, BOOL inherit, LPCSTR name )
{
HANDLE handle = 0;
K32OBJ *obj;
struct open_named_obj_request req;
struct open_named_obj_reply reply;
int len = name ? strlen(name) + 1 : 0;
......@@ -88,20 +68,8 @@ HANDLE WINAPI OpenSemaphoreA( DWORD access, BOOL inherit, LPCSTR name )
req.inherit = inherit;
CLIENT_SendRequest( REQ_OPEN_NAMED_OBJ, -1, 2, &req, sizeof(req), name, len );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
if (reply.handle != -1)
{
SYSTEM_LOCK();
if ((obj = K32OBJ_FindNameType( name, K32OBJ_SEMAPHORE )) != NULL)
{
handle = HANDLE_Alloc( PROCESS_Current(), obj, access, inherit, reply.handle );
K32OBJ_DecCount( obj );
if (handle == INVALID_HANDLE_VALUE)
handle = 0; /* must return 0 on failure, not -1 */
}
else CLIENT_CloseHandle( reply.handle );
SYSTEM_UNLOCK();
}
return handle;
if (reply.handle == -1) return 0; /* must return 0 on failure, not -1 */
return reply.handle;
}
......@@ -130,10 +98,8 @@ BOOL WINAPI ReleaseSemaphore( HANDLE handle, LONG count, LONG *previous )
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_SEMAPHORE, SEMAPHORE_MODIFY_STATE );
if (req.handle == -1) return FALSE;
req.count = (unsigned int)count;
req.handle = handle;
req.count = (unsigned int)count;
CLIENT_SendRequest( REQ_RELEASE_SEMAPHORE, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL )) return FALSE;
if (previous) *previous = reply.prev_count;
......
......@@ -8,7 +8,6 @@
#include <signal.h>
#include <sys/time.h>
#include <unistd.h>
#include "k32obj.h"
#include "heap.h"
#include "process.h"
#include "thread.h"
......@@ -85,17 +84,7 @@ DWORD WINAPI WaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
return WAIT_FAILED;
}
for (i = 0; i < count; i++)
{
TRACE(win32,"handle %d is %08x\n",i,handles[i]);
server_handle[i] = HANDLE_GetServerHandle( PROCESS_Current(), handles[i],
K32OBJ_UNKNOWN, SYNCHRONIZE );
if (server_handle[i] == -1)
{
ERR(win32,"No server handle for %08x\n",handles[i] );
return WAIT_FAILED;
}
}
for (i = 0; i < count; i++) server_handle[i] = handles[i];
req.count = count;
req.flags = 0;
......
......@@ -119,11 +119,11 @@ int SYSDEPS_SpawnThread( THDB *thread )
* SYSDEPS_ExitThread
*
* Exit a running thread; must not return.
* Must not make any reference to the thread structures (THDB etc.) as
* they have already been deleted.
*/
void SYSDEPS_ExitThread(void)
{
THDB *thdb = THREAD_Current();
close( thdb->socket );
_exit( 0 );
}
......
......@@ -28,13 +28,6 @@
THDB *pCurrentThread;
#endif
static void THREAD_Destroy( K32OBJ *obj );
const K32OBJ_OPS THREAD_Ops =
{
THREAD_Destroy /* destroy */
};
/* Is threading code initialized? */
BOOL THREAD_InitDone = FALSE;
......@@ -173,8 +166,6 @@ THDB *THREAD_CreateInitialThread( PDB *pdb )
extern void server_init( int fd );
extern void select_loop(void);
initial_thdb.header.type = K32OBJ_THREAD;
initial_thdb.header.refcount = 1;
initial_thdb.process = pdb;
initial_thdb.teb.except = (void *)-1;
initial_thdb.teb.self = &initial_thdb.teb;
......@@ -241,8 +232,6 @@ THDB *THREAD_Create( PDB *pdb, DWORD stack_size, BOOL alloc_stack16,
{
THDB *thdb = HeapAlloc( SystemHeap, HEAP_ZERO_MEMORY, sizeof(THDB) );
if (!thdb) return NULL;
thdb->header.type = K32OBJ_THREAD;
thdb->header.refcount = 1;
thdb->process = pdb;
thdb->teb.except = (void *)-1;
thdb->teb.htask16 = pdb->task;
......@@ -278,43 +267,6 @@ error:
/***********************************************************************
* THREAD_Destroy
*/
static void THREAD_Destroy( K32OBJ *ptr )
{
THDB *thdb = (THDB *)ptr;
THDB **pptr = &THREAD_First;
assert( ptr->type == K32OBJ_THREAD );
ptr->type = K32OBJ_UNKNOWN;
while (*pptr && (*pptr != thdb)) pptr = &(*pptr)->next;
if (*pptr) *pptr = thdb->next;
/* Free the associated memory */
#ifdef __i386__
{
/* Check if we are deleting the current thread */
WORD fs;
GET_FS( fs );
if (fs == thdb->teb_sel)
{
GET_DS( fs );
SET_FS( fs );
}
}
#endif
CloseHandle( thdb->event );
close( thdb->socket );
SELECTOR_FreeBlock( thdb->teb_sel, 1 );
if (thdb->teb.stack_sel) SELECTOR_FreeBlock( thdb->teb.stack_sel, 1 );
HeapFree( SystemHeap, 0, thdb );
}
/***********************************************************************
* THREAD_Start
*
* Start execution of a newly created thread. Does not return.
......@@ -336,24 +288,18 @@ HANDLE WINAPI CreateThread( SECURITY_ATTRIBUTES *sa, DWORD stack,
LPTHREAD_START_ROUTINE start, LPVOID param,
DWORD flags, LPDWORD id )
{
int server_handle = -1;
HANDLE handle = INVALID_HANDLE_VALUE;
int handle = -1;
BOOL inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
THDB *thread = THREAD_Create( PROCESS_Current(), stack,
TRUE, &server_handle, NULL, start, param );
TRUE, &handle, NULL, start, param );
if (!thread) return INVALID_HANDLE_VALUE;
handle = HANDLE_Alloc( PROCESS_Current(), &thread->header,
THREAD_ALL_ACCESS, inherit, server_handle );
if (handle == INVALID_HANDLE_VALUE) goto error;
if (SYSDEPS_SpawnThread( thread ) == -1) goto error;
if (SYSDEPS_SpawnThread( thread ) == -1)
{
CloseHandle( handle );
return INVALID_HANDLE_VALUE;
}
if (id) *id = (DWORD)thread->server_tid;
return handle;
error:
if (handle != INVALID_HANDLE_VALUE) CloseHandle( handle );
K32OBJ_DecCount( &thread->header );
return INVALID_HANDLE_VALUE;
}
......@@ -367,26 +313,32 @@ void WINAPI ExitThread(
DWORD code) /* [in] Exit code for this thread */
{
THDB *thdb = THREAD_Current();
LONG count;
THDB **pptr = &THREAD_First;
WORD ds;
MODULE_InitializeDLLs( 0, DLL_THREAD_DETACH, NULL );
SYSTEM_LOCK();
thdb->exit_code = code;
/* cleanup the message queue, if there's one */
if (thdb->teb.queue)
USER_QueueCleanup( thdb->teb.queue );
CloseHandle( thdb->event );
while (*pptr && (*pptr != thdb)) pptr = &(*pptr)->next;
if (*pptr) *pptr = thdb->next;
/* Free the associated memory */
if (thdb->teb.stack_sel) SELECTOR_FreeBlock( thdb->teb.stack_sel, 1 );
GET_DS( ds );
SET_FS( ds );
SELECTOR_FreeBlock( thdb->teb_sel, 1 );
close( thdb->socket );
HeapFree( SystemHeap, HEAP_NO_SERIALIZE, thdb );
/* FIXME: should free the stack somehow */
#if 0
/* FIXME: We cannot do this; once the current thread is destroyed,
synchronization primitives do not work properly. */
K32OBJ_DecCount( &thdb->header );
#endif
/* Completely unlock the system lock just in case */
count = SYSTEM_LOCK_COUNT();
while (count--) SYSTEM_UNLOCK();
SYSDEPS_ExitThread();
}
......@@ -653,8 +605,7 @@ INT WINAPI GetThreadPriority(
{
struct get_thread_info_request req;
struct get_thread_info_reply reply;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hthread,
K32OBJ_THREAD, THREAD_QUERY_INFORMATION );
req.handle = hthread;
CLIENT_SendRequest( REQ_GET_THREAD_INFO, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL ))
return THREAD_PRIORITY_ERROR_RETURN;
......@@ -674,9 +625,7 @@ BOOL WINAPI SetThreadPriority(
INT priority) /* [in] Thread priority level */
{
struct set_thread_info_request req;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hthread,
K32OBJ_THREAD, THREAD_SET_INFORMATION );
if (req.handle == -1) return FALSE;
req.handle = hthread;
req.priority = priority;
req.mask = SET_THREAD_INFO_PRIORITY;
CLIENT_SendRequest( REQ_SET_THREAD_INFO, -1, 1, &req, sizeof(req) );
......@@ -690,9 +639,7 @@ BOOL WINAPI SetThreadPriority(
DWORD WINAPI SetThreadAffinityMask( HANDLE hThread, DWORD dwThreadAffinityMask )
{
struct set_thread_info_request req;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hThread,
K32OBJ_THREAD, THREAD_SET_INFORMATION );
if (req.handle == -1) return FALSE;
req.handle = hThread;
req.affinity = dwThreadAffinityMask;
req.mask = SET_THREAD_INFO_AFFINITY;
CLIENT_SendRequest( REQ_SET_THREAD_INFO, -1, 1, &req, sizeof(req) );
......@@ -713,9 +660,7 @@ BOOL WINAPI TerminateThread(
DWORD exitcode) /* [in] Exit code for thread */
{
struct terminate_thread_request req;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_THREAD, THREAD_TERMINATE );
req.handle = handle;
req.exit_code = exitcode;
CLIENT_SendRequest( REQ_TERMINATE_THREAD, -1, 1, &req, sizeof(req) );
return !CLIENT_WaitReply( NULL, NULL, 0 );
......@@ -735,8 +680,7 @@ BOOL WINAPI GetExitCodeThread(
{
struct get_thread_info_request req;
struct get_thread_info_reply reply;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hthread,
K32OBJ_THREAD, THREAD_QUERY_INFORMATION );
req.handle = hthread;
CLIENT_SendRequest( REQ_GET_THREAD_INFO, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL )) return FALSE;
if (exitcode) *exitcode = reply.exit_code;
......@@ -760,8 +704,7 @@ DWORD WINAPI ResumeThread(
{
struct resume_thread_request req;
struct resume_thread_reply reply;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hthread,
K32OBJ_THREAD, THREAD_SUSPEND_RESUME );
req.handle = hthread;
CLIENT_SendRequest( REQ_RESUME_THREAD, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL )) return 0xffffffff;
return reply.count;
......@@ -780,8 +723,7 @@ DWORD WINAPI SuspendThread(
{
struct suspend_thread_request req;
struct suspend_thread_reply reply;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hthread,
K32OBJ_THREAD, THREAD_SUSPEND_RESUME );
req.handle = hthread;
CLIENT_SendRequest( REQ_SUSPEND_THREAD, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL )) return 0xffffffff;
return reply.count;
......@@ -794,10 +736,9 @@ DWORD WINAPI SuspendThread(
DWORD WINAPI QueueUserAPC( PAPCFUNC func, HANDLE hthread, ULONG_PTR data )
{
struct queue_apc_request req;
req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hthread,
K32OBJ_THREAD, THREAD_SET_CONTEXT );
req.func = func;
req.param = (void *)data;
req.handle = hthread;
req.func = func;
req.param = (void *)data;
CLIENT_SendRequest( REQ_QUEUE_APC, -1, 1, &req, sizeof(req) );
return !CLIENT_WaitReply( NULL, NULL, 0 );
}
......
......@@ -272,9 +272,7 @@ static const struct VxDInfo *DEVICE_GetInfo( HANDLE handle )
struct get_file_info_request req;
struct get_file_info_reply reply;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_FILE, 0 )) == -1)
return NULL;
req.handle = handle;
CLIENT_SendRequest( REQ_GET_FILE_INFO, -1, 1, &req, sizeof(req) );
if (!CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL ) &&
(reply.type == FILE_TYPE_UNKNOWN) &&
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment