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