ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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

This commit is contained in:
Alexandre Julliard 1999-02-28 13:27:56 +00:00
parent ee517e863e
commit 96c08d817c
25 changed files with 185 additions and 1652 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
files/change.c
View File

@ -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;
}

4
files/dos_fs.c
View File

@ -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))

93
files/file.c
View File

@ -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;

2
include/file.h
View File

@ -8,7 +8,7 @@
#define __WINE_FILE_H
#include <time.h> /* time_t */
#include "k32obj.h"
#include "winbase.h"
#define MAX_PATHNAME_LEN 1024

64
include/k32obj.h
View File

@ -1,64 +0,0 @@
/*
* 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 */

59
include/process.h
View File

@ -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 */

7
include/thread.h
View File

@ -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 */

4
loader/task.c
View File

@ -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 */

106
memory/virtual.c
View File

@ -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;

26
misc/toolhelp.c
View File

@ -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;

1
scheduler/Makefile.in
View File

@ -10,7 +10,6 @@ C_SRCS = \
critsection.c \
event.c \
handle.c \
k32obj.c \
mutex.c \
pipe.c \
process.c \

58
scheduler/client.c
View File

@ -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;
}

76
scheduler/critsection.c
View File

@ -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 );
}
}

45
scheduler/event.c
View File

@ -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 );
}

431
scheduler/handle.c
View File

@ -7,296 +7,7 @@
#include <assert.h>
#include <stdio.h>
#include "winbase.h"
#include "winerror.h"
#include "heap.h"
#include "process.h"
#include "server.h"
#include "thread.h"
#include "debug.h"
#define HTABLE_SIZE 0x30 /* Handle table initial size */
#define HTABLE_INC 0x10 /* Handle table increment */
/* Reserved access rights */
#define RESERVED_ALL (0x0007 << RESERVED_SHIFT)
#define RESERVED_SHIFT 25
#define RESERVED_INHERIT (HANDLE_FLAG_INHERIT<<RESERVED_SHIFT)
#define RESERVED_CLOSE_PROTECT (HANDLE_FLAG_PROTECT_FROM_CLOSE<<RESERVED_SHIFT)
/***********************************************************************
* HANDLE_GrowTable
*/
static BOOL HANDLE_GrowTable( PDB *process, INT incr )
{
HANDLE_TABLE *table;
SYSTEM_LOCK();
table = process->handle_table;
table = HeapReAlloc( process->system_heap,
HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE, table,
sizeof(HANDLE_TABLE) +
(table->count + incr - 1) * sizeof(HANDLE_ENTRY) );
if (table)
{
table->count += incr;
process->handle_table = table;
}
SYSTEM_UNLOCK();
return (table != NULL);
}
/***********************************************************************
* HANDLE_CreateTable
*
* Create a process handle table, optionally inheriting the parent's handles.
*/
BOOL HANDLE_CreateTable( PDB *pdb, BOOL inherit )
{
DWORD size;
/* Process must not already have a handle table */
assert( !pdb->handle_table );
/* If this is the first process, simply allocate a table */
if (!pdb->parent) inherit = FALSE;
SYSTEM_LOCK();
size = inherit ? pdb->parent->handle_table->count : HTABLE_SIZE;
if ((pdb->handle_table = HeapAlloc( pdb->system_heap,
HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE,
sizeof(HANDLE_TABLE) +
(size-1) * sizeof(HANDLE_ENTRY) )))
{
pdb->handle_table->count = size;
if (inherit)
{
HANDLE_ENTRY *src = pdb->parent->handle_table->entries;
HANDLE_ENTRY *dst = pdb->handle_table->entries;
HANDLE h;
for (h = 0; h < size; h++, src++, dst++)
{
/* Check if handle is valid and inheritable */
if (src->ptr && (src->access & RESERVED_INHERIT))
{
dst->access = src->access;
dst->ptr = src->ptr;
dst->server = src->server;
K32OBJ_IncCount( dst->ptr );
}
}
}
/* Handle 1 is the process itself (unless the parent decided otherwise) */
if (!pdb->handle_table->entries[1].ptr)
{
pdb->handle_table->entries[1].ptr = &pdb->header;
pdb->handle_table->entries[1].access = PROCESS_ALL_ACCESS;
pdb->handle_table->entries[1].server = -1; /* FIXME */
K32OBJ_IncCount( &pdb->header );
}
}
SYSTEM_UNLOCK();
return (pdb->handle_table != NULL);
}
/***********************************************************************
* HANDLE_Alloc
*
* Allocate a handle for a kernel object and increment its refcount.
*/
HANDLE HANDLE_Alloc( PDB *pdb, K32OBJ *ptr, DWORD access,
BOOL inherit, int server_handle )
{
HANDLE h;
HANDLE_ENTRY *entry;
assert( ptr );
/* Set the inherit reserved flag */
access &= ~RESERVED_ALL;
if (inherit) access |= RESERVED_INHERIT;
SYSTEM_LOCK();
K32OBJ_IncCount( ptr );
/* Don't try to allocate handle 0 */
entry = pdb->handle_table->entries + 1;
for (h = 1; h < pdb->handle_table->count; h++, entry++)
if (!entry->ptr) break;
if ((h < pdb->handle_table->count) || HANDLE_GrowTable( pdb, HTABLE_INC ))
{
entry = &pdb->handle_table->entries[h];
entry->access = access;
entry->ptr = ptr;
entry->server = server_handle;
SYSTEM_UNLOCK();
return h;
}
K32OBJ_DecCount( ptr );
SYSTEM_UNLOCK();
if (server_handle != -1) CLIENT_CloseHandle( server_handle );
SetLastError( ERROR_OUTOFMEMORY );
return INVALID_HANDLE_VALUE;
}
/***********************************************************************
* HANDLE_GetObjPtr
*
* Retrieve a pointer to a kernel object and increments its reference count.
* The refcount must be decremented when the pointer is no longer used.
*/
K32OBJ *HANDLE_GetObjPtr( PDB *pdb, HANDLE handle,
K32OBJ_TYPE type, DWORD access,
int *server_handle )
{
K32OBJ *ptr = NULL;
SYSTEM_LOCK();
if (HANDLE_IS_GLOBAL( handle ))
{
handle = HANDLE_GLOBAL_TO_LOCAL( handle );
pdb = PROCESS_Initial();
}
if ((handle > 0) && (handle < pdb->handle_table->count))
{
HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
if ((entry->access & access) != access)
WARN(win32, "Handle %08x bad access (acc=%08lx req=%08lx)\n",
handle, entry->access, access );
ptr = entry->ptr;
if (server_handle) *server_handle = entry->server;
}
else if (handle == CURRENT_THREAD_PSEUDOHANDLE)
{
ptr = (K32OBJ *)THREAD_Current();
if (server_handle) *server_handle = CURRENT_THREAD_PSEUDOHANDLE;
}
else if (handle == CURRENT_PROCESS_PSEUDOHANDLE)
{
ptr = (K32OBJ *)PROCESS_Current();
if (server_handle) *server_handle = CURRENT_PROCESS_PSEUDOHANDLE;
}
if (ptr && ((type == K32OBJ_UNKNOWN) || (ptr->type == type)))
K32OBJ_IncCount( ptr );
else
ptr = NULL;
SYSTEM_UNLOCK();
if (!ptr) SetLastError( ERROR_INVALID_HANDLE );
return ptr;
}
/***********************************************************************
* HANDLE_GetServerHandle
*
* Retrieve the server handle associated to an object.
*/
int HANDLE_GetServerHandle( PDB *pdb, HANDLE handle,
K32OBJ_TYPE type, DWORD access )
{
int server_handle;
K32OBJ *obj;
SYSTEM_LOCK();
if ((obj = HANDLE_GetObjPtr( pdb, handle, type, access, &server_handle )))
K32OBJ_DecCount( obj );
else
server_handle = -1;
SYSTEM_UNLOCK();
return server_handle;
}
/*********************************************************************
* HANDLE_GetAccess
*/
static BOOL HANDLE_GetAccess( PDB *pdb, HANDLE handle, LPDWORD access )
{
BOOL ret = FALSE;
SYSTEM_LOCK();
if ((handle > 0) && (handle < pdb->handle_table->count))
{
HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
if (entry->ptr)
{
*access = entry->access & ~RESERVED_ALL;
ret = TRUE;
}
}
SYSTEM_UNLOCK();
if (!ret) SetLastError( ERROR_INVALID_HANDLE );
return ret;
}
/*********************************************************************
* HANDLE_Close
*/
static BOOL HANDLE_Close( PDB *pdb, HANDLE handle )
{
BOOL ret = FALSE;
K32OBJ *ptr;
if (HANDLE_IS_GLOBAL( handle ))
{
handle = HANDLE_GLOBAL_TO_LOCAL( handle );
pdb = PROCESS_Initial();
}
SYSTEM_LOCK();
if ((handle > 0) && (handle < pdb->handle_table->count))
{
HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
if ((ptr = entry->ptr))
{
if (!(entry->access & RESERVED_CLOSE_PROTECT))
{
entry->access = 0;
entry->ptr = NULL;
if (entry->server != -1)
CLIENT_CloseHandle( entry->server );
K32OBJ_DecCount( ptr );
ret = TRUE;
}
/* FIXME: else SetLastError */
}
}
SYSTEM_UNLOCK();
if (!ret) SetLastError( ERROR_INVALID_HANDLE );
return ret;
}
/*********************************************************************
* HANDLE_CloseAll
*
* Close all handles pointing to a given object (or all handles of the
* process if the object is NULL)
*/
void HANDLE_CloseAll( PDB *pdb, K32OBJ *obj )
{
HANDLE_ENTRY *entry;
K32OBJ *ptr;
HANDLE handle;
SYSTEM_LOCK();
entry = pdb->handle_table->entries;
for (handle = 0; handle < pdb->handle_table->count; handle++, entry++)
{
if (!(ptr = entry->ptr)) continue; /* empty slot */
if (obj && (ptr != obj)) continue; /* not the right object */
entry->access = 0;
entry->ptr = NULL;
if (entry->server != -1) CLIENT_CloseHandle( entry->server );
K32OBJ_DecCount( ptr );
}
SYSTEM_UNLOCK();
}
/*********************************************************************
@ -304,7 +15,9 @@ void HANDLE_CloseAll( PDB *pdb, K32OBJ *obj )
*/
BOOL WINAPI CloseHandle( HANDLE handle )
{
return HANDLE_Close( PROCESS_Current(), handle );
struct close_handle_request req = { handle };
CLIENT_SendRequest( REQ_CLOSE_HANDLE, -1, 1, &req, sizeof(req) );
return !CLIENT_WaitReply( NULL, NULL, 0 );
}
@ -313,23 +26,14 @@ BOOL WINAPI CloseHandle( HANDLE handle )
*/
BOOL WINAPI GetHandleInformation( HANDLE handle, LPDWORD flags )
{
BOOL ret = FALSE;
PDB *pdb = PROCESS_Current();
struct get_handle_info_request req;
struct get_handle_info_reply reply;
SYSTEM_LOCK();
if ((handle > 0) && (handle < pdb->handle_table->count))
{
HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
if (entry->ptr)
{
if (flags)
*flags = (entry->access & RESERVED_ALL) >> RESERVED_SHIFT;
ret = TRUE;
}
}
SYSTEM_UNLOCK();
if (!ret) SetLastError( ERROR_INVALID_HANDLE );
return ret;
req.handle = handle;
CLIENT_SendRequest( REQ_GET_HANDLE_INFO, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL )) return FALSE;
if (flags) *flags = reply.flags;
return TRUE;
}
@ -338,24 +42,13 @@ BOOL WINAPI GetHandleInformation( HANDLE handle, LPDWORD flags )
*/
BOOL WINAPI SetHandleInformation( HANDLE handle, DWORD mask, DWORD flags )
{
BOOL ret = FALSE;
PDB *pdb = PROCESS_Current();
struct set_handle_info_request req;
mask = (mask << RESERVED_SHIFT) & RESERVED_ALL;
flags = (flags << RESERVED_SHIFT) & RESERVED_ALL;
SYSTEM_LOCK();
if ((handle > 0) && (handle < pdb->handle_table->count))
{
HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
if (entry->ptr)
{
entry->access = (entry->access & ~mask) | flags;
ret = TRUE;
}
}
SYSTEM_UNLOCK();
if (!ret) SetLastError( ERROR_INVALID_HANDLE );
return ret;
req.handle = handle;
req.flags = flags;
req.mask = mask;
CLIENT_SendRequest( REQ_SET_HANDLE_INFO, -1, 1, &req, sizeof(req) );
return !CLIENT_WaitReply( NULL, NULL, 0 );
}
@ -366,52 +59,20 @@ BOOL WINAPI DuplicateHandle( HANDLE source_process, HANDLE source,
HANDLE dest_process, HANDLE *dest,
DWORD access, BOOL inherit, DWORD options )
{
PDB *src_pdb = NULL, *dst_pdb = NULL;
K32OBJ *obj = NULL;
BOOL ret = FALSE;
HANDLE handle;
int src_process, src_handle, dst_process, dst_handle;
struct dup_handle_request req;
struct dup_handle_reply reply;
SYSTEM_LOCK();
req.src_process = source_process;
req.src_handle = source;
req.dst_process = dest_process;
req.access = access;
req.inherit = inherit;
req.options = options;
if (!(src_pdb = (PDB *)HANDLE_GetObjPtr( PROCESS_Current(), source_process,
K32OBJ_PROCESS, PROCESS_DUP_HANDLE, &src_process )))
goto done;
if (!(obj = HANDLE_GetObjPtr( src_pdb, source, K32OBJ_UNKNOWN, 0, &src_handle )))
goto done;
/* Now that we are sure the source is valid, handle the options */
if (options & DUPLICATE_SAME_ACCESS)
HANDLE_GetAccess( src_pdb, source, &access );
if (options & DUPLICATE_CLOSE_SOURCE)
HANDLE_Close( src_pdb, source );
/* And duplicate the handle in the dest process */
if (!(dst_pdb = (PDB *)HANDLE_GetObjPtr( PROCESS_Current(), dest_process,
K32OBJ_PROCESS, PROCESS_DUP_HANDLE, &dst_process )))
goto done;
if ((src_process != -1) && (src_handle != -1) && (dst_process != -1))
dst_handle = CLIENT_DuplicateHandle( src_process, src_handle, dst_process, -1,
access, inherit, options );
else
dst_handle = -1;
if ((handle = HANDLE_Alloc( dst_pdb, obj, access, inherit,
dst_handle )) != INVALID_HANDLE_VALUE)
{
if (dest) *dest = handle;
ret = TRUE;
}
done:
if (dst_pdb) K32OBJ_DecCount( &dst_pdb->header );
if (obj) K32OBJ_DecCount( obj );
if (src_pdb) K32OBJ_DecCount( &src_pdb->header );
SYSTEM_UNLOCK();
return ret;
CLIENT_SendRequest( REQ_DUP_HANDLE, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL )) return FALSE;
if (dest) *dest = reply.handle;
return TRUE;
}
@ -420,31 +81,17 @@ done:
*/
HANDLE WINAPI ConvertToGlobalHandle(HANDLE hSrc)
{
int src_handle, dst_handle;
HANDLE handle;
K32OBJ *obj = NULL;
DWORD access;
struct dup_handle_request req;
struct dup_handle_reply reply;
if (HANDLE_IS_GLOBAL(hSrc))
return hSrc;
req.src_process = GetCurrentProcess();
req.src_handle = hSrc;
req.dst_process = -1;
req.access = 0;
req.inherit = FALSE;
req.options = DUP_HANDLE_MAKE_GLOBAL | DUP_HANDLE_SAME_ACCESS;
if (!(obj = HANDLE_GetObjPtr( PROCESS_Current(), hSrc, K32OBJ_UNKNOWN, 0, &src_handle )))
return 0;
HANDLE_GetAccess( PROCESS_Current(), hSrc, &access );
if (src_handle != -1)
dst_handle = CLIENT_DuplicateHandle( GetCurrentProcess(), src_handle, -1, -1, 0, FALSE,
DUP_HANDLE_MAKE_GLOBAL | DUP_HANDLE_SAME_ACCESS );
else
dst_handle = -1;
if ((handle = HANDLE_Alloc( PROCESS_Initial(), obj, access, FALSE,
dst_handle )) != INVALID_HANDLE_VALUE)
handle = HANDLE_LOCAL_TO_GLOBAL(handle);
else
handle = 0;
CloseHandle( hSrc );
return handle;
CLIENT_SendRequest( REQ_DUP_HANDLE, -1, 1, &req, sizeof(req) );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
return reply.handle;
}

278
scheduler/k32obj.c
View File

@ -1,278 +0,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;
}

43
scheduler/mutex.c
View File

@ -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 );
}

40
scheduler/pipe.c
View File

@ -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;
}

81
scheduler/process.c
View File

@ -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,27 +365,11 @@ 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)
*/
@ -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) );

44
scheduler/semaphore.c
View File

@ -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;

13
scheduler/synchro.c
View File

@ -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;

4
scheduler/sysdeps.c
View File

@ -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 );
}

125
scheduler/thread.c
View File

@ -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;
@ -277,43 +266,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
*
@ -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 );
}

205
win32/console.c
View File

@ -36,7 +36,6 @@
#include "winbase.h"
#include "wine/winuser16.h"
#include "wine/keyboard16.h"
#include "k32obj.h"
#include "thread.h"
#include "async.h"
#include "file.h"
@ -49,10 +48,6 @@
#include "server/request.h"
#include "server.h"
/* The CONSOLE kernel32 Object */
typedef struct _CONSOLE {
K32OBJ header;
} CONSOLE;
/* FIXME: Should be in an internal header file. OK, so which one?
Used by CONSOLE_makecomplex. */
@ -66,9 +61,7 @@ static BOOL CONSOLE_GetInfo( HANDLE handle, struct get_console_info_reply *reply
{
struct get_console_info_request req;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_CONSOLE, GENERIC_READ )) == -1)
return FALSE;
req.handle = handle;
CLIENT_SendRequest( REQ_GET_CONSOLE_INFO, -1, 1, &req, sizeof(req) );
return !CLIENT_WaitSimpleReply( reply, sizeof(*reply), NULL );
}
@ -432,32 +425,8 @@ DWORD WINAPI GetLargestConsoleWindowSize( HANDLE hConsoleOutput )
*/
BOOL WINAPI FreeConsole(VOID)
{
PDB *pdb = PROCESS_Current();
CONSOLE *console;
SYSTEM_LOCK();
console = (CONSOLE *)pdb->console;
if (console == NULL) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
CLIENT_SendRequest( REQ_FREE_CONSOLE, -1, 0 );
if (CLIENT_WaitReply( NULL, NULL, 0 ) != ERROR_SUCCESS)
{
K32OBJ_DecCount(&console->header);
SYSTEM_UNLOCK();
return FALSE;
}
HANDLE_CloseAll( pdb, &console->header );
K32OBJ_DecCount( &console->header );
pdb->console = NULL;
SYSTEM_UNLOCK();
return TRUE;
CLIENT_SendRequest( REQ_FREE_CONSOLE, -1, 0 );
return !CLIENT_WaitReply( NULL, NULL, 0 );
}
@ -470,29 +439,13 @@ HANDLE CONSOLE_OpenHandle( BOOL output, DWORD access, LPSECURITY_ATTRIBUTES sa )
{
struct open_console_request req;
struct open_console_reply reply;
CONSOLE *console;
HANDLE handle;
req.output = output;
req.access = access;
req.inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
CLIENT_SendRequest( REQ_OPEN_CONSOLE, -1, 1, &req, sizeof(req) );
CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL );
if (reply.handle == -1) return INVALID_HANDLE_VALUE;
SYSTEM_LOCK();
if (!(console = (CONSOLE*)HeapAlloc( SystemHeap, 0, sizeof(*console))))
{
SYSTEM_UNLOCK();
return FALSE;
}
console->header.type = K32OBJ_CONSOLE;
console->header.refcount = 1;
handle = HANDLE_Alloc( PROCESS_Current(), &console->header, req.access,
req.inherit, reply.handle );
SYSTEM_UNLOCK();
K32OBJ_DecCount(&console->header);
return handle;
return reply.handle;
}
@ -531,10 +484,6 @@ static BOOL CONSOLE_make_complex(HANDLE handle)
}
term.c_lflag = ~(ECHO|ICANON);
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_CONSOLE, 0 )) == -1)
return FALSE;
if (wine_openpty(&master, &slave, NULL, &term, NULL) < 0)
return FALSE;
@ -549,6 +498,7 @@ static BOOL CONSOLE_make_complex(HANDLE handle)
exit(1);
}
req.handle = handle;
req.pid = xpid;
CLIENT_SendRequest( REQ_SET_CONSOLE_FD, dup(slave), 1, &req, sizeof(req) );
CLIENT_WaitReply( NULL, NULL, 0 );
@ -591,37 +541,10 @@ BOOL WINAPI AllocConsole(VOID)
{
struct open_console_request req;
struct open_console_reply reply;
PDB *pdb = PROCESS_Current();
CONSOLE *console;
HANDLE hIn, hOut, hErr;
SYSTEM_LOCK(); /* FIXME: really only need to lock the process */
console = (CONSOLE *)pdb->console;
/* don't create a console if we already have one */
if (console != NULL) {
SetLastError(ERROR_ACCESS_DENIED);
SYSTEM_UNLOCK();
return FALSE;
}
if (!(console = (CONSOLE*)HeapAlloc( SystemHeap, 0, sizeof(*console))))
{
SYSTEM_UNLOCK();
return FALSE;
}
console->header.type = K32OBJ_CONSOLE;
console->header.refcount = 1;
CLIENT_SendRequest( REQ_ALLOC_CONSOLE, -1, 0 );
if (CLIENT_WaitReply( NULL, NULL, 0 ) != ERROR_SUCCESS)
{
K32OBJ_DecCount(&console->header);
SYSTEM_UNLOCK();
return FALSE;
}
if (CLIENT_WaitReply( NULL, NULL, 0 ) != ERROR_SUCCESS) return FALSE;
req.output = 0;
req.access = GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE;
@ -629,35 +552,20 @@ BOOL WINAPI AllocConsole(VOID)
CLIENT_SendRequest( REQ_OPEN_CONSOLE, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL ) != ERROR_SUCCESS)
{
K32OBJ_DecCount(&console->header);
SYSTEM_UNLOCK();
/* FIXME: free console */
return FALSE;
}
if ((hIn = HANDLE_Alloc(pdb,&console->header, req.access,
FALSE, reply.handle)) == INVALID_HANDLE_VALUE)
{
K32OBJ_DecCount(&console->header);
SYSTEM_UNLOCK();
return FALSE;
}
hIn = reply.handle;
req.output = 1;
CLIENT_SendRequest( REQ_OPEN_CONSOLE, -1, 1, &req, sizeof(req) );
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL ) != ERROR_SUCCESS)
{
CloseHandle(hIn);
K32OBJ_DecCount(&console->header);
SYSTEM_UNLOCK();
/* FIXME: free console */
return FALSE;
}
if ((hOut = HANDLE_Alloc(pdb,&console->header, req.access,
FALSE, reply.handle)) == INVALID_HANDLE_VALUE)
{
CloseHandle(hIn);
K32OBJ_DecCount(&console->header);
SYSTEM_UNLOCK();
return FALSE;
}
hOut = reply.handle;
if (!DuplicateHandle( GetCurrentProcess(), hOut,
GetCurrentProcess(), &hErr,
@ -665,22 +573,15 @@ BOOL WINAPI AllocConsole(VOID)
{
CloseHandle(hIn);
CloseHandle(hOut);
K32OBJ_DecCount(&console->header);
SYSTEM_UNLOCK();
return FALSE;
}
if (pdb->console) K32OBJ_DecCount( pdb->console );
pdb->console = (K32OBJ *)console;
K32OBJ_IncCount( pdb->console );
/* NT resets the STD_*_HANDLEs on console alloc */
SetStdHandle(STD_INPUT_HANDLE, hIn);
SetStdHandle(STD_OUTPUT_HANDLE, hOut);
SetStdHandle(STD_ERROR_HANDLE, hErr);
SetLastError(ERROR_SUCCESS);
SYSTEM_UNLOCK();
SetConsoleTitleA("Wine Console");
return TRUE;
}
@ -714,9 +615,7 @@ BOOL WINAPI GetConsoleMode(HANDLE hcon,LPDWORD mode)
struct get_console_mode_request req;
struct get_console_mode_reply reply;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hcon,
K32OBJ_CONSOLE, GENERIC_READ )) == -1)
return FALSE;
req.handle = hcon;
CLIENT_SendRequest( REQ_GET_CONSOLE_MODE, -1, 1, &req, sizeof(req));
if (CLIENT_WaitSimpleReply( &reply, sizeof(reply), NULL )) return FALSE;
*mode = reply.mode;
@ -739,9 +638,7 @@ BOOL WINAPI SetConsoleMode( HANDLE hcon, DWORD mode )
{
struct set_console_mode_request req;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hcon,
K32OBJ_CONSOLE, GENERIC_READ )) == -1)
return FALSE;
req.handle = hcon;
req.mode = mode;
CLIENT_SendRequest( REQ_SET_CONSOLE_MODE, -1, 1, &req, sizeof(req));
return !CLIENT_WaitReply( NULL, NULL, 0 );
@ -762,12 +659,7 @@ DWORD WINAPI GetConsoleTitleA(LPSTR title,DWORD size)
if ((hcon = CreateFileA( "CONOUT$", GENERIC_READ, 0, NULL,
OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE)
return 0;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hcon,
K32OBJ_CONSOLE, GENERIC_READ )) == -1)
{
CloseHandle( hcon );
return 0;
}
req.handle = hcon;
CLIENT_SendRequest( REQ_GET_CONSOLE_INFO, -1, 1, &req, sizeof(req) );
if (!CLIENT_WaitReply( &len, NULL, 2, &reply, sizeof(reply), title, size ))
{
@ -913,9 +805,6 @@ BOOL WINAPI ReadConsoleA( HANDLE hConsoleInput,
struct read_console_input_request req;
INPUT_RECORD ir;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hConsoleInput,
K32OBJ_CONSOLE, GENERIC_READ )) == -1)
return FALSE;
TRACE(console,"(%d,%p,%ld,%p,%p)\n",
hConsoleInput,lpBuffer,nNumberOfCharsToRead,
lpNumberOfCharsRead,lpReserved
@ -923,6 +812,7 @@ BOOL WINAPI ReadConsoleA( HANDLE hConsoleInput,
CONSOLE_get_input(hConsoleInput,FALSE);
req.handle = hConsoleInput;
req.count = 1;
req.flush = 1;
@ -994,9 +884,7 @@ BOOL WINAPI ReadConsoleInputA(HANDLE hConsoleInput,
struct read_console_input_request req;
int len;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hConsoleInput,
K32OBJ_CONSOLE, GENERIC_READ )) == -1)
return FALSE;
req.handle = hConsoleInput;
req.count = nLength;
req.flush = 1;
@ -1035,9 +923,7 @@ BOOL WINAPI FlushConsoleInputBuffer( HANDLE handle )
struct read_console_input_request req;
int len;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_CONSOLE, GENERIC_READ )) == -1)
return FALSE;
req.handle = handle;
req.count = -1; /* get all records */
req.flush = 1;
CLIENT_SendRequest( REQ_READ_CONSOLE_INPUT, -1, 1, &req, sizeof(req) );
@ -1058,11 +944,8 @@ BOOL WINAPI PeekConsoleInputA( HANDLE handle, LPINPUT_RECORD buffer,
struct read_console_input_request req;
int len;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_CONSOLE, GENERIC_READ )) == -1)
return FALSE;
CONSOLE_get_input(handle,FALSE);
req.handle = handle;
req.count = count;
req.flush = 0;
@ -1098,9 +981,7 @@ BOOL WINAPI WriteConsoleInputA( HANDLE handle, INPUT_RECORD *buffer,
struct write_console_input_request req;
struct write_console_input_reply reply;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), handle,
K32OBJ_CONSOLE, GENERIC_WRITE )) == -1)
return FALSE;
req.handle = handle;
req.count = count;
CLIENT_SendRequest( REQ_WRITE_CONSOLE_INPUT, -1, 2, &req, sizeof(req),
buffer, count * sizeof(*buffer) );
@ -1121,47 +1002,6 @@ BOOL WINAPI WriteConsoleInputA( HANDLE handle, INPUT_RECORD *buffer,
*/
BOOL WINAPI SetConsoleTitleA(LPCSTR title)
{
#if 0
PDB *pdb = PROCESS_Current();
CONSOLE *console;
DWORD written;
char titleformat[]="\033]2;%s\a"; /*this should work for xterms*/
LPSTR titlestring;
BOOL ret=FALSE;
TRACE(console,"(%s)\n",title);
console = (CONSOLE *)pdb->console;
if (!console)
return FALSE;
if(console->title) /* Free old title, if there is one */
HeapFree( SystemHeap, 0, console->title );
console->title = (LPSTR)HeapAlloc(SystemHeap, 0,strlen(title)+1);
if(console->title) strcpy(console->title,title);
titlestring = HeapAlloc(GetProcessHeap(), 0,strlen(title)+strlen(titleformat)+1);
if (!titlestring) {
K32OBJ_DecCount(&console->header);
return FALSE;
}
sprintf(titlestring,titleformat,title);
#if 0
/* only set title for complex console (own xterm) */
if (console->pid != -1) {
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),titlestring,strlen(titlestring),&written,NULL);
if (written == strlen(titlestring))
ret =TRUE;
} else
ret = TRUE;
#endif
HeapFree( GetProcessHeap(), 0, titlestring );
K32OBJ_DecCount(&console->header);
return ret;
#endif
struct set_console_info_request req;
struct get_console_info_reply info;
HANDLE hcon;
@ -1170,9 +1010,7 @@ BOOL WINAPI SetConsoleTitleA(LPCSTR title)
if ((hcon = CreateFileA( "CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE)
return FALSE;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hcon,
K32OBJ_CONSOLE, GENERIC_WRITE )) == -1)
goto error;
req.handle = hcon;
req.mask = SET_CONSOLE_INFO_TITLE;
CLIENT_SendRequest( REQ_SET_CONSOLE_INFO, -1, 2, &req, sizeof(req),
title, strlen(title)+1 );
@ -1184,6 +1022,7 @@ BOOL WINAPI SetConsoleTitleA(LPCSTR title)
WriteFile( hcon, title, strlen(title), &written, NULL );
WriteFile( hcon, "\a", 1, &written, NULL );
}
CloseHandle( hcon );
return TRUE;
error:
CloseHandle( hcon );
@ -1307,9 +1146,7 @@ BOOL WINAPI SetConsoleCursorInfo(
char buf[8];
DWORD xlen;
if ((req.handle = HANDLE_GetServerHandle( PROCESS_Current(), hcon,
K32OBJ_CONSOLE, GENERIC_WRITE )) == -1)
return FALSE;
req.handle = hcon;
CONSOLE_make_complex(hcon);
sprintf(buf,"\033[?25%c",cinfo->bVisible?'h':'l');
WriteFile(hcon,buf,strlen(buf),&xlen,NULL);

4
win32/device.c
View File

@ -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) &&