/* * Wine server definitions * * Copyright (C) 1998 Alexandre Julliard */ #ifndef __WINE_SERVER_H #define __WINE_SERVER_H #include #include /* message header as sent on the wire */ struct header { unsigned int len; /* total msg length (including this header) */ unsigned int type; /* msg type */ unsigned int seq; /* sequence number */ }; /* max msg length (not including the header) */ #define MAX_MSG_LENGTH (16384 - sizeof(struct header)) /* data structure used to pass an fd with sendmsg/recvmsg */ struct cmsg_fd { int len; /* sizeof structure */ int level; /* SOL_SOCKET */ int type; /* SCM_RIGHTS */ int fd; /* fd to pass */ }; /* request handler definition */ #define DECL_HANDLER(name) \ void req_##name( struct name##_request *req, void *data, int len, int fd ) /* Request structures */ /* following are the definitions of all the client<->server */ /* communication format; requests are from client to server, */ /* replies are from server to client. All requests must have */ /* a corresponding structure; the replies can be empty in */ /* which case it isn't necessary to define a structure. */ /* Create a new process from the context of the parent */ struct new_process_request { int inherit; /* inherit flag */ int inherit_all; /* inherit all handles from parent */ int create_flags; /* creation flags */ int start_flags; /* flags from startup info */ int hstdin; /* handle for stdin */ int hstdout; /* handle for stdout */ int hstderr; /* handle for stderr */ int cmd_show; /* main window show mode */ void* env_ptr; /* pointer to environment (FIXME: hack) */ char cmd_line[0]; /* command line */ }; struct new_process_reply { void* pid; /* process id */ int handle; /* process handle (in the current process) */ }; /* Create a new thread from the context of the parent */ struct new_thread_request { void* pid; /* process id for the new thread */ int suspend; /* new thread should be suspended on creation */ int inherit; /* inherit flag */ }; struct new_thread_reply { void* tid; /* thread id */ int handle; /* thread handle (in the current process) */ }; /* Set the server debug level */ struct set_debug_request { int level; /* New debug level */ }; /* Initialize a process; called from the new process context */ struct init_process_request { int dummy; }; struct init_process_reply { int start_flags; /* flags from startup info */ int hstdin; /* handle for stdin */ int hstdout; /* handle for stdout */ int hstderr; /* handle for stderr */ int cmd_show; /* main window show mode */ void* env_ptr; /* pointer to environment (FIXME: hack) */ char cmdline[0]; /* command line */ }; /* Initialize a thread; called from the child after fork()/clone() */ struct init_thread_request { int unix_pid; /* Unix pid of new thread */ void* teb; /* TEB of new thread (in thread address space) */ }; struct init_thread_reply { void* pid; /* process id of the new thread's process */ void* tid; /* thread id of the new thread */ }; /* Terminate a process */ struct terminate_process_request { int handle; /* process handle to terminate */ int exit_code; /* process exit code */ }; /* Terminate a thread */ struct terminate_thread_request { int handle; /* thread handle to terminate */ int exit_code; /* thread exit code */ }; /* Retrieve information about a process */ struct get_process_info_request { int handle; /* process handle */ }; struct get_process_info_reply { void* pid; /* server process id */ int exit_code; /* process exit code */ int priority; /* priority class */ int process_affinity; /* process affinity mask */ int system_affinity; /* system affinity mask */ }; /* Set a process informations */ struct set_process_info_request { int handle; /* process handle */ int mask; /* setting mask (see below) */ int priority; /* priority class */ int affinity; /* affinity mask */ }; #define SET_PROCESS_INFO_PRIORITY 0x01 #define SET_PROCESS_INFO_AFFINITY 0x02 /* Retrieve information about a thread */ struct get_thread_info_request { int handle; /* thread handle */ }; struct get_thread_info_reply { void* tid; /* server thread id */ int exit_code; /* thread exit code */ int priority; /* thread priority level */ }; /* Set a thread informations */ struct set_thread_info_request { int handle; /* thread handle */ int mask; /* setting mask (see below) */ int priority; /* priority class */ int affinity; /* affinity mask */ }; #define SET_THREAD_INFO_PRIORITY 0x01 #define SET_THREAD_INFO_AFFINITY 0x02 /* Suspend a thread */ struct suspend_thread_request { int handle; /* thread handle */ }; struct suspend_thread_reply { int count; /* new suspend count */ }; /* Resume a thread */ struct resume_thread_request { int handle; /* thread handle */ }; struct resume_thread_reply { int count; /* new suspend count */ }; /* Debugger support: freeze / unfreeze */ struct debugger_request { int op; /* operation type */ }; enum debugger_op { DEBUGGER_FREEZE_ALL, DEBUGGER_UNFREEZE_ALL }; /* Queue an APC for a thread */ struct queue_apc_request { int handle; /* thread handle */ void* func; /* function to call */ void* param; /* param for function to call */ }; /* Close a handle for the current process */ struct close_handle_request { int handle; /* handle to close */ }; /* Get information about a handle */ struct get_handle_info_request { int handle; /* handle we are interested in */ }; struct get_handle_info_reply { int flags; /* handle flags */ }; /* Set a handle information */ struct set_handle_info_request { int handle; /* handle we are interested in */ int flags; /* new handle flags */ int mask; /* mask for flags to set */ }; /* Duplicate a handle */ struct dup_handle_request { int src_process; /* src process handle */ int src_handle; /* src handle to duplicate */ int dst_process; /* dst process handle */ unsigned int access; /* wanted access rights */ int inherit; /* inherit flag */ int options; /* duplicate options (see below) */ }; #define DUP_HANDLE_CLOSE_SOURCE DUPLICATE_CLOSE_SOURCE #define DUP_HANDLE_SAME_ACCESS DUPLICATE_SAME_ACCESS #define DUP_HANDLE_MAKE_GLOBAL 0x80000000 /* Not a Windows flag */ struct dup_handle_reply { int handle; /* duplicated handle in dst process */ }; /* Open a handle to a process */ struct open_process_request { void* pid; /* process id to open */ unsigned int access; /* wanted access rights */ int inherit; /* inherit flag */ }; struct open_process_reply { int handle; /* handle to the process */ }; /* Wait for handles */ struct select_request { int count; /* handles count */ int flags; /* wait flags (see below) */ int timeout; /* timeout in ms */ int handles[0]; /* handles to select on */ }; struct select_reply { int signaled; /* signaled handle */ void* apcs[0]; /* async procedures to call */ }; #define SELECT_ALL 1 #define SELECT_ALERTABLE 2 #define SELECT_TIMEOUT 4 /* Create an event */ struct create_event_request { int manual_reset; /* manual reset event */ int initial_state; /* initial state of the event */ int inherit; /* inherit flag */ char name[0]; /* event name */ }; struct create_event_reply { int handle; /* handle to the event */ }; /* Event operation */ struct event_op_request { int handle; /* handle to event */ int op; /* event operation (see below) */ }; enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT }; /* Open an event */ struct open_event_request { unsigned int access; /* wanted access rights */ int inherit; /* inherit flag */ char name[0]; /* object name */ }; struct open_event_reply { int handle; /* handle to the event */ }; /* Create a mutex */ struct create_mutex_request { int owned; /* initially owned? */ int inherit; /* inherit flag */ char name[0]; /* mutex name */ }; struct create_mutex_reply { int handle; /* handle to the mutex */ }; /* Release a mutex */ struct release_mutex_request { int handle; /* handle to the mutex */ }; /* Open a mutex */ struct open_mutex_request { unsigned int access; /* wanted access rights */ int inherit; /* inherit flag */ char name[0]; /* object name */ }; struct open_mutex_reply { int handle; /* handle to the mutex */ }; /* Create a semaphore */ struct create_semaphore_request { unsigned int initial; /* initial count */ unsigned int max; /* maximum count */ int inherit; /* inherit flag */ char name[0]; /* semaphore name */ }; struct create_semaphore_reply { int handle; /* handle to the semaphore */ }; /* Release a semaphore */ struct release_semaphore_request { int handle; /* handle to the semaphore */ unsigned int count; /* count to add to semaphore */ }; struct release_semaphore_reply { unsigned int prev_count; /* previous semaphore count */ }; /* Open a semaphore */ struct open_semaphore_request { unsigned int access; /* wanted access rights */ int inherit; /* inherit flag */ char name[0]; /* object name */ }; struct open_semaphore_reply { int handle; /* handle to the semaphore */ }; /* Create a file */ struct create_file_request { unsigned int access; /* wanted access rights */ int inherit; /* inherit flag */ unsigned int sharing; /* sharing flags */ int create; /* file create action */ unsigned int attrs; /* file attributes for creation */ char name[0]; /* file name */ }; struct create_file_reply { int handle; /* handle to the file */ }; /* Get a Unix fd to read from a file */ struct get_read_fd_request { int handle; /* handle to the file */ }; /* Get a Unix fd to write to a file */ struct get_write_fd_request { int handle; /* handle to the file */ }; /* Set a file current position */ struct set_file_pointer_request { int handle; /* handle to the file */ int low; /* position low word */ int high; /* position high word */ int whence; /* whence to seek */ }; struct set_file_pointer_reply { int low; /* new position low word */ int high; /* new position high word */ }; /* Truncate (or extend) a file */ struct truncate_file_request { int handle; /* handle to the file */ }; /* Set a file access and modification times */ struct set_file_time_request { int handle; /* handle to the file */ time_t access_time; /* last access time */ time_t write_time; /* last write time */ }; /* Flush a file buffers */ struct flush_file_request { int handle; /* handle to the file */ }; /* Get information about a file */ struct get_file_info_request { int handle; /* handle to the file */ }; struct get_file_info_reply { int type; /* file type */ int attr; /* file attributes */ time_t access_time; /* last access time */ time_t write_time; /* last write time */ int size_high; /* file size */ int size_low; /* file size */ int links; /* number of links */ int index_high; /* unique index */ int index_low; /* unique index */ unsigned int serial; /* volume serial number */ }; /* Lock a region of a file */ struct lock_file_request { int handle; /* handle to the file */ unsigned int offset_low; /* offset of start of lock */ unsigned int offset_high; /* offset of start of lock */ unsigned int count_low; /* count of bytes to lock */ unsigned int count_high; /* count of bytes to lock */ }; /* Unlock a region of a file */ struct unlock_file_request { int handle; /* handle to the file */ unsigned int offset_low; /* offset of start of unlock */ unsigned int offset_high; /* offset of start of unlock */ unsigned int count_low; /* count of bytes to unlock */ unsigned int count_high; /* count of bytes to unlock */ }; /* Create an anonymous pipe */ struct create_pipe_request { int inherit; /* inherit flag */ }; struct create_pipe_reply { int handle_read; /* handle to the read-side of the pipe */ int handle_write; /* handle to the write-side of the pipe */ }; /* Allocate a console for the current process */ struct alloc_console_request { int dummy; }; /* Free the console of the current process */ struct free_console_request { int dummy; }; /* Open a handle to the process console */ struct open_console_request { int output; /* input or output? */ unsigned int access; /* wanted access rights */ int inherit; /* inherit flag */ }; struct open_console_reply { int handle; /* handle to the console */ }; /* Set a console file descriptor */ struct set_console_fd_request { int handle; /* handle to the console */ int pid; /* pid of xterm (hack) */ }; /* Get a console mode (input or output) */ struct get_console_mode_request { int handle; /* handle to the console */ }; struct get_console_mode_reply { int mode; /* console mode */ }; /* Set a console mode (input or output) */ struct set_console_mode_request { int handle; /* handle to the console */ int mode; /* console mode */ }; /* Set info about a console (output only) */ struct set_console_info_request { int handle; /* handle to the console */ int mask; /* setting mask (see below) */ int cursor_size; /* size of cursor (percentage filled) */ int cursor_visible;/* cursor visibility flag */ char title[0]; /* console title */ }; #define SET_CONSOLE_INFO_CURSOR 0x01 #define SET_CONSOLE_INFO_TITLE 0x02 /* Get info about a console (output only) */ struct get_console_info_request { int handle; /* handle to the console */ }; struct get_console_info_reply { int cursor_size; /* size of cursor (percentage filled) */ int cursor_visible;/* cursor visibility flag */ int pid; /* pid of xterm (hack) */ /* char title[0]; */ /* console title */ }; /* Add input records to a console input queue */ struct write_console_input_request { int handle; /* handle to the console input */ int count; /* number of input records */ /* INPUT_RECORD records[0]; */ /* input records */ }; struct write_console_input_reply { int written; /* number of records written */ }; /* Fetch input records from a console input queue */ struct read_console_input_request { int handle; /* handle to the console input */ int count; /* max number of records to retrieve */ int flush; /* flush the retrieved records from the queue? */ }; struct read_console_input_reply { int dummy; /* INPUT_RECORD records[0]; */ /* input records */ }; /* Create a change notification */ struct create_change_notification_request { int subtree; /* watch all the subtree */ int filter; /* notification filter */ }; struct create_change_notification_reply { int handle; /* handle to the change notification */ }; /* Create a file mapping */ struct create_mapping_request { int size_high; /* mapping size */ int size_low; /* mapping size */ int protect; /* protection flags (see below) */ int inherit; /* inherit flag */ int handle; /* file handle */ char name[0]; /* object name */ }; struct create_mapping_reply { int handle; /* handle to the mapping */ }; /* protection flags */ #define VPROT_READ 0x01 #define VPROT_WRITE 0x02 #define VPROT_EXEC 0x04 #define VPROT_WRITECOPY 0x08 #define VPROT_GUARD 0x10 #define VPROT_NOCACHE 0x20 #define VPROT_COMMITTED 0x40 /* Open a mapping */ struct open_mapping_request { unsigned int access; /* wanted access rights */ int inherit; /* inherit flag */ char name[0]; /* object name */ }; struct open_mapping_reply { int handle; /* handle to the mapping */ }; /* Get information about a file mapping */ struct get_mapping_info_request { int handle; /* handle to the mapping */ }; struct get_mapping_info_reply { int size_high; /* mapping size */ int size_low; /* mapping size */ int protect; /* protection flags */ }; /* Create a device */ struct create_device_request { unsigned int access; /* wanted access rights */ int inherit; /* inherit flag */ int id; /* client private id */ }; struct create_device_reply { int handle; /* handle to the device */ }; /* Create a snapshot */ struct create_snapshot_request { int inherit; /* inherit flag */ int flags; /* snapshot flags (TH32CS_*) */ }; struct create_snapshot_reply { int handle; /* handle to the snapshot */ }; /* Get the next process from a snapshot */ struct next_process_request { int handle; /* handle to the snapshot */ int reset; /* reset snapshot position? */ }; struct next_process_reply { void* pid; /* process id */ int threads; /* number of threads */ int priority; /* process priority */ }; /* Wait for a debug event */ struct wait_debug_event_request { int timeout; /* timeout in ms */ }; struct wait_debug_event_reply { int code; /* event code */ void* pid; /* process id */ void* tid; /* thread id */ /* followed by the event data (see below) */ }; /* Send a debug event */ struct send_debug_event_request { int code; /* event code */ /* followed by the event data (see below) */ }; struct send_debug_event_reply { int status; /* event continuation status */ }; /* definitions of the event data depending on the event code */ struct debug_event_exception { int code; /* exception code */ int flags; /* exception flags */ void *record; /* exception record ptr */ void *addr; /* exception address */ int nb_params; /* exceptions parameters */ int params[15]; int first_chance; /* first chance to handle it? */ }; struct debug_event_create_thread { int handle; /* handle to the new thread */ void *teb; /* thread teb (in debugged process address space) */ void *start; /* thread startup routine */ }; struct debug_event_create_process { int file; /* handle to the process exe file */ int process; /* handle to the new process */ int thread; /* handle to the new thread */ void *base; /* base of executable image */ int dbg_offset; /* offset of debug info in file */ int dbg_size; /* size of debug info */ void *teb; /* thread teb (in debugged process address space) */ void *start; /* thread startup routine */ void *name; /* image name (optional) */ int unicode; /* is it Unicode? */ }; struct debug_event_exit { int exit_code; /* thread or process exit code */ }; struct debug_event_load_dll { int handle; /* file handle for the dll */ void *base; /* base address of the dll */ int dbg_offset; /* offset of debug info in file */ int dbg_size; /* size of debug info */ void *name; /* image name (optional) */ int unicode; /* is it Unicode? */ }; struct debug_event_unload_dll { void *base; /* base address of the dll */ }; struct debug_event_output_string { void *string; /* string to display (in debugged process address space) */ int unicode; /* is it Unicode? */ int length; /* string length */ }; struct debug_event_rip_info { int error; /* ??? */ int type; /* ??? */ }; union debug_event_data { struct debug_event_exception exception; struct debug_event_create_thread create_thread; struct debug_event_create_process create_process; struct debug_event_exit exit; struct debug_event_load_dll load_dll; struct debug_event_unload_dll unload_dll; struct debug_event_output_string output_string; struct debug_event_rip_info rip_info; }; /* Continue a debug event */ struct continue_debug_event_request { void* pid; /* process id to continue */ void* tid; /* thread id to continue */ int status; /* continuation status */ }; /* Start debugging an existing process */ struct debug_process_request { void* pid; /* id of the process to debug */ }; /* requests definitions */ #include "server/request.h" /* client-side functions */ #ifndef __WINE_SERVER__ /* client communication functions */ extern void CLIENT_ProtocolError( const char *err, ... ); extern void CLIENT_SendRequest( enum request req, int pass_fd, int n, ... /* arg_1, len_1, etc. */ ); extern unsigned int CLIENT_WaitReply( int *len, int *passed_fd, int n, ... /* arg_1, len_1, etc. */ ); extern unsigned int CLIENT_WaitSimpleReply( void *reply, int len, int *passed_fd ); extern int CLIENT_InitServer(void); extern int CLIENT_SetDebug( int level ); extern int CLIENT_DebuggerRequest( int op ); extern int CLIENT_InitThread(void); #endif /* __WINE_SERVER__ */ #endif /* __WINE_SERVER_H */