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