request.h 127 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266
  1. /*
  2. * Wine server requests
  3. *
  4. * Copyright (C) 1999 Alexandre Julliard
  5. *
  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.
  10. *
  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.
  15. *
  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
  19. */
  20. #ifndef __WINE_SERVER_REQUEST_H
  21. #define __WINE_SERVER_REQUEST_H
  22. #include <assert.h>
  23. #include "thread.h"
  24. #include "wine/server_protocol.h"
  25. /* max request length */
  26. #define MAX_REQUEST_LENGTH 8192
  27. /* request handler definition */
  28. #define DECL_HANDLER(name) \
  29. void req_##name( const struct name##_request *req, struct name##_reply *reply )
  30. /* request functions */
  31. #ifdef __GNUC__
  32. extern void fatal_protocol_error( struct thread *thread,
  33. const char *err, ... ) __attribute__((format (printf,2,3)));
  34. extern void fatal_error( const char *err, ... ) __attribute__((noreturn,format(printf,1,2)));
  35. #else
  36. extern void fatal_protocol_error( struct thread *thread, const char *err, ... );
  37. extern void fatal_error( const char *err, ... );
  38. #endif
  39. extern const char *get_config_dir(void);
  40. extern void *set_reply_data_size( data_size_t size );
  41. extern const struct object_attributes *get_req_object_attributes( const struct security_descriptor **sd,
  42. struct unicode_str *name,
  43. struct object **root );
  44. extern const void *get_req_data_after_objattr( const struct object_attributes *attr, data_size_t *len );
  45. extern int receive_fd( struct process *process );
  46. extern int send_client_fd( struct process *process, int fd, obj_handle_t handle );
  47. extern void read_request( struct thread *thread );
  48. extern void write_reply( struct thread *thread );
  49. extern timeout_t monotonic_counter(void);
  50. extern void open_master_socket(void);
  51. extern void close_master_socket( timeout_t timeout );
  52. extern void shutdown_master_socket(void);
  53. extern int wait_for_lock(void);
  54. extern int kill_lock_owner( int sig );
  55. extern char *server_dir;
  56. extern int server_dir_fd, config_dir_fd;
  57. extern void trace_request(void);
  58. extern void trace_reply( enum request req, const union generic_reply *reply );
  59. /* get current tick count to return to client */
  60. static inline unsigned int get_tick_count(void)
  61. {
  62. return monotonic_counter() / 10000;
  63. }
  64. /* get the request vararg data */
  65. static inline const void *get_req_data(void)
  66. {
  67. return current->req_data;
  68. }
  69. /* get the request vararg size */
  70. static inline data_size_t get_req_data_size(void)
  71. {
  72. return current->req.request_header.request_size;
  73. }
  74. /* get the request vararg as unicode string */
  75. static inline struct unicode_str get_req_unicode_str(void)
  76. {
  77. struct unicode_str ret;
  78. ret.str = get_req_data();
  79. ret.len = (get_req_data_size() / sizeof(WCHAR)) * sizeof(WCHAR);
  80. return ret;
  81. }
  82. /* get the reply maximum vararg size */
  83. static inline data_size_t get_reply_max_size(void)
  84. {
  85. return current->req.request_header.reply_size;
  86. }
  87. /* allocate and fill the reply data */
  88. static inline void *set_reply_data( const void *data, data_size_t size )
  89. {
  90. void *ret = set_reply_data_size( size );
  91. if (ret) memcpy( ret, data, size );
  92. return ret;
  93. }
  94. /* set the reply data pointer directly (will be freed by request code) */
  95. static inline void set_reply_data_ptr( void *data, data_size_t size )
  96. {
  97. assert( size <= get_reply_max_size() );
  98. current->reply_size = size;
  99. current->reply_data = data;
  100. }
  101. /* Everything below this line is generated automatically by tools/make_requests */
  102. /* ### make_requests begin ### */
  103. DECL_HANDLER(new_process);
  104. DECL_HANDLER(get_new_process_info);
  105. DECL_HANDLER(new_thread);
  106. DECL_HANDLER(get_startup_info);
  107. DECL_HANDLER(init_process_done);
  108. DECL_HANDLER(init_first_thread);
  109. DECL_HANDLER(init_thread);
  110. DECL_HANDLER(terminate_process);
  111. DECL_HANDLER(terminate_thread);
  112. DECL_HANDLER(get_process_info);
  113. DECL_HANDLER(get_process_debug_info);
  114. DECL_HANDLER(get_process_image_name);
  115. DECL_HANDLER(get_process_vm_counters);
  116. DECL_HANDLER(set_process_info);
  117. DECL_HANDLER(get_thread_info);
  118. DECL_HANDLER(get_thread_times);
  119. DECL_HANDLER(set_thread_info);
  120. DECL_HANDLER(suspend_thread);
  121. DECL_HANDLER(resume_thread);
  122. DECL_HANDLER(queue_apc);
  123. DECL_HANDLER(get_apc_result);
  124. DECL_HANDLER(close_handle);
  125. DECL_HANDLER(set_handle_info);
  126. DECL_HANDLER(dup_handle);
  127. DECL_HANDLER(compare_objects);
  128. DECL_HANDLER(make_temporary);
  129. DECL_HANDLER(open_process);
  130. DECL_HANDLER(open_thread);
  131. DECL_HANDLER(select);
  132. DECL_HANDLER(create_event);
  133. DECL_HANDLER(event_op);
  134. DECL_HANDLER(query_event);
  135. DECL_HANDLER(open_event);
  136. DECL_HANDLER(create_keyed_event);
  137. DECL_HANDLER(open_keyed_event);
  138. DECL_HANDLER(create_mutex);
  139. DECL_HANDLER(release_mutex);
  140. DECL_HANDLER(open_mutex);
  141. DECL_HANDLER(query_mutex);
  142. DECL_HANDLER(create_semaphore);
  143. DECL_HANDLER(release_semaphore);
  144. DECL_HANDLER(query_semaphore);
  145. DECL_HANDLER(open_semaphore);
  146. DECL_HANDLER(create_file);
  147. DECL_HANDLER(open_file_object);
  148. DECL_HANDLER(alloc_file_handle);
  149. DECL_HANDLER(get_handle_unix_name);
  150. DECL_HANDLER(get_handle_fd);
  151. DECL_HANDLER(get_directory_cache_entry);
  152. DECL_HANDLER(flush);
  153. DECL_HANDLER(get_file_info);
  154. DECL_HANDLER(get_volume_info);
  155. DECL_HANDLER(lock_file);
  156. DECL_HANDLER(unlock_file);
  157. DECL_HANDLER(recv_socket);
  158. DECL_HANDLER(send_socket);
  159. DECL_HANDLER(get_next_console_request);
  160. DECL_HANDLER(read_directory_changes);
  161. DECL_HANDLER(read_change);
  162. DECL_HANDLER(create_mapping);
  163. DECL_HANDLER(open_mapping);
  164. DECL_HANDLER(get_mapping_info);
  165. DECL_HANDLER(map_view);
  166. DECL_HANDLER(unmap_view);
  167. DECL_HANDLER(get_mapping_committed_range);
  168. DECL_HANDLER(add_mapping_committed_range);
  169. DECL_HANDLER(is_same_mapping);
  170. DECL_HANDLER(get_mapping_filename);
  171. DECL_HANDLER(list_processes);
  172. DECL_HANDLER(create_debug_obj);
  173. DECL_HANDLER(wait_debug_event);
  174. DECL_HANDLER(queue_exception_event);
  175. DECL_HANDLER(get_exception_status);
  176. DECL_HANDLER(continue_debug_event);
  177. DECL_HANDLER(debug_process);
  178. DECL_HANDLER(set_debug_obj_info);
  179. DECL_HANDLER(read_process_memory);
  180. DECL_HANDLER(write_process_memory);
  181. DECL_HANDLER(create_key);
  182. DECL_HANDLER(open_key);
  183. DECL_HANDLER(delete_key);
  184. DECL_HANDLER(flush_key);
  185. DECL_HANDLER(enum_key);
  186. DECL_HANDLER(set_key_value);
  187. DECL_HANDLER(get_key_value);
  188. DECL_HANDLER(enum_key_value);
  189. DECL_HANDLER(delete_key_value);
  190. DECL_HANDLER(load_registry);
  191. DECL_HANDLER(unload_registry);
  192. DECL_HANDLER(save_registry);
  193. DECL_HANDLER(set_registry_notification);
  194. DECL_HANDLER(create_timer);
  195. DECL_HANDLER(open_timer);
  196. DECL_HANDLER(set_timer);
  197. DECL_HANDLER(cancel_timer);
  198. DECL_HANDLER(get_timer_info);
  199. DECL_HANDLER(get_thread_context);
  200. DECL_HANDLER(set_thread_context);
  201. DECL_HANDLER(get_selector_entry);
  202. DECL_HANDLER(add_atom);
  203. DECL_HANDLER(delete_atom);
  204. DECL_HANDLER(find_atom);
  205. DECL_HANDLER(get_atom_information);
  206. DECL_HANDLER(get_msg_queue);
  207. DECL_HANDLER(set_queue_fd);
  208. DECL_HANDLER(set_queue_mask);
  209. DECL_HANDLER(get_queue_status);
  210. DECL_HANDLER(get_process_idle_event);
  211. DECL_HANDLER(send_message);
  212. DECL_HANDLER(post_quit_message);
  213. DECL_HANDLER(send_hardware_message);
  214. DECL_HANDLER(get_message);
  215. DECL_HANDLER(reply_message);
  216. DECL_HANDLER(accept_hardware_message);
  217. DECL_HANDLER(get_message_reply);
  218. DECL_HANDLER(set_win_timer);
  219. DECL_HANDLER(kill_win_timer);
  220. DECL_HANDLER(is_window_hung);
  221. DECL_HANDLER(get_serial_info);
  222. DECL_HANDLER(set_serial_info);
  223. DECL_HANDLER(register_async);
  224. DECL_HANDLER(cancel_async);
  225. DECL_HANDLER(get_async_result);
  226. DECL_HANDLER(set_async_direct_result);
  227. DECL_HANDLER(read);
  228. DECL_HANDLER(write);
  229. DECL_HANDLER(ioctl);
  230. DECL_HANDLER(set_irp_result);
  231. DECL_HANDLER(create_named_pipe);
  232. DECL_HANDLER(set_named_pipe_info);
  233. DECL_HANDLER(create_window);
  234. DECL_HANDLER(destroy_window);
  235. DECL_HANDLER(get_desktop_window);
  236. DECL_HANDLER(set_window_owner);
  237. DECL_HANDLER(get_window_info);
  238. DECL_HANDLER(set_window_info);
  239. DECL_HANDLER(set_parent);
  240. DECL_HANDLER(get_window_parents);
  241. DECL_HANDLER(get_window_children);
  242. DECL_HANDLER(get_window_children_from_point);
  243. DECL_HANDLER(get_window_tree);
  244. DECL_HANDLER(set_window_pos);
  245. DECL_HANDLER(get_window_rectangles);
  246. DECL_HANDLER(get_window_text);
  247. DECL_HANDLER(set_window_text);
  248. DECL_HANDLER(get_windows_offset);
  249. DECL_HANDLER(get_visible_region);
  250. DECL_HANDLER(get_surface_region);
  251. DECL_HANDLER(get_window_region);
  252. DECL_HANDLER(set_window_region);
  253. DECL_HANDLER(get_update_region);
  254. DECL_HANDLER(update_window_zorder);
  255. DECL_HANDLER(redraw_window);
  256. DECL_HANDLER(set_window_property);
  257. DECL_HANDLER(remove_window_property);
  258. DECL_HANDLER(get_window_property);
  259. DECL_HANDLER(get_window_properties);
  260. DECL_HANDLER(create_winstation);
  261. DECL_HANDLER(open_winstation);
  262. DECL_HANDLER(close_winstation);
  263. DECL_HANDLER(get_process_winstation);
  264. DECL_HANDLER(set_process_winstation);
  265. DECL_HANDLER(enum_winstation);
  266. DECL_HANDLER(create_desktop);
  267. DECL_HANDLER(open_desktop);
  268. DECL_HANDLER(open_input_desktop);
  269. DECL_HANDLER(close_desktop);
  270. DECL_HANDLER(get_thread_desktop);
  271. DECL_HANDLER(set_thread_desktop);
  272. DECL_HANDLER(enum_desktop);
  273. DECL_HANDLER(set_user_object_info);
  274. DECL_HANDLER(register_hotkey);
  275. DECL_HANDLER(unregister_hotkey);
  276. DECL_HANDLER(attach_thread_input);
  277. DECL_HANDLER(get_thread_input);
  278. DECL_HANDLER(get_last_input_time);
  279. DECL_HANDLER(get_key_state);
  280. DECL_HANDLER(set_key_state);
  281. DECL_HANDLER(set_foreground_window);
  282. DECL_HANDLER(set_focus_window);
  283. DECL_HANDLER(set_active_window);
  284. DECL_HANDLER(set_capture_window);
  285. DECL_HANDLER(set_caret_window);
  286. DECL_HANDLER(set_caret_info);
  287. DECL_HANDLER(set_hook);
  288. DECL_HANDLER(remove_hook);
  289. DECL_HANDLER(start_hook_chain);
  290. DECL_HANDLER(finish_hook_chain);
  291. DECL_HANDLER(get_hook_info);
  292. DECL_HANDLER(create_class);
  293. DECL_HANDLER(destroy_class);
  294. DECL_HANDLER(set_class_info);
  295. DECL_HANDLER(open_clipboard);
  296. DECL_HANDLER(close_clipboard);
  297. DECL_HANDLER(empty_clipboard);
  298. DECL_HANDLER(set_clipboard_data);
  299. DECL_HANDLER(get_clipboard_data);
  300. DECL_HANDLER(get_clipboard_formats);
  301. DECL_HANDLER(enum_clipboard_formats);
  302. DECL_HANDLER(release_clipboard);
  303. DECL_HANDLER(get_clipboard_info);
  304. DECL_HANDLER(set_clipboard_viewer);
  305. DECL_HANDLER(add_clipboard_listener);
  306. DECL_HANDLER(remove_clipboard_listener);
  307. DECL_HANDLER(open_token);
  308. DECL_HANDLER(set_global_windows);
  309. DECL_HANDLER(adjust_token_privileges);
  310. DECL_HANDLER(get_token_privileges);
  311. DECL_HANDLER(check_token_privileges);
  312. DECL_HANDLER(duplicate_token);
  313. DECL_HANDLER(filter_token);
  314. DECL_HANDLER(access_check);
  315. DECL_HANDLER(get_token_sid);
  316. DECL_HANDLER(get_token_groups);
  317. DECL_HANDLER(get_token_default_dacl);
  318. DECL_HANDLER(set_token_default_dacl);
  319. DECL_HANDLER(set_security_object);
  320. DECL_HANDLER(get_security_object);
  321. DECL_HANDLER(get_system_handles);
  322. DECL_HANDLER(create_mailslot);
  323. DECL_HANDLER(set_mailslot_info);
  324. DECL_HANDLER(create_directory);
  325. DECL_HANDLER(open_directory);
  326. DECL_HANDLER(get_directory_entries);
  327. DECL_HANDLER(create_symlink);
  328. DECL_HANDLER(open_symlink);
  329. DECL_HANDLER(query_symlink);
  330. DECL_HANDLER(get_object_info);
  331. DECL_HANDLER(get_object_name);
  332. DECL_HANDLER(get_object_type);
  333. DECL_HANDLER(get_object_types);
  334. DECL_HANDLER(allocate_locally_unique_id);
  335. DECL_HANDLER(create_device_manager);
  336. DECL_HANDLER(create_device);
  337. DECL_HANDLER(delete_device);
  338. DECL_HANDLER(get_next_device_request);
  339. DECL_HANDLER(get_kernel_object_ptr);
  340. DECL_HANDLER(set_kernel_object_ptr);
  341. DECL_HANDLER(grab_kernel_object);
  342. DECL_HANDLER(release_kernel_object);
  343. DECL_HANDLER(get_kernel_object_handle);
  344. DECL_HANDLER(make_process_system);
  345. DECL_HANDLER(get_token_info);
  346. DECL_HANDLER(create_linked_token);
  347. DECL_HANDLER(create_completion);
  348. DECL_HANDLER(open_completion);
  349. DECL_HANDLER(add_completion);
  350. DECL_HANDLER(remove_completion);
  351. DECL_HANDLER(query_completion);
  352. DECL_HANDLER(set_completion_info);
  353. DECL_HANDLER(add_fd_completion);
  354. DECL_HANDLER(set_fd_completion_mode);
  355. DECL_HANDLER(set_fd_disp_info);
  356. DECL_HANDLER(set_fd_name_info);
  357. DECL_HANDLER(set_fd_eof_info);
  358. DECL_HANDLER(get_window_layered_info);
  359. DECL_HANDLER(set_window_layered_info);
  360. DECL_HANDLER(alloc_user_handle);
  361. DECL_HANDLER(free_user_handle);
  362. DECL_HANDLER(set_cursor);
  363. DECL_HANDLER(get_cursor_history);
  364. DECL_HANDLER(get_rawinput_buffer);
  365. DECL_HANDLER(update_rawinput_devices);
  366. DECL_HANDLER(get_rawinput_devices);
  367. DECL_HANDLER(create_job);
  368. DECL_HANDLER(open_job);
  369. DECL_HANDLER(assign_job);
  370. DECL_HANDLER(process_in_job);
  371. DECL_HANDLER(set_job_limits);
  372. DECL_HANDLER(set_job_completion_port);
  373. DECL_HANDLER(get_job_info);
  374. DECL_HANDLER(terminate_job);
  375. DECL_HANDLER(suspend_process);
  376. DECL_HANDLER(resume_process);
  377. DECL_HANDLER(get_next_thread);
  378. #ifdef WANT_REQUEST_HANDLERS
  379. typedef void (*req_handler)( const void *req, void *reply );
  380. static const req_handler req_handlers[REQ_NB_REQUESTS] =
  381. {
  382. (req_handler)req_new_process,
  383. (req_handler)req_get_new_process_info,
  384. (req_handler)req_new_thread,
  385. (req_handler)req_get_startup_info,
  386. (req_handler)req_init_process_done,
  387. (req_handler)req_init_first_thread,
  388. (req_handler)req_init_thread,
  389. (req_handler)req_terminate_process,
  390. (req_handler)req_terminate_thread,
  391. (req_handler)req_get_process_info,
  392. (req_handler)req_get_process_debug_info,
  393. (req_handler)req_get_process_image_name,
  394. (req_handler)req_get_process_vm_counters,
  395. (req_handler)req_set_process_info,
  396. (req_handler)req_get_thread_info,
  397. (req_handler)req_get_thread_times,
  398. (req_handler)req_set_thread_info,
  399. (req_handler)req_suspend_thread,
  400. (req_handler)req_resume_thread,
  401. (req_handler)req_queue_apc,
  402. (req_handler)req_get_apc_result,
  403. (req_handler)req_close_handle,
  404. (req_handler)req_set_handle_info,
  405. (req_handler)req_dup_handle,
  406. (req_handler)req_compare_objects,
  407. (req_handler)req_make_temporary,
  408. (req_handler)req_open_process,
  409. (req_handler)req_open_thread,
  410. (req_handler)req_select,
  411. (req_handler)req_create_event,
  412. (req_handler)req_event_op,
  413. (req_handler)req_query_event,
  414. (req_handler)req_open_event,
  415. (req_handler)req_create_keyed_event,
  416. (req_handler)req_open_keyed_event,
  417. (req_handler)req_create_mutex,
  418. (req_handler)req_release_mutex,
  419. (req_handler)req_open_mutex,
  420. (req_handler)req_query_mutex,
  421. (req_handler)req_create_semaphore,
  422. (req_handler)req_release_semaphore,
  423. (req_handler)req_query_semaphore,
  424. (req_handler)req_open_semaphore,
  425. (req_handler)req_create_file,
  426. (req_handler)req_open_file_object,
  427. (req_handler)req_alloc_file_handle,
  428. (req_handler)req_get_handle_unix_name,
  429. (req_handler)req_get_handle_fd,
  430. (req_handler)req_get_directory_cache_entry,
  431. (req_handler)req_flush,
  432. (req_handler)req_get_file_info,
  433. (req_handler)req_get_volume_info,
  434. (req_handler)req_lock_file,
  435. (req_handler)req_unlock_file,
  436. (req_handler)req_recv_socket,
  437. (req_handler)req_send_socket,
  438. (req_handler)req_get_next_console_request,
  439. (req_handler)req_read_directory_changes,
  440. (req_handler)req_read_change,
  441. (req_handler)req_create_mapping,
  442. (req_handler)req_open_mapping,
  443. (req_handler)req_get_mapping_info,
  444. (req_handler)req_map_view,
  445. (req_handler)req_unmap_view,
  446. (req_handler)req_get_mapping_committed_range,
  447. (req_handler)req_add_mapping_committed_range,
  448. (req_handler)req_is_same_mapping,
  449. (req_handler)req_get_mapping_filename,
  450. (req_handler)req_list_processes,
  451. (req_handler)req_create_debug_obj,
  452. (req_handler)req_wait_debug_event,
  453. (req_handler)req_queue_exception_event,
  454. (req_handler)req_get_exception_status,
  455. (req_handler)req_continue_debug_event,
  456. (req_handler)req_debug_process,
  457. (req_handler)req_set_debug_obj_info,
  458. (req_handler)req_read_process_memory,
  459. (req_handler)req_write_process_memory,
  460. (req_handler)req_create_key,
  461. (req_handler)req_open_key,
  462. (req_handler)req_delete_key,
  463. (req_handler)req_flush_key,
  464. (req_handler)req_enum_key,
  465. (req_handler)req_set_key_value,
  466. (req_handler)req_get_key_value,
  467. (req_handler)req_enum_key_value,
  468. (req_handler)req_delete_key_value,
  469. (req_handler)req_load_registry,
  470. (req_handler)req_unload_registry,
  471. (req_handler)req_save_registry,
  472. (req_handler)req_set_registry_notification,
  473. (req_handler)req_create_timer,
  474. (req_handler)req_open_timer,
  475. (req_handler)req_set_timer,
  476. (req_handler)req_cancel_timer,
  477. (req_handler)req_get_timer_info,
  478. (req_handler)req_get_thread_context,
  479. (req_handler)req_set_thread_context,
  480. (req_handler)req_get_selector_entry,
  481. (req_handler)req_add_atom,
  482. (req_handler)req_delete_atom,
  483. (req_handler)req_find_atom,
  484. (req_handler)req_get_atom_information,
  485. (req_handler)req_get_msg_queue,
  486. (req_handler)req_set_queue_fd,
  487. (req_handler)req_set_queue_mask,
  488. (req_handler)req_get_queue_status,
  489. (req_handler)req_get_process_idle_event,
  490. (req_handler)req_send_message,
  491. (req_handler)req_post_quit_message,
  492. (req_handler)req_send_hardware_message,
  493. (req_handler)req_get_message,
  494. (req_handler)req_reply_message,
  495. (req_handler)req_accept_hardware_message,
  496. (req_handler)req_get_message_reply,
  497. (req_handler)req_set_win_timer,
  498. (req_handler)req_kill_win_timer,
  499. (req_handler)req_is_window_hung,
  500. (req_handler)req_get_serial_info,
  501. (req_handler)req_set_serial_info,
  502. (req_handler)req_register_async,
  503. (req_handler)req_cancel_async,
  504. (req_handler)req_get_async_result,
  505. (req_handler)req_set_async_direct_result,
  506. (req_handler)req_read,
  507. (req_handler)req_write,
  508. (req_handler)req_ioctl,
  509. (req_handler)req_set_irp_result,
  510. (req_handler)req_create_named_pipe,
  511. (req_handler)req_set_named_pipe_info,
  512. (req_handler)req_create_window,
  513. (req_handler)req_destroy_window,
  514. (req_handler)req_get_desktop_window,
  515. (req_handler)req_set_window_owner,
  516. (req_handler)req_get_window_info,
  517. (req_handler)req_set_window_info,
  518. (req_handler)req_set_parent,
  519. (req_handler)req_get_window_parents,
  520. (req_handler)req_get_window_children,
  521. (req_handler)req_get_window_children_from_point,
  522. (req_handler)req_get_window_tree,
  523. (req_handler)req_set_window_pos,
  524. (req_handler)req_get_window_rectangles,
  525. (req_handler)req_get_window_text,
  526. (req_handler)req_set_window_text,
  527. (req_handler)req_get_windows_offset,
  528. (req_handler)req_get_visible_region,
  529. (req_handler)req_get_surface_region,
  530. (req_handler)req_get_window_region,
  531. (req_handler)req_set_window_region,
  532. (req_handler)req_get_update_region,
  533. (req_handler)req_update_window_zorder,
  534. (req_handler)req_redraw_window,
  535. (req_handler)req_set_window_property,
  536. (req_handler)req_remove_window_property,
  537. (req_handler)req_get_window_property,
  538. (req_handler)req_get_window_properties,
  539. (req_handler)req_create_winstation,
  540. (req_handler)req_open_winstation,
  541. (req_handler)req_close_winstation,
  542. (req_handler)req_get_process_winstation,
  543. (req_handler)req_set_process_winstation,
  544. (req_handler)req_enum_winstation,
  545. (req_handler)req_create_desktop,
  546. (req_handler)req_open_desktop,
  547. (req_handler)req_open_input_desktop,
  548. (req_handler)req_close_desktop,
  549. (req_handler)req_get_thread_desktop,
  550. (req_handler)req_set_thread_desktop,
  551. (req_handler)req_enum_desktop,
  552. (req_handler)req_set_user_object_info,
  553. (req_handler)req_register_hotkey,
  554. (req_handler)req_unregister_hotkey,
  555. (req_handler)req_attach_thread_input,
  556. (req_handler)req_get_thread_input,
  557. (req_handler)req_get_last_input_time,
  558. (req_handler)req_get_key_state,
  559. (req_handler)req_set_key_state,
  560. (req_handler)req_set_foreground_window,
  561. (req_handler)req_set_focus_window,
  562. (req_handler)req_set_active_window,
  563. (req_handler)req_set_capture_window,
  564. (req_handler)req_set_caret_window,
  565. (req_handler)req_set_caret_info,
  566. (req_handler)req_set_hook,
  567. (req_handler)req_remove_hook,
  568. (req_handler)req_start_hook_chain,
  569. (req_handler)req_finish_hook_chain,
  570. (req_handler)req_get_hook_info,
  571. (req_handler)req_create_class,
  572. (req_handler)req_destroy_class,
  573. (req_handler)req_set_class_info,
  574. (req_handler)req_open_clipboard,
  575. (req_handler)req_close_clipboard,
  576. (req_handler)req_empty_clipboard,
  577. (req_handler)req_set_clipboard_data,
  578. (req_handler)req_get_clipboard_data,
  579. (req_handler)req_get_clipboard_formats,
  580. (req_handler)req_enum_clipboard_formats,
  581. (req_handler)req_release_clipboard,
  582. (req_handler)req_get_clipboard_info,
  583. (req_handler)req_set_clipboard_viewer,
  584. (req_handler)req_add_clipboard_listener,
  585. (req_handler)req_remove_clipboard_listener,
  586. (req_handler)req_open_token,
  587. (req_handler)req_set_global_windows,
  588. (req_handler)req_adjust_token_privileges,
  589. (req_handler)req_get_token_privileges,
  590. (req_handler)req_check_token_privileges,
  591. (req_handler)req_duplicate_token,
  592. (req_handler)req_filter_token,
  593. (req_handler)req_access_check,
  594. (req_handler)req_get_token_sid,
  595. (req_handler)req_get_token_groups,
  596. (req_handler)req_get_token_default_dacl,
  597. (req_handler)req_set_token_default_dacl,
  598. (req_handler)req_set_security_object,
  599. (req_handler)req_get_security_object,
  600. (req_handler)req_get_system_handles,
  601. (req_handler)req_create_mailslot,
  602. (req_handler)req_set_mailslot_info,
  603. (req_handler)req_create_directory,
  604. (req_handler)req_open_directory,
  605. (req_handler)req_get_directory_entries,
  606. (req_handler)req_create_symlink,
  607. (req_handler)req_open_symlink,
  608. (req_handler)req_query_symlink,
  609. (req_handler)req_get_object_info,
  610. (req_handler)req_get_object_name,
  611. (req_handler)req_get_object_type,
  612. (req_handler)req_get_object_types,
  613. (req_handler)req_allocate_locally_unique_id,
  614. (req_handler)req_create_device_manager,
  615. (req_handler)req_create_device,
  616. (req_handler)req_delete_device,
  617. (req_handler)req_get_next_device_request,
  618. (req_handler)req_get_kernel_object_ptr,
  619. (req_handler)req_set_kernel_object_ptr,
  620. (req_handler)req_grab_kernel_object,
  621. (req_handler)req_release_kernel_object,
  622. (req_handler)req_get_kernel_object_handle,
  623. (req_handler)req_make_process_system,
  624. (req_handler)req_get_token_info,
  625. (req_handler)req_create_linked_token,
  626. (req_handler)req_create_completion,
  627. (req_handler)req_open_completion,
  628. (req_handler)req_add_completion,
  629. (req_handler)req_remove_completion,
  630. (req_handler)req_query_completion,
  631. (req_handler)req_set_completion_info,
  632. (req_handler)req_add_fd_completion,
  633. (req_handler)req_set_fd_completion_mode,
  634. (req_handler)req_set_fd_disp_info,
  635. (req_handler)req_set_fd_name_info,
  636. (req_handler)req_set_fd_eof_info,
  637. (req_handler)req_get_window_layered_info,
  638. (req_handler)req_set_window_layered_info,
  639. (req_handler)req_alloc_user_handle,
  640. (req_handler)req_free_user_handle,
  641. (req_handler)req_set_cursor,
  642. (req_handler)req_get_cursor_history,
  643. (req_handler)req_get_rawinput_buffer,
  644. (req_handler)req_update_rawinput_devices,
  645. (req_handler)req_get_rawinput_devices,
  646. (req_handler)req_create_job,
  647. (req_handler)req_open_job,
  648. (req_handler)req_assign_job,
  649. (req_handler)req_process_in_job,
  650. (req_handler)req_set_job_limits,
  651. (req_handler)req_set_job_completion_port,
  652. (req_handler)req_get_job_info,
  653. (req_handler)req_terminate_job,
  654. (req_handler)req_suspend_process,
  655. (req_handler)req_resume_process,
  656. (req_handler)req_get_next_thread,
  657. };
  658. C_ASSERT( sizeof(abstime_t) == 8 );
  659. C_ASSERT( sizeof(affinity_t) == 8 );
  660. C_ASSERT( sizeof(apc_call_t) == 48 );
  661. C_ASSERT( sizeof(apc_param_t) == 8 );
  662. C_ASSERT( sizeof(apc_result_t) == 40 );
  663. C_ASSERT( sizeof(async_data_t) == 40 );
  664. C_ASSERT( sizeof(atom_t) == 4 );
  665. C_ASSERT( sizeof(char) == 1 );
  666. C_ASSERT( sizeof(client_ptr_t) == 8 );
  667. C_ASSERT( sizeof(data_size_t) == 4 );
  668. C_ASSERT( sizeof(file_pos_t) == 8 );
  669. C_ASSERT( sizeof(generic_map_t) == 16 );
  670. C_ASSERT( sizeof(hw_input_t) == 40 );
  671. C_ASSERT( sizeof(int) == 4 );
  672. C_ASSERT( sizeof(ioctl_code_t) == 4 );
  673. C_ASSERT( sizeof(irp_params_t) == 32 );
  674. C_ASSERT( sizeof(lparam_t) == 8 );
  675. C_ASSERT( sizeof(mem_size_t) == 8 );
  676. C_ASSERT( sizeof(mod_handle_t) == 8 );
  677. C_ASSERT( sizeof(obj_handle_t) == 4 );
  678. C_ASSERT( sizeof(process_id_t) == 4 );
  679. C_ASSERT( sizeof(rectangle_t) == 16 );
  680. C_ASSERT( sizeof(short int) == 2 );
  681. C_ASSERT( sizeof(struct luid) == 8 );
  682. C_ASSERT( sizeof(thread_id_t) == 4 );
  683. C_ASSERT( sizeof(timeout_t) == 8 );
  684. C_ASSERT( sizeof(unsigned char) == 1 );
  685. C_ASSERT( sizeof(unsigned int) == 4 );
  686. C_ASSERT( sizeof(unsigned short) == 2 );
  687. C_ASSERT( sizeof(user_handle_t) == 4 );
  688. C_ASSERT( FIELD_OFFSET(struct new_process_request, token) == 12 );
  689. C_ASSERT( FIELD_OFFSET(struct new_process_request, debug) == 16 );
  690. C_ASSERT( FIELD_OFFSET(struct new_process_request, parent_process) == 20 );
  691. C_ASSERT( FIELD_OFFSET(struct new_process_request, flags) == 24 );
  692. C_ASSERT( FIELD_OFFSET(struct new_process_request, socket_fd) == 28 );
  693. C_ASSERT( FIELD_OFFSET(struct new_process_request, access) == 32 );
  694. C_ASSERT( FIELD_OFFSET(struct new_process_request, machine) == 36 );
  695. C_ASSERT( FIELD_OFFSET(struct new_process_request, info_size) == 40 );
  696. C_ASSERT( FIELD_OFFSET(struct new_process_request, handles_size) == 44 );
  697. C_ASSERT( FIELD_OFFSET(struct new_process_request, jobs_size) == 48 );
  698. C_ASSERT( sizeof(struct new_process_request) == 56 );
  699. C_ASSERT( FIELD_OFFSET(struct new_process_reply, info) == 8 );
  700. C_ASSERT( FIELD_OFFSET(struct new_process_reply, pid) == 12 );
  701. C_ASSERT( FIELD_OFFSET(struct new_process_reply, handle) == 16 );
  702. C_ASSERT( sizeof(struct new_process_reply) == 24 );
  703. C_ASSERT( FIELD_OFFSET(struct get_new_process_info_request, info) == 12 );
  704. C_ASSERT( sizeof(struct get_new_process_info_request) == 16 );
  705. C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply, success) == 8 );
  706. C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply, exit_code) == 12 );
  707. C_ASSERT( sizeof(struct get_new_process_info_reply) == 16 );
  708. C_ASSERT( FIELD_OFFSET(struct new_thread_request, process) == 12 );
  709. C_ASSERT( FIELD_OFFSET(struct new_thread_request, access) == 16 );
  710. C_ASSERT( FIELD_OFFSET(struct new_thread_request, flags) == 20 );
  711. C_ASSERT( FIELD_OFFSET(struct new_thread_request, request_fd) == 24 );
  712. C_ASSERT( sizeof(struct new_thread_request) == 32 );
  713. C_ASSERT( FIELD_OFFSET(struct new_thread_reply, tid) == 8 );
  714. C_ASSERT( FIELD_OFFSET(struct new_thread_reply, handle) == 12 );
  715. C_ASSERT( sizeof(struct new_thread_reply) == 16 );
  716. C_ASSERT( sizeof(struct get_startup_info_request) == 16 );
  717. C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply, info_size) == 8 );
  718. C_ASSERT( sizeof(struct get_startup_info_reply) == 16 );
  719. C_ASSERT( FIELD_OFFSET(struct init_process_done_request, teb) == 16 );
  720. C_ASSERT( FIELD_OFFSET(struct init_process_done_request, peb) == 24 );
  721. C_ASSERT( FIELD_OFFSET(struct init_process_done_request, ldt_copy) == 32 );
  722. C_ASSERT( sizeof(struct init_process_done_request) == 40 );
  723. C_ASSERT( FIELD_OFFSET(struct init_process_done_reply, entry) == 8 );
  724. C_ASSERT( FIELD_OFFSET(struct init_process_done_reply, suspend) == 16 );
  725. C_ASSERT( sizeof(struct init_process_done_reply) == 24 );
  726. C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, unix_pid) == 12 );
  727. C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, unix_tid) == 16 );
  728. C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, debug_level) == 20 );
  729. C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, reply_fd) == 24 );
  730. C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, wait_fd) == 28 );
  731. C_ASSERT( sizeof(struct init_first_thread_request) == 32 );
  732. C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply, pid) == 8 );
  733. C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply, tid) == 12 );
  734. C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply, server_start) == 16 );
  735. C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply, session_id) == 24 );
  736. C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply, info_size) == 28 );
  737. C_ASSERT( sizeof(struct init_first_thread_reply) == 32 );
  738. C_ASSERT( FIELD_OFFSET(struct init_thread_request, unix_tid) == 12 );
  739. C_ASSERT( FIELD_OFFSET(struct init_thread_request, reply_fd) == 16 );
  740. C_ASSERT( FIELD_OFFSET(struct init_thread_request, wait_fd) == 20 );
  741. C_ASSERT( FIELD_OFFSET(struct init_thread_request, teb) == 24 );
  742. C_ASSERT( FIELD_OFFSET(struct init_thread_request, entry) == 32 );
  743. C_ASSERT( sizeof(struct init_thread_request) == 40 );
  744. C_ASSERT( FIELD_OFFSET(struct init_thread_reply, suspend) == 8 );
  745. C_ASSERT( sizeof(struct init_thread_reply) == 16 );
  746. C_ASSERT( FIELD_OFFSET(struct terminate_process_request, handle) == 12 );
  747. C_ASSERT( FIELD_OFFSET(struct terminate_process_request, exit_code) == 16 );
  748. C_ASSERT( sizeof(struct terminate_process_request) == 24 );
  749. C_ASSERT( FIELD_OFFSET(struct terminate_process_reply, self) == 8 );
  750. C_ASSERT( sizeof(struct terminate_process_reply) == 16 );
  751. C_ASSERT( FIELD_OFFSET(struct terminate_thread_request, handle) == 12 );
  752. C_ASSERT( FIELD_OFFSET(struct terminate_thread_request, exit_code) == 16 );
  753. C_ASSERT( sizeof(struct terminate_thread_request) == 24 );
  754. C_ASSERT( FIELD_OFFSET(struct terminate_thread_reply, self) == 8 );
  755. C_ASSERT( sizeof(struct terminate_thread_reply) == 16 );
  756. C_ASSERT( FIELD_OFFSET(struct get_process_info_request, handle) == 12 );
  757. C_ASSERT( sizeof(struct get_process_info_request) == 16 );
  758. C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, pid) == 8 );
  759. C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, ppid) == 12 );
  760. C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, affinity) == 16 );
  761. C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, peb) == 24 );
  762. C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, start_time) == 32 );
  763. C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, end_time) == 40 );
  764. C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, session_id) == 48 );
  765. C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, exit_code) == 52 );
  766. C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, priority) == 56 );
  767. C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, machine) == 60 );
  768. C_ASSERT( sizeof(struct get_process_info_reply) == 64 );
  769. C_ASSERT( FIELD_OFFSET(struct get_process_debug_info_request, handle) == 12 );
  770. C_ASSERT( sizeof(struct get_process_debug_info_request) == 16 );
  771. C_ASSERT( FIELD_OFFSET(struct get_process_debug_info_reply, debug) == 8 );
  772. C_ASSERT( FIELD_OFFSET(struct get_process_debug_info_reply, debug_children) == 12 );
  773. C_ASSERT( sizeof(struct get_process_debug_info_reply) == 16 );
  774. C_ASSERT( FIELD_OFFSET(struct get_process_image_name_request, handle) == 12 );
  775. C_ASSERT( FIELD_OFFSET(struct get_process_image_name_request, win32) == 16 );
  776. C_ASSERT( sizeof(struct get_process_image_name_request) == 24 );
  777. C_ASSERT( FIELD_OFFSET(struct get_process_image_name_reply, len) == 8 );
  778. C_ASSERT( sizeof(struct get_process_image_name_reply) == 16 );
  779. C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_request, handle) == 12 );
  780. C_ASSERT( sizeof(struct get_process_vm_counters_request) == 16 );
  781. C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, peak_virtual_size) == 8 );
  782. C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, virtual_size) == 16 );
  783. C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, peak_working_set_size) == 24 );
  784. C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, working_set_size) == 32 );
  785. C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, pagefile_usage) == 40 );
  786. C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, peak_pagefile_usage) == 48 );
  787. C_ASSERT( sizeof(struct get_process_vm_counters_reply) == 56 );
  788. C_ASSERT( FIELD_OFFSET(struct set_process_info_request, handle) == 12 );
  789. C_ASSERT( FIELD_OFFSET(struct set_process_info_request, mask) == 16 );
  790. C_ASSERT( FIELD_OFFSET(struct set_process_info_request, priority) == 20 );
  791. C_ASSERT( FIELD_OFFSET(struct set_process_info_request, affinity) == 24 );
  792. C_ASSERT( sizeof(struct set_process_info_request) == 32 );
  793. C_ASSERT( FIELD_OFFSET(struct get_thread_info_request, handle) == 12 );
  794. C_ASSERT( FIELD_OFFSET(struct get_thread_info_request, access) == 16 );
  795. C_ASSERT( sizeof(struct get_thread_info_request) == 24 );
  796. C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, pid) == 8 );
  797. C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, tid) == 12 );
  798. C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, teb) == 16 );
  799. C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, entry_point) == 24 );
  800. C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, affinity) == 32 );
  801. C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, exit_code) == 40 );
  802. C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, priority) == 44 );
  803. C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, last) == 48 );
  804. C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, suspend_count) == 52 );
  805. C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, dbg_hidden) == 56 );
  806. C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, desc_len) == 60 );
  807. C_ASSERT( sizeof(struct get_thread_info_reply) == 64 );
  808. C_ASSERT( FIELD_OFFSET(struct get_thread_times_request, handle) == 12 );
  809. C_ASSERT( sizeof(struct get_thread_times_request) == 16 );
  810. C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply, creation_time) == 8 );
  811. C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply, exit_time) == 16 );
  812. C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply, unix_pid) == 24 );
  813. C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply, unix_tid) == 28 );
  814. C_ASSERT( sizeof(struct get_thread_times_reply) == 32 );
  815. C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, handle) == 12 );
  816. C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, mask) == 16 );
  817. C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, priority) == 20 );
  818. C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, affinity) == 24 );
  819. C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, entry_point) == 32 );
  820. C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, token) == 40 );
  821. C_ASSERT( sizeof(struct set_thread_info_request) == 48 );
  822. C_ASSERT( FIELD_OFFSET(struct suspend_thread_request, handle) == 12 );
  823. C_ASSERT( sizeof(struct suspend_thread_request) == 16 );
  824. C_ASSERT( FIELD_OFFSET(struct suspend_thread_reply, count) == 8 );
  825. C_ASSERT( sizeof(struct suspend_thread_reply) == 16 );
  826. C_ASSERT( FIELD_OFFSET(struct resume_thread_request, handle) == 12 );
  827. C_ASSERT( sizeof(struct resume_thread_request) == 16 );
  828. C_ASSERT( FIELD_OFFSET(struct resume_thread_reply, count) == 8 );
  829. C_ASSERT( sizeof(struct resume_thread_reply) == 16 );
  830. C_ASSERT( FIELD_OFFSET(struct queue_apc_request, handle) == 12 );
  831. C_ASSERT( FIELD_OFFSET(struct queue_apc_request, call) == 16 );
  832. C_ASSERT( sizeof(struct queue_apc_request) == 64 );
  833. C_ASSERT( FIELD_OFFSET(struct queue_apc_reply, handle) == 8 );
  834. C_ASSERT( FIELD_OFFSET(struct queue_apc_reply, self) == 12 );
  835. C_ASSERT( sizeof(struct queue_apc_reply) == 16 );
  836. C_ASSERT( FIELD_OFFSET(struct get_apc_result_request, handle) == 12 );
  837. C_ASSERT( sizeof(struct get_apc_result_request) == 16 );
  838. C_ASSERT( FIELD_OFFSET(struct get_apc_result_reply, result) == 8 );
  839. C_ASSERT( sizeof(struct get_apc_result_reply) == 48 );
  840. C_ASSERT( FIELD_OFFSET(struct close_handle_request, handle) == 12 );
  841. C_ASSERT( sizeof(struct close_handle_request) == 16 );
  842. C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, handle) == 12 );
  843. C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, flags) == 16 );
  844. C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, mask) == 20 );
  845. C_ASSERT( sizeof(struct set_handle_info_request) == 24 );
  846. C_ASSERT( FIELD_OFFSET(struct set_handle_info_reply, old_flags) == 8 );
  847. C_ASSERT( sizeof(struct set_handle_info_reply) == 16 );
  848. C_ASSERT( FIELD_OFFSET(struct dup_handle_request, src_process) == 12 );
  849. C_ASSERT( FIELD_OFFSET(struct dup_handle_request, src_handle) == 16 );
  850. C_ASSERT( FIELD_OFFSET(struct dup_handle_request, dst_process) == 20 );
  851. C_ASSERT( FIELD_OFFSET(struct dup_handle_request, access) == 24 );
  852. C_ASSERT( FIELD_OFFSET(struct dup_handle_request, attributes) == 28 );
  853. C_ASSERT( FIELD_OFFSET(struct dup_handle_request, options) == 32 );
  854. C_ASSERT( sizeof(struct dup_handle_request) == 40 );
  855. C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, handle) == 8 );
  856. C_ASSERT( sizeof(struct dup_handle_reply) == 16 );
  857. C_ASSERT( FIELD_OFFSET(struct compare_objects_request, first) == 12 );
  858. C_ASSERT( FIELD_OFFSET(struct compare_objects_request, second) == 16 );
  859. C_ASSERT( sizeof(struct compare_objects_request) == 24 );
  860. C_ASSERT( FIELD_OFFSET(struct make_temporary_request, handle) == 12 );
  861. C_ASSERT( sizeof(struct make_temporary_request) == 16 );
  862. C_ASSERT( FIELD_OFFSET(struct open_process_request, pid) == 12 );
  863. C_ASSERT( FIELD_OFFSET(struct open_process_request, access) == 16 );
  864. C_ASSERT( FIELD_OFFSET(struct open_process_request, attributes) == 20 );
  865. C_ASSERT( sizeof(struct open_process_request) == 24 );
  866. C_ASSERT( FIELD_OFFSET(struct open_process_reply, handle) == 8 );
  867. C_ASSERT( sizeof(struct open_process_reply) == 16 );
  868. C_ASSERT( FIELD_OFFSET(struct open_thread_request, tid) == 12 );
  869. C_ASSERT( FIELD_OFFSET(struct open_thread_request, access) == 16 );
  870. C_ASSERT( FIELD_OFFSET(struct open_thread_request, attributes) == 20 );
  871. C_ASSERT( sizeof(struct open_thread_request) == 24 );
  872. C_ASSERT( FIELD_OFFSET(struct open_thread_reply, handle) == 8 );
  873. C_ASSERT( sizeof(struct open_thread_reply) == 16 );
  874. C_ASSERT( FIELD_OFFSET(struct select_request, flags) == 12 );
  875. C_ASSERT( FIELD_OFFSET(struct select_request, cookie) == 16 );
  876. C_ASSERT( FIELD_OFFSET(struct select_request, timeout) == 24 );
  877. C_ASSERT( FIELD_OFFSET(struct select_request, size) == 32 );
  878. C_ASSERT( FIELD_OFFSET(struct select_request, prev_apc) == 36 );
  879. C_ASSERT( sizeof(struct select_request) == 40 );
  880. C_ASSERT( FIELD_OFFSET(struct select_reply, call) == 8 );
  881. C_ASSERT( FIELD_OFFSET(struct select_reply, apc_handle) == 56 );
  882. C_ASSERT( FIELD_OFFSET(struct select_reply, signaled) == 60 );
  883. C_ASSERT( sizeof(struct select_reply) == 64 );
  884. C_ASSERT( FIELD_OFFSET(struct create_event_request, access) == 12 );
  885. C_ASSERT( FIELD_OFFSET(struct create_event_request, manual_reset) == 16 );
  886. C_ASSERT( FIELD_OFFSET(struct create_event_request, initial_state) == 20 );
  887. C_ASSERT( sizeof(struct create_event_request) == 24 );
  888. C_ASSERT( FIELD_OFFSET(struct create_event_reply, handle) == 8 );
  889. C_ASSERT( sizeof(struct create_event_reply) == 16 );
  890. C_ASSERT( FIELD_OFFSET(struct event_op_request, handle) == 12 );
  891. C_ASSERT( FIELD_OFFSET(struct event_op_request, op) == 16 );
  892. C_ASSERT( sizeof(struct event_op_request) == 24 );
  893. C_ASSERT( FIELD_OFFSET(struct event_op_reply, state) == 8 );
  894. C_ASSERT( sizeof(struct event_op_reply) == 16 );
  895. C_ASSERT( FIELD_OFFSET(struct query_event_request, handle) == 12 );
  896. C_ASSERT( sizeof(struct query_event_request) == 16 );
  897. C_ASSERT( FIELD_OFFSET(struct query_event_reply, manual_reset) == 8 );
  898. C_ASSERT( FIELD_OFFSET(struct query_event_reply, state) == 12 );
  899. C_ASSERT( sizeof(struct query_event_reply) == 16 );
  900. C_ASSERT( FIELD_OFFSET(struct open_event_request, access) == 12 );
  901. C_ASSERT( FIELD_OFFSET(struct open_event_request, attributes) == 16 );
  902. C_ASSERT( FIELD_OFFSET(struct open_event_request, rootdir) == 20 );
  903. C_ASSERT( sizeof(struct open_event_request) == 24 );
  904. C_ASSERT( FIELD_OFFSET(struct open_event_reply, handle) == 8 );
  905. C_ASSERT( sizeof(struct open_event_reply) == 16 );
  906. C_ASSERT( FIELD_OFFSET(struct create_keyed_event_request, access) == 12 );
  907. C_ASSERT( sizeof(struct create_keyed_event_request) == 16 );
  908. C_ASSERT( FIELD_OFFSET(struct create_keyed_event_reply, handle) == 8 );
  909. C_ASSERT( sizeof(struct create_keyed_event_reply) == 16 );
  910. C_ASSERT( FIELD_OFFSET(struct open_keyed_event_request, access) == 12 );
  911. C_ASSERT( FIELD_OFFSET(struct open_keyed_event_request, attributes) == 16 );
  912. C_ASSERT( FIELD_OFFSET(struct open_keyed_event_request, rootdir) == 20 );
  913. C_ASSERT( sizeof(struct open_keyed_event_request) == 24 );
  914. C_ASSERT( FIELD_OFFSET(struct open_keyed_event_reply, handle) == 8 );
  915. C_ASSERT( sizeof(struct open_keyed_event_reply) == 16 );
  916. C_ASSERT( FIELD_OFFSET(struct create_mutex_request, access) == 12 );
  917. C_ASSERT( FIELD_OFFSET(struct create_mutex_request, owned) == 16 );
  918. C_ASSERT( sizeof(struct create_mutex_request) == 24 );
  919. C_ASSERT( FIELD_OFFSET(struct create_mutex_reply, handle) == 8 );
  920. C_ASSERT( sizeof(struct create_mutex_reply) == 16 );
  921. C_ASSERT( FIELD_OFFSET(struct release_mutex_request, handle) == 12 );
  922. C_ASSERT( sizeof(struct release_mutex_request) == 16 );
  923. C_ASSERT( FIELD_OFFSET(struct release_mutex_reply, prev_count) == 8 );
  924. C_ASSERT( sizeof(struct release_mutex_reply) == 16 );
  925. C_ASSERT( FIELD_OFFSET(struct open_mutex_request, access) == 12 );
  926. C_ASSERT( FIELD_OFFSET(struct open_mutex_request, attributes) == 16 );
  927. C_ASSERT( FIELD_OFFSET(struct open_mutex_request, rootdir) == 20 );
  928. C_ASSERT( sizeof(struct open_mutex_request) == 24 );
  929. C_ASSERT( FIELD_OFFSET(struct open_mutex_reply, handle) == 8 );
  930. C_ASSERT( sizeof(struct open_mutex_reply) == 16 );
  931. C_ASSERT( FIELD_OFFSET(struct query_mutex_request, handle) == 12 );
  932. C_ASSERT( sizeof(struct query_mutex_request) == 16 );
  933. C_ASSERT( FIELD_OFFSET(struct query_mutex_reply, count) == 8 );
  934. C_ASSERT( FIELD_OFFSET(struct query_mutex_reply, owned) == 12 );
  935. C_ASSERT( FIELD_OFFSET(struct query_mutex_reply, abandoned) == 16 );
  936. C_ASSERT( sizeof(struct query_mutex_reply) == 24 );
  937. C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, access) == 12 );
  938. C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, initial) == 16 );
  939. C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, max) == 20 );
  940. C_ASSERT( sizeof(struct create_semaphore_request) == 24 );
  941. C_ASSERT( FIELD_OFFSET(struct create_semaphore_reply, handle) == 8 );
  942. C_ASSERT( sizeof(struct create_semaphore_reply) == 16 );
  943. C_ASSERT( FIELD_OFFSET(struct release_semaphore_request, handle) == 12 );
  944. C_ASSERT( FIELD_OFFSET(struct release_semaphore_request, count) == 16 );
  945. C_ASSERT( sizeof(struct release_semaphore_request) == 24 );
  946. C_ASSERT( FIELD_OFFSET(struct release_semaphore_reply, prev_count) == 8 );
  947. C_ASSERT( sizeof(struct release_semaphore_reply) == 16 );
  948. C_ASSERT( FIELD_OFFSET(struct query_semaphore_request, handle) == 12 );
  949. C_ASSERT( sizeof(struct query_semaphore_request) == 16 );
  950. C_ASSERT( FIELD_OFFSET(struct query_semaphore_reply, current) == 8 );
  951. C_ASSERT( FIELD_OFFSET(struct query_semaphore_reply, max) == 12 );
  952. C_ASSERT( sizeof(struct query_semaphore_reply) == 16 );
  953. C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, access) == 12 );
  954. C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, attributes) == 16 );
  955. C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, rootdir) == 20 );
  956. C_ASSERT( sizeof(struct open_semaphore_request) == 24 );
  957. C_ASSERT( FIELD_OFFSET(struct open_semaphore_reply, handle) == 8 );
  958. C_ASSERT( sizeof(struct open_semaphore_reply) == 16 );
  959. C_ASSERT( FIELD_OFFSET(struct create_file_request, access) == 12 );
  960. C_ASSERT( FIELD_OFFSET(struct create_file_request, sharing) == 16 );
  961. C_ASSERT( FIELD_OFFSET(struct create_file_request, create) == 20 );
  962. C_ASSERT( FIELD_OFFSET(struct create_file_request, options) == 24 );
  963. C_ASSERT( FIELD_OFFSET(struct create_file_request, attrs) == 28 );
  964. C_ASSERT( sizeof(struct create_file_request) == 32 );
  965. C_ASSERT( FIELD_OFFSET(struct create_file_reply, handle) == 8 );
  966. C_ASSERT( sizeof(struct create_file_reply) == 16 );
  967. C_ASSERT( FIELD_OFFSET(struct open_file_object_request, access) == 12 );
  968. C_ASSERT( FIELD_OFFSET(struct open_file_object_request, attributes) == 16 );
  969. C_ASSERT( FIELD_OFFSET(struct open_file_object_request, rootdir) == 20 );
  970. C_ASSERT( FIELD_OFFSET(struct open_file_object_request, sharing) == 24 );
  971. C_ASSERT( FIELD_OFFSET(struct open_file_object_request, options) == 28 );
  972. C_ASSERT( sizeof(struct open_file_object_request) == 32 );
  973. C_ASSERT( FIELD_OFFSET(struct open_file_object_reply, handle) == 8 );
  974. C_ASSERT( sizeof(struct open_file_object_reply) == 16 );
  975. C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, access) == 12 );
  976. C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, attributes) == 16 );
  977. C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, fd) == 20 );
  978. C_ASSERT( sizeof(struct alloc_file_handle_request) == 24 );
  979. C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_reply, handle) == 8 );
  980. C_ASSERT( sizeof(struct alloc_file_handle_reply) == 16 );
  981. C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_request, handle) == 12 );
  982. C_ASSERT( sizeof(struct get_handle_unix_name_request) == 16 );
  983. C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_reply, name_len) == 8 );
  984. C_ASSERT( sizeof(struct get_handle_unix_name_reply) == 16 );
  985. C_ASSERT( FIELD_OFFSET(struct get_handle_fd_request, handle) == 12 );
  986. C_ASSERT( sizeof(struct get_handle_fd_request) == 16 );
  987. C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, type) == 8 );
  988. C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, cacheable) == 12 );
  989. C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, access) == 16 );
  990. C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, options) == 20 );
  991. C_ASSERT( sizeof(struct get_handle_fd_reply) == 24 );
  992. C_ASSERT( FIELD_OFFSET(struct get_directory_cache_entry_request, handle) == 12 );
  993. C_ASSERT( sizeof(struct get_directory_cache_entry_request) == 16 );
  994. C_ASSERT( FIELD_OFFSET(struct get_directory_cache_entry_reply, entry) == 8 );
  995. C_ASSERT( sizeof(struct get_directory_cache_entry_reply) == 16 );
  996. C_ASSERT( FIELD_OFFSET(struct flush_request, async) == 16 );
  997. C_ASSERT( sizeof(struct flush_request) == 56 );
  998. C_ASSERT( FIELD_OFFSET(struct flush_reply, event) == 8 );
  999. C_ASSERT( sizeof(struct flush_reply) == 16 );
  1000. C_ASSERT( FIELD_OFFSET(struct get_file_info_request, handle) == 12 );
  1001. C_ASSERT( FIELD_OFFSET(struct get_file_info_request, info_class) == 16 );
  1002. C_ASSERT( sizeof(struct get_file_info_request) == 24 );
  1003. C_ASSERT( sizeof(struct get_file_info_reply) == 8 );
  1004. C_ASSERT( FIELD_OFFSET(struct get_volume_info_request, handle) == 12 );
  1005. C_ASSERT( FIELD_OFFSET(struct get_volume_info_request, async) == 16 );
  1006. C_ASSERT( FIELD_OFFSET(struct get_volume_info_request, info_class) == 56 );
  1007. C_ASSERT( sizeof(struct get_volume_info_request) == 64 );
  1008. C_ASSERT( FIELD_OFFSET(struct get_volume_info_reply, wait) == 8 );
  1009. C_ASSERT( sizeof(struct get_volume_info_reply) == 16 );
  1010. C_ASSERT( FIELD_OFFSET(struct lock_file_request, handle) == 12 );
  1011. C_ASSERT( FIELD_OFFSET(struct lock_file_request, offset) == 16 );
  1012. C_ASSERT( FIELD_OFFSET(struct lock_file_request, count) == 24 );
  1013. C_ASSERT( FIELD_OFFSET(struct lock_file_request, shared) == 32 );
  1014. C_ASSERT( FIELD_OFFSET(struct lock_file_request, wait) == 36 );
  1015. C_ASSERT( sizeof(struct lock_file_request) == 40 );
  1016. C_ASSERT( FIELD_OFFSET(struct lock_file_reply, handle) == 8 );
  1017. C_ASSERT( FIELD_OFFSET(struct lock_file_reply, overlapped) == 12 );
  1018. C_ASSERT( sizeof(struct lock_file_reply) == 16 );
  1019. C_ASSERT( FIELD_OFFSET(struct unlock_file_request, handle) == 12 );
  1020. C_ASSERT( FIELD_OFFSET(struct unlock_file_request, offset) == 16 );
  1021. C_ASSERT( FIELD_OFFSET(struct unlock_file_request, count) == 24 );
  1022. C_ASSERT( sizeof(struct unlock_file_request) == 32 );
  1023. C_ASSERT( FIELD_OFFSET(struct recv_socket_request, oob) == 12 );
  1024. C_ASSERT( FIELD_OFFSET(struct recv_socket_request, async) == 16 );
  1025. C_ASSERT( FIELD_OFFSET(struct recv_socket_request, force_async) == 56 );
  1026. C_ASSERT( sizeof(struct recv_socket_request) == 64 );
  1027. C_ASSERT( FIELD_OFFSET(struct recv_socket_reply, wait) == 8 );
  1028. C_ASSERT( FIELD_OFFSET(struct recv_socket_reply, options) == 12 );
  1029. C_ASSERT( FIELD_OFFSET(struct recv_socket_reply, nonblocking) == 16 );
  1030. C_ASSERT( sizeof(struct recv_socket_reply) == 24 );
  1031. C_ASSERT( FIELD_OFFSET(struct send_socket_request, async) == 16 );
  1032. C_ASSERT( FIELD_OFFSET(struct send_socket_request, force_async) == 56 );
  1033. C_ASSERT( sizeof(struct send_socket_request) == 64 );
  1034. C_ASSERT( FIELD_OFFSET(struct send_socket_reply, wait) == 8 );
  1035. C_ASSERT( FIELD_OFFSET(struct send_socket_reply, options) == 12 );
  1036. C_ASSERT( FIELD_OFFSET(struct send_socket_reply, nonblocking) == 16 );
  1037. C_ASSERT( sizeof(struct send_socket_reply) == 24 );
  1038. C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, handle) == 12 );
  1039. C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, signal) == 16 );
  1040. C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, read) == 20 );
  1041. C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, status) == 24 );
  1042. C_ASSERT( sizeof(struct get_next_console_request_request) == 32 );
  1043. C_ASSERT( FIELD_OFFSET(struct get_next_console_request_reply, code) == 8 );
  1044. C_ASSERT( FIELD_OFFSET(struct get_next_console_request_reply, output) == 12 );
  1045. C_ASSERT( FIELD_OFFSET(struct get_next_console_request_reply, out_size) == 16 );
  1046. C_ASSERT( sizeof(struct get_next_console_request_reply) == 24 );
  1047. C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, filter) == 12 );
  1048. C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, subtree) == 16 );
  1049. C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, want_data) == 20 );
  1050. C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, async) == 24 );
  1051. C_ASSERT( sizeof(struct read_directory_changes_request) == 64 );
  1052. C_ASSERT( FIELD_OFFSET(struct read_change_request, handle) == 12 );
  1053. C_ASSERT( sizeof(struct read_change_request) == 16 );
  1054. C_ASSERT( sizeof(struct read_change_reply) == 8 );
  1055. C_ASSERT( FIELD_OFFSET(struct create_mapping_request, access) == 12 );
  1056. C_ASSERT( FIELD_OFFSET(struct create_mapping_request, flags) == 16 );
  1057. C_ASSERT( FIELD_OFFSET(struct create_mapping_request, file_access) == 20 );
  1058. C_ASSERT( FIELD_OFFSET(struct create_mapping_request, size) == 24 );
  1059. C_ASSERT( FIELD_OFFSET(struct create_mapping_request, file_handle) == 32 );
  1060. C_ASSERT( sizeof(struct create_mapping_request) == 40 );
  1061. C_ASSERT( FIELD_OFFSET(struct create_mapping_reply, handle) == 8 );
  1062. C_ASSERT( sizeof(struct create_mapping_reply) == 16 );
  1063. C_ASSERT( FIELD_OFFSET(struct open_mapping_request, access) == 12 );
  1064. C_ASSERT( FIELD_OFFSET(struct open_mapping_request, attributes) == 16 );
  1065. C_ASSERT( FIELD_OFFSET(struct open_mapping_request, rootdir) == 20 );
  1066. C_ASSERT( sizeof(struct open_mapping_request) == 24 );
  1067. C_ASSERT( FIELD_OFFSET(struct open_mapping_reply, handle) == 8 );
  1068. C_ASSERT( sizeof(struct open_mapping_reply) == 16 );
  1069. C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request, handle) == 12 );
  1070. C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request, access) == 16 );
  1071. C_ASSERT( sizeof(struct get_mapping_info_request) == 24 );
  1072. C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, size) == 8 );
  1073. C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, flags) == 16 );
  1074. C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, shared_file) == 20 );
  1075. C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, total) == 24 );
  1076. C_ASSERT( sizeof(struct get_mapping_info_reply) == 32 );
  1077. C_ASSERT( FIELD_OFFSET(struct map_view_request, mapping) == 12 );
  1078. C_ASSERT( FIELD_OFFSET(struct map_view_request, access) == 16 );
  1079. C_ASSERT( FIELD_OFFSET(struct map_view_request, base) == 24 );
  1080. C_ASSERT( FIELD_OFFSET(struct map_view_request, size) == 32 );
  1081. C_ASSERT( FIELD_OFFSET(struct map_view_request, start) == 40 );
  1082. C_ASSERT( sizeof(struct map_view_request) == 48 );
  1083. C_ASSERT( FIELD_OFFSET(struct unmap_view_request, base) == 16 );
  1084. C_ASSERT( sizeof(struct unmap_view_request) == 24 );
  1085. C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request, base) == 16 );
  1086. C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request, offset) == 24 );
  1087. C_ASSERT( sizeof(struct get_mapping_committed_range_request) == 32 );
  1088. C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply, size) == 8 );
  1089. C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply, committed) == 16 );
  1090. C_ASSERT( sizeof(struct get_mapping_committed_range_reply) == 24 );
  1091. C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, base) == 16 );
  1092. C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, offset) == 24 );
  1093. C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, size) == 32 );
  1094. C_ASSERT( sizeof(struct add_mapping_committed_range_request) == 40 );
  1095. C_ASSERT( FIELD_OFFSET(struct is_same_mapping_request, base1) == 16 );
  1096. C_ASSERT( FIELD_OFFSET(struct is_same_mapping_request, base2) == 24 );
  1097. C_ASSERT( sizeof(struct is_same_mapping_request) == 32 );
  1098. C_ASSERT( FIELD_OFFSET(struct get_mapping_filename_request, process) == 12 );
  1099. C_ASSERT( FIELD_OFFSET(struct get_mapping_filename_request, addr) == 16 );
  1100. C_ASSERT( sizeof(struct get_mapping_filename_request) == 24 );
  1101. C_ASSERT( FIELD_OFFSET(struct get_mapping_filename_reply, len) == 8 );
  1102. C_ASSERT( sizeof(struct get_mapping_filename_reply) == 16 );
  1103. C_ASSERT( sizeof(struct list_processes_request) == 16 );
  1104. C_ASSERT( FIELD_OFFSET(struct list_processes_reply, info_size) == 8 );
  1105. C_ASSERT( FIELD_OFFSET(struct list_processes_reply, process_count) == 12 );
  1106. C_ASSERT( FIELD_OFFSET(struct list_processes_reply, total_thread_count) == 16 );
  1107. C_ASSERT( FIELD_OFFSET(struct list_processes_reply, total_name_len) == 20 );
  1108. C_ASSERT( sizeof(struct list_processes_reply) == 24 );
  1109. C_ASSERT( FIELD_OFFSET(struct create_debug_obj_request, access) == 12 );
  1110. C_ASSERT( FIELD_OFFSET(struct create_debug_obj_request, flags) == 16 );
  1111. C_ASSERT( sizeof(struct create_debug_obj_request) == 24 );
  1112. C_ASSERT( FIELD_OFFSET(struct create_debug_obj_reply, handle) == 8 );
  1113. C_ASSERT( sizeof(struct create_debug_obj_reply) == 16 );
  1114. C_ASSERT( FIELD_OFFSET(struct wait_debug_event_request, debug) == 12 );
  1115. C_ASSERT( sizeof(struct wait_debug_event_request) == 16 );
  1116. C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, pid) == 8 );
  1117. C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, tid) == 12 );
  1118. C_ASSERT( sizeof(struct wait_debug_event_reply) == 16 );
  1119. C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, first) == 12 );
  1120. C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, code) == 16 );
  1121. C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, flags) == 20 );
  1122. C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, record) == 24 );
  1123. C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, address) == 32 );
  1124. C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, len) == 40 );
  1125. C_ASSERT( sizeof(struct queue_exception_event_request) == 48 );
  1126. C_ASSERT( FIELD_OFFSET(struct queue_exception_event_reply, handle) == 8 );
  1127. C_ASSERT( sizeof(struct queue_exception_event_reply) == 16 );
  1128. C_ASSERT( FIELD_OFFSET(struct get_exception_status_request, handle) == 12 );
  1129. C_ASSERT( sizeof(struct get_exception_status_request) == 16 );
  1130. C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, debug) == 12 );
  1131. C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, pid) == 16 );
  1132. C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, tid) == 20 );
  1133. C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, status) == 24 );
  1134. C_ASSERT( sizeof(struct continue_debug_event_request) == 32 );
  1135. C_ASSERT( FIELD_OFFSET(struct debug_process_request, handle) == 12 );
  1136. C_ASSERT( FIELD_OFFSET(struct debug_process_request, debug) == 16 );
  1137. C_ASSERT( FIELD_OFFSET(struct debug_process_request, attach) == 20 );
  1138. C_ASSERT( sizeof(struct debug_process_request) == 24 );
  1139. C_ASSERT( FIELD_OFFSET(struct set_debug_obj_info_request, debug) == 12 );
  1140. C_ASSERT( FIELD_OFFSET(struct set_debug_obj_info_request, flags) == 16 );
  1141. C_ASSERT( sizeof(struct set_debug_obj_info_request) == 24 );
  1142. C_ASSERT( FIELD_OFFSET(struct read_process_memory_request, handle) == 12 );
  1143. C_ASSERT( FIELD_OFFSET(struct read_process_memory_request, addr) == 16 );
  1144. C_ASSERT( sizeof(struct read_process_memory_request) == 24 );
  1145. C_ASSERT( sizeof(struct read_process_memory_reply) == 8 );
  1146. C_ASSERT( FIELD_OFFSET(struct write_process_memory_request, handle) == 12 );
  1147. C_ASSERT( FIELD_OFFSET(struct write_process_memory_request, addr) == 16 );
  1148. C_ASSERT( sizeof(struct write_process_memory_request) == 24 );
  1149. C_ASSERT( FIELD_OFFSET(struct create_key_request, access) == 12 );
  1150. C_ASSERT( FIELD_OFFSET(struct create_key_request, options) == 16 );
  1151. C_ASSERT( sizeof(struct create_key_request) == 24 );
  1152. C_ASSERT( FIELD_OFFSET(struct create_key_reply, hkey) == 8 );
  1153. C_ASSERT( FIELD_OFFSET(struct create_key_reply, created) == 12 );
  1154. C_ASSERT( sizeof(struct create_key_reply) == 16 );
  1155. C_ASSERT( FIELD_OFFSET(struct open_key_request, parent) == 12 );
  1156. C_ASSERT( FIELD_OFFSET(struct open_key_request, access) == 16 );
  1157. C_ASSERT( FIELD_OFFSET(struct open_key_request, attributes) == 20 );
  1158. C_ASSERT( sizeof(struct open_key_request) == 24 );
  1159. C_ASSERT( FIELD_OFFSET(struct open_key_reply, hkey) == 8 );
  1160. C_ASSERT( sizeof(struct open_key_reply) == 16 );
  1161. C_ASSERT( FIELD_OFFSET(struct delete_key_request, hkey) == 12 );
  1162. C_ASSERT( sizeof(struct delete_key_request) == 16 );
  1163. C_ASSERT( FIELD_OFFSET(struct flush_key_request, hkey) == 12 );
  1164. C_ASSERT( sizeof(struct flush_key_request) == 16 );
  1165. C_ASSERT( FIELD_OFFSET(struct enum_key_request, hkey) == 12 );
  1166. C_ASSERT( FIELD_OFFSET(struct enum_key_request, index) == 16 );
  1167. C_ASSERT( FIELD_OFFSET(struct enum_key_request, info_class) == 20 );
  1168. C_ASSERT( sizeof(struct enum_key_request) == 24 );
  1169. C_ASSERT( FIELD_OFFSET(struct enum_key_reply, subkeys) == 8 );
  1170. C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_subkey) == 12 );
  1171. C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_class) == 16 );
  1172. C_ASSERT( FIELD_OFFSET(struct enum_key_reply, values) == 20 );
  1173. C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_value) == 24 );
  1174. C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_data) == 28 );
  1175. C_ASSERT( FIELD_OFFSET(struct enum_key_reply, modif) == 32 );
  1176. C_ASSERT( FIELD_OFFSET(struct enum_key_reply, total) == 40 );
  1177. C_ASSERT( FIELD_OFFSET(struct enum_key_reply, namelen) == 44 );
  1178. C_ASSERT( sizeof(struct enum_key_reply) == 48 );
  1179. C_ASSERT( FIELD_OFFSET(struct set_key_value_request, hkey) == 12 );
  1180. C_ASSERT( FIELD_OFFSET(struct set_key_value_request, type) == 16 );
  1181. C_ASSERT( FIELD_OFFSET(struct set_key_value_request, namelen) == 20 );
  1182. C_ASSERT( sizeof(struct set_key_value_request) == 24 );
  1183. C_ASSERT( FIELD_OFFSET(struct get_key_value_request, hkey) == 12 );
  1184. C_ASSERT( sizeof(struct get_key_value_request) == 16 );
  1185. C_ASSERT( FIELD_OFFSET(struct get_key_value_reply, type) == 8 );
  1186. C_ASSERT( FIELD_OFFSET(struct get_key_value_reply, total) == 12 );
  1187. C_ASSERT( sizeof(struct get_key_value_reply) == 16 );
  1188. C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, hkey) == 12 );
  1189. C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, index) == 16 );
  1190. C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, info_class) == 20 );
  1191. C_ASSERT( sizeof(struct enum_key_value_request) == 24 );
  1192. C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, type) == 8 );
  1193. C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, total) == 12 );
  1194. C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, namelen) == 16 );
  1195. C_ASSERT( sizeof(struct enum_key_value_reply) == 24 );
  1196. C_ASSERT( FIELD_OFFSET(struct delete_key_value_request, hkey) == 12 );
  1197. C_ASSERT( sizeof(struct delete_key_value_request) == 16 );
  1198. C_ASSERT( FIELD_OFFSET(struct load_registry_request, file) == 12 );
  1199. C_ASSERT( sizeof(struct load_registry_request) == 16 );
  1200. C_ASSERT( FIELD_OFFSET(struct unload_registry_request, parent) == 12 );
  1201. C_ASSERT( FIELD_OFFSET(struct unload_registry_request, attributes) == 16 );
  1202. C_ASSERT( sizeof(struct unload_registry_request) == 24 );
  1203. C_ASSERT( FIELD_OFFSET(struct save_registry_request, hkey) == 12 );
  1204. C_ASSERT( FIELD_OFFSET(struct save_registry_request, file) == 16 );
  1205. C_ASSERT( sizeof(struct save_registry_request) == 24 );
  1206. C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, hkey) == 12 );
  1207. C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, event) == 16 );
  1208. C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, subtree) == 20 );
  1209. C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, filter) == 24 );
  1210. C_ASSERT( sizeof(struct set_registry_notification_request) == 32 );
  1211. C_ASSERT( FIELD_OFFSET(struct create_timer_request, access) == 12 );
  1212. C_ASSERT( FIELD_OFFSET(struct create_timer_request, manual) == 16 );
  1213. C_ASSERT( sizeof(struct create_timer_request) == 24 );
  1214. C_ASSERT( FIELD_OFFSET(struct create_timer_reply, handle) == 8 );
  1215. C_ASSERT( sizeof(struct create_timer_reply) == 16 );
  1216. C_ASSERT( FIELD_OFFSET(struct open_timer_request, access) == 12 );
  1217. C_ASSERT( FIELD_OFFSET(struct open_timer_request, attributes) == 16 );
  1218. C_ASSERT( FIELD_OFFSET(struct open_timer_request, rootdir) == 20 );
  1219. C_ASSERT( sizeof(struct open_timer_request) == 24 );
  1220. C_ASSERT( FIELD_OFFSET(struct open_timer_reply, handle) == 8 );
  1221. C_ASSERT( sizeof(struct open_timer_reply) == 16 );
  1222. C_ASSERT( FIELD_OFFSET(struct set_timer_request, handle) == 12 );
  1223. C_ASSERT( FIELD_OFFSET(struct set_timer_request, expire) == 16 );
  1224. C_ASSERT( FIELD_OFFSET(struct set_timer_request, callback) == 24 );
  1225. C_ASSERT( FIELD_OFFSET(struct set_timer_request, arg) == 32 );
  1226. C_ASSERT( FIELD_OFFSET(struct set_timer_request, period) == 40 );
  1227. C_ASSERT( sizeof(struct set_timer_request) == 48 );
  1228. C_ASSERT( FIELD_OFFSET(struct set_timer_reply, signaled) == 8 );
  1229. C_ASSERT( sizeof(struct set_timer_reply) == 16 );
  1230. C_ASSERT( FIELD_OFFSET(struct cancel_timer_request, handle) == 12 );
  1231. C_ASSERT( sizeof(struct cancel_timer_request) == 16 );
  1232. C_ASSERT( FIELD_OFFSET(struct cancel_timer_reply, signaled) == 8 );
  1233. C_ASSERT( sizeof(struct cancel_timer_reply) == 16 );
  1234. C_ASSERT( FIELD_OFFSET(struct get_timer_info_request, handle) == 12 );
  1235. C_ASSERT( sizeof(struct get_timer_info_request) == 16 );
  1236. C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply, when) == 8 );
  1237. C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply, signaled) == 16 );
  1238. C_ASSERT( sizeof(struct get_timer_info_reply) == 24 );
  1239. C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, handle) == 12 );
  1240. C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, context) == 16 );
  1241. C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, flags) == 20 );
  1242. C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, machine) == 24 );
  1243. C_ASSERT( sizeof(struct get_thread_context_request) == 32 );
  1244. C_ASSERT( FIELD_OFFSET(struct get_thread_context_reply, self) == 8 );
  1245. C_ASSERT( FIELD_OFFSET(struct get_thread_context_reply, handle) == 12 );
  1246. C_ASSERT( sizeof(struct get_thread_context_reply) == 16 );
  1247. C_ASSERT( FIELD_OFFSET(struct set_thread_context_request, handle) == 12 );
  1248. C_ASSERT( sizeof(struct set_thread_context_request) == 16 );
  1249. C_ASSERT( FIELD_OFFSET(struct set_thread_context_reply, self) == 8 );
  1250. C_ASSERT( sizeof(struct set_thread_context_reply) == 16 );
  1251. C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request, handle) == 12 );
  1252. C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request, entry) == 16 );
  1253. C_ASSERT( sizeof(struct get_selector_entry_request) == 24 );
  1254. C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, base) == 8 );
  1255. C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, limit) == 12 );
  1256. C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, flags) == 16 );
  1257. C_ASSERT( sizeof(struct get_selector_entry_reply) == 24 );
  1258. C_ASSERT( sizeof(struct add_atom_request) == 16 );
  1259. C_ASSERT( FIELD_OFFSET(struct add_atom_reply, atom) == 8 );
  1260. C_ASSERT( sizeof(struct add_atom_reply) == 16 );
  1261. C_ASSERT( FIELD_OFFSET(struct delete_atom_request, atom) == 12 );
  1262. C_ASSERT( sizeof(struct delete_atom_request) == 16 );
  1263. C_ASSERT( sizeof(struct find_atom_request) == 16 );
  1264. C_ASSERT( FIELD_OFFSET(struct find_atom_reply, atom) == 8 );
  1265. C_ASSERT( sizeof(struct find_atom_reply) == 16 );
  1266. C_ASSERT( FIELD_OFFSET(struct get_atom_information_request, atom) == 12 );
  1267. C_ASSERT( sizeof(struct get_atom_information_request) == 16 );
  1268. C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, count) == 8 );
  1269. C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, pinned) == 12 );
  1270. C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, total) == 16 );
  1271. C_ASSERT( sizeof(struct get_atom_information_reply) == 24 );
  1272. C_ASSERT( sizeof(struct get_msg_queue_request) == 16 );
  1273. C_ASSERT( FIELD_OFFSET(struct get_msg_queue_reply, handle) == 8 );
  1274. C_ASSERT( sizeof(struct get_msg_queue_reply) == 16 );
  1275. C_ASSERT( FIELD_OFFSET(struct set_queue_fd_request, handle) == 12 );
  1276. C_ASSERT( sizeof(struct set_queue_fd_request) == 16 );
  1277. C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, wake_mask) == 12 );
  1278. C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, changed_mask) == 16 );
  1279. C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, skip_wait) == 20 );
  1280. C_ASSERT( sizeof(struct set_queue_mask_request) == 24 );
  1281. C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply, wake_bits) == 8 );
  1282. C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply, changed_bits) == 12 );
  1283. C_ASSERT( sizeof(struct set_queue_mask_reply) == 16 );
  1284. C_ASSERT( FIELD_OFFSET(struct get_queue_status_request, clear_bits) == 12 );
  1285. C_ASSERT( sizeof(struct get_queue_status_request) == 16 );
  1286. C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply, wake_bits) == 8 );
  1287. C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply, changed_bits) == 12 );
  1288. C_ASSERT( sizeof(struct get_queue_status_reply) == 16 );
  1289. C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_request, handle) == 12 );
  1290. C_ASSERT( sizeof(struct get_process_idle_event_request) == 16 );
  1291. C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_reply, event) == 8 );
  1292. C_ASSERT( sizeof(struct get_process_idle_event_reply) == 16 );
  1293. C_ASSERT( FIELD_OFFSET(struct send_message_request, id) == 12 );
  1294. C_ASSERT( FIELD_OFFSET(struct send_message_request, type) == 16 );
  1295. C_ASSERT( FIELD_OFFSET(struct send_message_request, flags) == 20 );
  1296. C_ASSERT( FIELD_OFFSET(struct send_message_request, win) == 24 );
  1297. C_ASSERT( FIELD_OFFSET(struct send_message_request, msg) == 28 );
  1298. C_ASSERT( FIELD_OFFSET(struct send_message_request, wparam) == 32 );
  1299. C_ASSERT( FIELD_OFFSET(struct send_message_request, lparam) == 40 );
  1300. C_ASSERT( FIELD_OFFSET(struct send_message_request, timeout) == 48 );
  1301. C_ASSERT( sizeof(struct send_message_request) == 56 );
  1302. C_ASSERT( FIELD_OFFSET(struct post_quit_message_request, exit_code) == 12 );
  1303. C_ASSERT( sizeof(struct post_quit_message_request) == 16 );
  1304. C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, win) == 12 );
  1305. C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, input) == 16 );
  1306. C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, flags) == 56 );
  1307. C_ASSERT( sizeof(struct send_hardware_message_request) == 64 );
  1308. C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, wait) == 8 );
  1309. C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, prev_x) == 12 );
  1310. C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, prev_y) == 16 );
  1311. C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, new_x) == 20 );
  1312. C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, new_y) == 24 );
  1313. C_ASSERT( sizeof(struct send_hardware_message_reply) == 32 );
  1314. C_ASSERT( FIELD_OFFSET(struct get_message_request, flags) == 12 );
  1315. C_ASSERT( FIELD_OFFSET(struct get_message_request, get_win) == 16 );
  1316. C_ASSERT( FIELD_OFFSET(struct get_message_request, get_first) == 20 );
  1317. C_ASSERT( FIELD_OFFSET(struct get_message_request, get_last) == 24 );
  1318. C_ASSERT( FIELD_OFFSET(struct get_message_request, hw_id) == 28 );
  1319. C_ASSERT( FIELD_OFFSET(struct get_message_request, wake_mask) == 32 );
  1320. C_ASSERT( FIELD_OFFSET(struct get_message_request, changed_mask) == 36 );
  1321. C_ASSERT( sizeof(struct get_message_request) == 40 );
  1322. C_ASSERT( FIELD_OFFSET(struct get_message_reply, win) == 8 );
  1323. C_ASSERT( FIELD_OFFSET(struct get_message_reply, msg) == 12 );
  1324. C_ASSERT( FIELD_OFFSET(struct get_message_reply, wparam) == 16 );
  1325. C_ASSERT( FIELD_OFFSET(struct get_message_reply, lparam) == 24 );
  1326. C_ASSERT( FIELD_OFFSET(struct get_message_reply, type) == 32 );
  1327. C_ASSERT( FIELD_OFFSET(struct get_message_reply, x) == 36 );
  1328. C_ASSERT( FIELD_OFFSET(struct get_message_reply, y) == 40 );
  1329. C_ASSERT( FIELD_OFFSET(struct get_message_reply, time) == 44 );
  1330. C_ASSERT( FIELD_OFFSET(struct get_message_reply, active_hooks) == 48 );
  1331. C_ASSERT( FIELD_OFFSET(struct get_message_reply, total) == 52 );
  1332. C_ASSERT( sizeof(struct get_message_reply) == 56 );
  1333. C_ASSERT( FIELD_OFFSET(struct reply_message_request, remove) == 12 );
  1334. C_ASSERT( FIELD_OFFSET(struct reply_message_request, result) == 16 );
  1335. C_ASSERT( sizeof(struct reply_message_request) == 24 );
  1336. C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request, hw_id) == 12 );
  1337. C_ASSERT( sizeof(struct accept_hardware_message_request) == 16 );
  1338. C_ASSERT( FIELD_OFFSET(struct get_message_reply_request, cancel) == 12 );
  1339. C_ASSERT( sizeof(struct get_message_reply_request) == 16 );
  1340. C_ASSERT( FIELD_OFFSET(struct get_message_reply_reply, result) == 8 );
  1341. C_ASSERT( sizeof(struct get_message_reply_reply) == 16 );
  1342. C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, win) == 12 );
  1343. C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, msg) == 16 );
  1344. C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, rate) == 20 );
  1345. C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, id) == 24 );
  1346. C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, lparam) == 32 );
  1347. C_ASSERT( sizeof(struct set_win_timer_request) == 40 );
  1348. C_ASSERT( FIELD_OFFSET(struct set_win_timer_reply, id) == 8 );
  1349. C_ASSERT( sizeof(struct set_win_timer_reply) == 16 );
  1350. C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, win) == 12 );
  1351. C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, id) == 16 );
  1352. C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, msg) == 24 );
  1353. C_ASSERT( sizeof(struct kill_win_timer_request) == 32 );
  1354. C_ASSERT( FIELD_OFFSET(struct is_window_hung_request, win) == 12 );
  1355. C_ASSERT( sizeof(struct is_window_hung_request) == 16 );
  1356. C_ASSERT( FIELD_OFFSET(struct is_window_hung_reply, is_hung) == 8 );
  1357. C_ASSERT( sizeof(struct is_window_hung_reply) == 16 );
  1358. C_ASSERT( FIELD_OFFSET(struct get_serial_info_request, handle) == 12 );
  1359. C_ASSERT( FIELD_OFFSET(struct get_serial_info_request, flags) == 16 );
  1360. C_ASSERT( sizeof(struct get_serial_info_request) == 24 );
  1361. C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, eventmask) == 8 );
  1362. C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, cookie) == 12 );
  1363. C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, pending_write) == 16 );
  1364. C_ASSERT( sizeof(struct get_serial_info_reply) == 24 );
  1365. C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, handle) == 12 );
  1366. C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, flags) == 16 );
  1367. C_ASSERT( sizeof(struct set_serial_info_request) == 24 );
  1368. C_ASSERT( FIELD_OFFSET(struct register_async_request, type) == 12 );
  1369. C_ASSERT( FIELD_OFFSET(struct register_async_request, async) == 16 );
  1370. C_ASSERT( FIELD_OFFSET(struct register_async_request, count) == 56 );
  1371. C_ASSERT( sizeof(struct register_async_request) == 64 );
  1372. C_ASSERT( FIELD_OFFSET(struct cancel_async_request, handle) == 12 );
  1373. C_ASSERT( FIELD_OFFSET(struct cancel_async_request, iosb) == 16 );
  1374. C_ASSERT( FIELD_OFFSET(struct cancel_async_request, only_thread) == 24 );
  1375. C_ASSERT( sizeof(struct cancel_async_request) == 32 );
  1376. C_ASSERT( FIELD_OFFSET(struct get_async_result_request, user_arg) == 16 );
  1377. C_ASSERT( sizeof(struct get_async_result_request) == 24 );
  1378. C_ASSERT( sizeof(struct get_async_result_reply) == 8 );
  1379. C_ASSERT( FIELD_OFFSET(struct set_async_direct_result_request, handle) == 12 );
  1380. C_ASSERT( FIELD_OFFSET(struct set_async_direct_result_request, information) == 16 );
  1381. C_ASSERT( FIELD_OFFSET(struct set_async_direct_result_request, status) == 24 );
  1382. C_ASSERT( FIELD_OFFSET(struct set_async_direct_result_request, mark_pending) == 28 );
  1383. C_ASSERT( sizeof(struct set_async_direct_result_request) == 32 );
  1384. C_ASSERT( FIELD_OFFSET(struct set_async_direct_result_reply, handle) == 8 );
  1385. C_ASSERT( sizeof(struct set_async_direct_result_reply) == 16 );
  1386. C_ASSERT( FIELD_OFFSET(struct read_request, async) == 16 );
  1387. C_ASSERT( FIELD_OFFSET(struct read_request, pos) == 56 );
  1388. C_ASSERT( sizeof(struct read_request) == 64 );
  1389. C_ASSERT( FIELD_OFFSET(struct read_reply, wait) == 8 );
  1390. C_ASSERT( FIELD_OFFSET(struct read_reply, options) == 12 );
  1391. C_ASSERT( sizeof(struct read_reply) == 16 );
  1392. C_ASSERT( FIELD_OFFSET(struct write_request, async) == 16 );
  1393. C_ASSERT( FIELD_OFFSET(struct write_request, pos) == 56 );
  1394. C_ASSERT( sizeof(struct write_request) == 64 );
  1395. C_ASSERT( FIELD_OFFSET(struct write_reply, wait) == 8 );
  1396. C_ASSERT( FIELD_OFFSET(struct write_reply, options) == 12 );
  1397. C_ASSERT( FIELD_OFFSET(struct write_reply, size) == 16 );
  1398. C_ASSERT( sizeof(struct write_reply) == 24 );
  1399. C_ASSERT( FIELD_OFFSET(struct ioctl_request, code) == 12 );
  1400. C_ASSERT( FIELD_OFFSET(struct ioctl_request, async) == 16 );
  1401. C_ASSERT( sizeof(struct ioctl_request) == 56 );
  1402. C_ASSERT( FIELD_OFFSET(struct ioctl_reply, wait) == 8 );
  1403. C_ASSERT( FIELD_OFFSET(struct ioctl_reply, options) == 12 );
  1404. C_ASSERT( sizeof(struct ioctl_reply) == 16 );
  1405. C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, handle) == 12 );
  1406. C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, status) == 16 );
  1407. C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, size) == 20 );
  1408. C_ASSERT( sizeof(struct set_irp_result_request) == 24 );
  1409. C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, access) == 12 );
  1410. C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, options) == 16 );
  1411. C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, sharing) == 20 );
  1412. C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, maxinstances) == 24 );
  1413. C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, outsize) == 28 );
  1414. C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, insize) == 32 );
  1415. C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, timeout) == 40 );
  1416. C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, flags) == 48 );
  1417. C_ASSERT( sizeof(struct create_named_pipe_request) == 56 );
  1418. C_ASSERT( FIELD_OFFSET(struct create_named_pipe_reply, handle) == 8 );
  1419. C_ASSERT( sizeof(struct create_named_pipe_reply) == 16 );
  1420. C_ASSERT( FIELD_OFFSET(struct set_named_pipe_info_request, handle) == 12 );
  1421. C_ASSERT( FIELD_OFFSET(struct set_named_pipe_info_request, flags) == 16 );
  1422. C_ASSERT( sizeof(struct set_named_pipe_info_request) == 24 );
  1423. C_ASSERT( FIELD_OFFSET(struct create_window_request, parent) == 12 );
  1424. C_ASSERT( FIELD_OFFSET(struct create_window_request, owner) == 16 );
  1425. C_ASSERT( FIELD_OFFSET(struct create_window_request, atom) == 20 );
  1426. C_ASSERT( FIELD_OFFSET(struct create_window_request, instance) == 24 );
  1427. C_ASSERT( FIELD_OFFSET(struct create_window_request, dpi) == 32 );
  1428. C_ASSERT( FIELD_OFFSET(struct create_window_request, awareness) == 36 );
  1429. C_ASSERT( FIELD_OFFSET(struct create_window_request, style) == 40 );
  1430. C_ASSERT( FIELD_OFFSET(struct create_window_request, ex_style) == 44 );
  1431. C_ASSERT( sizeof(struct create_window_request) == 48 );
  1432. C_ASSERT( FIELD_OFFSET(struct create_window_reply, handle) == 8 );
  1433. C_ASSERT( FIELD_OFFSET(struct create_window_reply, parent) == 12 );
  1434. C_ASSERT( FIELD_OFFSET(struct create_window_reply, owner) == 16 );
  1435. C_ASSERT( FIELD_OFFSET(struct create_window_reply, extra) == 20 );
  1436. C_ASSERT( FIELD_OFFSET(struct create_window_reply, class_ptr) == 24 );
  1437. C_ASSERT( FIELD_OFFSET(struct create_window_reply, dpi) == 32 );
  1438. C_ASSERT( FIELD_OFFSET(struct create_window_reply, awareness) == 36 );
  1439. C_ASSERT( sizeof(struct create_window_reply) == 40 );
  1440. C_ASSERT( FIELD_OFFSET(struct destroy_window_request, handle) == 12 );
  1441. C_ASSERT( sizeof(struct destroy_window_request) == 16 );
  1442. C_ASSERT( FIELD_OFFSET(struct get_desktop_window_request, force) == 12 );
  1443. C_ASSERT( sizeof(struct get_desktop_window_request) == 16 );
  1444. C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply, top_window) == 8 );
  1445. C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply, msg_window) == 12 );
  1446. C_ASSERT( sizeof(struct get_desktop_window_reply) == 16 );
  1447. C_ASSERT( FIELD_OFFSET(struct set_window_owner_request, handle) == 12 );
  1448. C_ASSERT( FIELD_OFFSET(struct set_window_owner_request, owner) == 16 );
  1449. C_ASSERT( sizeof(struct set_window_owner_request) == 24 );
  1450. C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply, full_owner) == 8 );
  1451. C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply, prev_owner) == 12 );
  1452. C_ASSERT( sizeof(struct set_window_owner_reply) == 16 );
  1453. C_ASSERT( FIELD_OFFSET(struct get_window_info_request, handle) == 12 );
  1454. C_ASSERT( sizeof(struct get_window_info_request) == 16 );
  1455. C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, full_handle) == 8 );
  1456. C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, last_active) == 12 );
  1457. C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, pid) == 16 );
  1458. C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, tid) == 20 );
  1459. C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, atom) == 24 );
  1460. C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, is_unicode) == 28 );
  1461. C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, dpi) == 32 );
  1462. C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, awareness) == 36 );
  1463. C_ASSERT( sizeof(struct get_window_info_reply) == 40 );
  1464. C_ASSERT( FIELD_OFFSET(struct set_window_info_request, flags) == 12 );
  1465. C_ASSERT( FIELD_OFFSET(struct set_window_info_request, is_unicode) == 14 );
  1466. C_ASSERT( FIELD_OFFSET(struct set_window_info_request, handle) == 16 );
  1467. C_ASSERT( FIELD_OFFSET(struct set_window_info_request, style) == 20 );
  1468. C_ASSERT( FIELD_OFFSET(struct set_window_info_request, ex_style) == 24 );
  1469. C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_size) == 28 );
  1470. C_ASSERT( FIELD_OFFSET(struct set_window_info_request, instance) == 32 );
  1471. C_ASSERT( FIELD_OFFSET(struct set_window_info_request, user_data) == 40 );
  1472. C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_value) == 48 );
  1473. C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_offset) == 56 );
  1474. C_ASSERT( sizeof(struct set_window_info_request) == 64 );
  1475. C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_style) == 8 );
  1476. C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_ex_style) == 12 );
  1477. C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_instance) == 16 );
  1478. C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_user_data) == 24 );
  1479. C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_extra_value) == 32 );
  1480. C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_id) == 40 );
  1481. C_ASSERT( sizeof(struct set_window_info_reply) == 48 );
  1482. C_ASSERT( FIELD_OFFSET(struct set_parent_request, handle) == 12 );
  1483. C_ASSERT( FIELD_OFFSET(struct set_parent_request, parent) == 16 );
  1484. C_ASSERT( sizeof(struct set_parent_request) == 24 );
  1485. C_ASSERT( FIELD_OFFSET(struct set_parent_reply, old_parent) == 8 );
  1486. C_ASSERT( FIELD_OFFSET(struct set_parent_reply, full_parent) == 12 );
  1487. C_ASSERT( FIELD_OFFSET(struct set_parent_reply, dpi) == 16 );
  1488. C_ASSERT( FIELD_OFFSET(struct set_parent_reply, awareness) == 20 );
  1489. C_ASSERT( sizeof(struct set_parent_reply) == 24 );
  1490. C_ASSERT( FIELD_OFFSET(struct get_window_parents_request, handle) == 12 );
  1491. C_ASSERT( sizeof(struct get_window_parents_request) == 16 );
  1492. C_ASSERT( FIELD_OFFSET(struct get_window_parents_reply, count) == 8 );
  1493. C_ASSERT( sizeof(struct get_window_parents_reply) == 16 );
  1494. C_ASSERT( FIELD_OFFSET(struct get_window_children_request, desktop) == 12 );
  1495. C_ASSERT( FIELD_OFFSET(struct get_window_children_request, parent) == 16 );
  1496. C_ASSERT( FIELD_OFFSET(struct get_window_children_request, atom) == 20 );
  1497. C_ASSERT( FIELD_OFFSET(struct get_window_children_request, tid) == 24 );
  1498. C_ASSERT( sizeof(struct get_window_children_request) == 32 );
  1499. C_ASSERT( FIELD_OFFSET(struct get_window_children_reply, count) == 8 );
  1500. C_ASSERT( sizeof(struct get_window_children_reply) == 16 );
  1501. C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, parent) == 12 );
  1502. C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, x) == 16 );
  1503. C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, y) == 20 );
  1504. C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, dpi) == 24 );
  1505. C_ASSERT( sizeof(struct get_window_children_from_point_request) == 32 );
  1506. C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_reply, count) == 8 );
  1507. C_ASSERT( sizeof(struct get_window_children_from_point_reply) == 16 );
  1508. C_ASSERT( FIELD_OFFSET(struct get_window_tree_request, handle) == 12 );
  1509. C_ASSERT( sizeof(struct get_window_tree_request) == 16 );
  1510. C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, parent) == 8 );
  1511. C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, owner) == 12 );
  1512. C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, next_sibling) == 16 );
  1513. C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, prev_sibling) == 20 );
  1514. C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, first_sibling) == 24 );
  1515. C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, last_sibling) == 28 );
  1516. C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, first_child) == 32 );
  1517. C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, last_child) == 36 );
  1518. C_ASSERT( sizeof(struct get_window_tree_reply) == 40 );
  1519. C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, swp_flags) == 12 );
  1520. C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, paint_flags) == 14 );
  1521. C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, handle) == 16 );
  1522. C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, previous) == 20 );
  1523. C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, window) == 24 );
  1524. C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, client) == 40 );
  1525. C_ASSERT( sizeof(struct set_window_pos_request) == 56 );
  1526. C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, new_style) == 8 );
  1527. C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, new_ex_style) == 12 );
  1528. C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, surface_win) == 16 );
  1529. C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, needs_update) == 20 );
  1530. C_ASSERT( sizeof(struct set_window_pos_reply) == 24 );
  1531. C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, handle) == 12 );
  1532. C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, relative) == 16 );
  1533. C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, dpi) == 20 );
  1534. C_ASSERT( sizeof(struct get_window_rectangles_request) == 24 );
  1535. C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, window) == 8 );
  1536. C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, client) == 24 );
  1537. C_ASSERT( sizeof(struct get_window_rectangles_reply) == 40 );
  1538. C_ASSERT( FIELD_OFFSET(struct get_window_text_request, handle) == 12 );
  1539. C_ASSERT( sizeof(struct get_window_text_request) == 16 );
  1540. C_ASSERT( FIELD_OFFSET(struct get_window_text_reply, length) == 8 );
  1541. C_ASSERT( sizeof(struct get_window_text_reply) == 16 );
  1542. C_ASSERT( FIELD_OFFSET(struct set_window_text_request, handle) == 12 );
  1543. C_ASSERT( sizeof(struct set_window_text_request) == 16 );
  1544. C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, from) == 12 );
  1545. C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, to) == 16 );
  1546. C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, dpi) == 20 );
  1547. C_ASSERT( sizeof(struct get_windows_offset_request) == 24 );
  1548. C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, x) == 8 );
  1549. C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, y) == 12 );
  1550. C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, mirror) == 16 );
  1551. C_ASSERT( sizeof(struct get_windows_offset_reply) == 24 );
  1552. C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, window) == 12 );
  1553. C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, flags) == 16 );
  1554. C_ASSERT( sizeof(struct get_visible_region_request) == 24 );
  1555. C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, top_win) == 8 );
  1556. C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, top_rect) == 12 );
  1557. C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, win_rect) == 28 );
  1558. C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, paint_flags) == 44 );
  1559. C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, total_size) == 48 );
  1560. C_ASSERT( sizeof(struct get_visible_region_reply) == 56 );
  1561. C_ASSERT( FIELD_OFFSET(struct get_surface_region_request, window) == 12 );
  1562. C_ASSERT( sizeof(struct get_surface_region_request) == 16 );
  1563. C_ASSERT( FIELD_OFFSET(struct get_surface_region_reply, visible_rect) == 8 );
  1564. C_ASSERT( FIELD_OFFSET(struct get_surface_region_reply, total_size) == 24 );
  1565. C_ASSERT( sizeof(struct get_surface_region_reply) == 32 );
  1566. C_ASSERT( FIELD_OFFSET(struct get_window_region_request, window) == 12 );
  1567. C_ASSERT( sizeof(struct get_window_region_request) == 16 );
  1568. C_ASSERT( FIELD_OFFSET(struct get_window_region_reply, total_size) == 8 );
  1569. C_ASSERT( sizeof(struct get_window_region_reply) == 16 );
  1570. C_ASSERT( FIELD_OFFSET(struct set_window_region_request, window) == 12 );
  1571. C_ASSERT( FIELD_OFFSET(struct set_window_region_request, redraw) == 16 );
  1572. C_ASSERT( sizeof(struct set_window_region_request) == 24 );
  1573. C_ASSERT( FIELD_OFFSET(struct get_update_region_request, window) == 12 );
  1574. C_ASSERT( FIELD_OFFSET(struct get_update_region_request, from_child) == 16 );
  1575. C_ASSERT( FIELD_OFFSET(struct get_update_region_request, flags) == 20 );
  1576. C_ASSERT( sizeof(struct get_update_region_request) == 24 );
  1577. C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, child) == 8 );
  1578. C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, flags) == 12 );
  1579. C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, total_size) == 16 );
  1580. C_ASSERT( sizeof(struct get_update_region_reply) == 24 );
  1581. C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request, window) == 12 );
  1582. C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request, rect) == 16 );
  1583. C_ASSERT( sizeof(struct update_window_zorder_request) == 32 );
  1584. C_ASSERT( FIELD_OFFSET(struct redraw_window_request, window) == 12 );
  1585. C_ASSERT( FIELD_OFFSET(struct redraw_window_request, flags) == 16 );
  1586. C_ASSERT( sizeof(struct redraw_window_request) == 24 );
  1587. C_ASSERT( FIELD_OFFSET(struct set_window_property_request, window) == 12 );
  1588. C_ASSERT( FIELD_OFFSET(struct set_window_property_request, data) == 16 );
  1589. C_ASSERT( FIELD_OFFSET(struct set_window_property_request, atom) == 24 );
  1590. C_ASSERT( sizeof(struct set_window_property_request) == 32 );
  1591. C_ASSERT( FIELD_OFFSET(struct remove_window_property_request, window) == 12 );
  1592. C_ASSERT( FIELD_OFFSET(struct remove_window_property_request, atom) == 16 );
  1593. C_ASSERT( sizeof(struct remove_window_property_request) == 24 );
  1594. C_ASSERT( FIELD_OFFSET(struct remove_window_property_reply, data) == 8 );
  1595. C_ASSERT( sizeof(struct remove_window_property_reply) == 16 );
  1596. C_ASSERT( FIELD_OFFSET(struct get_window_property_request, window) == 12 );
  1597. C_ASSERT( FIELD_OFFSET(struct get_window_property_request, atom) == 16 );
  1598. C_ASSERT( sizeof(struct get_window_property_request) == 24 );
  1599. C_ASSERT( FIELD_OFFSET(struct get_window_property_reply, data) == 8 );
  1600. C_ASSERT( sizeof(struct get_window_property_reply) == 16 );
  1601. C_ASSERT( FIELD_OFFSET(struct get_window_properties_request, window) == 12 );
  1602. C_ASSERT( sizeof(struct get_window_properties_request) == 16 );
  1603. C_ASSERT( FIELD_OFFSET(struct get_window_properties_reply, total) == 8 );
  1604. C_ASSERT( sizeof(struct get_window_properties_reply) == 16 );
  1605. C_ASSERT( FIELD_OFFSET(struct create_winstation_request, flags) == 12 );
  1606. C_ASSERT( FIELD_OFFSET(struct create_winstation_request, access) == 16 );
  1607. C_ASSERT( FIELD_OFFSET(struct create_winstation_request, attributes) == 20 );
  1608. C_ASSERT( FIELD_OFFSET(struct create_winstation_request, rootdir) == 24 );
  1609. C_ASSERT( sizeof(struct create_winstation_request) == 32 );
  1610. C_ASSERT( FIELD_OFFSET(struct create_winstation_reply, handle) == 8 );
  1611. C_ASSERT( sizeof(struct create_winstation_reply) == 16 );
  1612. C_ASSERT( FIELD_OFFSET(struct open_winstation_request, access) == 12 );
  1613. C_ASSERT( FIELD_OFFSET(struct open_winstation_request, attributes) == 16 );
  1614. C_ASSERT( FIELD_OFFSET(struct open_winstation_request, rootdir) == 20 );
  1615. C_ASSERT( sizeof(struct open_winstation_request) == 24 );
  1616. C_ASSERT( FIELD_OFFSET(struct open_winstation_reply, handle) == 8 );
  1617. C_ASSERT( sizeof(struct open_winstation_reply) == 16 );
  1618. C_ASSERT( FIELD_OFFSET(struct close_winstation_request, handle) == 12 );
  1619. C_ASSERT( sizeof(struct close_winstation_request) == 16 );
  1620. C_ASSERT( sizeof(struct get_process_winstation_request) == 16 );
  1621. C_ASSERT( FIELD_OFFSET(struct get_process_winstation_reply, handle) == 8 );
  1622. C_ASSERT( sizeof(struct get_process_winstation_reply) == 16 );
  1623. C_ASSERT( FIELD_OFFSET(struct set_process_winstation_request, handle) == 12 );
  1624. C_ASSERT( sizeof(struct set_process_winstation_request) == 16 );
  1625. C_ASSERT( FIELD_OFFSET(struct enum_winstation_request, index) == 12 );
  1626. C_ASSERT( sizeof(struct enum_winstation_request) == 16 );
  1627. C_ASSERT( FIELD_OFFSET(struct enum_winstation_reply, next) == 8 );
  1628. C_ASSERT( sizeof(struct enum_winstation_reply) == 16 );
  1629. C_ASSERT( FIELD_OFFSET(struct create_desktop_request, flags) == 12 );
  1630. C_ASSERT( FIELD_OFFSET(struct create_desktop_request, access) == 16 );
  1631. C_ASSERT( FIELD_OFFSET(struct create_desktop_request, attributes) == 20 );
  1632. C_ASSERT( sizeof(struct create_desktop_request) == 24 );
  1633. C_ASSERT( FIELD_OFFSET(struct create_desktop_reply, handle) == 8 );
  1634. C_ASSERT( sizeof(struct create_desktop_reply) == 16 );
  1635. C_ASSERT( FIELD_OFFSET(struct open_desktop_request, winsta) == 12 );
  1636. C_ASSERT( FIELD_OFFSET(struct open_desktop_request, flags) == 16 );
  1637. C_ASSERT( FIELD_OFFSET(struct open_desktop_request, access) == 20 );
  1638. C_ASSERT( FIELD_OFFSET(struct open_desktop_request, attributes) == 24 );
  1639. C_ASSERT( sizeof(struct open_desktop_request) == 32 );
  1640. C_ASSERT( FIELD_OFFSET(struct open_desktop_reply, handle) == 8 );
  1641. C_ASSERT( sizeof(struct open_desktop_reply) == 16 );
  1642. C_ASSERT( FIELD_OFFSET(struct open_input_desktop_request, flags) == 12 );
  1643. C_ASSERT( FIELD_OFFSET(struct open_input_desktop_request, access) == 16 );
  1644. C_ASSERT( FIELD_OFFSET(struct open_input_desktop_request, attributes) == 20 );
  1645. C_ASSERT( sizeof(struct open_input_desktop_request) == 24 );
  1646. C_ASSERT( FIELD_OFFSET(struct open_input_desktop_reply, handle) == 8 );
  1647. C_ASSERT( sizeof(struct open_input_desktop_reply) == 16 );
  1648. C_ASSERT( FIELD_OFFSET(struct close_desktop_request, handle) == 12 );
  1649. C_ASSERT( sizeof(struct close_desktop_request) == 16 );
  1650. C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_request, tid) == 12 );
  1651. C_ASSERT( sizeof(struct get_thread_desktop_request) == 16 );
  1652. C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_reply, handle) == 8 );
  1653. C_ASSERT( sizeof(struct get_thread_desktop_reply) == 16 );
  1654. C_ASSERT( FIELD_OFFSET(struct set_thread_desktop_request, handle) == 12 );
  1655. C_ASSERT( sizeof(struct set_thread_desktop_request) == 16 );
  1656. C_ASSERT( FIELD_OFFSET(struct enum_desktop_request, winstation) == 12 );
  1657. C_ASSERT( FIELD_OFFSET(struct enum_desktop_request, index) == 16 );
  1658. C_ASSERT( sizeof(struct enum_desktop_request) == 24 );
  1659. C_ASSERT( FIELD_OFFSET(struct enum_desktop_reply, next) == 8 );
  1660. C_ASSERT( sizeof(struct enum_desktop_reply) == 16 );
  1661. C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, handle) == 12 );
  1662. C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, flags) == 16 );
  1663. C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, obj_flags) == 20 );
  1664. C_ASSERT( sizeof(struct set_user_object_info_request) == 24 );
  1665. C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply, is_desktop) == 8 );
  1666. C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply, old_obj_flags) == 12 );
  1667. C_ASSERT( sizeof(struct set_user_object_info_reply) == 16 );
  1668. C_ASSERT( FIELD_OFFSET(struct register_hotkey_request, window) == 12 );
  1669. C_ASSERT( FIELD_OFFSET(struct register_hotkey_request, id) == 16 );
  1670. C_ASSERT( FIELD_OFFSET(struct register_hotkey_request, flags) == 20 );
  1671. C_ASSERT( FIELD_OFFSET(struct register_hotkey_request, vkey) == 24 );
  1672. C_ASSERT( sizeof(struct register_hotkey_request) == 32 );
  1673. C_ASSERT( FIELD_OFFSET(struct register_hotkey_reply, replaced) == 8 );
  1674. C_ASSERT( FIELD_OFFSET(struct register_hotkey_reply, flags) == 12 );
  1675. C_ASSERT( FIELD_OFFSET(struct register_hotkey_reply, vkey) == 16 );
  1676. C_ASSERT( sizeof(struct register_hotkey_reply) == 24 );
  1677. C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_request, window) == 12 );
  1678. C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_request, id) == 16 );
  1679. C_ASSERT( sizeof(struct unregister_hotkey_request) == 24 );
  1680. C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_reply, flags) == 8 );
  1681. C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_reply, vkey) == 12 );
  1682. C_ASSERT( sizeof(struct unregister_hotkey_reply) == 16 );
  1683. C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, tid_from) == 12 );
  1684. C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, tid_to) == 16 );
  1685. C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, attach) == 20 );
  1686. C_ASSERT( sizeof(struct attach_thread_input_request) == 24 );
  1687. C_ASSERT( FIELD_OFFSET(struct get_thread_input_request, tid) == 12 );
  1688. C_ASSERT( sizeof(struct get_thread_input_request) == 16 );
  1689. C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, focus) == 8 );
  1690. C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, capture) == 12 );
  1691. C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, active) == 16 );
  1692. C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, foreground) == 20 );
  1693. C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, menu_owner) == 24 );
  1694. C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, move_size) == 28 );
  1695. C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, caret) == 32 );
  1696. C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, cursor) == 36 );
  1697. C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, show_count) == 40 );
  1698. C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, rect) == 44 );
  1699. C_ASSERT( sizeof(struct get_thread_input_reply) == 64 );
  1700. C_ASSERT( sizeof(struct get_last_input_time_request) == 16 );
  1701. C_ASSERT( FIELD_OFFSET(struct get_last_input_time_reply, time) == 8 );
  1702. C_ASSERT( sizeof(struct get_last_input_time_reply) == 16 );
  1703. C_ASSERT( FIELD_OFFSET(struct get_key_state_request, async) == 12 );
  1704. C_ASSERT( FIELD_OFFSET(struct get_key_state_request, key) == 16 );
  1705. C_ASSERT( sizeof(struct get_key_state_request) == 24 );
  1706. C_ASSERT( FIELD_OFFSET(struct get_key_state_reply, state) == 8 );
  1707. C_ASSERT( sizeof(struct get_key_state_reply) == 16 );
  1708. C_ASSERT( FIELD_OFFSET(struct set_key_state_request, async) == 12 );
  1709. C_ASSERT( sizeof(struct set_key_state_request) == 16 );
  1710. C_ASSERT( FIELD_OFFSET(struct set_foreground_window_request, handle) == 12 );
  1711. C_ASSERT( sizeof(struct set_foreground_window_request) == 16 );
  1712. C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, previous) == 8 );
  1713. C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, send_msg_old) == 12 );
  1714. C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, send_msg_new) == 16 );
  1715. C_ASSERT( sizeof(struct set_foreground_window_reply) == 24 );
  1716. C_ASSERT( FIELD_OFFSET(struct set_focus_window_request, handle) == 12 );
  1717. C_ASSERT( sizeof(struct set_focus_window_request) == 16 );
  1718. C_ASSERT( FIELD_OFFSET(struct set_focus_window_reply, previous) == 8 );
  1719. C_ASSERT( sizeof(struct set_focus_window_reply) == 16 );
  1720. C_ASSERT( FIELD_OFFSET(struct set_active_window_request, handle) == 12 );
  1721. C_ASSERT( sizeof(struct set_active_window_request) == 16 );
  1722. C_ASSERT( FIELD_OFFSET(struct set_active_window_reply, previous) == 8 );
  1723. C_ASSERT( sizeof(struct set_active_window_reply) == 16 );
  1724. C_ASSERT( FIELD_OFFSET(struct set_capture_window_request, handle) == 12 );
  1725. C_ASSERT( FIELD_OFFSET(struct set_capture_window_request, flags) == 16 );
  1726. C_ASSERT( sizeof(struct set_capture_window_request) == 24 );
  1727. C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply, previous) == 8 );
  1728. C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply, full_handle) == 12 );
  1729. C_ASSERT( sizeof(struct set_capture_window_reply) == 16 );
  1730. C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, handle) == 12 );
  1731. C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, width) == 16 );
  1732. C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, height) == 20 );
  1733. C_ASSERT( sizeof(struct set_caret_window_request) == 24 );
  1734. C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, previous) == 8 );
  1735. C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_rect) == 12 );
  1736. C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_hide) == 28 );
  1737. C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_state) == 32 );
  1738. C_ASSERT( sizeof(struct set_caret_window_reply) == 40 );
  1739. C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, flags) == 12 );
  1740. C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, handle) == 16 );
  1741. C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, x) == 20 );
  1742. C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, y) == 24 );
  1743. C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, hide) == 28 );
  1744. C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, state) == 32 );
  1745. C_ASSERT( sizeof(struct set_caret_info_request) == 40 );
  1746. C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, full_handle) == 8 );
  1747. C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_rect) == 12 );
  1748. C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_hide) == 28 );
  1749. C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_state) == 32 );
  1750. C_ASSERT( sizeof(struct set_caret_info_reply) == 40 );
  1751. C_ASSERT( FIELD_OFFSET(struct set_hook_request, id) == 12 );
  1752. C_ASSERT( FIELD_OFFSET(struct set_hook_request, pid) == 16 );
  1753. C_ASSERT( FIELD_OFFSET(struct set_hook_request, tid) == 20 );
  1754. C_ASSERT( FIELD_OFFSET(struct set_hook_request, event_min) == 24 );
  1755. C_ASSERT( FIELD_OFFSET(struct set_hook_request, event_max) == 28 );
  1756. C_ASSERT( FIELD_OFFSET(struct set_hook_request, proc) == 32 );
  1757. C_ASSERT( FIELD_OFFSET(struct set_hook_request, flags) == 40 );
  1758. C_ASSERT( FIELD_OFFSET(struct set_hook_request, unicode) == 44 );
  1759. C_ASSERT( sizeof(struct set_hook_request) == 48 );
  1760. C_ASSERT( FIELD_OFFSET(struct set_hook_reply, handle) == 8 );
  1761. C_ASSERT( FIELD_OFFSET(struct set_hook_reply, active_hooks) == 12 );
  1762. C_ASSERT( sizeof(struct set_hook_reply) == 16 );
  1763. C_ASSERT( FIELD_OFFSET(struct remove_hook_request, handle) == 12 );
  1764. C_ASSERT( FIELD_OFFSET(struct remove_hook_request, proc) == 16 );
  1765. C_ASSERT( FIELD_OFFSET(struct remove_hook_request, id) == 24 );
  1766. C_ASSERT( sizeof(struct remove_hook_request) == 32 );
  1767. C_ASSERT( FIELD_OFFSET(struct remove_hook_reply, active_hooks) == 8 );
  1768. C_ASSERT( sizeof(struct remove_hook_reply) == 16 );
  1769. C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, id) == 12 );
  1770. C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, event) == 16 );
  1771. C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, window) == 20 );
  1772. C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, object_id) == 24 );
  1773. C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, child_id) == 28 );
  1774. C_ASSERT( sizeof(struct start_hook_chain_request) == 32 );
  1775. C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, handle) == 8 );
  1776. C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, pid) == 12 );
  1777. C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, tid) == 16 );
  1778. C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, unicode) == 20 );
  1779. C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, proc) == 24 );
  1780. C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, active_hooks) == 32 );
  1781. C_ASSERT( sizeof(struct start_hook_chain_reply) == 40 );
  1782. C_ASSERT( FIELD_OFFSET(struct finish_hook_chain_request, id) == 12 );
  1783. C_ASSERT( sizeof(struct finish_hook_chain_request) == 16 );
  1784. C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, handle) == 12 );
  1785. C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, get_next) == 16 );
  1786. C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, event) == 20 );
  1787. C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, window) == 24 );
  1788. C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, object_id) == 28 );
  1789. C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, child_id) == 32 );
  1790. C_ASSERT( sizeof(struct get_hook_info_request) == 40 );
  1791. C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, handle) == 8 );
  1792. C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, id) == 12 );
  1793. C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, pid) == 16 );
  1794. C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, tid) == 20 );
  1795. C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, proc) == 24 );
  1796. C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, unicode) == 32 );
  1797. C_ASSERT( sizeof(struct get_hook_info_reply) == 40 );
  1798. C_ASSERT( FIELD_OFFSET(struct create_class_request, local) == 12 );
  1799. C_ASSERT( FIELD_OFFSET(struct create_class_request, atom) == 16 );
  1800. C_ASSERT( FIELD_OFFSET(struct create_class_request, style) == 20 );
  1801. C_ASSERT( FIELD_OFFSET(struct create_class_request, instance) == 24 );
  1802. C_ASSERT( FIELD_OFFSET(struct create_class_request, extra) == 32 );
  1803. C_ASSERT( FIELD_OFFSET(struct create_class_request, win_extra) == 36 );
  1804. C_ASSERT( FIELD_OFFSET(struct create_class_request, client_ptr) == 40 );
  1805. C_ASSERT( FIELD_OFFSET(struct create_class_request, name_offset) == 48 );
  1806. C_ASSERT( sizeof(struct create_class_request) == 56 );
  1807. C_ASSERT( FIELD_OFFSET(struct create_class_reply, atom) == 8 );
  1808. C_ASSERT( sizeof(struct create_class_reply) == 16 );
  1809. C_ASSERT( FIELD_OFFSET(struct destroy_class_request, atom) == 12 );
  1810. C_ASSERT( FIELD_OFFSET(struct destroy_class_request, instance) == 16 );
  1811. C_ASSERT( sizeof(struct destroy_class_request) == 24 );
  1812. C_ASSERT( FIELD_OFFSET(struct destroy_class_reply, client_ptr) == 8 );
  1813. C_ASSERT( sizeof(struct destroy_class_reply) == 16 );
  1814. C_ASSERT( FIELD_OFFSET(struct set_class_info_request, window) == 12 );
  1815. C_ASSERT( FIELD_OFFSET(struct set_class_info_request, flags) == 16 );
  1816. C_ASSERT( FIELD_OFFSET(struct set_class_info_request, atom) == 20 );
  1817. C_ASSERT( FIELD_OFFSET(struct set_class_info_request, style) == 24 );
  1818. C_ASSERT( FIELD_OFFSET(struct set_class_info_request, win_extra) == 28 );
  1819. C_ASSERT( FIELD_OFFSET(struct set_class_info_request, instance) == 32 );
  1820. C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_offset) == 40 );
  1821. C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_size) == 44 );
  1822. C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_value) == 48 );
  1823. C_ASSERT( sizeof(struct set_class_info_request) == 56 );
  1824. C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_atom) == 8 );
  1825. C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, base_atom) == 12 );
  1826. C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_instance) == 16 );
  1827. C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_extra_value) == 24 );
  1828. C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_style) == 32 );
  1829. C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_extra) == 36 );
  1830. C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_win_extra) == 40 );
  1831. C_ASSERT( sizeof(struct set_class_info_reply) == 48 );
  1832. C_ASSERT( FIELD_OFFSET(struct open_clipboard_request, window) == 12 );
  1833. C_ASSERT( sizeof(struct open_clipboard_request) == 16 );
  1834. C_ASSERT( FIELD_OFFSET(struct open_clipboard_reply, owner) == 8 );
  1835. C_ASSERT( sizeof(struct open_clipboard_reply) == 16 );
  1836. C_ASSERT( sizeof(struct close_clipboard_request) == 16 );
  1837. C_ASSERT( FIELD_OFFSET(struct close_clipboard_reply, viewer) == 8 );
  1838. C_ASSERT( FIELD_OFFSET(struct close_clipboard_reply, owner) == 12 );
  1839. C_ASSERT( sizeof(struct close_clipboard_reply) == 16 );
  1840. C_ASSERT( sizeof(struct empty_clipboard_request) == 16 );
  1841. C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_request, format) == 12 );
  1842. C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_request, lcid) == 16 );
  1843. C_ASSERT( sizeof(struct set_clipboard_data_request) == 24 );
  1844. C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_reply, seqno) == 8 );
  1845. C_ASSERT( sizeof(struct set_clipboard_data_reply) == 16 );
  1846. C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request, format) == 12 );
  1847. C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request, render) == 16 );
  1848. C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request, cached) == 20 );
  1849. C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request, seqno) == 24 );
  1850. C_ASSERT( sizeof(struct get_clipboard_data_request) == 32 );
  1851. C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, from) == 8 );
  1852. C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, owner) == 12 );
  1853. C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, seqno) == 16 );
  1854. C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, total) == 20 );
  1855. C_ASSERT( sizeof(struct get_clipboard_data_reply) == 24 );
  1856. C_ASSERT( FIELD_OFFSET(struct get_clipboard_formats_request, format) == 12 );
  1857. C_ASSERT( sizeof(struct get_clipboard_formats_request) == 16 );
  1858. C_ASSERT( FIELD_OFFSET(struct get_clipboard_formats_reply, count) == 8 );
  1859. C_ASSERT( sizeof(struct get_clipboard_formats_reply) == 16 );
  1860. C_ASSERT( FIELD_OFFSET(struct enum_clipboard_formats_request, previous) == 12 );
  1861. C_ASSERT( sizeof(struct enum_clipboard_formats_request) == 16 );
  1862. C_ASSERT( FIELD_OFFSET(struct enum_clipboard_formats_reply, format) == 8 );
  1863. C_ASSERT( sizeof(struct enum_clipboard_formats_reply) == 16 );
  1864. C_ASSERT( FIELD_OFFSET(struct release_clipboard_request, owner) == 12 );
  1865. C_ASSERT( sizeof(struct release_clipboard_request) == 16 );
  1866. C_ASSERT( FIELD_OFFSET(struct release_clipboard_reply, viewer) == 8 );
  1867. C_ASSERT( FIELD_OFFSET(struct release_clipboard_reply, owner) == 12 );
  1868. C_ASSERT( sizeof(struct release_clipboard_reply) == 16 );
  1869. C_ASSERT( sizeof(struct get_clipboard_info_request) == 16 );
  1870. C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply, window) == 8 );
  1871. C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply, owner) == 12 );
  1872. C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply, viewer) == 16 );
  1873. C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply, seqno) == 20 );
  1874. C_ASSERT( sizeof(struct get_clipboard_info_reply) == 24 );
  1875. C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_request, viewer) == 12 );
  1876. C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_request, previous) == 16 );
  1877. C_ASSERT( sizeof(struct set_clipboard_viewer_request) == 24 );
  1878. C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_reply, old_viewer) == 8 );
  1879. C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_reply, owner) == 12 );
  1880. C_ASSERT( sizeof(struct set_clipboard_viewer_reply) == 16 );
  1881. C_ASSERT( FIELD_OFFSET(struct add_clipboard_listener_request, window) == 12 );
  1882. C_ASSERT( sizeof(struct add_clipboard_listener_request) == 16 );
  1883. C_ASSERT( FIELD_OFFSET(struct remove_clipboard_listener_request, window) == 12 );
  1884. C_ASSERT( sizeof(struct remove_clipboard_listener_request) == 16 );
  1885. C_ASSERT( FIELD_OFFSET(struct open_token_request, handle) == 12 );
  1886. C_ASSERT( FIELD_OFFSET(struct open_token_request, access) == 16 );
  1887. C_ASSERT( FIELD_OFFSET(struct open_token_request, attributes) == 20 );
  1888. C_ASSERT( FIELD_OFFSET(struct open_token_request, flags) == 24 );
  1889. C_ASSERT( sizeof(struct open_token_request) == 32 );
  1890. C_ASSERT( FIELD_OFFSET(struct open_token_reply, token) == 8 );
  1891. C_ASSERT( sizeof(struct open_token_reply) == 16 );
  1892. C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, flags) == 12 );
  1893. C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, shell_window) == 16 );
  1894. C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, shell_listview) == 20 );
  1895. C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, progman_window) == 24 );
  1896. C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, taskman_window) == 28 );
  1897. C_ASSERT( sizeof(struct set_global_windows_request) == 32 );
  1898. C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_shell_window) == 8 );
  1899. C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_shell_listview) == 12 );
  1900. C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_progman_window) == 16 );
  1901. C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_taskman_window) == 20 );
  1902. C_ASSERT( sizeof(struct set_global_windows_reply) == 24 );
  1903. C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, handle) == 12 );
  1904. C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, disable_all) == 16 );
  1905. C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, get_modified_state) == 20 );
  1906. C_ASSERT( sizeof(struct adjust_token_privileges_request) == 24 );
  1907. C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_reply, len) == 8 );
  1908. C_ASSERT( sizeof(struct adjust_token_privileges_reply) == 16 );
  1909. C_ASSERT( FIELD_OFFSET(struct get_token_privileges_request, handle) == 12 );
  1910. C_ASSERT( sizeof(struct get_token_privileges_request) == 16 );
  1911. C_ASSERT( FIELD_OFFSET(struct get_token_privileges_reply, len) == 8 );
  1912. C_ASSERT( sizeof(struct get_token_privileges_reply) == 16 );
  1913. C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request, handle) == 12 );
  1914. C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request, all_required) == 16 );
  1915. C_ASSERT( sizeof(struct check_token_privileges_request) == 24 );
  1916. C_ASSERT( FIELD_OFFSET(struct check_token_privileges_reply, has_privileges) == 8 );
  1917. C_ASSERT( sizeof(struct check_token_privileges_reply) == 16 );
  1918. C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, handle) == 12 );
  1919. C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, access) == 16 );
  1920. C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, primary) == 20 );
  1921. C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, impersonation_level) == 24 );
  1922. C_ASSERT( sizeof(struct duplicate_token_request) == 32 );
  1923. C_ASSERT( FIELD_OFFSET(struct duplicate_token_reply, new_handle) == 8 );
  1924. C_ASSERT( sizeof(struct duplicate_token_reply) == 16 );
  1925. C_ASSERT( FIELD_OFFSET(struct filter_token_request, handle) == 12 );
  1926. C_ASSERT( FIELD_OFFSET(struct filter_token_request, flags) == 16 );
  1927. C_ASSERT( FIELD_OFFSET(struct filter_token_request, privileges_size) == 20 );
  1928. C_ASSERT( sizeof(struct filter_token_request) == 24 );
  1929. C_ASSERT( FIELD_OFFSET(struct filter_token_reply, new_handle) == 8 );
  1930. C_ASSERT( sizeof(struct filter_token_reply) == 16 );
  1931. C_ASSERT( FIELD_OFFSET(struct access_check_request, handle) == 12 );
  1932. C_ASSERT( FIELD_OFFSET(struct access_check_request, desired_access) == 16 );
  1933. C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping) == 20 );
  1934. C_ASSERT( sizeof(struct access_check_request) == 40 );
  1935. C_ASSERT( FIELD_OFFSET(struct access_check_reply, access_granted) == 8 );
  1936. C_ASSERT( FIELD_OFFSET(struct access_check_reply, access_status) == 12 );
  1937. C_ASSERT( FIELD_OFFSET(struct access_check_reply, privileges_len) == 16 );
  1938. C_ASSERT( sizeof(struct access_check_reply) == 24 );
  1939. C_ASSERT( FIELD_OFFSET(struct get_token_sid_request, handle) == 12 );
  1940. C_ASSERT( FIELD_OFFSET(struct get_token_sid_request, which_sid) == 16 );
  1941. C_ASSERT( sizeof(struct get_token_sid_request) == 24 );
  1942. C_ASSERT( FIELD_OFFSET(struct get_token_sid_reply, sid_len) == 8 );
  1943. C_ASSERT( sizeof(struct get_token_sid_reply) == 16 );
  1944. C_ASSERT( FIELD_OFFSET(struct get_token_groups_request, handle) == 12 );
  1945. C_ASSERT( sizeof(struct get_token_groups_request) == 16 );
  1946. C_ASSERT( FIELD_OFFSET(struct get_token_groups_reply, attr_len) == 8 );
  1947. C_ASSERT( FIELD_OFFSET(struct get_token_groups_reply, sid_len) == 12 );
  1948. C_ASSERT( sizeof(struct get_token_groups_reply) == 16 );
  1949. C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_request, handle) == 12 );
  1950. C_ASSERT( sizeof(struct get_token_default_dacl_request) == 16 );
  1951. C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_reply, acl_len) == 8 );
  1952. C_ASSERT( sizeof(struct get_token_default_dacl_reply) == 16 );
  1953. C_ASSERT( FIELD_OFFSET(struct set_token_default_dacl_request, handle) == 12 );
  1954. C_ASSERT( sizeof(struct set_token_default_dacl_request) == 16 );
  1955. C_ASSERT( FIELD_OFFSET(struct set_security_object_request, handle) == 12 );
  1956. C_ASSERT( FIELD_OFFSET(struct set_security_object_request, security_info) == 16 );
  1957. C_ASSERT( sizeof(struct set_security_object_request) == 24 );
  1958. C_ASSERT( FIELD_OFFSET(struct get_security_object_request, handle) == 12 );
  1959. C_ASSERT( FIELD_OFFSET(struct get_security_object_request, security_info) == 16 );
  1960. C_ASSERT( sizeof(struct get_security_object_request) == 24 );
  1961. C_ASSERT( FIELD_OFFSET(struct get_security_object_reply, sd_len) == 8 );
  1962. C_ASSERT( sizeof(struct get_security_object_reply) == 16 );
  1963. C_ASSERT( sizeof(struct get_system_handles_request) == 16 );
  1964. C_ASSERT( FIELD_OFFSET(struct get_system_handles_reply, count) == 8 );
  1965. C_ASSERT( sizeof(struct get_system_handles_reply) == 16 );
  1966. C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, access) == 12 );
  1967. C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, read_timeout) == 16 );
  1968. C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, max_msgsize) == 24 );
  1969. C_ASSERT( sizeof(struct create_mailslot_request) == 32 );
  1970. C_ASSERT( FIELD_OFFSET(struct create_mailslot_reply, handle) == 8 );
  1971. C_ASSERT( sizeof(struct create_mailslot_reply) == 16 );
  1972. C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, handle) == 12 );
  1973. C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, read_timeout) == 16 );
  1974. C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, flags) == 24 );
  1975. C_ASSERT( sizeof(struct set_mailslot_info_request) == 32 );
  1976. C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply, read_timeout) == 8 );
  1977. C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply, max_msgsize) == 16 );
  1978. C_ASSERT( sizeof(struct set_mailslot_info_reply) == 24 );
  1979. C_ASSERT( FIELD_OFFSET(struct create_directory_request, access) == 12 );
  1980. C_ASSERT( sizeof(struct create_directory_request) == 16 );
  1981. C_ASSERT( FIELD_OFFSET(struct create_directory_reply, handle) == 8 );
  1982. C_ASSERT( sizeof(struct create_directory_reply) == 16 );
  1983. C_ASSERT( FIELD_OFFSET(struct open_directory_request, access) == 12 );
  1984. C_ASSERT( FIELD_OFFSET(struct open_directory_request, attributes) == 16 );
  1985. C_ASSERT( FIELD_OFFSET(struct open_directory_request, rootdir) == 20 );
  1986. C_ASSERT( sizeof(struct open_directory_request) == 24 );
  1987. C_ASSERT( FIELD_OFFSET(struct open_directory_reply, handle) == 8 );
  1988. C_ASSERT( sizeof(struct open_directory_reply) == 16 );
  1989. C_ASSERT( FIELD_OFFSET(struct get_directory_entries_request, handle) == 12 );
  1990. C_ASSERT( FIELD_OFFSET(struct get_directory_entries_request, index) == 16 );
  1991. C_ASSERT( FIELD_OFFSET(struct get_directory_entries_request, max_count) == 20 );
  1992. C_ASSERT( sizeof(struct get_directory_entries_request) == 24 );
  1993. C_ASSERT( FIELD_OFFSET(struct get_directory_entries_reply, count) == 8 );
  1994. C_ASSERT( FIELD_OFFSET(struct get_directory_entries_reply, total_count) == 12 );
  1995. C_ASSERT( FIELD_OFFSET(struct get_directory_entries_reply, total_len) == 16 );
  1996. C_ASSERT( sizeof(struct get_directory_entries_reply) == 24 );
  1997. C_ASSERT( FIELD_OFFSET(struct create_symlink_request, access) == 12 );
  1998. C_ASSERT( sizeof(struct create_symlink_request) == 16 );
  1999. C_ASSERT( FIELD_OFFSET(struct create_symlink_reply, handle) == 8 );
  2000. C_ASSERT( sizeof(struct create_symlink_reply) == 16 );
  2001. C_ASSERT( FIELD_OFFSET(struct open_symlink_request, access) == 12 );
  2002. C_ASSERT( FIELD_OFFSET(struct open_symlink_request, attributes) == 16 );
  2003. C_ASSERT( FIELD_OFFSET(struct open_symlink_request, rootdir) == 20 );
  2004. C_ASSERT( sizeof(struct open_symlink_request) == 24 );
  2005. C_ASSERT( FIELD_OFFSET(struct open_symlink_reply, handle) == 8 );
  2006. C_ASSERT( sizeof(struct open_symlink_reply) == 16 );
  2007. C_ASSERT( FIELD_OFFSET(struct query_symlink_request, handle) == 12 );
  2008. C_ASSERT( sizeof(struct query_symlink_request) == 16 );
  2009. C_ASSERT( FIELD_OFFSET(struct query_symlink_reply, total) == 8 );
  2010. C_ASSERT( sizeof(struct query_symlink_reply) == 16 );
  2011. C_ASSERT( FIELD_OFFSET(struct get_object_info_request, handle) == 12 );
  2012. C_ASSERT( sizeof(struct get_object_info_request) == 16 );
  2013. C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, access) == 8 );
  2014. C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, ref_count) == 12 );
  2015. C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, handle_count) == 16 );
  2016. C_ASSERT( sizeof(struct get_object_info_reply) == 24 );
  2017. C_ASSERT( FIELD_OFFSET(struct get_object_name_request, handle) == 12 );
  2018. C_ASSERT( sizeof(struct get_object_name_request) == 16 );
  2019. C_ASSERT( FIELD_OFFSET(struct get_object_name_reply, total) == 8 );
  2020. C_ASSERT( sizeof(struct get_object_name_reply) == 16 );
  2021. C_ASSERT( FIELD_OFFSET(struct get_object_type_request, handle) == 12 );
  2022. C_ASSERT( sizeof(struct get_object_type_request) == 16 );
  2023. C_ASSERT( sizeof(struct get_object_type_reply) == 8 );
  2024. C_ASSERT( sizeof(struct get_object_types_request) == 16 );
  2025. C_ASSERT( FIELD_OFFSET(struct get_object_types_reply, count) == 8 );
  2026. C_ASSERT( sizeof(struct get_object_types_reply) == 16 );
  2027. C_ASSERT( sizeof(struct allocate_locally_unique_id_request) == 16 );
  2028. C_ASSERT( FIELD_OFFSET(struct allocate_locally_unique_id_reply, luid) == 8 );
  2029. C_ASSERT( sizeof(struct allocate_locally_unique_id_reply) == 16 );
  2030. C_ASSERT( FIELD_OFFSET(struct create_device_manager_request, access) == 12 );
  2031. C_ASSERT( FIELD_OFFSET(struct create_device_manager_request, attributes) == 16 );
  2032. C_ASSERT( sizeof(struct create_device_manager_request) == 24 );
  2033. C_ASSERT( FIELD_OFFSET(struct create_device_manager_reply, handle) == 8 );
  2034. C_ASSERT( sizeof(struct create_device_manager_reply) == 16 );
  2035. C_ASSERT( FIELD_OFFSET(struct create_device_request, rootdir) == 12 );
  2036. C_ASSERT( FIELD_OFFSET(struct create_device_request, user_ptr) == 16 );
  2037. C_ASSERT( FIELD_OFFSET(struct create_device_request, manager) == 24 );
  2038. C_ASSERT( sizeof(struct create_device_request) == 32 );
  2039. C_ASSERT( FIELD_OFFSET(struct delete_device_request, manager) == 12 );
  2040. C_ASSERT( FIELD_OFFSET(struct delete_device_request, device) == 16 );
  2041. C_ASSERT( sizeof(struct delete_device_request) == 24 );
  2042. C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, manager) == 12 );
  2043. C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, prev) == 16 );
  2044. C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, status) == 20 );
  2045. C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, user_ptr) == 24 );
  2046. C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, pending) == 32 );
  2047. C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, iosb_status) == 36 );
  2048. C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, result) == 40 );
  2049. C_ASSERT( sizeof(struct get_next_device_request_request) == 48 );
  2050. C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, params) == 8 );
  2051. C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, next) == 40 );
  2052. C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, client_tid) == 44 );
  2053. C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, client_thread) == 48 );
  2054. C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, in_size) == 56 );
  2055. C_ASSERT( sizeof(struct get_next_device_request_reply) == 64 );
  2056. C_ASSERT( FIELD_OFFSET(struct get_kernel_object_ptr_request, manager) == 12 );
  2057. C_ASSERT( FIELD_OFFSET(struct get_kernel_object_ptr_request, handle) == 16 );
  2058. C_ASSERT( sizeof(struct get_kernel_object_ptr_request) == 24 );
  2059. C_ASSERT( FIELD_OFFSET(struct get_kernel_object_ptr_reply, user_ptr) == 8 );
  2060. C_ASSERT( sizeof(struct get_kernel_object_ptr_reply) == 16 );
  2061. C_ASSERT( FIELD_OFFSET(struct set_kernel_object_ptr_request, manager) == 12 );
  2062. C_ASSERT( FIELD_OFFSET(struct set_kernel_object_ptr_request, handle) == 16 );
  2063. C_ASSERT( FIELD_OFFSET(struct set_kernel_object_ptr_request, user_ptr) == 24 );
  2064. C_ASSERT( sizeof(struct set_kernel_object_ptr_request) == 32 );
  2065. C_ASSERT( FIELD_OFFSET(struct grab_kernel_object_request, manager) == 12 );
  2066. C_ASSERT( FIELD_OFFSET(struct grab_kernel_object_request, user_ptr) == 16 );
  2067. C_ASSERT( sizeof(struct grab_kernel_object_request) == 24 );
  2068. C_ASSERT( FIELD_OFFSET(struct release_kernel_object_request, manager) == 12 );
  2069. C_ASSERT( FIELD_OFFSET(struct release_kernel_object_request, user_ptr) == 16 );
  2070. C_ASSERT( sizeof(struct release_kernel_object_request) == 24 );
  2071. C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_request, manager) == 12 );
  2072. C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_request, user_ptr) == 16 );
  2073. C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_request, access) == 24 );
  2074. C_ASSERT( sizeof(struct get_kernel_object_handle_request) == 32 );
  2075. C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_reply, handle) == 8 );
  2076. C_ASSERT( sizeof(struct get_kernel_object_handle_reply) == 16 );
  2077. C_ASSERT( FIELD_OFFSET(struct make_process_system_request, handle) == 12 );
  2078. C_ASSERT( sizeof(struct make_process_system_request) == 16 );
  2079. C_ASSERT( FIELD_OFFSET(struct make_process_system_reply, event) == 8 );
  2080. C_ASSERT( sizeof(struct make_process_system_reply) == 16 );
  2081. C_ASSERT( FIELD_OFFSET(struct get_token_info_request, handle) == 12 );
  2082. C_ASSERT( sizeof(struct get_token_info_request) == 16 );
  2083. C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, token_id) == 8 );
  2084. C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, modified_id) == 16 );
  2085. C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, session_id) == 24 );
  2086. C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, primary) == 28 );
  2087. C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, impersonation_level) == 32 );
  2088. C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, elevation) == 36 );
  2089. C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, group_count) == 40 );
  2090. C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, privilege_count) == 44 );
  2091. C_ASSERT( sizeof(struct get_token_info_reply) == 48 );
  2092. C_ASSERT( FIELD_OFFSET(struct create_linked_token_request, handle) == 12 );
  2093. C_ASSERT( sizeof(struct create_linked_token_request) == 16 );
  2094. C_ASSERT( FIELD_OFFSET(struct create_linked_token_reply, linked) == 8 );
  2095. C_ASSERT( sizeof(struct create_linked_token_reply) == 16 );
  2096. C_ASSERT( FIELD_OFFSET(struct create_completion_request, access) == 12 );
  2097. C_ASSERT( FIELD_OFFSET(struct create_completion_request, concurrent) == 16 );
  2098. C_ASSERT( sizeof(struct create_completion_request) == 24 );
  2099. C_ASSERT( FIELD_OFFSET(struct create_completion_reply, handle) == 8 );
  2100. C_ASSERT( sizeof(struct create_completion_reply) == 16 );
  2101. C_ASSERT( FIELD_OFFSET(struct open_completion_request, access) == 12 );
  2102. C_ASSERT( FIELD_OFFSET(struct open_completion_request, attributes) == 16 );
  2103. C_ASSERT( FIELD_OFFSET(struct open_completion_request, rootdir) == 20 );
  2104. C_ASSERT( sizeof(struct open_completion_request) == 24 );
  2105. C_ASSERT( FIELD_OFFSET(struct open_completion_reply, handle) == 8 );
  2106. C_ASSERT( sizeof(struct open_completion_reply) == 16 );
  2107. C_ASSERT( FIELD_OFFSET(struct add_completion_request, handle) == 12 );
  2108. C_ASSERT( FIELD_OFFSET(struct add_completion_request, ckey) == 16 );
  2109. C_ASSERT( FIELD_OFFSET(struct add_completion_request, cvalue) == 24 );
  2110. C_ASSERT( FIELD_OFFSET(struct add_completion_request, information) == 32 );
  2111. C_ASSERT( FIELD_OFFSET(struct add_completion_request, status) == 40 );
  2112. C_ASSERT( sizeof(struct add_completion_request) == 48 );
  2113. C_ASSERT( FIELD_OFFSET(struct remove_completion_request, handle) == 12 );
  2114. C_ASSERT( sizeof(struct remove_completion_request) == 16 );
  2115. C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, ckey) == 8 );
  2116. C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, cvalue) == 16 );
  2117. C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, information) == 24 );
  2118. C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, status) == 32 );
  2119. C_ASSERT( sizeof(struct remove_completion_reply) == 40 );
  2120. C_ASSERT( FIELD_OFFSET(struct query_completion_request, handle) == 12 );
  2121. C_ASSERT( sizeof(struct query_completion_request) == 16 );
  2122. C_ASSERT( FIELD_OFFSET(struct query_completion_reply, depth) == 8 );
  2123. C_ASSERT( sizeof(struct query_completion_reply) == 16 );
  2124. C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, handle) == 12 );
  2125. C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, ckey) == 16 );
  2126. C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, chandle) == 24 );
  2127. C_ASSERT( sizeof(struct set_completion_info_request) == 32 );
  2128. C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, handle) == 12 );
  2129. C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, cvalue) == 16 );
  2130. C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, information) == 24 );
  2131. C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, status) == 32 );
  2132. C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, async) == 36 );
  2133. C_ASSERT( sizeof(struct add_fd_completion_request) == 40 );
  2134. C_ASSERT( FIELD_OFFSET(struct set_fd_completion_mode_request, handle) == 12 );
  2135. C_ASSERT( FIELD_OFFSET(struct set_fd_completion_mode_request, flags) == 16 );
  2136. C_ASSERT( sizeof(struct set_fd_completion_mode_request) == 24 );
  2137. C_ASSERT( FIELD_OFFSET(struct set_fd_disp_info_request, handle) == 12 );
  2138. C_ASSERT( FIELD_OFFSET(struct set_fd_disp_info_request, unlink) == 16 );
  2139. C_ASSERT( sizeof(struct set_fd_disp_info_request) == 24 );
  2140. C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, handle) == 12 );
  2141. C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, rootdir) == 16 );
  2142. C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, namelen) == 20 );
  2143. C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, link) == 24 );
  2144. C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, replace) == 28 );
  2145. C_ASSERT( sizeof(struct set_fd_name_info_request) == 32 );
  2146. C_ASSERT( FIELD_OFFSET(struct set_fd_eof_info_request, handle) == 12 );
  2147. C_ASSERT( FIELD_OFFSET(struct set_fd_eof_info_request, eof) == 16 );
  2148. C_ASSERT( sizeof(struct set_fd_eof_info_request) == 24 );
  2149. C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_request, handle) == 12 );
  2150. C_ASSERT( sizeof(struct get_window_layered_info_request) == 16 );
  2151. C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, color_key) == 8 );
  2152. C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, alpha) == 12 );
  2153. C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, flags) == 16 );
  2154. C_ASSERT( sizeof(struct get_window_layered_info_reply) == 24 );
  2155. C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, handle) == 12 );
  2156. C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, color_key) == 16 );
  2157. C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, alpha) == 20 );
  2158. C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, flags) == 24 );
  2159. C_ASSERT( sizeof(struct set_window_layered_info_request) == 32 );
  2160. C_ASSERT( sizeof(struct alloc_user_handle_request) == 16 );
  2161. C_ASSERT( FIELD_OFFSET(struct alloc_user_handle_reply, handle) == 8 );
  2162. C_ASSERT( sizeof(struct alloc_user_handle_reply) == 16 );
  2163. C_ASSERT( FIELD_OFFSET(struct free_user_handle_request, handle) == 12 );
  2164. C_ASSERT( sizeof(struct free_user_handle_request) == 16 );
  2165. C_ASSERT( FIELD_OFFSET(struct set_cursor_request, flags) == 12 );
  2166. C_ASSERT( FIELD_OFFSET(struct set_cursor_request, handle) == 16 );
  2167. C_ASSERT( FIELD_OFFSET(struct set_cursor_request, show_count) == 20 );
  2168. C_ASSERT( FIELD_OFFSET(struct set_cursor_request, x) == 24 );
  2169. C_ASSERT( FIELD_OFFSET(struct set_cursor_request, y) == 28 );
  2170. C_ASSERT( FIELD_OFFSET(struct set_cursor_request, clip) == 32 );
  2171. C_ASSERT( FIELD_OFFSET(struct set_cursor_request, clip_msg) == 48 );
  2172. C_ASSERT( sizeof(struct set_cursor_request) == 56 );
  2173. C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_handle) == 8 );
  2174. C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_count) == 12 );
  2175. C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_x) == 16 );
  2176. C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_y) == 20 );
  2177. C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, new_x) == 24 );
  2178. C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, new_y) == 28 );
  2179. C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, new_clip) == 32 );
  2180. C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, last_change) == 48 );
  2181. C_ASSERT( sizeof(struct set_cursor_reply) == 56 );
  2182. C_ASSERT( sizeof(struct get_cursor_history_request) == 16 );
  2183. C_ASSERT( sizeof(struct get_cursor_history_reply) == 8 );
  2184. C_ASSERT( FIELD_OFFSET(struct get_rawinput_buffer_request, rawinput_size) == 12 );
  2185. C_ASSERT( FIELD_OFFSET(struct get_rawinput_buffer_request, buffer_size) == 16 );
  2186. C_ASSERT( sizeof(struct get_rawinput_buffer_request) == 24 );
  2187. C_ASSERT( FIELD_OFFSET(struct get_rawinput_buffer_reply, next_size) == 8 );
  2188. C_ASSERT( FIELD_OFFSET(struct get_rawinput_buffer_reply, count) == 12 );
  2189. C_ASSERT( sizeof(struct get_rawinput_buffer_reply) == 16 );
  2190. C_ASSERT( sizeof(struct update_rawinput_devices_request) == 16 );
  2191. C_ASSERT( sizeof(struct get_rawinput_devices_request) == 16 );
  2192. C_ASSERT( FIELD_OFFSET(struct get_rawinput_devices_reply, device_count) == 8 );
  2193. C_ASSERT( sizeof(struct get_rawinput_devices_reply) == 16 );
  2194. C_ASSERT( FIELD_OFFSET(struct create_job_request, access) == 12 );
  2195. C_ASSERT( sizeof(struct create_job_request) == 16 );
  2196. C_ASSERT( FIELD_OFFSET(struct create_job_reply, handle) == 8 );
  2197. C_ASSERT( sizeof(struct create_job_reply) == 16 );
  2198. C_ASSERT( FIELD_OFFSET(struct open_job_request, access) == 12 );
  2199. C_ASSERT( FIELD_OFFSET(struct open_job_request, attributes) == 16 );
  2200. C_ASSERT( FIELD_OFFSET(struct open_job_request, rootdir) == 20 );
  2201. C_ASSERT( sizeof(struct open_job_request) == 24 );
  2202. C_ASSERT( FIELD_OFFSET(struct open_job_reply, handle) == 8 );
  2203. C_ASSERT( sizeof(struct open_job_reply) == 16 );
  2204. C_ASSERT( FIELD_OFFSET(struct assign_job_request, job) == 12 );
  2205. C_ASSERT( FIELD_OFFSET(struct assign_job_request, process) == 16 );
  2206. C_ASSERT( sizeof(struct assign_job_request) == 24 );
  2207. C_ASSERT( FIELD_OFFSET(struct process_in_job_request, job) == 12 );
  2208. C_ASSERT( FIELD_OFFSET(struct process_in_job_request, process) == 16 );
  2209. C_ASSERT( sizeof(struct process_in_job_request) == 24 );
  2210. C_ASSERT( FIELD_OFFSET(struct set_job_limits_request, handle) == 12 );
  2211. C_ASSERT( FIELD_OFFSET(struct set_job_limits_request, limit_flags) == 16 );
  2212. C_ASSERT( sizeof(struct set_job_limits_request) == 24 );
  2213. C_ASSERT( FIELD_OFFSET(struct set_job_completion_port_request, job) == 12 );
  2214. C_ASSERT( FIELD_OFFSET(struct set_job_completion_port_request, port) == 16 );
  2215. C_ASSERT( FIELD_OFFSET(struct set_job_completion_port_request, key) == 24 );
  2216. C_ASSERT( sizeof(struct set_job_completion_port_request) == 32 );
  2217. C_ASSERT( FIELD_OFFSET(struct get_job_info_request, handle) == 12 );
  2218. C_ASSERT( sizeof(struct get_job_info_request) == 16 );
  2219. C_ASSERT( FIELD_OFFSET(struct get_job_info_reply, total_processes) == 8 );
  2220. C_ASSERT( FIELD_OFFSET(struct get_job_info_reply, active_processes) == 12 );
  2221. C_ASSERT( sizeof(struct get_job_info_reply) == 16 );
  2222. C_ASSERT( FIELD_OFFSET(struct terminate_job_request, handle) == 12 );
  2223. C_ASSERT( FIELD_OFFSET(struct terminate_job_request, status) == 16 );
  2224. C_ASSERT( sizeof(struct terminate_job_request) == 24 );
  2225. C_ASSERT( FIELD_OFFSET(struct suspend_process_request, handle) == 12 );
  2226. C_ASSERT( sizeof(struct suspend_process_request) == 16 );
  2227. C_ASSERT( FIELD_OFFSET(struct resume_process_request, handle) == 12 );
  2228. C_ASSERT( sizeof(struct resume_process_request) == 16 );
  2229. C_ASSERT( FIELD_OFFSET(struct get_next_thread_request, process) == 12 );
  2230. C_ASSERT( FIELD_OFFSET(struct get_next_thread_request, last) == 16 );
  2231. C_ASSERT( FIELD_OFFSET(struct get_next_thread_request, access) == 20 );
  2232. C_ASSERT( FIELD_OFFSET(struct get_next_thread_request, attributes) == 24 );
  2233. C_ASSERT( FIELD_OFFSET(struct get_next_thread_request, flags) == 28 );
  2234. C_ASSERT( sizeof(struct get_next_thread_request) == 32 );
  2235. C_ASSERT( FIELD_OFFSET(struct get_next_thread_reply, handle) == 8 );
  2236. C_ASSERT( sizeof(struct get_next_thread_reply) == 16 );
  2237. #endif /* WANT_REQUEST_HANDLERS */
  2238. /* ### make_requests end ### */
  2239. /* Everything above this line is generated automatically by tools/make_requests */
  2240. #endif /* __WINE_SERVER_REQUEST_H */