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