/*
 * Wine server protocol definitions
 *
 * This file is automatically generated; DO NO EDIT!
 * Edit server/protocol.def instead and re-run tools/make_requests
 */

#ifndef __WINE_WINE_SERVER_PROTOCOL_H
#define __WINE_WINE_SERVER_PROTOCOL_H

#include "config.h"

#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif

#include <stdlib.h>
#include <time.h>
#include "winbase.h"

struct request_header
{
    int          req;
    size_t       request_size;
    size_t       reply_size;
};

struct reply_header
{
    unsigned int error;
    size_t       reply_size;
};



struct request_max_size
{
    int pad[16];
};


#define REQUEST_MAX_VAR_SIZE  1024

typedef int handle_t;
typedef unsigned short atom_t;
typedef unsigned int user_handle_t;
typedef unsigned int thread_id_t;
typedef unsigned int process_id_t;

#define FIRST_USER_HANDLE 0x0020
#define LAST_USER_HANDLE  0xffef



struct debug_event_exception
{
    EXCEPTION_RECORD record;
    int              first;
};
struct debug_event_create_thread
{
    handle_t    handle;
    void       *teb;
    void       *start;
};
struct debug_event_create_process
{
    handle_t    file;
    handle_t    process;
    handle_t    thread;
    void       *base;
    int         dbg_offset;
    int         dbg_size;
    void       *teb;
    void       *start;
    void       *name;
    int         unicode;
};
struct debug_event_exit
{
    int         exit_code;
};
struct debug_event_load_dll
{
    handle_t    handle;
    void       *base;
    int         dbg_offset;
    int         dbg_size;
    void       *name;
    int         unicode;
};
struct debug_event_unload_dll
{
    void       *base;
};
struct debug_event_output_string
{
    void       *string;
    int         unicode;
    int         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;
};


typedef struct
{
    int                      code;
    union debug_event_data   info;
} debug_event_t;


struct send_fd
{
    thread_id_t tid;
    int         fd;
};


struct wake_up_reply
{
    void *cookie;
    int   signaled;
};


typedef struct
{
    atom_t         atom;
    short          string;
    handle_t       handle;
} property_data_t;


typedef struct
{
    int  left;
    int  top;
    int  right;
    int  bottom;
} rectangle_t;


typedef struct
{
    WCHAR          ch;
    unsigned short attr;
} char_info_t;





struct new_process_request
{
    struct request_header __header;
    int          inherit_all;
    int          create_flags;
    int          start_flags;
    int          unix_pid;
    handle_t     exe_file;
    handle_t     hstdin;
    handle_t     hstdout;
    handle_t     hstderr;
    int          cmd_show;
    /* VARARG(filename,string); */
};
struct new_process_reply
{
    struct reply_header __header;
    handle_t     info;
};



struct get_new_process_info_request
{
    struct request_header __header;
    handle_t     info;
    int          pinherit;
    int          tinherit;
};
struct get_new_process_info_reply
{
    struct reply_header __header;
    process_id_t pid;
    handle_t     phandle;
    thread_id_t  tid;
    handle_t     thandle;
    handle_t     event;
};



struct new_thread_request
{
    struct request_header __header;
    int          suspend;
    int          inherit;
    int          request_fd;
};
struct new_thread_reply
{
    struct reply_header __header;
    thread_id_t  tid;
    handle_t     handle;
};



struct boot_done_request
{
    struct request_header __header;
    int          debug_level;
};
struct boot_done_reply
{
    struct reply_header __header;
};



struct init_process_request
{
    struct request_header __header;
    void*        ldt_copy;
};
struct init_process_reply
{
    struct reply_header __header;
    int          create_flags;
    int          start_flags;
    unsigned int server_start;
    handle_t     exe_file;
    handle_t     hstdin;
    handle_t     hstdout;
    handle_t     hstderr;
    int          cmd_show;
    /* VARARG(filename,string); */
};



struct init_process_done_request
{
    struct request_header __header;
    void*        module;
    size_t       base_size;
    void*        entry;
    void*        name;
    handle_t     exe_file;
    int          gui;
    /* VARARG(filename,string); */
};
struct init_process_done_reply
{
    struct reply_header __header;
    int          debugged;
    int          shm_server;
    size_t       shm_size;
    void*        shm_addr;
};



struct init_thread_request
{
    struct request_header __header;
    pid_t        unix_tid;
    void*        teb;
    void*        entry;
    int          reply_fd;
    int          wait_fd;
};
struct init_thread_reply
{
    struct reply_header __header;
    process_id_t pid;
    thread_id_t  tid;
    int          boot;
    int          version;
};


struct set_thread_moduleload_request
{
    struct request_header __header;
    int          status;
};
struct set_thread_moduleload_reply
{
    struct reply_header __header;
};
#define THREAD_MODULE_NONE         0x0000
#define THREAD_MODULE_INIT         0x0001
#define THREAD_MODULE_BUILDING     0x0002
#define THREAD_MODULE_LOADING      0x0003


struct get_thread_moduleload_request
{
    struct request_header __header;
    handle_t     handle;
};
struct get_thread_moduleload_reply
{
    struct reply_header __header;
    int          status;
    int          self;
};


struct terminate_process_request
{
    struct request_header __header;
    handle_t     handle;
    int          exit_code;
};
struct terminate_process_reply
{
    struct reply_header __header;
    int          self;
};



struct terminate_thread_request
{
    struct request_header __header;
    handle_t     handle;
    int          exit_code;
};
struct terminate_thread_reply
{
    struct reply_header __header;
    int          self;
    int          last;
};



struct get_process_info_request
{
    struct request_header __header;
    handle_t     handle;
};
struct get_process_info_reply
{
    struct reply_header __header;
    process_id_t pid;
    int          debugged;
    int          exit_code;
    int          priority;
    int          process_affinity;
    int          system_affinity;
};



struct set_process_info_request
{
    struct request_header __header;
    handle_t     handle;
    int          mask;
    int          priority;
    int          affinity;
};
struct set_process_info_reply
{
    struct reply_header __header;
};
#define SET_PROCESS_INFO_PRIORITY 0x01
#define SET_PROCESS_INFO_AFFINITY 0x02



struct get_thread_info_request
{
    struct request_header __header;
    handle_t     handle;
    thread_id_t  tid_in;
};
struct get_thread_info_reply
{
    struct reply_header __header;
    thread_id_t  tid;
    void*        teb;
    int          exit_code;
    int          priority;
};



struct set_thread_info_request
{
    struct request_header __header;
    handle_t     handle;
    int          mask;
    int          priority;
    int          affinity;
};
struct set_thread_info_reply
{
    struct reply_header __header;
};
#define SET_THREAD_INFO_PRIORITY 0x01
#define SET_THREAD_INFO_AFFINITY 0x02



struct suspend_thread_request
{
    struct request_header __header;
    handle_t     handle;
};
struct suspend_thread_reply
{
    struct reply_header __header;
    int          count;
};



struct resume_thread_request
{
    struct request_header __header;
    handle_t     handle;
};
struct resume_thread_reply
{
    struct reply_header __header;
    int          count;
};



struct load_dll_request
{
    struct request_header __header;
    handle_t     handle;
    void*        base;
    size_t       base_size;
    int          dbg_offset;
    int          dbg_size;
    void*        name;
    /* VARARG(filename,string); */
};
struct load_dll_reply
{
    struct reply_header __header;
};



struct unload_dll_request
{
    struct request_header __header;
    void*        base;
};
struct unload_dll_reply
{
    struct reply_header __header;
};



struct queue_apc_request
{
    struct request_header __header;
    handle_t     handle;
    int          user;
    void*        func;
    void*        param;
};
struct queue_apc_reply
{
    struct reply_header __header;
};



struct get_apc_request
{
    struct request_header __header;
    int          alertable;
};
struct get_apc_reply
{
    struct reply_header __header;
    void*        func;
    int          type;
    /* VARARG(args,ptrs); */
};
enum apc_type { APC_NONE, APC_USER, APC_TIMER, APC_ASYNC, APC_ASYNC_IO };



struct close_handle_request
{
    struct request_header __header;
    handle_t     handle;
};
struct close_handle_reply
{
    struct reply_header __header;
    int          fd;
};



struct set_handle_info_request
{
    struct request_header __header;
    handle_t     handle;
    int          flags;
    int          mask;
    int          fd;
};
struct set_handle_info_reply
{
    struct reply_header __header;
    int          old_flags;
    int          cur_fd;
};



struct dup_handle_request
{
    struct request_header __header;
    handle_t     src_process;
    handle_t     src_handle;
    handle_t     dst_process;
    unsigned int access;
    int          inherit;
    int          options;
};
struct dup_handle_reply
{
    struct reply_header __header;
    handle_t     handle;
    int          fd;
};
#define DUP_HANDLE_CLOSE_SOURCE  DUPLICATE_CLOSE_SOURCE
#define DUP_HANDLE_SAME_ACCESS   DUPLICATE_SAME_ACCESS
#define DUP_HANDLE_MAKE_GLOBAL   0x80000000



struct open_process_request
{
    struct request_header __header;
    process_id_t pid;
    unsigned int access;
    int          inherit;
};
struct open_process_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct open_thread_request
{
    struct request_header __header;
    thread_id_t  tid;
    unsigned int access;
    int          inherit;
};
struct open_thread_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct select_request
{
    struct request_header __header;
    int          flags;
    void*        cookie;
    int          sec;
    int          usec;
    /* VARARG(handles,handles); */
};
struct select_reply
{
    struct reply_header __header;
};
#define SELECT_ALL           1
#define SELECT_ALERTABLE     2
#define SELECT_INTERRUPTIBLE 4
#define SELECT_TIMEOUT       8


struct shm_select_request
{
    struct request_header __header;
    int          flags;
    void*        cookie;
    int          sec;
    int          usec;
    void*        pollfd;
    /* VARARG(handles,handles); */
};
struct shm_select_reply
{
    struct reply_header __header;
    int          pollfds;
};



struct create_event_request
{
    struct request_header __header;
    int          manual_reset;
    int          initial_state;
    int          inherit;
    /* VARARG(name,unicode_str); */
};
struct create_event_reply
{
    struct reply_header __header;
    handle_t     handle;
};


struct event_op_request
{
    struct request_header __header;
    handle_t      handle;
    int           op;
};
struct event_op_reply
{
    struct reply_header __header;
};
enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT };



struct open_event_request
{
    struct request_header __header;
    unsigned int access;
    int          inherit;
    /* VARARG(name,unicode_str); */
};
struct open_event_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct create_mutex_request
{
    struct request_header __header;
    int          owned;
    int          inherit;
    /* VARARG(name,unicode_str); */
};
struct create_mutex_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct release_mutex_request
{
    struct request_header __header;
    handle_t     handle;
};
struct release_mutex_reply
{
    struct reply_header __header;
};



struct open_mutex_request
{
    struct request_header __header;
    unsigned int access;
    int          inherit;
    /* VARARG(name,unicode_str); */
};
struct open_mutex_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct create_semaphore_request
{
    struct request_header __header;
    unsigned int initial;
    unsigned int max;
    int          inherit;
    /* VARARG(name,unicode_str); */
};
struct create_semaphore_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct release_semaphore_request
{
    struct request_header __header;
    handle_t     handle;
    unsigned int count;
};
struct release_semaphore_reply
{
    struct reply_header __header;
    unsigned int prev_count;
};



struct open_semaphore_request
{
    struct request_header __header;
    unsigned int access;
    int          inherit;
    /* VARARG(name,unicode_str); */
};
struct open_semaphore_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct create_file_request
{
    struct request_header __header;
    unsigned int access;
    int          inherit;
    unsigned int sharing;
    int          create;
    unsigned int attrs;
    int          drive_type;
    int          drive;
    /* VARARG(filename,string); */
};
struct create_file_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct alloc_file_handle_request
{
    struct request_header __header;
    unsigned int access;
    int          inherit;
    int          fd;
};
struct alloc_file_handle_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct get_handle_fd_request
{
    struct request_header __header;
    handle_t     handle;
    unsigned int access;
};
struct get_handle_fd_reply
{
    struct reply_header __header;
    int          fd;
    int          type;
    int          flags;
};
enum fd_type
{
    FD_TYPE_INVALID,
    FD_TYPE_DEFAULT,
    FD_TYPE_CONSOLE,
    FD_TYPE_SOCKET
};
#define FD_FLAG_OVERLAPPED         0x01
#define FD_FLAG_TIMEOUT            0x02
#define FD_FLAG_RECV_SHUTDOWN      0x04
#define FD_FLAG_SEND_SHUTDOWN      0x08


struct set_file_pointer_request
{
    struct request_header __header;
    handle_t     handle;
    int          low;
    int          high;
    int          whence;
};
struct set_file_pointer_reply
{
    struct reply_header __header;
    int          new_low;
    int          new_high;
};



struct truncate_file_request
{
    struct request_header __header;
    handle_t     handle;
};
struct truncate_file_reply
{
    struct reply_header __header;
};



struct set_file_time_request
{
    struct request_header __header;
    handle_t     handle;
    time_t       access_time;
    time_t       write_time;
};
struct set_file_time_reply
{
    struct reply_header __header;
};



struct flush_file_request
{
    struct request_header __header;
    handle_t     handle;
};
struct flush_file_reply
{
    struct reply_header __header;
};



struct get_file_info_request
{
    struct request_header __header;
    handle_t     handle;
};
struct get_file_info_reply
{
    struct reply_header __header;
    int          type;
    int          attr;
    time_t       access_time;
    time_t       write_time;
    int          size_high;
    int          size_low;
    int          links;
    int          index_high;
    int          index_low;
    unsigned int serial;
};



struct lock_file_request
{
    struct request_header __header;
    handle_t     handle;
    unsigned int offset_low;
    unsigned int offset_high;
    unsigned int count_low;
    unsigned int count_high;
};
struct lock_file_reply
{
    struct reply_header __header;
};



struct unlock_file_request
{
    struct request_header __header;
    handle_t     handle;
    unsigned int offset_low;
    unsigned int offset_high;
    unsigned int count_low;
    unsigned int count_high;
};
struct unlock_file_reply
{
    struct reply_header __header;
};



struct create_socket_request
{
    struct request_header __header;
    unsigned int access;
    int          inherit;
    int          family;
    int          type;
    int          protocol;
    unsigned int flags;
};
struct create_socket_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct accept_socket_request
{
    struct request_header __header;
    handle_t     lhandle;
    unsigned int access;
    int          inherit;
};
struct accept_socket_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct set_socket_event_request
{
    struct request_header __header;
    handle_t      handle;
    unsigned int  mask;
    handle_t      event;
    user_handle_t window;
    unsigned int  msg;
};
struct set_socket_event_reply
{
    struct reply_header __header;
};



struct get_socket_event_request
{
    struct request_header __header;
    handle_t     handle;
    int          service;
    handle_t     c_event;
};
struct get_socket_event_reply
{
    struct reply_header __header;
    unsigned int mask;
    unsigned int pmask;
    unsigned int state;
    /* VARARG(errors,ints); */
};



struct enable_socket_event_request
{
    struct request_header __header;
    handle_t     handle;
    unsigned int mask;
    unsigned int sstate;
    unsigned int cstate;
};
struct enable_socket_event_reply
{
    struct reply_header __header;
};

struct set_socket_deferred_request
{
    struct request_header __header;
    handle_t     handle;
    handle_t     deferred;
};
struct set_socket_deferred_reply
{
    struct reply_header __header;
};


struct alloc_console_request
{
    struct request_header __header;
    unsigned int access;
    int          inherit;
    process_id_t pid;
};
struct alloc_console_reply
{
    struct reply_header __header;
    handle_t     handle_in;
    handle_t     event;
};



struct free_console_request
{
    struct request_header __header;
};
struct free_console_reply
{
    struct reply_header __header;
};


#define CONSOLE_RENDERER_NONE_EVENT        0x00
#define CONSOLE_RENDERER_TITLE_EVENT       0x01
#define CONSOLE_RENDERER_ACTIVE_SB_EVENT   0x02
#define CONSOLE_RENDERER_SB_RESIZE_EVENT   0x03
#define CONSOLE_RENDERER_UPDATE_EVENT      0x04
#define CONSOLE_RENDERER_CURSOR_POS_EVENT  0x05
#define CONSOLE_RENDERER_CURSOR_GEOM_EVENT 0x06
#define CONSOLE_RENDERER_DISPLAY_EVENT     0x07
#define CONSOLE_RENDERER_EXIT_EVENT        0x08
struct console_renderer_event
{
    short event;
    union
    {
        struct update
        {
            short top;
            short bottom;
        } update;
        struct resize
        {
            short width;
            short height;
        } resize;
        struct cursor_pos
        {
            short x;
            short y;
        } cursor_pos;
        struct cursor_geom
        {
            short visible;
            short size;
        } cursor_geom;
        struct display
        {
            short left;
            short top;
            short width;
            short height;
        } display;
    } u;
};


struct get_console_renderer_events_request
{
    struct request_header __header;
    handle_t     handle;
};
struct get_console_renderer_events_reply
{
    struct reply_header __header;
    /* VARARG(data,bytes); */
};



struct open_console_request
{
    struct request_header __header;
    int          from;

    unsigned int access;
    int          inherit;
    int          share;
};
struct open_console_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct get_console_mode_request
{
    struct request_header __header;
    handle_t     handle;
};
struct get_console_mode_reply
{
    struct reply_header __header;
    int          mode;
};



struct set_console_mode_request
{
    struct request_header __header;
    handle_t     handle;
    int          mode;
};
struct set_console_mode_reply
{
    struct reply_header __header;
};



struct set_console_input_info_request
{
    struct request_header __header;
    handle_t     handle;
    int          mask;
    handle_t     active_sb;
    int          history_mode;
    int          history_size;
    /* VARARG(title,unicode_str); */
};
struct set_console_input_info_reply
{
    struct reply_header __header;
};
#define SET_CONSOLE_INPUT_INFO_ACTIVE_SB        0x01
#define SET_CONSOLE_INPUT_INFO_TITLE            0x02
#define SET_CONSOLE_INPUT_INFO_HISTORY_MODE     0x04
#define SET_CONSOLE_INPUT_INFO_HISTORY_SIZE     0x08



struct get_console_input_info_request
{
    struct request_header __header;
    handle_t     handle;
};
struct get_console_input_info_reply
{
    struct reply_header __header;
    int          history_mode;
    int          history_size;
    int          history_index;
    /* VARARG(title,unicode_str); */
};



struct append_console_input_history_request
{
    struct request_header __header;
    handle_t     handle;
    /* VARARG(line,unicode_str); */
};
struct append_console_input_history_reply
{
    struct reply_header __header;
};



struct get_console_input_history_request
{
    struct request_header __header;
    handle_t     handle;
    int          index;
};
struct get_console_input_history_reply
{
    struct reply_header __header;
    int          total;
    /* VARARG(line,unicode_str); */
};



struct create_console_output_request
{
    struct request_header __header;
    handle_t     handle_in;
    int          access;
    int          share;
    int          inherit;
};
struct create_console_output_reply
{
    struct reply_header __header;
    handle_t     handle_out;
};



struct set_console_output_info_request
{
    struct request_header __header;
    handle_t     handle;
    int          mask;
    short int    cursor_size;
    short int    cursor_visible;
    short int    cursor_x;
    short int    cursor_y;
    short int    width;
    short int    height;
    short int    attr;
    short int    win_left;
    short int    win_top;
    short int    win_right;
    short int    win_bottom;
    short int    max_width;
    short int    max_height;
};
struct set_console_output_info_reply
{
    struct reply_header __header;
};
#define SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM     0x01
#define SET_CONSOLE_OUTPUT_INFO_CURSOR_POS      0x02
#define SET_CONSOLE_OUTPUT_INFO_SIZE            0x04
#define SET_CONSOLE_OUTPUT_INFO_ATTR            0x08
#define SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW  0x10
#define SET_CONSOLE_OUTPUT_INFO_MAX_SIZE        0x20



struct get_console_output_info_request
{
    struct request_header __header;
    handle_t     handle;
};
struct get_console_output_info_reply
{
    struct reply_header __header;
    short int    cursor_size;
    short int    cursor_visible;
    short int    cursor_x;
    short int    cursor_y;
    short int    width;
    short int    height;
    short int    attr;
    short int    win_left;
    short int    win_top;
    short int    win_right;
    short int    win_bottom;
    short int    max_width;
    short int    max_height;
};


struct write_console_input_request
{
    struct request_header __header;
    handle_t     handle;
    /* VARARG(rec,input_records); */
};
struct write_console_input_reply
{
    struct reply_header __header;
    int          written;
};



struct read_console_input_request
{
    struct request_header __header;
    handle_t     handle;
    int          flush;
};
struct read_console_input_reply
{
    struct reply_header __header;
    int          read;
    /* VARARG(rec,input_records); */
};



struct write_console_output_request
{
    struct request_header __header;
    handle_t     handle;
    int          x;
    int          y;
    int          mode;
    int          wrap;
    /* VARARG(data,bytes); */
};
struct write_console_output_reply
{
    struct reply_header __header;
    int          written;
    int          width;
    int          height;
};
enum char_info_mode
{
    CHAR_INFO_MODE_TEXT,
    CHAR_INFO_MODE_ATTR,
    CHAR_INFO_MODE_TEXTATTR,
    CHAR_INFO_MODE_TEXTSTDATTR
};



struct fill_console_output_request
{
    struct request_header __header;
    handle_t     handle;
    int          x;
    int          y;
    int          mode;
    int          count;
    int          wrap;
    char_info_t  data;
};
struct fill_console_output_reply
{
    struct reply_header __header;
    int          written;
};



struct read_console_output_request
{
    struct request_header __header;
    handle_t     handle;
    int          x;
    int          y;
    int          mode;
    int          wrap;
};
struct read_console_output_reply
{
    struct reply_header __header;
    int          width;
    int          height;
    /* VARARG(data,bytes); */
};



struct move_console_output_request
{
    struct request_header __header;
    handle_t     handle;
    short int    x_src;
    short int    y_src;
    short int    x_dst;
    short int    y_dst;
    short int    w;
    short int    h;
};
struct move_console_output_reply
{
    struct reply_header __header;
};



struct send_console_signal_request
{
    struct request_header __header;
    int          signal;
    process_id_t group_id;
};
struct send_console_signal_reply
{
    struct reply_header __header;
};



struct create_change_notification_request
{
    struct request_header __header;
    int          subtree;
    int          filter;
};
struct create_change_notification_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct create_mapping_request
{
    struct request_header __header;
    int          size_high;
    int          size_low;
    int          protect;
    int          inherit;
    handle_t     file_handle;
    /* VARARG(name,unicode_str); */
};
struct create_mapping_reply
{
    struct reply_header __header;
    handle_t     handle;
};

#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
#define VPROT_IMAGE      0x80



struct open_mapping_request
{
    struct request_header __header;
    unsigned int access;
    int          inherit;
    /* VARARG(name,unicode_str); */
};
struct open_mapping_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct get_mapping_info_request
{
    struct request_header __header;
    handle_t     handle;
};
struct get_mapping_info_reply
{
    struct reply_header __header;
    int          size_high;
    int          size_low;
    int          protect;
    int          header_size;
    void*        base;
    handle_t     shared_file;
    int          shared_size;
    int          drive_type;
};



struct create_device_request
{
    struct request_header __header;
    unsigned int access;
    int          inherit;
    int          id;
};
struct create_device_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct create_snapshot_request
{
    struct request_header __header;
    int          inherit;
    int          flags;
    process_id_t pid;
};
struct create_snapshot_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct next_process_request
{
    struct request_header __header;
    handle_t     handle;
    int          reset;
};
struct next_process_reply
{
    struct reply_header __header;
    int          count;
    process_id_t pid;
    process_id_t ppid;
    void*        def_heap;
    void*        module;
    int          threads;
    int          priority;
    /* VARARG(name,string); */
};



struct next_thread_request
{
    struct request_header __header;
    handle_t     handle;
    int          reset;
};
struct next_thread_reply
{
    struct reply_header __header;
    int          count;
    process_id_t pid;
    thread_id_t  tid;
    int          base_pri;
    int          delta_pri;
};



struct next_module_request
{
    struct request_header __header;
    handle_t     handle;
    int          reset;
};
struct next_module_reply
{
    struct reply_header __header;
    process_id_t pid;
    void*        base;
    size_t       base_size;
    /* VARARG(name,string); */
};



struct wait_debug_event_request
{
    struct request_header __header;
    int           get_handle;
};
struct wait_debug_event_reply
{
    struct reply_header __header;
    process_id_t  pid;
    thread_id_t   tid;
    handle_t      wait;
    /* VARARG(event,debug_event); */
};



struct queue_exception_event_request
{
    struct request_header __header;
    int              first;
    /* VARARG(record,exc_event); */
};
struct queue_exception_event_reply
{
    struct reply_header __header;
    handle_t         handle;
};



struct get_exception_status_request
{
    struct request_header __header;
    handle_t         handle;
};
struct get_exception_status_reply
{
    struct reply_header __header;
    int              status;
    /* VARARG(context,context); */
};



struct output_debug_string_request
{
    struct request_header __header;
    void*         string;
    int           unicode;
    int           length;
};
struct output_debug_string_reply
{
    struct reply_header __header;
};



struct continue_debug_event_request
{
    struct request_header __header;
    process_id_t pid;
    thread_id_t  tid;
    int          status;
};
struct continue_debug_event_reply
{
    struct reply_header __header;
};



struct debug_process_request
{
    struct request_header __header;
    process_id_t pid;
    int          attach;
};
struct debug_process_reply
{
    struct reply_header __header;
};



struct debug_break_request
{
    struct request_header __header;
    handle_t     handle;
};
struct debug_break_reply
{
    struct reply_header __header;
    int          self;
};



struct set_debugger_kill_on_exit_request
{
    struct request_header __header;
    int          kill_on_exit;
};
struct set_debugger_kill_on_exit_reply
{
    struct reply_header __header;
};



struct read_process_memory_request
{
    struct request_header __header;
    handle_t     handle;
    void*        addr;
    unsigned int len;
    unsigned int check_len;
};
struct read_process_memory_reply
{
    struct reply_header __header;
    /* VARARG(data,bytes); */
};



struct write_process_memory_request
{
    struct request_header __header;
    handle_t     handle;
    void*        addr;
    int          len;
    unsigned int check_len;
    /* VARARG(data,bytes); */
};
struct write_process_memory_reply
{
    struct reply_header __header;
};



struct create_key_request
{
    struct request_header __header;
    handle_t     parent;
    unsigned int access;
    unsigned int options;
    time_t       modif;
    size_t       namelen;
    /* VARARG(name,unicode_str,namelen); */
    /* VARARG(class,unicode_str); */
};
struct create_key_reply
{
    struct reply_header __header;
    handle_t     hkey;
    int          created;
};


struct open_key_request
{
    struct request_header __header;
    handle_t     parent;
    unsigned int access;
    /* VARARG(name,unicode_str); */
};
struct open_key_reply
{
    struct reply_header __header;
    handle_t     hkey;
};



struct delete_key_request
{
    struct request_header __header;
    handle_t     hkey;
};
struct delete_key_reply
{
    struct reply_header __header;
};



struct enum_key_request
{
    struct request_header __header;
    handle_t     hkey;
    int          index;
    int          info_class;
};
struct enum_key_reply
{
    struct reply_header __header;
    int          subkeys;
    int          max_subkey;
    int          max_class;
    int          values;
    int          max_value;
    int          max_data;
    time_t       modif;
    size_t       total;
    size_t       namelen;
    /* VARARG(name,unicode_str,namelen); */
    /* VARARG(class,unicode_str); */
};



struct set_key_value_request
{
    struct request_header __header;
    handle_t     hkey;
    int          type;
    size_t       namelen;
    /* VARARG(name,unicode_str,namelen); */
    /* VARARG(data,bytes); */
};
struct set_key_value_reply
{
    struct reply_header __header;
};



struct get_key_value_request
{
    struct request_header __header;
    handle_t     hkey;
    /* VARARG(name,unicode_str); */
};
struct get_key_value_reply
{
    struct reply_header __header;
    int          type;
    size_t       total;
    /* VARARG(data,bytes); */
};



struct enum_key_value_request
{
    struct request_header __header;
    handle_t     hkey;
    int          index;
    int          info_class;
};
struct enum_key_value_reply
{
    struct reply_header __header;
    int          type;
    size_t       total;
    size_t       namelen;
    /* VARARG(name,unicode_str,namelen); */
    /* VARARG(data,bytes); */
};



struct delete_key_value_request
{
    struct request_header __header;
    handle_t     hkey;
    /* VARARG(name,unicode_str); */
};
struct delete_key_value_reply
{
    struct reply_header __header;
};



struct load_registry_request
{
    struct request_header __header;
    handle_t     hkey;
    handle_t     file;
    /* VARARG(name,unicode_str); */
};
struct load_registry_reply
{
    struct reply_header __header;
};



struct save_registry_request
{
    struct request_header __header;
    handle_t     hkey;
    handle_t     file;
};
struct save_registry_reply
{
    struct reply_header __header;
};



struct save_registry_atexit_request
{
    struct request_header __header;
    handle_t     hkey;
    /* VARARG(file,string); */
};
struct save_registry_atexit_reply
{
    struct reply_header __header;
};



struct set_registry_levels_request
{
    struct request_header __header;
    int          current;
    int          saving;
    int          period;
};
struct set_registry_levels_reply
{
    struct reply_header __header;
};



struct create_timer_request
{
    struct request_header __header;
    int          inherit;
    int          manual;
    /* VARARG(name,unicode_str); */
};
struct create_timer_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct open_timer_request
{
    struct request_header __header;
    unsigned int access;
    int          inherit;
    /* VARARG(name,unicode_str); */
};
struct open_timer_reply
{
    struct reply_header __header;
    handle_t     handle;
};


struct set_timer_request
{
    struct request_header __header;
    handle_t     handle;
    int          sec;
    int          usec;
    int          period;
    void*        callback;
    void*        arg;
};
struct set_timer_reply
{
    struct reply_header __header;
};


struct cancel_timer_request
{
    struct request_header __header;
    handle_t     handle;
};
struct cancel_timer_reply
{
    struct reply_header __header;
};



struct get_thread_context_request
{
    struct request_header __header;
    handle_t     handle;
    unsigned int flags;
};
struct get_thread_context_reply
{
    struct reply_header __header;
    /* VARARG(context,context); */
};



struct set_thread_context_request
{
    struct request_header __header;
    handle_t     handle;
    unsigned int flags;
    /* VARARG(context,context); */
};
struct set_thread_context_reply
{
    struct reply_header __header;
};



struct get_selector_entry_request
{
    struct request_header __header;
    handle_t      handle;
    int           entry;
};
struct get_selector_entry_reply
{
    struct reply_header __header;
    unsigned int  base;
    unsigned int  limit;
    unsigned char flags;
};



struct add_atom_request
{
    struct request_header __header;
    int           local;
    /* VARARG(name,unicode_str); */
};
struct add_atom_reply
{
    struct reply_header __header;
    atom_t        atom;
};



struct delete_atom_request
{
    struct request_header __header;
    atom_t        atom;
    int           local;
};
struct delete_atom_reply
{
    struct reply_header __header;
};



struct find_atom_request
{
    struct request_header __header;
    int          local;
    /* VARARG(name,unicode_str); */
};
struct find_atom_reply
{
    struct reply_header __header;
    atom_t       atom;
};



struct get_atom_name_request
{
    struct request_header __header;
    atom_t       atom;
    int          local;
};
struct get_atom_name_reply
{
    struct reply_header __header;
    int          count;
    /* VARARG(name,unicode_str); */
};



struct init_atom_table_request
{
    struct request_header __header;
    int          entries;
};
struct init_atom_table_reply
{
    struct reply_header __header;
};



struct get_msg_queue_request
{
    struct request_header __header;
};
struct get_msg_queue_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct set_queue_mask_request
{
    struct request_header __header;
    unsigned int wake_mask;
    unsigned int changed_mask;
    int          skip_wait;
};
struct set_queue_mask_reply
{
    struct reply_header __header;
    unsigned int wake_bits;
    unsigned int changed_bits;
};



struct get_queue_status_request
{
    struct request_header __header;
    int          clear;
};
struct get_queue_status_reply
{
    struct reply_header __header;
    unsigned int wake_bits;
    unsigned int changed_bits;
};



struct wait_input_idle_request
{
    struct request_header __header;
    handle_t     handle;
    int          timeout;
};
struct wait_input_idle_reply
{
    struct reply_header __header;
    handle_t     event;
};



struct send_message_request
{
    struct request_header __header;
    thread_id_t     id;
    int             type;
    user_handle_t   win;
    unsigned int    msg;
    unsigned int    wparam;
    unsigned int    lparam;
    int             x;
    int             y;
    unsigned int    time;
    unsigned int    info;
    int             timeout;
    /* VARARG(data,bytes); */
};
struct send_message_reply
{
    struct reply_header __header;
};

enum message_type
{
    MSG_ASCII,
    MSG_UNICODE,
    MSG_NOTIFY,
    MSG_CALLBACK,
    MSG_OTHER_PROCESS,
    MSG_POSTED,
    MSG_HARDWARE_RAW,
    MSG_HARDWARE_COOKED
};



struct get_message_request
{
    struct request_header __header;
    int             flags;
    user_handle_t   get_win;
    unsigned int    get_first;
    unsigned int    get_last;
};
struct get_message_reply
{
    struct reply_header __header;
    int             type;
    user_handle_t   win;
    unsigned int    msg;
    unsigned int    wparam;
    unsigned int    lparam;
    int             x;
    int             y;
    unsigned int    time;
    unsigned int    info;
    size_t          total;
    /* VARARG(data,bytes); */
};
#define GET_MSG_REMOVE      1
#define GET_MSG_SENT_ONLY   2
#define GET_MSG_REMOVE_LAST 4


struct reply_message_request
{
    struct request_header __header;
    unsigned int    result;
    int             remove;
    /* VARARG(data,bytes); */
};
struct reply_message_reply
{
    struct reply_header __header;
};



struct get_message_reply_request
{
    struct request_header __header;
    int             cancel;
};
struct get_message_reply_reply
{
    struct reply_header __header;
    unsigned int    result;
    /* VARARG(data,bytes); */
};



struct set_win_timer_request
{
    struct request_header __header;
    user_handle_t   win;
    unsigned int    msg;
    unsigned int    id;
    unsigned int    rate;
    unsigned int    lparam;
};
struct set_win_timer_reply
{
    struct reply_header __header;
};



struct kill_win_timer_request
{
    struct request_header __header;
    user_handle_t   win;
    unsigned int    msg;
    unsigned int    id;
};
struct kill_win_timer_reply
{
    struct reply_header __header;
};



struct create_serial_request
{
    struct request_header __header;
    unsigned int access;
    int          inherit;
    unsigned int attributes;
    unsigned int sharing;
    /* VARARG(name,string); */
};
struct create_serial_reply
{
    struct reply_header __header;
    handle_t     handle;
};



struct get_serial_info_request
{
    struct request_header __header;
    handle_t     handle;
};
struct get_serial_info_reply
{
    struct reply_header __header;
    unsigned int readinterval;
    unsigned int readconst;
    unsigned int readmult;
    unsigned int writeconst;
    unsigned int writemult;
    unsigned int eventmask;
    unsigned int commerror;
};



struct set_serial_info_request
{
    struct request_header __header;
    handle_t     handle;
    int          flags;
    unsigned int readinterval;
    unsigned int readconst;
    unsigned int readmult;
    unsigned int writeconst;
    unsigned int writemult;
    unsigned int eventmask;
    unsigned int commerror;
};
struct set_serial_info_reply
{
    struct reply_header __header;
};
#define SERIALINFO_SET_TIMEOUTS  0x01
#define SERIALINFO_SET_MASK      0x02
#define SERIALINFO_SET_ERROR     0x04



struct register_async_request
{
    struct request_header __header;
    handle_t     handle;
    int          type;
    void*        overlapped;
    int          count;
    unsigned int status;
};
struct register_async_reply
{
    struct reply_header __header;
};
#define ASYNC_TYPE_NONE  0x00
#define ASYNC_TYPE_READ  0x01
#define ASYNC_TYPE_WRITE 0x02
#define ASYNC_TYPE_WAIT  0x03



struct create_named_pipe_request
{
    struct request_header __header;
    unsigned int   openmode;
    unsigned int   pipemode;
    unsigned int   maxinstances;
    unsigned int   outsize;
    unsigned int   insize;
    unsigned int   timeout;
    /* VARARG(name,unicode_str); */
};
struct create_named_pipe_reply
{
    struct reply_header __header;
    handle_t       handle;
};



struct open_named_pipe_request
{
    struct request_header __header;
    unsigned int   access;
    /* VARARG(name,unicode_str); */
};
struct open_named_pipe_reply
{
    struct reply_header __header;
    handle_t       handle;
};



struct connect_named_pipe_request
{
    struct request_header __header;
    handle_t       handle;
    void*          overlapped;
    void*          func;
};
struct connect_named_pipe_reply
{
    struct reply_header __header;
};



struct wait_named_pipe_request
{
    struct request_header __header;
    unsigned int   timeout;
    void*          overlapped;
    void*          func;
    /* VARARG(name,unicode_str); */
};
struct wait_named_pipe_reply
{
    struct reply_header __header;
};



struct disconnect_named_pipe_request
{
    struct request_header __header;
    handle_t       handle;
};
struct disconnect_named_pipe_reply
{
    struct reply_header __header;
};


struct get_named_pipe_info_request
{
    struct request_header __header;
    handle_t       handle;
};
struct get_named_pipe_info_reply
{
    struct reply_header __header;
    unsigned int   flags;
    unsigned int   maxinstances;
    unsigned int   outsize;
    unsigned int   insize;
};



struct create_window_request
{
    struct request_header __header;
    user_handle_t  parent;
    user_handle_t  owner;
    atom_t         atom;
};
struct create_window_reply
{
    struct reply_header __header;
    user_handle_t  handle;
};



struct link_window_request
{
    struct request_header __header;
    user_handle_t  handle;
    user_handle_t  parent;
    user_handle_t  previous;
};
struct link_window_reply
{
    struct reply_header __header;
    user_handle_t  full_parent;
};



struct destroy_window_request
{
    struct request_header __header;
    user_handle_t  handle;
};
struct destroy_window_reply
{
    struct reply_header __header;
};



struct set_window_owner_request
{
    struct request_header __header;
    user_handle_t  handle;
    user_handle_t  owner;
};
struct set_window_owner_reply
{
    struct reply_header __header;
    user_handle_t  full_owner;
};



struct get_window_info_request
{
    struct request_header __header;
    user_handle_t  handle;
};
struct get_window_info_reply
{
    struct reply_header __header;
    user_handle_t  full_handle;
    process_id_t   pid;
    thread_id_t    tid;
    atom_t         atom;
};



struct set_window_info_request
{
    struct request_header __header;
    user_handle_t  handle;
    unsigned int   flags;
    unsigned int   style;
    unsigned int   ex_style;
    unsigned int   id;
    void*          instance;
    void*          user_data;
};
struct set_window_info_reply
{
    struct reply_header __header;
    unsigned int   old_style;
    unsigned int   old_ex_style;
    unsigned int   old_id;
    void*          old_instance;
    void*          old_user_data;
};
#define SET_WIN_STYLE     0x01
#define SET_WIN_EXSTYLE   0x02
#define SET_WIN_ID        0x04
#define SET_WIN_INSTANCE  0x08
#define SET_WIN_USERDATA  0x10



struct get_window_parents_request
{
    struct request_header __header;
    user_handle_t  handle;
};
struct get_window_parents_reply
{
    struct reply_header __header;
    int            count;
    /* VARARG(parents,user_handles); */
};



struct get_window_children_request
{
    struct request_header __header;
    user_handle_t  parent;
    atom_t         atom;
    thread_id_t    tid;
    int            all;
};
struct get_window_children_reply
{
    struct reply_header __header;
    int            count;
    /* VARARG(children,user_handles); */
};



struct get_window_tree_request
{
    struct request_header __header;
    user_handle_t  handle;
};
struct get_window_tree_reply
{
    struct reply_header __header;
    user_handle_t  parent;
    user_handle_t  owner;
    user_handle_t  next_sibling;
    user_handle_t  prev_sibling;
    user_handle_t  first_sibling;
    user_handle_t  last_sibling;
    user_handle_t  first_child;
    user_handle_t  last_child;
};


struct set_window_rectangles_request
{
    struct request_header __header;
    user_handle_t  handle;
    rectangle_t    window;
    rectangle_t    client;
};
struct set_window_rectangles_reply
{
    struct reply_header __header;
};



struct get_window_rectangles_request
{
    struct request_header __header;
    user_handle_t  handle;
};
struct get_window_rectangles_reply
{
    struct reply_header __header;
    rectangle_t    window;
    rectangle_t    client;
};



struct get_window_text_request
{
    struct request_header __header;
    user_handle_t  handle;
};
struct get_window_text_reply
{
    struct reply_header __header;
    /* VARARG(text,unicode_str); */
};



struct set_window_text_request
{
    struct request_header __header;
    user_handle_t  handle;
    /* VARARG(text,unicode_str); */
};
struct set_window_text_reply
{
    struct reply_header __header;
};



struct inc_window_paint_count_request
{
    struct request_header __header;
    user_handle_t  handle;
    int             incr;
};
struct inc_window_paint_count_reply
{
    struct reply_header __header;
};



struct get_windows_offset_request
{
    struct request_header __header;
    user_handle_t  from;
    user_handle_t  to;
};
struct get_windows_offset_reply
{
    struct reply_header __header;
    int            x;
    int            y;
};



struct set_window_property_request
{
    struct request_header __header;
    user_handle_t  window;
    atom_t         atom;
    int            string;
    handle_t       handle;
};
struct set_window_property_reply
{
    struct reply_header __header;
};



struct remove_window_property_request
{
    struct request_header __header;
    user_handle_t  window;
    atom_t         atom;
};
struct remove_window_property_reply
{
    struct reply_header __header;
    handle_t       handle;
};



struct get_window_property_request
{
    struct request_header __header;
    user_handle_t  window;
    atom_t         atom;
};
struct get_window_property_reply
{
    struct reply_header __header;
    handle_t       handle;
};



struct get_window_properties_request
{
    struct request_header __header;
    user_handle_t  window;
};
struct get_window_properties_reply
{
    struct reply_header __header;
    int            total;
    /* VARARG(props,properties); */
};



struct enable_trace_request
{
    struct request_header __header;
    int            debug_level;
};
struct enable_trace_reply
{
    struct reply_header __header;
};



struct register_rpc_endpoints_request
{
    struct request_header __header;
    int            objects;
    int            bindings;
    int            no_replace;
    /* VARARG(eps,bytes); */
};
struct register_rpc_endpoints_reply
{
    struct reply_header __header;
};



struct unregister_rpc_endpoints_request
{
    struct request_header __header;
    int            objects;
    int            bindings;
    /* VARARG(eps,bytes); */
};
struct unregister_rpc_endpoints_reply
{
    struct reply_header __header;
};



struct resolve_rpc_endpoint_request
{
    struct request_header __header;
    /* VARARG(binding,bytes); */
};
struct resolve_rpc_endpoint_reply
{
    struct reply_header __header;
    /* VARARG(ep,bytes); */
};

struct update_thread_tid_request
{
    struct request_header __header;
    pid_t old_unix_tid;
    pid_t new_unix_tid;
};
struct update_thread_tid_reply
{
    struct reply_header __header;
};


struct get_cdrom_eject_fd_count_request
{
    struct request_header __header;
    int            cd_drive;
};
struct get_cdrom_eject_fd_count_reply
{
    struct reply_header __header;
    int            count;
};

struct get_cdrom_eject_fd_list_request
{
    struct request_header __header;
    int            cd_drive;
};
struct get_cdrom_eject_fd_list_reply
{
    struct reply_header __header;
    /* VARARG(fds,ints); */
};

struct add_cdrom_device_info_request
{
    struct request_header __header;
    int            cd_drive;
    /* VARARG(devicename,string); */
};
struct add_cdrom_device_info_reply
{
    struct reply_header __header;
};


struct open_token_request
{
    struct request_header __header;
    unsigned int access;
    handle_t     handle;
    int          thread;
};
struct open_token_reply
{
    struct reply_header __header;
    handle_t     handle;
};



enum request
{
    REQ_new_process, /* 0*/
    REQ_get_new_process_info, /* 1*/
    REQ_new_thread, /* 2*/
    REQ_boot_done, /* 3*/
    REQ_init_process, /* 4*/
    REQ_init_process_done, /* 5*/
    REQ_init_thread, /* 6*/
    REQ_set_thread_moduleload, /* 7*/
    REQ_get_thread_moduleload, /* 8*/
    REQ_terminate_process, /* 9*/
    REQ_terminate_thread, /* 10*/
    REQ_get_process_info, /* 11*/
    REQ_set_process_info, /* 12*/
    REQ_get_thread_info, /* 13*/
    REQ_set_thread_info, /* 14*/
    REQ_suspend_thread, /* 15*/
    REQ_resume_thread, /* 16*/
    REQ_load_dll, /* 17*/
    REQ_unload_dll, /* 18*/
    REQ_queue_apc, /* 19*/
    REQ_get_apc, /* 20*/
    REQ_close_handle, /* 21*/
    REQ_set_handle_info, /* 22*/
    REQ_dup_handle, /* 23*/
    REQ_open_process, /* 24*/
    REQ_open_thread, /* 25*/
    REQ_select, /* 26*/
    REQ_shm_select, /* 27*/
    REQ_create_event, /* 28*/
    REQ_event_op, /* 29*/
    REQ_open_event, /* 30*/
    REQ_create_mutex, /* 31*/
    REQ_release_mutex, /* 32*/
    REQ_open_mutex, /* 33*/
    REQ_create_semaphore, /* 34*/
    REQ_release_semaphore, /* 35*/
    REQ_open_semaphore, /* 36*/
    REQ_create_file, /* 37*/
    REQ_alloc_file_handle, /* 38*/
    REQ_get_handle_fd, /* 39*/
    REQ_set_file_pointer, /* 40*/
    REQ_truncate_file, /* 41*/
    REQ_set_file_time, /* 42*/
    REQ_flush_file, /* 43*/
    REQ_get_file_info, /* 44*/
    REQ_lock_file, /* 45*/
    REQ_unlock_file, /* 46*/
    REQ_create_socket, /* 47*/
    REQ_accept_socket, /* 48*/
    REQ_set_socket_event, /* 49*/
    REQ_get_socket_event, /* 50*/
    REQ_enable_socket_event, /* 51*/
    REQ_set_socket_deferred, /* 52*/
    REQ_alloc_console, /* 53*/
    REQ_free_console, /* 54*/
    REQ_get_console_renderer_events, /* 55*/
    REQ_open_console, /* 56*/
    REQ_get_console_mode, /* 57*/
    REQ_set_console_mode, /* 58*/
    REQ_set_console_input_info, /* 59*/
    REQ_get_console_input_info, /* 60*/
    REQ_append_console_input_history, /* 61*/
    REQ_get_console_input_history, /* 62*/
    REQ_create_console_output, /* 63*/
    REQ_set_console_output_info, /* 64*/
    REQ_get_console_output_info, /* 65*/
    REQ_write_console_input, /* 66*/
    REQ_read_console_input, /* 67*/
    REQ_write_console_output, /* 68*/
    REQ_fill_console_output, /* 69*/
    REQ_read_console_output, /* 70*/
    REQ_move_console_output, /* 71*/
    REQ_send_console_signal, /* 72*/
    REQ_create_change_notification, /* 73*/
    REQ_create_mapping, /* 74*/
    REQ_open_mapping, /* 75*/
    REQ_get_mapping_info, /* 76*/
    REQ_create_device, /* 77*/
    REQ_create_snapshot, /* 78*/
    REQ_next_process, /* 79*/
    REQ_next_thread, /* 80*/
    REQ_next_module, /* 81*/
    REQ_wait_debug_event, /* 82*/
    REQ_queue_exception_event, /* 83*/
    REQ_get_exception_status, /* 84*/
    REQ_output_debug_string, /* 85*/
    REQ_continue_debug_event, /* 86*/
    REQ_debug_process, /* 87*/
    REQ_debug_break, /* 88*/
    REQ_set_debugger_kill_on_exit, /* 89*/
    REQ_read_process_memory, /* 90*/
    REQ_write_process_memory, /* 91*/
    REQ_create_key, /* 92*/
    REQ_open_key, /* 93*/
    REQ_delete_key, /* 94*/
    REQ_enum_key, /* 95*/
    REQ_set_key_value, /* 96*/
    REQ_get_key_value, /* 97*/
    REQ_enum_key_value, /* 98*/
    REQ_delete_key_value, /* 99*/
    REQ_load_registry, /* 100*/
    REQ_save_registry, /* 101*/
    REQ_save_registry_atexit, /* 102*/
    REQ_set_registry_levels, /* 103*/
    REQ_create_timer, /* 104*/
    REQ_open_timer, /* 105*/
    REQ_set_timer, /* 106*/
    REQ_cancel_timer, /* 107*/
    REQ_get_thread_context, /* 108*/
    REQ_set_thread_context, /* 109*/
    REQ_get_selector_entry, /* 110*/
    REQ_add_atom, /* 111*/
    REQ_delete_atom, /* 112*/
    REQ_find_atom, /* 113*/
    REQ_get_atom_name, /* 114*/
    REQ_init_atom_table, /* 115*/
    REQ_get_msg_queue, /* 116*/
    REQ_set_queue_mask, /* 117*/
    REQ_get_queue_status, /* 118*/
    REQ_wait_input_idle, /* 119*/
    REQ_send_message, /* 120*/
    REQ_get_message, /* 121*/
    REQ_reply_message, /* 122*/
    REQ_get_message_reply, /* 123*/
    REQ_set_win_timer, /* 124*/
    REQ_kill_win_timer, /* 125*/
    REQ_create_serial, /* 126*/
    REQ_get_serial_info, /* 127*/
    REQ_set_serial_info, /* 128*/
    REQ_register_async, /* 129*/
    REQ_create_named_pipe, /* 130*/
    REQ_open_named_pipe, /* 131*/
    REQ_connect_named_pipe, /* 132*/
    REQ_wait_named_pipe, /* 133*/
    REQ_disconnect_named_pipe, /* 134*/
    REQ_get_named_pipe_info, /* 135*/
    REQ_create_window, /* 136*/
    REQ_link_window, /* 137*/
    REQ_destroy_window, /* 138*/
    REQ_set_window_owner, /* 139*/
    REQ_get_window_info, /* 140*/
    REQ_set_window_info, /* 141*/
    REQ_get_window_parents, /* 142*/
    REQ_get_window_children, /* 143*/
    REQ_get_window_tree, /* 144*/
    REQ_set_window_rectangles, /* 145*/
    REQ_get_window_rectangles, /* 146*/
    REQ_get_window_text, /* 147*/
    REQ_set_window_text, /* 148*/
    REQ_inc_window_paint_count, /* 149*/
    REQ_get_windows_offset, /* 150*/
    REQ_set_window_property, /* 151*/
    REQ_remove_window_property, /* 152*/
    REQ_get_window_property, /* 153*/
    REQ_get_window_properties, /* 154*/
    REQ_enable_trace, /* 155*/
    REQ_register_rpc_endpoints, /* 156*/
    REQ_unregister_rpc_endpoints, /* 157*/
    REQ_resolve_rpc_endpoint, /* 158*/
    REQ_update_thread_tid, /* 159*/
    REQ_get_cdrom_eject_fd_count, /* 160*/
    REQ_get_cdrom_eject_fd_list, /* 161*/
    REQ_add_cdrom_device_info, /* 162*/
    REQ_open_token, /* 163*/
    REQ_NB_REQUESTS
};

union generic_request
{
    struct request_max_size max_size;
    struct request_header request_header;
    struct new_process_request new_process_request;
    struct get_new_process_info_request get_new_process_info_request;
    struct new_thread_request new_thread_request;
    struct boot_done_request boot_done_request;
    struct init_process_request init_process_request;
    struct init_process_done_request init_process_done_request;
    struct init_thread_request init_thread_request;
    struct set_thread_moduleload_request set_thread_moduleload_request;
    struct get_thread_moduleload_request get_thread_moduleload_request;
    struct terminate_process_request terminate_process_request;
    struct terminate_thread_request terminate_thread_request;
    struct get_process_info_request get_process_info_request;
    struct set_process_info_request set_process_info_request;
    struct get_thread_info_request get_thread_info_request;
    struct set_thread_info_request set_thread_info_request;
    struct suspend_thread_request suspend_thread_request;
    struct resume_thread_request resume_thread_request;
    struct load_dll_request load_dll_request;
    struct unload_dll_request unload_dll_request;
    struct queue_apc_request queue_apc_request;
    struct get_apc_request get_apc_request;
    struct close_handle_request close_handle_request;
    struct set_handle_info_request set_handle_info_request;
    struct dup_handle_request dup_handle_request;
    struct open_process_request open_process_request;
    struct open_thread_request open_thread_request;
    struct select_request select_request;
    struct shm_select_request shm_select_request;
    struct create_event_request create_event_request;
    struct event_op_request event_op_request;
    struct open_event_request open_event_request;
    struct create_mutex_request create_mutex_request;
    struct release_mutex_request release_mutex_request;
    struct open_mutex_request open_mutex_request;
    struct create_semaphore_request create_semaphore_request;
    struct release_semaphore_request release_semaphore_request;
    struct open_semaphore_request open_semaphore_request;
    struct create_file_request create_file_request;
    struct alloc_file_handle_request alloc_file_handle_request;
    struct get_handle_fd_request get_handle_fd_request;
    struct set_file_pointer_request set_file_pointer_request;
    struct truncate_file_request truncate_file_request;
    struct set_file_time_request set_file_time_request;
    struct flush_file_request flush_file_request;
    struct get_file_info_request get_file_info_request;
    struct lock_file_request lock_file_request;
    struct unlock_file_request unlock_file_request;
    struct create_socket_request create_socket_request;
    struct accept_socket_request accept_socket_request;
    struct set_socket_event_request set_socket_event_request;
    struct get_socket_event_request get_socket_event_request;
    struct enable_socket_event_request enable_socket_event_request;
    struct set_socket_deferred_request set_socket_deferred_request;
    struct alloc_console_request alloc_console_request;
    struct free_console_request free_console_request;
    struct get_console_renderer_events_request get_console_renderer_events_request;
    struct open_console_request open_console_request;
    struct get_console_mode_request get_console_mode_request;
    struct set_console_mode_request set_console_mode_request;
    struct set_console_input_info_request set_console_input_info_request;
    struct get_console_input_info_request get_console_input_info_request;
    struct append_console_input_history_request append_console_input_history_request;
    struct get_console_input_history_request get_console_input_history_request;
    struct create_console_output_request create_console_output_request;
    struct set_console_output_info_request set_console_output_info_request;
    struct get_console_output_info_request get_console_output_info_request;
    struct write_console_input_request write_console_input_request;
    struct read_console_input_request read_console_input_request;
    struct write_console_output_request write_console_output_request;
    struct fill_console_output_request fill_console_output_request;
    struct read_console_output_request read_console_output_request;
    struct move_console_output_request move_console_output_request;
    struct send_console_signal_request send_console_signal_request;
    struct create_change_notification_request create_change_notification_request;
    struct create_mapping_request create_mapping_request;
    struct open_mapping_request open_mapping_request;
    struct get_mapping_info_request get_mapping_info_request;
    struct create_device_request create_device_request;
    struct create_snapshot_request create_snapshot_request;
    struct next_process_request next_process_request;
    struct next_thread_request next_thread_request;
    struct next_module_request next_module_request;
    struct wait_debug_event_request wait_debug_event_request;
    struct queue_exception_event_request queue_exception_event_request;
    struct get_exception_status_request get_exception_status_request;
    struct output_debug_string_request output_debug_string_request;
    struct continue_debug_event_request continue_debug_event_request;
    struct debug_process_request debug_process_request;
    struct debug_break_request debug_break_request;
    struct set_debugger_kill_on_exit_request set_debugger_kill_on_exit_request;
    struct read_process_memory_request read_process_memory_request;
    struct write_process_memory_request write_process_memory_request;
    struct create_key_request create_key_request;
    struct open_key_request open_key_request;
    struct delete_key_request delete_key_request;
    struct enum_key_request enum_key_request;
    struct set_key_value_request set_key_value_request;
    struct get_key_value_request get_key_value_request;
    struct enum_key_value_request enum_key_value_request;
    struct delete_key_value_request delete_key_value_request;
    struct load_registry_request load_registry_request;
    struct save_registry_request save_registry_request;
    struct save_registry_atexit_request save_registry_atexit_request;
    struct set_registry_levels_request set_registry_levels_request;
    struct create_timer_request create_timer_request;
    struct open_timer_request open_timer_request;
    struct set_timer_request set_timer_request;
    struct cancel_timer_request cancel_timer_request;
    struct get_thread_context_request get_thread_context_request;
    struct set_thread_context_request set_thread_context_request;
    struct get_selector_entry_request get_selector_entry_request;
    struct add_atom_request add_atom_request;
    struct delete_atom_request delete_atom_request;
    struct find_atom_request find_atom_request;
    struct get_atom_name_request get_atom_name_request;
    struct init_atom_table_request init_atom_table_request;
    struct get_msg_queue_request get_msg_queue_request;
    struct set_queue_mask_request set_queue_mask_request;
    struct get_queue_status_request get_queue_status_request;
    struct wait_input_idle_request wait_input_idle_request;
    struct send_message_request send_message_request;
    struct get_message_request get_message_request;
    struct reply_message_request reply_message_request;
    struct get_message_reply_request get_message_reply_request;
    struct set_win_timer_request set_win_timer_request;
    struct kill_win_timer_request kill_win_timer_request;
    struct create_serial_request create_serial_request;
    struct get_serial_info_request get_serial_info_request;
    struct set_serial_info_request set_serial_info_request;
    struct register_async_request register_async_request;
    struct create_named_pipe_request create_named_pipe_request;
    struct open_named_pipe_request open_named_pipe_request;
    struct connect_named_pipe_request connect_named_pipe_request;
    struct wait_named_pipe_request wait_named_pipe_request;
    struct disconnect_named_pipe_request disconnect_named_pipe_request;
    struct get_named_pipe_info_request get_named_pipe_info_request;
    struct create_window_request create_window_request;
    struct link_window_request link_window_request;
    struct destroy_window_request destroy_window_request;
    struct set_window_owner_request set_window_owner_request;
    struct get_window_info_request get_window_info_request;
    struct set_window_info_request set_window_info_request;
    struct get_window_parents_request get_window_parents_request;
    struct get_window_children_request get_window_children_request;
    struct get_window_tree_request get_window_tree_request;
    struct set_window_rectangles_request set_window_rectangles_request;
    struct get_window_rectangles_request get_window_rectangles_request;
    struct get_window_text_request get_window_text_request;
    struct set_window_text_request set_window_text_request;
    struct inc_window_paint_count_request inc_window_paint_count_request;
    struct get_windows_offset_request get_windows_offset_request;
    struct set_window_property_request set_window_property_request;
    struct remove_window_property_request remove_window_property_request;
    struct get_window_property_request get_window_property_request;
    struct get_window_properties_request get_window_properties_request;
    struct enable_trace_request enable_trace_request;
    struct register_rpc_endpoints_request register_rpc_endpoints_request;
    struct unregister_rpc_endpoints_request unregister_rpc_endpoints_request;
    struct resolve_rpc_endpoint_request resolve_rpc_endpoint_request;
    struct update_thread_tid_request update_thread_tid_request;
    struct get_cdrom_eject_fd_count_request get_cdrom_eject_fd_count_request;
    struct get_cdrom_eject_fd_list_request get_cdrom_eject_fd_list_request;
    struct add_cdrom_device_info_request add_cdrom_device_info_request;
    struct open_token_request open_token_request;
};
union generic_reply
{
    struct request_max_size max_size;
    struct reply_header reply_header;
    struct new_process_reply new_process_reply;
    struct get_new_process_info_reply get_new_process_info_reply;
    struct new_thread_reply new_thread_reply;
    struct boot_done_reply boot_done_reply;
    struct init_process_reply init_process_reply;
    struct init_process_done_reply init_process_done_reply;
    struct init_thread_reply init_thread_reply;
    struct set_thread_moduleload_reply set_thread_moduleload_reply;
    struct get_thread_moduleload_reply get_thread_moduleload_reply;
    struct terminate_process_reply terminate_process_reply;
    struct terminate_thread_reply terminate_thread_reply;
    struct get_process_info_reply get_process_info_reply;
    struct set_process_info_reply set_process_info_reply;
    struct get_thread_info_reply get_thread_info_reply;
    struct set_thread_info_reply set_thread_info_reply;
    struct suspend_thread_reply suspend_thread_reply;
    struct resume_thread_reply resume_thread_reply;
    struct load_dll_reply load_dll_reply;
    struct unload_dll_reply unload_dll_reply;
    struct queue_apc_reply queue_apc_reply;
    struct get_apc_reply get_apc_reply;
    struct close_handle_reply close_handle_reply;
    struct set_handle_info_reply set_handle_info_reply;
    struct dup_handle_reply dup_handle_reply;
    struct open_process_reply open_process_reply;
    struct open_thread_reply open_thread_reply;
    struct select_reply select_reply;
    struct shm_select_reply shm_select_reply;
    struct create_event_reply create_event_reply;
    struct event_op_reply event_op_reply;
    struct open_event_reply open_event_reply;
    struct create_mutex_reply create_mutex_reply;
    struct release_mutex_reply release_mutex_reply;
    struct open_mutex_reply open_mutex_reply;
    struct create_semaphore_reply create_semaphore_reply;
    struct release_semaphore_reply release_semaphore_reply;
    struct open_semaphore_reply open_semaphore_reply;
    struct create_file_reply create_file_reply;
    struct alloc_file_handle_reply alloc_file_handle_reply;
    struct get_handle_fd_reply get_handle_fd_reply;
    struct set_file_pointer_reply set_file_pointer_reply;
    struct truncate_file_reply truncate_file_reply;
    struct set_file_time_reply set_file_time_reply;
    struct flush_file_reply flush_file_reply;
    struct get_file_info_reply get_file_info_reply;
    struct lock_file_reply lock_file_reply;
    struct unlock_file_reply unlock_file_reply;
    struct create_socket_reply create_socket_reply;
    struct accept_socket_reply accept_socket_reply;
    struct set_socket_event_reply set_socket_event_reply;
    struct get_socket_event_reply get_socket_event_reply;
    struct enable_socket_event_reply enable_socket_event_reply;
    struct set_socket_deferred_reply set_socket_deferred_reply;
    struct alloc_console_reply alloc_console_reply;
    struct free_console_reply free_console_reply;
    struct get_console_renderer_events_reply get_console_renderer_events_reply;
    struct open_console_reply open_console_reply;
    struct get_console_mode_reply get_console_mode_reply;
    struct set_console_mode_reply set_console_mode_reply;
    struct set_console_input_info_reply set_console_input_info_reply;
    struct get_console_input_info_reply get_console_input_info_reply;
    struct append_console_input_history_reply append_console_input_history_reply;
    struct get_console_input_history_reply get_console_input_history_reply;
    struct create_console_output_reply create_console_output_reply;
    struct set_console_output_info_reply set_console_output_info_reply;
    struct get_console_output_info_reply get_console_output_info_reply;
    struct write_console_input_reply write_console_input_reply;
    struct read_console_input_reply read_console_input_reply;
    struct write_console_output_reply write_console_output_reply;
    struct fill_console_output_reply fill_console_output_reply;
    struct read_console_output_reply read_console_output_reply;
    struct move_console_output_reply move_console_output_reply;
    struct send_console_signal_reply send_console_signal_reply;
    struct create_change_notification_reply create_change_notification_reply;
    struct create_mapping_reply create_mapping_reply;
    struct open_mapping_reply open_mapping_reply;
    struct get_mapping_info_reply get_mapping_info_reply;
    struct create_device_reply create_device_reply;
    struct create_snapshot_reply create_snapshot_reply;
    struct next_process_reply next_process_reply;
    struct next_thread_reply next_thread_reply;
    struct next_module_reply next_module_reply;
    struct wait_debug_event_reply wait_debug_event_reply;
    struct queue_exception_event_reply queue_exception_event_reply;
    struct get_exception_status_reply get_exception_status_reply;
    struct output_debug_string_reply output_debug_string_reply;
    struct continue_debug_event_reply continue_debug_event_reply;
    struct debug_process_reply debug_process_reply;
    struct debug_break_reply debug_break_reply;
    struct set_debugger_kill_on_exit_reply set_debugger_kill_on_exit_reply;
    struct read_process_memory_reply read_process_memory_reply;
    struct write_process_memory_reply write_process_memory_reply;
    struct create_key_reply create_key_reply;
    struct open_key_reply open_key_reply;
    struct delete_key_reply delete_key_reply;
    struct enum_key_reply enum_key_reply;
    struct set_key_value_reply set_key_value_reply;
    struct get_key_value_reply get_key_value_reply;
    struct enum_key_value_reply enum_key_value_reply;
    struct delete_key_value_reply delete_key_value_reply;
    struct load_registry_reply load_registry_reply;
    struct save_registry_reply save_registry_reply;
    struct save_registry_atexit_reply save_registry_atexit_reply;
    struct set_registry_levels_reply set_registry_levels_reply;
    struct create_timer_reply create_timer_reply;
    struct open_timer_reply open_timer_reply;
    struct set_timer_reply set_timer_reply;
    struct cancel_timer_reply cancel_timer_reply;
    struct get_thread_context_reply get_thread_context_reply;
    struct set_thread_context_reply set_thread_context_reply;
    struct get_selector_entry_reply get_selector_entry_reply;
    struct add_atom_reply add_atom_reply;
    struct delete_atom_reply delete_atom_reply;
    struct find_atom_reply find_atom_reply;
    struct get_atom_name_reply get_atom_name_reply;
    struct init_atom_table_reply init_atom_table_reply;
    struct get_msg_queue_reply get_msg_queue_reply;
    struct set_queue_mask_reply set_queue_mask_reply;
    struct get_queue_status_reply get_queue_status_reply;
    struct wait_input_idle_reply wait_input_idle_reply;
    struct send_message_reply send_message_reply;
    struct get_message_reply get_message_reply;
    struct reply_message_reply reply_message_reply;
    struct get_message_reply_reply get_message_reply_reply;
    struct set_win_timer_reply set_win_timer_reply;
    struct kill_win_timer_reply kill_win_timer_reply;
    struct create_serial_reply create_serial_reply;
    struct get_serial_info_reply get_serial_info_reply;
    struct set_serial_info_reply set_serial_info_reply;
    struct register_async_reply register_async_reply;
    struct create_named_pipe_reply create_named_pipe_reply;
    struct open_named_pipe_reply open_named_pipe_reply;
    struct connect_named_pipe_reply connect_named_pipe_reply;
    struct wait_named_pipe_reply wait_named_pipe_reply;
    struct disconnect_named_pipe_reply disconnect_named_pipe_reply;
    struct get_named_pipe_info_reply get_named_pipe_info_reply;
    struct create_window_reply create_window_reply;
    struct link_window_reply link_window_reply;
    struct destroy_window_reply destroy_window_reply;
    struct set_window_owner_reply set_window_owner_reply;
    struct get_window_info_reply get_window_info_reply;
    struct set_window_info_reply set_window_info_reply;
    struct get_window_parents_reply get_window_parents_reply;
    struct get_window_children_reply get_window_children_reply;
    struct get_window_tree_reply get_window_tree_reply;
    struct set_window_rectangles_reply set_window_rectangles_reply;
    struct get_window_rectangles_reply get_window_rectangles_reply;
    struct get_window_text_reply get_window_text_reply;
    struct set_window_text_reply set_window_text_reply;
    struct inc_window_paint_count_reply inc_window_paint_count_reply;
    struct get_windows_offset_reply get_windows_offset_reply;
    struct set_window_property_reply set_window_property_reply;
    struct remove_window_property_reply remove_window_property_reply;
    struct get_window_property_reply get_window_property_reply;
    struct get_window_properties_reply get_window_properties_reply;
    struct enable_trace_reply enable_trace_reply;
    struct register_rpc_endpoints_reply register_rpc_endpoints_reply;
    struct unregister_rpc_endpoints_reply unregister_rpc_endpoints_reply;
    struct resolve_rpc_endpoint_reply resolve_rpc_endpoint_reply;
    struct update_thread_tid_reply update_thread_tid_reply;
    struct get_cdrom_eject_fd_count_reply get_cdrom_eject_fd_count_reply;
    struct get_cdrom_eject_fd_list_reply get_cdrom_eject_fd_list_reply;
    struct add_cdrom_device_info_reply add_cdrom_device_info_reply;
    struct open_token_reply open_token_reply;
};

#define SERVER_PROTOCOL_VERSION 94

#endif /* __WINE_WINE_SERVER_PROTOCOL_H */
