From 3044d734b1cd84746cc57ace8b79a156ea9391b1 Mon Sep 17 00:00:00 2001 From: Alexandre Julliard Date: Tue, 20 Apr 2010 21:25:38 +0200 Subject: [PATCH] server: Fix structure padding for requests that have a reply. --- include/wine/server_protocol.h | 65 +++++++++++- server/request.h | 174 +++++++++++++++++++++++++++++++++ tools/make_requests | 22 +++-- 3 files changed, 254 insertions(+), 7 deletions(-) diff --git a/include/wine/server_protocol.h b/include/wine/server_protocol.h index edb2d9decdb..83c55db41ec 100644 --- a/include/wine/server_protocol.h +++ b/include/wine/server_protocol.h @@ -612,6 +612,7 @@ struct new_thread_request unsigned int attributes; int suspend; int request_fd; + char __pad_28[4]; }; struct new_thread_reply { @@ -625,6 +626,7 @@ struct new_thread_reply struct get_startup_info_request { struct request_header __header; + char __pad_12[4]; }; struct get_startup_info_reply { @@ -663,6 +665,7 @@ struct init_thread_request int reply_fd; int wait_fd; cpu_type_t cpu; + char __pad_52[4]; }; struct init_thread_reply { @@ -683,6 +686,7 @@ struct terminate_process_request struct request_header __header; obj_handle_t handle; int exit_code; + char __pad_20[4]; }; struct terminate_process_reply { @@ -698,6 +702,7 @@ struct terminate_thread_request struct request_header __header; obj_handle_t handle; int exit_code; + char __pad_20[4]; }; struct terminate_thread_reply { @@ -752,6 +757,7 @@ struct get_thread_info_request struct request_header __header; obj_handle_t handle; thread_id_t tid_in; + char __pad_20[4]; }; struct get_thread_info_reply { @@ -932,6 +938,7 @@ struct dup_handle_request unsigned int access; unsigned int attributes; unsigned int options; + char __pad_36[4]; }; struct dup_handle_reply { @@ -1012,6 +1019,7 @@ struct create_event_request int manual_reset; int initial_state; /* VARARG(objattr,object_attributes); */ + char __pad_28[4]; }; struct create_event_reply { @@ -1109,6 +1117,7 @@ struct create_semaphore_request unsigned int initial; unsigned int max; /* VARARG(objattr,object_attributes); */ + char __pad_28[4]; }; struct create_semaphore_reply { @@ -1124,6 +1133,7 @@ struct release_semaphore_request struct request_header __header; obj_handle_t handle; unsigned int count; + char __pad_20[4]; }; struct release_semaphore_reply { @@ -1162,6 +1172,7 @@ struct create_file_request unsigned int attrs; /* VARARG(objattr,object_attributes); */ /* VARARG(filename,string); */ + char __pad_36[4]; }; struct create_file_reply { @@ -1306,6 +1317,7 @@ struct create_socket_request int type; int protocol; unsigned int flags; + char __pad_36[4]; }; struct create_socket_reply { @@ -1487,6 +1499,7 @@ struct open_console_request unsigned int access; unsigned int attributes; int share; + char __pad_28[4]; }; struct open_console_reply { @@ -1500,6 +1513,7 @@ struct open_console_reply struct get_console_wait_event_request { struct request_header __header; + char __pad_12[4]; }; struct get_console_wait_event_reply { @@ -1605,6 +1619,7 @@ struct get_console_input_history_request struct request_header __header; obj_handle_t handle; int index; + char __pad_20[4]; }; struct get_console_input_history_reply { @@ -1623,6 +1638,7 @@ struct create_console_output_request unsigned int access; unsigned int attributes; unsigned int share; + char __pad_28[4]; }; struct create_console_output_reply { @@ -1711,6 +1727,7 @@ struct read_console_input_request struct request_header __header; obj_handle_t handle; int flush; + char __pad_20[4]; }; struct read_console_input_reply { @@ -1860,6 +1877,7 @@ struct create_mapping_request mem_size_t size; obj_handle_t file_handle; /* VARARG(objattr,object_attributes); */ + char __pad_36[4]; }; struct create_mapping_reply { @@ -1906,6 +1924,7 @@ struct get_mapping_info_request struct request_header __header; obj_handle_t handle; unsigned int access; + char __pad_20[4]; }; struct get_mapping_info_reply { @@ -1957,6 +1976,7 @@ struct create_snapshot_request struct request_header __header; unsigned int attributes; unsigned int flags; + char __pad_20[4]; }; struct create_snapshot_reply { @@ -1972,6 +1992,7 @@ struct next_process_request struct request_header __header; obj_handle_t handle; int reset; + char __pad_20[4]; }; struct next_process_reply { @@ -1992,6 +2013,7 @@ struct next_thread_request struct request_header __header; obj_handle_t handle; int reset; + char __pad_20[4]; }; struct next_thread_reply { @@ -2034,6 +2056,7 @@ struct queue_exception_event_request data_size_t len; /* VARARG(params,uints64,len); */ /* VARARG(context,context); */ + char __pad_44[4]; }; struct queue_exception_event_reply { @@ -2367,6 +2390,7 @@ struct create_timer_request obj_handle_t rootdir; int manual; /* VARARG(name,unicode_str); */ + char __pad_28[4]; }; struct create_timer_reply { @@ -2401,6 +2425,7 @@ struct set_timer_request client_ptr_t callback; client_ptr_t arg; int period; + char __pad_44[4]; }; struct set_timer_reply { @@ -2461,6 +2486,7 @@ struct set_thread_context_request obj_handle_t handle; int suspend; /* VARARG(context,context); */ + char __pad_20[4]; }; struct set_thread_context_reply { @@ -2476,6 +2502,7 @@ struct get_selector_entry_request struct request_header __header; obj_handle_t handle; int entry; + char __pad_20[4]; }; struct get_selector_entry_reply { @@ -2537,6 +2564,7 @@ struct get_atom_information_request struct request_header __header; obj_handle_t table; atom_t atom; + char __pad_20[4]; }; struct get_atom_information_reply { @@ -2595,6 +2623,7 @@ struct init_atom_table_reply struct get_msg_queue_request { struct request_header __header; + char __pad_12[4]; }; struct get_msg_queue_reply { @@ -2921,6 +2950,7 @@ struct ioctl_request async_data_t async; int blocking; /* VARARG(in_data,bytes); */ + char __pad_60[4]; }; struct ioctl_reply { @@ -2959,6 +2989,7 @@ struct create_named_pipe_request timeout_t timeout; unsigned int flags; /* VARARG(name,unicode_str); */ + char __pad_52[4]; }; struct create_named_pipe_reply { @@ -3044,6 +3075,7 @@ struct set_window_owner_request struct request_header __header; user_handle_t handle; user_handle_t owner; + char __pad_20[4]; }; struct set_window_owner_reply { @@ -3113,6 +3145,7 @@ struct set_parent_request struct request_header __header; user_handle_t handle; user_handle_t parent; + char __pad_20[4]; }; struct set_parent_reply { @@ -3146,6 +3179,7 @@ struct get_window_children_request atom_t atom; thread_id_t tid; /* VARARG(class,unicode_str); */ + char __pad_28[4]; }; struct get_window_children_reply { @@ -3258,6 +3292,7 @@ struct get_windows_offset_request struct request_header __header; user_handle_t from; user_handle_t to; + char __pad_20[4]; }; struct get_windows_offset_reply { @@ -3273,6 +3308,7 @@ struct get_visible_region_request struct request_header __header; user_handle_t window; unsigned int flags; + char __pad_20[4]; }; struct get_visible_region_reply { @@ -3393,6 +3429,7 @@ struct remove_window_property_request user_handle_t window; atom_t atom; /* VARARG(name,unicode_str); */ + char __pad_20[4]; }; struct remove_window_property_reply { @@ -3408,6 +3445,7 @@ struct get_window_property_request user_handle_t window; atom_t atom; /* VARARG(name,unicode_str); */ + char __pad_20[4]; }; struct get_window_property_reply { @@ -3455,6 +3493,7 @@ struct open_winstation_request unsigned int access; unsigned int attributes; /* VARARG(name,unicode_str); */ + char __pad_20[4]; }; struct open_winstation_reply { @@ -3480,6 +3519,7 @@ struct close_winstation_reply struct get_process_winstation_request { struct request_header __header; + char __pad_12[4]; }; struct get_process_winstation_reply { @@ -3542,6 +3582,7 @@ struct open_desktop_request unsigned int access; unsigned int attributes; /* VARARG(name,unicode_str); */ + char __pad_28[4]; }; struct open_desktop_reply { @@ -3595,6 +3636,7 @@ struct enum_desktop_request struct request_header __header; obj_handle_t winstation; unsigned int index; + char __pad_20[4]; }; struct enum_desktop_reply { @@ -3662,6 +3704,7 @@ struct get_thread_input_reply struct get_last_input_time_request { struct request_header __header; + char __pad_12[4]; }; struct get_last_input_time_reply { @@ -3677,6 +3720,7 @@ struct get_key_state_request struct request_header __header; thread_id_t tid; int key; + char __pad_20[4]; }; struct get_key_state_reply { @@ -3745,6 +3789,7 @@ struct set_capture_window_request struct request_header __header; user_handle_t handle; unsigned int flags; + char __pad_20[4]; }; struct set_capture_window_reply { @@ -3785,6 +3830,7 @@ struct set_caret_info_request int y; int hide; int state; + char __pad_36[4]; }; struct set_caret_info_reply { @@ -3829,6 +3875,7 @@ struct remove_hook_request user_handle_t handle; client_ptr_t proc; int id; + char __pad_28[4]; }; struct remove_hook_reply { @@ -3884,6 +3931,7 @@ struct get_hook_info_request user_handle_t window; int object_id; int child_id; + char __pad_36[4]; }; struct get_hook_info_reply { @@ -4006,6 +4054,7 @@ struct open_token_request unsigned int access; unsigned int attributes; unsigned int flags; + char __pad_28[4]; }; struct open_token_reply { @@ -4077,6 +4126,7 @@ struct check_token_privileges_request obj_handle_t handle; int all_required; /* VARARG(privileges,LUID_AND_ATTRIBUTES); */ + char __pad_20[4]; }; struct check_token_privileges_reply { @@ -4112,6 +4162,7 @@ struct access_check_request unsigned int mapping_execute; unsigned int mapping_all; /* VARARG(sd,security_descriptor); */ + char __pad_36[4]; }; struct access_check_reply { @@ -4128,6 +4179,7 @@ struct get_token_sid_request struct request_header __header; obj_handle_t handle; unsigned int which_sid; + char __pad_20[4]; }; struct get_token_sid_reply { @@ -4192,6 +4244,7 @@ struct get_security_object_request struct request_header __header; obj_handle_t handle; unsigned int security_info; + char __pad_20[4]; }; struct get_security_object_reply { @@ -4211,6 +4264,7 @@ struct create_mailslot_request timeout_t read_timeout; unsigned int max_msgsize; /* VARARG(name,unicode_str); */ + char __pad_36[4]; }; struct create_mailslot_reply { @@ -4227,6 +4281,7 @@ struct set_mailslot_info_request obj_handle_t handle; timeout_t read_timeout; unsigned int flags; + char __pad_28[4]; }; struct set_mailslot_info_reply { @@ -4278,6 +4333,7 @@ struct get_directory_entry_request struct request_header __header; obj_handle_t handle; unsigned int index; + char __pad_20[4]; }; struct get_directory_entry_reply { @@ -4299,6 +4355,7 @@ struct create_symlink_request data_size_t name_len; /* VARARG(name,unicode_str,name_len); */ /* VARARG(target_name,unicode_str); */ + char __pad_28[4]; }; struct create_symlink_reply { @@ -4384,6 +4441,7 @@ struct get_token_impersonation_level_reply struct allocate_locally_unique_id_request { struct request_header __header; + char __pad_12[4]; }; struct allocate_locally_unique_id_reply { @@ -4398,6 +4456,7 @@ struct create_device_manager_request struct request_header __header; unsigned int access; unsigned int attributes; + char __pad_20[4]; }; struct create_device_manager_reply { @@ -4417,6 +4476,7 @@ struct create_device_request client_ptr_t user_ptr; obj_handle_t manager; /* VARARG(name,unicode_str); */ + char __pad_36[4]; }; struct create_device_reply { @@ -4463,6 +4523,7 @@ struct get_next_device_request_reply struct make_process_system_request { struct request_header __header; + char __pad_12[4]; }; struct make_process_system_reply { @@ -4499,6 +4560,7 @@ struct create_completion_request unsigned int concurrent; obj_handle_t rootdir; /* VARARG(filename,string); */ + char __pad_28[4]; }; struct create_completion_reply { @@ -4637,6 +4699,7 @@ struct set_window_layered_info_reply struct alloc_user_handle_request { struct request_header __header; + char __pad_12[4]; }; struct alloc_user_handle_reply { @@ -5418,6 +5481,6 @@ union generic_reply struct set_cursor_reply set_cursor_reply; }; -#define SERVER_PROTOCOL_VERSION 398 +#define SERVER_PROTOCOL_VERSION 399 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */ diff --git a/server/request.h b/server/request.h index 7667264b96d..eb710b9b2f9 100644 --- a/server/request.h +++ b/server/request.h @@ -640,6 +640,7 @@ C_ASSERT( FIELD_OFFSET(struct new_process_request, process_attr) == 32 ); C_ASSERT( FIELD_OFFSET(struct new_process_request, thread_access) == 36 ); C_ASSERT( FIELD_OFFSET(struct new_process_request, thread_attr) == 40 ); C_ASSERT( FIELD_OFFSET(struct new_process_request, info_size) == 44 ); +C_ASSERT( sizeof(struct new_process_request) == 48 ); C_ASSERT( FIELD_OFFSET(struct new_process_reply, info) == 8 ); C_ASSERT( FIELD_OFFSET(struct new_process_reply, pid) == 12 ); C_ASSERT( FIELD_OFFSET(struct new_process_reply, phandle) == 16 ); @@ -647,6 +648,7 @@ C_ASSERT( FIELD_OFFSET(struct new_process_reply, tid) == 20 ); C_ASSERT( FIELD_OFFSET(struct new_process_reply, thandle) == 24 ); C_ASSERT( sizeof(struct new_process_reply) == 32 ); C_ASSERT( FIELD_OFFSET(struct get_new_process_info_request, info) == 12 ); +C_ASSERT( sizeof(struct get_new_process_info_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply, success) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply, exit_code) == 12 ); C_ASSERT( sizeof(struct get_new_process_info_reply) == 16 ); @@ -654,9 +656,11 @@ C_ASSERT( FIELD_OFFSET(struct new_thread_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct new_thread_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct new_thread_request, suspend) == 20 ); C_ASSERT( FIELD_OFFSET(struct new_thread_request, request_fd) == 24 ); +C_ASSERT( sizeof(struct new_thread_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct new_thread_reply, tid) == 8 ); C_ASSERT( FIELD_OFFSET(struct new_thread_reply, handle) == 12 ); C_ASSERT( sizeof(struct new_thread_reply) == 16 ); +C_ASSERT( sizeof(struct get_startup_info_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply, exe_file) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply, info_size) == 12 ); C_ASSERT( sizeof(struct get_startup_info_reply) == 16 ); @@ -673,6 +677,7 @@ C_ASSERT( FIELD_OFFSET(struct init_thread_request, entry) == 32 ); C_ASSERT( FIELD_OFFSET(struct init_thread_request, reply_fd) == 40 ); C_ASSERT( FIELD_OFFSET(struct init_thread_request, wait_fd) == 44 ); C_ASSERT( FIELD_OFFSET(struct init_thread_request, cpu) == 48 ); +C_ASSERT( sizeof(struct init_thread_request) == 56 ); C_ASSERT( FIELD_OFFSET(struct init_thread_reply, pid) == 8 ); C_ASSERT( FIELD_OFFSET(struct init_thread_reply, tid) == 12 ); C_ASSERT( FIELD_OFFSET(struct init_thread_reply, server_start) == 16 ); @@ -682,14 +687,17 @@ C_ASSERT( FIELD_OFFSET(struct init_thread_reply, all_cpus) == 32 ); C_ASSERT( sizeof(struct init_thread_reply) == 40 ); C_ASSERT( FIELD_OFFSET(struct terminate_process_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct terminate_process_request, exit_code) == 16 ); +C_ASSERT( sizeof(struct terminate_process_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct terminate_process_reply, self) == 8 ); C_ASSERT( sizeof(struct terminate_process_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct terminate_thread_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct terminate_thread_request, exit_code) == 16 ); +C_ASSERT( sizeof(struct terminate_thread_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct terminate_thread_reply, self) == 8 ); C_ASSERT( FIELD_OFFSET(struct terminate_thread_reply, last) == 12 ); C_ASSERT( sizeof(struct terminate_thread_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_process_info_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_process_info_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, pid) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, ppid) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, affinity) == 16 ); @@ -708,6 +716,7 @@ C_ASSERT( FIELD_OFFSET(struct set_process_info_request, affinity) == 24 ); C_ASSERT( sizeof(struct set_process_info_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct get_thread_info_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_thread_info_request, tid_in) == 16 ); +C_ASSERT( sizeof(struct get_thread_info_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, pid) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, tid) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, teb) == 16 ); @@ -726,14 +735,17 @@ C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, token) == 32 ); C_ASSERT( sizeof(struct set_thread_info_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct get_dll_info_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_dll_info_request, base_address) == 16 ); +C_ASSERT( sizeof(struct get_dll_info_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply, entry_point) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply, size) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply, filename_len) == 20 ); C_ASSERT( sizeof(struct get_dll_info_reply) == 24 ); C_ASSERT( FIELD_OFFSET(struct suspend_thread_request, handle) == 12 ); +C_ASSERT( sizeof(struct suspend_thread_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct suspend_thread_reply, count) == 8 ); C_ASSERT( sizeof(struct suspend_thread_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct resume_thread_request, handle) == 12 ); +C_ASSERT( sizeof(struct resume_thread_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct resume_thread_reply, count) == 8 ); C_ASSERT( sizeof(struct resume_thread_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct load_dll_request, handle) == 12 ); @@ -747,10 +759,12 @@ C_ASSERT( FIELD_OFFSET(struct unload_dll_request, base) == 16 ); C_ASSERT( sizeof(struct unload_dll_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct queue_apc_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct queue_apc_request, call) == 16 ); +C_ASSERT( sizeof(struct queue_apc_request) == 56 ); C_ASSERT( FIELD_OFFSET(struct queue_apc_reply, handle) == 8 ); C_ASSERT( FIELD_OFFSET(struct queue_apc_reply, self) == 12 ); C_ASSERT( sizeof(struct queue_apc_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_apc_result_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_apc_result_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_apc_result_reply, result) == 8 ); C_ASSERT( sizeof(struct get_apc_result_reply) == 48 ); C_ASSERT( FIELD_OFFSET(struct close_handle_request, handle) == 12 ); @@ -758,6 +772,7 @@ C_ASSERT( sizeof(struct close_handle_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, flags) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, mask) == 20 ); +C_ASSERT( sizeof(struct set_handle_info_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_handle_info_reply, old_flags) == 8 ); C_ASSERT( sizeof(struct set_handle_info_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct dup_handle_request, src_process) == 12 ); @@ -766,6 +781,7 @@ C_ASSERT( FIELD_OFFSET(struct dup_handle_request, dst_process) == 20 ); C_ASSERT( FIELD_OFFSET(struct dup_handle_request, access) == 24 ); C_ASSERT( FIELD_OFFSET(struct dup_handle_request, attributes) == 28 ); C_ASSERT( FIELD_OFFSET(struct dup_handle_request, options) == 32 ); +C_ASSERT( sizeof(struct dup_handle_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, handle) == 8 ); C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, self) == 12 ); C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, closed) == 16 ); @@ -773,11 +789,13 @@ C_ASSERT( sizeof(struct dup_handle_reply) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_process_request, pid) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_process_request, access) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_process_request, attributes) == 20 ); +C_ASSERT( sizeof(struct open_process_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_process_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_process_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_thread_request, tid) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_thread_request, access) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_thread_request, attributes) == 20 ); +C_ASSERT( sizeof(struct open_thread_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_thread_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_thread_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct select_request, flags) == 12 ); @@ -785,6 +803,7 @@ C_ASSERT( FIELD_OFFSET(struct select_request, cookie) == 16 ); C_ASSERT( FIELD_OFFSET(struct select_request, signal) == 24 ); C_ASSERT( FIELD_OFFSET(struct select_request, prev_apc) == 28 ); C_ASSERT( FIELD_OFFSET(struct select_request, timeout) == 32 ); +C_ASSERT( sizeof(struct select_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct select_reply, timeout) == 8 ); C_ASSERT( FIELD_OFFSET(struct select_reply, call) == 16 ); C_ASSERT( FIELD_OFFSET(struct select_reply, apc_handle) == 56 ); @@ -793,6 +812,7 @@ C_ASSERT( FIELD_OFFSET(struct create_event_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_event_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_event_request, manual_reset) == 20 ); C_ASSERT( FIELD_OFFSET(struct create_event_request, initial_state) == 24 ); +C_ASSERT( sizeof(struct create_event_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct create_event_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_event_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct event_op_request, handle) == 12 ); @@ -801,34 +821,41 @@ C_ASSERT( sizeof(struct event_op_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_event_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_event_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_event_request, rootdir) == 20 ); +C_ASSERT( sizeof(struct open_event_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_event_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_event_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_mutex_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_mutex_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_mutex_request, owned) == 20 ); +C_ASSERT( sizeof(struct create_mutex_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_mutex_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_mutex_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct release_mutex_request, handle) == 12 ); +C_ASSERT( sizeof(struct release_mutex_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct release_mutex_reply, prev_count) == 8 ); C_ASSERT( sizeof(struct release_mutex_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_mutex_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_mutex_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_mutex_request, rootdir) == 20 ); +C_ASSERT( sizeof(struct open_mutex_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_mutex_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_mutex_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, initial) == 20 ); C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, max) == 24 ); +C_ASSERT( sizeof(struct create_semaphore_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct create_semaphore_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_semaphore_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct release_semaphore_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct release_semaphore_request, count) == 16 ); +C_ASSERT( sizeof(struct release_semaphore_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct release_semaphore_reply, prev_count) == 8 ); C_ASSERT( sizeof(struct release_semaphore_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, rootdir) == 20 ); +C_ASSERT( sizeof(struct open_semaphore_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_semaphore_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_semaphore_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_file_request, access) == 12 ); @@ -837,6 +864,7 @@ C_ASSERT( FIELD_OFFSET(struct create_file_request, sharing) == 20 ); C_ASSERT( FIELD_OFFSET(struct create_file_request, create) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_file_request, options) == 28 ); C_ASSERT( FIELD_OFFSET(struct create_file_request, attrs) == 32 ); +C_ASSERT( sizeof(struct create_file_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct create_file_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_file_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_file_object_request, access) == 12 ); @@ -844,23 +872,28 @@ C_ASSERT( FIELD_OFFSET(struct open_file_object_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_file_object_request, rootdir) == 20 ); C_ASSERT( FIELD_OFFSET(struct open_file_object_request, sharing) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_file_object_request, options) == 28 ); +C_ASSERT( sizeof(struct open_file_object_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct open_file_object_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_file_object_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, fd) == 20 ); +C_ASSERT( sizeof(struct alloc_file_handle_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_reply, handle) == 8 ); C_ASSERT( sizeof(struct alloc_file_handle_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_handle_unix_name_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_reply, name_len) == 8 ); C_ASSERT( sizeof(struct get_handle_unix_name_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_handle_fd_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_handle_fd_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, type) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, removable) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, access) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, options) == 20 ); C_ASSERT( sizeof(struct get_handle_fd_reply) == 24 ); C_ASSERT( FIELD_OFFSET(struct flush_file_request, handle) == 12 ); +C_ASSERT( sizeof(struct flush_file_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct flush_file_reply, event) == 8 ); C_ASSERT( sizeof(struct flush_file_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct lock_file_request, handle) == 12 ); @@ -868,6 +901,7 @@ C_ASSERT( FIELD_OFFSET(struct lock_file_request, offset) == 16 ); C_ASSERT( FIELD_OFFSET(struct lock_file_request, count) == 24 ); C_ASSERT( FIELD_OFFSET(struct lock_file_request, shared) == 32 ); C_ASSERT( FIELD_OFFSET(struct lock_file_request, wait) == 36 ); +C_ASSERT( sizeof(struct lock_file_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct lock_file_reply, handle) == 8 ); C_ASSERT( FIELD_OFFSET(struct lock_file_reply, overlapped) == 12 ); C_ASSERT( sizeof(struct lock_file_reply) == 16 ); @@ -881,11 +915,13 @@ C_ASSERT( FIELD_OFFSET(struct create_socket_request, family) == 20 ); C_ASSERT( FIELD_OFFSET(struct create_socket_request, type) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_socket_request, protocol) == 28 ); C_ASSERT( FIELD_OFFSET(struct create_socket_request, flags) == 32 ); +C_ASSERT( sizeof(struct create_socket_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct create_socket_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_socket_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct accept_socket_request, lhandle) == 12 ); C_ASSERT( FIELD_OFFSET(struct accept_socket_request, access) == 16 ); C_ASSERT( FIELD_OFFSET(struct accept_socket_request, attributes) == 20 ); +C_ASSERT( sizeof(struct accept_socket_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct accept_socket_reply, handle) == 8 ); C_ASSERT( sizeof(struct accept_socket_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, handle) == 12 ); @@ -897,6 +933,7 @@ C_ASSERT( sizeof(struct set_socket_event_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct get_socket_event_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_socket_event_request, service) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_socket_event_request, c_event) == 20 ); +C_ASSERT( sizeof(struct get_socket_event_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply, mask) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply, pmask) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply, state) == 16 ); @@ -912,21 +949,26 @@ C_ASSERT( sizeof(struct set_socket_deferred_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct alloc_console_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct alloc_console_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct alloc_console_request, pid) == 20 ); +C_ASSERT( sizeof(struct alloc_console_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct alloc_console_reply, handle_in) == 8 ); C_ASSERT( FIELD_OFFSET(struct alloc_console_reply, event) == 12 ); C_ASSERT( sizeof(struct alloc_console_reply) == 16 ); C_ASSERT( sizeof(struct free_console_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_console_renderer_events_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_console_renderer_events_request) == 16 ); C_ASSERT( sizeof(struct get_console_renderer_events_reply) == 8 ); C_ASSERT( FIELD_OFFSET(struct open_console_request, from) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_console_request, access) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_console_request, attributes) == 20 ); C_ASSERT( FIELD_OFFSET(struct open_console_request, share) == 24 ); +C_ASSERT( sizeof(struct open_console_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct open_console_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_console_reply) == 16 ); +C_ASSERT( sizeof(struct get_console_wait_event_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_console_wait_event_reply, handle) == 8 ); C_ASSERT( sizeof(struct get_console_wait_event_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_console_mode_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_console_mode_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_console_mode_reply, mode) == 8 ); C_ASSERT( sizeof(struct get_console_mode_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_console_mode_request, handle) == 12 ); @@ -943,6 +985,7 @@ C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, output_cp) == 40 ) C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, win) == 44 ); C_ASSERT( sizeof(struct set_console_input_info_request) == 48 ); C_ASSERT( FIELD_OFFSET(struct get_console_input_info_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_console_input_info_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, history_mode) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, history_size) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, history_index) == 16 ); @@ -955,12 +998,14 @@ C_ASSERT( FIELD_OFFSET(struct append_console_input_history_request, handle) == 1 C_ASSERT( sizeof(struct append_console_input_history_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_console_input_history_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_console_input_history_request, index) == 16 ); +C_ASSERT( sizeof(struct get_console_input_history_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_console_input_history_reply, total) == 8 ); C_ASSERT( sizeof(struct get_console_input_history_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_console_output_request, handle_in) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_console_output_request, access) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_console_output_request, attributes) == 20 ); C_ASSERT( FIELD_OFFSET(struct create_console_output_request, share) == 24 ); +C_ASSERT( sizeof(struct create_console_output_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct create_console_output_reply, handle_out) == 8 ); C_ASSERT( sizeof(struct create_console_output_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, handle) == 12 ); @@ -980,6 +1025,7 @@ C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, max_width) == 42 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, max_height) == 44 ); C_ASSERT( sizeof(struct set_console_output_info_request) == 48 ); C_ASSERT( FIELD_OFFSET(struct get_console_output_info_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_console_output_info_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_size) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_visible) == 10 ); C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_x) == 12 ); @@ -995,10 +1041,12 @@ C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, max_width) == 30 ); C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, max_height) == 32 ); C_ASSERT( sizeof(struct get_console_output_info_reply) == 40 ); C_ASSERT( FIELD_OFFSET(struct write_console_input_request, handle) == 12 ); +C_ASSERT( sizeof(struct write_console_input_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct write_console_input_reply, written) == 8 ); C_ASSERT( sizeof(struct write_console_input_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct read_console_input_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct read_console_input_request, flush) == 16 ); +C_ASSERT( sizeof(struct read_console_input_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct read_console_input_reply, read) == 8 ); C_ASSERT( sizeof(struct read_console_input_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct write_console_output_request, handle) == 12 ); @@ -1006,6 +1054,7 @@ C_ASSERT( FIELD_OFFSET(struct write_console_output_request, x) == 16 ); C_ASSERT( FIELD_OFFSET(struct write_console_output_request, y) == 20 ); C_ASSERT( FIELD_OFFSET(struct write_console_output_request, mode) == 24 ); C_ASSERT( FIELD_OFFSET(struct write_console_output_request, wrap) == 28 ); +C_ASSERT( sizeof(struct write_console_output_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct write_console_output_reply, written) == 8 ); C_ASSERT( FIELD_OFFSET(struct write_console_output_reply, width) == 12 ); C_ASSERT( FIELD_OFFSET(struct write_console_output_reply, height) == 16 ); @@ -1017,6 +1066,7 @@ C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, mode) == 24 ); C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, count) == 28 ); C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, wrap) == 32 ); C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, data) == 36 ); +C_ASSERT( sizeof(struct fill_console_output_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct fill_console_output_reply, written) == 8 ); C_ASSERT( sizeof(struct fill_console_output_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct read_console_output_request, handle) == 12 ); @@ -1024,6 +1074,7 @@ C_ASSERT( FIELD_OFFSET(struct read_console_output_request, x) == 16 ); C_ASSERT( FIELD_OFFSET(struct read_console_output_request, y) == 20 ); C_ASSERT( FIELD_OFFSET(struct read_console_output_request, mode) == 24 ); C_ASSERT( FIELD_OFFSET(struct read_console_output_request, wrap) == 28 ); +C_ASSERT( sizeof(struct read_console_output_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct read_console_output_reply, width) == 8 ); C_ASSERT( FIELD_OFFSET(struct read_console_output_reply, height) == 12 ); C_ASSERT( sizeof(struct read_console_output_reply) == 16 ); @@ -1044,6 +1095,7 @@ C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, want_data) == 20 ) C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, async) == 24 ); C_ASSERT( sizeof(struct read_directory_changes_request) == 64 ); C_ASSERT( FIELD_OFFSET(struct read_change_request, handle) == 12 ); +C_ASSERT( sizeof(struct read_change_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct read_change_reply, action) == 8 ); C_ASSERT( sizeof(struct read_change_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_mapping_request, access) == 12 ); @@ -1051,15 +1103,18 @@ C_ASSERT( FIELD_OFFSET(struct create_mapping_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_mapping_request, protect) == 20 ); C_ASSERT( FIELD_OFFSET(struct create_mapping_request, size) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_mapping_request, file_handle) == 32 ); +C_ASSERT( sizeof(struct create_mapping_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct create_mapping_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_mapping_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_mapping_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_mapping_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_mapping_request, rootdir) == 20 ); +C_ASSERT( sizeof(struct open_mapping_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_mapping_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_mapping_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request, access) == 16 ); +C_ASSERT( sizeof(struct get_mapping_info_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, size) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, protect) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, header_size) == 20 ); @@ -1069,6 +1124,7 @@ C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, shared_file) == 36 ); C_ASSERT( sizeof(struct get_mapping_info_reply) == 40 ); C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request, offset) == 16 ); +C_ASSERT( sizeof(struct get_mapping_committed_range_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply, size) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply, committed) == 16 ); C_ASSERT( sizeof(struct get_mapping_committed_range_reply) == 24 ); @@ -1078,10 +1134,12 @@ C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, size) == 24 ) C_ASSERT( sizeof(struct add_mapping_committed_range_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct create_snapshot_request, attributes) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_snapshot_request, flags) == 16 ); +C_ASSERT( sizeof(struct create_snapshot_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_snapshot_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_snapshot_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct next_process_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct next_process_request, reset) == 16 ); +C_ASSERT( sizeof(struct next_process_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct next_process_reply, count) == 8 ); C_ASSERT( FIELD_OFFSET(struct next_process_reply, pid) == 12 ); C_ASSERT( FIELD_OFFSET(struct next_process_reply, ppid) == 16 ); @@ -1091,6 +1149,7 @@ C_ASSERT( FIELD_OFFSET(struct next_process_reply, handles) == 28 ); C_ASSERT( sizeof(struct next_process_reply) == 32 ); C_ASSERT( FIELD_OFFSET(struct next_thread_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct next_thread_request, reset) == 16 ); +C_ASSERT( sizeof(struct next_thread_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct next_thread_reply, count) == 8 ); C_ASSERT( FIELD_OFFSET(struct next_thread_reply, pid) == 12 ); C_ASSERT( FIELD_OFFSET(struct next_thread_reply, tid) == 16 ); @@ -1098,6 +1157,7 @@ C_ASSERT( FIELD_OFFSET(struct next_thread_reply, base_pri) == 20 ); C_ASSERT( FIELD_OFFSET(struct next_thread_reply, delta_pri) == 24 ); C_ASSERT( sizeof(struct next_thread_reply) == 32 ); C_ASSERT( FIELD_OFFSET(struct wait_debug_event_request, get_handle) == 12 ); +C_ASSERT( sizeof(struct wait_debug_event_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, pid) == 8 ); C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, tid) == 12 ); C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, wait) == 16 ); @@ -1108,9 +1168,11 @@ C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, flags) == 20 ); C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, record) == 24 ); C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, address) == 32 ); C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, len) == 40 ); +C_ASSERT( sizeof(struct queue_exception_event_request) == 48 ); C_ASSERT( FIELD_OFFSET(struct queue_exception_event_reply, handle) == 8 ); C_ASSERT( sizeof(struct queue_exception_event_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_exception_status_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_exception_status_request) == 16 ); C_ASSERT( sizeof(struct get_exception_status_reply) == 8 ); C_ASSERT( FIELD_OFFSET(struct output_debug_string_request, length) == 12 ); C_ASSERT( FIELD_OFFSET(struct output_debug_string_request, string) == 16 ); @@ -1123,12 +1185,14 @@ C_ASSERT( FIELD_OFFSET(struct debug_process_request, pid) == 12 ); C_ASSERT( FIELD_OFFSET(struct debug_process_request, attach) == 16 ); C_ASSERT( sizeof(struct debug_process_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct debug_break_request, handle) == 12 ); +C_ASSERT( sizeof(struct debug_break_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct debug_break_reply, self) == 8 ); C_ASSERT( sizeof(struct debug_break_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_debugger_kill_on_exit_request, kill_on_exit) == 12 ); C_ASSERT( sizeof(struct set_debugger_kill_on_exit_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct read_process_memory_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct read_process_memory_request, addr) == 16 ); +C_ASSERT( sizeof(struct read_process_memory_request) == 24 ); C_ASSERT( sizeof(struct read_process_memory_reply) == 8 ); C_ASSERT( FIELD_OFFSET(struct write_process_memory_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct write_process_memory_request, addr) == 16 ); @@ -1138,12 +1202,14 @@ C_ASSERT( FIELD_OFFSET(struct create_key_request, access) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_key_request, attributes) == 20 ); C_ASSERT( FIELD_OFFSET(struct create_key_request, options) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_key_request, namelen) == 28 ); +C_ASSERT( sizeof(struct create_key_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct create_key_reply, hkey) == 8 ); C_ASSERT( FIELD_OFFSET(struct create_key_reply, created) == 12 ); C_ASSERT( sizeof(struct create_key_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_key_request, parent) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_key_request, access) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_key_request, attributes) == 20 ); +C_ASSERT( sizeof(struct open_key_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_key_reply, hkey) == 8 ); C_ASSERT( sizeof(struct open_key_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct delete_key_request, hkey) == 12 ); @@ -1153,6 +1219,7 @@ C_ASSERT( sizeof(struct flush_key_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct enum_key_request, hkey) == 12 ); C_ASSERT( FIELD_OFFSET(struct enum_key_request, index) == 16 ); C_ASSERT( FIELD_OFFSET(struct enum_key_request, info_class) == 20 ); +C_ASSERT( sizeof(struct enum_key_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct enum_key_reply, subkeys) == 8 ); C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_subkey) == 12 ); C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_class) == 16 ); @@ -1168,12 +1235,14 @@ C_ASSERT( FIELD_OFFSET(struct set_key_value_request, type) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_key_value_request, namelen) == 20 ); C_ASSERT( sizeof(struct set_key_value_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_key_value_request, hkey) == 12 ); +C_ASSERT( sizeof(struct get_key_value_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_key_value_reply, type) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_key_value_reply, total) == 12 ); C_ASSERT( sizeof(struct get_key_value_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, hkey) == 12 ); C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, index) == 16 ); C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, info_class) == 20 ); +C_ASSERT( sizeof(struct enum_key_value_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, type) == 8 ); C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, total) == 12 ); C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, namelen) == 16 ); @@ -1197,11 +1266,13 @@ C_ASSERT( FIELD_OFFSET(struct create_timer_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_timer_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_timer_request, rootdir) == 20 ); C_ASSERT( FIELD_OFFSET(struct create_timer_request, manual) == 24 ); +C_ASSERT( sizeof(struct create_timer_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct create_timer_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_timer_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_timer_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_timer_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_timer_request, rootdir) == 20 ); +C_ASSERT( sizeof(struct open_timer_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_timer_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_timer_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_timer_request, handle) == 12 ); @@ -1209,41 +1280,50 @@ C_ASSERT( FIELD_OFFSET(struct set_timer_request, expire) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_timer_request, callback) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_timer_request, arg) == 32 ); C_ASSERT( FIELD_OFFSET(struct set_timer_request, period) == 40 ); +C_ASSERT( sizeof(struct set_timer_request) == 48 ); C_ASSERT( FIELD_OFFSET(struct set_timer_reply, signaled) == 8 ); C_ASSERT( sizeof(struct set_timer_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct cancel_timer_request, handle) == 12 ); +C_ASSERT( sizeof(struct cancel_timer_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct cancel_timer_reply, signaled) == 8 ); C_ASSERT( sizeof(struct cancel_timer_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_timer_info_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_timer_info_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply, when) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply, signaled) == 16 ); C_ASSERT( sizeof(struct get_timer_info_reply) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, flags) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, suspend) == 20 ); +C_ASSERT( sizeof(struct get_thread_context_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_thread_context_reply, self) == 8 ); C_ASSERT( sizeof(struct get_thread_context_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_thread_context_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_thread_context_request, suspend) == 16 ); +C_ASSERT( sizeof(struct set_thread_context_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_thread_context_reply, self) == 8 ); C_ASSERT( sizeof(struct set_thread_context_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request, entry) == 16 ); +C_ASSERT( sizeof(struct get_selector_entry_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, base) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, limit) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, flags) == 16 ); C_ASSERT( sizeof(struct get_selector_entry_reply) == 24 ); C_ASSERT( FIELD_OFFSET(struct add_atom_request, table) == 12 ); +C_ASSERT( sizeof(struct add_atom_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct add_atom_reply, atom) == 8 ); C_ASSERT( sizeof(struct add_atom_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct delete_atom_request, table) == 12 ); C_ASSERT( FIELD_OFFSET(struct delete_atom_request, atom) == 16 ); C_ASSERT( sizeof(struct delete_atom_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct find_atom_request, table) == 12 ); +C_ASSERT( sizeof(struct find_atom_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct find_atom_reply, atom) == 8 ); C_ASSERT( sizeof(struct find_atom_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_atom_information_request, table) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_atom_information_request, atom) == 16 ); +C_ASSERT( sizeof(struct get_atom_information_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, count) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, pinned) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, total) == 16 ); @@ -1256,8 +1336,10 @@ C_ASSERT( FIELD_OFFSET(struct empty_atom_table_request, table) == 12 ); C_ASSERT( FIELD_OFFSET(struct empty_atom_table_request, if_pinned) == 16 ); C_ASSERT( sizeof(struct empty_atom_table_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct init_atom_table_request, entries) == 12 ); +C_ASSERT( sizeof(struct init_atom_table_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct init_atom_table_reply, table) == 8 ); C_ASSERT( sizeof(struct init_atom_table_reply) == 16 ); +C_ASSERT( sizeof(struct get_msg_queue_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_msg_queue_reply, handle) == 8 ); C_ASSERT( sizeof(struct get_msg_queue_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_queue_fd_request, handle) == 12 ); @@ -1265,14 +1347,17 @@ C_ASSERT( sizeof(struct set_queue_fd_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, wake_mask) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, changed_mask) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, skip_wait) == 20 ); +C_ASSERT( sizeof(struct set_queue_mask_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply, wake_bits) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply, changed_bits) == 12 ); C_ASSERT( sizeof(struct set_queue_mask_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_queue_status_request, clear) == 12 ); +C_ASSERT( sizeof(struct get_queue_status_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply, wake_bits) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply, changed_bits) == 12 ); C_ASSERT( sizeof(struct get_queue_status_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_process_idle_event_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_reply, event) == 8 ); C_ASSERT( sizeof(struct get_process_idle_event_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct send_message_request, id) == 12 ); @@ -1303,6 +1388,7 @@ C_ASSERT( FIELD_OFFSET(struct get_message_request, get_last) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_message_request, hw_id) == 28 ); C_ASSERT( FIELD_OFFSET(struct get_message_request, wake_mask) == 32 ); C_ASSERT( FIELD_OFFSET(struct get_message_request, changed_mask) == 36 ); +C_ASSERT( sizeof(struct get_message_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct get_message_reply, win) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_message_reply, msg) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_message_reply, wparam) == 16 ); @@ -1320,6 +1406,7 @@ C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request, remove) == 16 ); C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request, new_win) == 20 ); C_ASSERT( sizeof(struct accept_hardware_message_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_message_reply_request, cancel) == 12 ); +C_ASSERT( sizeof(struct get_message_reply_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_message_reply_reply, result) == 8 ); C_ASSERT( sizeof(struct get_message_reply_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, win) == 12 ); @@ -1327,6 +1414,7 @@ C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, msg) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, rate) == 20 ); C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, id) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, lparam) == 32 ); +C_ASSERT( sizeof(struct set_win_timer_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct set_win_timer_reply, id) == 8 ); C_ASSERT( sizeof(struct set_win_timer_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, win) == 12 ); @@ -1334,9 +1422,11 @@ C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, id) == 16 ); C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, msg) == 24 ); C_ASSERT( sizeof(struct kill_win_timer_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct is_window_hung_request, win) == 12 ); +C_ASSERT( sizeof(struct is_window_hung_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct is_window_hung_reply, is_hung) == 8 ); C_ASSERT( sizeof(struct is_window_hung_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_serial_info_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_serial_info_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, readinterval) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, readconst) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, readmult) == 16 ); @@ -1364,11 +1454,13 @@ C_ASSERT( sizeof(struct cancel_async_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct ioctl_request, code) == 12 ); C_ASSERT( FIELD_OFFSET(struct ioctl_request, async) == 16 ); C_ASSERT( FIELD_OFFSET(struct ioctl_request, blocking) == 56 ); +C_ASSERT( sizeof(struct ioctl_request) == 64 ); C_ASSERT( FIELD_OFFSET(struct ioctl_reply, wait) == 8 ); C_ASSERT( FIELD_OFFSET(struct ioctl_reply, options) == 12 ); C_ASSERT( sizeof(struct ioctl_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_ioctl_result_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_ioctl_result_request, user_arg) == 16 ); +C_ASSERT( sizeof(struct get_ioctl_result_request) == 24 ); C_ASSERT( sizeof(struct get_ioctl_result_reply) == 8 ); C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, attributes) == 16 ); @@ -1379,9 +1471,11 @@ C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, outsize) == 32 ); C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, insize) == 36 ); C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, timeout) == 40 ); C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, flags) == 48 ); +C_ASSERT( sizeof(struct create_named_pipe_request) == 56 ); C_ASSERT( FIELD_OFFSET(struct create_named_pipe_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_named_pipe_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_named_pipe_info_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, flags) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, maxinstances) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, instances) == 16 ); @@ -1392,6 +1486,7 @@ C_ASSERT( FIELD_OFFSET(struct create_window_request, parent) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_window_request, owner) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_window_request, atom) == 20 ); C_ASSERT( FIELD_OFFSET(struct create_window_request, instance) == 24 ); +C_ASSERT( sizeof(struct create_window_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct create_window_reply, handle) == 8 ); C_ASSERT( FIELD_OFFSET(struct create_window_reply, parent) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_window_reply, owner) == 16 ); @@ -1401,15 +1496,18 @@ C_ASSERT( sizeof(struct create_window_reply) == 32 ); C_ASSERT( FIELD_OFFSET(struct destroy_window_request, handle) == 12 ); C_ASSERT( sizeof(struct destroy_window_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_desktop_window_request, force) == 12 ); +C_ASSERT( sizeof(struct get_desktop_window_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply, top_window) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply, msg_window) == 12 ); C_ASSERT( sizeof(struct get_desktop_window_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_window_owner_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_window_owner_request, owner) == 16 ); +C_ASSERT( sizeof(struct set_window_owner_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply, full_owner) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply, prev_owner) == 12 ); C_ASSERT( sizeof(struct set_window_owner_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_info_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_window_info_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, full_handle) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, last_active) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, pid) == 16 ); @@ -1428,6 +1526,7 @@ C_ASSERT( FIELD_OFFSET(struct set_window_info_request, user_data) == 40 ); C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_offset) == 48 ); C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_size) == 52 ); C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_value) == 56 ); +C_ASSERT( sizeof(struct set_window_info_request) == 64 ); C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_style) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_ex_style) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_instance) == 16 ); @@ -1437,24 +1536,29 @@ C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_id) == 40 ); C_ASSERT( sizeof(struct set_window_info_reply) == 48 ); C_ASSERT( FIELD_OFFSET(struct set_parent_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_parent_request, parent) == 16 ); +C_ASSERT( sizeof(struct set_parent_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_parent_reply, old_parent) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_parent_reply, full_parent) == 12 ); C_ASSERT( sizeof(struct set_parent_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_parents_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_window_parents_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_parents_reply, count) == 8 ); C_ASSERT( sizeof(struct get_window_parents_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_children_request, desktop) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_window_children_request, parent) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_children_request, atom) == 20 ); C_ASSERT( FIELD_OFFSET(struct get_window_children_request, tid) == 24 ); +C_ASSERT( sizeof(struct get_window_children_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct get_window_children_reply, count) == 8 ); C_ASSERT( sizeof(struct get_window_children_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, parent) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, x) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, y) == 20 ); +C_ASSERT( sizeof(struct get_window_children_from_point_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_reply, count) == 8 ); C_ASSERT( sizeof(struct get_window_children_from_point_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_tree_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_window_tree_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, parent) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, owner) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, next_sibling) == 16 ); @@ -1469,31 +1573,37 @@ C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, handle) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, previous) == 20 ); C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, window) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, client) == 40 ); +C_ASSERT( sizeof(struct set_window_pos_request) == 56 ); C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, new_style) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, new_ex_style) == 12 ); C_ASSERT( sizeof(struct set_window_pos_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_window_rectangles_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, window) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, visible) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, client) == 40 ); C_ASSERT( sizeof(struct get_window_rectangles_reply) == 56 ); C_ASSERT( FIELD_OFFSET(struct get_window_text_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_window_text_request) == 16 ); C_ASSERT( sizeof(struct get_window_text_reply) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_window_text_request, handle) == 12 ); C_ASSERT( sizeof(struct set_window_text_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, from) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, to) == 16 ); +C_ASSERT( sizeof(struct get_windows_offset_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, x) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, y) == 12 ); C_ASSERT( sizeof(struct get_windows_offset_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, window) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, flags) == 16 ); +C_ASSERT( sizeof(struct get_visible_region_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, top_win) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, top_rect) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, win_rect) == 28 ); C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, total_size) == 44 ); C_ASSERT( sizeof(struct get_visible_region_reply) == 48 ); C_ASSERT( FIELD_OFFSET(struct get_window_region_request, window) == 12 ); +C_ASSERT( sizeof(struct get_window_region_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_region_reply, total_size) == 8 ); C_ASSERT( sizeof(struct get_window_region_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_window_region_request, window) == 12 ); @@ -1502,6 +1612,7 @@ C_ASSERT( sizeof(struct set_window_region_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_update_region_request, window) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_update_region_request, from_child) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_update_region_request, flags) == 20 ); +C_ASSERT( sizeof(struct get_update_region_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, child) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, flags) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, total_size) == 16 ); @@ -1518,58 +1629,70 @@ C_ASSERT( FIELD_OFFSET(struct set_window_property_request, atom) == 24 ); C_ASSERT( sizeof(struct set_window_property_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct remove_window_property_request, window) == 12 ); C_ASSERT( FIELD_OFFSET(struct remove_window_property_request, atom) == 16 ); +C_ASSERT( sizeof(struct remove_window_property_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct remove_window_property_reply, data) == 8 ); C_ASSERT( sizeof(struct remove_window_property_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_property_request, window) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_window_property_request, atom) == 16 ); +C_ASSERT( sizeof(struct get_window_property_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_window_property_reply, data) == 8 ); C_ASSERT( sizeof(struct get_window_property_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_properties_request, window) == 12 ); +C_ASSERT( sizeof(struct get_window_properties_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_properties_reply, total) == 8 ); C_ASSERT( sizeof(struct get_window_properties_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_winstation_request, flags) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_winstation_request, access) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_winstation_request, attributes) == 20 ); +C_ASSERT( sizeof(struct create_winstation_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_winstation_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_winstation_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_winstation_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_winstation_request, attributes) == 16 ); +C_ASSERT( sizeof(struct open_winstation_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_winstation_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_winstation_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct close_winstation_request, handle) == 12 ); C_ASSERT( sizeof(struct close_winstation_request) == 16 ); +C_ASSERT( sizeof(struct get_process_winstation_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_process_winstation_reply, handle) == 8 ); C_ASSERT( sizeof(struct get_process_winstation_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_process_winstation_request, handle) == 12 ); C_ASSERT( sizeof(struct set_process_winstation_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct enum_winstation_request, index) == 12 ); +C_ASSERT( sizeof(struct enum_winstation_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct enum_winstation_reply, next) == 8 ); C_ASSERT( sizeof(struct enum_winstation_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_desktop_request, flags) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_desktop_request, access) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_desktop_request, attributes) == 20 ); +C_ASSERT( sizeof(struct create_desktop_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_desktop_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_desktop_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_desktop_request, winsta) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_desktop_request, flags) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_desktop_request, access) == 20 ); C_ASSERT( FIELD_OFFSET(struct open_desktop_request, attributes) == 24 ); +C_ASSERT( sizeof(struct open_desktop_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct open_desktop_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_desktop_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct close_desktop_request, handle) == 12 ); C_ASSERT( sizeof(struct close_desktop_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_request, tid) == 12 ); +C_ASSERT( sizeof(struct get_thread_desktop_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_reply, handle) == 8 ); C_ASSERT( sizeof(struct get_thread_desktop_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_thread_desktop_request, handle) == 12 ); C_ASSERT( sizeof(struct set_thread_desktop_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct enum_desktop_request, winstation) == 12 ); C_ASSERT( FIELD_OFFSET(struct enum_desktop_request, index) == 16 ); +C_ASSERT( sizeof(struct enum_desktop_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct enum_desktop_reply, next) == 8 ); C_ASSERT( sizeof(struct enum_desktop_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, flags) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, obj_flags) == 20 ); +C_ASSERT( sizeof(struct set_user_object_info_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply, is_desktop) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply, old_obj_flags) == 12 ); C_ASSERT( sizeof(struct set_user_object_info_reply) == 16 ); @@ -1578,6 +1701,7 @@ C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, tid_to) == 16 ); C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, attach) == 20 ); C_ASSERT( sizeof(struct attach_thread_input_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_thread_input_request, tid) == 12 ); +C_ASSERT( sizeof(struct get_thread_input_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, focus) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, capture) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, active) == 16 ); @@ -1587,33 +1711,40 @@ C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, move_size) == 28 ); C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, caret) == 32 ); C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, rect) == 36 ); C_ASSERT( sizeof(struct get_thread_input_reply) == 56 ); +C_ASSERT( sizeof(struct get_last_input_time_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_last_input_time_reply, time) == 8 ); C_ASSERT( sizeof(struct get_last_input_time_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_key_state_request, tid) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_key_state_request, key) == 16 ); +C_ASSERT( sizeof(struct get_key_state_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_key_state_reply, state) == 8 ); C_ASSERT( sizeof(struct get_key_state_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_key_state_request, tid) == 12 ); C_ASSERT( sizeof(struct set_key_state_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_foreground_window_request, handle) == 12 ); +C_ASSERT( sizeof(struct set_foreground_window_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, previous) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, send_msg_old) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, send_msg_new) == 16 ); C_ASSERT( sizeof(struct set_foreground_window_reply) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_focus_window_request, handle) == 12 ); +C_ASSERT( sizeof(struct set_focus_window_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_focus_window_reply, previous) == 8 ); C_ASSERT( sizeof(struct set_focus_window_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_active_window_request, handle) == 12 ); +C_ASSERT( sizeof(struct set_active_window_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_active_window_reply, previous) == 8 ); C_ASSERT( sizeof(struct set_active_window_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_capture_window_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_capture_window_request, flags) == 16 ); +C_ASSERT( sizeof(struct set_capture_window_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply, previous) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply, full_handle) == 12 ); C_ASSERT( sizeof(struct set_capture_window_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, width) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, height) == 20 ); +C_ASSERT( sizeof(struct set_caret_window_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, previous) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_rect) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_hide) == 28 ); @@ -1625,6 +1756,7 @@ C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, x) == 20 ); C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, y) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, hide) == 28 ); C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, state) == 32 ); +C_ASSERT( sizeof(struct set_caret_info_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, full_handle) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_rect) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_hide) == 28 ); @@ -1638,12 +1770,14 @@ C_ASSERT( FIELD_OFFSET(struct set_hook_request, event_max) == 28 ); C_ASSERT( FIELD_OFFSET(struct set_hook_request, proc) == 32 ); C_ASSERT( FIELD_OFFSET(struct set_hook_request, flags) == 40 ); C_ASSERT( FIELD_OFFSET(struct set_hook_request, unicode) == 44 ); +C_ASSERT( sizeof(struct set_hook_request) == 48 ); C_ASSERT( FIELD_OFFSET(struct set_hook_reply, handle) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_hook_reply, active_hooks) == 12 ); C_ASSERT( sizeof(struct set_hook_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct remove_hook_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct remove_hook_request, proc) == 16 ); C_ASSERT( FIELD_OFFSET(struct remove_hook_request, id) == 24 ); +C_ASSERT( sizeof(struct remove_hook_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct remove_hook_reply, active_hooks) == 8 ); C_ASSERT( sizeof(struct remove_hook_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, id) == 12 ); @@ -1651,6 +1785,7 @@ C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, event) == 16 ); C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, window) == 20 ); C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, object_id) == 24 ); C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, child_id) == 28 ); +C_ASSERT( sizeof(struct start_hook_chain_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, handle) == 8 ); C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, pid) == 12 ); C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, tid) == 16 ); @@ -1666,6 +1801,7 @@ C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, event) == 20 ); C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, window) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, object_id) == 28 ); C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, child_id) == 32 ); +C_ASSERT( sizeof(struct get_hook_info_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, handle) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, id) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, pid) == 16 ); @@ -1680,10 +1816,12 @@ C_ASSERT( FIELD_OFFSET(struct create_class_request, instance) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_class_request, extra) == 32 ); C_ASSERT( FIELD_OFFSET(struct create_class_request, win_extra) == 36 ); C_ASSERT( FIELD_OFFSET(struct create_class_request, client_ptr) == 40 ); +C_ASSERT( sizeof(struct create_class_request) == 48 ); C_ASSERT( FIELD_OFFSET(struct create_class_reply, atom) == 8 ); C_ASSERT( sizeof(struct create_class_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct destroy_class_request, atom) == 12 ); C_ASSERT( FIELD_OFFSET(struct destroy_class_request, instance) == 16 ); +C_ASSERT( sizeof(struct destroy_class_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct destroy_class_reply, client_ptr) == 8 ); C_ASSERT( sizeof(struct destroy_class_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_class_info_request, window) == 12 ); @@ -1695,6 +1833,7 @@ C_ASSERT( FIELD_OFFSET(struct set_class_info_request, instance) == 32 ); C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_offset) == 40 ); C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_size) == 44 ); C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_value) == 48 ); +C_ASSERT( sizeof(struct set_class_info_request) == 56 ); C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_atom) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_style) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_extra) == 16 ); @@ -1707,6 +1846,7 @@ C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, clipboard) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, owner) == 20 ); C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, viewer) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, seqno) == 28 ); +C_ASSERT( sizeof(struct set_clipboard_info_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply, flags) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply, old_clipboard) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply, old_owner) == 16 ); @@ -1717,6 +1857,7 @@ C_ASSERT( FIELD_OFFSET(struct open_token_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_token_request, access) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_token_request, attributes) == 20 ); C_ASSERT( FIELD_OFFSET(struct open_token_request, flags) == 24 ); +C_ASSERT( sizeof(struct open_token_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct open_token_reply, token) == 8 ); C_ASSERT( sizeof(struct open_token_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, flags) == 12 ); @@ -1724,6 +1865,7 @@ C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, shell_window) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, shell_listview) == 20 ); C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, progman_window) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, taskman_window) == 28 ); +C_ASSERT( sizeof(struct set_global_windows_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_shell_window) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_shell_listview) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_progman_window) == 16 ); @@ -1732,13 +1874,16 @@ C_ASSERT( sizeof(struct set_global_windows_reply) == 24 ); C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, disable_all) == 16 ); C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, get_modified_state) == 20 ); +C_ASSERT( sizeof(struct adjust_token_privileges_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_reply, len) == 8 ); C_ASSERT( sizeof(struct adjust_token_privileges_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_token_privileges_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_token_privileges_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_token_privileges_reply, len) == 8 ); C_ASSERT( sizeof(struct get_token_privileges_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request, all_required) == 16 ); +C_ASSERT( sizeof(struct check_token_privileges_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct check_token_privileges_reply, has_privileges) == 8 ); C_ASSERT( sizeof(struct check_token_privileges_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, handle) == 12 ); @@ -1746,6 +1891,7 @@ C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, access) == 16 ); C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, attributes) == 20 ); C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, primary) == 24 ); C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, impersonation_level) == 28 ); +C_ASSERT( sizeof(struct duplicate_token_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct duplicate_token_reply, new_handle) == 8 ); C_ASSERT( sizeof(struct duplicate_token_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct access_check_request, handle) == 12 ); @@ -1754,18 +1900,22 @@ C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_read) == 20 ); C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_write) == 24 ); C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_execute) == 28 ); C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_all) == 32 ); +C_ASSERT( sizeof(struct access_check_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct access_check_reply, access_granted) == 8 ); C_ASSERT( FIELD_OFFSET(struct access_check_reply, access_status) == 12 ); C_ASSERT( FIELD_OFFSET(struct access_check_reply, privileges_len) == 16 ); C_ASSERT( sizeof(struct access_check_reply) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_token_sid_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_token_sid_request, which_sid) == 16 ); +C_ASSERT( sizeof(struct get_token_sid_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_token_sid_reply, sid_len) == 8 ); C_ASSERT( sizeof(struct get_token_sid_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_token_groups_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_token_groups_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_token_groups_reply, user_len) == 8 ); C_ASSERT( sizeof(struct get_token_groups_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_token_default_dacl_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_reply, acl_len) == 8 ); C_ASSERT( sizeof(struct get_token_default_dacl_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_token_default_dacl_request, handle) == 12 ); @@ -1775,6 +1925,7 @@ C_ASSERT( FIELD_OFFSET(struct set_security_object_request, security_info) == 16 C_ASSERT( sizeof(struct set_security_object_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_security_object_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_security_object_request, security_info) == 16 ); +C_ASSERT( sizeof(struct get_security_object_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_security_object_reply, sd_len) == 8 ); C_ASSERT( sizeof(struct get_security_object_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, access) == 12 ); @@ -1782,42 +1933,51 @@ C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, rootdir) == 20 ); C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, read_timeout) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, max_msgsize) == 32 ); +C_ASSERT( sizeof(struct create_mailslot_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct create_mailslot_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_mailslot_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, read_timeout) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, flags) == 24 ); +C_ASSERT( sizeof(struct set_mailslot_info_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply, read_timeout) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply, max_msgsize) == 16 ); C_ASSERT( sizeof(struct set_mailslot_info_reply) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_directory_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_directory_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_directory_request, rootdir) == 20 ); +C_ASSERT( sizeof(struct create_directory_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_directory_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_directory_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_directory_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_directory_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_directory_request, rootdir) == 20 ); +C_ASSERT( sizeof(struct open_directory_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_directory_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_directory_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request, handle) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request, index) == 16 ); +C_ASSERT( sizeof(struct get_directory_entry_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_directory_entry_reply, name_len) == 8 ); C_ASSERT( sizeof(struct get_directory_entry_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_symlink_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_symlink_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_symlink_request, rootdir) == 20 ); C_ASSERT( FIELD_OFFSET(struct create_symlink_request, name_len) == 24 ); +C_ASSERT( sizeof(struct create_symlink_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct create_symlink_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_symlink_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_symlink_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_symlink_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_symlink_request, rootdir) == 20 ); +C_ASSERT( sizeof(struct open_symlink_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_symlink_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_symlink_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct query_symlink_request, handle) == 12 ); +C_ASSERT( sizeof(struct query_symlink_request) == 16 ); C_ASSERT( sizeof(struct query_symlink_reply) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_object_info_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_object_info_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, access) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, ref_count) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, total) == 16 ); @@ -1825,12 +1985,15 @@ C_ASSERT( sizeof(struct get_object_info_reply) == 24 ); C_ASSERT( FIELD_OFFSET(struct unlink_object_request, handle) == 12 ); C_ASSERT( sizeof(struct unlink_object_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_token_impersonation_level_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_token_impersonation_level_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_token_impersonation_level_reply, impersonation_level) == 8 ); C_ASSERT( sizeof(struct get_token_impersonation_level_reply) == 16 ); +C_ASSERT( sizeof(struct allocate_locally_unique_id_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct allocate_locally_unique_id_reply, luid) == 8 ); C_ASSERT( sizeof(struct allocate_locally_unique_id_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_device_manager_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_device_manager_request, attributes) == 16 ); +C_ASSERT( sizeof(struct create_device_manager_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_device_manager_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_device_manager_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_device_request, access) == 12 ); @@ -1838,6 +2001,7 @@ C_ASSERT( FIELD_OFFSET(struct create_device_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_device_request, rootdir) == 20 ); C_ASSERT( FIELD_OFFSET(struct create_device_request, user_ptr) == 24 ); C_ASSERT( FIELD_OFFSET(struct create_device_request, manager) == 32 ); +C_ASSERT( sizeof(struct create_device_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct create_device_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_device_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct delete_device_request, handle) == 12 ); @@ -1845,15 +2009,18 @@ C_ASSERT( sizeof(struct delete_device_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, manager) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, prev) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, status) == 20 ); +C_ASSERT( sizeof(struct get_next_device_request_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, next) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, code) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, user_ptr) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, in_size) == 24 ); C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, out_size) == 28 ); C_ASSERT( sizeof(struct get_next_device_request_reply) == 32 ); +C_ASSERT( sizeof(struct make_process_system_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct make_process_system_reply, event) == 8 ); C_ASSERT( sizeof(struct make_process_system_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_token_statistics_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_token_statistics_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, token_id) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, modified_id) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, primary) == 24 ); @@ -1865,11 +2032,13 @@ C_ASSERT( FIELD_OFFSET(struct create_completion_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct create_completion_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct create_completion_request, concurrent) == 20 ); C_ASSERT( FIELD_OFFSET(struct create_completion_request, rootdir) == 24 ); +C_ASSERT( sizeof(struct create_completion_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct create_completion_reply, handle) == 8 ); C_ASSERT( sizeof(struct create_completion_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_completion_request, access) == 12 ); C_ASSERT( FIELD_OFFSET(struct open_completion_request, attributes) == 16 ); C_ASSERT( FIELD_OFFSET(struct open_completion_request, rootdir) == 20 ); +C_ASSERT( sizeof(struct open_completion_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct open_completion_reply, handle) == 8 ); C_ASSERT( sizeof(struct open_completion_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct add_completion_request, handle) == 12 ); @@ -1879,12 +2048,14 @@ C_ASSERT( FIELD_OFFSET(struct add_completion_request, information) == 32 ); C_ASSERT( FIELD_OFFSET(struct add_completion_request, status) == 36 ); C_ASSERT( sizeof(struct add_completion_request) == 40 ); C_ASSERT( FIELD_OFFSET(struct remove_completion_request, handle) == 12 ); +C_ASSERT( sizeof(struct remove_completion_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, ckey) == 8 ); C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, cvalue) == 16 ); C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, information) == 24 ); C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, status) == 28 ); C_ASSERT( sizeof(struct remove_completion_reply) == 32 ); C_ASSERT( FIELD_OFFSET(struct query_completion_request, handle) == 12 ); +C_ASSERT( sizeof(struct query_completion_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct query_completion_reply, depth) == 8 ); C_ASSERT( sizeof(struct query_completion_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, handle) == 12 ); @@ -1897,6 +2068,7 @@ C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, status) == 24 ); C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, information) == 28 ); C_ASSERT( sizeof(struct add_fd_completion_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_request, handle) == 12 ); +C_ASSERT( sizeof(struct get_window_layered_info_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, color_key) == 8 ); C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, alpha) == 12 ); C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, flags) == 16 ); @@ -1906,6 +2078,7 @@ C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, color_key) == 16 C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, alpha) == 20 ); C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, flags) == 24 ); C_ASSERT( sizeof(struct set_window_layered_info_request) == 32 ); +C_ASSERT( sizeof(struct alloc_user_handle_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct alloc_user_handle_reply, handle) == 8 ); C_ASSERT( sizeof(struct alloc_user_handle_reply) == 16 ); C_ASSERT( FIELD_OFFSET(struct free_user_handle_request, handle) == 12 ); @@ -1913,6 +2086,7 @@ C_ASSERT( sizeof(struct free_user_handle_request) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_cursor_request, flags) == 12 ); C_ASSERT( FIELD_OFFSET(struct set_cursor_request, handle) == 16 ); C_ASSERT( FIELD_OFFSET(struct set_cursor_request, show_count) == 20 ); +C_ASSERT( sizeof(struct set_cursor_request) == 24 ); C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_handle) == 8 ); C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_count) == 12 ); C_ASSERT( sizeof(struct set_cursor_reply) == 16 ); diff --git a/tools/make_requests b/tools/make_requests index e7a1ffbb586..22be2f72cc2 100755 --- a/tools/make_requests +++ b/tools/make_requests @@ -63,6 +63,18 @@ my $max_req_size = 64; my $warnings = scalar(@ARGV) && $ARGV[0] eq "-w"; +sub add_padding($$) +{ + my ($offset, $padding) = @_; + if ($offset % $padding) + { + my $count = $padding - ($offset % $padding); + print SERVER_PROT " char __pad_$offset\[$count\];\n"; + $offset += $count; + } + return $offset; +} + ### Generate a dumping function sub DO_DUMP_FUNC($$@) @@ -151,6 +163,9 @@ sub PARSE_REQUESTS() if (/^\@REPLY/) { die "Misplaced \@REPLY" unless $state == 2; + $offset = add_padding( $offset, 8 ); # all requests should be 8-byte aligned + die "request $name too large ($offset)" if ($offset > $max_req_size); + push @asserts, "C_ASSERT( sizeof(struct ${name}_request) == $offset );\n"; print SERVER_PROT "};\n"; print SERVER_PROT "struct ${name}_reply\n{\n"; print SERVER_PROT " struct reply_header __header;\n"; @@ -164,12 +179,7 @@ sub PARSE_REQUESTS() { die "Misplaced \@END" unless ($state == 2 || $state == 3); - if ($offset & 7) # all requests should be 8-byte aligned - { - my $count = 8 - ($offset & 7); - print SERVER_PROT " char __pad_$offset\[$count\];\n"; - $offset += $count; - } + $offset = add_padding( $offset, 8 ); # all requests should be 8-byte aligned print SERVER_PROT "};\n"; if ($state == 2) # build dummy reply struct {