Release 1.3.7.
[wine/gsoc-2012-control.git] / server / request.h
blobe0bffaf501c35d808397f247f3225018cc8f7c23
1 /*
2 * Wine server requests
4 * Copyright (C) 1999 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #ifndef __WINE_SERVER_REQUEST_H
22 #define __WINE_SERVER_REQUEST_H
24 #include <assert.h>
26 #include "thread.h"
27 #include "wine/server_protocol.h"
29 /* max request length */
30 #define MAX_REQUEST_LENGTH 8192
32 /* request handler definition */
33 #define DECL_HANDLER(name) \
34 void req_##name( const struct name##_request *req, struct name##_reply *reply )
36 /* request functions */
38 #ifdef __GNUC__
39 extern void fatal_protocol_error( struct thread *thread,
40 const char *err, ... ) __attribute__((format (printf,2,3)));
41 extern void fatal_protocol_perror( struct thread *thread,
42 const char *err, ... ) __attribute__((format (printf,2,3)));
43 extern void fatal_error( const char *err, ... ) __attribute__((noreturn,format(printf,1,2)));
44 extern void fatal_perror( const char *err, ... ) __attribute__((noreturn,format(printf,1,2)));
45 #else
46 extern void fatal_protocol_error( struct thread *thread, const char *err, ... );
47 extern void fatal_protocol_perror( struct thread *thread, const char *err, ... );
48 extern void fatal_error( const char *err, ... );
49 extern void fatal_perror( const char *err, ... );
50 #endif
52 extern const char *get_config_dir(void);
53 extern void *set_reply_data_size( data_size_t size );
54 extern int receive_fd( struct process *process );
55 extern int send_client_fd( struct process *process, int fd, obj_handle_t handle );
56 extern void read_request( struct thread *thread );
57 extern void write_reply( struct thread *thread );
58 extern unsigned int get_tick_count(void);
59 extern void open_master_socket(void);
60 extern void close_master_socket( timeout_t timeout );
61 extern void shutdown_master_socket(void);
62 extern int wait_for_lock(void);
63 extern int kill_lock_owner( int sig );
64 extern int server_dir_fd, config_dir_fd;
66 extern void trace_request(void);
67 extern void trace_reply( enum request req, const union generic_reply *reply );
69 /* get the request vararg data */
70 static inline const void *get_req_data(void)
72 return current->req_data;
75 /* get the request vararg size */
76 static inline data_size_t get_req_data_size(void)
78 return current->req.request_header.request_size;
81 /* get the request vararg as unicode string */
82 static inline void get_req_unicode_str( struct unicode_str *str )
84 str->str = get_req_data();
85 str->len = (get_req_data_size() / sizeof(WCHAR)) * sizeof(WCHAR);
88 /* get the reply maximum vararg size */
89 static inline data_size_t get_reply_max_size(void)
91 return current->req.request_header.reply_size;
94 /* allocate and fill the reply data */
95 static inline void *set_reply_data( const void *data, data_size_t size )
97 void *ret = set_reply_data_size( size );
98 if (ret) memcpy( ret, data, size );
99 return ret;
102 /* set the reply data pointer directly (will be freed by request code) */
103 static inline void set_reply_data_ptr( void *data, data_size_t size )
105 assert( size <= get_reply_max_size() );
106 current->reply_size = size;
107 current->reply_data = data;
111 /* Everything below this line is generated automatically by tools/make_requests */
112 /* ### make_requests begin ### */
114 DECL_HANDLER(new_process);
115 DECL_HANDLER(get_new_process_info);
116 DECL_HANDLER(new_thread);
117 DECL_HANDLER(get_startup_info);
118 DECL_HANDLER(init_process_done);
119 DECL_HANDLER(init_thread);
120 DECL_HANDLER(terminate_process);
121 DECL_HANDLER(terminate_thread);
122 DECL_HANDLER(get_process_info);
123 DECL_HANDLER(set_process_info);
124 DECL_HANDLER(get_thread_info);
125 DECL_HANDLER(set_thread_info);
126 DECL_HANDLER(get_dll_info);
127 DECL_HANDLER(suspend_thread);
128 DECL_HANDLER(resume_thread);
129 DECL_HANDLER(load_dll);
130 DECL_HANDLER(unload_dll);
131 DECL_HANDLER(queue_apc);
132 DECL_HANDLER(get_apc_result);
133 DECL_HANDLER(close_handle);
134 DECL_HANDLER(set_handle_info);
135 DECL_HANDLER(dup_handle);
136 DECL_HANDLER(open_process);
137 DECL_HANDLER(open_thread);
138 DECL_HANDLER(select);
139 DECL_HANDLER(create_event);
140 DECL_HANDLER(event_op);
141 DECL_HANDLER(open_event);
142 DECL_HANDLER(create_mutex);
143 DECL_HANDLER(release_mutex);
144 DECL_HANDLER(open_mutex);
145 DECL_HANDLER(create_semaphore);
146 DECL_HANDLER(release_semaphore);
147 DECL_HANDLER(open_semaphore);
148 DECL_HANDLER(create_file);
149 DECL_HANDLER(open_file_object);
150 DECL_HANDLER(alloc_file_handle);
151 DECL_HANDLER(get_handle_unix_name);
152 DECL_HANDLER(get_handle_fd);
153 DECL_HANDLER(flush_file);
154 DECL_HANDLER(lock_file);
155 DECL_HANDLER(unlock_file);
156 DECL_HANDLER(create_socket);
157 DECL_HANDLER(accept_socket);
158 DECL_HANDLER(accept_into_socket);
159 DECL_HANDLER(set_socket_event);
160 DECL_HANDLER(get_socket_event);
161 DECL_HANDLER(enable_socket_event);
162 DECL_HANDLER(set_socket_deferred);
163 DECL_HANDLER(alloc_console);
164 DECL_HANDLER(free_console);
165 DECL_HANDLER(get_console_renderer_events);
166 DECL_HANDLER(open_console);
167 DECL_HANDLER(get_console_wait_event);
168 DECL_HANDLER(get_console_mode);
169 DECL_HANDLER(set_console_mode);
170 DECL_HANDLER(set_console_input_info);
171 DECL_HANDLER(get_console_input_info);
172 DECL_HANDLER(append_console_input_history);
173 DECL_HANDLER(get_console_input_history);
174 DECL_HANDLER(create_console_output);
175 DECL_HANDLER(set_console_output_info);
176 DECL_HANDLER(get_console_output_info);
177 DECL_HANDLER(write_console_input);
178 DECL_HANDLER(read_console_input);
179 DECL_HANDLER(write_console_output);
180 DECL_HANDLER(fill_console_output);
181 DECL_HANDLER(read_console_output);
182 DECL_HANDLER(move_console_output);
183 DECL_HANDLER(send_console_signal);
184 DECL_HANDLER(read_directory_changes);
185 DECL_HANDLER(read_change);
186 DECL_HANDLER(create_mapping);
187 DECL_HANDLER(open_mapping);
188 DECL_HANDLER(get_mapping_info);
189 DECL_HANDLER(get_mapping_committed_range);
190 DECL_HANDLER(add_mapping_committed_range);
191 DECL_HANDLER(create_snapshot);
192 DECL_HANDLER(next_process);
193 DECL_HANDLER(next_thread);
194 DECL_HANDLER(wait_debug_event);
195 DECL_HANDLER(queue_exception_event);
196 DECL_HANDLER(get_exception_status);
197 DECL_HANDLER(output_debug_string);
198 DECL_HANDLER(continue_debug_event);
199 DECL_HANDLER(debug_process);
200 DECL_HANDLER(debug_break);
201 DECL_HANDLER(set_debugger_kill_on_exit);
202 DECL_HANDLER(read_process_memory);
203 DECL_HANDLER(write_process_memory);
204 DECL_HANDLER(create_key);
205 DECL_HANDLER(open_key);
206 DECL_HANDLER(delete_key);
207 DECL_HANDLER(flush_key);
208 DECL_HANDLER(enum_key);
209 DECL_HANDLER(set_key_value);
210 DECL_HANDLER(get_key_value);
211 DECL_HANDLER(enum_key_value);
212 DECL_HANDLER(delete_key_value);
213 DECL_HANDLER(load_registry);
214 DECL_HANDLER(unload_registry);
215 DECL_HANDLER(save_registry);
216 DECL_HANDLER(set_registry_notification);
217 DECL_HANDLER(create_timer);
218 DECL_HANDLER(open_timer);
219 DECL_HANDLER(set_timer);
220 DECL_HANDLER(cancel_timer);
221 DECL_HANDLER(get_timer_info);
222 DECL_HANDLER(get_thread_context);
223 DECL_HANDLER(set_thread_context);
224 DECL_HANDLER(get_selector_entry);
225 DECL_HANDLER(add_atom);
226 DECL_HANDLER(delete_atom);
227 DECL_HANDLER(find_atom);
228 DECL_HANDLER(get_atom_information);
229 DECL_HANDLER(set_atom_information);
230 DECL_HANDLER(empty_atom_table);
231 DECL_HANDLER(init_atom_table);
232 DECL_HANDLER(get_msg_queue);
233 DECL_HANDLER(set_queue_fd);
234 DECL_HANDLER(set_queue_mask);
235 DECL_HANDLER(get_queue_status);
236 DECL_HANDLER(get_process_idle_event);
237 DECL_HANDLER(send_message);
238 DECL_HANDLER(post_quit_message);
239 DECL_HANDLER(send_hardware_message);
240 DECL_HANDLER(get_message);
241 DECL_HANDLER(reply_message);
242 DECL_HANDLER(accept_hardware_message);
243 DECL_HANDLER(get_message_reply);
244 DECL_HANDLER(set_win_timer);
245 DECL_HANDLER(kill_win_timer);
246 DECL_HANDLER(is_window_hung);
247 DECL_HANDLER(get_serial_info);
248 DECL_HANDLER(set_serial_info);
249 DECL_HANDLER(register_async);
250 DECL_HANDLER(cancel_async);
251 DECL_HANDLER(ioctl);
252 DECL_HANDLER(get_ioctl_result);
253 DECL_HANDLER(create_named_pipe);
254 DECL_HANDLER(get_named_pipe_info);
255 DECL_HANDLER(create_window);
256 DECL_HANDLER(destroy_window);
257 DECL_HANDLER(get_desktop_window);
258 DECL_HANDLER(set_window_owner);
259 DECL_HANDLER(get_window_info);
260 DECL_HANDLER(set_window_info);
261 DECL_HANDLER(set_parent);
262 DECL_HANDLER(get_window_parents);
263 DECL_HANDLER(get_window_children);
264 DECL_HANDLER(get_window_children_from_point);
265 DECL_HANDLER(get_window_tree);
266 DECL_HANDLER(set_window_pos);
267 DECL_HANDLER(get_window_rectangles);
268 DECL_HANDLER(get_window_text);
269 DECL_HANDLER(set_window_text);
270 DECL_HANDLER(get_windows_offset);
271 DECL_HANDLER(get_visible_region);
272 DECL_HANDLER(get_window_region);
273 DECL_HANDLER(set_window_region);
274 DECL_HANDLER(get_update_region);
275 DECL_HANDLER(update_window_zorder);
276 DECL_HANDLER(redraw_window);
277 DECL_HANDLER(set_window_property);
278 DECL_HANDLER(remove_window_property);
279 DECL_HANDLER(get_window_property);
280 DECL_HANDLER(get_window_properties);
281 DECL_HANDLER(create_winstation);
282 DECL_HANDLER(open_winstation);
283 DECL_HANDLER(close_winstation);
284 DECL_HANDLER(get_process_winstation);
285 DECL_HANDLER(set_process_winstation);
286 DECL_HANDLER(enum_winstation);
287 DECL_HANDLER(create_desktop);
288 DECL_HANDLER(open_desktop);
289 DECL_HANDLER(close_desktop);
290 DECL_HANDLER(get_thread_desktop);
291 DECL_HANDLER(set_thread_desktop);
292 DECL_HANDLER(enum_desktop);
293 DECL_HANDLER(set_user_object_info);
294 DECL_HANDLER(attach_thread_input);
295 DECL_HANDLER(get_thread_input);
296 DECL_HANDLER(get_last_input_time);
297 DECL_HANDLER(get_key_state);
298 DECL_HANDLER(set_key_state);
299 DECL_HANDLER(set_foreground_window);
300 DECL_HANDLER(set_focus_window);
301 DECL_HANDLER(set_active_window);
302 DECL_HANDLER(set_capture_window);
303 DECL_HANDLER(set_caret_window);
304 DECL_HANDLER(set_caret_info);
305 DECL_HANDLER(set_hook);
306 DECL_HANDLER(remove_hook);
307 DECL_HANDLER(start_hook_chain);
308 DECL_HANDLER(finish_hook_chain);
309 DECL_HANDLER(get_hook_info);
310 DECL_HANDLER(create_class);
311 DECL_HANDLER(destroy_class);
312 DECL_HANDLER(set_class_info);
313 DECL_HANDLER(set_clipboard_info);
314 DECL_HANDLER(open_token);
315 DECL_HANDLER(set_global_windows);
316 DECL_HANDLER(adjust_token_privileges);
317 DECL_HANDLER(get_token_privileges);
318 DECL_HANDLER(check_token_privileges);
319 DECL_HANDLER(duplicate_token);
320 DECL_HANDLER(access_check);
321 DECL_HANDLER(get_token_sid);
322 DECL_HANDLER(get_token_groups);
323 DECL_HANDLER(get_token_default_dacl);
324 DECL_HANDLER(set_token_default_dacl);
325 DECL_HANDLER(set_security_object);
326 DECL_HANDLER(get_security_object);
327 DECL_HANDLER(create_mailslot);
328 DECL_HANDLER(set_mailslot_info);
329 DECL_HANDLER(create_directory);
330 DECL_HANDLER(open_directory);
331 DECL_HANDLER(get_directory_entry);
332 DECL_HANDLER(create_symlink);
333 DECL_HANDLER(open_symlink);
334 DECL_HANDLER(query_symlink);
335 DECL_HANDLER(get_object_info);
336 DECL_HANDLER(unlink_object);
337 DECL_HANDLER(get_token_impersonation_level);
338 DECL_HANDLER(allocate_locally_unique_id);
339 DECL_HANDLER(create_device_manager);
340 DECL_HANDLER(create_device);
341 DECL_HANDLER(delete_device);
342 DECL_HANDLER(get_next_device_request);
343 DECL_HANDLER(make_process_system);
344 DECL_HANDLER(get_token_statistics);
345 DECL_HANDLER(create_completion);
346 DECL_HANDLER(open_completion);
347 DECL_HANDLER(add_completion);
348 DECL_HANDLER(remove_completion);
349 DECL_HANDLER(query_completion);
350 DECL_HANDLER(set_completion_info);
351 DECL_HANDLER(add_fd_completion);
352 DECL_HANDLER(get_window_layered_info);
353 DECL_HANDLER(set_window_layered_info);
354 DECL_HANDLER(alloc_user_handle);
355 DECL_HANDLER(free_user_handle);
356 DECL_HANDLER(set_cursor);
358 #ifdef WANT_REQUEST_HANDLERS
360 typedef void (*req_handler)( const void *req, void *reply );
361 static const req_handler req_handlers[REQ_NB_REQUESTS] =
363 (req_handler)req_new_process,
364 (req_handler)req_get_new_process_info,
365 (req_handler)req_new_thread,
366 (req_handler)req_get_startup_info,
367 (req_handler)req_init_process_done,
368 (req_handler)req_init_thread,
369 (req_handler)req_terminate_process,
370 (req_handler)req_terminate_thread,
371 (req_handler)req_get_process_info,
372 (req_handler)req_set_process_info,
373 (req_handler)req_get_thread_info,
374 (req_handler)req_set_thread_info,
375 (req_handler)req_get_dll_info,
376 (req_handler)req_suspend_thread,
377 (req_handler)req_resume_thread,
378 (req_handler)req_load_dll,
379 (req_handler)req_unload_dll,
380 (req_handler)req_queue_apc,
381 (req_handler)req_get_apc_result,
382 (req_handler)req_close_handle,
383 (req_handler)req_set_handle_info,
384 (req_handler)req_dup_handle,
385 (req_handler)req_open_process,
386 (req_handler)req_open_thread,
387 (req_handler)req_select,
388 (req_handler)req_create_event,
389 (req_handler)req_event_op,
390 (req_handler)req_open_event,
391 (req_handler)req_create_mutex,
392 (req_handler)req_release_mutex,
393 (req_handler)req_open_mutex,
394 (req_handler)req_create_semaphore,
395 (req_handler)req_release_semaphore,
396 (req_handler)req_open_semaphore,
397 (req_handler)req_create_file,
398 (req_handler)req_open_file_object,
399 (req_handler)req_alloc_file_handle,
400 (req_handler)req_get_handle_unix_name,
401 (req_handler)req_get_handle_fd,
402 (req_handler)req_flush_file,
403 (req_handler)req_lock_file,
404 (req_handler)req_unlock_file,
405 (req_handler)req_create_socket,
406 (req_handler)req_accept_socket,
407 (req_handler)req_accept_into_socket,
408 (req_handler)req_set_socket_event,
409 (req_handler)req_get_socket_event,
410 (req_handler)req_enable_socket_event,
411 (req_handler)req_set_socket_deferred,
412 (req_handler)req_alloc_console,
413 (req_handler)req_free_console,
414 (req_handler)req_get_console_renderer_events,
415 (req_handler)req_open_console,
416 (req_handler)req_get_console_wait_event,
417 (req_handler)req_get_console_mode,
418 (req_handler)req_set_console_mode,
419 (req_handler)req_set_console_input_info,
420 (req_handler)req_get_console_input_info,
421 (req_handler)req_append_console_input_history,
422 (req_handler)req_get_console_input_history,
423 (req_handler)req_create_console_output,
424 (req_handler)req_set_console_output_info,
425 (req_handler)req_get_console_output_info,
426 (req_handler)req_write_console_input,
427 (req_handler)req_read_console_input,
428 (req_handler)req_write_console_output,
429 (req_handler)req_fill_console_output,
430 (req_handler)req_read_console_output,
431 (req_handler)req_move_console_output,
432 (req_handler)req_send_console_signal,
433 (req_handler)req_read_directory_changes,
434 (req_handler)req_read_change,
435 (req_handler)req_create_mapping,
436 (req_handler)req_open_mapping,
437 (req_handler)req_get_mapping_info,
438 (req_handler)req_get_mapping_committed_range,
439 (req_handler)req_add_mapping_committed_range,
440 (req_handler)req_create_snapshot,
441 (req_handler)req_next_process,
442 (req_handler)req_next_thread,
443 (req_handler)req_wait_debug_event,
444 (req_handler)req_queue_exception_event,
445 (req_handler)req_get_exception_status,
446 (req_handler)req_output_debug_string,
447 (req_handler)req_continue_debug_event,
448 (req_handler)req_debug_process,
449 (req_handler)req_debug_break,
450 (req_handler)req_set_debugger_kill_on_exit,
451 (req_handler)req_read_process_memory,
452 (req_handler)req_write_process_memory,
453 (req_handler)req_create_key,
454 (req_handler)req_open_key,
455 (req_handler)req_delete_key,
456 (req_handler)req_flush_key,
457 (req_handler)req_enum_key,
458 (req_handler)req_set_key_value,
459 (req_handler)req_get_key_value,
460 (req_handler)req_enum_key_value,
461 (req_handler)req_delete_key_value,
462 (req_handler)req_load_registry,
463 (req_handler)req_unload_registry,
464 (req_handler)req_save_registry,
465 (req_handler)req_set_registry_notification,
466 (req_handler)req_create_timer,
467 (req_handler)req_open_timer,
468 (req_handler)req_set_timer,
469 (req_handler)req_cancel_timer,
470 (req_handler)req_get_timer_info,
471 (req_handler)req_get_thread_context,
472 (req_handler)req_set_thread_context,
473 (req_handler)req_get_selector_entry,
474 (req_handler)req_add_atom,
475 (req_handler)req_delete_atom,
476 (req_handler)req_find_atom,
477 (req_handler)req_get_atom_information,
478 (req_handler)req_set_atom_information,
479 (req_handler)req_empty_atom_table,
480 (req_handler)req_init_atom_table,
481 (req_handler)req_get_msg_queue,
482 (req_handler)req_set_queue_fd,
483 (req_handler)req_set_queue_mask,
484 (req_handler)req_get_queue_status,
485 (req_handler)req_get_process_idle_event,
486 (req_handler)req_send_message,
487 (req_handler)req_post_quit_message,
488 (req_handler)req_send_hardware_message,
489 (req_handler)req_get_message,
490 (req_handler)req_reply_message,
491 (req_handler)req_accept_hardware_message,
492 (req_handler)req_get_message_reply,
493 (req_handler)req_set_win_timer,
494 (req_handler)req_kill_win_timer,
495 (req_handler)req_is_window_hung,
496 (req_handler)req_get_serial_info,
497 (req_handler)req_set_serial_info,
498 (req_handler)req_register_async,
499 (req_handler)req_cancel_async,
500 (req_handler)req_ioctl,
501 (req_handler)req_get_ioctl_result,
502 (req_handler)req_create_named_pipe,
503 (req_handler)req_get_named_pipe_info,
504 (req_handler)req_create_window,
505 (req_handler)req_destroy_window,
506 (req_handler)req_get_desktop_window,
507 (req_handler)req_set_window_owner,
508 (req_handler)req_get_window_info,
509 (req_handler)req_set_window_info,
510 (req_handler)req_set_parent,
511 (req_handler)req_get_window_parents,
512 (req_handler)req_get_window_children,
513 (req_handler)req_get_window_children_from_point,
514 (req_handler)req_get_window_tree,
515 (req_handler)req_set_window_pos,
516 (req_handler)req_get_window_rectangles,
517 (req_handler)req_get_window_text,
518 (req_handler)req_set_window_text,
519 (req_handler)req_get_windows_offset,
520 (req_handler)req_get_visible_region,
521 (req_handler)req_get_window_region,
522 (req_handler)req_set_window_region,
523 (req_handler)req_get_update_region,
524 (req_handler)req_update_window_zorder,
525 (req_handler)req_redraw_window,
526 (req_handler)req_set_window_property,
527 (req_handler)req_remove_window_property,
528 (req_handler)req_get_window_property,
529 (req_handler)req_get_window_properties,
530 (req_handler)req_create_winstation,
531 (req_handler)req_open_winstation,
532 (req_handler)req_close_winstation,
533 (req_handler)req_get_process_winstation,
534 (req_handler)req_set_process_winstation,
535 (req_handler)req_enum_winstation,
536 (req_handler)req_create_desktop,
537 (req_handler)req_open_desktop,
538 (req_handler)req_close_desktop,
539 (req_handler)req_get_thread_desktop,
540 (req_handler)req_set_thread_desktop,
541 (req_handler)req_enum_desktop,
542 (req_handler)req_set_user_object_info,
543 (req_handler)req_attach_thread_input,
544 (req_handler)req_get_thread_input,
545 (req_handler)req_get_last_input_time,
546 (req_handler)req_get_key_state,
547 (req_handler)req_set_key_state,
548 (req_handler)req_set_foreground_window,
549 (req_handler)req_set_focus_window,
550 (req_handler)req_set_active_window,
551 (req_handler)req_set_capture_window,
552 (req_handler)req_set_caret_window,
553 (req_handler)req_set_caret_info,
554 (req_handler)req_set_hook,
555 (req_handler)req_remove_hook,
556 (req_handler)req_start_hook_chain,
557 (req_handler)req_finish_hook_chain,
558 (req_handler)req_get_hook_info,
559 (req_handler)req_create_class,
560 (req_handler)req_destroy_class,
561 (req_handler)req_set_class_info,
562 (req_handler)req_set_clipboard_info,
563 (req_handler)req_open_token,
564 (req_handler)req_set_global_windows,
565 (req_handler)req_adjust_token_privileges,
566 (req_handler)req_get_token_privileges,
567 (req_handler)req_check_token_privileges,
568 (req_handler)req_duplicate_token,
569 (req_handler)req_access_check,
570 (req_handler)req_get_token_sid,
571 (req_handler)req_get_token_groups,
572 (req_handler)req_get_token_default_dacl,
573 (req_handler)req_set_token_default_dacl,
574 (req_handler)req_set_security_object,
575 (req_handler)req_get_security_object,
576 (req_handler)req_create_mailslot,
577 (req_handler)req_set_mailslot_info,
578 (req_handler)req_create_directory,
579 (req_handler)req_open_directory,
580 (req_handler)req_get_directory_entry,
581 (req_handler)req_create_symlink,
582 (req_handler)req_open_symlink,
583 (req_handler)req_query_symlink,
584 (req_handler)req_get_object_info,
585 (req_handler)req_unlink_object,
586 (req_handler)req_get_token_impersonation_level,
587 (req_handler)req_allocate_locally_unique_id,
588 (req_handler)req_create_device_manager,
589 (req_handler)req_create_device,
590 (req_handler)req_delete_device,
591 (req_handler)req_get_next_device_request,
592 (req_handler)req_make_process_system,
593 (req_handler)req_get_token_statistics,
594 (req_handler)req_create_completion,
595 (req_handler)req_open_completion,
596 (req_handler)req_add_completion,
597 (req_handler)req_remove_completion,
598 (req_handler)req_query_completion,
599 (req_handler)req_set_completion_info,
600 (req_handler)req_add_fd_completion,
601 (req_handler)req_get_window_layered_info,
602 (req_handler)req_set_window_layered_info,
603 (req_handler)req_alloc_user_handle,
604 (req_handler)req_free_user_handle,
605 (req_handler)req_set_cursor,
608 C_ASSERT( sizeof(affinity_t) == 8 );
609 C_ASSERT( sizeof(apc_call_t) == 40 );
610 C_ASSERT( sizeof(apc_param_t) == 8 );
611 C_ASSERT( sizeof(apc_result_t) == 40 );
612 C_ASSERT( sizeof(async_data_t) == 40 );
613 C_ASSERT( sizeof(atom_t) == 4 );
614 C_ASSERT( sizeof(char) == 1 );
615 C_ASSERT( sizeof(char_info_t) == 4 );
616 C_ASSERT( sizeof(client_ptr_t) == 8 );
617 C_ASSERT( sizeof(cpu_type_t) == 4 );
618 C_ASSERT( sizeof(data_size_t) == 4 );
619 C_ASSERT( sizeof(file_pos_t) == 8 );
620 C_ASSERT( sizeof(int) == 4 );
621 C_ASSERT( sizeof(ioctl_code_t) == 4 );
622 C_ASSERT( sizeof(lparam_t) == 8 );
623 C_ASSERT( sizeof(luid_t) == 8 );
624 C_ASSERT( sizeof(mem_size_t) == 8 );
625 C_ASSERT( sizeof(mod_handle_t) == 8 );
626 C_ASSERT( sizeof(obj_handle_t) == 4 );
627 C_ASSERT( sizeof(process_id_t) == 4 );
628 C_ASSERT( sizeof(rectangle_t) == 16 );
629 C_ASSERT( sizeof(short int) == 2 );
630 C_ASSERT( sizeof(thread_id_t) == 4 );
631 C_ASSERT( sizeof(timeout_t) == 8 );
632 C_ASSERT( sizeof(unsigned char) == 1 );
633 C_ASSERT( sizeof(unsigned int) == 4 );
634 C_ASSERT( sizeof(unsigned short) == 2 );
635 C_ASSERT( sizeof(user_handle_t) == 4 );
636 C_ASSERT( FIELD_OFFSET(struct new_process_request, inherit_all) == 12 );
637 C_ASSERT( FIELD_OFFSET(struct new_process_request, create_flags) == 16 );
638 C_ASSERT( FIELD_OFFSET(struct new_process_request, socket_fd) == 20 );
639 C_ASSERT( FIELD_OFFSET(struct new_process_request, exe_file) == 24 );
640 C_ASSERT( FIELD_OFFSET(struct new_process_request, process_access) == 28 );
641 C_ASSERT( FIELD_OFFSET(struct new_process_request, process_attr) == 32 );
642 C_ASSERT( FIELD_OFFSET(struct new_process_request, thread_access) == 36 );
643 C_ASSERT( FIELD_OFFSET(struct new_process_request, thread_attr) == 40 );
644 C_ASSERT( FIELD_OFFSET(struct new_process_request, info_size) == 44 );
645 C_ASSERT( sizeof(struct new_process_request) == 48 );
646 C_ASSERT( FIELD_OFFSET(struct new_process_reply, info) == 8 );
647 C_ASSERT( FIELD_OFFSET(struct new_process_reply, pid) == 12 );
648 C_ASSERT( FIELD_OFFSET(struct new_process_reply, phandle) == 16 );
649 C_ASSERT( FIELD_OFFSET(struct new_process_reply, tid) == 20 );
650 C_ASSERT( FIELD_OFFSET(struct new_process_reply, thandle) == 24 );
651 C_ASSERT( sizeof(struct new_process_reply) == 32 );
652 C_ASSERT( FIELD_OFFSET(struct get_new_process_info_request, info) == 12 );
653 C_ASSERT( sizeof(struct get_new_process_info_request) == 16 );
654 C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply, success) == 8 );
655 C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply, exit_code) == 12 );
656 C_ASSERT( sizeof(struct get_new_process_info_reply) == 16 );
657 C_ASSERT( FIELD_OFFSET(struct new_thread_request, access) == 12 );
658 C_ASSERT( FIELD_OFFSET(struct new_thread_request, attributes) == 16 );
659 C_ASSERT( FIELD_OFFSET(struct new_thread_request, suspend) == 20 );
660 C_ASSERT( FIELD_OFFSET(struct new_thread_request, request_fd) == 24 );
661 C_ASSERT( sizeof(struct new_thread_request) == 32 );
662 C_ASSERT( FIELD_OFFSET(struct new_thread_reply, tid) == 8 );
663 C_ASSERT( FIELD_OFFSET(struct new_thread_reply, handle) == 12 );
664 C_ASSERT( sizeof(struct new_thread_reply) == 16 );
665 C_ASSERT( sizeof(struct get_startup_info_request) == 16 );
666 C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply, exe_file) == 8 );
667 C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply, info_size) == 12 );
668 C_ASSERT( sizeof(struct get_startup_info_reply) == 16 );
669 C_ASSERT( FIELD_OFFSET(struct init_process_done_request, gui) == 12 );
670 C_ASSERT( FIELD_OFFSET(struct init_process_done_request, module) == 16 );
671 C_ASSERT( FIELD_OFFSET(struct init_process_done_request, ldt_copy) == 24 );
672 C_ASSERT( FIELD_OFFSET(struct init_process_done_request, entry) == 32 );
673 C_ASSERT( sizeof(struct init_process_done_request) == 40 );
674 C_ASSERT( FIELD_OFFSET(struct init_thread_request, unix_pid) == 12 );
675 C_ASSERT( FIELD_OFFSET(struct init_thread_request, unix_tid) == 16 );
676 C_ASSERT( FIELD_OFFSET(struct init_thread_request, debug_level) == 20 );
677 C_ASSERT( FIELD_OFFSET(struct init_thread_request, teb) == 24 );
678 C_ASSERT( FIELD_OFFSET(struct init_thread_request, entry) == 32 );
679 C_ASSERT( FIELD_OFFSET(struct init_thread_request, reply_fd) == 40 );
680 C_ASSERT( FIELD_OFFSET(struct init_thread_request, wait_fd) == 44 );
681 C_ASSERT( FIELD_OFFSET(struct init_thread_request, cpu) == 48 );
682 C_ASSERT( sizeof(struct init_thread_request) == 56 );
683 C_ASSERT( FIELD_OFFSET(struct init_thread_reply, pid) == 8 );
684 C_ASSERT( FIELD_OFFSET(struct init_thread_reply, tid) == 12 );
685 C_ASSERT( FIELD_OFFSET(struct init_thread_reply, server_start) == 16 );
686 C_ASSERT( FIELD_OFFSET(struct init_thread_reply, info_size) == 24 );
687 C_ASSERT( FIELD_OFFSET(struct init_thread_reply, version) == 28 );
688 C_ASSERT( FIELD_OFFSET(struct init_thread_reply, all_cpus) == 32 );
689 C_ASSERT( sizeof(struct init_thread_reply) == 40 );
690 C_ASSERT( FIELD_OFFSET(struct terminate_process_request, handle) == 12 );
691 C_ASSERT( FIELD_OFFSET(struct terminate_process_request, exit_code) == 16 );
692 C_ASSERT( sizeof(struct terminate_process_request) == 24 );
693 C_ASSERT( FIELD_OFFSET(struct terminate_process_reply, self) == 8 );
694 C_ASSERT( sizeof(struct terminate_process_reply) == 16 );
695 C_ASSERT( FIELD_OFFSET(struct terminate_thread_request, handle) == 12 );
696 C_ASSERT( FIELD_OFFSET(struct terminate_thread_request, exit_code) == 16 );
697 C_ASSERT( sizeof(struct terminate_thread_request) == 24 );
698 C_ASSERT( FIELD_OFFSET(struct terminate_thread_reply, self) == 8 );
699 C_ASSERT( FIELD_OFFSET(struct terminate_thread_reply, last) == 12 );
700 C_ASSERT( sizeof(struct terminate_thread_reply) == 16 );
701 C_ASSERT( FIELD_OFFSET(struct get_process_info_request, handle) == 12 );
702 C_ASSERT( sizeof(struct get_process_info_request) == 16 );
703 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, pid) == 8 );
704 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, ppid) == 12 );
705 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, affinity) == 16 );
706 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, peb) == 24 );
707 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, start_time) == 32 );
708 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, end_time) == 40 );
709 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, exit_code) == 48 );
710 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, priority) == 52 );
711 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, cpu) == 56 );
712 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, debugger_present) == 60 );
713 C_ASSERT( sizeof(struct get_process_info_reply) == 64 );
714 C_ASSERT( FIELD_OFFSET(struct set_process_info_request, handle) == 12 );
715 C_ASSERT( FIELD_OFFSET(struct set_process_info_request, mask) == 16 );
716 C_ASSERT( FIELD_OFFSET(struct set_process_info_request, priority) == 20 );
717 C_ASSERT( FIELD_OFFSET(struct set_process_info_request, affinity) == 24 );
718 C_ASSERT( sizeof(struct set_process_info_request) == 32 );
719 C_ASSERT( FIELD_OFFSET(struct get_thread_info_request, handle) == 12 );
720 C_ASSERT( FIELD_OFFSET(struct get_thread_info_request, tid_in) == 16 );
721 C_ASSERT( sizeof(struct get_thread_info_request) == 24 );
722 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, pid) == 8 );
723 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, tid) == 12 );
724 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, teb) == 16 );
725 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, affinity) == 24 );
726 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, creation_time) == 32 );
727 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, exit_time) == 40 );
728 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, exit_code) == 48 );
729 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, priority) == 52 );
730 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, last) == 56 );
731 C_ASSERT( sizeof(struct get_thread_info_reply) == 64 );
732 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, handle) == 12 );
733 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, mask) == 16 );
734 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, priority) == 20 );
735 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, affinity) == 24 );
736 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, token) == 32 );
737 C_ASSERT( sizeof(struct set_thread_info_request) == 40 );
738 C_ASSERT( FIELD_OFFSET(struct get_dll_info_request, handle) == 12 );
739 C_ASSERT( FIELD_OFFSET(struct get_dll_info_request, base_address) == 16 );
740 C_ASSERT( sizeof(struct get_dll_info_request) == 24 );
741 C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply, entry_point) == 8 );
742 C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply, size) == 16 );
743 C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply, filename_len) == 20 );
744 C_ASSERT( sizeof(struct get_dll_info_reply) == 24 );
745 C_ASSERT( FIELD_OFFSET(struct suspend_thread_request, handle) == 12 );
746 C_ASSERT( sizeof(struct suspend_thread_request) == 16 );
747 C_ASSERT( FIELD_OFFSET(struct suspend_thread_reply, count) == 8 );
748 C_ASSERT( sizeof(struct suspend_thread_reply) == 16 );
749 C_ASSERT( FIELD_OFFSET(struct resume_thread_request, handle) == 12 );
750 C_ASSERT( sizeof(struct resume_thread_request) == 16 );
751 C_ASSERT( FIELD_OFFSET(struct resume_thread_reply, count) == 8 );
752 C_ASSERT( sizeof(struct resume_thread_reply) == 16 );
753 C_ASSERT( FIELD_OFFSET(struct load_dll_request, handle) == 12 );
754 C_ASSERT( FIELD_OFFSET(struct load_dll_request, base) == 16 );
755 C_ASSERT( FIELD_OFFSET(struct load_dll_request, name) == 24 );
756 C_ASSERT( FIELD_OFFSET(struct load_dll_request, size) == 32 );
757 C_ASSERT( FIELD_OFFSET(struct load_dll_request, dbg_offset) == 36 );
758 C_ASSERT( FIELD_OFFSET(struct load_dll_request, dbg_size) == 40 );
759 C_ASSERT( sizeof(struct load_dll_request) == 48 );
760 C_ASSERT( FIELD_OFFSET(struct unload_dll_request, base) == 16 );
761 C_ASSERT( sizeof(struct unload_dll_request) == 24 );
762 C_ASSERT( FIELD_OFFSET(struct queue_apc_request, handle) == 12 );
763 C_ASSERT( FIELD_OFFSET(struct queue_apc_request, call) == 16 );
764 C_ASSERT( sizeof(struct queue_apc_request) == 56 );
765 C_ASSERT( FIELD_OFFSET(struct queue_apc_reply, handle) == 8 );
766 C_ASSERT( FIELD_OFFSET(struct queue_apc_reply, self) == 12 );
767 C_ASSERT( sizeof(struct queue_apc_reply) == 16 );
768 C_ASSERT( FIELD_OFFSET(struct get_apc_result_request, handle) == 12 );
769 C_ASSERT( sizeof(struct get_apc_result_request) == 16 );
770 C_ASSERT( FIELD_OFFSET(struct get_apc_result_reply, result) == 8 );
771 C_ASSERT( sizeof(struct get_apc_result_reply) == 48 );
772 C_ASSERT( FIELD_OFFSET(struct close_handle_request, handle) == 12 );
773 C_ASSERT( sizeof(struct close_handle_request) == 16 );
774 C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, handle) == 12 );
775 C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, flags) == 16 );
776 C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, mask) == 20 );
777 C_ASSERT( sizeof(struct set_handle_info_request) == 24 );
778 C_ASSERT( FIELD_OFFSET(struct set_handle_info_reply, old_flags) == 8 );
779 C_ASSERT( sizeof(struct set_handle_info_reply) == 16 );
780 C_ASSERT( FIELD_OFFSET(struct dup_handle_request, src_process) == 12 );
781 C_ASSERT( FIELD_OFFSET(struct dup_handle_request, src_handle) == 16 );
782 C_ASSERT( FIELD_OFFSET(struct dup_handle_request, dst_process) == 20 );
783 C_ASSERT( FIELD_OFFSET(struct dup_handle_request, access) == 24 );
784 C_ASSERT( FIELD_OFFSET(struct dup_handle_request, attributes) == 28 );
785 C_ASSERT( FIELD_OFFSET(struct dup_handle_request, options) == 32 );
786 C_ASSERT( sizeof(struct dup_handle_request) == 40 );
787 C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, handle) == 8 );
788 C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, self) == 12 );
789 C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, closed) == 16 );
790 C_ASSERT( sizeof(struct dup_handle_reply) == 24 );
791 C_ASSERT( FIELD_OFFSET(struct open_process_request, pid) == 12 );
792 C_ASSERT( FIELD_OFFSET(struct open_process_request, access) == 16 );
793 C_ASSERT( FIELD_OFFSET(struct open_process_request, attributes) == 20 );
794 C_ASSERT( sizeof(struct open_process_request) == 24 );
795 C_ASSERT( FIELD_OFFSET(struct open_process_reply, handle) == 8 );
796 C_ASSERT( sizeof(struct open_process_reply) == 16 );
797 C_ASSERT( FIELD_OFFSET(struct open_thread_request, tid) == 12 );
798 C_ASSERT( FIELD_OFFSET(struct open_thread_request, access) == 16 );
799 C_ASSERT( FIELD_OFFSET(struct open_thread_request, attributes) == 20 );
800 C_ASSERT( sizeof(struct open_thread_request) == 24 );
801 C_ASSERT( FIELD_OFFSET(struct open_thread_reply, handle) == 8 );
802 C_ASSERT( sizeof(struct open_thread_reply) == 16 );
803 C_ASSERT( FIELD_OFFSET(struct select_request, flags) == 12 );
804 C_ASSERT( FIELD_OFFSET(struct select_request, cookie) == 16 );
805 C_ASSERT( FIELD_OFFSET(struct select_request, signal) == 24 );
806 C_ASSERT( FIELD_OFFSET(struct select_request, prev_apc) == 28 );
807 C_ASSERT( FIELD_OFFSET(struct select_request, timeout) == 32 );
808 C_ASSERT( sizeof(struct select_request) == 40 );
809 C_ASSERT( FIELD_OFFSET(struct select_reply, timeout) == 8 );
810 C_ASSERT( FIELD_OFFSET(struct select_reply, call) == 16 );
811 C_ASSERT( FIELD_OFFSET(struct select_reply, apc_handle) == 56 );
812 C_ASSERT( sizeof(struct select_reply) == 64 );
813 C_ASSERT( FIELD_OFFSET(struct create_event_request, access) == 12 );
814 C_ASSERT( FIELD_OFFSET(struct create_event_request, attributes) == 16 );
815 C_ASSERT( FIELD_OFFSET(struct create_event_request, manual_reset) == 20 );
816 C_ASSERT( FIELD_OFFSET(struct create_event_request, initial_state) == 24 );
817 C_ASSERT( sizeof(struct create_event_request) == 32 );
818 C_ASSERT( FIELD_OFFSET(struct create_event_reply, handle) == 8 );
819 C_ASSERT( sizeof(struct create_event_reply) == 16 );
820 C_ASSERT( FIELD_OFFSET(struct event_op_request, handle) == 12 );
821 C_ASSERT( FIELD_OFFSET(struct event_op_request, op) == 16 );
822 C_ASSERT( sizeof(struct event_op_request) == 24 );
823 C_ASSERT( FIELD_OFFSET(struct open_event_request, access) == 12 );
824 C_ASSERT( FIELD_OFFSET(struct open_event_request, attributes) == 16 );
825 C_ASSERT( FIELD_OFFSET(struct open_event_request, rootdir) == 20 );
826 C_ASSERT( sizeof(struct open_event_request) == 24 );
827 C_ASSERT( FIELD_OFFSET(struct open_event_reply, handle) == 8 );
828 C_ASSERT( sizeof(struct open_event_reply) == 16 );
829 C_ASSERT( FIELD_OFFSET(struct create_mutex_request, access) == 12 );
830 C_ASSERT( FIELD_OFFSET(struct create_mutex_request, attributes) == 16 );
831 C_ASSERT( FIELD_OFFSET(struct create_mutex_request, owned) == 20 );
832 C_ASSERT( sizeof(struct create_mutex_request) == 24 );
833 C_ASSERT( FIELD_OFFSET(struct create_mutex_reply, handle) == 8 );
834 C_ASSERT( sizeof(struct create_mutex_reply) == 16 );
835 C_ASSERT( FIELD_OFFSET(struct release_mutex_request, handle) == 12 );
836 C_ASSERT( sizeof(struct release_mutex_request) == 16 );
837 C_ASSERT( FIELD_OFFSET(struct release_mutex_reply, prev_count) == 8 );
838 C_ASSERT( sizeof(struct release_mutex_reply) == 16 );
839 C_ASSERT( FIELD_OFFSET(struct open_mutex_request, access) == 12 );
840 C_ASSERT( FIELD_OFFSET(struct open_mutex_request, attributes) == 16 );
841 C_ASSERT( FIELD_OFFSET(struct open_mutex_request, rootdir) == 20 );
842 C_ASSERT( sizeof(struct open_mutex_request) == 24 );
843 C_ASSERT( FIELD_OFFSET(struct open_mutex_reply, handle) == 8 );
844 C_ASSERT( sizeof(struct open_mutex_reply) == 16 );
845 C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, access) == 12 );
846 C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, attributes) == 16 );
847 C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, initial) == 20 );
848 C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, max) == 24 );
849 C_ASSERT( sizeof(struct create_semaphore_request) == 32 );
850 C_ASSERT( FIELD_OFFSET(struct create_semaphore_reply, handle) == 8 );
851 C_ASSERT( sizeof(struct create_semaphore_reply) == 16 );
852 C_ASSERT( FIELD_OFFSET(struct release_semaphore_request, handle) == 12 );
853 C_ASSERT( FIELD_OFFSET(struct release_semaphore_request, count) == 16 );
854 C_ASSERT( sizeof(struct release_semaphore_request) == 24 );
855 C_ASSERT( FIELD_OFFSET(struct release_semaphore_reply, prev_count) == 8 );
856 C_ASSERT( sizeof(struct release_semaphore_reply) == 16 );
857 C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, access) == 12 );
858 C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, attributes) == 16 );
859 C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, rootdir) == 20 );
860 C_ASSERT( sizeof(struct open_semaphore_request) == 24 );
861 C_ASSERT( FIELD_OFFSET(struct open_semaphore_reply, handle) == 8 );
862 C_ASSERT( sizeof(struct open_semaphore_reply) == 16 );
863 C_ASSERT( FIELD_OFFSET(struct create_file_request, access) == 12 );
864 C_ASSERT( FIELD_OFFSET(struct create_file_request, attributes) == 16 );
865 C_ASSERT( FIELD_OFFSET(struct create_file_request, sharing) == 20 );
866 C_ASSERT( FIELD_OFFSET(struct create_file_request, create) == 24 );
867 C_ASSERT( FIELD_OFFSET(struct create_file_request, options) == 28 );
868 C_ASSERT( FIELD_OFFSET(struct create_file_request, attrs) == 32 );
869 C_ASSERT( sizeof(struct create_file_request) == 40 );
870 C_ASSERT( FIELD_OFFSET(struct create_file_reply, handle) == 8 );
871 C_ASSERT( sizeof(struct create_file_reply) == 16 );
872 C_ASSERT( FIELD_OFFSET(struct open_file_object_request, access) == 12 );
873 C_ASSERT( FIELD_OFFSET(struct open_file_object_request, attributes) == 16 );
874 C_ASSERT( FIELD_OFFSET(struct open_file_object_request, rootdir) == 20 );
875 C_ASSERT( FIELD_OFFSET(struct open_file_object_request, sharing) == 24 );
876 C_ASSERT( FIELD_OFFSET(struct open_file_object_request, options) == 28 );
877 C_ASSERT( sizeof(struct open_file_object_request) == 32 );
878 C_ASSERT( FIELD_OFFSET(struct open_file_object_reply, handle) == 8 );
879 C_ASSERT( sizeof(struct open_file_object_reply) == 16 );
880 C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, access) == 12 );
881 C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, attributes) == 16 );
882 C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, fd) == 20 );
883 C_ASSERT( sizeof(struct alloc_file_handle_request) == 24 );
884 C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_reply, handle) == 8 );
885 C_ASSERT( sizeof(struct alloc_file_handle_reply) == 16 );
886 C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_request, handle) == 12 );
887 C_ASSERT( sizeof(struct get_handle_unix_name_request) == 16 );
888 C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_reply, name_len) == 8 );
889 C_ASSERT( sizeof(struct get_handle_unix_name_reply) == 16 );
890 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_request, handle) == 12 );
891 C_ASSERT( sizeof(struct get_handle_fd_request) == 16 );
892 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, type) == 8 );
893 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, cacheable) == 12 );
894 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, access) == 16 );
895 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, options) == 20 );
896 C_ASSERT( sizeof(struct get_handle_fd_reply) == 24 );
897 C_ASSERT( FIELD_OFFSET(struct flush_file_request, handle) == 12 );
898 C_ASSERT( sizeof(struct flush_file_request) == 16 );
899 C_ASSERT( FIELD_OFFSET(struct flush_file_reply, event) == 8 );
900 C_ASSERT( sizeof(struct flush_file_reply) == 16 );
901 C_ASSERT( FIELD_OFFSET(struct lock_file_request, handle) == 12 );
902 C_ASSERT( FIELD_OFFSET(struct lock_file_request, offset) == 16 );
903 C_ASSERT( FIELD_OFFSET(struct lock_file_request, count) == 24 );
904 C_ASSERT( FIELD_OFFSET(struct lock_file_request, shared) == 32 );
905 C_ASSERT( FIELD_OFFSET(struct lock_file_request, wait) == 36 );
906 C_ASSERT( sizeof(struct lock_file_request) == 40 );
907 C_ASSERT( FIELD_OFFSET(struct lock_file_reply, handle) == 8 );
908 C_ASSERT( FIELD_OFFSET(struct lock_file_reply, overlapped) == 12 );
909 C_ASSERT( sizeof(struct lock_file_reply) == 16 );
910 C_ASSERT( FIELD_OFFSET(struct unlock_file_request, handle) == 12 );
911 C_ASSERT( FIELD_OFFSET(struct unlock_file_request, offset) == 16 );
912 C_ASSERT( FIELD_OFFSET(struct unlock_file_request, count) == 24 );
913 C_ASSERT( sizeof(struct unlock_file_request) == 32 );
914 C_ASSERT( FIELD_OFFSET(struct create_socket_request, access) == 12 );
915 C_ASSERT( FIELD_OFFSET(struct create_socket_request, attributes) == 16 );
916 C_ASSERT( FIELD_OFFSET(struct create_socket_request, family) == 20 );
917 C_ASSERT( FIELD_OFFSET(struct create_socket_request, type) == 24 );
918 C_ASSERT( FIELD_OFFSET(struct create_socket_request, protocol) == 28 );
919 C_ASSERT( FIELD_OFFSET(struct create_socket_request, flags) == 32 );
920 C_ASSERT( sizeof(struct create_socket_request) == 40 );
921 C_ASSERT( FIELD_OFFSET(struct create_socket_reply, handle) == 8 );
922 C_ASSERT( sizeof(struct create_socket_reply) == 16 );
923 C_ASSERT( FIELD_OFFSET(struct accept_socket_request, lhandle) == 12 );
924 C_ASSERT( FIELD_OFFSET(struct accept_socket_request, access) == 16 );
925 C_ASSERT( FIELD_OFFSET(struct accept_socket_request, attributes) == 20 );
926 C_ASSERT( sizeof(struct accept_socket_request) == 24 );
927 C_ASSERT( FIELD_OFFSET(struct accept_socket_reply, handle) == 8 );
928 C_ASSERT( sizeof(struct accept_socket_reply) == 16 );
929 C_ASSERT( FIELD_OFFSET(struct accept_into_socket_request, lhandle) == 12 );
930 C_ASSERT( FIELD_OFFSET(struct accept_into_socket_request, ahandle) == 16 );
931 C_ASSERT( sizeof(struct accept_into_socket_request) == 24 );
932 C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, handle) == 12 );
933 C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, mask) == 16 );
934 C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, event) == 20 );
935 C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, window) == 24 );
936 C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, msg) == 28 );
937 C_ASSERT( sizeof(struct set_socket_event_request) == 32 );
938 C_ASSERT( FIELD_OFFSET(struct get_socket_event_request, handle) == 12 );
939 C_ASSERT( FIELD_OFFSET(struct get_socket_event_request, service) == 16 );
940 C_ASSERT( FIELD_OFFSET(struct get_socket_event_request, c_event) == 20 );
941 C_ASSERT( sizeof(struct get_socket_event_request) == 24 );
942 C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply, mask) == 8 );
943 C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply, pmask) == 12 );
944 C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply, state) == 16 );
945 C_ASSERT( sizeof(struct get_socket_event_reply) == 24 );
946 C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request, handle) == 12 );
947 C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request, mask) == 16 );
948 C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request, sstate) == 20 );
949 C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request, cstate) == 24 );
950 C_ASSERT( sizeof(struct enable_socket_event_request) == 32 );
951 C_ASSERT( FIELD_OFFSET(struct set_socket_deferred_request, handle) == 12 );
952 C_ASSERT( FIELD_OFFSET(struct set_socket_deferred_request, deferred) == 16 );
953 C_ASSERT( sizeof(struct set_socket_deferred_request) == 24 );
954 C_ASSERT( FIELD_OFFSET(struct alloc_console_request, access) == 12 );
955 C_ASSERT( FIELD_OFFSET(struct alloc_console_request, attributes) == 16 );
956 C_ASSERT( FIELD_OFFSET(struct alloc_console_request, pid) == 20 );
957 C_ASSERT( FIELD_OFFSET(struct alloc_console_request, input_fd) == 24 );
958 C_ASSERT( sizeof(struct alloc_console_request) == 32 );
959 C_ASSERT( FIELD_OFFSET(struct alloc_console_reply, handle_in) == 8 );
960 C_ASSERT( FIELD_OFFSET(struct alloc_console_reply, event) == 12 );
961 C_ASSERT( sizeof(struct alloc_console_reply) == 16 );
962 C_ASSERT( sizeof(struct free_console_request) == 16 );
963 C_ASSERT( FIELD_OFFSET(struct get_console_renderer_events_request, handle) == 12 );
964 C_ASSERT( sizeof(struct get_console_renderer_events_request) == 16 );
965 C_ASSERT( sizeof(struct get_console_renderer_events_reply) == 8 );
966 C_ASSERT( FIELD_OFFSET(struct open_console_request, from) == 12 );
967 C_ASSERT( FIELD_OFFSET(struct open_console_request, access) == 16 );
968 C_ASSERT( FIELD_OFFSET(struct open_console_request, attributes) == 20 );
969 C_ASSERT( FIELD_OFFSET(struct open_console_request, share) == 24 );
970 C_ASSERT( sizeof(struct open_console_request) == 32 );
971 C_ASSERT( FIELD_OFFSET(struct open_console_reply, handle) == 8 );
972 C_ASSERT( sizeof(struct open_console_reply) == 16 );
973 C_ASSERT( sizeof(struct get_console_wait_event_request) == 16 );
974 C_ASSERT( FIELD_OFFSET(struct get_console_wait_event_reply, handle) == 8 );
975 C_ASSERT( sizeof(struct get_console_wait_event_reply) == 16 );
976 C_ASSERT( FIELD_OFFSET(struct get_console_mode_request, handle) == 12 );
977 C_ASSERT( sizeof(struct get_console_mode_request) == 16 );
978 C_ASSERT( FIELD_OFFSET(struct get_console_mode_reply, mode) == 8 );
979 C_ASSERT( sizeof(struct get_console_mode_reply) == 16 );
980 C_ASSERT( FIELD_OFFSET(struct set_console_mode_request, handle) == 12 );
981 C_ASSERT( FIELD_OFFSET(struct set_console_mode_request, mode) == 16 );
982 C_ASSERT( sizeof(struct set_console_mode_request) == 24 );
983 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, handle) == 12 );
984 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, mask) == 16 );
985 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, active_sb) == 20 );
986 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, history_mode) == 24 );
987 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, history_size) == 28 );
988 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, edition_mode) == 32 );
989 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, input_cp) == 36 );
990 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, output_cp) == 40 );
991 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, win) == 44 );
992 C_ASSERT( sizeof(struct set_console_input_info_request) == 48 );
993 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_request, handle) == 12 );
994 C_ASSERT( sizeof(struct get_console_input_info_request) == 16 );
995 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, history_mode) == 8 );
996 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, history_size) == 12 );
997 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, history_index) == 16 );
998 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, edition_mode) == 20 );
999 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, input_cp) == 24 );
1000 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, output_cp) == 28 );
1001 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, win) == 32 );
1002 C_ASSERT( sizeof(struct get_console_input_info_reply) == 40 );
1003 C_ASSERT( FIELD_OFFSET(struct append_console_input_history_request, handle) == 12 );
1004 C_ASSERT( sizeof(struct append_console_input_history_request) == 16 );
1005 C_ASSERT( FIELD_OFFSET(struct get_console_input_history_request, handle) == 12 );
1006 C_ASSERT( FIELD_OFFSET(struct get_console_input_history_request, index) == 16 );
1007 C_ASSERT( sizeof(struct get_console_input_history_request) == 24 );
1008 C_ASSERT( FIELD_OFFSET(struct get_console_input_history_reply, total) == 8 );
1009 C_ASSERT( sizeof(struct get_console_input_history_reply) == 16 );
1010 C_ASSERT( FIELD_OFFSET(struct create_console_output_request, handle_in) == 12 );
1011 C_ASSERT( FIELD_OFFSET(struct create_console_output_request, access) == 16 );
1012 C_ASSERT( FIELD_OFFSET(struct create_console_output_request, attributes) == 20 );
1013 C_ASSERT( FIELD_OFFSET(struct create_console_output_request, share) == 24 );
1014 C_ASSERT( FIELD_OFFSET(struct create_console_output_request, fd) == 28 );
1015 C_ASSERT( sizeof(struct create_console_output_request) == 32 );
1016 C_ASSERT( FIELD_OFFSET(struct create_console_output_reply, handle_out) == 8 );
1017 C_ASSERT( sizeof(struct create_console_output_reply) == 16 );
1018 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, handle) == 12 );
1019 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, mask) == 16 );
1020 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, cursor_size) == 20 );
1021 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, cursor_visible) == 22 );
1022 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, cursor_x) == 24 );
1023 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, cursor_y) == 26 );
1024 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, width) == 28 );
1025 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, height) == 30 );
1026 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, attr) == 32 );
1027 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, win_left) == 34 );
1028 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, win_top) == 36 );
1029 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, win_right) == 38 );
1030 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, win_bottom) == 40 );
1031 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, max_width) == 42 );
1032 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, max_height) == 44 );
1033 C_ASSERT( sizeof(struct set_console_output_info_request) == 48 );
1034 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_request, handle) == 12 );
1035 C_ASSERT( sizeof(struct get_console_output_info_request) == 16 );
1036 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_size) == 8 );
1037 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_visible) == 10 );
1038 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_x) == 12 );
1039 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_y) == 14 );
1040 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, width) == 16 );
1041 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, height) == 18 );
1042 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, attr) == 20 );
1043 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, win_left) == 22 );
1044 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, win_top) == 24 );
1045 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, win_right) == 26 );
1046 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, win_bottom) == 28 );
1047 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, max_width) == 30 );
1048 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, max_height) == 32 );
1049 C_ASSERT( sizeof(struct get_console_output_info_reply) == 40 );
1050 C_ASSERT( FIELD_OFFSET(struct write_console_input_request, handle) == 12 );
1051 C_ASSERT( sizeof(struct write_console_input_request) == 16 );
1052 C_ASSERT( FIELD_OFFSET(struct write_console_input_reply, written) == 8 );
1053 C_ASSERT( sizeof(struct write_console_input_reply) == 16 );
1054 C_ASSERT( FIELD_OFFSET(struct read_console_input_request, handle) == 12 );
1055 C_ASSERT( FIELD_OFFSET(struct read_console_input_request, flush) == 16 );
1056 C_ASSERT( sizeof(struct read_console_input_request) == 24 );
1057 C_ASSERT( FIELD_OFFSET(struct read_console_input_reply, read) == 8 );
1058 C_ASSERT( sizeof(struct read_console_input_reply) == 16 );
1059 C_ASSERT( FIELD_OFFSET(struct write_console_output_request, handle) == 12 );
1060 C_ASSERT( FIELD_OFFSET(struct write_console_output_request, x) == 16 );
1061 C_ASSERT( FIELD_OFFSET(struct write_console_output_request, y) == 20 );
1062 C_ASSERT( FIELD_OFFSET(struct write_console_output_request, mode) == 24 );
1063 C_ASSERT( FIELD_OFFSET(struct write_console_output_request, wrap) == 28 );
1064 C_ASSERT( sizeof(struct write_console_output_request) == 32 );
1065 C_ASSERT( FIELD_OFFSET(struct write_console_output_reply, written) == 8 );
1066 C_ASSERT( FIELD_OFFSET(struct write_console_output_reply, width) == 12 );
1067 C_ASSERT( FIELD_OFFSET(struct write_console_output_reply, height) == 16 );
1068 C_ASSERT( sizeof(struct write_console_output_reply) == 24 );
1069 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, handle) == 12 );
1070 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, x) == 16 );
1071 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, y) == 20 );
1072 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, mode) == 24 );
1073 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, count) == 28 );
1074 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, wrap) == 32 );
1075 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, data) == 36 );
1076 C_ASSERT( sizeof(struct fill_console_output_request) == 40 );
1077 C_ASSERT( FIELD_OFFSET(struct fill_console_output_reply, written) == 8 );
1078 C_ASSERT( sizeof(struct fill_console_output_reply) == 16 );
1079 C_ASSERT( FIELD_OFFSET(struct read_console_output_request, handle) == 12 );
1080 C_ASSERT( FIELD_OFFSET(struct read_console_output_request, x) == 16 );
1081 C_ASSERT( FIELD_OFFSET(struct read_console_output_request, y) == 20 );
1082 C_ASSERT( FIELD_OFFSET(struct read_console_output_request, mode) == 24 );
1083 C_ASSERT( FIELD_OFFSET(struct read_console_output_request, wrap) == 28 );
1084 C_ASSERT( sizeof(struct read_console_output_request) == 32 );
1085 C_ASSERT( FIELD_OFFSET(struct read_console_output_reply, width) == 8 );
1086 C_ASSERT( FIELD_OFFSET(struct read_console_output_reply, height) == 12 );
1087 C_ASSERT( sizeof(struct read_console_output_reply) == 16 );
1088 C_ASSERT( FIELD_OFFSET(struct move_console_output_request, handle) == 12 );
1089 C_ASSERT( FIELD_OFFSET(struct move_console_output_request, x_src) == 16 );
1090 C_ASSERT( FIELD_OFFSET(struct move_console_output_request, y_src) == 18 );
1091 C_ASSERT( FIELD_OFFSET(struct move_console_output_request, x_dst) == 20 );
1092 C_ASSERT( FIELD_OFFSET(struct move_console_output_request, y_dst) == 22 );
1093 C_ASSERT( FIELD_OFFSET(struct move_console_output_request, w) == 24 );
1094 C_ASSERT( FIELD_OFFSET(struct move_console_output_request, h) == 26 );
1095 C_ASSERT( sizeof(struct move_console_output_request) == 32 );
1096 C_ASSERT( FIELD_OFFSET(struct send_console_signal_request, signal) == 12 );
1097 C_ASSERT( FIELD_OFFSET(struct send_console_signal_request, group_id) == 16 );
1098 C_ASSERT( sizeof(struct send_console_signal_request) == 24 );
1099 C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, filter) == 12 );
1100 C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, subtree) == 16 );
1101 C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, want_data) == 20 );
1102 C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, async) == 24 );
1103 C_ASSERT( sizeof(struct read_directory_changes_request) == 64 );
1104 C_ASSERT( FIELD_OFFSET(struct read_change_request, handle) == 12 );
1105 C_ASSERT( sizeof(struct read_change_request) == 16 );
1106 C_ASSERT( FIELD_OFFSET(struct read_change_reply, action) == 8 );
1107 C_ASSERT( sizeof(struct read_change_reply) == 16 );
1108 C_ASSERT( FIELD_OFFSET(struct create_mapping_request, access) == 12 );
1109 C_ASSERT( FIELD_OFFSET(struct create_mapping_request, attributes) == 16 );
1110 C_ASSERT( FIELD_OFFSET(struct create_mapping_request, protect) == 20 );
1111 C_ASSERT( FIELD_OFFSET(struct create_mapping_request, size) == 24 );
1112 C_ASSERT( FIELD_OFFSET(struct create_mapping_request, file_handle) == 32 );
1113 C_ASSERT( sizeof(struct create_mapping_request) == 40 );
1114 C_ASSERT( FIELD_OFFSET(struct create_mapping_reply, handle) == 8 );
1115 C_ASSERT( sizeof(struct create_mapping_reply) == 16 );
1116 C_ASSERT( FIELD_OFFSET(struct open_mapping_request, access) == 12 );
1117 C_ASSERT( FIELD_OFFSET(struct open_mapping_request, attributes) == 16 );
1118 C_ASSERT( FIELD_OFFSET(struct open_mapping_request, rootdir) == 20 );
1119 C_ASSERT( sizeof(struct open_mapping_request) == 24 );
1120 C_ASSERT( FIELD_OFFSET(struct open_mapping_reply, handle) == 8 );
1121 C_ASSERT( sizeof(struct open_mapping_reply) == 16 );
1122 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request, handle) == 12 );
1123 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request, access) == 16 );
1124 C_ASSERT( sizeof(struct get_mapping_info_request) == 24 );
1125 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, size) == 8 );
1126 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, protect) == 16 );
1127 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, header_size) == 20 );
1128 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, base) == 24 );
1129 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, mapping) == 32 );
1130 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, shared_file) == 36 );
1131 C_ASSERT( sizeof(struct get_mapping_info_reply) == 40 );
1132 C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request, handle) == 12 );
1133 C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request, offset) == 16 );
1134 C_ASSERT( sizeof(struct get_mapping_committed_range_request) == 24 );
1135 C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply, size) == 8 );
1136 C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply, committed) == 16 );
1137 C_ASSERT( sizeof(struct get_mapping_committed_range_reply) == 24 );
1138 C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, handle) == 12 );
1139 C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, offset) == 16 );
1140 C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, size) == 24 );
1141 C_ASSERT( sizeof(struct add_mapping_committed_range_request) == 32 );
1142 C_ASSERT( FIELD_OFFSET(struct create_snapshot_request, attributes) == 12 );
1143 C_ASSERT( FIELD_OFFSET(struct create_snapshot_request, flags) == 16 );
1144 C_ASSERT( sizeof(struct create_snapshot_request) == 24 );
1145 C_ASSERT( FIELD_OFFSET(struct create_snapshot_reply, handle) == 8 );
1146 C_ASSERT( sizeof(struct create_snapshot_reply) == 16 );
1147 C_ASSERT( FIELD_OFFSET(struct next_process_request, handle) == 12 );
1148 C_ASSERT( FIELD_OFFSET(struct next_process_request, reset) == 16 );
1149 C_ASSERT( sizeof(struct next_process_request) == 24 );
1150 C_ASSERT( FIELD_OFFSET(struct next_process_reply, count) == 8 );
1151 C_ASSERT( FIELD_OFFSET(struct next_process_reply, pid) == 12 );
1152 C_ASSERT( FIELD_OFFSET(struct next_process_reply, ppid) == 16 );
1153 C_ASSERT( FIELD_OFFSET(struct next_process_reply, threads) == 20 );
1154 C_ASSERT( FIELD_OFFSET(struct next_process_reply, priority) == 24 );
1155 C_ASSERT( FIELD_OFFSET(struct next_process_reply, handles) == 28 );
1156 C_ASSERT( sizeof(struct next_process_reply) == 32 );
1157 C_ASSERT( FIELD_OFFSET(struct next_thread_request, handle) == 12 );
1158 C_ASSERT( FIELD_OFFSET(struct next_thread_request, reset) == 16 );
1159 C_ASSERT( sizeof(struct next_thread_request) == 24 );
1160 C_ASSERT( FIELD_OFFSET(struct next_thread_reply, count) == 8 );
1161 C_ASSERT( FIELD_OFFSET(struct next_thread_reply, pid) == 12 );
1162 C_ASSERT( FIELD_OFFSET(struct next_thread_reply, tid) == 16 );
1163 C_ASSERT( FIELD_OFFSET(struct next_thread_reply, base_pri) == 20 );
1164 C_ASSERT( FIELD_OFFSET(struct next_thread_reply, delta_pri) == 24 );
1165 C_ASSERT( sizeof(struct next_thread_reply) == 32 );
1166 C_ASSERT( FIELD_OFFSET(struct wait_debug_event_request, get_handle) == 12 );
1167 C_ASSERT( sizeof(struct wait_debug_event_request) == 16 );
1168 C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, pid) == 8 );
1169 C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, tid) == 12 );
1170 C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, wait) == 16 );
1171 C_ASSERT( sizeof(struct wait_debug_event_reply) == 24 );
1172 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, first) == 12 );
1173 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, code) == 16 );
1174 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, flags) == 20 );
1175 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, record) == 24 );
1176 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, address) == 32 );
1177 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, len) == 40 );
1178 C_ASSERT( sizeof(struct queue_exception_event_request) == 48 );
1179 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_reply, handle) == 8 );
1180 C_ASSERT( sizeof(struct queue_exception_event_reply) == 16 );
1181 C_ASSERT( FIELD_OFFSET(struct get_exception_status_request, handle) == 12 );
1182 C_ASSERT( sizeof(struct get_exception_status_request) == 16 );
1183 C_ASSERT( sizeof(struct get_exception_status_reply) == 8 );
1184 C_ASSERT( FIELD_OFFSET(struct output_debug_string_request, length) == 12 );
1185 C_ASSERT( FIELD_OFFSET(struct output_debug_string_request, string) == 16 );
1186 C_ASSERT( sizeof(struct output_debug_string_request) == 24 );
1187 C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, pid) == 12 );
1188 C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, tid) == 16 );
1189 C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, status) == 20 );
1190 C_ASSERT( sizeof(struct continue_debug_event_request) == 24 );
1191 C_ASSERT( FIELD_OFFSET(struct debug_process_request, pid) == 12 );
1192 C_ASSERT( FIELD_OFFSET(struct debug_process_request, attach) == 16 );
1193 C_ASSERT( sizeof(struct debug_process_request) == 24 );
1194 C_ASSERT( FIELD_OFFSET(struct debug_break_request, handle) == 12 );
1195 C_ASSERT( sizeof(struct debug_break_request) == 16 );
1196 C_ASSERT( FIELD_OFFSET(struct debug_break_reply, self) == 8 );
1197 C_ASSERT( sizeof(struct debug_break_reply) == 16 );
1198 C_ASSERT( FIELD_OFFSET(struct set_debugger_kill_on_exit_request, kill_on_exit) == 12 );
1199 C_ASSERT( sizeof(struct set_debugger_kill_on_exit_request) == 16 );
1200 C_ASSERT( FIELD_OFFSET(struct read_process_memory_request, handle) == 12 );
1201 C_ASSERT( FIELD_OFFSET(struct read_process_memory_request, addr) == 16 );
1202 C_ASSERT( sizeof(struct read_process_memory_request) == 24 );
1203 C_ASSERT( sizeof(struct read_process_memory_reply) == 8 );
1204 C_ASSERT( FIELD_OFFSET(struct write_process_memory_request, handle) == 12 );
1205 C_ASSERT( FIELD_OFFSET(struct write_process_memory_request, addr) == 16 );
1206 C_ASSERT( sizeof(struct write_process_memory_request) == 24 );
1207 C_ASSERT( FIELD_OFFSET(struct create_key_request, parent) == 12 );
1208 C_ASSERT( FIELD_OFFSET(struct create_key_request, access) == 16 );
1209 C_ASSERT( FIELD_OFFSET(struct create_key_request, attributes) == 20 );
1210 C_ASSERT( FIELD_OFFSET(struct create_key_request, options) == 24 );
1211 C_ASSERT( FIELD_OFFSET(struct create_key_request, namelen) == 28 );
1212 C_ASSERT( sizeof(struct create_key_request) == 32 );
1213 C_ASSERT( FIELD_OFFSET(struct create_key_reply, hkey) == 8 );
1214 C_ASSERT( FIELD_OFFSET(struct create_key_reply, created) == 12 );
1215 C_ASSERT( sizeof(struct create_key_reply) == 16 );
1216 C_ASSERT( FIELD_OFFSET(struct open_key_request, parent) == 12 );
1217 C_ASSERT( FIELD_OFFSET(struct open_key_request, access) == 16 );
1218 C_ASSERT( FIELD_OFFSET(struct open_key_request, attributes) == 20 );
1219 C_ASSERT( sizeof(struct open_key_request) == 24 );
1220 C_ASSERT( FIELD_OFFSET(struct open_key_reply, hkey) == 8 );
1221 C_ASSERT( sizeof(struct open_key_reply) == 16 );
1222 C_ASSERT( FIELD_OFFSET(struct delete_key_request, hkey) == 12 );
1223 C_ASSERT( sizeof(struct delete_key_request) == 16 );
1224 C_ASSERT( FIELD_OFFSET(struct flush_key_request, hkey) == 12 );
1225 C_ASSERT( sizeof(struct flush_key_request) == 16 );
1226 C_ASSERT( FIELD_OFFSET(struct enum_key_request, hkey) == 12 );
1227 C_ASSERT( FIELD_OFFSET(struct enum_key_request, index) == 16 );
1228 C_ASSERT( FIELD_OFFSET(struct enum_key_request, info_class) == 20 );
1229 C_ASSERT( sizeof(struct enum_key_request) == 24 );
1230 C_ASSERT( FIELD_OFFSET(struct enum_key_reply, subkeys) == 8 );
1231 C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_subkey) == 12 );
1232 C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_class) == 16 );
1233 C_ASSERT( FIELD_OFFSET(struct enum_key_reply, values) == 20 );
1234 C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_value) == 24 );
1235 C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_data) == 28 );
1236 C_ASSERT( FIELD_OFFSET(struct enum_key_reply, modif) == 32 );
1237 C_ASSERT( FIELD_OFFSET(struct enum_key_reply, total) == 40 );
1238 C_ASSERT( FIELD_OFFSET(struct enum_key_reply, namelen) == 44 );
1239 C_ASSERT( sizeof(struct enum_key_reply) == 48 );
1240 C_ASSERT( FIELD_OFFSET(struct set_key_value_request, hkey) == 12 );
1241 C_ASSERT( FIELD_OFFSET(struct set_key_value_request, type) == 16 );
1242 C_ASSERT( FIELD_OFFSET(struct set_key_value_request, namelen) == 20 );
1243 C_ASSERT( sizeof(struct set_key_value_request) == 24 );
1244 C_ASSERT( FIELD_OFFSET(struct get_key_value_request, hkey) == 12 );
1245 C_ASSERT( sizeof(struct get_key_value_request) == 16 );
1246 C_ASSERT( FIELD_OFFSET(struct get_key_value_reply, type) == 8 );
1247 C_ASSERT( FIELD_OFFSET(struct get_key_value_reply, total) == 12 );
1248 C_ASSERT( sizeof(struct get_key_value_reply) == 16 );
1249 C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, hkey) == 12 );
1250 C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, index) == 16 );
1251 C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, info_class) == 20 );
1252 C_ASSERT( sizeof(struct enum_key_value_request) == 24 );
1253 C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, type) == 8 );
1254 C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, total) == 12 );
1255 C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, namelen) == 16 );
1256 C_ASSERT( sizeof(struct enum_key_value_reply) == 24 );
1257 C_ASSERT( FIELD_OFFSET(struct delete_key_value_request, hkey) == 12 );
1258 C_ASSERT( sizeof(struct delete_key_value_request) == 16 );
1259 C_ASSERT( FIELD_OFFSET(struct load_registry_request, hkey) == 12 );
1260 C_ASSERT( FIELD_OFFSET(struct load_registry_request, file) == 16 );
1261 C_ASSERT( sizeof(struct load_registry_request) == 24 );
1262 C_ASSERT( FIELD_OFFSET(struct unload_registry_request, hkey) == 12 );
1263 C_ASSERT( sizeof(struct unload_registry_request) == 16 );
1264 C_ASSERT( FIELD_OFFSET(struct save_registry_request, hkey) == 12 );
1265 C_ASSERT( FIELD_OFFSET(struct save_registry_request, file) == 16 );
1266 C_ASSERT( sizeof(struct save_registry_request) == 24 );
1267 C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, hkey) == 12 );
1268 C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, event) == 16 );
1269 C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, subtree) == 20 );
1270 C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, filter) == 24 );
1271 C_ASSERT( sizeof(struct set_registry_notification_request) == 32 );
1272 C_ASSERT( FIELD_OFFSET(struct create_timer_request, access) == 12 );
1273 C_ASSERT( FIELD_OFFSET(struct create_timer_request, attributes) == 16 );
1274 C_ASSERT( FIELD_OFFSET(struct create_timer_request, rootdir) == 20 );
1275 C_ASSERT( FIELD_OFFSET(struct create_timer_request, manual) == 24 );
1276 C_ASSERT( sizeof(struct create_timer_request) == 32 );
1277 C_ASSERT( FIELD_OFFSET(struct create_timer_reply, handle) == 8 );
1278 C_ASSERT( sizeof(struct create_timer_reply) == 16 );
1279 C_ASSERT( FIELD_OFFSET(struct open_timer_request, access) == 12 );
1280 C_ASSERT( FIELD_OFFSET(struct open_timer_request, attributes) == 16 );
1281 C_ASSERT( FIELD_OFFSET(struct open_timer_request, rootdir) == 20 );
1282 C_ASSERT( sizeof(struct open_timer_request) == 24 );
1283 C_ASSERT( FIELD_OFFSET(struct open_timer_reply, handle) == 8 );
1284 C_ASSERT( sizeof(struct open_timer_reply) == 16 );
1285 C_ASSERT( FIELD_OFFSET(struct set_timer_request, handle) == 12 );
1286 C_ASSERT( FIELD_OFFSET(struct set_timer_request, expire) == 16 );
1287 C_ASSERT( FIELD_OFFSET(struct set_timer_request, callback) == 24 );
1288 C_ASSERT( FIELD_OFFSET(struct set_timer_request, arg) == 32 );
1289 C_ASSERT( FIELD_OFFSET(struct set_timer_request, period) == 40 );
1290 C_ASSERT( sizeof(struct set_timer_request) == 48 );
1291 C_ASSERT( FIELD_OFFSET(struct set_timer_reply, signaled) == 8 );
1292 C_ASSERT( sizeof(struct set_timer_reply) == 16 );
1293 C_ASSERT( FIELD_OFFSET(struct cancel_timer_request, handle) == 12 );
1294 C_ASSERT( sizeof(struct cancel_timer_request) == 16 );
1295 C_ASSERT( FIELD_OFFSET(struct cancel_timer_reply, signaled) == 8 );
1296 C_ASSERT( sizeof(struct cancel_timer_reply) == 16 );
1297 C_ASSERT( FIELD_OFFSET(struct get_timer_info_request, handle) == 12 );
1298 C_ASSERT( sizeof(struct get_timer_info_request) == 16 );
1299 C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply, when) == 8 );
1300 C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply, signaled) == 16 );
1301 C_ASSERT( sizeof(struct get_timer_info_reply) == 24 );
1302 C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, handle) == 12 );
1303 C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, flags) == 16 );
1304 C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, suspend) == 20 );
1305 C_ASSERT( sizeof(struct get_thread_context_request) == 24 );
1306 C_ASSERT( FIELD_OFFSET(struct get_thread_context_reply, self) == 8 );
1307 C_ASSERT( sizeof(struct get_thread_context_reply) == 16 );
1308 C_ASSERT( FIELD_OFFSET(struct set_thread_context_request, handle) == 12 );
1309 C_ASSERT( FIELD_OFFSET(struct set_thread_context_request, suspend) == 16 );
1310 C_ASSERT( sizeof(struct set_thread_context_request) == 24 );
1311 C_ASSERT( FIELD_OFFSET(struct set_thread_context_reply, self) == 8 );
1312 C_ASSERT( sizeof(struct set_thread_context_reply) == 16 );
1313 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request, handle) == 12 );
1314 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request, entry) == 16 );
1315 C_ASSERT( sizeof(struct get_selector_entry_request) == 24 );
1316 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, base) == 8 );
1317 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, limit) == 12 );
1318 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, flags) == 16 );
1319 C_ASSERT( sizeof(struct get_selector_entry_reply) == 24 );
1320 C_ASSERT( FIELD_OFFSET(struct add_atom_request, table) == 12 );
1321 C_ASSERT( sizeof(struct add_atom_request) == 16 );
1322 C_ASSERT( FIELD_OFFSET(struct add_atom_reply, atom) == 8 );
1323 C_ASSERT( sizeof(struct add_atom_reply) == 16 );
1324 C_ASSERT( FIELD_OFFSET(struct delete_atom_request, table) == 12 );
1325 C_ASSERT( FIELD_OFFSET(struct delete_atom_request, atom) == 16 );
1326 C_ASSERT( sizeof(struct delete_atom_request) == 24 );
1327 C_ASSERT( FIELD_OFFSET(struct find_atom_request, table) == 12 );
1328 C_ASSERT( sizeof(struct find_atom_request) == 16 );
1329 C_ASSERT( FIELD_OFFSET(struct find_atom_reply, atom) == 8 );
1330 C_ASSERT( sizeof(struct find_atom_reply) == 16 );
1331 C_ASSERT( FIELD_OFFSET(struct get_atom_information_request, table) == 12 );
1332 C_ASSERT( FIELD_OFFSET(struct get_atom_information_request, atom) == 16 );
1333 C_ASSERT( sizeof(struct get_atom_information_request) == 24 );
1334 C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, count) == 8 );
1335 C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, pinned) == 12 );
1336 C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, total) == 16 );
1337 C_ASSERT( sizeof(struct get_atom_information_reply) == 24 );
1338 C_ASSERT( FIELD_OFFSET(struct set_atom_information_request, table) == 12 );
1339 C_ASSERT( FIELD_OFFSET(struct set_atom_information_request, atom) == 16 );
1340 C_ASSERT( FIELD_OFFSET(struct set_atom_information_request, pinned) == 20 );
1341 C_ASSERT( sizeof(struct set_atom_information_request) == 24 );
1342 C_ASSERT( FIELD_OFFSET(struct empty_atom_table_request, table) == 12 );
1343 C_ASSERT( FIELD_OFFSET(struct empty_atom_table_request, if_pinned) == 16 );
1344 C_ASSERT( sizeof(struct empty_atom_table_request) == 24 );
1345 C_ASSERT( FIELD_OFFSET(struct init_atom_table_request, entries) == 12 );
1346 C_ASSERT( sizeof(struct init_atom_table_request) == 16 );
1347 C_ASSERT( FIELD_OFFSET(struct init_atom_table_reply, table) == 8 );
1348 C_ASSERT( sizeof(struct init_atom_table_reply) == 16 );
1349 C_ASSERT( sizeof(struct get_msg_queue_request) == 16 );
1350 C_ASSERT( FIELD_OFFSET(struct get_msg_queue_reply, handle) == 8 );
1351 C_ASSERT( sizeof(struct get_msg_queue_reply) == 16 );
1352 C_ASSERT( FIELD_OFFSET(struct set_queue_fd_request, handle) == 12 );
1353 C_ASSERT( sizeof(struct set_queue_fd_request) == 16 );
1354 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, wake_mask) == 12 );
1355 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, changed_mask) == 16 );
1356 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, skip_wait) == 20 );
1357 C_ASSERT( sizeof(struct set_queue_mask_request) == 24 );
1358 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply, wake_bits) == 8 );
1359 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply, changed_bits) == 12 );
1360 C_ASSERT( sizeof(struct set_queue_mask_reply) == 16 );
1361 C_ASSERT( FIELD_OFFSET(struct get_queue_status_request, clear) == 12 );
1362 C_ASSERT( sizeof(struct get_queue_status_request) == 16 );
1363 C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply, wake_bits) == 8 );
1364 C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply, changed_bits) == 12 );
1365 C_ASSERT( sizeof(struct get_queue_status_reply) == 16 );
1366 C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_request, handle) == 12 );
1367 C_ASSERT( sizeof(struct get_process_idle_event_request) == 16 );
1368 C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_reply, event) == 8 );
1369 C_ASSERT( sizeof(struct get_process_idle_event_reply) == 16 );
1370 C_ASSERT( FIELD_OFFSET(struct send_message_request, id) == 12 );
1371 C_ASSERT( FIELD_OFFSET(struct send_message_request, type) == 16 );
1372 C_ASSERT( FIELD_OFFSET(struct send_message_request, flags) == 20 );
1373 C_ASSERT( FIELD_OFFSET(struct send_message_request, win) == 24 );
1374 C_ASSERT( FIELD_OFFSET(struct send_message_request, msg) == 28 );
1375 C_ASSERT( FIELD_OFFSET(struct send_message_request, wparam) == 32 );
1376 C_ASSERT( FIELD_OFFSET(struct send_message_request, lparam) == 40 );
1377 C_ASSERT( FIELD_OFFSET(struct send_message_request, timeout) == 48 );
1378 C_ASSERT( sizeof(struct send_message_request) == 56 );
1379 C_ASSERT( FIELD_OFFSET(struct post_quit_message_request, exit_code) == 12 );
1380 C_ASSERT( sizeof(struct post_quit_message_request) == 16 );
1381 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, id) == 12 );
1382 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, win) == 16 );
1383 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, msg) == 20 );
1384 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, wparam) == 24 );
1385 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, lparam) == 32 );
1386 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, info) == 40 );
1387 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, x) == 48 );
1388 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, y) == 52 );
1389 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, time) == 56 );
1390 C_ASSERT( sizeof(struct send_hardware_message_request) == 64 );
1391 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, cursor) == 8 );
1392 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, count) == 12 );
1393 C_ASSERT( sizeof(struct send_hardware_message_reply) == 16 );
1394 C_ASSERT( FIELD_OFFSET(struct get_message_request, flags) == 12 );
1395 C_ASSERT( FIELD_OFFSET(struct get_message_request, get_win) == 16 );
1396 C_ASSERT( FIELD_OFFSET(struct get_message_request, get_first) == 20 );
1397 C_ASSERT( FIELD_OFFSET(struct get_message_request, get_last) == 24 );
1398 C_ASSERT( FIELD_OFFSET(struct get_message_request, hw_id) == 28 );
1399 C_ASSERT( FIELD_OFFSET(struct get_message_request, wake_mask) == 32 );
1400 C_ASSERT( FIELD_OFFSET(struct get_message_request, changed_mask) == 36 );
1401 C_ASSERT( sizeof(struct get_message_request) == 40 );
1402 C_ASSERT( FIELD_OFFSET(struct get_message_reply, win) == 8 );
1403 C_ASSERT( FIELD_OFFSET(struct get_message_reply, msg) == 12 );
1404 C_ASSERT( FIELD_OFFSET(struct get_message_reply, wparam) == 16 );
1405 C_ASSERT( FIELD_OFFSET(struct get_message_reply, lparam) == 24 );
1406 C_ASSERT( FIELD_OFFSET(struct get_message_reply, type) == 32 );
1407 C_ASSERT( FIELD_OFFSET(struct get_message_reply, time) == 36 );
1408 C_ASSERT( FIELD_OFFSET(struct get_message_reply, active_hooks) == 40 );
1409 C_ASSERT( FIELD_OFFSET(struct get_message_reply, total) == 44 );
1410 C_ASSERT( sizeof(struct get_message_reply) == 48 );
1411 C_ASSERT( FIELD_OFFSET(struct reply_message_request, remove) == 12 );
1412 C_ASSERT( FIELD_OFFSET(struct reply_message_request, result) == 16 );
1413 C_ASSERT( sizeof(struct reply_message_request) == 24 );
1414 C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request, hw_id) == 12 );
1415 C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request, remove) == 16 );
1416 C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request, new_win) == 20 );
1417 C_ASSERT( sizeof(struct accept_hardware_message_request) == 24 );
1418 C_ASSERT( FIELD_OFFSET(struct get_message_reply_request, cancel) == 12 );
1419 C_ASSERT( sizeof(struct get_message_reply_request) == 16 );
1420 C_ASSERT( FIELD_OFFSET(struct get_message_reply_reply, result) == 8 );
1421 C_ASSERT( sizeof(struct get_message_reply_reply) == 16 );
1422 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, win) == 12 );
1423 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, msg) == 16 );
1424 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, rate) == 20 );
1425 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, id) == 24 );
1426 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, lparam) == 32 );
1427 C_ASSERT( sizeof(struct set_win_timer_request) == 40 );
1428 C_ASSERT( FIELD_OFFSET(struct set_win_timer_reply, id) == 8 );
1429 C_ASSERT( sizeof(struct set_win_timer_reply) == 16 );
1430 C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, win) == 12 );
1431 C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, id) == 16 );
1432 C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, msg) == 24 );
1433 C_ASSERT( sizeof(struct kill_win_timer_request) == 32 );
1434 C_ASSERT( FIELD_OFFSET(struct is_window_hung_request, win) == 12 );
1435 C_ASSERT( sizeof(struct is_window_hung_request) == 16 );
1436 C_ASSERT( FIELD_OFFSET(struct is_window_hung_reply, is_hung) == 8 );
1437 C_ASSERT( sizeof(struct is_window_hung_reply) == 16 );
1438 C_ASSERT( FIELD_OFFSET(struct get_serial_info_request, handle) == 12 );
1439 C_ASSERT( sizeof(struct get_serial_info_request) == 16 );
1440 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, readinterval) == 8 );
1441 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, readconst) == 12 );
1442 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, readmult) == 16 );
1443 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, writeconst) == 20 );
1444 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, writemult) == 24 );
1445 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, eventmask) == 28 );
1446 C_ASSERT( sizeof(struct get_serial_info_reply) == 32 );
1447 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, handle) == 12 );
1448 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, flags) == 16 );
1449 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, readinterval) == 20 );
1450 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, readconst) == 24 );
1451 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, readmult) == 28 );
1452 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, writeconst) == 32 );
1453 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, writemult) == 36 );
1454 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, eventmask) == 40 );
1455 C_ASSERT( sizeof(struct set_serial_info_request) == 48 );
1456 C_ASSERT( FIELD_OFFSET(struct register_async_request, type) == 12 );
1457 C_ASSERT( FIELD_OFFSET(struct register_async_request, async) == 16 );
1458 C_ASSERT( FIELD_OFFSET(struct register_async_request, count) == 56 );
1459 C_ASSERT( sizeof(struct register_async_request) == 64 );
1460 C_ASSERT( FIELD_OFFSET(struct cancel_async_request, handle) == 12 );
1461 C_ASSERT( FIELD_OFFSET(struct cancel_async_request, iosb) == 16 );
1462 C_ASSERT( FIELD_OFFSET(struct cancel_async_request, only_thread) == 24 );
1463 C_ASSERT( sizeof(struct cancel_async_request) == 32 );
1464 C_ASSERT( FIELD_OFFSET(struct ioctl_request, code) == 12 );
1465 C_ASSERT( FIELD_OFFSET(struct ioctl_request, async) == 16 );
1466 C_ASSERT( FIELD_OFFSET(struct ioctl_request, blocking) == 56 );
1467 C_ASSERT( sizeof(struct ioctl_request) == 64 );
1468 C_ASSERT( FIELD_OFFSET(struct ioctl_reply, wait) == 8 );
1469 C_ASSERT( FIELD_OFFSET(struct ioctl_reply, options) == 12 );
1470 C_ASSERT( sizeof(struct ioctl_reply) == 16 );
1471 C_ASSERT( FIELD_OFFSET(struct get_ioctl_result_request, handle) == 12 );
1472 C_ASSERT( FIELD_OFFSET(struct get_ioctl_result_request, user_arg) == 16 );
1473 C_ASSERT( sizeof(struct get_ioctl_result_request) == 24 );
1474 C_ASSERT( sizeof(struct get_ioctl_result_reply) == 8 );
1475 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, access) == 12 );
1476 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, attributes) == 16 );
1477 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, rootdir) == 20 );
1478 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, options) == 24 );
1479 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, maxinstances) == 28 );
1480 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, outsize) == 32 );
1481 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, insize) == 36 );
1482 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, timeout) == 40 );
1483 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, flags) == 48 );
1484 C_ASSERT( sizeof(struct create_named_pipe_request) == 56 );
1485 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_reply, handle) == 8 );
1486 C_ASSERT( sizeof(struct create_named_pipe_reply) == 16 );
1487 C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_request, handle) == 12 );
1488 C_ASSERT( sizeof(struct get_named_pipe_info_request) == 16 );
1489 C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, flags) == 8 );
1490 C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, maxinstances) == 12 );
1491 C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, instances) == 16 );
1492 C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, outsize) == 20 );
1493 C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, insize) == 24 );
1494 C_ASSERT( sizeof(struct get_named_pipe_info_reply) == 32 );
1495 C_ASSERT( FIELD_OFFSET(struct create_window_request, parent) == 12 );
1496 C_ASSERT( FIELD_OFFSET(struct create_window_request, owner) == 16 );
1497 C_ASSERT( FIELD_OFFSET(struct create_window_request, atom) == 20 );
1498 C_ASSERT( FIELD_OFFSET(struct create_window_request, instance) == 24 );
1499 C_ASSERT( sizeof(struct create_window_request) == 32 );
1500 C_ASSERT( FIELD_OFFSET(struct create_window_reply, handle) == 8 );
1501 C_ASSERT( FIELD_OFFSET(struct create_window_reply, parent) == 12 );
1502 C_ASSERT( FIELD_OFFSET(struct create_window_reply, owner) == 16 );
1503 C_ASSERT( FIELD_OFFSET(struct create_window_reply, extra) == 20 );
1504 C_ASSERT( FIELD_OFFSET(struct create_window_reply, class_ptr) == 24 );
1505 C_ASSERT( sizeof(struct create_window_reply) == 32 );
1506 C_ASSERT( FIELD_OFFSET(struct destroy_window_request, handle) == 12 );
1507 C_ASSERT( sizeof(struct destroy_window_request) == 16 );
1508 C_ASSERT( FIELD_OFFSET(struct get_desktop_window_request, force) == 12 );
1509 C_ASSERT( sizeof(struct get_desktop_window_request) == 16 );
1510 C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply, top_window) == 8 );
1511 C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply, msg_window) == 12 );
1512 C_ASSERT( sizeof(struct get_desktop_window_reply) == 16 );
1513 C_ASSERT( FIELD_OFFSET(struct set_window_owner_request, handle) == 12 );
1514 C_ASSERT( FIELD_OFFSET(struct set_window_owner_request, owner) == 16 );
1515 C_ASSERT( sizeof(struct set_window_owner_request) == 24 );
1516 C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply, full_owner) == 8 );
1517 C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply, prev_owner) == 12 );
1518 C_ASSERT( sizeof(struct set_window_owner_reply) == 16 );
1519 C_ASSERT( FIELD_OFFSET(struct get_window_info_request, handle) == 12 );
1520 C_ASSERT( sizeof(struct get_window_info_request) == 16 );
1521 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, full_handle) == 8 );
1522 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, last_active) == 12 );
1523 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, pid) == 16 );
1524 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, tid) == 20 );
1525 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, atom) == 24 );
1526 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, is_unicode) == 28 );
1527 C_ASSERT( sizeof(struct get_window_info_reply) == 32 );
1528 C_ASSERT( FIELD_OFFSET(struct set_window_info_request, flags) == 12 );
1529 C_ASSERT( FIELD_OFFSET(struct set_window_info_request, is_unicode) == 14 );
1530 C_ASSERT( FIELD_OFFSET(struct set_window_info_request, handle) == 16 );
1531 C_ASSERT( FIELD_OFFSET(struct set_window_info_request, style) == 20 );
1532 C_ASSERT( FIELD_OFFSET(struct set_window_info_request, ex_style) == 24 );
1533 C_ASSERT( FIELD_OFFSET(struct set_window_info_request, id) == 28 );
1534 C_ASSERT( FIELD_OFFSET(struct set_window_info_request, instance) == 32 );
1535 C_ASSERT( FIELD_OFFSET(struct set_window_info_request, user_data) == 40 );
1536 C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_offset) == 48 );
1537 C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_size) == 52 );
1538 C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_value) == 56 );
1539 C_ASSERT( sizeof(struct set_window_info_request) == 64 );
1540 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_style) == 8 );
1541 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_ex_style) == 12 );
1542 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_instance) == 16 );
1543 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_user_data) == 24 );
1544 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_extra_value) == 32 );
1545 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_id) == 40 );
1546 C_ASSERT( sizeof(struct set_window_info_reply) == 48 );
1547 C_ASSERT( FIELD_OFFSET(struct set_parent_request, handle) == 12 );
1548 C_ASSERT( FIELD_OFFSET(struct set_parent_request, parent) == 16 );
1549 C_ASSERT( sizeof(struct set_parent_request) == 24 );
1550 C_ASSERT( FIELD_OFFSET(struct set_parent_reply, old_parent) == 8 );
1551 C_ASSERT( FIELD_OFFSET(struct set_parent_reply, full_parent) == 12 );
1552 C_ASSERT( sizeof(struct set_parent_reply) == 16 );
1553 C_ASSERT( FIELD_OFFSET(struct get_window_parents_request, handle) == 12 );
1554 C_ASSERT( sizeof(struct get_window_parents_request) == 16 );
1555 C_ASSERT( FIELD_OFFSET(struct get_window_parents_reply, count) == 8 );
1556 C_ASSERT( sizeof(struct get_window_parents_reply) == 16 );
1557 C_ASSERT( FIELD_OFFSET(struct get_window_children_request, desktop) == 12 );
1558 C_ASSERT( FIELD_OFFSET(struct get_window_children_request, parent) == 16 );
1559 C_ASSERT( FIELD_OFFSET(struct get_window_children_request, atom) == 20 );
1560 C_ASSERT( FIELD_OFFSET(struct get_window_children_request, tid) == 24 );
1561 C_ASSERT( sizeof(struct get_window_children_request) == 32 );
1562 C_ASSERT( FIELD_OFFSET(struct get_window_children_reply, count) == 8 );
1563 C_ASSERT( sizeof(struct get_window_children_reply) == 16 );
1564 C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, parent) == 12 );
1565 C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, x) == 16 );
1566 C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, y) == 20 );
1567 C_ASSERT( sizeof(struct get_window_children_from_point_request) == 24 );
1568 C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_reply, count) == 8 );
1569 C_ASSERT( sizeof(struct get_window_children_from_point_reply) == 16 );
1570 C_ASSERT( FIELD_OFFSET(struct get_window_tree_request, handle) == 12 );
1571 C_ASSERT( sizeof(struct get_window_tree_request) == 16 );
1572 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, parent) == 8 );
1573 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, owner) == 12 );
1574 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, next_sibling) == 16 );
1575 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, prev_sibling) == 20 );
1576 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, first_sibling) == 24 );
1577 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, last_sibling) == 28 );
1578 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, first_child) == 32 );
1579 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, last_child) == 36 );
1580 C_ASSERT( sizeof(struct get_window_tree_reply) == 40 );
1581 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, flags) == 12 );
1582 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, handle) == 16 );
1583 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, previous) == 20 );
1584 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, window) == 24 );
1585 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, client) == 40 );
1586 C_ASSERT( sizeof(struct set_window_pos_request) == 56 );
1587 C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, new_style) == 8 );
1588 C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, new_ex_style) == 12 );
1589 C_ASSERT( sizeof(struct set_window_pos_reply) == 16 );
1590 C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, handle) == 12 );
1591 C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, relative) == 16 );
1592 C_ASSERT( sizeof(struct get_window_rectangles_request) == 24 );
1593 C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, window) == 8 );
1594 C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, visible) == 24 );
1595 C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, client) == 40 );
1596 C_ASSERT( sizeof(struct get_window_rectangles_reply) == 56 );
1597 C_ASSERT( FIELD_OFFSET(struct get_window_text_request, handle) == 12 );
1598 C_ASSERT( sizeof(struct get_window_text_request) == 16 );
1599 C_ASSERT( sizeof(struct get_window_text_reply) == 8 );
1600 C_ASSERT( FIELD_OFFSET(struct set_window_text_request, handle) == 12 );
1601 C_ASSERT( sizeof(struct set_window_text_request) == 16 );
1602 C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, from) == 12 );
1603 C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, to) == 16 );
1604 C_ASSERT( sizeof(struct get_windows_offset_request) == 24 );
1605 C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, x) == 8 );
1606 C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, y) == 12 );
1607 C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, mirror) == 16 );
1608 C_ASSERT( sizeof(struct get_windows_offset_reply) == 24 );
1609 C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, window) == 12 );
1610 C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, flags) == 16 );
1611 C_ASSERT( sizeof(struct get_visible_region_request) == 24 );
1612 C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, top_win) == 8 );
1613 C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, top_rect) == 12 );
1614 C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, win_rect) == 28 );
1615 C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, total_size) == 44 );
1616 C_ASSERT( sizeof(struct get_visible_region_reply) == 48 );
1617 C_ASSERT( FIELD_OFFSET(struct get_window_region_request, window) == 12 );
1618 C_ASSERT( sizeof(struct get_window_region_request) == 16 );
1619 C_ASSERT( FIELD_OFFSET(struct get_window_region_reply, total_size) == 8 );
1620 C_ASSERT( sizeof(struct get_window_region_reply) == 16 );
1621 C_ASSERT( FIELD_OFFSET(struct set_window_region_request, window) == 12 );
1622 C_ASSERT( FIELD_OFFSET(struct set_window_region_request, redraw) == 16 );
1623 C_ASSERT( sizeof(struct set_window_region_request) == 24 );
1624 C_ASSERT( FIELD_OFFSET(struct get_update_region_request, window) == 12 );
1625 C_ASSERT( FIELD_OFFSET(struct get_update_region_request, from_child) == 16 );
1626 C_ASSERT( FIELD_OFFSET(struct get_update_region_request, flags) == 20 );
1627 C_ASSERT( sizeof(struct get_update_region_request) == 24 );
1628 C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, child) == 8 );
1629 C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, flags) == 12 );
1630 C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, total_size) == 16 );
1631 C_ASSERT( sizeof(struct get_update_region_reply) == 24 );
1632 C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request, window) == 12 );
1633 C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request, rect) == 16 );
1634 C_ASSERT( sizeof(struct update_window_zorder_request) == 32 );
1635 C_ASSERT( FIELD_OFFSET(struct redraw_window_request, window) == 12 );
1636 C_ASSERT( FIELD_OFFSET(struct redraw_window_request, flags) == 16 );
1637 C_ASSERT( sizeof(struct redraw_window_request) == 24 );
1638 C_ASSERT( FIELD_OFFSET(struct set_window_property_request, window) == 12 );
1639 C_ASSERT( FIELD_OFFSET(struct set_window_property_request, data) == 16 );
1640 C_ASSERT( FIELD_OFFSET(struct set_window_property_request, atom) == 24 );
1641 C_ASSERT( sizeof(struct set_window_property_request) == 32 );
1642 C_ASSERT( FIELD_OFFSET(struct remove_window_property_request, window) == 12 );
1643 C_ASSERT( FIELD_OFFSET(struct remove_window_property_request, atom) == 16 );
1644 C_ASSERT( sizeof(struct remove_window_property_request) == 24 );
1645 C_ASSERT( FIELD_OFFSET(struct remove_window_property_reply, data) == 8 );
1646 C_ASSERT( sizeof(struct remove_window_property_reply) == 16 );
1647 C_ASSERT( FIELD_OFFSET(struct get_window_property_request, window) == 12 );
1648 C_ASSERT( FIELD_OFFSET(struct get_window_property_request, atom) == 16 );
1649 C_ASSERT( sizeof(struct get_window_property_request) == 24 );
1650 C_ASSERT( FIELD_OFFSET(struct get_window_property_reply, data) == 8 );
1651 C_ASSERT( sizeof(struct get_window_property_reply) == 16 );
1652 C_ASSERT( FIELD_OFFSET(struct get_window_properties_request, window) == 12 );
1653 C_ASSERT( sizeof(struct get_window_properties_request) == 16 );
1654 C_ASSERT( FIELD_OFFSET(struct get_window_properties_reply, total) == 8 );
1655 C_ASSERT( sizeof(struct get_window_properties_reply) == 16 );
1656 C_ASSERT( FIELD_OFFSET(struct create_winstation_request, flags) == 12 );
1657 C_ASSERT( FIELD_OFFSET(struct create_winstation_request, access) == 16 );
1658 C_ASSERT( FIELD_OFFSET(struct create_winstation_request, attributes) == 20 );
1659 C_ASSERT( sizeof(struct create_winstation_request) == 24 );
1660 C_ASSERT( FIELD_OFFSET(struct create_winstation_reply, handle) == 8 );
1661 C_ASSERT( sizeof(struct create_winstation_reply) == 16 );
1662 C_ASSERT( FIELD_OFFSET(struct open_winstation_request, access) == 12 );
1663 C_ASSERT( FIELD_OFFSET(struct open_winstation_request, attributes) == 16 );
1664 C_ASSERT( sizeof(struct open_winstation_request) == 24 );
1665 C_ASSERT( FIELD_OFFSET(struct open_winstation_reply, handle) == 8 );
1666 C_ASSERT( sizeof(struct open_winstation_reply) == 16 );
1667 C_ASSERT( FIELD_OFFSET(struct close_winstation_request, handle) == 12 );
1668 C_ASSERT( sizeof(struct close_winstation_request) == 16 );
1669 C_ASSERT( sizeof(struct get_process_winstation_request) == 16 );
1670 C_ASSERT( FIELD_OFFSET(struct get_process_winstation_reply, handle) == 8 );
1671 C_ASSERT( sizeof(struct get_process_winstation_reply) == 16 );
1672 C_ASSERT( FIELD_OFFSET(struct set_process_winstation_request, handle) == 12 );
1673 C_ASSERT( sizeof(struct set_process_winstation_request) == 16 );
1674 C_ASSERT( FIELD_OFFSET(struct enum_winstation_request, index) == 12 );
1675 C_ASSERT( sizeof(struct enum_winstation_request) == 16 );
1676 C_ASSERT( FIELD_OFFSET(struct enum_winstation_reply, next) == 8 );
1677 C_ASSERT( sizeof(struct enum_winstation_reply) == 16 );
1678 C_ASSERT( FIELD_OFFSET(struct create_desktop_request, flags) == 12 );
1679 C_ASSERT( FIELD_OFFSET(struct create_desktop_request, access) == 16 );
1680 C_ASSERT( FIELD_OFFSET(struct create_desktop_request, attributes) == 20 );
1681 C_ASSERT( sizeof(struct create_desktop_request) == 24 );
1682 C_ASSERT( FIELD_OFFSET(struct create_desktop_reply, handle) == 8 );
1683 C_ASSERT( sizeof(struct create_desktop_reply) == 16 );
1684 C_ASSERT( FIELD_OFFSET(struct open_desktop_request, winsta) == 12 );
1685 C_ASSERT( FIELD_OFFSET(struct open_desktop_request, flags) == 16 );
1686 C_ASSERT( FIELD_OFFSET(struct open_desktop_request, access) == 20 );
1687 C_ASSERT( FIELD_OFFSET(struct open_desktop_request, attributes) == 24 );
1688 C_ASSERT( sizeof(struct open_desktop_request) == 32 );
1689 C_ASSERT( FIELD_OFFSET(struct open_desktop_reply, handle) == 8 );
1690 C_ASSERT( sizeof(struct open_desktop_reply) == 16 );
1691 C_ASSERT( FIELD_OFFSET(struct close_desktop_request, handle) == 12 );
1692 C_ASSERT( sizeof(struct close_desktop_request) == 16 );
1693 C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_request, tid) == 12 );
1694 C_ASSERT( sizeof(struct get_thread_desktop_request) == 16 );
1695 C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_reply, handle) == 8 );
1696 C_ASSERT( sizeof(struct get_thread_desktop_reply) == 16 );
1697 C_ASSERT( FIELD_OFFSET(struct set_thread_desktop_request, handle) == 12 );
1698 C_ASSERT( sizeof(struct set_thread_desktop_request) == 16 );
1699 C_ASSERT( FIELD_OFFSET(struct enum_desktop_request, winstation) == 12 );
1700 C_ASSERT( FIELD_OFFSET(struct enum_desktop_request, index) == 16 );
1701 C_ASSERT( sizeof(struct enum_desktop_request) == 24 );
1702 C_ASSERT( FIELD_OFFSET(struct enum_desktop_reply, next) == 8 );
1703 C_ASSERT( sizeof(struct enum_desktop_reply) == 16 );
1704 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, handle) == 12 );
1705 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, flags) == 16 );
1706 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, obj_flags) == 20 );
1707 C_ASSERT( sizeof(struct set_user_object_info_request) == 24 );
1708 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply, is_desktop) == 8 );
1709 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply, old_obj_flags) == 12 );
1710 C_ASSERT( sizeof(struct set_user_object_info_reply) == 16 );
1711 C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, tid_from) == 12 );
1712 C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, tid_to) == 16 );
1713 C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, attach) == 20 );
1714 C_ASSERT( sizeof(struct attach_thread_input_request) == 24 );
1715 C_ASSERT( FIELD_OFFSET(struct get_thread_input_request, tid) == 12 );
1716 C_ASSERT( sizeof(struct get_thread_input_request) == 16 );
1717 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, focus) == 8 );
1718 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, capture) == 12 );
1719 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, active) == 16 );
1720 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, foreground) == 20 );
1721 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, menu_owner) == 24 );
1722 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, move_size) == 28 );
1723 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, caret) == 32 );
1724 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, cursor) == 36 );
1725 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, show_count) == 40 );
1726 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, rect) == 44 );
1727 C_ASSERT( sizeof(struct get_thread_input_reply) == 64 );
1728 C_ASSERT( sizeof(struct get_last_input_time_request) == 16 );
1729 C_ASSERT( FIELD_OFFSET(struct get_last_input_time_reply, time) == 8 );
1730 C_ASSERT( sizeof(struct get_last_input_time_reply) == 16 );
1731 C_ASSERT( FIELD_OFFSET(struct get_key_state_request, tid) == 12 );
1732 C_ASSERT( FIELD_OFFSET(struct get_key_state_request, key) == 16 );
1733 C_ASSERT( sizeof(struct get_key_state_request) == 24 );
1734 C_ASSERT( FIELD_OFFSET(struct get_key_state_reply, state) == 8 );
1735 C_ASSERT( sizeof(struct get_key_state_reply) == 16 );
1736 C_ASSERT( FIELD_OFFSET(struct set_key_state_request, tid) == 12 );
1737 C_ASSERT( sizeof(struct set_key_state_request) == 16 );
1738 C_ASSERT( FIELD_OFFSET(struct set_foreground_window_request, handle) == 12 );
1739 C_ASSERT( sizeof(struct set_foreground_window_request) == 16 );
1740 C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, previous) == 8 );
1741 C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, send_msg_old) == 12 );
1742 C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, send_msg_new) == 16 );
1743 C_ASSERT( sizeof(struct set_foreground_window_reply) == 24 );
1744 C_ASSERT( FIELD_OFFSET(struct set_focus_window_request, handle) == 12 );
1745 C_ASSERT( sizeof(struct set_focus_window_request) == 16 );
1746 C_ASSERT( FIELD_OFFSET(struct set_focus_window_reply, previous) == 8 );
1747 C_ASSERT( sizeof(struct set_focus_window_reply) == 16 );
1748 C_ASSERT( FIELD_OFFSET(struct set_active_window_request, handle) == 12 );
1749 C_ASSERT( sizeof(struct set_active_window_request) == 16 );
1750 C_ASSERT( FIELD_OFFSET(struct set_active_window_reply, previous) == 8 );
1751 C_ASSERT( sizeof(struct set_active_window_reply) == 16 );
1752 C_ASSERT( FIELD_OFFSET(struct set_capture_window_request, handle) == 12 );
1753 C_ASSERT( FIELD_OFFSET(struct set_capture_window_request, flags) == 16 );
1754 C_ASSERT( sizeof(struct set_capture_window_request) == 24 );
1755 C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply, previous) == 8 );
1756 C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply, full_handle) == 12 );
1757 C_ASSERT( sizeof(struct set_capture_window_reply) == 16 );
1758 C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, handle) == 12 );
1759 C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, width) == 16 );
1760 C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, height) == 20 );
1761 C_ASSERT( sizeof(struct set_caret_window_request) == 24 );
1762 C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, previous) == 8 );
1763 C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_rect) == 12 );
1764 C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_hide) == 28 );
1765 C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_state) == 32 );
1766 C_ASSERT( sizeof(struct set_caret_window_reply) == 40 );
1767 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, flags) == 12 );
1768 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, handle) == 16 );
1769 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, x) == 20 );
1770 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, y) == 24 );
1771 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, hide) == 28 );
1772 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, state) == 32 );
1773 C_ASSERT( sizeof(struct set_caret_info_request) == 40 );
1774 C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, full_handle) == 8 );
1775 C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_rect) == 12 );
1776 C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_hide) == 28 );
1777 C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_state) == 32 );
1778 C_ASSERT( sizeof(struct set_caret_info_reply) == 40 );
1779 C_ASSERT( FIELD_OFFSET(struct set_hook_request, id) == 12 );
1780 C_ASSERT( FIELD_OFFSET(struct set_hook_request, pid) == 16 );
1781 C_ASSERT( FIELD_OFFSET(struct set_hook_request, tid) == 20 );
1782 C_ASSERT( FIELD_OFFSET(struct set_hook_request, event_min) == 24 );
1783 C_ASSERT( FIELD_OFFSET(struct set_hook_request, event_max) == 28 );
1784 C_ASSERT( FIELD_OFFSET(struct set_hook_request, proc) == 32 );
1785 C_ASSERT( FIELD_OFFSET(struct set_hook_request, flags) == 40 );
1786 C_ASSERT( FIELD_OFFSET(struct set_hook_request, unicode) == 44 );
1787 C_ASSERT( sizeof(struct set_hook_request) == 48 );
1788 C_ASSERT( FIELD_OFFSET(struct set_hook_reply, handle) == 8 );
1789 C_ASSERT( FIELD_OFFSET(struct set_hook_reply, active_hooks) == 12 );
1790 C_ASSERT( sizeof(struct set_hook_reply) == 16 );
1791 C_ASSERT( FIELD_OFFSET(struct remove_hook_request, handle) == 12 );
1792 C_ASSERT( FIELD_OFFSET(struct remove_hook_request, proc) == 16 );
1793 C_ASSERT( FIELD_OFFSET(struct remove_hook_request, id) == 24 );
1794 C_ASSERT( sizeof(struct remove_hook_request) == 32 );
1795 C_ASSERT( FIELD_OFFSET(struct remove_hook_reply, active_hooks) == 8 );
1796 C_ASSERT( sizeof(struct remove_hook_reply) == 16 );
1797 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, id) == 12 );
1798 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, event) == 16 );
1799 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, window) == 20 );
1800 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, object_id) == 24 );
1801 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, child_id) == 28 );
1802 C_ASSERT( sizeof(struct start_hook_chain_request) == 32 );
1803 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, handle) == 8 );
1804 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, pid) == 12 );
1805 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, tid) == 16 );
1806 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, unicode) == 20 );
1807 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, proc) == 24 );
1808 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, active_hooks) == 32 );
1809 C_ASSERT( sizeof(struct start_hook_chain_reply) == 40 );
1810 C_ASSERT( FIELD_OFFSET(struct finish_hook_chain_request, id) == 12 );
1811 C_ASSERT( sizeof(struct finish_hook_chain_request) == 16 );
1812 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, handle) == 12 );
1813 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, get_next) == 16 );
1814 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, event) == 20 );
1815 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, window) == 24 );
1816 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, object_id) == 28 );
1817 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, child_id) == 32 );
1818 C_ASSERT( sizeof(struct get_hook_info_request) == 40 );
1819 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, handle) == 8 );
1820 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, id) == 12 );
1821 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, pid) == 16 );
1822 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, tid) == 20 );
1823 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, proc) == 24 );
1824 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, unicode) == 32 );
1825 C_ASSERT( sizeof(struct get_hook_info_reply) == 40 );
1826 C_ASSERT( FIELD_OFFSET(struct create_class_request, local) == 12 );
1827 C_ASSERT( FIELD_OFFSET(struct create_class_request, atom) == 16 );
1828 C_ASSERT( FIELD_OFFSET(struct create_class_request, style) == 20 );
1829 C_ASSERT( FIELD_OFFSET(struct create_class_request, instance) == 24 );
1830 C_ASSERT( FIELD_OFFSET(struct create_class_request, extra) == 32 );
1831 C_ASSERT( FIELD_OFFSET(struct create_class_request, win_extra) == 36 );
1832 C_ASSERT( FIELD_OFFSET(struct create_class_request, client_ptr) == 40 );
1833 C_ASSERT( sizeof(struct create_class_request) == 48 );
1834 C_ASSERT( FIELD_OFFSET(struct create_class_reply, atom) == 8 );
1835 C_ASSERT( sizeof(struct create_class_reply) == 16 );
1836 C_ASSERT( FIELD_OFFSET(struct destroy_class_request, atom) == 12 );
1837 C_ASSERT( FIELD_OFFSET(struct destroy_class_request, instance) == 16 );
1838 C_ASSERT( sizeof(struct destroy_class_request) == 24 );
1839 C_ASSERT( FIELD_OFFSET(struct destroy_class_reply, client_ptr) == 8 );
1840 C_ASSERT( sizeof(struct destroy_class_reply) == 16 );
1841 C_ASSERT( FIELD_OFFSET(struct set_class_info_request, window) == 12 );
1842 C_ASSERT( FIELD_OFFSET(struct set_class_info_request, flags) == 16 );
1843 C_ASSERT( FIELD_OFFSET(struct set_class_info_request, atom) == 20 );
1844 C_ASSERT( FIELD_OFFSET(struct set_class_info_request, style) == 24 );
1845 C_ASSERT( FIELD_OFFSET(struct set_class_info_request, win_extra) == 28 );
1846 C_ASSERT( FIELD_OFFSET(struct set_class_info_request, instance) == 32 );
1847 C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_offset) == 40 );
1848 C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_size) == 44 );
1849 C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_value) == 48 );
1850 C_ASSERT( sizeof(struct set_class_info_request) == 56 );
1851 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_atom) == 8 );
1852 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_style) == 12 );
1853 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_extra) == 16 );
1854 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_win_extra) == 20 );
1855 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_instance) == 24 );
1856 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_extra_value) == 32 );
1857 C_ASSERT( sizeof(struct set_class_info_reply) == 40 );
1858 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, flags) == 12 );
1859 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, clipboard) == 16 );
1860 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, owner) == 20 );
1861 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, viewer) == 24 );
1862 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, seqno) == 28 );
1863 C_ASSERT( sizeof(struct set_clipboard_info_request) == 32 );
1864 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply, flags) == 8 );
1865 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply, old_clipboard) == 12 );
1866 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply, old_owner) == 16 );
1867 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply, old_viewer) == 20 );
1868 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply, seqno) == 24 );
1869 C_ASSERT( sizeof(struct set_clipboard_info_reply) == 32 );
1870 C_ASSERT( FIELD_OFFSET(struct open_token_request, handle) == 12 );
1871 C_ASSERT( FIELD_OFFSET(struct open_token_request, access) == 16 );
1872 C_ASSERT( FIELD_OFFSET(struct open_token_request, attributes) == 20 );
1873 C_ASSERT( FIELD_OFFSET(struct open_token_request, flags) == 24 );
1874 C_ASSERT( sizeof(struct open_token_request) == 32 );
1875 C_ASSERT( FIELD_OFFSET(struct open_token_reply, token) == 8 );
1876 C_ASSERT( sizeof(struct open_token_reply) == 16 );
1877 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, flags) == 12 );
1878 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, shell_window) == 16 );
1879 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, shell_listview) == 20 );
1880 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, progman_window) == 24 );
1881 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, taskman_window) == 28 );
1882 C_ASSERT( sizeof(struct set_global_windows_request) == 32 );
1883 C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_shell_window) == 8 );
1884 C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_shell_listview) == 12 );
1885 C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_progman_window) == 16 );
1886 C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_taskman_window) == 20 );
1887 C_ASSERT( sizeof(struct set_global_windows_reply) == 24 );
1888 C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, handle) == 12 );
1889 C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, disable_all) == 16 );
1890 C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, get_modified_state) == 20 );
1891 C_ASSERT( sizeof(struct adjust_token_privileges_request) == 24 );
1892 C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_reply, len) == 8 );
1893 C_ASSERT( sizeof(struct adjust_token_privileges_reply) == 16 );
1894 C_ASSERT( FIELD_OFFSET(struct get_token_privileges_request, handle) == 12 );
1895 C_ASSERT( sizeof(struct get_token_privileges_request) == 16 );
1896 C_ASSERT( FIELD_OFFSET(struct get_token_privileges_reply, len) == 8 );
1897 C_ASSERT( sizeof(struct get_token_privileges_reply) == 16 );
1898 C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request, handle) == 12 );
1899 C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request, all_required) == 16 );
1900 C_ASSERT( sizeof(struct check_token_privileges_request) == 24 );
1901 C_ASSERT( FIELD_OFFSET(struct check_token_privileges_reply, has_privileges) == 8 );
1902 C_ASSERT( sizeof(struct check_token_privileges_reply) == 16 );
1903 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, handle) == 12 );
1904 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, access) == 16 );
1905 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, attributes) == 20 );
1906 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, primary) == 24 );
1907 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, impersonation_level) == 28 );
1908 C_ASSERT( sizeof(struct duplicate_token_request) == 32 );
1909 C_ASSERT( FIELD_OFFSET(struct duplicate_token_reply, new_handle) == 8 );
1910 C_ASSERT( sizeof(struct duplicate_token_reply) == 16 );
1911 C_ASSERT( FIELD_OFFSET(struct access_check_request, handle) == 12 );
1912 C_ASSERT( FIELD_OFFSET(struct access_check_request, desired_access) == 16 );
1913 C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_read) == 20 );
1914 C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_write) == 24 );
1915 C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_execute) == 28 );
1916 C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_all) == 32 );
1917 C_ASSERT( sizeof(struct access_check_request) == 40 );
1918 C_ASSERT( FIELD_OFFSET(struct access_check_reply, access_granted) == 8 );
1919 C_ASSERT( FIELD_OFFSET(struct access_check_reply, access_status) == 12 );
1920 C_ASSERT( FIELD_OFFSET(struct access_check_reply, privileges_len) == 16 );
1921 C_ASSERT( sizeof(struct access_check_reply) == 24 );
1922 C_ASSERT( FIELD_OFFSET(struct get_token_sid_request, handle) == 12 );
1923 C_ASSERT( FIELD_OFFSET(struct get_token_sid_request, which_sid) == 16 );
1924 C_ASSERT( sizeof(struct get_token_sid_request) == 24 );
1925 C_ASSERT( FIELD_OFFSET(struct get_token_sid_reply, sid_len) == 8 );
1926 C_ASSERT( sizeof(struct get_token_sid_reply) == 16 );
1927 C_ASSERT( FIELD_OFFSET(struct get_token_groups_request, handle) == 12 );
1928 C_ASSERT( sizeof(struct get_token_groups_request) == 16 );
1929 C_ASSERT( FIELD_OFFSET(struct get_token_groups_reply, user_len) == 8 );
1930 C_ASSERT( sizeof(struct get_token_groups_reply) == 16 );
1931 C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_request, handle) == 12 );
1932 C_ASSERT( sizeof(struct get_token_default_dacl_request) == 16 );
1933 C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_reply, acl_len) == 8 );
1934 C_ASSERT( sizeof(struct get_token_default_dacl_reply) == 16 );
1935 C_ASSERT( FIELD_OFFSET(struct set_token_default_dacl_request, handle) == 12 );
1936 C_ASSERT( sizeof(struct set_token_default_dacl_request) == 16 );
1937 C_ASSERT( FIELD_OFFSET(struct set_security_object_request, handle) == 12 );
1938 C_ASSERT( FIELD_OFFSET(struct set_security_object_request, security_info) == 16 );
1939 C_ASSERT( sizeof(struct set_security_object_request) == 24 );
1940 C_ASSERT( FIELD_OFFSET(struct get_security_object_request, handle) == 12 );
1941 C_ASSERT( FIELD_OFFSET(struct get_security_object_request, security_info) == 16 );
1942 C_ASSERT( sizeof(struct get_security_object_request) == 24 );
1943 C_ASSERT( FIELD_OFFSET(struct get_security_object_reply, sd_len) == 8 );
1944 C_ASSERT( sizeof(struct get_security_object_reply) == 16 );
1945 C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, access) == 12 );
1946 C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, attributes) == 16 );
1947 C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, rootdir) == 20 );
1948 C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, read_timeout) == 24 );
1949 C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, max_msgsize) == 32 );
1950 C_ASSERT( sizeof(struct create_mailslot_request) == 40 );
1951 C_ASSERT( FIELD_OFFSET(struct create_mailslot_reply, handle) == 8 );
1952 C_ASSERT( sizeof(struct create_mailslot_reply) == 16 );
1953 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, handle) == 12 );
1954 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, read_timeout) == 16 );
1955 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, flags) == 24 );
1956 C_ASSERT( sizeof(struct set_mailslot_info_request) == 32 );
1957 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply, read_timeout) == 8 );
1958 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply, max_msgsize) == 16 );
1959 C_ASSERT( sizeof(struct set_mailslot_info_reply) == 24 );
1960 C_ASSERT( FIELD_OFFSET(struct create_directory_request, access) == 12 );
1961 C_ASSERT( FIELD_OFFSET(struct create_directory_request, attributes) == 16 );
1962 C_ASSERT( FIELD_OFFSET(struct create_directory_request, rootdir) == 20 );
1963 C_ASSERT( sizeof(struct create_directory_request) == 24 );
1964 C_ASSERT( FIELD_OFFSET(struct create_directory_reply, handle) == 8 );
1965 C_ASSERT( sizeof(struct create_directory_reply) == 16 );
1966 C_ASSERT( FIELD_OFFSET(struct open_directory_request, access) == 12 );
1967 C_ASSERT( FIELD_OFFSET(struct open_directory_request, attributes) == 16 );
1968 C_ASSERT( FIELD_OFFSET(struct open_directory_request, rootdir) == 20 );
1969 C_ASSERT( sizeof(struct open_directory_request) == 24 );
1970 C_ASSERT( FIELD_OFFSET(struct open_directory_reply, handle) == 8 );
1971 C_ASSERT( sizeof(struct open_directory_reply) == 16 );
1972 C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request, handle) == 12 );
1973 C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request, index) == 16 );
1974 C_ASSERT( sizeof(struct get_directory_entry_request) == 24 );
1975 C_ASSERT( FIELD_OFFSET(struct get_directory_entry_reply, name_len) == 8 );
1976 C_ASSERT( sizeof(struct get_directory_entry_reply) == 16 );
1977 C_ASSERT( FIELD_OFFSET(struct create_symlink_request, access) == 12 );
1978 C_ASSERT( FIELD_OFFSET(struct create_symlink_request, attributes) == 16 );
1979 C_ASSERT( FIELD_OFFSET(struct create_symlink_request, rootdir) == 20 );
1980 C_ASSERT( FIELD_OFFSET(struct create_symlink_request, name_len) == 24 );
1981 C_ASSERT( sizeof(struct create_symlink_request) == 32 );
1982 C_ASSERT( FIELD_OFFSET(struct create_symlink_reply, handle) == 8 );
1983 C_ASSERT( sizeof(struct create_symlink_reply) == 16 );
1984 C_ASSERT( FIELD_OFFSET(struct open_symlink_request, access) == 12 );
1985 C_ASSERT( FIELD_OFFSET(struct open_symlink_request, attributes) == 16 );
1986 C_ASSERT( FIELD_OFFSET(struct open_symlink_request, rootdir) == 20 );
1987 C_ASSERT( sizeof(struct open_symlink_request) == 24 );
1988 C_ASSERT( FIELD_OFFSET(struct open_symlink_reply, handle) == 8 );
1989 C_ASSERT( sizeof(struct open_symlink_reply) == 16 );
1990 C_ASSERT( FIELD_OFFSET(struct query_symlink_request, handle) == 12 );
1991 C_ASSERT( sizeof(struct query_symlink_request) == 16 );
1992 C_ASSERT( FIELD_OFFSET(struct query_symlink_reply, total) == 8 );
1993 C_ASSERT( sizeof(struct query_symlink_reply) == 16 );
1994 C_ASSERT( FIELD_OFFSET(struct get_object_info_request, handle) == 12 );
1995 C_ASSERT( sizeof(struct get_object_info_request) == 16 );
1996 C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, access) == 8 );
1997 C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, ref_count) == 12 );
1998 C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, total) == 16 );
1999 C_ASSERT( sizeof(struct get_object_info_reply) == 24 );
2000 C_ASSERT( FIELD_OFFSET(struct unlink_object_request, handle) == 12 );
2001 C_ASSERT( sizeof(struct unlink_object_request) == 16 );
2002 C_ASSERT( FIELD_OFFSET(struct get_token_impersonation_level_request, handle) == 12 );
2003 C_ASSERT( sizeof(struct get_token_impersonation_level_request) == 16 );
2004 C_ASSERT( FIELD_OFFSET(struct get_token_impersonation_level_reply, impersonation_level) == 8 );
2005 C_ASSERT( sizeof(struct get_token_impersonation_level_reply) == 16 );
2006 C_ASSERT( sizeof(struct allocate_locally_unique_id_request) == 16 );
2007 C_ASSERT( FIELD_OFFSET(struct allocate_locally_unique_id_reply, luid) == 8 );
2008 C_ASSERT( sizeof(struct allocate_locally_unique_id_reply) == 16 );
2009 C_ASSERT( FIELD_OFFSET(struct create_device_manager_request, access) == 12 );
2010 C_ASSERT( FIELD_OFFSET(struct create_device_manager_request, attributes) == 16 );
2011 C_ASSERT( sizeof(struct create_device_manager_request) == 24 );
2012 C_ASSERT( FIELD_OFFSET(struct create_device_manager_reply, handle) == 8 );
2013 C_ASSERT( sizeof(struct create_device_manager_reply) == 16 );
2014 C_ASSERT( FIELD_OFFSET(struct create_device_request, access) == 12 );
2015 C_ASSERT( FIELD_OFFSET(struct create_device_request, attributes) == 16 );
2016 C_ASSERT( FIELD_OFFSET(struct create_device_request, rootdir) == 20 );
2017 C_ASSERT( FIELD_OFFSET(struct create_device_request, user_ptr) == 24 );
2018 C_ASSERT( FIELD_OFFSET(struct create_device_request, manager) == 32 );
2019 C_ASSERT( sizeof(struct create_device_request) == 40 );
2020 C_ASSERT( FIELD_OFFSET(struct create_device_reply, handle) == 8 );
2021 C_ASSERT( sizeof(struct create_device_reply) == 16 );
2022 C_ASSERT( FIELD_OFFSET(struct delete_device_request, handle) == 12 );
2023 C_ASSERT( sizeof(struct delete_device_request) == 16 );
2024 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, manager) == 12 );
2025 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, prev) == 16 );
2026 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, status) == 20 );
2027 C_ASSERT( sizeof(struct get_next_device_request_request) == 24 );
2028 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, next) == 8 );
2029 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, code) == 12 );
2030 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, user_ptr) == 16 );
2031 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, in_size) == 24 );
2032 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, out_size) == 28 );
2033 C_ASSERT( sizeof(struct get_next_device_request_reply) == 32 );
2034 C_ASSERT( sizeof(struct make_process_system_request) == 16 );
2035 C_ASSERT( FIELD_OFFSET(struct make_process_system_reply, event) == 8 );
2036 C_ASSERT( sizeof(struct make_process_system_reply) == 16 );
2037 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_request, handle) == 12 );
2038 C_ASSERT( sizeof(struct get_token_statistics_request) == 16 );
2039 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, token_id) == 8 );
2040 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, modified_id) == 16 );
2041 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, primary) == 24 );
2042 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, impersonation_level) == 28 );
2043 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, group_count) == 32 );
2044 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, privilege_count) == 36 );
2045 C_ASSERT( sizeof(struct get_token_statistics_reply) == 40 );
2046 C_ASSERT( FIELD_OFFSET(struct create_completion_request, access) == 12 );
2047 C_ASSERT( FIELD_OFFSET(struct create_completion_request, attributes) == 16 );
2048 C_ASSERT( FIELD_OFFSET(struct create_completion_request, concurrent) == 20 );
2049 C_ASSERT( FIELD_OFFSET(struct create_completion_request, rootdir) == 24 );
2050 C_ASSERT( sizeof(struct create_completion_request) == 32 );
2051 C_ASSERT( FIELD_OFFSET(struct create_completion_reply, handle) == 8 );
2052 C_ASSERT( sizeof(struct create_completion_reply) == 16 );
2053 C_ASSERT( FIELD_OFFSET(struct open_completion_request, access) == 12 );
2054 C_ASSERT( FIELD_OFFSET(struct open_completion_request, attributes) == 16 );
2055 C_ASSERT( FIELD_OFFSET(struct open_completion_request, rootdir) == 20 );
2056 C_ASSERT( sizeof(struct open_completion_request) == 24 );
2057 C_ASSERT( FIELD_OFFSET(struct open_completion_reply, handle) == 8 );
2058 C_ASSERT( sizeof(struct open_completion_reply) == 16 );
2059 C_ASSERT( FIELD_OFFSET(struct add_completion_request, handle) == 12 );
2060 C_ASSERT( FIELD_OFFSET(struct add_completion_request, ckey) == 16 );
2061 C_ASSERT( FIELD_OFFSET(struct add_completion_request, cvalue) == 24 );
2062 C_ASSERT( FIELD_OFFSET(struct add_completion_request, information) == 32 );
2063 C_ASSERT( FIELD_OFFSET(struct add_completion_request, status) == 36 );
2064 C_ASSERT( sizeof(struct add_completion_request) == 40 );
2065 C_ASSERT( FIELD_OFFSET(struct remove_completion_request, handle) == 12 );
2066 C_ASSERT( sizeof(struct remove_completion_request) == 16 );
2067 C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, ckey) == 8 );
2068 C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, cvalue) == 16 );
2069 C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, information) == 24 );
2070 C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, status) == 28 );
2071 C_ASSERT( sizeof(struct remove_completion_reply) == 32 );
2072 C_ASSERT( FIELD_OFFSET(struct query_completion_request, handle) == 12 );
2073 C_ASSERT( sizeof(struct query_completion_request) == 16 );
2074 C_ASSERT( FIELD_OFFSET(struct query_completion_reply, depth) == 8 );
2075 C_ASSERT( sizeof(struct query_completion_reply) == 16 );
2076 C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, handle) == 12 );
2077 C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, ckey) == 16 );
2078 C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, chandle) == 24 );
2079 C_ASSERT( sizeof(struct set_completion_info_request) == 32 );
2080 C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, handle) == 12 );
2081 C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, cvalue) == 16 );
2082 C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, status) == 24 );
2083 C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, information) == 28 );
2084 C_ASSERT( sizeof(struct add_fd_completion_request) == 32 );
2085 C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_request, handle) == 12 );
2086 C_ASSERT( sizeof(struct get_window_layered_info_request) == 16 );
2087 C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, color_key) == 8 );
2088 C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, alpha) == 12 );
2089 C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, flags) == 16 );
2090 C_ASSERT( sizeof(struct get_window_layered_info_reply) == 24 );
2091 C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, handle) == 12 );
2092 C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, color_key) == 16 );
2093 C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, alpha) == 20 );
2094 C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, flags) == 24 );
2095 C_ASSERT( sizeof(struct set_window_layered_info_request) == 32 );
2096 C_ASSERT( sizeof(struct alloc_user_handle_request) == 16 );
2097 C_ASSERT( FIELD_OFFSET(struct alloc_user_handle_reply, handle) == 8 );
2098 C_ASSERT( sizeof(struct alloc_user_handle_reply) == 16 );
2099 C_ASSERT( FIELD_OFFSET(struct free_user_handle_request, handle) == 12 );
2100 C_ASSERT( sizeof(struct free_user_handle_request) == 16 );
2101 C_ASSERT( FIELD_OFFSET(struct set_cursor_request, flags) == 12 );
2102 C_ASSERT( FIELD_OFFSET(struct set_cursor_request, handle) == 16 );
2103 C_ASSERT( FIELD_OFFSET(struct set_cursor_request, show_count) == 20 );
2104 C_ASSERT( sizeof(struct set_cursor_request) == 24 );
2105 C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_handle) == 8 );
2106 C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_count) == 12 );
2107 C_ASSERT( sizeof(struct set_cursor_reply) == 16 );
2109 #endif /* WANT_REQUEST_HANDLERS */
2111 /* ### make_requests end ### */
2112 /* Everything above this line is generated automatically by tools/make_requests */
2114 #endif /* __WINE_SERVER_REQUEST_H */