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