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

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