git.oblomov.eu Git - wine/blob - include/wine/server_protocol.h

   1 /*
   2  * Wine server protocol definitions
   3  *
   4  * This file is automatically generated; DO NO EDIT!
   5  * Edit server/protocol.def instead and re-run tools/make_requests
   6  */
   7
   8 #ifndef __WINE_WINE_SERVER_PROTOCOL_H
   9 #define __WINE_WINE_SERVER_PROTOCOL_H
  10
  11 #include <stdarg.h>
  12 #include <stdlib.h>
  13 #include <time.h>
  14
  15 #include <windef.h>
  16 #include <winbase.h>
  17
  18 typedef unsigned int obj_handle_t;
  19 typedef unsigned int user_handle_t;
  20 typedef unsigned int atom_t;
  21 typedef unsigned int process_id_t;
  22 typedef unsigned int thread_id_t;
  23 typedef unsigned int data_size_t;
  24 typedef unsigned int ioctl_code_t;
  25 typedef unsigned __int64 lparam_t;
  26 typedef unsigned __int64 apc_param_t;
  27 typedef unsigned __int64 mem_size_t;
  28 typedef unsigned __int64 file_pos_t;
  29 typedef unsigned __int64 client_ptr_t;
  30 typedef unsigned __int64 affinity_t;
  31 typedef client_ptr_t mod_handle_t;
  32
  33 struct request_header
  34 {
  35     int          req;
  36     data_size_t  request_size;
  37     data_size_t  reply_size;
  38 };
  39
  40 struct reply_header
  41 {
  42     unsigned int error;
  43     data_size_t  reply_size;
  44 };
  45
  46
  47
  48 struct request_max_size
  49 {
  50     int pad[16];
  51 };
  52
  53 #define FIRST_USER_HANDLE 0x0020
  54 #define LAST_USER_HANDLE  0xffef
  55
  56
  57
  58 typedef union
  59 {
  60     int code;
  61     struct
  62     {
  63         int              code;
  64         int              first;
  65         unsigned int     exc_code;
  66         unsigned int     flags;
  67         client_ptr_t     record;
  68         client_ptr_t     address;
  69         int              nb_params;
  70         int              __pad;
  71         client_ptr_t     params[15];
  72     } exception;
  73     struct
  74     {
  75         int          code;
  76         obj_handle_t handle;
  77         client_ptr_t teb;
  78         client_ptr_t start;
  79     } create_thread;
  80     struct
  81     {
  82         int          code;
  83         obj_handle_t file;
  84         obj_handle_t process;
  85         obj_handle_t thread;
  86         mod_handle_t base;
  87         int          dbg_offset;
  88         int          dbg_size;
  89         client_ptr_t teb;
  90         client_ptr_t start;
  91         client_ptr_t name;
  92         int          unicode;
  93     } create_process;
  94     struct
  95     {
  96         int          code;
  97         int          exit_code;
  98     } exit;
  99     struct
 100     {
 101         int          code;
 102         obj_handle_t handle;
 103         mod_handle_t base;
 104         int          dbg_offset;
 105         int          dbg_size;
 106         client_ptr_t name;
 107         int          unicode;
 108     } load_dll;
 109     struct
 110     {
 111         int          code;
 112         int          __pad;
 113         mod_handle_t base;
 114     } unload_dll;
 115     struct
 116     {
 117         int          code;
 118         data_size_t  length;
 119         client_ptr_t string;
 120     } output_string;
 121     struct
 122     {
 123         int          code;
 124         int          error;
 125         int          type;
 126     } rip_info;
 127 } debug_event_t;
 128
 129
 130 enum cpu_type
 131 {
 132     CPU_x86, CPU_x86_64, CPU_POWERPC, CPU_ARM, CPU_SPARC
 133 };
 134 typedef int cpu_type_t;
 135
 136
 137 typedef struct
 138 {
 139     cpu_type_t       cpu;
 140     unsigned int     flags;
 141     union
 142     {
 143         struct { unsigned int eip, ebp, esp, eflags, cs, ss; } i386_regs;
 144         struct { unsigned __int64 rip, rbp, rsp;
 145                  unsigned int cs, ss, flags, __pad; } x86_64_regs;
 146         struct { unsigned int iar, msr, ctr, lr, dar, dsisr, trap, __pad; } powerpc_regs;
 147         struct { unsigned int sp, lr, pc, cpsr; } arm_regs;
 148         struct { unsigned int psr, pc, npc, y, wim, tbr; } sparc_regs;
 149     } ctl;
 150     union
 151     {
 152         struct { unsigned int eax, ebx, ecx, edx, esi, edi; } i386_regs;
 153         struct { unsigned __int64 rax,rbx, rcx, rdx, rsi, rdi,
 154                                   r8, r9, r10, r11, r12, r13, r14, r15; } x86_64_regs;
 155         struct { unsigned int gpr[32], cr, xer; } powerpc_regs;
 156         struct { unsigned int r[13]; } arm_regs;
 157         struct { unsigned int g[8], o[8], l[8], i[8]; } sparc_regs;
 158     } integer;
 159     union
 160     {
 161         struct { unsigned int ds, es, fs, gs; } i386_regs;
 162         struct { unsigned int ds, es, fs, gs; } x86_64_regs;
 163     } seg;
 164     union
 165     {
 166         struct { unsigned int ctrl, status, tag, err_off, err_sel, data_off, data_sel, cr0npx;
 167                  unsigned char regs[80]; } i386_regs;
 168         struct { struct { unsigned __int64 low, high; } fpregs[32]; } x86_64_regs;
 169         struct { double fpr[32], fpscr; } powerpc_regs;
 170     } fp;
 171     union
 172     {
 173         struct { unsigned int dr0, dr1, dr2, dr3, dr6, dr7; } i386_regs;
 174         struct { unsigned __int64 dr0, dr1, dr2, dr3, dr6, dr7; } x86_64_regs;
 175         struct { unsigned int dr[8]; } powerpc_regs;
 176     } debug;
 177     union
 178     {
 179         unsigned char i386_regs[512];
 180     } ext;
 181 } context_t;
 182
 183 #define SERVER_CTX_CONTROL            0x01
 184 #define SERVER_CTX_INTEGER            0x02
 185 #define SERVER_CTX_SEGMENTS           0x04
 186 #define SERVER_CTX_FLOATING_POINT     0x08
 187 #define SERVER_CTX_DEBUG_REGISTERS    0x10
 188 #define SERVER_CTX_EXTENDED_REGISTERS 0x20
 189
 190
 191 struct send_fd
 192 {
 193     thread_id_t tid;
 194     int         fd;
 195 };
 196
 197
 198 struct wake_up_reply
 199 {
 200     client_ptr_t cookie;
 201     int          signaled;
 202     int          __pad;
 203 };
 204
 205
 206 typedef __int64 timeout_t;
 207 #define TIMEOUT_INFINITE (((timeout_t)0x7fffffff) << 32 | 0xffffffff)
 208
 209
 210 typedef struct
 211 {
 212     unsigned int debug_flags;
 213     unsigned int console_flags;
 214     obj_handle_t console;
 215     obj_handle_t hstdin;
 216     obj_handle_t hstdout;
 217     obj_handle_t hstderr;
 218     unsigned int x;
 219     unsigned int y;
 220     unsigned int xsize;
 221     unsigned int ysize;
 222     unsigned int xchars;
 223     unsigned int ychars;
 224     unsigned int attribute;
 225     unsigned int flags;
 226     unsigned int show;
 227     data_size_t  curdir_len;
 228     data_size_t  dllpath_len;
 229     data_size_t  imagepath_len;
 230     data_size_t  cmdline_len;
 231     data_size_t  title_len;
 232     data_size_t  desktop_len;
 233     data_size_t  shellinfo_len;
 234     data_size_t  runtime_len;
 235
 236
 237
 238
 239
 240
 241
 242
 243 } startup_info_t;
 244
 245
 246 typedef struct
 247 {
 248     atom_t         atom;
 249     int            string;
 250     lparam_t       data;
 251 } property_data_t;
 252
 253
 254 typedef struct
 255 {
 256     int  left;
 257     int  top;
 258     int  right;
 259     int  bottom;
 260 } rectangle_t;
 261
 262
 263 typedef struct
 264 {
 265     obj_handle_t    handle;
 266     obj_handle_t    event;
 267     client_ptr_t    callback;
 268     client_ptr_t    iosb;
 269     client_ptr_t    arg;
 270     apc_param_t     cvalue;
 271 } async_data_t;
 272
 273
 274
 275 struct hardware_msg_data
 276 {
 277     lparam_t        info;
 278     int             x;
 279     int             y;
 280     unsigned int    hw_id;
 281     unsigned int    flags;
 282     union
 283     {
 284         int type;
 285         struct
 286         {
 287             int            type;
 288             unsigned int   message;
 289             unsigned short vkey;
 290             unsigned short scan;
 291         } kbd;
 292         struct
 293         {
 294             int            type;
 295             int            x;
 296             int            y;
 297             unsigned int   data;
 298         } mouse;
 299     } rawinput;
 300 };
 301
 302 struct callback_msg_data
 303 {
 304     client_ptr_t    callback;
 305     lparam_t        data;
 306     lparam_t        result;
 307 };
 308
 309 struct winevent_msg_data
 310 {
 311     user_handle_t   hook;
 312     thread_id_t     tid;
 313     client_ptr_t    hook_proc;
 314
 315 };
 316
 317 typedef union
 318 {
 319     int type;
 320     struct
 321     {
 322         int            type;
 323         unsigned short vkey;
 324         unsigned short scan;
 325         unsigned int   flags;
 326         unsigned int   time;
 327         lparam_t       info;
 328     } kbd;
 329     struct
 330     {
 331         int            type;
 332         int            x;
 333         int            y;
 334         unsigned int   data;
 335         unsigned int   flags;
 336         unsigned int   time;
 337         lparam_t       info;
 338     } mouse;
 339     struct
 340     {
 341         int            type;
 342         unsigned int   msg;
 343         lparam_t       lparam;
 344     } hw;
 345 } hw_input_t;
 346
 347 typedef union
 348 {
 349     unsigned char            bytes[1];
 350     struct hardware_msg_data hardware;
 351     struct callback_msg_data callback;
 352     struct winevent_msg_data winevent;
 353 } message_data_t;
 354
 355
 356 typedef struct
 357 {
 358     WCHAR          ch;
 359     unsigned short attr;
 360 } char_info_t;
 361
 362
 363 struct filesystem_event
 364 {
 365     int         action;
 366     data_size_t len;
 367     char        name[1];
 368 };
 369
 370 typedef struct
 371 {
 372     unsigned int low_part;
 373     int          high_part;
 374 } luid_t;
 375
 376 #define MAX_ACL_LEN 65535
 377
 378 struct security_descriptor
 379 {
 380     unsigned int control;
 381     data_size_t  owner_len;
 382     data_size_t  group_len;
 383     data_size_t  sacl_len;
 384     data_size_t  dacl_len;
 385
 386
 387
 388
 389 };
 390
 391 struct object_attributes
 392 {
 393     obj_handle_t rootdir;
 394     data_size_t sd_len;
 395     data_size_t name_len;
 396
 397
 398 };
 399
 400 struct token_groups
 401 {
 402     unsigned int count;
 403
 404
 405 };
 406
 407 enum apc_type
 408 {
 409     APC_NONE,
 410     APC_USER,
 411     APC_TIMER,
 412     APC_ASYNC_IO,
 413     APC_VIRTUAL_ALLOC,
 414     APC_VIRTUAL_FREE,
 415     APC_VIRTUAL_QUERY,
 416     APC_VIRTUAL_PROTECT,
 417     APC_VIRTUAL_FLUSH,
 418     APC_VIRTUAL_LOCK,
 419     APC_VIRTUAL_UNLOCK,
 420     APC_MAP_VIEW,
 421     APC_UNMAP_VIEW,
 422     APC_CREATE_THREAD
 423 };
 424
 425 typedef union
 426 {
 427     enum apc_type type;
 428     struct
 429     {
 430         enum apc_type    type;
 431         int              __pad;
 432         client_ptr_t     func;
 433         apc_param_t      args[3];
 434     } user;
 435     struct
 436     {
 437         enum apc_type    type;
 438         int              __pad;
 439         client_ptr_t     func;
 440         timeout_t        time;
 441         client_ptr_t     arg;
 442     } timer;
 443     struct
 444     {
 445         enum apc_type    type;
 446         unsigned int     status;
 447         client_ptr_t     func;
 448         client_ptr_t     user;
 449         client_ptr_t     sb;
 450     } async_io;
 451     struct
 452     {
 453         enum apc_type    type;
 454         unsigned int     op_type;
 455         client_ptr_t     addr;
 456         mem_size_t       size;
 457         unsigned int     zero_bits;
 458         unsigned int     prot;
 459     } virtual_alloc;
 460     struct
 461     {
 462         enum apc_type    type;
 463         unsigned int     op_type;
 464         client_ptr_t     addr;
 465         mem_size_t       size;
 466     } virtual_free;
 467     struct
 468     {
 469         enum apc_type    type;
 470         int              __pad;
 471         client_ptr_t     addr;
 472     } virtual_query;
 473     struct
 474     {
 475         enum apc_type    type;
 476         unsigned int     prot;
 477         client_ptr_t     addr;
 478         mem_size_t       size;
 479     } virtual_protect;
 480     struct
 481     {
 482         enum apc_type    type;
 483         int              __pad;
 484         client_ptr_t     addr;
 485         mem_size_t       size;
 486     } virtual_flush;
 487     struct
 488     {
 489         enum apc_type    type;
 490         int              __pad;
 491         client_ptr_t     addr;
 492         mem_size_t       size;
 493     } virtual_lock;
 494     struct
 495     {
 496         enum apc_type    type;
 497         int              __pad;
 498         client_ptr_t     addr;
 499         mem_size_t       size;
 500     } virtual_unlock;
 501     struct
 502     {
 503         enum apc_type    type;
 504         obj_handle_t     handle;
 505         client_ptr_t     addr;
 506         mem_size_t       size;
 507         file_pos_t       offset;
 508         unsigned int     alloc_type;
 509         unsigned short   zero_bits;
 510         unsigned short   prot;
 511     } map_view;
 512     struct
 513     {
 514         enum apc_type    type;
 515         int              __pad;
 516         client_ptr_t     addr;
 517     } unmap_view;
 518     struct
 519     {
 520         enum apc_type    type;
 521         int              suspend;
 522         client_ptr_t     func;
 523         client_ptr_t     arg;
 524         mem_size_t       reserve;
 525         mem_size_t       commit;
 526     } create_thread;
 527 } apc_call_t;
 528
 529 typedef union
 530 {
 531     enum apc_type type;
 532     struct
 533     {
 534         enum apc_type    type;
 535         unsigned int     status;
 536         client_ptr_t     apc;
 537         unsigned int     total;
 538     } async_io;
 539     struct
 540     {
 541         enum apc_type    type;
 542         unsigned int     status;
 543         client_ptr_t     addr;
 544         mem_size_t       size;
 545     } virtual_alloc;
 546     struct
 547     {
 548         enum apc_type    type;
 549         unsigned int     status;
 550         client_ptr_t     addr;
 551         mem_size_t       size;
 552     } virtual_free;
 553     struct
 554     {
 555         enum apc_type    type;
 556         unsigned int     status;
 557         client_ptr_t     base;
 558         client_ptr_t     alloc_base;
 559         mem_size_t       size;
 560         unsigned short   state;
 561         unsigned short   prot;
 562         unsigned short   alloc_prot;
 563         unsigned short   alloc_type;
 564     } virtual_query;
 565     struct
 566     {
 567         enum apc_type    type;
 568         unsigned int     status;
 569         client_ptr_t     addr;
 570         mem_size_t       size;
 571         unsigned int     prot;
 572     } virtual_protect;
 573     struct
 574     {
 575         enum apc_type    type;
 576         unsigned int     status;
 577         client_ptr_t     addr;
 578         mem_size_t       size;
 579     } virtual_flush;
 580     struct
 581     {
 582         enum apc_type    type;
 583         unsigned int     status;
 584         client_ptr_t     addr;
 585         mem_size_t       size;
 586     } virtual_lock;
 587     struct
 588     {
 589         enum apc_type    type;
 590         unsigned int     status;
 591         client_ptr_t     addr;
 592         mem_size_t       size;
 593     } virtual_unlock;
 594     struct
 595     {
 596         enum apc_type    type;
 597         unsigned int     status;
 598         client_ptr_t     addr;
 599         mem_size_t       size;
 600     } map_view;
 601     struct
 602     {
 603         enum apc_type    type;
 604         unsigned int     status;
 605     } unmap_view;
 606     struct
 607     {
 608         enum apc_type    type;
 609         unsigned int     status;
 610         thread_id_t      tid;
 611         obj_handle_t     handle;
 612     } create_thread;
 613 } apc_result_t;
 614
 615 struct rawinput_device
 616 {
 617     unsigned short usage_page;
 618     unsigned short usage;
 619     unsigned int   flags;
 620     user_handle_t  target;
 621 };
 622
 623
 624
 625
 626
 627 struct new_process_request
 628 {
 629     struct request_header __header;
 630     int          inherit_all;
 631     unsigned int create_flags;
 632     int          socket_fd;
 633     obj_handle_t exe_file;
 634     unsigned int process_access;
 635     unsigned int process_attr;
 636     unsigned int thread_access;
 637     unsigned int thread_attr;
 638     data_size_t  info_size;
 639     /* VARARG(info,startup_info,info_size); */
 640     /* VARARG(env,unicode_str); */
 641 };
 642 struct new_process_reply
 643 {
 644     struct reply_header __header;
 645     obj_handle_t info;
 646     process_id_t pid;
 647     obj_handle_t phandle;
 648     thread_id_t  tid;
 649     obj_handle_t thandle;
 650     char __pad_28[4];
 651 };
 652
 653
 654
 655 struct get_new_process_info_request
 656 {
 657     struct request_header __header;
 658     obj_handle_t info;
 659 };
 660 struct get_new_process_info_reply
 661 {
 662     struct reply_header __header;
 663     int          success;
 664     int          exit_code;
 665 };
 666
 667
 668
 669 struct new_thread_request
 670 {
 671     struct request_header __header;
 672     unsigned int access;
 673     unsigned int attributes;
 674     int          suspend;
 675     int          request_fd;
 676     char __pad_28[4];
 677 };
 678 struct new_thread_reply
 679 {
 680     struct reply_header __header;
 681     thread_id_t  tid;
 682     obj_handle_t handle;
 683 };
 684
 685
 686
 687 struct get_startup_info_request
 688 {
 689     struct request_header __header;
 690     char __pad_12[4];
 691 };
 692 struct get_startup_info_reply
 693 {
 694     struct reply_header __header;
 695     obj_handle_t exe_file;
 696     data_size_t  info_size;
 697     /* VARARG(info,startup_info,info_size); */
 698     /* VARARG(env,unicode_str); */
 699 };
 700
 701
 702
 703 struct init_process_done_request
 704 {
 705     struct request_header __header;
 706     int          gui;
 707     mod_handle_t module;
 708     client_ptr_t ldt_copy;
 709     client_ptr_t entry;
 710 };
 711 struct init_process_done_reply
 712 {
 713     struct reply_header __header;
 714 };
 715
 716
 717
 718 struct init_thread_request
 719 {
 720     struct request_header __header;
 721     int          unix_pid;
 722     int          unix_tid;
 723     int          debug_level;
 724     client_ptr_t teb;
 725     client_ptr_t entry;
 726     int          reply_fd;
 727     int          wait_fd;
 728     cpu_type_t   cpu;
 729     char __pad_52[4];
 730 };
 731 struct init_thread_reply
 732 {
 733     struct reply_header __header;
 734     process_id_t pid;
 735     thread_id_t  tid;
 736     timeout_t    server_start;
 737     data_size_t  info_size;
 738     int          version;
 739     unsigned int all_cpus;
 740     char __pad_36[4];
 741 };
 742
 743
 744
 745 struct terminate_process_request
 746 {
 747     struct request_header __header;
 748     obj_handle_t handle;
 749     int          exit_code;
 750     char __pad_20[4];
 751 };
 752 struct terminate_process_reply
 753 {
 754     struct reply_header __header;
 755     int          self;
 756     char __pad_12[4];
 757 };
 758
 759
 760
 761 struct terminate_thread_request
 762 {
 763     struct request_header __header;
 764     obj_handle_t handle;
 765     int          exit_code;
 766     char __pad_20[4];
 767 };
 768 struct terminate_thread_reply
 769 {
 770     struct reply_header __header;
 771     int          self;
 772     int          last;
 773 };
 774
 775
 776
 777 struct get_process_info_request
 778 {
 779     struct request_header __header;
 780     obj_handle_t handle;
 781 };
 782 struct get_process_info_reply
 783 {
 784     struct reply_header __header;
 785     process_id_t pid;
 786     process_id_t ppid;
 787     affinity_t   affinity;
 788     client_ptr_t peb;
 789     timeout_t    start_time;
 790     timeout_t    end_time;
 791     int          exit_code;
 792     int          priority;
 793     cpu_type_t   cpu;
 794     int          debugger_present;
 795 };
 796
 797
 798
 799 struct set_process_info_request
 800 {
 801     struct request_header __header;
 802     obj_handle_t handle;
 803     int          mask;
 804     int          priority;
 805     affinity_t   affinity;
 806 };
 807 struct set_process_info_reply
 808 {
 809     struct reply_header __header;
 810 };
 811 #define SET_PROCESS_INFO_PRIORITY 0x01
 812 #define SET_PROCESS_INFO_AFFINITY 0x02
 813
 814
 815
 816 struct get_thread_info_request
 817 {
 818     struct request_header __header;
 819     obj_handle_t handle;
 820     thread_id_t  tid_in;
 821     char __pad_20[4];
 822 };
 823 struct get_thread_info_reply
 824 {
 825     struct reply_header __header;
 826     process_id_t pid;
 827     thread_id_t  tid;
 828     client_ptr_t teb;
 829     affinity_t   affinity;
 830     timeout_t    creation_time;
 831     timeout_t    exit_time;
 832     int          exit_code;
 833     int          priority;
 834     int          last;
 835     char __pad_60[4];
 836 };
 837
 838
 839
 840 struct set_thread_info_request
 841 {
 842     struct request_header __header;
 843     obj_handle_t handle;
 844     int          mask;
 845     int          priority;
 846     affinity_t   affinity;
 847     obj_handle_t token;
 848     char __pad_36[4];
 849 };
 850 struct set_thread_info_reply
 851 {
 852     struct reply_header __header;
 853 };
 854 #define SET_THREAD_INFO_PRIORITY 0x01
 855 #define SET_THREAD_INFO_AFFINITY 0x02
 856 #define SET_THREAD_INFO_TOKEN    0x04
 857
 858
 859
 860 struct get_dll_info_request
 861 {
 862     struct request_header __header;
 863     obj_handle_t handle;
 864     mod_handle_t base_address;
 865 };
 866 struct get_dll_info_reply
 867 {
 868     struct reply_header __header;
 869     client_ptr_t entry_point;
 870     data_size_t  size;
 871     data_size_t  filename_len;
 872     /* VARARG(filename,unicode_str); */
 873 };
 874
 875
 876
 877 struct suspend_thread_request
 878 {
 879     struct request_header __header;
 880     obj_handle_t handle;
 881 };
 882 struct suspend_thread_reply
 883 {
 884     struct reply_header __header;
 885     int          count;
 886     char __pad_12[4];
 887 };
 888
 889
 890
 891 struct resume_thread_request
 892 {
 893     struct request_header __header;
 894     obj_handle_t handle;
 895 };
 896 struct resume_thread_reply
 897 {
 898     struct reply_header __header;
 899     int          count;
 900     char __pad_12[4];
 901 };
 902
 903
 904
 905 struct load_dll_request
 906 {
 907     struct request_header __header;
 908     obj_handle_t mapping;
 909     mod_handle_t base;
 910     client_ptr_t name;
 911     data_size_t  size;
 912     int          dbg_offset;
 913     int          dbg_size;
 914     /* VARARG(filename,unicode_str); */
 915     char __pad_44[4];
 916 };
 917 struct load_dll_reply
 918 {
 919     struct reply_header __header;
 920 };
 921
 922
 923
 924 struct unload_dll_request
 925 {
 926     struct request_header __header;
 927     char __pad_12[4];
 928     mod_handle_t base;
 929 };
 930 struct unload_dll_reply
 931 {
 932     struct reply_header __header;
 933 };
 934
 935
 936
 937 struct queue_apc_request
 938 {
 939     struct request_header __header;
 940     obj_handle_t handle;
 941     apc_call_t   call;
 942 };
 943 struct queue_apc_reply
 944 {
 945     struct reply_header __header;
 946     obj_handle_t handle;
 947     int          self;
 948 };
 949
 950
 951
 952 struct get_apc_result_request
 953 {
 954     struct request_header __header;
 955     obj_handle_t handle;
 956 };
 957 struct get_apc_result_reply
 958 {
 959     struct reply_header __header;
 960     apc_result_t result;
 961 };
 962
 963
 964
 965 struct close_handle_request
 966 {
 967     struct request_header __header;
 968     obj_handle_t handle;
 969 };
 970 struct close_handle_reply
 971 {
 972     struct reply_header __header;
 973 };
 974
 975
 976
 977 struct set_handle_info_request
 978 {
 979     struct request_header __header;
 980     obj_handle_t handle;
 981     int          flags;
 982     int          mask;
 983 };
 984 struct set_handle_info_reply
 985 {
 986     struct reply_header __header;
 987     int          old_flags;
 988     char __pad_12[4];
 989 };
 990
 991
 992
 993 struct dup_handle_request
 994 {
 995     struct request_header __header;
 996     obj_handle_t src_process;
 997     obj_handle_t src_handle;
 998     obj_handle_t dst_process;
 999     unsigned int access;
1000     unsigned int attributes;
1001     unsigned int options;
1002     char __pad_36[4];
1003 };
1004 struct dup_handle_reply
1005 {
1006     struct reply_header __header;
1007     obj_handle_t handle;
1008     int          self;
1009     int          closed;
1010     char __pad_20[4];
1011 };
1012 #define DUP_HANDLE_CLOSE_SOURCE  DUPLICATE_CLOSE_SOURCE
1013 #define DUP_HANDLE_SAME_ACCESS   DUPLICATE_SAME_ACCESS
1014 #define DUP_HANDLE_MAKE_GLOBAL   0x80000000
1015
1016
1017
1018 struct open_process_request
1019 {
1020     struct request_header __header;
1021     process_id_t pid;
1022     unsigned int access;
1023     unsigned int attributes;
1024 };
1025 struct open_process_reply
1026 {
1027     struct reply_header __header;
1028     obj_handle_t handle;
1029     char __pad_12[4];
1030 };
1031
1032
1033
1034 struct open_thread_request
1035 {
1036     struct request_header __header;
1037     thread_id_t  tid;
1038     unsigned int access;
1039     unsigned int attributes;
1040 };
1041 struct open_thread_reply
1042 {
1043     struct reply_header __header;
1044     obj_handle_t handle;
1045     char __pad_12[4];
1046 };
1047
1048
1049
1050 struct select_request
1051 {
1052     struct request_header __header;
1053     int          flags;
1054     client_ptr_t cookie;
1055     obj_handle_t signal;
1056     obj_handle_t prev_apc;
1057     timeout_t    timeout;
1058     /* VARARG(result,apc_result); */
1059     /* VARARG(handles,handles); */
1060 };
1061 struct select_reply
1062 {
1063     struct reply_header __header;
1064     timeout_t    timeout;
1065     apc_call_t   call;
1066     obj_handle_t apc_handle;
1067     char __pad_60[4];
1068 };
1069 #define SELECT_ALL           1
1070 #define SELECT_ALERTABLE     2
1071 #define SELECT_INTERRUPTIBLE 4
1072
1073
1074
1075 struct create_event_request
1076 {
1077     struct request_header __header;
1078     unsigned int access;
1079     unsigned int attributes;
1080     int          manual_reset;
1081     int          initial_state;
1082     /* VARARG(objattr,object_attributes); */
1083     char __pad_28[4];
1084 };
1085 struct create_event_reply
1086 {
1087     struct reply_header __header;
1088     obj_handle_t handle;
1089     char __pad_12[4];
1090 };
1091
1092
1093 struct event_op_request
1094 {
1095     struct request_header __header;
1096     obj_handle_t  handle;
1097     int           op;
1098     char __pad_20[4];
1099 };
1100 struct event_op_reply
1101 {
1102     struct reply_header __header;
1103 };
1104 enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT };
1105
1106
1107
1108 struct open_event_request
1109 {
1110     struct request_header __header;
1111     unsigned int access;
1112     unsigned int attributes;
1113     obj_handle_t rootdir;
1114     /* VARARG(name,unicode_str); */
1115 };
1116 struct open_event_reply
1117 {
1118     struct reply_header __header;
1119     obj_handle_t handle;
1120     char __pad_12[4];
1121 };
1122
1123
1124
1125 struct create_mutex_request
1126 {
1127     struct request_header __header;
1128     unsigned int access;
1129     unsigned int attributes;
1130     int          owned;
1131     /* VARARG(objattr,object_attributes); */
1132 };
1133 struct create_mutex_reply
1134 {
1135     struct reply_header __header;
1136     obj_handle_t handle;
1137     char __pad_12[4];
1138 };
1139
1140
1141
1142 struct release_mutex_request
1143 {
1144     struct request_header __header;
1145     obj_handle_t handle;
1146 };
1147 struct release_mutex_reply
1148 {
1149     struct reply_header __header;
1150     unsigned int prev_count;
1151     char __pad_12[4];
1152 };
1153
1154
1155
1156 struct open_mutex_request
1157 {
1158     struct request_header __header;
1159     unsigned int access;
1160     unsigned int attributes;
1161     obj_handle_t rootdir;
1162     /* VARARG(name,unicode_str); */
1163 };
1164 struct open_mutex_reply
1165 {
1166     struct reply_header __header;
1167     obj_handle_t handle;
1168     char __pad_12[4];
1169 };
1170
1171
1172
1173 struct create_semaphore_request
1174 {
1175     struct request_header __header;
1176     unsigned int access;
1177     unsigned int attributes;
1178     unsigned int initial;
1179     unsigned int max;
1180     /* VARARG(objattr,object_attributes); */
1181     char __pad_28[4];
1182 };
1183 struct create_semaphore_reply
1184 {
1185     struct reply_header __header;
1186     obj_handle_t handle;
1187     char __pad_12[4];
1188 };
1189
1190
1191
1192 struct release_semaphore_request
1193 {
1194     struct request_header __header;
1195     obj_handle_t handle;
1196     unsigned int count;
1197     char __pad_20[4];
1198 };
1199 struct release_semaphore_reply
1200 {
1201     struct reply_header __header;
1202     unsigned int prev_count;
1203     char __pad_12[4];
1204 };
1205
1206
1207
1208 struct open_semaphore_request
1209 {
1210     struct request_header __header;
1211     unsigned int access;
1212     unsigned int attributes;
1213     obj_handle_t rootdir;
1214     /* VARARG(name,unicode_str); */
1215 };
1216 struct open_semaphore_reply
1217 {
1218     struct reply_header __header;
1219     obj_handle_t handle;
1220     char __pad_12[4];
1221 };
1222
1223
1224
1225 struct create_file_request
1226 {
1227     struct request_header __header;
1228     unsigned int access;
1229     unsigned int attributes;
1230     unsigned int sharing;
1231     int          create;
1232     unsigned int options;
1233     unsigned int attrs;
1234     /* VARARG(objattr,object_attributes); */
1235     /* VARARG(filename,string); */
1236     char __pad_36[4];
1237 };
1238 struct create_file_reply
1239 {
1240     struct reply_header __header;
1241     obj_handle_t handle;
1242     char __pad_12[4];
1243 };
1244
1245
1246
1247 struct open_file_object_request
1248 {
1249     struct request_header __header;
1250     unsigned int access;
1251     unsigned int attributes;
1252     obj_handle_t rootdir;
1253     unsigned int sharing;
1254     unsigned int options;
1255     /* VARARG(filename,unicode_str); */
1256 };
1257 struct open_file_object_reply
1258 {
1259     struct reply_header __header;
1260     obj_handle_t handle;
1261     char __pad_12[4];
1262 };
1263
1264
1265
1266 struct alloc_file_handle_request
1267 {
1268     struct request_header __header;
1269     unsigned int access;
1270     unsigned int attributes;
1271     int          fd;
1272 };
1273 struct alloc_file_handle_reply
1274 {
1275     struct reply_header __header;
1276     obj_handle_t handle;
1277     char __pad_12[4];
1278 };
1279
1280
1281
1282 struct get_handle_unix_name_request
1283 {
1284     struct request_header __header;
1285     obj_handle_t   handle;
1286 };
1287 struct get_handle_unix_name_reply
1288 {
1289     struct reply_header __header;
1290     data_size_t    name_len;
1291     /* VARARG(name,string); */
1292     char __pad_12[4];
1293 };
1294
1295
1296
1297 struct get_handle_fd_request
1298 {
1299     struct request_header __header;
1300     obj_handle_t handle;
1301 };
1302 struct get_handle_fd_reply
1303 {
1304     struct reply_header __header;
1305     int          type;
1306     int          cacheable;
1307     unsigned int access;
1308     unsigned int options;
1309 };
1310 enum server_fd_type
1311 {
1312     FD_TYPE_INVALID,
1313     FD_TYPE_FILE,
1314     FD_TYPE_DIR,
1315     FD_TYPE_SOCKET,
1316     FD_TYPE_SERIAL,
1317     FD_TYPE_PIPE,
1318     FD_TYPE_MAILSLOT,
1319     FD_TYPE_CHAR,
1320     FD_TYPE_DEVICE,
1321     FD_TYPE_NB_TYPES
1322 };
1323
1324
1325
1326 struct flush_file_request
1327 {
1328     struct request_header __header;
1329     obj_handle_t handle;
1330 };
1331 struct flush_file_reply
1332 {
1333     struct reply_header __header;
1334     obj_handle_t event;
1335     char __pad_12[4];
1336 };
1337
1338
1339
1340 struct lock_file_request
1341 {
1342     struct request_header __header;
1343     obj_handle_t handle;
1344     file_pos_t   offset;
1345     file_pos_t   count;
1346     int          shared;
1347     int          wait;
1348 };
1349 struct lock_file_reply
1350 {
1351     struct reply_header __header;
1352     obj_handle_t handle;
1353     int          overlapped;
1354 };
1355
1356
1357
1358 struct unlock_file_request
1359 {
1360     struct request_header __header;
1361     obj_handle_t handle;
1362     file_pos_t   offset;
1363     file_pos_t   count;
1364 };
1365 struct unlock_file_reply
1366 {
1367     struct reply_header __header;
1368 };
1369
1370
1371
1372 struct create_socket_request
1373 {
1374     struct request_header __header;
1375     unsigned int access;
1376     unsigned int attributes;
1377     int          family;
1378     int          type;
1379     int          protocol;
1380     unsigned int flags;
1381     char __pad_36[4];
1382 };
1383 struct create_socket_reply
1384 {
1385     struct reply_header __header;
1386     obj_handle_t handle;
1387     char __pad_12[4];
1388 };
1389
1390
1391
1392 struct accept_socket_request
1393 {
1394     struct request_header __header;
1395     obj_handle_t lhandle;
1396     unsigned int access;
1397     unsigned int attributes;
1398 };
1399 struct accept_socket_reply
1400 {
1401     struct reply_header __header;
1402     obj_handle_t handle;
1403     char __pad_12[4];
1404 };
1405
1406
1407
1408 struct accept_into_socket_request
1409 {
1410     struct request_header __header;
1411     obj_handle_t lhandle;
1412     obj_handle_t ahandle;
1413     char __pad_20[4];
1414 };
1415 struct accept_into_socket_reply
1416 {
1417     struct reply_header __header;
1418 };
1419
1420
1421
1422 struct set_socket_event_request
1423 {
1424     struct request_header __header;
1425     obj_handle_t  handle;
1426     unsigned int  mask;
1427     obj_handle_t  event;
1428     user_handle_t window;
1429     unsigned int  msg;
1430 };
1431 struct set_socket_event_reply
1432 {
1433     struct reply_header __header;
1434 };
1435
1436
1437
1438 struct get_socket_event_request
1439 {
1440     struct request_header __header;
1441     obj_handle_t handle;
1442     int          service;
1443     obj_handle_t c_event;
1444 };
1445 struct get_socket_event_reply
1446 {
1447     struct reply_header __header;
1448     unsigned int mask;
1449     unsigned int pmask;
1450     unsigned int state;
1451     /* VARARG(errors,ints); */
1452     char __pad_20[4];
1453 };
1454
1455
1456
1457 struct enable_socket_event_request
1458 {
1459     struct request_header __header;
1460     obj_handle_t handle;
1461     unsigned int mask;
1462     unsigned int sstate;
1463     unsigned int cstate;
1464     char __pad_28[4];
1465 };
1466 struct enable_socket_event_reply
1467 {
1468     struct reply_header __header;
1469 };
1470
1471 struct set_socket_deferred_request
1472 {
1473     struct request_header __header;
1474     obj_handle_t handle;
1475     obj_handle_t deferred;
1476     char __pad_20[4];
1477 };
1478 struct set_socket_deferred_reply
1479 {
1480     struct reply_header __header;
1481 };
1482
1483
1484 struct alloc_console_request
1485 {
1486     struct request_header __header;
1487     unsigned int access;
1488     unsigned int attributes;
1489     process_id_t pid;
1490     int          input_fd;
1491     char __pad_28[4];
1492 };
1493 struct alloc_console_reply
1494 {
1495     struct reply_header __header;
1496     obj_handle_t handle_in;
1497     obj_handle_t event;
1498 };
1499
1500
1501
1502 struct free_console_request
1503 {
1504     struct request_header __header;
1505     char __pad_12[4];
1506 };
1507 struct free_console_reply
1508 {
1509     struct reply_header __header;
1510 };
1511
1512
1513 #define CONSOLE_RENDERER_NONE_EVENT        0x00
1514 #define CONSOLE_RENDERER_TITLE_EVENT       0x01
1515 #define CONSOLE_RENDERER_ACTIVE_SB_EVENT   0x02
1516 #define CONSOLE_RENDERER_SB_RESIZE_EVENT   0x03
1517 #define CONSOLE_RENDERER_UPDATE_EVENT      0x04
1518 #define CONSOLE_RENDERER_CURSOR_POS_EVENT  0x05
1519 #define CONSOLE_RENDERER_CURSOR_GEOM_EVENT 0x06
1520 #define CONSOLE_RENDERER_DISPLAY_EVENT     0x07
1521 #define CONSOLE_RENDERER_EXIT_EVENT        0x08
1522 struct console_renderer_event
1523 {
1524     short event;
1525     union
1526     {
1527         struct update
1528         {
1529             short top;
1530             short bottom;
1531         } update;
1532         struct resize
1533         {
1534             short width;
1535             short height;
1536         } resize;
1537         struct cursor_pos
1538         {
1539             short x;
1540             short y;
1541         } cursor_pos;
1542         struct cursor_geom
1543         {
1544             short visible;
1545             short size;
1546         } cursor_geom;
1547         struct display
1548         {
1549             short left;
1550             short top;
1551             short width;
1552             short height;
1553         } display;
1554     } u;
1555 };
1556
1557
1558 struct get_console_renderer_events_request
1559 {
1560     struct request_header __header;
1561     obj_handle_t handle;
1562 };
1563 struct get_console_renderer_events_reply
1564 {
1565     struct reply_header __header;
1566     /* VARARG(data,bytes); */
1567 };
1568
1569
1570
1571 struct open_console_request
1572 {
1573     struct request_header __header;
1574     obj_handle_t from;
1575
1576     unsigned int access;
1577     unsigned int attributes;
1578     int          share;
1579     char __pad_28[4];
1580 };
1581 struct open_console_reply
1582 {
1583     struct reply_header __header;
1584     obj_handle_t handle;
1585     char __pad_12[4];
1586 };
1587
1588
1589
1590 struct get_console_wait_event_request
1591 {
1592     struct request_header __header;
1593     char __pad_12[4];
1594 };
1595 struct get_console_wait_event_reply
1596 {
1597     struct reply_header __header;
1598     obj_handle_t handle;
1599     char __pad_12[4];
1600 };
1601
1602
1603 struct get_console_mode_request
1604 {
1605     struct request_header __header;
1606     obj_handle_t handle;
1607 };
1608 struct get_console_mode_reply
1609 {
1610     struct reply_header __header;
1611     int          mode;
1612     char __pad_12[4];
1613 };
1614
1615
1616
1617 struct set_console_mode_request
1618 {
1619     struct request_header __header;
1620     obj_handle_t handle;
1621     int          mode;
1622     char __pad_20[4];
1623 };
1624 struct set_console_mode_reply
1625 {
1626     struct reply_header __header;
1627 };
1628
1629
1630
1631 struct set_console_input_info_request
1632 {
1633     struct request_header __header;
1634     obj_handle_t  handle;
1635     int           mask;
1636     obj_handle_t  active_sb;
1637     int           history_mode;
1638     int           history_size;
1639     int           edition_mode;
1640     int           input_cp;
1641     int           output_cp;
1642     user_handle_t win;
1643     /* VARARG(title,unicode_str); */
1644 };
1645 struct set_console_input_info_reply
1646 {
1647     struct reply_header __header;
1648 };
1649 #define SET_CONSOLE_INPUT_INFO_ACTIVE_SB        0x01
1650 #define SET_CONSOLE_INPUT_INFO_TITLE            0x02
1651 #define SET_CONSOLE_INPUT_INFO_HISTORY_MODE     0x04
1652 #define SET_CONSOLE_INPUT_INFO_HISTORY_SIZE     0x08
1653 #define SET_CONSOLE_INPUT_INFO_EDITION_MODE     0x10
1654 #define SET_CONSOLE_INPUT_INFO_INPUT_CODEPAGE   0x20
1655 #define SET_CONSOLE_INPUT_INFO_OUTPUT_CODEPAGE  0x40
1656 #define SET_CONSOLE_INPUT_INFO_WIN              0x80
1657
1658
1659
1660 struct get_console_input_info_request
1661 {
1662     struct request_header __header;
1663     obj_handle_t  handle;
1664 };
1665 struct get_console_input_info_reply
1666 {
1667     struct reply_header __header;
1668     int           history_mode;
1669     int           history_size;
1670     int           history_index;
1671     int           edition_mode;
1672     int           input_cp;
1673     int           output_cp;
1674     user_handle_t win;
1675     /* VARARG(title,unicode_str); */
1676     char __pad_36[4];
1677 };
1678
1679
1680
1681 struct append_console_input_history_request
1682 {
1683     struct request_header __header;
1684     obj_handle_t handle;
1685     /* VARARG(line,unicode_str); */
1686 };
1687 struct append_console_input_history_reply
1688 {
1689     struct reply_header __header;
1690 };
1691
1692
1693
1694 struct get_console_input_history_request
1695 {
1696     struct request_header __header;
1697     obj_handle_t handle;
1698     int          index;
1699     char __pad_20[4];
1700 };
1701 struct get_console_input_history_reply
1702 {
1703     struct reply_header __header;
1704     int          total;
1705     /* VARARG(line,unicode_str); */
1706     char __pad_12[4];
1707 };
1708
1709
1710
1711 struct create_console_output_request
1712 {
1713     struct request_header __header;
1714     obj_handle_t handle_in;
1715     unsigned int access;
1716     unsigned int attributes;
1717     unsigned int share;
1718     int          fd;
1719 };
1720 struct create_console_output_reply
1721 {
1722     struct reply_header __header;
1723     obj_handle_t handle_out;
1724     char __pad_12[4];
1725 };
1726
1727
1728
1729 struct set_console_output_info_request
1730 {
1731     struct request_header __header;
1732     obj_handle_t handle;
1733     int          mask;
1734     short int    cursor_size;
1735     short int    cursor_visible;
1736     short int    cursor_x;
1737     short int    cursor_y;
1738     short int    width;
1739     short int    height;
1740     short int    attr;
1741     short int    win_left;
1742     short int    win_top;
1743     short int    win_right;
1744     short int    win_bottom;
1745     short int    max_width;
1746     short int    max_height;
1747     char __pad_46[2];
1748 };
1749 struct set_console_output_info_reply
1750 {
1751     struct reply_header __header;
1752 };
1753 #define SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM     0x01
1754 #define SET_CONSOLE_OUTPUT_INFO_CURSOR_POS      0x02
1755 #define SET_CONSOLE_OUTPUT_INFO_SIZE            0x04
1756 #define SET_CONSOLE_OUTPUT_INFO_ATTR            0x08
1757 #define SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW  0x10
1758 #define SET_CONSOLE_OUTPUT_INFO_MAX_SIZE        0x20
1759
1760
1761
1762 struct get_console_output_info_request
1763 {
1764     struct request_header __header;
1765     obj_handle_t handle;
1766 };
1767 struct get_console_output_info_reply
1768 {
1769     struct reply_header __header;
1770     short int    cursor_size;
1771     short int    cursor_visible;
1772     short int    cursor_x;
1773     short int    cursor_y;
1774     short int    width;
1775     short int    height;
1776     short int    attr;
1777     short int    win_left;
1778     short int    win_top;
1779     short int    win_right;
1780     short int    win_bottom;
1781     short int    max_width;
1782     short int    max_height;
1783     char __pad_34[6];
1784 };
1785
1786
1787 struct write_console_input_request
1788 {
1789     struct request_header __header;
1790     obj_handle_t handle;
1791     /* VARARG(rec,input_records); */
1792 };
1793 struct write_console_input_reply
1794 {
1795     struct reply_header __header;
1796     int          written;
1797     char __pad_12[4];
1798 };
1799
1800
1801
1802 struct read_console_input_request
1803 {
1804     struct request_header __header;
1805     obj_handle_t handle;
1806     int          flush;
1807     char __pad_20[4];
1808 };
1809 struct read_console_input_reply
1810 {
1811     struct reply_header __header;
1812     int          read;
1813     /* VARARG(rec,input_records); */
1814     char __pad_12[4];
1815 };
1816
1817
1818
1819 struct write_console_output_request
1820 {
1821     struct request_header __header;
1822     obj_handle_t handle;
1823     int          x;
1824     int          y;
1825     int          mode;
1826     int          wrap;
1827     /* VARARG(data,bytes); */
1828 };
1829 struct write_console_output_reply
1830 {
1831     struct reply_header __header;
1832     int          written;
1833     int          width;
1834     int          height;
1835     char __pad_20[4];
1836 };
1837 enum char_info_mode
1838 {
1839     CHAR_INFO_MODE_TEXT,
1840     CHAR_INFO_MODE_ATTR,
1841     CHAR_INFO_MODE_TEXTATTR,
1842     CHAR_INFO_MODE_TEXTSTDATTR
1843 };
1844
1845
1846
1847 struct fill_console_output_request
1848 {
1849     struct request_header __header;
1850     obj_handle_t handle;
1851     int          x;
1852     int          y;
1853     int          mode;
1854     int          count;
1855     int          wrap;
1856     char_info_t  data;
1857 };
1858 struct fill_console_output_reply
1859 {
1860     struct reply_header __header;
1861     int          written;
1862     char __pad_12[4];
1863 };
1864
1865
1866
1867 struct read_console_output_request
1868 {
1869     struct request_header __header;
1870     obj_handle_t handle;
1871     int          x;
1872     int          y;
1873     int          mode;
1874     int          wrap;
1875 };
1876 struct read_console_output_reply
1877 {
1878     struct reply_header __header;
1879     int          width;
1880     int          height;
1881     /* VARARG(data,bytes); */
1882 };
1883
1884
1885
1886 struct move_console_output_request
1887 {
1888     struct request_header __header;
1889     obj_handle_t handle;
1890     short int    x_src;
1891     short int    y_src;
1892     short int    x_dst;
1893     short int    y_dst;
1894     short int    w;
1895     short int    h;
1896     char __pad_28[4];
1897 };
1898 struct move_console_output_reply
1899 {
1900     struct reply_header __header;
1901 };
1902
1903
1904
1905 struct send_console_signal_request
1906 {
1907     struct request_header __header;
1908     int          signal;
1909     process_id_t group_id;
1910     char __pad_20[4];
1911 };
1912 struct send_console_signal_reply
1913 {
1914     struct reply_header __header;
1915 };
1916
1917
1918
1919 struct read_directory_changes_request
1920 {
1921     struct request_header __header;
1922     unsigned int filter;
1923     int          subtree;
1924     int          want_data;
1925     async_data_t async;
1926 };
1927 struct read_directory_changes_reply
1928 {
1929     struct reply_header __header;
1930 };
1931
1932
1933 struct read_change_request
1934 {
1935     struct request_header __header;
1936     obj_handle_t handle;
1937 };
1938 struct read_change_reply
1939 {
1940     struct reply_header __header;
1941     /* VARARG(events,filesystem_event); */
1942 };
1943
1944
1945
1946 struct create_mapping_request
1947 {
1948     struct request_header __header;
1949     unsigned int access;
1950     unsigned int attributes;
1951     unsigned int protect;
1952     mem_size_t   size;
1953     obj_handle_t file_handle;
1954     /* VARARG(objattr,object_attributes); */
1955     char __pad_36[4];
1956 };
1957 struct create_mapping_reply
1958 {
1959     struct reply_header __header;
1960     obj_handle_t handle;
1961     char __pad_12[4];
1962 };
1963
1964 #define VPROT_READ       0x01
1965 #define VPROT_WRITE      0x02
1966 #define VPROT_EXEC       0x04
1967 #define VPROT_WRITECOPY  0x08
1968 #define VPROT_GUARD      0x10
1969 #define VPROT_NOCACHE    0x20
1970 #define VPROT_COMMITTED  0x40
1971 #define VPROT_WRITEWATCH 0x80
1972
1973 #define VPROT_IMAGE      0x0100
1974 #define VPROT_SYSTEM     0x0200
1975 #define VPROT_VALLOC     0x0400
1976 #define VPROT_NOEXEC     0x0800
1977
1978
1979
1980 struct open_mapping_request
1981 {
1982     struct request_header __header;
1983     unsigned int access;
1984     unsigned int attributes;
1985     obj_handle_t rootdir;
1986     /* VARARG(name,unicode_str); */
1987 };
1988 struct open_mapping_reply
1989 {
1990     struct reply_header __header;
1991     obj_handle_t handle;
1992     char __pad_12[4];
1993 };
1994
1995
1996
1997 struct get_mapping_info_request
1998 {
1999     struct request_header __header;
2000     obj_handle_t handle;
2001     unsigned int access;
2002     char __pad_20[4];
2003 };
2004 struct get_mapping_info_reply
2005 {
2006     struct reply_header __header;
2007     mem_size_t   size;
2008     int          protect;
2009     int          header_size;
2010     client_ptr_t base;
2011     obj_handle_t mapping;
2012     obj_handle_t shared_file;
2013 };
2014
2015
2016
2017 struct get_mapping_committed_range_request
2018 {
2019     struct request_header __header;
2020     obj_handle_t handle;
2021     file_pos_t   offset;
2022 };
2023 struct get_mapping_committed_range_reply
2024 {
2025     struct reply_header __header;
2026     mem_size_t   size;
2027     int          committed;
2028     char __pad_20[4];
2029 };
2030
2031
2032
2033 struct add_mapping_committed_range_request
2034 {
2035     struct request_header __header;
2036     obj_handle_t handle;
2037     file_pos_t   offset;
2038     mem_size_t   size;
2039 };
2040 struct add_mapping_committed_range_reply
2041 {
2042     struct reply_header __header;
2043 };
2044
2045
2046 #define SNAP_PROCESS    0x00000001
2047 #define SNAP_THREAD     0x00000002
2048
2049 struct create_snapshot_request
2050 {
2051     struct request_header __header;
2052     unsigned int attributes;
2053     unsigned int flags;
2054     char __pad_20[4];
2055 };
2056 struct create_snapshot_reply
2057 {
2058     struct reply_header __header;
2059     obj_handle_t handle;
2060     char __pad_12[4];
2061 };
2062
2063
2064
2065 struct next_process_request
2066 {
2067     struct request_header __header;
2068     obj_handle_t handle;
2069     int          reset;
2070     char __pad_20[4];
2071 };
2072 struct next_process_reply
2073 {
2074     struct reply_header __header;
2075     int          count;
2076     process_id_t pid;
2077     process_id_t ppid;
2078     int          threads;
2079     int          priority;
2080     int          handles;
2081     int          unix_pid;
2082     /* VARARG(filename,unicode_str); */
2083     char __pad_36[4];
2084 };
2085
2086
2087
2088 struct next_thread_request
2089 {
2090     struct request_header __header;
2091     obj_handle_t handle;
2092     int          reset;
2093     char __pad_20[4];
2094 };
2095 struct next_thread_reply
2096 {
2097     struct reply_header __header;
2098     int          count;
2099     process_id_t pid;
2100     thread_id_t  tid;
2101     int          base_pri;
2102     int          delta_pri;
2103     char __pad_28[4];
2104 };
2105
2106
2107
2108 struct wait_debug_event_request
2109 {
2110     struct request_header __header;
2111     int           get_handle;
2112 };
2113 struct wait_debug_event_reply
2114 {
2115     struct reply_header __header;
2116     process_id_t  pid;
2117     thread_id_t   tid;
2118     obj_handle_t  wait;
2119     /* VARARG(event,debug_event); */
2120     char __pad_20[4];
2121 };
2122
2123
2124
2125 struct queue_exception_event_request
2126 {
2127     struct request_header __header;
2128     int           first;
2129     unsigned int  code;
2130     unsigned int  flags;
2131     client_ptr_t  record;
2132     client_ptr_t  address;
2133     data_size_t   len;
2134     /* VARARG(params,uints64,len); */
2135     /* VARARG(context,context); */
2136     char __pad_44[4];
2137 };
2138 struct queue_exception_event_reply
2139 {
2140     struct reply_header __header;
2141     obj_handle_t     handle;
2142     char __pad_12[4];
2143 };
2144
2145
2146
2147 struct get_exception_status_request
2148 {
2149     struct request_header __header;
2150     obj_handle_t     handle;
2151 };
2152 struct get_exception_status_reply
2153 {
2154     struct reply_header __header;
2155     /* VARARG(context,context); */
2156 };
2157
2158
2159
2160 struct output_debug_string_request
2161 {
2162     struct request_header __header;
2163     data_size_t   length;
2164     client_ptr_t  string;
2165 };
2166 struct output_debug_string_reply
2167 {
2168     struct reply_header __header;
2169 };
2170
2171
2172
2173 struct continue_debug_event_request
2174 {
2175     struct request_header __header;
2176     process_id_t pid;
2177     thread_id_t  tid;
2178     int          status;
2179 };
2180 struct continue_debug_event_reply
2181 {
2182     struct reply_header __header;
2183 };
2184
2185
2186
2187 struct debug_process_request
2188 {
2189     struct request_header __header;
2190     process_id_t pid;
2191     int          attach;
2192     char __pad_20[4];
2193 };
2194 struct debug_process_reply
2195 {
2196     struct reply_header __header;
2197 };
2198
2199
2200
2201 struct debug_break_request
2202 {
2203     struct request_header __header;
2204     obj_handle_t handle;
2205 };
2206 struct debug_break_reply
2207 {
2208     struct reply_header __header;
2209     int          self;
2210     char __pad_12[4];
2211 };
2212
2213
2214
2215 struct set_debugger_kill_on_exit_request
2216 {
2217     struct request_header __header;
2218     int          kill_on_exit;
2219 };
2220 struct set_debugger_kill_on_exit_reply
2221 {
2222     struct reply_header __header;
2223 };
2224
2225
2226
2227 struct read_process_memory_request
2228 {
2229     struct request_header __header;
2230     obj_handle_t handle;
2231     client_ptr_t addr;
2232 };
2233 struct read_process_memory_reply
2234 {
2235     struct reply_header __header;
2236     /* VARARG(data,bytes); */
2237 };
2238
2239
2240
2241 struct write_process_memory_request
2242 {
2243     struct request_header __header;
2244     obj_handle_t handle;
2245     client_ptr_t addr;
2246     /* VARARG(data,bytes); */
2247 };
2248 struct write_process_memory_reply
2249 {
2250     struct reply_header __header;
2251 };
2252
2253
2254
2255 struct create_key_request
2256 {
2257     struct request_header __header;
2258     obj_handle_t parent;
2259     unsigned int access;
2260     unsigned int attributes;
2261     unsigned int options;
2262     data_size_t  namelen;
2263     /* VARARG(name,unicode_str,namelen); */
2264     /* VARARG(class,unicode_str); */
2265 };
2266 struct create_key_reply
2267 {
2268     struct reply_header __header;
2269     obj_handle_t hkey;
2270     int          created;
2271 };
2272
2273
2274 struct open_key_request
2275 {
2276     struct request_header __header;
2277     obj_handle_t parent;
2278     unsigned int access;
2279     unsigned int attributes;
2280     /* VARARG(name,unicode_str); */
2281 };
2282 struct open_key_reply
2283 {
2284     struct reply_header __header;
2285     obj_handle_t hkey;
2286     char __pad_12[4];
2287 };
2288
2289
2290
2291 struct delete_key_request
2292 {
2293     struct request_header __header;
2294     obj_handle_t hkey;
2295 };
2296 struct delete_key_reply
2297 {
2298     struct reply_header __header;
2299 };
2300
2301
2302
2303 struct flush_key_request
2304 {
2305     struct request_header __header;
2306     obj_handle_t hkey;
2307 };
2308 struct flush_key_reply
2309 {
2310     struct reply_header __header;
2311 };
2312
2313
2314
2315 struct enum_key_request
2316 {
2317     struct request_header __header;
2318     obj_handle_t hkey;
2319     int          index;
2320     int          info_class;
2321 };
2322 struct enum_key_reply
2323 {
2324     struct reply_header __header;
2325     int          subkeys;
2326     int          max_subkey;
2327     int          max_class;
2328     int          values;
2329     int          max_value;
2330     int          max_data;
2331     timeout_t    modif;
2332     data_size_t  total;
2333     data_size_t  namelen;
2334     /* VARARG(name,unicode_str,namelen); */
2335     /* VARARG(class,unicode_str); */
2336 };
2337
2338
2339
2340 struct set_key_value_request
2341 {
2342     struct request_header __header;
2343     obj_handle_t hkey;
2344     int          type;
2345     data_size_t  namelen;
2346     /* VARARG(name,unicode_str,namelen); */
2347     /* VARARG(data,bytes); */
2348 };
2349 struct set_key_value_reply
2350 {
2351     struct reply_header __header;
2352 };
2353
2354
2355
2356 struct get_key_value_request
2357 {
2358     struct request_header __header;
2359     obj_handle_t hkey;
2360     /* VARARG(name,unicode_str); */
2361 };
2362 struct get_key_value_reply
2363 {
2364     struct reply_header __header;
2365     int          type;
2366     data_size_t  total;
2367     /* VARARG(data,bytes); */
2368 };
2369
2370
2371
2372 struct enum_key_value_request
2373 {
2374     struct request_header __header;
2375     obj_handle_t hkey;
2376     int          index;
2377     int          info_class;
2378 };
2379 struct enum_key_value_reply
2380 {
2381     struct reply_header __header;
2382     int          type;
2383     data_size_t  total;
2384     data_size_t  namelen;
2385     /* VARARG(name,unicode_str,namelen); */
2386     /* VARARG(data,bytes); */
2387     char __pad_20[4];
2388 };
2389
2390
2391
2392 struct delete_key_value_request
2393 {
2394     struct request_header __header;
2395     obj_handle_t hkey;
2396     /* VARARG(name,unicode_str); */
2397 };
2398 struct delete_key_value_reply
2399 {
2400     struct reply_header __header;
2401 };
2402
2403
2404
2405 struct load_registry_request
2406 {
2407     struct request_header __header;
2408     obj_handle_t hkey;
2409     obj_handle_t file;
2410     /* VARARG(name,unicode_str); */
2411     char __pad_20[4];
2412 };
2413 struct load_registry_reply
2414 {
2415     struct reply_header __header;
2416 };
2417
2418
2419
2420 struct unload_registry_request
2421 {
2422     struct request_header __header;
2423     obj_handle_t hkey;
2424 };
2425 struct unload_registry_reply
2426 {
2427     struct reply_header __header;
2428 };
2429
2430
2431
2432 struct save_registry_request
2433 {
2434     struct request_header __header;
2435     obj_handle_t hkey;
2436     obj_handle_t file;
2437     char __pad_20[4];
2438 };
2439 struct save_registry_reply
2440 {
2441     struct reply_header __header;
2442 };
2443
2444
2445
2446 struct set_registry_notification_request
2447 {
2448     struct request_header __header;
2449     obj_handle_t hkey;
2450     obj_handle_t event;
2451     int          subtree;
2452     unsigned int filter;
2453     char __pad_28[4];
2454 };
2455 struct set_registry_notification_reply
2456 {
2457     struct reply_header __header;
2458 };
2459
2460
2461
2462 struct create_timer_request
2463 {
2464     struct request_header __header;
2465     unsigned int access;
2466     unsigned int attributes;
2467     obj_handle_t rootdir;
2468     int          manual;
2469     /* VARARG(name,unicode_str); */
2470     char __pad_28[4];
2471 };
2472 struct create_timer_reply
2473 {
2474     struct reply_header __header;
2475     obj_handle_t handle;
2476     char __pad_12[4];
2477 };
2478
2479
2480
2481 struct open_timer_request
2482 {
2483     struct request_header __header;
2484     unsigned int access;
2485     unsigned int attributes;
2486     obj_handle_t rootdir;
2487     /* VARARG(name,unicode_str); */
2488 };
2489 struct open_timer_reply
2490 {
2491     struct reply_header __header;
2492     obj_handle_t handle;
2493     char __pad_12[4];
2494 };
2495
2496
2497 struct set_timer_request
2498 {
2499     struct request_header __header;
2500     obj_handle_t handle;
2501     timeout_t    expire;
2502     client_ptr_t callback;
2503     client_ptr_t arg;
2504     int          period;
2505     char __pad_44[4];
2506 };
2507 struct set_timer_reply
2508 {
2509     struct reply_header __header;
2510     int          signaled;
2511     char __pad_12[4];
2512 };
2513
2514
2515 struct cancel_timer_request
2516 {
2517     struct request_header __header;
2518     obj_handle_t handle;
2519 };
2520 struct cancel_timer_reply
2521 {
2522     struct reply_header __header;
2523      int         signaled;
2524     char __pad_12[4];
2525 };
2526
2527
2528 struct get_timer_info_request
2529 {
2530     struct request_header __header;
2531     obj_handle_t handle;
2532 };
2533 struct get_timer_info_reply
2534 {
2535     struct reply_header __header;
2536     timeout_t    when;
2537     int          signaled;
2538     char __pad_20[4];
2539 };
2540
2541
2542
2543 struct get_thread_context_request
2544 {
2545     struct request_header __header;
2546     obj_handle_t handle;
2547     unsigned int flags;
2548     int          suspend;
2549 };
2550 struct get_thread_context_reply
2551 {
2552     struct reply_header __header;
2553     int          self;
2554     /* VARARG(context,context); */
2555     char __pad_12[4];
2556 };
2557
2558
2559
2560 struct set_thread_context_request
2561 {
2562     struct request_header __header;
2563     obj_handle_t handle;
2564     int          suspend;
2565     /* VARARG(context,context); */
2566     char __pad_20[4];
2567 };
2568 struct set_thread_context_reply
2569 {
2570     struct reply_header __header;
2571     int          self;
2572     char __pad_12[4];
2573 };
2574
2575
2576
2577 struct get_selector_entry_request
2578 {
2579     struct request_header __header;
2580     obj_handle_t  handle;
2581     int           entry;
2582     char __pad_20[4];
2583 };
2584 struct get_selector_entry_reply
2585 {
2586     struct reply_header __header;
2587     unsigned int  base;
2588     unsigned int  limit;
2589     unsigned char flags;
2590     char __pad_17[7];
2591 };
2592
2593
2594
2595 struct add_atom_request
2596 {
2597     struct request_header __header;
2598     obj_handle_t  table;
2599     /* VARARG(name,unicode_str); */
2600 };
2601 struct add_atom_reply
2602 {
2603     struct reply_header __header;
2604     atom_t        atom;
2605     char __pad_12[4];
2606 };
2607
2608
2609
2610 struct delete_atom_request
2611 {
2612     struct request_header __header;
2613     obj_handle_t  table;
2614     atom_t        atom;
2615     char __pad_20[4];
2616 };
2617 struct delete_atom_reply
2618 {
2619     struct reply_header __header;
2620 };
2621
2622
2623
2624 struct find_atom_request
2625 {
2626     struct request_header __header;
2627     obj_handle_t table;
2628     /* VARARG(name,unicode_str); */
2629 };
2630 struct find_atom_reply
2631 {
2632     struct reply_header __header;
2633     atom_t       atom;
2634     char __pad_12[4];
2635 };
2636
2637
2638
2639 struct get_atom_information_request
2640 {
2641     struct request_header __header;
2642     obj_handle_t table;
2643     atom_t       atom;
2644     char __pad_20[4];
2645 };
2646 struct get_atom_information_reply
2647 {
2648     struct reply_header __header;
2649     int          count;
2650     int          pinned;
2651     data_size_t  total;
2652     /* VARARG(name,unicode_str); */
2653     char __pad_20[4];
2654 };
2655
2656
2657
2658 struct set_atom_information_request
2659 {
2660     struct request_header __header;
2661     obj_handle_t table;
2662     atom_t       atom;
2663     int          pinned;
2664 };
2665 struct set_atom_information_reply
2666 {
2667     struct reply_header __header;
2668 };
2669
2670
2671
2672 struct empty_atom_table_request
2673 {
2674     struct request_header __header;
2675     obj_handle_t table;
2676     int          if_pinned;
2677     char __pad_20[4];
2678 };
2679 struct empty_atom_table_reply
2680 {
2681     struct reply_header __header;
2682 };
2683
2684
2685
2686 struct init_atom_table_request
2687 {
2688     struct request_header __header;
2689     int          entries;
2690 };
2691 struct init_atom_table_reply
2692 {
2693     struct reply_header __header;
2694     obj_handle_t table;
2695     char __pad_12[4];
2696 };
2697
2698
2699
2700 struct get_msg_queue_request
2701 {
2702     struct request_header __header;
2703     char __pad_12[4];
2704 };
2705 struct get_msg_queue_reply
2706 {
2707     struct reply_header __header;
2708     obj_handle_t handle;
2709     char __pad_12[4];
2710 };
2711
2712
2713
2714 struct set_queue_fd_request
2715 {
2716     struct request_header __header;
2717     obj_handle_t handle;
2718 };
2719 struct set_queue_fd_reply
2720 {
2721     struct reply_header __header;
2722 };
2723
2724
2725
2726 struct set_queue_mask_request
2727 {
2728     struct request_header __header;
2729     unsigned int wake_mask;
2730     unsigned int changed_mask;
2731     int          skip_wait;
2732 };
2733 struct set_queue_mask_reply
2734 {
2735     struct reply_header __header;
2736     unsigned int wake_bits;
2737     unsigned int changed_bits;
2738 };
2739
2740
2741
2742 struct get_queue_status_request
2743 {
2744     struct request_header __header;
2745     int          clear;
2746 };
2747 struct get_queue_status_reply
2748 {
2749     struct reply_header __header;
2750     unsigned int wake_bits;
2751     unsigned int changed_bits;
2752 };
2753
2754
2755
2756 struct get_process_idle_event_request
2757 {
2758     struct request_header __header;
2759     obj_handle_t handle;
2760 };
2761 struct get_process_idle_event_reply
2762 {
2763     struct reply_header __header;
2764     obj_handle_t event;
2765     char __pad_12[4];
2766 };
2767
2768
2769
2770 struct send_message_request
2771 {
2772     struct request_header __header;
2773     thread_id_t     id;
2774     int             type;
2775     int             flags;
2776     user_handle_t   win;
2777     unsigned int    msg;
2778     lparam_t        wparam;
2779     lparam_t        lparam;
2780     timeout_t       timeout;
2781     /* VARARG(data,message_data); */
2782 };
2783 struct send_message_reply
2784 {
2785     struct reply_header __header;
2786 };
2787
2788 struct post_quit_message_request
2789 {
2790     struct request_header __header;
2791     int             exit_code;
2792 };
2793 struct post_quit_message_reply
2794 {
2795     struct reply_header __header;
2796 };
2797
2798 enum message_type
2799 {
2800     MSG_ASCII,
2801     MSG_UNICODE,
2802     MSG_NOTIFY,
2803     MSG_CALLBACK,
2804     MSG_CALLBACK_RESULT,
2805     MSG_OTHER_PROCESS,
2806     MSG_POSTED,
2807     MSG_HARDWARE,
2808     MSG_WINEVENT,
2809     MSG_HOOK_LL
2810 };
2811 #define SEND_MSG_ABORT_IF_HUNG  0x01
2812
2813
2814
2815 struct send_hardware_message_request
2816 {
2817     struct request_header __header;
2818     user_handle_t   win;
2819     hw_input_t      input;
2820     unsigned int    flags;
2821     char __pad_52[4];
2822 };
2823 struct send_hardware_message_reply
2824 {
2825     struct reply_header __header;
2826     int             wait;
2827     int             prev_x;
2828     int             prev_y;
2829     int             new_x;
2830     int             new_y;
2831     /* VARARG(keystate,bytes); */
2832     char __pad_28[4];
2833 };
2834 #define SEND_HWMSG_INJECTED    0x01
2835
2836
2837
2838 struct get_message_request
2839 {
2840     struct request_header __header;
2841     unsigned int    flags;
2842     user_handle_t   get_win;
2843     unsigned int    get_first;
2844     unsigned int    get_last;
2845     unsigned int    hw_id;
2846     unsigned int    wake_mask;
2847     unsigned int    changed_mask;
2848 };
2849 struct get_message_reply
2850 {
2851     struct reply_header __header;
2852     user_handle_t   win;
2853     unsigned int    msg;
2854     lparam_t        wparam;
2855     lparam_t        lparam;
2856     int             type;
2857     unsigned int    time;
2858     unsigned int    active_hooks;
2859     data_size_t     total;
2860     /* VARARG(data,message_data); */
2861 };
2862
2863
2864
2865 struct reply_message_request
2866 {
2867     struct request_header __header;
2868     int             remove;
2869     lparam_t        result;
2870     /* VARARG(data,bytes); */
2871 };
2872 struct reply_message_reply
2873 {
2874     struct reply_header __header;
2875 };
2876
2877
2878
2879 struct accept_hardware_message_request
2880 {
2881     struct request_header __header;
2882     unsigned int    hw_id;
2883     int             remove;
2884     user_handle_t   new_win;
2885 };
2886 struct accept_hardware_message_reply
2887 {
2888     struct reply_header __header;
2889 };
2890
2891
2892
2893 struct get_message_reply_request
2894 {
2895     struct request_header __header;
2896     int             cancel;
2897 };
2898 struct get_message_reply_reply
2899 {
2900     struct reply_header __header;
2901     lparam_t        result;
2902     /* VARARG(data,bytes); */
2903 };
2904
2905
2906
2907 struct set_win_timer_request
2908 {
2909     struct request_header __header;
2910     user_handle_t   win;
2911     unsigned int    msg;
2912     unsigned int    rate;
2913     lparam_t        id;
2914     lparam_t        lparam;
2915 };
2916 struct set_win_timer_reply
2917 {
2918     struct reply_header __header;
2919     lparam_t        id;
2920 };
2921
2922
2923
2924 struct kill_win_timer_request
2925 {
2926     struct request_header __header;
2927     user_handle_t   win;
2928     lparam_t        id;
2929     unsigned int    msg;
2930     char __pad_28[4];
2931 };
2932 struct kill_win_timer_reply
2933 {
2934     struct reply_header __header;
2935 };
2936
2937
2938
2939 struct is_window_hung_request
2940 {
2941     struct request_header __header;
2942     user_handle_t   win;
2943 };
2944 struct is_window_hung_reply
2945 {
2946     struct reply_header __header;
2947     int is_hung;
2948     char __pad_12[4];
2949 };
2950
2951
2952
2953 struct get_serial_info_request
2954 {
2955     struct request_header __header;
2956     obj_handle_t handle;
2957 };
2958 struct get_serial_info_reply
2959 {
2960     struct reply_header __header;
2961     unsigned int readinterval;
2962     unsigned int readconst;
2963     unsigned int readmult;
2964     unsigned int writeconst;
2965     unsigned int writemult;
2966     unsigned int eventmask;
2967 };
2968
2969
2970
2971 struct set_serial_info_request
2972 {
2973     struct request_header __header;
2974     obj_handle_t handle;
2975     int          flags;
2976     unsigned int readinterval;
2977     unsigned int readconst;
2978     unsigned int readmult;
2979     unsigned int writeconst;
2980     unsigned int writemult;
2981     unsigned int eventmask;
2982     char __pad_44[4];
2983 };
2984 struct set_serial_info_reply
2985 {
2986     struct reply_header __header;
2987 };
2988 #define SERIALINFO_SET_TIMEOUTS  0x01
2989 #define SERIALINFO_SET_MASK      0x02
2990
2991
2992
2993 struct register_async_request
2994 {
2995     struct request_header __header;
2996     int          type;
2997     async_data_t async;
2998     int          count;
2999     char __pad_60[4];
3000 };
3001 struct register_async_reply
3002 {
3003     struct reply_header __header;
3004 };
3005 #define ASYNC_TYPE_READ  0x01
3006 #define ASYNC_TYPE_WRITE 0x02
3007 #define ASYNC_TYPE_WAIT  0x03
3008
3009
3010
3011 struct cancel_async_request
3012 {
3013     struct request_header __header;
3014     obj_handle_t handle;
3015     client_ptr_t iosb;
3016     int          only_thread;
3017     char __pad_28[4];
3018 };
3019 struct cancel_async_reply
3020 {
3021     struct reply_header __header;
3022 };
3023
3024
3025
3026 struct ioctl_request
3027 {
3028     struct request_header __header;
3029     ioctl_code_t   code;
3030     async_data_t   async;
3031     int            blocking;
3032     /* VARARG(in_data,bytes); */
3033     char __pad_60[4];
3034 };
3035 struct ioctl_reply
3036 {
3037     struct reply_header __header;
3038     obj_handle_t   wait;
3039     unsigned int   options;
3040     /* VARARG(out_data,bytes); */
3041 };
3042
3043
3044
3045 struct get_ioctl_result_request
3046 {
3047     struct request_header __header;
3048     obj_handle_t   handle;
3049     client_ptr_t   user_arg;
3050 };
3051 struct get_ioctl_result_reply
3052 {
3053     struct reply_header __header;
3054     /* VARARG(out_data,bytes); */
3055 };
3056
3057
3058
3059 struct create_named_pipe_request
3060 {
3061     struct request_header __header;
3062     unsigned int   access;
3063     unsigned int   attributes;
3064     obj_handle_t   rootdir;
3065     unsigned int   options;
3066     unsigned int   sharing;
3067     unsigned int   maxinstances;
3068     unsigned int   outsize;
3069     unsigned int   insize;
3070     char __pad_44[4];
3071     timeout_t      timeout;
3072     unsigned int   flags;
3073     /* VARARG(name,unicode_str); */
3074     char __pad_60[4];
3075 };
3076 struct create_named_pipe_reply
3077 {
3078     struct reply_header __header;
3079     obj_handle_t   handle;
3080     char __pad_12[4];
3081 };
3082
3083
3084 #define NAMED_PIPE_MESSAGE_STREAM_WRITE 0x0001
3085 #define NAMED_PIPE_MESSAGE_STREAM_READ  0x0002
3086 #define NAMED_PIPE_NONBLOCKING_MODE     0x0004
3087 #define NAMED_PIPE_SERVER_END           0x8000
3088
3089
3090 struct get_named_pipe_info_request
3091 {
3092     struct request_header __header;
3093     obj_handle_t   handle;
3094 };
3095 struct get_named_pipe_info_reply
3096 {
3097     struct reply_header __header;
3098     unsigned int   flags;
3099     unsigned int   sharing;
3100     unsigned int   maxinstances;
3101     unsigned int   instances;
3102     unsigned int   outsize;
3103     unsigned int   insize;
3104 };
3105
3106
3107
3108 struct create_window_request
3109 {
3110     struct request_header __header;
3111     user_handle_t  parent;
3112     user_handle_t  owner;
3113     atom_t         atom;
3114     mod_handle_t   instance;
3115     /* VARARG(class,unicode_str); */
3116 };
3117 struct create_window_reply
3118 {
3119     struct reply_header __header;
3120     user_handle_t  handle;
3121     user_handle_t  parent;
3122     user_handle_t  owner;
3123     int            extra;
3124     client_ptr_t   class_ptr;
3125 };
3126
3127
3128
3129 struct destroy_window_request
3130 {
3131     struct request_header __header;
3132     user_handle_t  handle;
3133 };
3134 struct destroy_window_reply
3135 {
3136     struct reply_header __header;
3137 };
3138
3139
3140
3141 struct get_desktop_window_request
3142 {
3143     struct request_header __header;
3144     int            force;
3145 };
3146 struct get_desktop_window_reply
3147 {
3148     struct reply_header __header;
3149     user_handle_t  top_window;
3150     user_handle_t  msg_window;
3151 };
3152
3153
3154
3155 struct set_window_owner_request
3156 {
3157     struct request_header __header;
3158     user_handle_t  handle;
3159     user_handle_t  owner;
3160     char __pad_20[4];
3161 };
3162 struct set_window_owner_reply
3163 {
3164     struct reply_header __header;
3165     user_handle_t  full_owner;
3166     user_handle_t  prev_owner;
3167 };
3168
3169
3170
3171 struct get_window_info_request
3172 {
3173     struct request_header __header;
3174     user_handle_t  handle;
3175 };
3176 struct get_window_info_reply
3177 {
3178     struct reply_header __header;
3179     user_handle_t  full_handle;
3180     user_handle_t  last_active;
3181     process_id_t   pid;
3182     thread_id_t    tid;
3183     atom_t         atom;
3184     int            is_unicode;
3185 };
3186
3187
3188
3189 struct set_window_info_request
3190 {
3191     struct request_header __header;
3192     unsigned short flags;
3193     short int      is_unicode;
3194     user_handle_t  handle;
3195     unsigned int   style;
3196     unsigned int   ex_style;
3197     unsigned int   id;
3198     mod_handle_t   instance;
3199     lparam_t       user_data;
3200     int            extra_offset;
3201     data_size_t    extra_size;
3202     lparam_t       extra_value;
3203 };
3204 struct set_window_info_reply
3205 {
3206     struct reply_header __header;
3207     unsigned int   old_style;
3208     unsigned int   old_ex_style;
3209     mod_handle_t   old_instance;
3210     lparam_t       old_user_data;
3211     lparam_t       old_extra_value;
3212     unsigned int   old_id;
3213     char __pad_44[4];
3214 };
3215 #define SET_WIN_STYLE     0x01
3216 #define SET_WIN_EXSTYLE   0x02
3217 #define SET_WIN_ID        0x04
3218 #define SET_WIN_INSTANCE  0x08
3219 #define SET_WIN_USERDATA  0x10
3220 #define SET_WIN_EXTRA     0x20
3221 #define SET_WIN_UNICODE   0x40
3222
3223
3224
3225 struct set_parent_request
3226 {
3227     struct request_header __header;
3228     user_handle_t  handle;
3229     user_handle_t  parent;
3230     char __pad_20[4];
3231 };
3232 struct set_parent_reply
3233 {
3234     struct reply_header __header;
3235     user_handle_t  old_parent;
3236     user_handle_t  full_parent;
3237 };
3238
3239
3240
3241 struct get_window_parents_request
3242 {
3243     struct request_header __header;
3244     user_handle_t  handle;
3245 };
3246 struct get_window_parents_reply
3247 {
3248     struct reply_header __header;
3249     int            count;
3250     /* VARARG(parents,user_handles); */
3251     char __pad_12[4];
3252 };
3253
3254
3255
3256 struct get_window_children_request
3257 {
3258     struct request_header __header;
3259     obj_handle_t   desktop;
3260     user_handle_t  parent;
3261     atom_t         atom;
3262     thread_id_t    tid;
3263     /* VARARG(class,unicode_str); */
3264     char __pad_28[4];
3265 };
3266 struct get_window_children_reply
3267 {
3268     struct reply_header __header;
3269     int            count;
3270     /* VARARG(children,user_handles); */
3271     char __pad_12[4];
3272 };
3273
3274
3275
3276 struct get_window_children_from_point_request
3277 {
3278     struct request_header __header;
3279     user_handle_t  parent;
3280     int            x;
3281     int            y;
3282 };
3283 struct get_window_children_from_point_reply
3284 {
3285     struct reply_header __header;
3286     int            count;
3287     /* VARARG(children,user_handles); */
3288     char __pad_12[4];
3289 };
3290
3291
3292
3293 struct get_window_tree_request
3294 {
3295     struct request_header __header;
3296     user_handle_t  handle;
3297 };
3298 struct get_window_tree_reply
3299 {
3300     struct reply_header __header;
3301     user_handle_t  parent;
3302     user_handle_t  owner;
3303     user_handle_t  next_sibling;
3304     user_handle_t  prev_sibling;
3305     user_handle_t  first_sibling;
3306     user_handle_t  last_sibling;
3307     user_handle_t  first_child;
3308     user_handle_t  last_child;
3309 };
3310
3311
3312 struct set_window_pos_request
3313 {
3314     struct request_header __header;
3315     unsigned short swp_flags;
3316     unsigned short paint_flags;
3317     user_handle_t  handle;
3318     user_handle_t  previous;
3319     rectangle_t    window;
3320     rectangle_t    client;
3321     /* VARARG(valid,rectangles); */
3322 };
3323 struct set_window_pos_reply
3324 {
3325     struct reply_header __header;
3326     unsigned int   new_style;
3327     unsigned int   new_ex_style;
3328     user_handle_t  surface_win;
3329     char __pad_20[4];
3330 };
3331 #define SET_WINPOS_PAINT_SURFACE 0x01
3332 #define SET_WINPOS_PIXEL_FORMAT  0x02
3333
3334
3335 struct get_window_rectangles_request
3336 {
3337     struct request_header __header;
3338     user_handle_t  handle;
3339     int            relative;
3340     char __pad_20[4];
3341 };
3342 struct get_window_rectangles_reply
3343 {
3344     struct reply_header __header;
3345     rectangle_t    window;
3346     rectangle_t    visible;
3347     rectangle_t    client;
3348 };
3349 enum coords_relative
3350 {
3351     COORDS_CLIENT,
3352     COORDS_WINDOW,
3353     COORDS_PARENT,
3354     COORDS_SCREEN
3355 };
3356
3357
3358
3359 struct get_window_text_request
3360 {
3361     struct request_header __header;
3362     user_handle_t  handle;
3363 };
3364 struct get_window_text_reply
3365 {
3366     struct reply_header __header;
3367     /* VARARG(text,unicode_str); */
3368 };
3369
3370
3371
3372 struct set_window_text_request
3373 {
3374     struct request_header __header;
3375     user_handle_t  handle;
3376     /* VARARG(text,unicode_str); */
3377 };
3378 struct set_window_text_reply
3379 {
3380     struct reply_header __header;
3381 };
3382
3383
3384
3385 struct get_windows_offset_request
3386 {
3387     struct request_header __header;
3388     user_handle_t  from;
3389     user_handle_t  to;
3390     char __pad_20[4];
3391 };
3392 struct get_windows_offset_reply
3393 {
3394     struct reply_header __header;
3395     int            x;
3396     int            y;
3397     int            mirror;
3398     char __pad_20[4];
3399 };
3400
3401
3402
3403 struct get_visible_region_request
3404 {
3405     struct request_header __header;
3406     user_handle_t  window;
3407     unsigned int   flags;
3408     char __pad_20[4];
3409 };
3410 struct get_visible_region_reply
3411 {
3412     struct reply_header __header;
3413     user_handle_t  top_win;
3414     rectangle_t    top_rect;
3415     rectangle_t    win_rect;
3416     data_size_t    total_size;
3417     /* VARARG(region,rectangles); */
3418 };
3419
3420
3421
3422 struct get_surface_region_request
3423 {
3424     struct request_header __header;
3425     user_handle_t  window;
3426 };
3427 struct get_surface_region_reply
3428 {
3429     struct reply_header __header;
3430     rectangle_t    visible_rect;
3431     data_size_t    total_size;
3432     /* VARARG(region,rectangles); */
3433     char __pad_28[4];
3434 };
3435
3436
3437
3438 struct get_window_region_request
3439 {
3440     struct request_header __header;
3441     user_handle_t  window;
3442 };
3443 struct get_window_region_reply
3444 {
3445     struct reply_header __header;
3446     data_size_t    total_size;
3447     /* VARARG(region,rectangles); */
3448     char __pad_12[4];
3449 };
3450
3451
3452
3453 struct set_window_region_request
3454 {
3455     struct request_header __header;
3456     user_handle_t  window;
3457     int            redraw;
3458     /* VARARG(region,rectangles); */
3459     char __pad_20[4];
3460 };
3461 struct set_window_region_reply
3462 {
3463     struct reply_header __header;
3464 };
3465
3466
3467
3468 struct get_update_region_request
3469 {
3470     struct request_header __header;
3471     user_handle_t  window;
3472     user_handle_t  from_child;
3473     unsigned int   flags;
3474 };
3475 struct get_update_region_reply
3476 {
3477     struct reply_header __header;
3478     user_handle_t  child;
3479     unsigned int   flags;
3480     data_size_t    total_size;
3481     /* VARARG(region,rectangles); */
3482     char __pad_20[4];
3483 };
3484 #define UPDATE_NONCLIENT       0x01
3485 #define UPDATE_ERASE           0x02
3486 #define UPDATE_PAINT           0x04
3487 #define UPDATE_INTERNALPAINT   0x08
3488 #define UPDATE_ALLCHILDREN     0x10
3489 #define UPDATE_NOCHILDREN      0x20
3490 #define UPDATE_NOREGION        0x40
3491 #define UPDATE_DELAYED_ERASE   0x80
3492
3493
3494
3495 struct update_window_zorder_request
3496 {
3497     struct request_header __header;
3498     user_handle_t  window;
3499     rectangle_t    rect;
3500 };
3501 struct update_window_zorder_reply
3502 {
3503     struct reply_header __header;
3504 };
3505
3506
3507
3508 struct redraw_window_request
3509 {
3510     struct request_header __header;
3511     user_handle_t  window;
3512     unsigned int   flags;
3513     /* VARARG(region,rectangles); */
3514     char __pad_20[4];
3515 };
3516 struct redraw_window_reply
3517 {
3518     struct reply_header __header;
3519 };
3520
3521
3522
3523 struct set_window_property_request
3524 {
3525     struct request_header __header;
3526     user_handle_t  window;
3527     lparam_t       data;
3528     atom_t         atom;
3529     /* VARARG(name,unicode_str); */
3530     char __pad_28[4];
3531 };
3532 struct set_window_property_reply
3533 {
3534     struct reply_header __header;
3535 };
3536
3537
3538
3539 struct remove_window_property_request
3540 {
3541     struct request_header __header;
3542     user_handle_t  window;
3543     atom_t         atom;
3544     /* VARARG(name,unicode_str); */
3545     char __pad_20[4];
3546 };
3547 struct remove_window_property_reply
3548 {
3549     struct reply_header __header;
3550     lparam_t       data;
3551 };
3552
3553
3554
3555 struct get_window_property_request
3556 {
3557     struct request_header __header;
3558     user_handle_t  window;
3559     atom_t         atom;
3560     /* VARARG(name,unicode_str); */
3561     char __pad_20[4];
3562 };
3563 struct get_window_property_reply
3564 {
3565     struct reply_header __header;
3566     lparam_t       data;
3567 };
3568
3569
3570
3571 struct get_window_properties_request
3572 {
3573     struct request_header __header;
3574     user_handle_t  window;
3575 };
3576 struct get_window_properties_reply
3577 {
3578     struct reply_header __header;
3579     int            total;
3580     /* VARARG(props,properties); */
3581     char __pad_12[4];
3582 };
3583
3584
3585
3586 struct create_winstation_request
3587 {
3588     struct request_header __header;
3589     unsigned int flags;
3590     unsigned int access;
3591     unsigned int attributes;
3592     /* VARARG(name,unicode_str); */
3593 };
3594 struct create_winstation_reply
3595 {
3596     struct reply_header __header;
3597     obj_handle_t handle;
3598     char __pad_12[4];
3599 };
3600
3601
3602
3603 struct open_winstation_request
3604 {
3605     struct request_header __header;
3606     unsigned int access;
3607     unsigned int attributes;
3608     /* VARARG(name,unicode_str); */
3609     char __pad_20[4];
3610 };
3611 struct open_winstation_reply
3612 {
3613     struct reply_header __header;
3614     obj_handle_t handle;
3615     char __pad_12[4];
3616 };
3617
3618
3619
3620 struct close_winstation_request
3621 {
3622     struct request_header __header;
3623     obj_handle_t handle;
3624 };
3625 struct close_winstation_reply
3626 {
3627     struct reply_header __header;
3628 };
3629
3630
3631
3632 struct get_process_winstation_request
3633 {
3634     struct request_header __header;
3635     char __pad_12[4];
3636 };
3637 struct get_process_winstation_reply
3638 {
3639     struct reply_header __header;
3640     obj_handle_t handle;
3641     char __pad_12[4];
3642 };
3643
3644
3645
3646 struct set_process_winstation_request
3647 {
3648     struct request_header __header;
3649     obj_handle_t handle;
3650 };
3651 struct set_process_winstation_reply
3652 {
3653     struct reply_header __header;
3654 };
3655
3656
3657
3658 struct enum_winstation_request
3659 {
3660     struct request_header __header;
3661     unsigned int index;
3662 };
3663 struct enum_winstation_reply
3664 {
3665     struct reply_header __header;
3666     unsigned int next;
3667     /* VARARG(name,unicode_str); */
3668     char __pad_12[4];
3669 };
3670
3671
3672
3673 struct create_desktop_request
3674 {
3675     struct request_header __header;
3676     unsigned int flags;
3677     unsigned int access;
3678     unsigned int attributes;
3679     /* VARARG(name,unicode_str); */
3680 };
3681 struct create_desktop_reply
3682 {
3683     struct reply_header __header;
3684     obj_handle_t handle;
3685     char __pad_12[4];
3686 };
3687
3688
3689
3690 struct open_desktop_request
3691 {
3692     struct request_header __header;
3693     obj_handle_t winsta;
3694     unsigned int flags;
3695     unsigned int access;
3696     unsigned int attributes;
3697     /* VARARG(name,unicode_str); */
3698     char __pad_28[4];
3699 };
3700 struct open_desktop_reply
3701 {
3702     struct reply_header __header;
3703     obj_handle_t handle;
3704     char __pad_12[4];
3705 };
3706
3707
3708
3709 struct close_desktop_request
3710 {
3711     struct request_header __header;
3712     obj_handle_t handle;
3713 };
3714 struct close_desktop_reply
3715 {
3716     struct reply_header __header;
3717 };
3718
3719
3720
3721 struct get_thread_desktop_request
3722 {
3723     struct request_header __header;
3724     thread_id_t  tid;
3725 };
3726 struct get_thread_desktop_reply
3727 {
3728     struct reply_header __header;
3729     obj_handle_t handle;
3730     char __pad_12[4];
3731 };
3732
3733
3734
3735 struct set_thread_desktop_request
3736 {
3737     struct request_header __header;
3738     obj_handle_t handle;
3739 };
3740 struct set_thread_desktop_reply
3741 {
3742     struct reply_header __header;
3743 };
3744
3745
3746
3747 struct enum_desktop_request
3748 {
3749     struct request_header __header;
3750     obj_handle_t winstation;
3751     unsigned int index;
3752     char __pad_20[4];
3753 };
3754 struct enum_desktop_reply
3755 {
3756     struct reply_header __header;
3757     unsigned int next;
3758     /* VARARG(name,unicode_str); */
3759     char __pad_12[4];
3760 };
3761
3762
3763
3764 struct set_user_object_info_request
3765 {
3766     struct request_header __header;
3767     obj_handle_t handle;
3768     unsigned int flags;
3769     unsigned int obj_flags;
3770 };
3771 struct set_user_object_info_reply
3772 {
3773     struct reply_header __header;
3774     int          is_desktop;
3775     unsigned int old_obj_flags;
3776     /* VARARG(name,unicode_str); */
3777 };
3778 #define SET_USER_OBJECT_FLAGS 1
3779
3780
3781
3782 struct register_hotkey_request
3783 {
3784     struct request_header __header;
3785     user_handle_t  window;
3786     int            id;
3787     unsigned int   flags;
3788     unsigned int   vkey;
3789     char __pad_28[4];
3790 };
3791 struct register_hotkey_reply
3792 {
3793     struct reply_header __header;
3794     int            replaced;
3795     unsigned int   flags;
3796     unsigned int   vkey;
3797     char __pad_20[4];
3798 };
3799
3800
3801
3802 struct unregister_hotkey_request
3803 {
3804     struct request_header __header;
3805     user_handle_t  window;
3806     int            id;
3807     char __pad_20[4];
3808 };
3809 struct unregister_hotkey_reply
3810 {
3811     struct reply_header __header;
3812     unsigned int   flags;
3813     unsigned int   vkey;
3814 };
3815
3816
3817
3818 struct attach_thread_input_request
3819 {
3820     struct request_header __header;
3821     thread_id_t    tid_from;
3822     thread_id_t    tid_to;
3823     int            attach;
3824 };
3825 struct attach_thread_input_reply
3826 {
3827     struct reply_header __header;
3828 };
3829
3830
3831
3832 struct get_thread_input_request
3833 {
3834     struct request_header __header;
3835     thread_id_t    tid;
3836 };
3837 struct get_thread_input_reply
3838 {
3839     struct reply_header __header;
3840     user_handle_t  focus;
3841     user_handle_t  capture;
3842     user_handle_t  active;
3843     user_handle_t  foreground;
3844     user_handle_t  menu_owner;
3845     user_handle_t  move_size;
3846     user_handle_t  caret;
3847     user_handle_t  cursor;
3848     int            show_count;
3849     rectangle_t    rect;
3850     char __pad_60[4];
3851 };
3852
3853
3854
3855 struct get_last_input_time_request
3856 {
3857     struct request_header __header;
3858     char __pad_12[4];
3859 };
3860 struct get_last_input_time_reply
3861 {
3862     struct reply_header __header;
3863     unsigned int time;
3864     char __pad_12[4];
3865 };
3866
3867
3868
3869 struct get_key_state_request
3870 {
3871     struct request_header __header;
3872     thread_id_t    tid;
3873     int            key;
3874     char __pad_20[4];
3875 };
3876 struct get_key_state_reply
3877 {
3878     struct reply_header __header;
3879     unsigned char  state;
3880     /* VARARG(keystate,bytes); */
3881     char __pad_9[7];
3882 };
3883
3884
3885 struct set_key_state_request
3886 {
3887     struct request_header __header;
3888     thread_id_t    tid;
3889     int            async;
3890     /* VARARG(keystate,bytes); */
3891     char __pad_20[4];
3892 };
3893 struct set_key_state_reply
3894 {
3895     struct reply_header __header;
3896 };
3897
3898
3899 struct set_foreground_window_request
3900 {
3901     struct request_header __header;
3902     user_handle_t  handle;
3903 };
3904 struct set_foreground_window_reply
3905 {
3906     struct reply_header __header;
3907     user_handle_t  previous;
3908     int            send_msg_old;
3909     int            send_msg_new;
3910     char __pad_20[4];
3911 };
3912
3913
3914 struct set_focus_window_request
3915 {
3916     struct request_header __header;
3917     user_handle_t  handle;
3918 };
3919 struct set_focus_window_reply
3920 {
3921     struct reply_header __header;
3922     user_handle_t  previous;
3923     char __pad_12[4];
3924 };
3925
3926
3927 struct set_active_window_request
3928 {
3929     struct request_header __header;
3930     user_handle_t  handle;
3931 };
3932 struct set_active_window_reply
3933 {
3934     struct reply_header __header;
3935     user_handle_t  previous;
3936     char __pad_12[4];
3937 };
3938
3939
3940 struct set_capture_window_request
3941 {
3942     struct request_header __header;
3943     user_handle_t  handle;
3944     unsigned int   flags;
3945     char __pad_20[4];
3946 };
3947 struct set_capture_window_reply
3948 {
3949     struct reply_header __header;
3950     user_handle_t  previous;
3951     user_handle_t  full_handle;
3952 };
3953 #define CAPTURE_MENU     0x01
3954 #define CAPTURE_MOVESIZE 0x02
3955
3956
3957
3958 struct set_caret_window_request
3959 {
3960     struct request_header __header;
3961     user_handle_t  handle;
3962     int            width;
3963     int            height;
3964 };
3965 struct set_caret_window_reply
3966 {
3967     struct reply_header __header;
3968     user_handle_t  previous;
3969     rectangle_t    old_rect;
3970     int            old_hide;
3971     int            old_state;
3972     char __pad_36[4];
3973 };
3974
3975
3976
3977 struct set_caret_info_request
3978 {
3979     struct request_header __header;
3980     unsigned int   flags;
3981     user_handle_t  handle;
3982     int            x;
3983     int            y;
3984     int            hide;
3985     int            state;
3986     char __pad_36[4];
3987 };
3988 struct set_caret_info_reply
3989 {
3990     struct reply_header __header;
3991     user_handle_t  full_handle;
3992     rectangle_t    old_rect;
3993     int            old_hide;
3994     int            old_state;
3995     char __pad_36[4];
3996 };
3997 #define SET_CARET_POS        0x01
3998 #define SET_CARET_HIDE       0x02
3999 #define SET_CARET_STATE      0x04
4000
4001
4002
4003 struct set_hook_request
4004 {
4005     struct request_header __header;
4006     int            id;
4007     process_id_t   pid;
4008     thread_id_t    tid;
4009     int            event_min;
4010     int            event_max;
4011     client_ptr_t   proc;
4012     int            flags;
4013     int            unicode;
4014     /* VARARG(module,unicode_str); */
4015 };
4016 struct set_hook_reply
4017 {
4018     struct reply_header __header;
4019     user_handle_t  handle;
4020     unsigned int   active_hooks;
4021 };
4022
4023
4024
4025 struct remove_hook_request
4026 {
4027     struct request_header __header;
4028     user_handle_t  handle;
4029     client_ptr_t   proc;
4030     int            id;
4031     char __pad_28[4];
4032 };
4033 struct remove_hook_reply
4034 {
4035     struct reply_header __header;
4036     unsigned int   active_hooks;
4037     char __pad_12[4];
4038 };
4039
4040
4041
4042 struct start_hook_chain_request
4043 {
4044     struct request_header __header;
4045     int            id;
4046     int            event;
4047     user_handle_t  window;
4048     int            object_id;
4049     int            child_id;
4050 };
4051 struct start_hook_chain_reply
4052 {
4053     struct reply_header __header;
4054     user_handle_t  handle;
4055     process_id_t   pid;
4056     thread_id_t    tid;
4057     int            unicode;
4058     client_ptr_t   proc;
4059     unsigned int   active_hooks;
4060     /* VARARG(module,unicode_str); */
4061     char __pad_36[4];
4062 };
4063
4064
4065
4066 struct finish_hook_chain_request
4067 {
4068     struct request_header __header;
4069     int            id;
4070 };
4071 struct finish_hook_chain_reply
4072 {
4073     struct reply_header __header;
4074 };
4075
4076
4077
4078 struct get_hook_info_request
4079 {
4080     struct request_header __header;
4081     user_handle_t  handle;
4082     int            get_next;
4083     int            event;
4084     user_handle_t  window;
4085     int            object_id;
4086     int            child_id;
4087     char __pad_36[4];
4088 };
4089 struct get_hook_info_reply
4090 {
4091     struct reply_header __header;
4092     user_handle_t  handle;
4093     int            id;
4094     process_id_t   pid;
4095     thread_id_t    tid;
4096     client_ptr_t   proc;
4097     int            unicode;
4098     /* VARARG(module,unicode_str); */
4099     char __pad_36[4];
4100 };
4101
4102
4103
4104 struct create_class_request
4105 {
4106     struct request_header __header;
4107     int            local;
4108     atom_t         atom;
4109     unsigned int   style;
4110     mod_handle_t   instance;
4111     int            extra;
4112     int            win_extra;
4113     client_ptr_t   client_ptr;
4114     /* VARARG(name,unicode_str); */
4115 };
4116 struct create_class_reply
4117 {
4118     struct reply_header __header;
4119     atom_t         atom;
4120     char __pad_12[4];
4121 };
4122
4123
4124
4125 struct destroy_class_request
4126 {
4127     struct request_header __header;
4128     atom_t         atom;
4129     mod_handle_t   instance;
4130     /* VARARG(name,unicode_str); */
4131 };
4132 struct destroy_class_reply
4133 {
4134     struct reply_header __header;
4135     client_ptr_t   client_ptr;
4136 };
4137
4138
4139
4140 struct set_class_info_request
4141 {
4142     struct request_header __header;
4143     user_handle_t  window;
4144     unsigned int   flags;
4145     atom_t         atom;
4146     unsigned int   style;
4147     int            win_extra;
4148     mod_handle_t   instance;
4149     int            extra_offset;
4150     data_size_t    extra_size;
4151     lparam_t       extra_value;
4152 };
4153 struct set_class_info_reply
4154 {
4155     struct reply_header __header;
4156     atom_t         old_atom;
4157     unsigned int   old_style;
4158     int            old_extra;
4159     int            old_win_extra;
4160     mod_handle_t   old_instance;
4161     lparam_t       old_extra_value;
4162 };
4163 #define SET_CLASS_ATOM      0x0001
4164 #define SET_CLASS_STYLE     0x0002
4165 #define SET_CLASS_WINEXTRA  0x0004
4166 #define SET_CLASS_INSTANCE  0x0008
4167 #define SET_CLASS_EXTRA     0x0010
4168
4169
4170
4171 struct set_clipboard_info_request
4172 {
4173     struct request_header __header;
4174     unsigned int   flags;
4175     user_handle_t  clipboard;
4176     user_handle_t  owner;
4177     user_handle_t  viewer;
4178     unsigned int   seqno;
4179 };
4180 struct set_clipboard_info_reply
4181 {
4182     struct reply_header __header;
4183     unsigned int   flags;
4184     user_handle_t  old_clipboard;
4185     user_handle_t  old_owner;
4186     user_handle_t  old_viewer;
4187     unsigned int   seqno;
4188     char __pad_28[4];
4189 };
4190
4191 #define SET_CB_OPEN      0x001
4192 #define SET_CB_OWNER     0x002
4193 #define SET_CB_VIEWER    0x004
4194 #define SET_CB_SEQNO     0x008
4195 #define SET_CB_RELOWNER  0x010
4196 #define SET_CB_CLOSE     0x020
4197 #define CB_OPEN          0x040
4198 #define CB_OWNER         0x080
4199 #define CB_PROCESS       0x100
4200
4201
4202
4203 struct open_token_request
4204 {
4205     struct request_header __header;
4206     obj_handle_t   handle;
4207     unsigned int   access;
4208     unsigned int   attributes;
4209     unsigned int   flags;
4210     char __pad_28[4];
4211 };
4212 struct open_token_reply
4213 {
4214     struct reply_header __header;
4215     obj_handle_t   token;
4216     char __pad_12[4];
4217 };
4218 #define OPEN_TOKEN_THREAD   1
4219 #define OPEN_TOKEN_AS_SELF  2
4220
4221
4222
4223 struct set_global_windows_request
4224 {
4225     struct request_header __header;
4226     unsigned int   flags;
4227     user_handle_t  shell_window;
4228     user_handle_t  shell_listview;
4229     user_handle_t  progman_window;
4230     user_handle_t  taskman_window;
4231 };
4232 struct set_global_windows_reply
4233 {
4234     struct reply_header __header;
4235     user_handle_t  old_shell_window;
4236     user_handle_t  old_shell_listview;
4237     user_handle_t  old_progman_window;
4238     user_handle_t  old_taskman_window;
4239 };
4240 #define SET_GLOBAL_SHELL_WINDOWS   0x01
4241 #define SET_GLOBAL_PROGMAN_WINDOW  0x02
4242 #define SET_GLOBAL_TASKMAN_WINDOW  0x04
4243
4244
4245 struct adjust_token_privileges_request
4246 {
4247     struct request_header __header;
4248     obj_handle_t  handle;
4249     int           disable_all;
4250     int           get_modified_state;
4251     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
4252 };
4253 struct adjust_token_privileges_reply
4254 {
4255     struct reply_header __header;
4256     unsigned int  len;
4257     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
4258     char __pad_12[4];
4259 };
4260
4261
4262 struct get_token_privileges_request
4263 {
4264     struct request_header __header;
4265     obj_handle_t  handle;
4266 };
4267 struct get_token_privileges_reply
4268 {
4269     struct reply_header __header;
4270     unsigned int  len;
4271     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
4272     char __pad_12[4];
4273 };
4274
4275
4276 struct check_token_privileges_request
4277 {
4278     struct request_header __header;
4279     obj_handle_t  handle;
4280     int           all_required;
4281     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
4282     char __pad_20[4];
4283 };
4284 struct check_token_privileges_reply
4285 {
4286     struct reply_header __header;
4287     int           has_privileges;
4288     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
4289     char __pad_12[4];
4290 };
4291
4292 struct duplicate_token_request
4293 {
4294     struct request_header __header;
4295     obj_handle_t  handle;
4296     unsigned int  access;
4297     unsigned int  attributes;
4298     int           primary;
4299     int           impersonation_level;
4300 };
4301 struct duplicate_token_reply
4302 {
4303     struct reply_header __header;
4304     obj_handle_t  new_handle;
4305     char __pad_12[4];
4306 };
4307
4308 struct access_check_request
4309 {
4310     struct request_header __header;
4311     obj_handle_t    handle;
4312     unsigned int    desired_access;
4313     unsigned int    mapping_read;
4314     unsigned int    mapping_write;
4315     unsigned int    mapping_execute;
4316     unsigned int    mapping_all;
4317     /* VARARG(sd,security_descriptor); */
4318     char __pad_36[4];
4319 };
4320 struct access_check_reply
4321 {
4322     struct reply_header __header;
4323     unsigned int    access_granted;
4324     unsigned int    access_status;
4325     unsigned int    privileges_len;
4326     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
4327     char __pad_20[4];
4328 };
4329
4330 struct get_token_sid_request
4331 {
4332     struct request_header __header;
4333     obj_handle_t    handle;
4334     unsigned int    which_sid;
4335     char __pad_20[4];
4336 };
4337 struct get_token_sid_reply
4338 {
4339     struct reply_header __header;
4340     data_size_t     sid_len;
4341     /* VARARG(sid,SID); */
4342     char __pad_12[4];
4343 };
4344
4345 struct get_token_groups_request
4346 {
4347     struct request_header __header;
4348     obj_handle_t    handle;
4349 };
4350 struct get_token_groups_reply
4351 {
4352     struct reply_header __header;
4353     data_size_t     user_len;
4354     /* VARARG(user,token_groups); */
4355     char __pad_12[4];
4356 };
4357
4358 struct get_token_default_dacl_request
4359 {
4360     struct request_header __header;
4361     obj_handle_t    handle;
4362 };
4363 struct get_token_default_dacl_reply
4364 {
4365     struct reply_header __header;
4366     data_size_t     acl_len;
4367     /* VARARG(acl,ACL); */
4368     char __pad_12[4];
4369 };
4370
4371 struct set_token_default_dacl_request
4372 {
4373     struct request_header __header;
4374     obj_handle_t    handle;
4375     /* VARARG(acl,ACL); */
4376 };
4377 struct set_token_default_dacl_reply
4378 {
4379     struct reply_header __header;
4380 };
4381
4382 struct set_security_object_request
4383 {
4384     struct request_header __header;
4385     obj_handle_t    handle;
4386     unsigned int    security_info;
4387     /* VARARG(sd,security_descriptor); */
4388     char __pad_20[4];
4389 };
4390 struct set_security_object_reply
4391 {
4392     struct reply_header __header;
4393 };
4394
4395 struct get_security_object_request
4396 {
4397     struct request_header __header;
4398     obj_handle_t    handle;
4399     unsigned int    security_info;
4400     char __pad_20[4];
4401 };
4402 struct get_security_object_reply
4403 {
4404     struct reply_header __header;
4405     unsigned int    sd_len;
4406     /* VARARG(sd,security_descriptor); */
4407     char __pad_12[4];
4408 };
4409
4410
4411 struct create_mailslot_request
4412 {
4413     struct request_header __header;
4414     unsigned int   access;
4415     unsigned int   attributes;
4416     obj_handle_t   rootdir;
4417     timeout_t      read_timeout;
4418     unsigned int   max_msgsize;
4419     /* VARARG(name,unicode_str); */
4420     char __pad_36[4];
4421 };
4422 struct create_mailslot_reply
4423 {
4424     struct reply_header __header;
4425     obj_handle_t   handle;
4426     char __pad_12[4];
4427 };
4428
4429
4430
4431 struct set_mailslot_info_request
4432 {
4433     struct request_header __header;
4434     obj_handle_t   handle;
4435     timeout_t      read_timeout;
4436     unsigned int   flags;
4437     char __pad_28[4];
4438 };
4439 struct set_mailslot_info_reply
4440 {
4441     struct reply_header __header;
4442     timeout_t      read_timeout;
4443     unsigned int   max_msgsize;
4444     char __pad_20[4];
4445 };
4446 #define MAILSLOT_SET_READ_TIMEOUT  1
4447
4448
4449
4450 struct create_directory_request
4451 {
4452     struct request_header __header;
4453     unsigned int   access;
4454     unsigned int   attributes;
4455     obj_handle_t   rootdir;
4456     /* VARARG(directory_name,unicode_str); */
4457 };
4458 struct create_directory_reply
4459 {
4460     struct reply_header __header;
4461     obj_handle_t   handle;
4462     char __pad_12[4];
4463 };
4464
4465
4466
4467 struct open_directory_request
4468 {
4469     struct request_header __header;
4470     unsigned int   access;
4471     unsigned int   attributes;
4472     obj_handle_t   rootdir;
4473     /* VARARG(directory_name,unicode_str); */
4474 };
4475 struct open_directory_reply
4476 {
4477     struct reply_header __header;
4478     obj_handle_t   handle;
4479     char __pad_12[4];
4480 };
4481
4482
4483
4484 struct get_directory_entry_request
4485 {
4486     struct request_header __header;
4487     obj_handle_t   handle;
4488     unsigned int   index;
4489     char __pad_20[4];
4490 };
4491 struct get_directory_entry_reply
4492 {
4493     struct reply_header __header;
4494     data_size_t    name_len;
4495     /* VARARG(name,unicode_str,name_len); */
4496     /* VARARG(type,unicode_str); */
4497     char __pad_12[4];
4498 };
4499
4500
4501
4502 struct create_symlink_request
4503 {
4504     struct request_header __header;
4505     unsigned int   access;
4506     unsigned int   attributes;
4507     obj_handle_t   rootdir;
4508     data_size_t    name_len;
4509     /* VARARG(name,unicode_str,name_len); */
4510     /* VARARG(target_name,unicode_str); */
4511     char __pad_28[4];
4512 };
4513 struct create_symlink_reply
4514 {
4515     struct reply_header __header;
4516     obj_handle_t   handle;
4517     char __pad_12[4];
4518 };
4519
4520
4521
4522 struct open_symlink_request
4523 {
4524     struct request_header __header;
4525     unsigned int   access;
4526     unsigned int   attributes;
4527     obj_handle_t   rootdir;
4528     /* VARARG(name,unicode_str); */
4529 };
4530 struct open_symlink_reply
4531 {
4532     struct reply_header __header;
4533     obj_handle_t   handle;
4534     char __pad_12[4];
4535 };
4536
4537
4538
4539 struct query_symlink_request
4540 {
4541     struct request_header __header;
4542     obj_handle_t   handle;
4543 };
4544 struct query_symlink_reply
4545 {
4546     struct reply_header __header;
4547     data_size_t    total;
4548     /* VARARG(target_name,unicode_str); */
4549     char __pad_12[4];
4550 };
4551
4552
4553
4554 struct get_object_info_request
4555 {
4556     struct request_header __header;
4557     obj_handle_t   handle;
4558 };
4559 struct get_object_info_reply
4560 {
4561     struct reply_header __header;
4562     unsigned int   access;
4563     unsigned int   ref_count;
4564     data_size_t    total;
4565     /* VARARG(name,unicode_str); */
4566     char __pad_20[4];
4567 };
4568
4569
4570
4571 struct unlink_object_request
4572 {
4573     struct request_header __header;
4574     obj_handle_t   handle;
4575 };
4576 struct unlink_object_reply
4577 {
4578     struct reply_header __header;
4579 };
4580
4581
4582
4583 struct get_token_impersonation_level_request
4584 {
4585     struct request_header __header;
4586     obj_handle_t   handle;
4587 };
4588 struct get_token_impersonation_level_reply
4589 {
4590     struct reply_header __header;
4591     int            impersonation_level;
4592     char __pad_12[4];
4593 };
4594
4595
4596 struct allocate_locally_unique_id_request
4597 {
4598     struct request_header __header;
4599     char __pad_12[4];
4600 };
4601 struct allocate_locally_unique_id_reply
4602 {
4603     struct reply_header __header;
4604     luid_t         luid;
4605 };
4606
4607
4608
4609 struct create_device_manager_request
4610 {
4611     struct request_header __header;
4612     unsigned int access;
4613     unsigned int attributes;
4614     char __pad_20[4];
4615 };
4616 struct create_device_manager_reply
4617 {
4618     struct reply_header __header;
4619     obj_handle_t handle;
4620     char __pad_12[4];
4621 };
4622
4623
4624
4625 struct create_device_request
4626 {
4627     struct request_header __header;
4628     unsigned int access;
4629     unsigned int attributes;
4630     obj_handle_t rootdir;
4631     client_ptr_t user_ptr;
4632     obj_handle_t manager;
4633     /* VARARG(name,unicode_str); */
4634     char __pad_36[4];
4635 };
4636 struct create_device_reply
4637 {
4638     struct reply_header __header;
4639     obj_handle_t handle;
4640     char __pad_12[4];
4641 };
4642
4643
4644
4645 struct delete_device_request
4646 {
4647     struct request_header __header;
4648     obj_handle_t handle;
4649 };
4650 struct delete_device_reply
4651 {
4652     struct reply_header __header;
4653 };
4654
4655
4656
4657 struct get_next_device_request_request
4658 {
4659     struct request_header __header;
4660     obj_handle_t manager;
4661     obj_handle_t prev;
4662     unsigned int status;
4663     /* VARARG(prev_data,bytes); */
4664 };
4665 struct get_next_device_request_reply
4666 {
4667     struct reply_header __header;
4668     obj_handle_t next;
4669     ioctl_code_t code;
4670     client_ptr_t user_ptr;
4671     process_id_t client_pid;
4672     thread_id_t  client_tid;
4673     data_size_t  in_size;
4674     data_size_t  out_size;
4675     /* VARARG(next_data,bytes); */
4676 };
4677
4678
4679
4680 struct make_process_system_request
4681 {
4682     struct request_header __header;
4683     char __pad_12[4];
4684 };
4685 struct make_process_system_reply
4686 {
4687     struct reply_header __header;
4688     obj_handle_t event;
4689     char __pad_12[4];
4690 };
4691
4692
4693
4694 struct get_token_statistics_request
4695 {
4696     struct request_header __header;
4697     obj_handle_t   handle;
4698 };
4699 struct get_token_statistics_reply
4700 {
4701     struct reply_header __header;
4702     luid_t         token_id;
4703     luid_t         modified_id;
4704     int            primary;
4705     int            impersonation_level;
4706     int            group_count;
4707     int            privilege_count;
4708 };
4709
4710
4711
4712 struct create_completion_request
4713 {
4714     struct request_header __header;
4715     unsigned int access;
4716     unsigned int attributes;
4717     unsigned int concurrent;
4718     obj_handle_t rootdir;
4719     /* VARARG(filename,string); */
4720     char __pad_28[4];
4721 };
4722 struct create_completion_reply
4723 {
4724     struct reply_header __header;
4725     obj_handle_t handle;
4726     char __pad_12[4];
4727 };
4728
4729
4730
4731 struct open_completion_request
4732 {
4733     struct request_header __header;
4734     unsigned int access;
4735     unsigned int attributes;
4736     obj_handle_t rootdir;
4737     /* VARARG(filename,string); */
4738 };
4739 struct open_completion_reply
4740 {
4741     struct reply_header __header;
4742     obj_handle_t handle;
4743     char __pad_12[4];
4744 };
4745
4746
4747
4748 struct add_completion_request
4749 {
4750     struct request_header __header;
4751     obj_handle_t  handle;
4752     apc_param_t   ckey;
4753     apc_param_t   cvalue;
4754     unsigned int  information;
4755     unsigned int  status;
4756 };
4757 struct add_completion_reply
4758 {
4759     struct reply_header __header;
4760 };
4761
4762
4763
4764 struct remove_completion_request
4765 {
4766     struct request_header __header;
4767     obj_handle_t handle;
4768 };
4769 struct remove_completion_reply
4770 {
4771     struct reply_header __header;
4772     apc_param_t   ckey;
4773     apc_param_t   cvalue;
4774     unsigned int  information;
4775     unsigned int  status;
4776 };
4777
4778
4779
4780 struct query_completion_request
4781 {
4782     struct request_header __header;
4783     obj_handle_t  handle;
4784 };
4785 struct query_completion_reply
4786 {
4787     struct reply_header __header;
4788     unsigned int  depth;
4789     char __pad_12[4];
4790 };
4791
4792
4793
4794 struct set_completion_info_request
4795 {
4796     struct request_header __header;
4797     obj_handle_t  handle;
4798     apc_param_t   ckey;
4799     obj_handle_t  chandle;
4800     char __pad_28[4];
4801 };
4802 struct set_completion_info_reply
4803 {
4804     struct reply_header __header;
4805 };
4806
4807
4808
4809 struct add_fd_completion_request
4810 {
4811     struct request_header __header;
4812     obj_handle_t   handle;
4813     apc_param_t    cvalue;
4814     unsigned int   status;
4815     unsigned int   information;
4816 };
4817 struct add_fd_completion_reply
4818 {
4819     struct reply_header __header;
4820 };
4821
4822
4823
4824 struct get_window_layered_info_request
4825 {
4826     struct request_header __header;
4827     user_handle_t  handle;
4828 };
4829 struct get_window_layered_info_reply
4830 {
4831     struct reply_header __header;
4832     unsigned int   color_key;
4833     unsigned int   alpha;
4834     unsigned int   flags;
4835     char __pad_20[4];
4836 };
4837
4838
4839
4840 struct set_window_layered_info_request
4841 {
4842     struct request_header __header;
4843     user_handle_t  handle;
4844     unsigned int   color_key;
4845     unsigned int   alpha;
4846     unsigned int   flags;
4847     char __pad_28[4];
4848 };
4849 struct set_window_layered_info_reply
4850 {
4851     struct reply_header __header;
4852 };
4853
4854
4855
4856 struct alloc_user_handle_request
4857 {
4858     struct request_header __header;
4859     char __pad_12[4];
4860 };
4861 struct alloc_user_handle_reply
4862 {
4863     struct reply_header __header;
4864     user_handle_t  handle;
4865     char __pad_12[4];
4866 };
4867
4868
4869
4870 struct free_user_handle_request
4871 {
4872     struct request_header __header;
4873     user_handle_t  handle;
4874 };
4875 struct free_user_handle_reply
4876 {
4877     struct reply_header __header;
4878 };
4879
4880
4881
4882 struct set_cursor_request
4883 {
4884     struct request_header __header;
4885     unsigned int   flags;
4886     user_handle_t  handle;
4887     int            show_count;
4888     int            x;
4889     int            y;
4890     rectangle_t    clip;
4891     unsigned int   clip_msg;
4892     char __pad_52[4];
4893 };
4894 struct set_cursor_reply
4895 {
4896     struct reply_header __header;
4897     user_handle_t  prev_handle;
4898     int            prev_count;
4899     int            prev_x;
4900     int            prev_y;
4901     int            new_x;
4902     int            new_y;
4903     rectangle_t    new_clip;
4904     unsigned int   last_change;
4905     char __pad_52[4];
4906 };
4907 #define SET_CURSOR_HANDLE 0x01
4908 #define SET_CURSOR_COUNT  0x02
4909 #define SET_CURSOR_POS    0x04
4910 #define SET_CURSOR_CLIP   0x08
4911 #define SET_CURSOR_NOCLIP 0x10
4912
4913
4914
4915 struct update_rawinput_devices_request
4916 {
4917     struct request_header __header;
4918     /* VARARG(devices,rawinput_devices); */
4919     char __pad_12[4];
4920 };
4921 struct update_rawinput_devices_reply
4922 {
4923     struct reply_header __header;
4924 };
4925
4926
4927
4928 struct get_suspend_context_request
4929 {
4930     struct request_header __header;
4931     char __pad_12[4];
4932 };
4933 struct get_suspend_context_reply
4934 {
4935     struct reply_header __header;
4936     /* VARARG(context,context); */
4937 };
4938
4939
4940
4941 struct set_suspend_context_request
4942 {
4943     struct request_header __header;
4944     /* VARARG(context,context); */
4945     char __pad_12[4];
4946 };
4947 struct set_suspend_context_reply
4948 {
4949     struct reply_header __header;
4950 };
4951
4952
4953 enum request
4954 {
4955     REQ_new_process,
4956     REQ_get_new_process_info,
4957     REQ_new_thread,
4958     REQ_get_startup_info,
4959     REQ_init_process_done,
4960     REQ_init_thread,
4961     REQ_terminate_process,
4962     REQ_terminate_thread,
4963     REQ_get_process_info,
4964     REQ_set_process_info,
4965     REQ_get_thread_info,
4966     REQ_set_thread_info,
4967     REQ_get_dll_info,
4968     REQ_suspend_thread,
4969     REQ_resume_thread,
4970     REQ_load_dll,
4971     REQ_unload_dll,
4972     REQ_queue_apc,
4973     REQ_get_apc_result,
4974     REQ_close_handle,
4975     REQ_set_handle_info,
4976     REQ_dup_handle,
4977     REQ_open_process,
4978     REQ_open_thread,
4979     REQ_select,
4980     REQ_create_event,
4981     REQ_event_op,
4982     REQ_open_event,
4983     REQ_create_mutex,
4984     REQ_release_mutex,
4985     REQ_open_mutex,
4986     REQ_create_semaphore,
4987     REQ_release_semaphore,
4988     REQ_open_semaphore,
4989     REQ_create_file,
4990     REQ_open_file_object,
4991     REQ_alloc_file_handle,
4992     REQ_get_handle_unix_name,
4993     REQ_get_handle_fd,
4994     REQ_flush_file,
4995     REQ_lock_file,
4996     REQ_unlock_file,
4997     REQ_create_socket,
4998     REQ_accept_socket,
4999     REQ_accept_into_socket,
5000     REQ_set_socket_event,
5001     REQ_get_socket_event,
5002     REQ_enable_socket_event,
5003     REQ_set_socket_deferred,
5004     REQ_alloc_console,
5005     REQ_free_console,
5006     REQ_get_console_renderer_events,
5007     REQ_open_console,
5008     REQ_get_console_wait_event,
5009     REQ_get_console_mode,
5010     REQ_set_console_mode,
5011     REQ_set_console_input_info,
5012     REQ_get_console_input_info,
5013     REQ_append_console_input_history,
5014     REQ_get_console_input_history,
5015     REQ_create_console_output,
5016     REQ_set_console_output_info,
5017     REQ_get_console_output_info,
5018     REQ_write_console_input,
5019     REQ_read_console_input,
5020     REQ_write_console_output,
5021     REQ_fill_console_output,
5022     REQ_read_console_output,
5023     REQ_move_console_output,
5024     REQ_send_console_signal,
5025     REQ_read_directory_changes,
5026     REQ_read_change,
5027     REQ_create_mapping,
5028     REQ_open_mapping,
5029     REQ_get_mapping_info,
5030     REQ_get_mapping_committed_range,
5031     REQ_add_mapping_committed_range,
5032     REQ_create_snapshot,
5033     REQ_next_process,
5034     REQ_next_thread,
5035     REQ_wait_debug_event,
5036     REQ_queue_exception_event,
5037     REQ_get_exception_status,
5038     REQ_output_debug_string,
5039     REQ_continue_debug_event,
5040     REQ_debug_process,
5041     REQ_debug_break,
5042     REQ_set_debugger_kill_on_exit,
5043     REQ_read_process_memory,
5044     REQ_write_process_memory,
5045     REQ_create_key,
5046     REQ_open_key,
5047     REQ_delete_key,
5048     REQ_flush_key,
5049     REQ_enum_key,
5050     REQ_set_key_value,
5051     REQ_get_key_value,
5052     REQ_enum_key_value,
5053     REQ_delete_key_value,
5054     REQ_load_registry,
5055     REQ_unload_registry,
5056     REQ_save_registry,
5057     REQ_set_registry_notification,
5058     REQ_create_timer,
5059     REQ_open_timer,
5060     REQ_set_timer,
5061     REQ_cancel_timer,
5062     REQ_get_timer_info,
5063     REQ_get_thread_context,
5064     REQ_set_thread_context,
5065     REQ_get_selector_entry,
5066     REQ_add_atom,
5067     REQ_delete_atom,
5068     REQ_find_atom,
5069     REQ_get_atom_information,
5070     REQ_set_atom_information,
5071     REQ_empty_atom_table,
5072     REQ_init_atom_table,
5073     REQ_get_msg_queue,
5074     REQ_set_queue_fd,
5075     REQ_set_queue_mask,
5076     REQ_get_queue_status,
5077     REQ_get_process_idle_event,
5078     REQ_send_message,
5079     REQ_post_quit_message,
5080     REQ_send_hardware_message,
5081     REQ_get_message,
5082     REQ_reply_message,
5083     REQ_accept_hardware_message,
5084     REQ_get_message_reply,
5085     REQ_set_win_timer,
5086     REQ_kill_win_timer,
5087     REQ_is_window_hung,
5088     REQ_get_serial_info,
5089     REQ_set_serial_info,
5090     REQ_register_async,
5091     REQ_cancel_async,
5092     REQ_ioctl,
5093     REQ_get_ioctl_result,
5094     REQ_create_named_pipe,
5095     REQ_get_named_pipe_info,
5096     REQ_create_window,
5097     REQ_destroy_window,
5098     REQ_get_desktop_window,
5099     REQ_set_window_owner,
5100     REQ_get_window_info,
5101     REQ_set_window_info,
5102     REQ_set_parent,
5103     REQ_get_window_parents,
5104     REQ_get_window_children,
5105     REQ_get_window_children_from_point,
5106     REQ_get_window_tree,
5107     REQ_set_window_pos,
5108     REQ_get_window_rectangles,
5109     REQ_get_window_text,
5110     REQ_set_window_text,
5111     REQ_get_windows_offset,
5112     REQ_get_visible_region,
5113     REQ_get_surface_region,
5114     REQ_get_window_region,
5115     REQ_set_window_region,
5116     REQ_get_update_region,
5117     REQ_update_window_zorder,
5118     REQ_redraw_window,
5119     REQ_set_window_property,
5120     REQ_remove_window_property,
5121     REQ_get_window_property,
5122     REQ_get_window_properties,
5123     REQ_create_winstation,
5124     REQ_open_winstation,
5125     REQ_close_winstation,
5126     REQ_get_process_winstation,
5127     REQ_set_process_winstation,
5128     REQ_enum_winstation,
5129     REQ_create_desktop,
5130     REQ_open_desktop,
5131     REQ_close_desktop,
5132     REQ_get_thread_desktop,
5133     REQ_set_thread_desktop,
5134     REQ_enum_desktop,
5135     REQ_set_user_object_info,
5136     REQ_register_hotkey,
5137     REQ_unregister_hotkey,
5138     REQ_attach_thread_input,
5139     REQ_get_thread_input,
5140     REQ_get_last_input_time,
5141     REQ_get_key_state,
5142     REQ_set_key_state,
5143     REQ_set_foreground_window,
5144     REQ_set_focus_window,
5145     REQ_set_active_window,
5146     REQ_set_capture_window,
5147     REQ_set_caret_window,
5148     REQ_set_caret_info,
5149     REQ_set_hook,
5150     REQ_remove_hook,
5151     REQ_start_hook_chain,
5152     REQ_finish_hook_chain,
5153     REQ_get_hook_info,
5154     REQ_create_class,
5155     REQ_destroy_class,
5156     REQ_set_class_info,
5157     REQ_set_clipboard_info,
5158     REQ_open_token,
5159     REQ_set_global_windows,
5160     REQ_adjust_token_privileges,
5161     REQ_get_token_privileges,
5162     REQ_check_token_privileges,
5163     REQ_duplicate_token,
5164     REQ_access_check,
5165     REQ_get_token_sid,
5166     REQ_get_token_groups,
5167     REQ_get_token_default_dacl,
5168     REQ_set_token_default_dacl,
5169     REQ_set_security_object,
5170     REQ_get_security_object,
5171     REQ_create_mailslot,
5172     REQ_set_mailslot_info,
5173     REQ_create_directory,
5174     REQ_open_directory,
5175     REQ_get_directory_entry,
5176     REQ_create_symlink,
5177     REQ_open_symlink,
5178     REQ_query_symlink,
5179     REQ_get_object_info,
5180     REQ_unlink_object,
5181     REQ_get_token_impersonation_level,
5182     REQ_allocate_locally_unique_id,
5183     REQ_create_device_manager,
5184     REQ_create_device,
5185     REQ_delete_device,
5186     REQ_get_next_device_request,
5187     REQ_make_process_system,
5188     REQ_get_token_statistics,
5189     REQ_create_completion,
5190     REQ_open_completion,
5191     REQ_add_completion,
5192     REQ_remove_completion,
5193     REQ_query_completion,
5194     REQ_set_completion_info,
5195     REQ_add_fd_completion,
5196     REQ_get_window_layered_info,
5197     REQ_set_window_layered_info,
5198     REQ_alloc_user_handle,
5199     REQ_free_user_handle,
5200     REQ_set_cursor,
5201     REQ_update_rawinput_devices,
5202     REQ_get_suspend_context,
5203     REQ_set_suspend_context,
5204     REQ_NB_REQUESTS
5205 };
5206
5207 union generic_request
5208 {
5209     struct request_max_size max_size;
5210     struct request_header request_header;
5211     struct new_process_request new_process_request;
5212     struct get_new_process_info_request get_new_process_info_request;
5213     struct new_thread_request new_thread_request;
5214     struct get_startup_info_request get_startup_info_request;
5215     struct init_process_done_request init_process_done_request;
5216     struct init_thread_request init_thread_request;
5217     struct terminate_process_request terminate_process_request;
5218     struct terminate_thread_request terminate_thread_request;
5219     struct get_process_info_request get_process_info_request;
5220     struct set_process_info_request set_process_info_request;
5221     struct get_thread_info_request get_thread_info_request;
5222     struct set_thread_info_request set_thread_info_request;
5223     struct get_dll_info_request get_dll_info_request;
5224     struct suspend_thread_request suspend_thread_request;
5225     struct resume_thread_request resume_thread_request;
5226     struct load_dll_request load_dll_request;
5227     struct unload_dll_request unload_dll_request;
5228     struct queue_apc_request queue_apc_request;
5229     struct get_apc_result_request get_apc_result_request;
5230     struct close_handle_request close_handle_request;
5231     struct set_handle_info_request set_handle_info_request;
5232     struct dup_handle_request dup_handle_request;
5233     struct open_process_request open_process_request;
5234     struct open_thread_request open_thread_request;
5235     struct select_request select_request;
5236     struct create_event_request create_event_request;
5237     struct event_op_request event_op_request;
5238     struct open_event_request open_event_request;
5239     struct create_mutex_request create_mutex_request;
5240     struct release_mutex_request release_mutex_request;
5241     struct open_mutex_request open_mutex_request;
5242     struct create_semaphore_request create_semaphore_request;
5243     struct release_semaphore_request release_semaphore_request;
5244     struct open_semaphore_request open_semaphore_request;
5245     struct create_file_request create_file_request;
5246     struct open_file_object_request open_file_object_request;
5247     struct alloc_file_handle_request alloc_file_handle_request;
5248     struct get_handle_unix_name_request get_handle_unix_name_request;
5249     struct get_handle_fd_request get_handle_fd_request;
5250     struct flush_file_request flush_file_request;
5251     struct lock_file_request lock_file_request;
5252     struct unlock_file_request unlock_file_request;
5253     struct create_socket_request create_socket_request;
5254     struct accept_socket_request accept_socket_request;
5255     struct accept_into_socket_request accept_into_socket_request;
5256     struct set_socket_event_request set_socket_event_request;
5257     struct get_socket_event_request get_socket_event_request;
5258     struct enable_socket_event_request enable_socket_event_request;
5259     struct set_socket_deferred_request set_socket_deferred_request;
5260     struct alloc_console_request alloc_console_request;
5261     struct free_console_request free_console_request;
5262     struct get_console_renderer_events_request get_console_renderer_events_request;
5263     struct open_console_request open_console_request;
5264     struct get_console_wait_event_request get_console_wait_event_request;
5265     struct get_console_mode_request get_console_mode_request;
5266     struct set_console_mode_request set_console_mode_request;
5267     struct set_console_input_info_request set_console_input_info_request;
5268     struct get_console_input_info_request get_console_input_info_request;
5269     struct append_console_input_history_request append_console_input_history_request;
5270     struct get_console_input_history_request get_console_input_history_request;
5271     struct create_console_output_request create_console_output_request;
5272     struct set_console_output_info_request set_console_output_info_request;
5273     struct get_console_output_info_request get_console_output_info_request;
5274     struct write_console_input_request write_console_input_request;
5275     struct read_console_input_request read_console_input_request;
5276     struct write_console_output_request write_console_output_request;
5277     struct fill_console_output_request fill_console_output_request;
5278     struct read_console_output_request read_console_output_request;
5279     struct move_console_output_request move_console_output_request;
5280     struct send_console_signal_request send_console_signal_request;
5281     struct read_directory_changes_request read_directory_changes_request;
5282     struct read_change_request read_change_request;
5283     struct create_mapping_request create_mapping_request;
5284     struct open_mapping_request open_mapping_request;
5285     struct get_mapping_info_request get_mapping_info_request;
5286     struct get_mapping_committed_range_request get_mapping_committed_range_request;
5287     struct add_mapping_committed_range_request add_mapping_committed_range_request;
5288     struct create_snapshot_request create_snapshot_request;
5289     struct next_process_request next_process_request;
5290     struct next_thread_request next_thread_request;
5291     struct wait_debug_event_request wait_debug_event_request;
5292     struct queue_exception_event_request queue_exception_event_request;
5293     struct get_exception_status_request get_exception_status_request;
5294     struct output_debug_string_request output_debug_string_request;
5295     struct continue_debug_event_request continue_debug_event_request;
5296     struct debug_process_request debug_process_request;
5297     struct debug_break_request debug_break_request;
5298     struct set_debugger_kill_on_exit_request set_debugger_kill_on_exit_request;
5299     struct read_process_memory_request read_process_memory_request;
5300     struct write_process_memory_request write_process_memory_request;
5301     struct create_key_request create_key_request;
5302     struct open_key_request open_key_request;
5303     struct delete_key_request delete_key_request;
5304     struct flush_key_request flush_key_request;
5305     struct enum_key_request enum_key_request;
5306     struct set_key_value_request set_key_value_request;
5307     struct get_key_value_request get_key_value_request;
5308     struct enum_key_value_request enum_key_value_request;
5309     struct delete_key_value_request delete_key_value_request;
5310     struct load_registry_request load_registry_request;
5311     struct unload_registry_request unload_registry_request;
5312     struct save_registry_request save_registry_request;
5313     struct set_registry_notification_request set_registry_notification_request;
5314     struct create_timer_request create_timer_request;
5315     struct open_timer_request open_timer_request;
5316     struct set_timer_request set_timer_request;
5317     struct cancel_timer_request cancel_timer_request;
5318     struct get_timer_info_request get_timer_info_request;
5319     struct get_thread_context_request get_thread_context_request;
5320     struct set_thread_context_request set_thread_context_request;
5321     struct get_selector_entry_request get_selector_entry_request;
5322     struct add_atom_request add_atom_request;
5323     struct delete_atom_request delete_atom_request;
5324     struct find_atom_request find_atom_request;
5325     struct get_atom_information_request get_atom_information_request;
5326     struct set_atom_information_request set_atom_information_request;
5327     struct empty_atom_table_request empty_atom_table_request;
5328     struct init_atom_table_request init_atom_table_request;
5329     struct get_msg_queue_request get_msg_queue_request;
5330     struct set_queue_fd_request set_queue_fd_request;
5331     struct set_queue_mask_request set_queue_mask_request;
5332     struct get_queue_status_request get_queue_status_request;
5333     struct get_process_idle_event_request get_process_idle_event_request;
5334     struct send_message_request send_message_request;
5335     struct post_quit_message_request post_quit_message_request;
5336     struct send_hardware_message_request send_hardware_message_request;
5337     struct get_message_request get_message_request;
5338     struct reply_message_request reply_message_request;
5339     struct accept_hardware_message_request accept_hardware_message_request;
5340     struct get_message_reply_request get_message_reply_request;
5341     struct set_win_timer_request set_win_timer_request;
5342     struct kill_win_timer_request kill_win_timer_request;
5343     struct is_window_hung_request is_window_hung_request;
5344     struct get_serial_info_request get_serial_info_request;
5345     struct set_serial_info_request set_serial_info_request;
5346     struct register_async_request register_async_request;
5347     struct cancel_async_request cancel_async_request;
5348     struct ioctl_request ioctl_request;
5349     struct get_ioctl_result_request get_ioctl_result_request;
5350     struct create_named_pipe_request create_named_pipe_request;
5351     struct get_named_pipe_info_request get_named_pipe_info_request;
5352     struct create_window_request create_window_request;
5353     struct destroy_window_request destroy_window_request;
5354     struct get_desktop_window_request get_desktop_window_request;
5355     struct set_window_owner_request set_window_owner_request;
5356     struct get_window_info_request get_window_info_request;
5357     struct set_window_info_request set_window_info_request;
5358     struct set_parent_request set_parent_request;
5359     struct get_window_parents_request get_window_parents_request;
5360     struct get_window_children_request get_window_children_request;
5361     struct get_window_children_from_point_request get_window_children_from_point_request;
5362     struct get_window_tree_request get_window_tree_request;
5363     struct set_window_pos_request set_window_pos_request;
5364     struct get_window_rectangles_request get_window_rectangles_request;
5365     struct get_window_text_request get_window_text_request;
5366     struct set_window_text_request set_window_text_request;
5367     struct get_windows_offset_request get_windows_offset_request;
5368     struct get_visible_region_request get_visible_region_request;
5369     struct get_surface_region_request get_surface_region_request;
5370     struct get_window_region_request get_window_region_request;
5371     struct set_window_region_request set_window_region_request;
5372     struct get_update_region_request get_update_region_request;
5373     struct update_window_zorder_request update_window_zorder_request;
5374     struct redraw_window_request redraw_window_request;
5375     struct set_window_property_request set_window_property_request;
5376     struct remove_window_property_request remove_window_property_request;
5377     struct get_window_property_request get_window_property_request;
5378     struct get_window_properties_request get_window_properties_request;
5379     struct create_winstation_request create_winstation_request;
5380     struct open_winstation_request open_winstation_request;
5381     struct close_winstation_request close_winstation_request;
5382     struct get_process_winstation_request get_process_winstation_request;
5383     struct set_process_winstation_request set_process_winstation_request;
5384     struct enum_winstation_request enum_winstation_request;
5385     struct create_desktop_request create_desktop_request;
5386     struct open_desktop_request open_desktop_request;
5387     struct close_desktop_request close_desktop_request;
5388     struct get_thread_desktop_request get_thread_desktop_request;
5389     struct set_thread_desktop_request set_thread_desktop_request;
5390     struct enum_desktop_request enum_desktop_request;
5391     struct set_user_object_info_request set_user_object_info_request;
5392     struct register_hotkey_request register_hotkey_request;
5393     struct unregister_hotkey_request unregister_hotkey_request;
5394     struct attach_thread_input_request attach_thread_input_request;
5395     struct get_thread_input_request get_thread_input_request;
5396     struct get_last_input_time_request get_last_input_time_request;
5397     struct get_key_state_request get_key_state_request;
5398     struct set_key_state_request set_key_state_request;
5399     struct set_foreground_window_request set_foreground_window_request;
5400     struct set_focus_window_request set_focus_window_request;
5401     struct set_active_window_request set_active_window_request;
5402     struct set_capture_window_request set_capture_window_request;
5403     struct set_caret_window_request set_caret_window_request;
5404     struct set_caret_info_request set_caret_info_request;
5405     struct set_hook_request set_hook_request;
5406     struct remove_hook_request remove_hook_request;
5407     struct start_hook_chain_request start_hook_chain_request;
5408     struct finish_hook_chain_request finish_hook_chain_request;
5409     struct get_hook_info_request get_hook_info_request;
5410     struct create_class_request create_class_request;
5411     struct destroy_class_request destroy_class_request;
5412     struct set_class_info_request set_class_info_request;
5413     struct set_clipboard_info_request set_clipboard_info_request;
5414     struct open_token_request open_token_request;
5415     struct set_global_windows_request set_global_windows_request;
5416     struct adjust_token_privileges_request adjust_token_privileges_request;
5417     struct get_token_privileges_request get_token_privileges_request;
5418     struct check_token_privileges_request check_token_privileges_request;
5419     struct duplicate_token_request duplicate_token_request;
5420     struct access_check_request access_check_request;
5421     struct get_token_sid_request get_token_sid_request;
5422     struct get_token_groups_request get_token_groups_request;
5423     struct get_token_default_dacl_request get_token_default_dacl_request;
5424     struct set_token_default_dacl_request set_token_default_dacl_request;
5425     struct set_security_object_request set_security_object_request;
5426     struct get_security_object_request get_security_object_request;
5427     struct create_mailslot_request create_mailslot_request;
5428     struct set_mailslot_info_request set_mailslot_info_request;
5429     struct create_directory_request create_directory_request;
5430     struct open_directory_request open_directory_request;
5431     struct get_directory_entry_request get_directory_entry_request;
5432     struct create_symlink_request create_symlink_request;
5433     struct open_symlink_request open_symlink_request;
5434     struct query_symlink_request query_symlink_request;
5435     struct get_object_info_request get_object_info_request;
5436     struct unlink_object_request unlink_object_request;
5437     struct get_token_impersonation_level_request get_token_impersonation_level_request;
5438     struct allocate_locally_unique_id_request allocate_locally_unique_id_request;
5439     struct create_device_manager_request create_device_manager_request;
5440     struct create_device_request create_device_request;
5441     struct delete_device_request delete_device_request;
5442     struct get_next_device_request_request get_next_device_request_request;
5443     struct make_process_system_request make_process_system_request;
5444     struct get_token_statistics_request get_token_statistics_request;
5445     struct create_completion_request create_completion_request;
5446     struct open_completion_request open_completion_request;
5447     struct add_completion_request add_completion_request;
5448     struct remove_completion_request remove_completion_request;
5449     struct query_completion_request query_completion_request;
5450     struct set_completion_info_request set_completion_info_request;
5451     struct add_fd_completion_request add_fd_completion_request;
5452     struct get_window_layered_info_request get_window_layered_info_request;
5453     struct set_window_layered_info_request set_window_layered_info_request;
5454     struct alloc_user_handle_request alloc_user_handle_request;
5455     struct free_user_handle_request free_user_handle_request;
5456     struct set_cursor_request set_cursor_request;
5457     struct update_rawinput_devices_request update_rawinput_devices_request;
5458     struct get_suspend_context_request get_suspend_context_request;
5459     struct set_suspend_context_request set_suspend_context_request;
5460 };
5461 union generic_reply
5462 {
5463     struct request_max_size max_size;
5464     struct reply_header reply_header;
5465     struct new_process_reply new_process_reply;
5466     struct get_new_process_info_reply get_new_process_info_reply;
5467     struct new_thread_reply new_thread_reply;
5468     struct get_startup_info_reply get_startup_info_reply;
5469     struct init_process_done_reply init_process_done_reply;
5470     struct init_thread_reply init_thread_reply;
5471     struct terminate_process_reply terminate_process_reply;
5472     struct terminate_thread_reply terminate_thread_reply;
5473     struct get_process_info_reply get_process_info_reply;
5474     struct set_process_info_reply set_process_info_reply;
5475     struct get_thread_info_reply get_thread_info_reply;
5476     struct set_thread_info_reply set_thread_info_reply;
5477     struct get_dll_info_reply get_dll_info_reply;
5478     struct suspend_thread_reply suspend_thread_reply;
5479     struct resume_thread_reply resume_thread_reply;
5480     struct load_dll_reply load_dll_reply;
5481     struct unload_dll_reply unload_dll_reply;
5482     struct queue_apc_reply queue_apc_reply;
5483     struct get_apc_result_reply get_apc_result_reply;
5484     struct close_handle_reply close_handle_reply;
5485     struct set_handle_info_reply set_handle_info_reply;
5486     struct dup_handle_reply dup_handle_reply;
5487     struct open_process_reply open_process_reply;
5488     struct open_thread_reply open_thread_reply;
5489     struct select_reply select_reply;
5490     struct create_event_reply create_event_reply;
5491     struct event_op_reply event_op_reply;
5492     struct open_event_reply open_event_reply;
5493     struct create_mutex_reply create_mutex_reply;
5494     struct release_mutex_reply release_mutex_reply;
5495     struct open_mutex_reply open_mutex_reply;
5496     struct create_semaphore_reply create_semaphore_reply;
5497     struct release_semaphore_reply release_semaphore_reply;
5498     struct open_semaphore_reply open_semaphore_reply;
5499     struct create_file_reply create_file_reply;
5500     struct open_file_object_reply open_file_object_reply;
5501     struct alloc_file_handle_reply alloc_file_handle_reply;
5502     struct get_handle_unix_name_reply get_handle_unix_name_reply;
5503     struct get_handle_fd_reply get_handle_fd_reply;
5504     struct flush_file_reply flush_file_reply;
5505     struct lock_file_reply lock_file_reply;
5506     struct unlock_file_reply unlock_file_reply;
5507     struct create_socket_reply create_socket_reply;
5508     struct accept_socket_reply accept_socket_reply;
5509     struct accept_into_socket_reply accept_into_socket_reply;
5510     struct set_socket_event_reply set_socket_event_reply;
5511     struct get_socket_event_reply get_socket_event_reply;
5512     struct enable_socket_event_reply enable_socket_event_reply;
5513     struct set_socket_deferred_reply set_socket_deferred_reply;
5514     struct alloc_console_reply alloc_console_reply;
5515     struct free_console_reply free_console_reply;
5516     struct get_console_renderer_events_reply get_console_renderer_events_reply;
5517     struct open_console_reply open_console_reply;
5518     struct get_console_wait_event_reply get_console_wait_event_reply;
5519     struct get_console_mode_reply get_console_mode_reply;
5520     struct set_console_mode_reply set_console_mode_reply;
5521     struct set_console_input_info_reply set_console_input_info_reply;
5522     struct get_console_input_info_reply get_console_input_info_reply;
5523     struct append_console_input_history_reply append_console_input_history_reply;
5524     struct get_console_input_history_reply get_console_input_history_reply;
5525     struct create_console_output_reply create_console_output_reply;
5526     struct set_console_output_info_reply set_console_output_info_reply;
5527     struct get_console_output_info_reply get_console_output_info_reply;
5528     struct write_console_input_reply write_console_input_reply;
5529     struct read_console_input_reply read_console_input_reply;
5530     struct write_console_output_reply write_console_output_reply;
5531     struct fill_console_output_reply fill_console_output_reply;
5532     struct read_console_output_reply read_console_output_reply;
5533     struct move_console_output_reply move_console_output_reply;
5534     struct send_console_signal_reply send_console_signal_reply;
5535     struct read_directory_changes_reply read_directory_changes_reply;
5536     struct read_change_reply read_change_reply;
5537     struct create_mapping_reply create_mapping_reply;
5538     struct open_mapping_reply open_mapping_reply;
5539     struct get_mapping_info_reply get_mapping_info_reply;
5540     struct get_mapping_committed_range_reply get_mapping_committed_range_reply;
5541     struct add_mapping_committed_range_reply add_mapping_committed_range_reply;
5542     struct create_snapshot_reply create_snapshot_reply;
5543     struct next_process_reply next_process_reply;
5544     struct next_thread_reply next_thread_reply;
5545     struct wait_debug_event_reply wait_debug_event_reply;
5546     struct queue_exception_event_reply queue_exception_event_reply;
5547     struct get_exception_status_reply get_exception_status_reply;
5548     struct output_debug_string_reply output_debug_string_reply;
5549     struct continue_debug_event_reply continue_debug_event_reply;
5550     struct debug_process_reply debug_process_reply;
5551     struct debug_break_reply debug_break_reply;
5552     struct set_debugger_kill_on_exit_reply set_debugger_kill_on_exit_reply;
5553     struct read_process_memory_reply read_process_memory_reply;
5554     struct write_process_memory_reply write_process_memory_reply;
5555     struct create_key_reply create_key_reply;
5556     struct open_key_reply open_key_reply;
5557     struct delete_key_reply delete_key_reply;
5558     struct flush_key_reply flush_key_reply;
5559     struct enum_key_reply enum_key_reply;
5560     struct set_key_value_reply set_key_value_reply;
5561     struct get_key_value_reply get_key_value_reply;
5562     struct enum_key_value_reply enum_key_value_reply;
5563     struct delete_key_value_reply delete_key_value_reply;
5564     struct load_registry_reply load_registry_reply;
5565     struct unload_registry_reply unload_registry_reply;
5566     struct save_registry_reply save_registry_reply;
5567     struct set_registry_notification_reply set_registry_notification_reply;
5568     struct create_timer_reply create_timer_reply;
5569     struct open_timer_reply open_timer_reply;
5570     struct set_timer_reply set_timer_reply;
5571     struct cancel_timer_reply cancel_timer_reply;
5572     struct get_timer_info_reply get_timer_info_reply;
5573     struct get_thread_context_reply get_thread_context_reply;
5574     struct set_thread_context_reply set_thread_context_reply;
5575     struct get_selector_entry_reply get_selector_entry_reply;
5576     struct add_atom_reply add_atom_reply;
5577     struct delete_atom_reply delete_atom_reply;
5578     struct find_atom_reply find_atom_reply;
5579     struct get_atom_information_reply get_atom_information_reply;
5580     struct set_atom_information_reply set_atom_information_reply;
5581     struct empty_atom_table_reply empty_atom_table_reply;
5582     struct init_atom_table_reply init_atom_table_reply;
5583     struct get_msg_queue_reply get_msg_queue_reply;
5584     struct set_queue_fd_reply set_queue_fd_reply;
5585     struct set_queue_mask_reply set_queue_mask_reply;
5586     struct get_queue_status_reply get_queue_status_reply;
5587     struct get_process_idle_event_reply get_process_idle_event_reply;
5588     struct send_message_reply send_message_reply;
5589     struct post_quit_message_reply post_quit_message_reply;
5590     struct send_hardware_message_reply send_hardware_message_reply;
5591     struct get_message_reply get_message_reply;
5592     struct reply_message_reply reply_message_reply;
5593     struct accept_hardware_message_reply accept_hardware_message_reply;
5594     struct get_message_reply_reply get_message_reply_reply;
5595     struct set_win_timer_reply set_win_timer_reply;
5596     struct kill_win_timer_reply kill_win_timer_reply;
5597     struct is_window_hung_reply is_window_hung_reply;
5598     struct get_serial_info_reply get_serial_info_reply;
5599     struct set_serial_info_reply set_serial_info_reply;
5600     struct register_async_reply register_async_reply;
5601     struct cancel_async_reply cancel_async_reply;
5602     struct ioctl_reply ioctl_reply;
5603     struct get_ioctl_result_reply get_ioctl_result_reply;
5604     struct create_named_pipe_reply create_named_pipe_reply;
5605     struct get_named_pipe_info_reply get_named_pipe_info_reply;
5606     struct create_window_reply create_window_reply;
5607     struct destroy_window_reply destroy_window_reply;
5608     struct get_desktop_window_reply get_desktop_window_reply;
5609     struct set_window_owner_reply set_window_owner_reply;
5610     struct get_window_info_reply get_window_info_reply;
5611     struct set_window_info_reply set_window_info_reply;
5612     struct set_parent_reply set_parent_reply;
5613     struct get_window_parents_reply get_window_parents_reply;
5614     struct get_window_children_reply get_window_children_reply;
5615     struct get_window_children_from_point_reply get_window_children_from_point_reply;
5616     struct get_window_tree_reply get_window_tree_reply;
5617     struct set_window_pos_reply set_window_pos_reply;
5618     struct get_window_rectangles_reply get_window_rectangles_reply;
5619     struct get_window_text_reply get_window_text_reply;
5620     struct set_window_text_reply set_window_text_reply;
5621     struct get_windows_offset_reply get_windows_offset_reply;
5622     struct get_visible_region_reply get_visible_region_reply;
5623     struct get_surface_region_reply get_surface_region_reply;
5624     struct get_window_region_reply get_window_region_reply;
5625     struct set_window_region_reply set_window_region_reply;
5626     struct get_update_region_reply get_update_region_reply;
5627     struct update_window_zorder_reply update_window_zorder_reply;
5628     struct redraw_window_reply redraw_window_reply;
5629     struct set_window_property_reply set_window_property_reply;
5630     struct remove_window_property_reply remove_window_property_reply;
5631     struct get_window_property_reply get_window_property_reply;
5632     struct get_window_properties_reply get_window_properties_reply;
5633     struct create_winstation_reply create_winstation_reply;
5634     struct open_winstation_reply open_winstation_reply;
5635     struct close_winstation_reply close_winstation_reply;
5636     struct get_process_winstation_reply get_process_winstation_reply;
5637     struct set_process_winstation_reply set_process_winstation_reply;
5638     struct enum_winstation_reply enum_winstation_reply;
5639     struct create_desktop_reply create_desktop_reply;
5640     struct open_desktop_reply open_desktop_reply;
5641     struct close_desktop_reply close_desktop_reply;
5642     struct get_thread_desktop_reply get_thread_desktop_reply;
5643     struct set_thread_desktop_reply set_thread_desktop_reply;
5644     struct enum_desktop_reply enum_desktop_reply;
5645     struct set_user_object_info_reply set_user_object_info_reply;
5646     struct register_hotkey_reply register_hotkey_reply;
5647     struct unregister_hotkey_reply unregister_hotkey_reply;
5648     struct attach_thread_input_reply attach_thread_input_reply;
5649     struct get_thread_input_reply get_thread_input_reply;
5650     struct get_last_input_time_reply get_last_input_time_reply;
5651     struct get_key_state_reply get_key_state_reply;
5652     struct set_key_state_reply set_key_state_reply;
5653     struct set_foreground_window_reply set_foreground_window_reply;
5654     struct set_focus_window_reply set_focus_window_reply;
5655     struct set_active_window_reply set_active_window_reply;
5656     struct set_capture_window_reply set_capture_window_reply;
5657     struct set_caret_window_reply set_caret_window_reply;
5658     struct set_caret_info_reply set_caret_info_reply;
5659     struct set_hook_reply set_hook_reply;
5660     struct remove_hook_reply remove_hook_reply;
5661     struct start_hook_chain_reply start_hook_chain_reply;
5662     struct finish_hook_chain_reply finish_hook_chain_reply;
5663     struct get_hook_info_reply get_hook_info_reply;
5664     struct create_class_reply create_class_reply;
5665     struct destroy_class_reply destroy_class_reply;
5666     struct set_class_info_reply set_class_info_reply;
5667     struct set_clipboard_info_reply set_clipboard_info_reply;
5668     struct open_token_reply open_token_reply;
5669     struct set_global_windows_reply set_global_windows_reply;
5670     struct adjust_token_privileges_reply adjust_token_privileges_reply;
5671     struct get_token_privileges_reply get_token_privileges_reply;
5672     struct check_token_privileges_reply check_token_privileges_reply;
5673     struct duplicate_token_reply duplicate_token_reply;
5674     struct access_check_reply access_check_reply;
5675     struct get_token_sid_reply get_token_sid_reply;
5676     struct get_token_groups_reply get_token_groups_reply;
5677     struct get_token_default_dacl_reply get_token_default_dacl_reply;
5678     struct set_token_default_dacl_reply set_token_default_dacl_reply;
5679     struct set_security_object_reply set_security_object_reply;
5680     struct get_security_object_reply get_security_object_reply;
5681     struct create_mailslot_reply create_mailslot_reply;
5682     struct set_mailslot_info_reply set_mailslot_info_reply;
5683     struct create_directory_reply create_directory_reply;
5684     struct open_directory_reply open_directory_reply;
5685     struct get_directory_entry_reply get_directory_entry_reply;
5686     struct create_symlink_reply create_symlink_reply;
5687     struct open_symlink_reply open_symlink_reply;
5688     struct query_symlink_reply query_symlink_reply;
5689     struct get_object_info_reply get_object_info_reply;
5690     struct unlink_object_reply unlink_object_reply;
5691     struct get_token_impersonation_level_reply get_token_impersonation_level_reply;
5692     struct allocate_locally_unique_id_reply allocate_locally_unique_id_reply;
5693     struct create_device_manager_reply create_device_manager_reply;
5694     struct create_device_reply create_device_reply;
5695     struct delete_device_reply delete_device_reply;
5696     struct get_next_device_request_reply get_next_device_request_reply;
5697     struct make_process_system_reply make_process_system_reply;
5698     struct get_token_statistics_reply get_token_statistics_reply;
5699     struct create_completion_reply create_completion_reply;
5700     struct open_completion_reply open_completion_reply;
5701     struct add_completion_reply add_completion_reply;
5702     struct remove_completion_reply remove_completion_reply;
5703     struct query_completion_reply query_completion_reply;
5704     struct set_completion_info_reply set_completion_info_reply;
5705     struct add_fd_completion_reply add_fd_completion_reply;
5706     struct get_window_layered_info_reply get_window_layered_info_reply;
5707     struct set_window_layered_info_reply set_window_layered_info_reply;
5708     struct alloc_user_handle_reply alloc_user_handle_reply;
5709     struct free_user_handle_reply free_user_handle_reply;
5710     struct set_cursor_reply set_cursor_reply;
5711     struct update_rawinput_devices_reply update_rawinput_devices_reply;
5712     struct get_suspend_context_reply get_suspend_context_reply;
5713     struct set_suspend_context_reply set_suspend_context_reply;
5714 };
5715
5716 #define SERVER_PROTOCOL_VERSION 437
5717
5718 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */