mirror of
git://source.winehq.org/git/wine.git
synced 2024-10-04 18:47:07 +00:00
Added the data structures and macros that will be needed to support
reentrant server requests.
This commit is contained in:
parent
5e7fa021ef
commit
8611353053
289
include/server.h
289
include/server.h
|
@ -22,7 +22,24 @@
|
|||
/* to generate the request/reply tracing functions */
|
||||
#define IN /*nothing*/
|
||||
#define OUT /*nothing*/
|
||||
#define VARARG(name,func) /*nothing*/
|
||||
|
||||
struct request_header
|
||||
{
|
||||
IN int req; /* request code */
|
||||
IN unsigned short fixed_size; /* size of the fixed part of the request */
|
||||
IN unsigned short var_size; /* size of the variable part of the request */
|
||||
OUT unsigned int error; /* error result */
|
||||
};
|
||||
#define REQUEST_HEADER struct request_header header
|
||||
|
||||
|
||||
/* placeholder structure for the maximum allowed request size */
|
||||
/* this is used to construct the generic_request union */
|
||||
struct request_max_size
|
||||
{
|
||||
int pad[16]; /* the max request size is 16 ints */
|
||||
};
|
||||
|
||||
/* a path name for server requests (Unicode) */
|
||||
typedef WCHAR path_t[MAX_PATH+1];
|
||||
|
@ -104,6 +121,7 @@ typedef struct
|
|||
/* Create a new process from the context of the parent */
|
||||
struct new_process_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int inherit_all; /* inherit all handles from parent */
|
||||
IN int create_flags; /* creation flags */
|
||||
IN int start_flags; /* flags from startup info */
|
||||
|
@ -120,6 +138,7 @@ struct new_process_request
|
|||
/* Wait for the new process to start */
|
||||
struct wait_process_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int pinherit; /* process handle inherit flag */
|
||||
IN int tinherit; /* thread handle inherit flag */
|
||||
IN int timeout; /* wait timeout */
|
||||
|
@ -135,6 +154,7 @@ struct wait_process_request
|
|||
/* Create a new thread from the context of the parent */
|
||||
struct new_thread_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int suspend; /* new thread should be suspended on creation */
|
||||
IN int inherit; /* inherit flag */
|
||||
OUT void* tid; /* thread id */
|
||||
|
@ -145,6 +165,7 @@ struct new_thread_request
|
|||
/* Signal that we are finished booting on the client side */
|
||||
struct boot_done_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int debug_level; /* new debug level */
|
||||
};
|
||||
|
||||
|
@ -152,6 +173,7 @@ struct boot_done_request
|
|||
/* Initialize a process; called from the new process context */
|
||||
struct init_process_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN void* ldt_copy; /* addr of LDT copy */
|
||||
IN void* ldt_flags; /* addr of LDT flags */
|
||||
IN int ppid; /* parent Unix pid */
|
||||
|
@ -168,6 +190,7 @@ struct init_process_request
|
|||
/* Signal the end of the process initialization */
|
||||
struct init_process_done_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN void* module; /* main module base address */
|
||||
IN void* entry; /* process entry point */
|
||||
IN void* name; /* ptr to ptr to name (in process addr space) */
|
||||
|
@ -179,6 +202,7 @@ struct init_process_done_request
|
|||
/* Initialize a thread; called from the child after fork()/clone() */
|
||||
struct init_thread_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int unix_pid; /* Unix pid of new thread */
|
||||
IN void* teb; /* TEB of new thread (in thread address space) */
|
||||
IN void* entry; /* thread entry point (in thread address space) */
|
||||
|
@ -190,6 +214,7 @@ struct init_thread_request
|
|||
/* created thread gets (without having to request it) */
|
||||
struct get_thread_buffer_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
OUT void* pid; /* process id of the new thread's process */
|
||||
OUT void* tid; /* thread id of the new thread */
|
||||
OUT int boot; /* is this the boot thread? */
|
||||
|
@ -200,6 +225,7 @@ struct get_thread_buffer_request
|
|||
/* Terminate a process */
|
||||
struct terminate_process_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* process handle to terminate */
|
||||
IN int exit_code; /* process exit code */
|
||||
OUT int self; /* suicide? */
|
||||
|
@ -209,6 +235,7 @@ struct terminate_process_request
|
|||
/* Terminate a thread */
|
||||
struct terminate_thread_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* thread handle to terminate */
|
||||
IN int exit_code; /* thread exit code */
|
||||
OUT int self; /* suicide? */
|
||||
|
@ -219,6 +246,7 @@ struct terminate_thread_request
|
|||
/* Retrieve information about a process */
|
||||
struct get_process_info_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* process handle */
|
||||
OUT void* pid; /* server process id */
|
||||
OUT int debugged; /* debugged? */
|
||||
|
@ -232,6 +260,7 @@ struct get_process_info_request
|
|||
/* Set a process informations */
|
||||
struct set_process_info_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* process handle */
|
||||
IN int mask; /* setting mask (see below) */
|
||||
IN int priority; /* priority class */
|
||||
|
@ -244,6 +273,7 @@ struct set_process_info_request
|
|||
/* Retrieve information about a thread */
|
||||
struct get_thread_info_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* thread handle */
|
||||
IN void* tid_in; /* thread id (optional) */
|
||||
OUT void* tid; /* server thread id */
|
||||
|
@ -256,6 +286,7 @@ struct get_thread_info_request
|
|||
/* Set a thread informations */
|
||||
struct set_thread_info_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* thread handle */
|
||||
IN int mask; /* setting mask (see below) */
|
||||
IN int priority; /* priority class */
|
||||
|
@ -268,6 +299,7 @@ struct set_thread_info_request
|
|||
/* Suspend a thread */
|
||||
struct suspend_thread_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* thread handle */
|
||||
OUT int count; /* new suspend count */
|
||||
};
|
||||
|
@ -276,6 +308,7 @@ struct suspend_thread_request
|
|||
/* Resume a thread */
|
||||
struct resume_thread_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* thread handle */
|
||||
OUT int count; /* new suspend count */
|
||||
};
|
||||
|
@ -284,6 +317,7 @@ struct resume_thread_request
|
|||
/* Notify the server that a dll has been loaded */
|
||||
struct load_dll_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* file handle */
|
||||
IN void* base; /* base address */
|
||||
IN int dbg_offset; /* debug info offset */
|
||||
|
@ -295,6 +329,7 @@ struct load_dll_request
|
|||
/* Notify the server that a dll is being unloaded */
|
||||
struct unload_dll_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN void* base; /* base address */
|
||||
};
|
||||
|
||||
|
@ -302,6 +337,7 @@ struct unload_dll_request
|
|||
/* Queue an APC for a thread */
|
||||
struct queue_apc_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* thread handle */
|
||||
IN void* func; /* function to call */
|
||||
IN void* param; /* param for function to call */
|
||||
|
@ -311,6 +347,7 @@ struct queue_apc_request
|
|||
/* Get next APC to call */
|
||||
struct get_apc_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
OUT void* func; /* function to call */
|
||||
OUT int type; /* function type */
|
||||
OUT int nb_args; /* number of arguments */
|
||||
|
@ -322,6 +359,7 @@ enum apc_type { APC_NONE, APC_USER, APC_TIMER };
|
|||
/* Close a handle for the current process */
|
||||
struct close_handle_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to close */
|
||||
};
|
||||
|
||||
|
@ -329,6 +367,7 @@ struct close_handle_request
|
|||
/* Get information about a handle */
|
||||
struct get_handle_info_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle we are interested in */
|
||||
OUT int flags; /* handle flags */
|
||||
};
|
||||
|
@ -337,6 +376,7 @@ struct get_handle_info_request
|
|||
/* Set a handle information */
|
||||
struct set_handle_info_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle we are interested in */
|
||||
IN int flags; /* new handle flags */
|
||||
IN int mask; /* mask for flags to set */
|
||||
|
@ -346,6 +386,7 @@ struct set_handle_info_request
|
|||
/* Duplicate a handle */
|
||||
struct dup_handle_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int src_process; /* src process handle */
|
||||
IN int src_handle; /* src handle to duplicate */
|
||||
IN int dst_process; /* dst process handle */
|
||||
|
@ -362,6 +403,7 @@ struct dup_handle_request
|
|||
/* Open a handle to a process */
|
||||
struct open_process_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN void* pid; /* process id to open */
|
||||
IN unsigned int access; /* wanted access rights */
|
||||
IN int inherit; /* inherit flag */
|
||||
|
@ -372,6 +414,7 @@ struct open_process_request
|
|||
/* Wait for handles */
|
||||
struct select_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int count; /* handles count */
|
||||
IN int flags; /* wait flags (see below) */
|
||||
IN int timeout; /* timeout in ms */
|
||||
|
@ -386,6 +429,7 @@ struct select_request
|
|||
/* Create an event */
|
||||
struct create_event_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int manual_reset; /* manual reset event */
|
||||
IN int initial_state; /* initial state of the event */
|
||||
IN int inherit; /* inherit flag */
|
||||
|
@ -396,6 +440,7 @@ struct create_event_request
|
|||
/* Event operation */
|
||||
struct event_op_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to event */
|
||||
IN int op; /* event operation (see below) */
|
||||
};
|
||||
|
@ -405,6 +450,7 @@ enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT };
|
|||
/* Open an event */
|
||||
struct open_event_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN unsigned int access; /* wanted access rights */
|
||||
IN int inherit; /* inherit flag */
|
||||
OUT int handle; /* handle to the event */
|
||||
|
@ -415,6 +461,7 @@ struct open_event_request
|
|||
/* Create a mutex */
|
||||
struct create_mutex_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int owned; /* initially owned? */
|
||||
IN int inherit; /* inherit flag */
|
||||
OUT int handle; /* handle to the mutex */
|
||||
|
@ -425,6 +472,7 @@ struct create_mutex_request
|
|||
/* Release a mutex */
|
||||
struct release_mutex_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the mutex */
|
||||
};
|
||||
|
||||
|
@ -432,6 +480,7 @@ struct release_mutex_request
|
|||
/* Open a mutex */
|
||||
struct open_mutex_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN unsigned int access; /* wanted access rights */
|
||||
IN int inherit; /* inherit flag */
|
||||
OUT int handle; /* handle to the mutex */
|
||||
|
@ -442,6 +491,7 @@ struct open_mutex_request
|
|||
/* Create a semaphore */
|
||||
struct create_semaphore_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN unsigned int initial; /* initial count */
|
||||
IN unsigned int max; /* maximum count */
|
||||
IN int inherit; /* inherit flag */
|
||||
|
@ -453,6 +503,7 @@ struct create_semaphore_request
|
|||
/* Release a semaphore */
|
||||
struct release_semaphore_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the semaphore */
|
||||
IN unsigned int count; /* count to add to semaphore */
|
||||
OUT unsigned int prev_count; /* previous semaphore count */
|
||||
|
@ -462,6 +513,7 @@ struct release_semaphore_request
|
|||
/* Open a semaphore */
|
||||
struct open_semaphore_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN unsigned int access; /* wanted access rights */
|
||||
IN int inherit; /* inherit flag */
|
||||
OUT int handle; /* handle to the semaphore */
|
||||
|
@ -472,6 +524,7 @@ struct open_semaphore_request
|
|||
/* Create a file */
|
||||
struct create_file_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN unsigned int access; /* wanted access rights */
|
||||
IN int inherit; /* inherit flag */
|
||||
IN unsigned int sharing; /* sharing flags */
|
||||
|
@ -485,6 +538,7 @@ struct create_file_request
|
|||
/* Allocate a file handle for a Unix fd */
|
||||
struct alloc_file_handle_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN unsigned int access; /* wanted access rights */
|
||||
OUT int handle; /* handle to the file */
|
||||
};
|
||||
|
@ -493,6 +547,7 @@ struct alloc_file_handle_request
|
|||
/* Get a Unix fd to read from a file */
|
||||
struct get_read_fd_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the file */
|
||||
};
|
||||
|
||||
|
@ -500,6 +555,7 @@ struct get_read_fd_request
|
|||
/* Get a Unix fd to write to a file */
|
||||
struct get_write_fd_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the file */
|
||||
};
|
||||
|
||||
|
@ -507,6 +563,7 @@ struct get_write_fd_request
|
|||
/* Set a file current position */
|
||||
struct set_file_pointer_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the file */
|
||||
IN int low; /* position low word */
|
||||
IN int high; /* position high word */
|
||||
|
@ -519,6 +576,7 @@ struct set_file_pointer_request
|
|||
/* Truncate (or extend) a file */
|
||||
struct truncate_file_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the file */
|
||||
};
|
||||
|
||||
|
@ -526,6 +584,7 @@ struct truncate_file_request
|
|||
/* Set a file access and modification times */
|
||||
struct set_file_time_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the file */
|
||||
IN time_t access_time; /* last access time */
|
||||
IN time_t write_time; /* last write time */
|
||||
|
@ -535,6 +594,7 @@ struct set_file_time_request
|
|||
/* Flush a file buffers */
|
||||
struct flush_file_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the file */
|
||||
};
|
||||
|
||||
|
@ -542,6 +602,7 @@ struct flush_file_request
|
|||
/* Get information about a file */
|
||||
struct get_file_info_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the file */
|
||||
OUT int type; /* file type */
|
||||
OUT int attr; /* file attributes */
|
||||
|
@ -559,6 +620,7 @@ struct get_file_info_request
|
|||
/* Lock a region of a file */
|
||||
struct lock_file_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the file */
|
||||
IN unsigned int offset_low; /* offset of start of lock */
|
||||
IN unsigned int offset_high; /* offset of start of lock */
|
||||
|
@ -570,6 +632,7 @@ struct lock_file_request
|
|||
/* Unlock a region of a file */
|
||||
struct unlock_file_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the file */
|
||||
IN unsigned int offset_low; /* offset of start of unlock */
|
||||
IN unsigned int offset_high; /* offset of start of unlock */
|
||||
|
@ -581,6 +644,7 @@ struct unlock_file_request
|
|||
/* Create an anonymous pipe */
|
||||
struct create_pipe_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int inherit; /* inherit flag */
|
||||
OUT int handle_read; /* handle to the read-side of the pipe */
|
||||
OUT int handle_write; /* handle to the write-side of the pipe */
|
||||
|
@ -590,6 +654,7 @@ struct create_pipe_request
|
|||
/* Create a socket */
|
||||
struct create_socket_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN unsigned int access; /* wanted access rights */
|
||||
IN int inherit; /* inherit flag */
|
||||
IN int family; /* family, see socket manpage */
|
||||
|
@ -602,6 +667,7 @@ struct create_socket_request
|
|||
/* Accept a socket */
|
||||
struct accept_socket_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int lhandle; /* handle to the listening socket */
|
||||
IN unsigned int access; /* wanted access rights */
|
||||
IN int inherit; /* inherit flag */
|
||||
|
@ -612,6 +678,7 @@ struct accept_socket_request
|
|||
/* Set socket event parameters */
|
||||
struct set_socket_event_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the socket */
|
||||
IN unsigned int mask; /* event mask */
|
||||
IN int event; /* event object */
|
||||
|
@ -621,6 +688,7 @@ struct set_socket_event_request
|
|||
/* Get socket event parameters */
|
||||
struct get_socket_event_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the socket */
|
||||
IN int service; /* clear pending? */
|
||||
IN int s_event; /* "expected" event object */
|
||||
|
@ -635,6 +703,7 @@ struct get_socket_event_request
|
|||
/* Reenable pending socket events */
|
||||
struct enable_socket_event_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the socket */
|
||||
IN unsigned int mask; /* events to re-enable */
|
||||
IN unsigned int sstate; /* status bits to set */
|
||||
|
@ -645,6 +714,7 @@ struct enable_socket_event_request
|
|||
/* Allocate a console for the current process */
|
||||
struct alloc_console_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN unsigned int access; /* wanted access rights */
|
||||
IN int inherit; /* inherit flag */
|
||||
OUT int handle_in; /* handle to console input */
|
||||
|
@ -655,13 +725,14 @@ struct alloc_console_request
|
|||
/* Free the console of the current process */
|
||||
struct free_console_request
|
||||
{
|
||||
IN int dummy;
|
||||
REQUEST_HEADER; /* request header */
|
||||
};
|
||||
|
||||
|
||||
/* Open a handle to the process console */
|
||||
struct open_console_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int output; /* input or output? */
|
||||
IN unsigned int access; /* wanted access rights */
|
||||
IN int inherit; /* inherit flag */
|
||||
|
@ -672,6 +743,7 @@ struct open_console_request
|
|||
/* Set a console file descriptor */
|
||||
struct set_console_fd_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the console */
|
||||
IN int file_handle; /* handle of file to use as file descriptor */
|
||||
IN int pid; /* pid of xterm (hack) */
|
||||
|
@ -681,6 +753,7 @@ struct set_console_fd_request
|
|||
/* Get a console mode (input or output) */
|
||||
struct get_console_mode_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the console */
|
||||
OUT int mode; /* console mode */
|
||||
};
|
||||
|
@ -689,6 +762,7 @@ struct get_console_mode_request
|
|||
/* Set a console mode (input or output) */
|
||||
struct set_console_mode_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the console */
|
||||
IN int mode; /* console mode */
|
||||
};
|
||||
|
@ -697,6 +771,7 @@ struct set_console_mode_request
|
|||
/* Set info about a console (output only) */
|
||||
struct set_console_info_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the console */
|
||||
IN int mask; /* setting mask (see below) */
|
||||
IN int cursor_size; /* size of cursor (percentage filled) */
|
||||
|
@ -709,6 +784,7 @@ struct set_console_info_request
|
|||
/* Get info about a console (output only) */
|
||||
struct get_console_info_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the console */
|
||||
OUT int cursor_size; /* size of cursor (percentage filled) */
|
||||
OUT int cursor_visible;/* cursor visibility flag */
|
||||
|
@ -720,6 +796,7 @@ struct get_console_info_request
|
|||
/* Add input records to a console input queue */
|
||||
struct write_console_input_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the console input */
|
||||
IN int count; /* number of input records */
|
||||
OUT int written; /* number of records written */
|
||||
|
@ -729,6 +806,7 @@ struct write_console_input_request
|
|||
/* Fetch input records from a console input queue */
|
||||
struct read_console_input_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the console input */
|
||||
IN int count; /* max number of records to retrieve */
|
||||
IN int flush; /* flush the retrieved records from the queue? */
|
||||
|
@ -740,6 +818,7 @@ struct read_console_input_request
|
|||
/* Create a change notification */
|
||||
struct create_change_notification_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int subtree; /* watch all the subtree */
|
||||
IN int filter; /* notification filter */
|
||||
OUT int handle; /* handle to the change notification */
|
||||
|
@ -749,6 +828,7 @@ struct create_change_notification_request
|
|||
/* Create a file mapping */
|
||||
struct create_mapping_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int size_high; /* mapping size */
|
||||
IN int size_low; /* mapping size */
|
||||
IN int protect; /* protection flags (see below) */
|
||||
|
@ -771,6 +851,7 @@ struct create_mapping_request
|
|||
/* Open a mapping */
|
||||
struct open_mapping_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN unsigned int access; /* wanted access rights */
|
||||
IN int inherit; /* inherit flag */
|
||||
OUT int handle; /* handle to the mapping */
|
||||
|
@ -781,6 +862,7 @@ struct open_mapping_request
|
|||
/* Get information about a file mapping */
|
||||
struct get_mapping_info_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the mapping */
|
||||
OUT int size_high; /* mapping size */
|
||||
OUT int size_low; /* mapping size */
|
||||
|
@ -795,6 +877,7 @@ struct get_mapping_info_request
|
|||
/* Create a device */
|
||||
struct create_device_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN unsigned int access; /* wanted access rights */
|
||||
IN int inherit; /* inherit flag */
|
||||
IN int id; /* client private id */
|
||||
|
@ -805,6 +888,7 @@ struct create_device_request
|
|||
/* Create a snapshot */
|
||||
struct create_snapshot_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int inherit; /* inherit flag */
|
||||
IN int flags; /* snapshot flags (TH32CS_*) */
|
||||
IN void* pid; /* process id */
|
||||
|
@ -815,6 +899,7 @@ struct create_snapshot_request
|
|||
/* Get the next process from a snapshot */
|
||||
struct next_process_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the snapshot */
|
||||
IN int reset; /* reset snapshot position? */
|
||||
OUT int count; /* process usage count */
|
||||
|
@ -827,6 +912,7 @@ struct next_process_request
|
|||
/* Get the next thread from a snapshot */
|
||||
struct next_thread_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the snapshot */
|
||||
IN int reset; /* reset snapshot position? */
|
||||
OUT int count; /* thread usage count */
|
||||
|
@ -840,6 +926,7 @@ struct next_thread_request
|
|||
/* Get the next module from a snapshot */
|
||||
struct next_module_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the snapshot */
|
||||
IN int reset; /* reset snapshot position? */
|
||||
OUT void* pid; /* process id */
|
||||
|
@ -850,6 +937,7 @@ struct next_module_request
|
|||
/* Wait for a debug event */
|
||||
struct wait_debug_event_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int timeout; /* timeout in ms */
|
||||
OUT void* pid; /* process id */
|
||||
OUT void* tid; /* thread id */
|
||||
|
@ -860,6 +948,7 @@ struct wait_debug_event_request
|
|||
/* Send an exception event */
|
||||
struct exception_event_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN EXCEPTION_RECORD record; /* exception record */
|
||||
IN int first; /* first chance exception? */
|
||||
IN CONTEXT context; /* thread context */
|
||||
|
@ -870,6 +959,7 @@ struct exception_event_request
|
|||
/* Send an output string to the debugger */
|
||||
struct output_debug_string_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN void* string; /* string to display (in debugged process address space) */
|
||||
IN int unicode; /* is it Unicode? */
|
||||
IN int length; /* string length */
|
||||
|
@ -879,6 +969,7 @@ struct output_debug_string_request
|
|||
/* Continue a debug event */
|
||||
struct continue_debug_event_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN void* pid; /* process id to continue */
|
||||
IN void* tid; /* thread id to continue */
|
||||
IN int status; /* continuation status */
|
||||
|
@ -888,6 +979,7 @@ struct continue_debug_event_request
|
|||
/* Start debugging an existing process */
|
||||
struct debug_process_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN void* pid; /* id of the process to debug */
|
||||
};
|
||||
|
||||
|
@ -895,6 +987,7 @@ struct debug_process_request
|
|||
/* Read data from a process address space */
|
||||
struct read_process_memory_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* process handle */
|
||||
IN void* addr; /* addr to read from (must be int-aligned) */
|
||||
IN int len; /* number of ints to read */
|
||||
|
@ -905,6 +998,7 @@ struct read_process_memory_request
|
|||
/* Write data to a process address space */
|
||||
struct write_process_memory_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* process handle */
|
||||
IN void* addr; /* addr to write to (must be int-aligned) */
|
||||
IN int len; /* number of ints to write */
|
||||
|
@ -917,6 +1011,7 @@ struct write_process_memory_request
|
|||
/* Create a registry key */
|
||||
struct create_key_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int parent; /* handle to the parent key */
|
||||
IN unsigned int access; /* desired access rights */
|
||||
IN unsigned int options; /* creation options */
|
||||
|
@ -931,6 +1026,7 @@ struct create_key_request
|
|||
/* Open a registry key */
|
||||
struct open_key_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int parent; /* handle to the parent key */
|
||||
IN unsigned int access; /* desired access rights */
|
||||
OUT int hkey; /* handle to the open key */
|
||||
|
@ -941,6 +1037,7 @@ struct open_key_request
|
|||
/* Delete a registry key */
|
||||
struct delete_key_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int hkey; /* handle to the parent key */
|
||||
IN path_t name; /* key name */
|
||||
};
|
||||
|
@ -949,6 +1046,7 @@ struct delete_key_request
|
|||
/* Close a registry key */
|
||||
struct close_key_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int hkey; /* key to close */
|
||||
};
|
||||
|
||||
|
@ -956,6 +1054,7 @@ struct close_key_request
|
|||
/* Enumerate registry subkeys */
|
||||
struct enum_key_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int hkey; /* handle to registry key */
|
||||
IN int index; /* index of subkey */
|
||||
OUT time_t modif; /* last modification time */
|
||||
|
@ -967,6 +1066,7 @@ struct enum_key_request
|
|||
/* Query information about a registry key */
|
||||
struct query_key_info_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int hkey; /* handle to registry key */
|
||||
OUT int subkeys; /* number of subkeys */
|
||||
OUT int max_subkey; /* longest subkey name */
|
||||
|
@ -983,6 +1083,7 @@ struct query_key_info_request
|
|||
/* Set a value of a registry key */
|
||||
struct set_key_value_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int hkey; /* handle to registry key */
|
||||
IN int type; /* value type */
|
||||
IN unsigned int total; /* total value len */
|
||||
|
@ -996,6 +1097,7 @@ struct set_key_value_request
|
|||
/* Retrieve the value of a registry key */
|
||||
struct get_key_value_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int hkey; /* handle to registry key */
|
||||
IN unsigned int offset; /* offset for getting data */
|
||||
OUT int type; /* value type */
|
||||
|
@ -1008,6 +1110,7 @@ struct get_key_value_request
|
|||
/* Enumerate a value of a registry key */
|
||||
struct enum_key_value_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int hkey; /* handle to registry key */
|
||||
IN int index; /* value index */
|
||||
IN unsigned int offset; /* offset for getting data */
|
||||
|
@ -1021,6 +1124,7 @@ struct enum_key_value_request
|
|||
/* Delete a value of a registry key */
|
||||
struct delete_key_value_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int hkey; /* handle to registry key */
|
||||
IN path_t name; /* value name */
|
||||
};
|
||||
|
@ -1029,6 +1133,7 @@ struct delete_key_value_request
|
|||
/* Load a registry branch from a file */
|
||||
struct load_registry_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int hkey; /* root key to load to */
|
||||
IN int file; /* file to load from */
|
||||
IN path_t name; /* subkey name */
|
||||
|
@ -1038,6 +1143,7 @@ struct load_registry_request
|
|||
/* Save a registry branch to a file */
|
||||
struct save_registry_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int hkey; /* key to save */
|
||||
IN int file; /* file to save to */
|
||||
};
|
||||
|
@ -1046,6 +1152,7 @@ struct save_registry_request
|
|||
/* Save a registry branch at server exit */
|
||||
struct save_registry_atexit_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int hkey; /* key to save */
|
||||
IN char file[1]; /* file to save to */
|
||||
};
|
||||
|
@ -1054,6 +1161,7 @@ struct save_registry_atexit_request
|
|||
/* Set the current and saving level for the registry */
|
||||
struct set_registry_levels_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int current; /* new current level */
|
||||
IN int saving; /* new saving level */
|
||||
IN int period; /* duration between periodic saves (milliseconds) */
|
||||
|
@ -1063,6 +1171,7 @@ struct set_registry_levels_request
|
|||
/* Create a waitable timer */
|
||||
struct create_timer_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int inherit; /* inherit flag */
|
||||
IN int manual; /* manual reset */
|
||||
OUT int handle; /* handle to the timer */
|
||||
|
@ -1073,6 +1182,7 @@ struct create_timer_request
|
|||
/* Open a waitable timer */
|
||||
struct open_timer_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN unsigned int access; /* wanted access rights */
|
||||
IN int inherit; /* inherit flag */
|
||||
OUT int handle; /* handle to the timer */
|
||||
|
@ -1082,6 +1192,7 @@ struct open_timer_request
|
|||
/* Set a waitable timer */
|
||||
struct set_timer_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the timer */
|
||||
IN int sec; /* next expiration absolute time */
|
||||
IN int usec; /* next expiration absolute time */
|
||||
|
@ -1093,6 +1204,7 @@ struct set_timer_request
|
|||
/* Cancel a waitable timer */
|
||||
struct cancel_timer_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the timer */
|
||||
};
|
||||
|
||||
|
@ -1100,6 +1212,7 @@ struct cancel_timer_request
|
|||
/* Retrieve the current context of a thread */
|
||||
struct get_thread_context_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* thread handle */
|
||||
IN unsigned int flags; /* context flags */
|
||||
OUT CONTEXT context; /* thread context */
|
||||
|
@ -1109,6 +1222,7 @@ struct get_thread_context_request
|
|||
/* Set the current context of a thread */
|
||||
struct set_thread_context_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* thread handle */
|
||||
IN unsigned int flags; /* context flags */
|
||||
IN CONTEXT context; /* thread context */
|
||||
|
@ -1118,6 +1232,7 @@ struct set_thread_context_request
|
|||
/* Fetch a selector entry for a thread */
|
||||
struct get_selector_entry_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* thread handle */
|
||||
IN int entry; /* LDT entry */
|
||||
OUT unsigned int base; /* selector base */
|
||||
|
@ -1129,6 +1244,7 @@ struct get_selector_entry_request
|
|||
/* Add an atom */
|
||||
struct add_atom_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int local; /* is atom in local process table? */
|
||||
OUT int atom; /* resulting atom */
|
||||
IN WCHAR name[1]; /* atom name */
|
||||
|
@ -1138,6 +1254,7 @@ struct add_atom_request
|
|||
/* Delete an atom */
|
||||
struct delete_atom_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int atom; /* atom handle */
|
||||
IN int local; /* is atom in local process table? */
|
||||
};
|
||||
|
@ -1146,6 +1263,7 @@ struct delete_atom_request
|
|||
/* Find an atom */
|
||||
struct find_atom_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int local; /* is atom in local process table? */
|
||||
OUT int atom; /* atom handle */
|
||||
IN WCHAR name[1]; /* atom name */
|
||||
|
@ -1155,6 +1273,7 @@ struct find_atom_request
|
|||
/* Get an atom name */
|
||||
struct get_atom_name_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int atom; /* atom handle */
|
||||
IN int local; /* is atom in local process table? */
|
||||
OUT int count; /* atom lock count */
|
||||
|
@ -1165,6 +1284,7 @@ struct get_atom_name_request
|
|||
/* Init the process atom table */
|
||||
struct init_atom_table_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int entries; /* number of entries */
|
||||
};
|
||||
|
||||
|
@ -1172,12 +1292,14 @@ struct init_atom_table_request
|
|||
/* Get the message queue of the current thread */
|
||||
struct get_msg_queue_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
OUT int handle; /* handle to the queue */
|
||||
};
|
||||
|
||||
/* Wake up a message queue */
|
||||
struct wake_queue_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* handle to the queue */
|
||||
IN unsigned int bits; /* wake bits */
|
||||
};
|
||||
|
@ -1185,6 +1307,7 @@ struct wake_queue_request
|
|||
/* Wait for a process to start waiting on input */
|
||||
struct wait_input_idle_request
|
||||
{
|
||||
REQUEST_HEADER; /* request header */
|
||||
IN int handle; /* process handle */
|
||||
IN int timeout; /* timeout */
|
||||
OUT int event; /* handle to idle event */
|
||||
|
@ -1306,11 +1429,133 @@ enum request
|
|||
REQ_NB_REQUESTS
|
||||
};
|
||||
|
||||
#define SERVER_PROTOCOL_VERSION 17
|
||||
union generic_request
|
||||
{
|
||||
struct request_max_size max_size;
|
||||
struct request_header header;
|
||||
struct new_process_request new_process;
|
||||
struct wait_process_request wait_process;
|
||||
struct new_thread_request new_thread;
|
||||
struct boot_done_request boot_done;
|
||||
struct init_process_request init_process;
|
||||
struct init_process_done_request init_process_done;
|
||||
struct init_thread_request init_thread;
|
||||
struct get_thread_buffer_request get_thread_buffer;
|
||||
struct terminate_process_request terminate_process;
|
||||
struct terminate_thread_request terminate_thread;
|
||||
struct get_process_info_request get_process_info;
|
||||
struct set_process_info_request set_process_info;
|
||||
struct get_thread_info_request get_thread_info;
|
||||
struct set_thread_info_request set_thread_info;
|
||||
struct suspend_thread_request suspend_thread;
|
||||
struct resume_thread_request resume_thread;
|
||||
struct load_dll_request load_dll;
|
||||
struct unload_dll_request unload_dll;
|
||||
struct queue_apc_request queue_apc;
|
||||
struct get_apc_request get_apc;
|
||||
struct close_handle_request close_handle;
|
||||
struct get_handle_info_request get_handle_info;
|
||||
struct set_handle_info_request set_handle_info;
|
||||
struct dup_handle_request dup_handle;
|
||||
struct open_process_request open_process;
|
||||
struct select_request select;
|
||||
struct create_event_request create_event;
|
||||
struct event_op_request event_op;
|
||||
struct open_event_request open_event;
|
||||
struct create_mutex_request create_mutex;
|
||||
struct release_mutex_request release_mutex;
|
||||
struct open_mutex_request open_mutex;
|
||||
struct create_semaphore_request create_semaphore;
|
||||
struct release_semaphore_request release_semaphore;
|
||||
struct open_semaphore_request open_semaphore;
|
||||
struct create_file_request create_file;
|
||||
struct alloc_file_handle_request alloc_file_handle;
|
||||
struct get_read_fd_request get_read_fd;
|
||||
struct get_write_fd_request get_write_fd;
|
||||
struct set_file_pointer_request set_file_pointer;
|
||||
struct truncate_file_request truncate_file;
|
||||
struct set_file_time_request set_file_time;
|
||||
struct flush_file_request flush_file;
|
||||
struct get_file_info_request get_file_info;
|
||||
struct lock_file_request lock_file;
|
||||
struct unlock_file_request unlock_file;
|
||||
struct create_pipe_request create_pipe;
|
||||
struct create_socket_request create_socket;
|
||||
struct accept_socket_request accept_socket;
|
||||
struct set_socket_event_request set_socket_event;
|
||||
struct get_socket_event_request get_socket_event;
|
||||
struct enable_socket_event_request enable_socket_event;
|
||||
struct alloc_console_request alloc_console;
|
||||
struct free_console_request free_console;
|
||||
struct open_console_request open_console;
|
||||
struct set_console_fd_request set_console_fd;
|
||||
struct get_console_mode_request get_console_mode;
|
||||
struct set_console_mode_request set_console_mode;
|
||||
struct set_console_info_request set_console_info;
|
||||
struct get_console_info_request get_console_info;
|
||||
struct write_console_input_request write_console_input;
|
||||
struct read_console_input_request read_console_input;
|
||||
struct create_change_notification_request create_change_notification;
|
||||
struct create_mapping_request create_mapping;
|
||||
struct open_mapping_request open_mapping;
|
||||
struct get_mapping_info_request get_mapping_info;
|
||||
struct create_device_request create_device;
|
||||
struct create_snapshot_request create_snapshot;
|
||||
struct next_process_request next_process;
|
||||
struct next_thread_request next_thread;
|
||||
struct next_module_request next_module;
|
||||
struct wait_debug_event_request wait_debug_event;
|
||||
struct exception_event_request exception_event;
|
||||
struct output_debug_string_request output_debug_string;
|
||||
struct continue_debug_event_request continue_debug_event;
|
||||
struct debug_process_request debug_process;
|
||||
struct read_process_memory_request read_process_memory;
|
||||
struct write_process_memory_request write_process_memory;
|
||||
struct create_key_request create_key;
|
||||
struct open_key_request open_key;
|
||||
struct delete_key_request delete_key;
|
||||
struct close_key_request close_key;
|
||||
struct enum_key_request enum_key;
|
||||
struct query_key_info_request query_key_info;
|
||||
struct set_key_value_request set_key_value;
|
||||
struct get_key_value_request get_key_value;
|
||||
struct enum_key_value_request enum_key_value;
|
||||
struct delete_key_value_request delete_key_value;
|
||||
struct load_registry_request load_registry;
|
||||
struct save_registry_request save_registry;
|
||||
struct save_registry_atexit_request save_registry_atexit;
|
||||
struct set_registry_levels_request set_registry_levels;
|
||||
struct create_timer_request create_timer;
|
||||
struct open_timer_request open_timer;
|
||||
struct set_timer_request set_timer;
|
||||
struct cancel_timer_request cancel_timer;
|
||||
struct get_thread_context_request get_thread_context;
|
||||
struct set_thread_context_request set_thread_context;
|
||||
struct get_selector_entry_request get_selector_entry;
|
||||
struct add_atom_request add_atom;
|
||||
struct delete_atom_request delete_atom;
|
||||
struct find_atom_request find_atom;
|
||||
struct get_atom_name_request get_atom_name;
|
||||
struct init_atom_table_request init_atom_table;
|
||||
struct get_msg_queue_request get_msg_queue;
|
||||
struct wake_queue_request wake_queue;
|
||||
struct wait_input_idle_request wait_input_idle;
|
||||
};
|
||||
|
||||
#define SERVER_PROTOCOL_VERSION 18
|
||||
|
||||
/* ### make_requests end ### */
|
||||
/* Everything above this line is generated automatically by tools/make_requests */
|
||||
|
||||
#undef REQUEST_HEADER
|
||||
#undef VARARG
|
||||
|
||||
/* format of the server buffer */
|
||||
struct server_buffer_info
|
||||
{
|
||||
volatile unsigned int cur_req; /* offset of the current request */
|
||||
volatile unsigned int cur_pos; /* first available position in buffer */
|
||||
};
|
||||
|
||||
/* client-side functions */
|
||||
|
||||
|
@ -1318,12 +1563,14 @@ enum request
|
|||
|
||||
#include "thread.h"
|
||||
#include "ntddk.h"
|
||||
#include "wine/exception.h"
|
||||
|
||||
/* client communication functions */
|
||||
|
||||
extern unsigned int server_call_noerr( enum request req );
|
||||
extern unsigned int server_call_fd( enum request req, int fd_out, int *fd_in );
|
||||
extern void server_protocol_error( const char *err, ... ) WINE_NORETURN;
|
||||
extern void *server_alloc_req( size_t fixed_size, size_t var_size );
|
||||
extern const char *get_config_dir(void);
|
||||
|
||||
/* get a pointer to the request buffer */
|
||||
|
@ -1335,7 +1582,7 @@ static inline void WINE_UNUSED *get_req_buffer(void)
|
|||
/* maximum remaining size in the server buffer */
|
||||
static inline int WINE_UNUSED server_remaining( const void *ptr )
|
||||
{
|
||||
return (char *)NtCurrentTeb()->buffer + NtCurrentTeb()->buffer_size - (char *)ptr;
|
||||
return (char *)NtCurrentTeb()->buffer_info - (char *)ptr;
|
||||
}
|
||||
|
||||
/* do a server call and set the last error code */
|
||||
|
@ -1351,7 +1598,7 @@ static inline void server_strcpyW( WCHAR *dst, const WCHAR *src )
|
|||
{
|
||||
if (src)
|
||||
{
|
||||
WCHAR *end = (WCHAR *)((char *)NtCurrentTeb()->buffer + NtCurrentTeb()->buffer_size) - 1;
|
||||
WCHAR *end = (WCHAR *)NtCurrentTeb()->buffer_info - 1;
|
||||
while ((dst < end) && *src) *dst++ = *src++;
|
||||
}
|
||||
*dst = 0;
|
||||
|
@ -1362,12 +1609,44 @@ static inline void server_strcpyAtoW( WCHAR *dst, const char *src )
|
|||
{
|
||||
if (src)
|
||||
{
|
||||
WCHAR *end = (WCHAR *)((char *)NtCurrentTeb()->buffer + NtCurrentTeb()->buffer_size) - 1;
|
||||
WCHAR *end = (WCHAR *)NtCurrentTeb()->buffer_info - 1;
|
||||
while ((dst < end) && *src) *dst++ = (WCHAR)(unsigned char)*src++;
|
||||
}
|
||||
*dst = 0;
|
||||
}
|
||||
|
||||
/* get a pointer to the variable part of the request */
|
||||
inline static void *server_data_ptr( void *req )
|
||||
{
|
||||
return (union generic_request *)req + 1;
|
||||
}
|
||||
|
||||
|
||||
/* exception support for server calls */
|
||||
|
||||
extern DWORD server_exception_handler( PEXCEPTION_RECORD record, EXCEPTION_FRAME *frame,
|
||||
CONTEXT *context, EXCEPTION_FRAME **pdispatcher );
|
||||
|
||||
struct __server_exception_frame
|
||||
{
|
||||
EXCEPTION_FRAME frame;
|
||||
struct server_buffer_info info; /* saved buffer information */
|
||||
};
|
||||
|
||||
#define SERVER_START_REQ \
|
||||
do { \
|
||||
struct __server_exception_frame __f; \
|
||||
__f.frame.Handler = server_exception_handler; \
|
||||
__f.info = *NtCurrentTeb()->buffer_info; \
|
||||
__wine_push_frame( &__f.frame ); \
|
||||
do {
|
||||
|
||||
#define SERVER_END_REQ \
|
||||
} while(0); \
|
||||
*NtCurrentTeb()->buffer_info = __f.info; \
|
||||
__wine_pop_frame( &__f.frame ); \
|
||||
} while(0);
|
||||
|
||||
extern int CLIENT_InitServer(void);
|
||||
extern int CLIENT_BootDone( int debug_level );
|
||||
extern int CLIENT_IsBootThread(void);
|
||||
|
|
|
@ -15,6 +15,7 @@ struct _PDB;
|
|||
struct __EXCEPTION_FRAME;
|
||||
struct _SECURITY_ATTRIBUTES;
|
||||
struct tagSYSLEVEL;
|
||||
struct server_buffer_info;
|
||||
|
||||
/* Thread exception block
|
||||
|
||||
|
@ -89,17 +90,16 @@ typedef struct _TEB
|
|||
DWORD unknown6[5]; /* --n 1e8 Unknown */
|
||||
|
||||
/* The following are Wine-specific fields (NT: GDI stuff) */
|
||||
struct _TEB *next; /* --3 1fc Global thread list */
|
||||
DWORD cleanup; /* --3 200 Cleanup service handle */
|
||||
int socket; /* --3 204 Socket for server communication */
|
||||
void *buffer; /* --3 208 Buffer shared with server */
|
||||
int buffer_size; /* --3 20c Size of server buffer */
|
||||
void *debug_info; /* --3 210 Info for debugstr functions */
|
||||
void *pthread_data; /* --3 214 Data for pthread emulation */
|
||||
DWORD cleanup; /* --3 1fc Cleanup service handle */
|
||||
int socket; /* --3 200 Socket for server communication */
|
||||
void *buffer; /* --3 204 Buffer shared with server */
|
||||
struct server_buffer_info *buffer_info; /* --3 208 Buffer information */
|
||||
void *debug_info; /* --3 20c Info for debugstr functions */
|
||||
void *pthread_data; /* --3 210 Data for pthread emulation */
|
||||
/* here is plenty space for wine specific fields (don't forget to change pad6!!) */
|
||||
|
||||
/* the following are nt specific fields */
|
||||
DWORD pad6[632]; /* --n 218 */
|
||||
DWORD pad6[633]; /* --n 214 */
|
||||
UNICODE_STRING StaticUnicodeString; /* -2- bf8 used by advapi32 */
|
||||
USHORT StaticUnicodeBuffer[261]; /* -2- c00 used by advapi32 */
|
||||
DWORD pad7; /* --n e0c */
|
||||
|
|
|
@ -110,22 +110,55 @@ static void server_perror( const char *err )
|
|||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
* server_exception_handler
|
||||
*/
|
||||
DWORD server_exception_handler( PEXCEPTION_RECORD record, EXCEPTION_FRAME *frame,
|
||||
CONTEXT *context, EXCEPTION_FRAME **pdispatcher )
|
||||
{
|
||||
struct __server_exception_frame *server_frame = (struct __server_exception_frame *)frame;
|
||||
if ((record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND)))
|
||||
*NtCurrentTeb()->buffer_info = server_frame->info;
|
||||
return ExceptionContinueSearch;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
* server_alloc_req
|
||||
*/
|
||||
void *server_alloc_req( size_t fixed_size, size_t var_size )
|
||||
{
|
||||
unsigned int pos = NtCurrentTeb()->buffer_info->cur_pos;
|
||||
union generic_request *req = (union generic_request *)((char *)NtCurrentTeb()->buffer + pos);
|
||||
size_t size = sizeof(*req) + var_size;
|
||||
|
||||
assert( fixed_size <= sizeof(*req) );
|
||||
|
||||
if ((char *)req + size > (char *)NtCurrentTeb()->buffer_info)
|
||||
server_protocol_error( "buffer overflow %d bytes\n",
|
||||
(char *)req + size - (char *)NtCurrentTeb()->buffer_info );
|
||||
NtCurrentTeb()->buffer_info->cur_pos = pos + size;
|
||||
req->header.fixed_size = fixed_size;
|
||||
req->header.var_size = var_size;
|
||||
return req;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
* send_request
|
||||
*
|
||||
* Send a request to the server.
|
||||
*/
|
||||
static void send_request( enum request req )
|
||||
static void send_request( enum request req, struct request_header *header )
|
||||
{
|
||||
int ret;
|
||||
if ((ret = write( NtCurrentTeb()->socket, &req, sizeof(req) )) == sizeof(req))
|
||||
return;
|
||||
if (ret == -1)
|
||||
header->req = req;
|
||||
NtCurrentTeb()->buffer_info->cur_req = (char *)header - (char *)NtCurrentTeb()->buffer;
|
||||
/* write a single byte; the value is ignored anyway */
|
||||
if (write( NtCurrentTeb()->socket, header, 1 ) == -1)
|
||||
{
|
||||
if (errno == EPIPE) SYSDEPS_ExitThread(0);
|
||||
server_perror( "sendmsg" );
|
||||
}
|
||||
server_protocol_error( "partial msg sent %d/%d\n", ret, sizeof(req) );
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
|
@ -133,17 +166,17 @@ static void send_request( enum request req )
|
|||
*
|
||||
* Send a request to the server, passing a file descriptor.
|
||||
*/
|
||||
static void send_request_fd( enum request req, int fd )
|
||||
static void send_request_fd( enum request req, struct request_header *header, int fd )
|
||||
{
|
||||
int ret;
|
||||
#ifndef HAVE_MSGHDR_ACCRIGHTS
|
||||
struct cmsg_fd cmsg;
|
||||
#endif
|
||||
struct msghdr msghdr;
|
||||
struct iovec vec;
|
||||
|
||||
vec.iov_base = (void *)&req;
|
||||
vec.iov_len = sizeof(req);
|
||||
/* write a single byte; the value is ignored anyway */
|
||||
vec.iov_base = (void *)header;
|
||||
vec.iov_len = 1;
|
||||
|
||||
msghdr.msg_name = NULL;
|
||||
msghdr.msg_namelen = 0;
|
||||
|
@ -163,13 +196,13 @@ static void send_request_fd( enum request req, int fd )
|
|||
msghdr.msg_flags = 0;
|
||||
#endif /* HAVE_MSGHDR_ACCRIGHTS */
|
||||
|
||||
if ((ret = sendmsg( NtCurrentTeb()->socket, &msghdr, 0 )) == sizeof(req)) return;
|
||||
if (ret == -1)
|
||||
header->req = req;
|
||||
|
||||
if (sendmsg( NtCurrentTeb()->socket, &msghdr, 0 ) == -1)
|
||||
{
|
||||
if (errno == EPIPE) SYSDEPS_ExitThread(0);
|
||||
server_perror( "sendmsg" );
|
||||
}
|
||||
server_protocol_error( "partial msg sent %d/%d\n", ret, sizeof(req) );
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
|
@ -177,23 +210,18 @@ static void send_request_fd( enum request req, int fd )
|
|||
*
|
||||
* Wait for a reply from the server.
|
||||
*/
|
||||
static unsigned int wait_reply(void)
|
||||
static void wait_reply(void)
|
||||
{
|
||||
int ret;
|
||||
unsigned int res;
|
||||
char dummy[1];
|
||||
|
||||
for (;;)
|
||||
{
|
||||
if ((ret = read( NtCurrentTeb()->socket, &res, sizeof(res) )) == sizeof(res))
|
||||
return res;
|
||||
if ((ret = read( NtCurrentTeb()->socket, dummy, 1 )) > 0) return;
|
||||
if (!ret) break;
|
||||
if (ret == -1)
|
||||
{
|
||||
if (errno == EINTR) continue;
|
||||
if (errno == EPIPE) break;
|
||||
server_perror("read");
|
||||
}
|
||||
server_protocol_error( "partial msg received %d/%d\n", ret, sizeof(res) );
|
||||
if (errno == EINTR) continue;
|
||||
if (errno == EPIPE) break;
|
||||
server_perror("read");
|
||||
}
|
||||
/* the server closed the connection; time to die... */
|
||||
SYSDEPS_ExitThread(0);
|
||||
|
@ -205,11 +233,11 @@ static unsigned int wait_reply(void)
|
|||
*
|
||||
* Wait for a reply from the server, when a file descriptor is passed.
|
||||
*/
|
||||
static unsigned int wait_reply_fd( int *fd )
|
||||
static void wait_reply_fd( int *fd )
|
||||
{
|
||||
struct iovec vec;
|
||||
int ret;
|
||||
unsigned int res;
|
||||
char dummy[1];
|
||||
|
||||
#ifdef HAVE_MSGHDR_ACCRIGHTS
|
||||
struct msghdr msghdr;
|
||||
|
@ -234,26 +262,22 @@ static unsigned int wait_reply_fd( int *fd )
|
|||
msghdr.msg_namelen = 0;
|
||||
msghdr.msg_iov = &vec;
|
||||
msghdr.msg_iovlen = 1;
|
||||
vec.iov_base = (void *)&res;
|
||||
vec.iov_len = sizeof(res);
|
||||
vec.iov_base = (void *)dummy;
|
||||
vec.iov_len = 1;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
if ((ret = recvmsg( NtCurrentTeb()->socket, &msghdr, 0 )) == sizeof(res))
|
||||
if ((ret = recvmsg( NtCurrentTeb()->socket, &msghdr, 0 )) > 0)
|
||||
{
|
||||
#ifndef HAVE_MSGHDR_ACCRIGHTS
|
||||
*fd = cmsg.fd;
|
||||
#endif
|
||||
return res;
|
||||
return;
|
||||
}
|
||||
if (!ret) break;
|
||||
if (ret == -1)
|
||||
{
|
||||
if (errno == EINTR) continue;
|
||||
if (errno == EPIPE) break;
|
||||
server_perror("recvmsg");
|
||||
}
|
||||
server_protocol_error( "partial seq received %d/%d\n", ret, sizeof(res) );
|
||||
if (errno == EINTR) continue;
|
||||
if (errno == EPIPE) break;
|
||||
server_perror("recvmsg");
|
||||
}
|
||||
/* the server closed the connection; time to die... */
|
||||
SYSDEPS_ExitThread(0);
|
||||
|
@ -267,8 +291,10 @@ static unsigned int wait_reply_fd( int *fd )
|
|||
*/
|
||||
unsigned int server_call_noerr( enum request req )
|
||||
{
|
||||
send_request( req );
|
||||
return wait_reply();
|
||||
void *req_ptr = get_req_buffer();
|
||||
send_request( req, req_ptr );
|
||||
wait_reply();
|
||||
return ((struct request_header *)req_ptr)->error;
|
||||
}
|
||||
|
||||
|
||||
|
@ -282,13 +308,16 @@ unsigned int server_call_noerr( enum request req )
|
|||
unsigned int server_call_fd( enum request req, int fd_out, int *fd_in )
|
||||
{
|
||||
unsigned int res;
|
||||
void *req_ptr = get_req_buffer();
|
||||
|
||||
if (fd_out == -1) send_request( req );
|
||||
else send_request_fd( req, fd_out );
|
||||
if (fd_out == -1) send_request( req, req_ptr );
|
||||
else send_request_fd( req, req_ptr, fd_out );
|
||||
|
||||
if (fd_in) res = wait_reply_fd( fd_in );
|
||||
else res = wait_reply();
|
||||
if (res) SetLastError( RtlNtStatusToDosError(res) );
|
||||
if (fd_in) wait_reply_fd( fd_in );
|
||||
else wait_reply();
|
||||
|
||||
if ((res = ((struct request_header *)req_ptr)->error))
|
||||
SetLastError( RtlNtStatusToDosError(res) );
|
||||
return res; /* error code */
|
||||
}
|
||||
|
||||
|
@ -517,37 +546,44 @@ int CLIENT_InitServer(void)
|
|||
*/
|
||||
int CLIENT_InitThread(void)
|
||||
{
|
||||
struct get_thread_buffer_request *first_req;
|
||||
struct init_thread_request *req;
|
||||
struct get_thread_buffer_request *req;
|
||||
TEB *teb = NtCurrentTeb();
|
||||
int fd;
|
||||
int fd, ret, size;
|
||||
|
||||
/* ignore SIGPIPE so that we get a EPIPE error instead */
|
||||
signal( SIGPIPE, SIG_IGN );
|
||||
|
||||
if (wait_reply_fd( &fd ) || (fd == -1))
|
||||
server_protocol_error( "no fd passed on first request\n" );
|
||||
if ((teb->buffer_size = lseek( fd, 0, SEEK_END )) == -1) server_perror( "lseek" );
|
||||
teb->buffer = mmap( 0, teb->buffer_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0 );
|
||||
wait_reply_fd( &fd );
|
||||
if (fd == -1) server_protocol_error( "no fd passed on first request\n" );
|
||||
|
||||
if ((size = lseek( fd, 0, SEEK_END )) == -1) server_perror( "lseek" );
|
||||
teb->buffer = mmap( 0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0 );
|
||||
close( fd );
|
||||
if (teb->buffer == (void*)-1) server_perror( "mmap" );
|
||||
first_req = teb->buffer;
|
||||
teb->pid = first_req->pid;
|
||||
teb->tid = first_req->tid;
|
||||
if (first_req->version != SERVER_PROTOCOL_VERSION)
|
||||
teb->buffer_info = (struct server_buffer_info *)((char *)teb->buffer + size) - 1;
|
||||
|
||||
req = (struct get_thread_buffer_request *)teb->buffer;
|
||||
teb->pid = req->pid;
|
||||
teb->tid = req->tid;
|
||||
if (req->version != SERVER_PROTOCOL_VERSION)
|
||||
server_protocol_error( "version mismatch %d/%d.\n"
|
||||
"Your %s binary was not upgraded correctly,\n"
|
||||
"or you have an older one somewhere in your PATH.\n",
|
||||
first_req->version, SERVER_PROTOCOL_VERSION,
|
||||
(first_req->version > SERVER_PROTOCOL_VERSION) ? "wine" : "wineserver" );
|
||||
if (first_req->boot) boot_thread_id = teb->tid;
|
||||
req->version, SERVER_PROTOCOL_VERSION,
|
||||
(req->version > SERVER_PROTOCOL_VERSION) ? "wine" : "wineserver" );
|
||||
if (req->boot) boot_thread_id = teb->tid;
|
||||
else if (boot_thread_id == teb->tid) boot_thread_id = 0;
|
||||
|
||||
req = teb->buffer;
|
||||
req->unix_pid = getpid();
|
||||
req->teb = teb;
|
||||
req->entry = teb->entry_point;
|
||||
return server_call_noerr( REQ_INIT_THREAD );
|
||||
SERVER_START_REQ
|
||||
{
|
||||
struct init_thread_request *req = server_alloc_req( sizeof(*req), 0 );
|
||||
req->unix_pid = getpid();
|
||||
req->teb = teb;
|
||||
req->entry = teb->entry_point;
|
||||
ret = server_call_noerr( REQ_INIT_THREAD );
|
||||
}
|
||||
SERVER_END_REQ;
|
||||
return ret;
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
|
@ -557,9 +593,15 @@ int CLIENT_InitThread(void)
|
|||
*/
|
||||
int CLIENT_BootDone( int debug_level )
|
||||
{
|
||||
struct boot_done_request *req = get_req_buffer();
|
||||
req->debug_level = debug_level;
|
||||
return server_call( REQ_BOOT_DONE );
|
||||
int ret;
|
||||
SERVER_START_REQ
|
||||
{
|
||||
struct boot_done_request *req = server_alloc_req( sizeof(*req), 0 );
|
||||
req->debug_level = debug_level;
|
||||
ret = server_call( REQ_BOOT_DONE );
|
||||
}
|
||||
SERVER_END_REQ;
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -105,7 +105,8 @@ static void CALLBACK THREAD_FreeTEB( TEB *teb )
|
|||
if (teb->socket != -1) close( teb->socket );
|
||||
if (teb->stack_sel) SELECTOR_FreeBlock( teb->stack_sel, 1 );
|
||||
SELECTOR_FreeBlock( teb->teb_sel, 1 );
|
||||
if (teb->buffer) munmap( teb->buffer, teb->buffer_size );
|
||||
if (teb->buffer) munmap( (void *)teb->buffer,
|
||||
(char *)(teb->buffer_info+1) - (char *)teb->buffer );
|
||||
if (teb->debug_info) HeapFree( GetProcessHeap(), 0, teb->debug_info );
|
||||
VirtualFree( teb->stack_base, 0, MEM_RELEASE );
|
||||
}
|
||||
|
|
|
@ -129,11 +129,14 @@ void fatal_perror( const char *err, ... )
|
|||
}
|
||||
|
||||
/* call a request handler */
|
||||
static inline void call_req_handler( struct thread *thread, enum request req )
|
||||
static inline void call_req_handler( struct thread *thread )
|
||||
{
|
||||
enum request req;
|
||||
current = thread;
|
||||
clear_error();
|
||||
|
||||
req = ((struct request_header *)current->buffer)->req;
|
||||
|
||||
if (debug_level) trace_request( req );
|
||||
|
||||
if (req < REQ_NB_REQUESTS)
|
||||
|
@ -165,7 +168,7 @@ void send_reply( struct thread *thread )
|
|||
void read_request( struct thread *thread )
|
||||
{
|
||||
int ret;
|
||||
enum request req;
|
||||
char dummy[1];
|
||||
|
||||
#ifdef HAVE_MSGHDR_ACCRIGHTS
|
||||
msghdr.msg_accrightslen = sizeof(int);
|
||||
|
@ -178,43 +181,42 @@ void read_request( struct thread *thread )
|
|||
|
||||
assert( thread->pass_fd == -1 );
|
||||
|
||||
myiovec.iov_base = (void *)&req;
|
||||
myiovec.iov_len = sizeof(req);
|
||||
myiovec.iov_base = dummy;
|
||||
myiovec.iov_len = 1;
|
||||
|
||||
ret = recvmsg( thread->obj.fd, &msghdr, 0 );
|
||||
#ifndef HAVE_MSGHDR_ACCRIGHTS
|
||||
thread->pass_fd = cmsg.fd;
|
||||
#endif
|
||||
|
||||
if (ret == sizeof(req))
|
||||
if (ret > 0)
|
||||
{
|
||||
call_req_handler( thread, req );
|
||||
call_req_handler( thread );
|
||||
thread->pass_fd = -1;
|
||||
return;
|
||||
}
|
||||
if (ret == -1)
|
||||
{
|
||||
perror("recvmsg");
|
||||
thread->exit_code = 1;
|
||||
kill_thread( thread, 1 );
|
||||
return;
|
||||
}
|
||||
if (!ret) /* closed pipe */
|
||||
{
|
||||
kill_thread( thread, 0 );
|
||||
return;
|
||||
}
|
||||
fatal_protocol_error( thread, "partial message received %d/%d\n", ret, sizeof(req) );
|
||||
perror("recvmsg");
|
||||
thread->exit_code = 1;
|
||||
kill_thread( thread, 1 );
|
||||
}
|
||||
|
||||
/* send a message to a client that is ready to receive something */
|
||||
int write_request( struct thread *thread )
|
||||
{
|
||||
int ret;
|
||||
struct request_header *header = thread->buffer;
|
||||
|
||||
header->error = thread->error;
|
||||
|
||||
if (thread->pass_fd == -1)
|
||||
{
|
||||
ret = write( thread->obj.fd, &thread->error, sizeof(thread->error) );
|
||||
/* write a single byte; the value is ignored anyway */
|
||||
ret = write( thread->obj.fd, header, 1 );
|
||||
}
|
||||
else /* we have an fd to send */
|
||||
{
|
||||
|
@ -227,37 +229,28 @@ int write_request( struct thread *thread )
|
|||
cmsg.fd = thread->pass_fd;
|
||||
#endif /* HAVE_MSGHDR_ACCRIGHTS */
|
||||
|
||||
myiovec.iov_base = (void *)&thread->error;
|
||||
myiovec.iov_len = sizeof(thread->error);
|
||||
myiovec.iov_base = (void *)header;
|
||||
myiovec.iov_len = 1;
|
||||
|
||||
ret = sendmsg( thread->obj.fd, &msghdr, 0 );
|
||||
close( thread->pass_fd );
|
||||
thread->pass_fd = -1;
|
||||
}
|
||||
if (ret == sizeof(thread->error))
|
||||
if (ret > 0)
|
||||
{
|
||||
set_select_events( &thread->obj, POLLIN );
|
||||
return 1;
|
||||
}
|
||||
if (ret == -1)
|
||||
if (errno == EWOULDBLOCK) return 0; /* not a fatal error */
|
||||
if (errno == EPIPE)
|
||||
{
|
||||
if (errno == EWOULDBLOCK) return 0; /* not a fatal error */
|
||||
if (errno == EPIPE)
|
||||
{
|
||||
kill_thread( thread, 0 ); /* normal death */
|
||||
}
|
||||
else
|
||||
{
|
||||
perror("sendmsg");
|
||||
thread->exit_code = 1;
|
||||
kill_thread( thread, 1 );
|
||||
}
|
||||
kill_thread( thread, 0 ); /* normal death */
|
||||
}
|
||||
else
|
||||
{
|
||||
perror("sendmsg");
|
||||
thread->exit_code = 1;
|
||||
kill_thread( thread, 1 );
|
||||
fprintf( stderr, "Partial message sent %d/%d\n", ret, sizeof(thread->error) );
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
|
|
@ -48,17 +48,26 @@ static inline void *get_req_ptr( struct thread *thread )
|
|||
return thread->buffer;
|
||||
}
|
||||
|
||||
/* get the request vararg data */
|
||||
inline static void *get_req_data( const void *req )
|
||||
{
|
||||
return ((union generic_request *)req + 1);
|
||||
}
|
||||
|
||||
|
||||
#define REQUEST_END(req) ((char *)(req) + MAX_REQUEST_LENGTH - sizeof(struct server_buffer_info))
|
||||
|
||||
/* get the remaining size in the request buffer for object of a given size */
|
||||
static inline int get_req_size( const void *req, const void *ptr, size_t typesize )
|
||||
{
|
||||
return ((char *)req + MAX_REQUEST_LENGTH - (char *)ptr) / typesize;
|
||||
return (REQUEST_END(req) - (char *)ptr) / typesize;
|
||||
}
|
||||
|
||||
/* get the length of a request string, without going past the end of the request */
|
||||
static inline size_t get_req_strlen( const void *req, const char *str )
|
||||
{
|
||||
const char *p = str;
|
||||
while (*p && (p < (char *)req + MAX_REQUEST_LENGTH - 1)) p++;
|
||||
while (*p && (p < REQUEST_END(req) - 1)) p++;
|
||||
return p - str;
|
||||
}
|
||||
|
||||
|
@ -66,7 +75,7 @@ static inline size_t get_req_strlen( const void *req, const char *str )
|
|||
static inline size_t get_req_strlenW( const void *req, const WCHAR *str )
|
||||
{
|
||||
const WCHAR *p = str;
|
||||
while (*p && (p < (WCHAR *)req + MAX_REQUEST_LENGTH/sizeof(WCHAR) - 1)) p++;
|
||||
while (*p && (p < (WCHAR *)REQUEST_END(req) - 1)) p++;
|
||||
return p - str;
|
||||
}
|
||||
|
||||
|
|
|
@ -96,6 +96,7 @@ static int alloc_client_buffer( struct thread *thread )
|
|||
if (ftruncate( fd, MAX_REQUEST_LENGTH ) == -1) goto error;
|
||||
if ((thread->buffer = mmap( 0, MAX_REQUEST_LENGTH, PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED, fd, 0 )) == (void*)-1) goto error;
|
||||
thread->buffer_info = (struct server_buffer_info *)((char *)thread->buffer + MAX_REQUEST_LENGTH) - 1;
|
||||
/* build the first request into the buffer and send it */
|
||||
req = thread->buffer;
|
||||
req->pid = get_process_id( thread->process );
|
||||
|
|
|
@ -59,6 +59,7 @@ struct thread
|
|||
int affinity; /* affinity mask */
|
||||
int suspend; /* suspend count */
|
||||
void *buffer; /* buffer for communication with the client */
|
||||
struct server_buffer_info *buffer_info; /* buffer information structure */
|
||||
enum request last_req; /* last request received (for debugging) */
|
||||
};
|
||||
|
||||
|
|
|
@ -787,7 +787,6 @@ static void dump_alloc_console_reply( const struct alloc_console_request *req )
|
|||
|
||||
static void dump_free_console_request( const struct free_console_request *req )
|
||||
{
|
||||
fprintf( stderr, " dummy=%d", req->dummy );
|
||||
}
|
||||
|
||||
static void dump_open_console_request( const struct open_console_request *req )
|
||||
|
|
|
@ -9,7 +9,6 @@
|
|||
%formats =
|
||||
(
|
||||
"int" => "%d",
|
||||
"long" => "%ld",
|
||||
"char" => "%c",
|
||||
"unsigned char" => "%02x",
|
||||
"unsigned int" => "%08x",
|
||||
|
@ -70,8 +69,13 @@ my @server_lines = ();
|
|||
|
||||
push @server_lines, "enum request\n{\n";
|
||||
foreach $req (@requests) { push @server_lines, " REQ_\U$req,\n"; }
|
||||
push @server_lines, " REQ_NB_REQUESTS\n};\n";
|
||||
push @server_lines, "\n#define SERVER_PROTOCOL_VERSION $protocol\n";
|
||||
push @server_lines, " REQ_NB_REQUESTS\n};\n\n";
|
||||
push @server_lines, "union generic_request\n{\n";
|
||||
push @server_lines, " struct request_max_size max_size;\n";
|
||||
push @server_lines, " struct request_header header;\n";
|
||||
foreach $req (@requests) { push @server_lines, " struct ${req}_request $req;\n"; }
|
||||
push @server_lines, "};\n\n";
|
||||
push @server_lines, "#define SERVER_PROTOCOL_VERSION $protocol\n";
|
||||
|
||||
REPLACE_IN_FILE( "include/server.h", @server_lines );
|
||||
|
||||
|
@ -98,6 +102,7 @@ sub DO_REQUEST
|
|||
my $name = shift;
|
||||
my @in_struct = ();
|
||||
my @out_struct = ();
|
||||
my $got_header = 0;
|
||||
while (<SERVER>)
|
||||
{
|
||||
my ($dir, $type, $var);
|
||||
|
@ -105,14 +110,34 @@ sub DO_REQUEST
|
|||
next if /^{$/;
|
||||
s!/\*.*\*/!!g;
|
||||
next if /^\s*$/;
|
||||
/^\s*(IN|OUT)\s*(\w+\**(\s+\w+\**)*)\s+(\w+)(\[[1]\])?;/ or die "Unrecognized syntax $_";
|
||||
$dir = $1;
|
||||
$type = $2 . ($5 || "");
|
||||
$var = $4;
|
||||
die "Unrecognized type $type" unless (defined($formats{$type}) || $5);
|
||||
if (/REQUEST_HEADER/)
|
||||
{
|
||||
die "Duplicated header" if $got_header;
|
||||
die "Header must be first" if ($#in_struct != -1 || $#out_struct != -1);
|
||||
$got_header++;
|
||||
next;
|
||||
}
|
||||
if (/^\s*(IN|OUT)\s*VARARG\((\w+),(\w+)\)/)
|
||||
{
|
||||
$dir = $1;
|
||||
$var = $2;
|
||||
$type = "&" . $3;
|
||||
}
|
||||
elsif (/^\s*(IN|OUT)\s*(\w+\**(\s+\w+\**)*)\s+(\w+)(\[[1]\])?;/)
|
||||
{
|
||||
$dir = $1;
|
||||
$type = $2 . ($5 || "");
|
||||
$var = $4;
|
||||
die "Unrecognized type $type" unless (defined($formats{$type}) || $5);
|
||||
}
|
||||
else
|
||||
{
|
||||
die "Unrecognized syntax $_";
|
||||
}
|
||||
if ($dir =~ /IN/) { push @in_struct, $type, $var; }
|
||||
if ($dir =~ /OUT/) { push @out_struct, $type, $var; }
|
||||
}
|
||||
die "Missing header" unless $got_header;
|
||||
push @requests, $name;
|
||||
&DO_DUMP_FUNC( $name, "request", @in_struct);
|
||||
if ($#out_struct >= 0)
|
||||
|
|
Loading…
Reference in a new issue