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 struct request_header
  19 {
  20     int          req;
  21     size_t       request_size;
  22     size_t       reply_size;
  23 };
  24
  25 struct reply_header
  26 {
  27     unsigned int error;
  28     size_t       reply_size;
  29 };
  30
  31
  32
  33 struct request_max_size
  34 {
  35     int pad[16];
  36 };
  37
  38 typedef void *obj_handle_t;
  39 typedef void *user_handle_t;
  40 typedef unsigned short atom_t;
  41 typedef unsigned int process_id_t;
  42 typedef unsigned int thread_id_t;
  43
  44 #define FIRST_USER_HANDLE 0x0020
  45 #define LAST_USER_HANDLE  0xffef
  46
  47
  48
  49 struct debug_event_exception
  50 {
  51     EXCEPTION_RECORD record;
  52     int              first;
  53 };
  54 struct debug_event_create_thread
  55 {
  56     obj_handle_t handle;
  57     void        *teb;
  58     void        *start;
  59 };
  60 struct debug_event_create_process
  61 {
  62     obj_handle_t file;
  63     obj_handle_t process;
  64     obj_handle_t thread;
  65     void        *base;
  66     int          dbg_offset;
  67     int          dbg_size;
  68     void        *teb;
  69     void        *start;
  70     void        *name;
  71     int          unicode;
  72 };
  73 struct debug_event_exit
  74 {
  75     int          exit_code;
  76 };
  77 struct debug_event_load_dll
  78 {
  79     obj_handle_t handle;
  80     void        *base;
  81     int          dbg_offset;
  82     int          dbg_size;
  83     void        *name;
  84     int          unicode;
  85 };
  86 struct debug_event_unload_dll
  87 {
  88     void       *base;
  89 };
  90 struct debug_event_output_string
  91 {
  92     void       *string;
  93     int         unicode;
  94     int         length;
  95 };
  96 struct debug_event_rip_info
  97 {
  98     int         error;
  99     int         type;
 100 };
 101 union debug_event_data
 102 {
 103     struct debug_event_exception      exception;
 104     struct debug_event_create_thread  create_thread;
 105     struct debug_event_create_process create_process;
 106     struct debug_event_exit           exit;
 107     struct debug_event_load_dll       load_dll;
 108     struct debug_event_unload_dll     unload_dll;
 109     struct debug_event_output_string  output_string;
 110     struct debug_event_rip_info       rip_info;
 111 };
 112
 113
 114 typedef struct
 115 {
 116     int                      code;
 117     union debug_event_data   info;
 118 } debug_event_t;
 119
 120
 121 struct send_fd
 122 {
 123     thread_id_t tid;
 124     int         fd;
 125 };
 126
 127
 128 struct wake_up_reply
 129 {
 130     void *cookie;
 131     int   signaled;
 132 };
 133
 134
 135 typedef struct
 136 {
 137     int            sec;
 138     int            usec;
 139 } abs_time_t;
 140
 141
 142 typedef struct
 143 {
 144     atom_t         atom;
 145     short          string;
 146     obj_handle_t   handle;
 147 } property_data_t;
 148
 149
 150 typedef struct
 151 {
 152     int  left;
 153     int  top;
 154     int  right;
 155     int  bottom;
 156 } rectangle_t;
 157
 158
 159 typedef struct
 160 {
 161     WCHAR          ch;
 162     unsigned short attr;
 163 } char_info_t;
 164
 165
 166
 167
 168
 169 struct new_process_request
 170 {
 171     struct request_header __header;
 172     int          inherit_all;
 173     int          create_flags;
 174     int          unix_pid;
 175     obj_handle_t exe_file;
 176     obj_handle_t hstdin;
 177     obj_handle_t hstdout;
 178     obj_handle_t hstderr;
 179     /* VARARG(info,startup_info); */
 180     /* VARARG(env,unicode_str); */
 181 };
 182 struct new_process_reply
 183 {
 184     struct reply_header __header;
 185     obj_handle_t info;
 186 };
 187
 188
 189
 190 struct get_new_process_info_request
 191 {
 192     struct request_header __header;
 193     obj_handle_t info;
 194     int          pinherit;
 195     int          tinherit;
 196 };
 197 struct get_new_process_info_reply
 198 {
 199     struct reply_header __header;
 200     process_id_t pid;
 201     obj_handle_t phandle;
 202     thread_id_t  tid;
 203     obj_handle_t thandle;
 204     int          success;
 205 };
 206
 207
 208
 209 struct new_thread_request
 210 {
 211     struct request_header __header;
 212     int          suspend;
 213     int          inherit;
 214     int          request_fd;
 215 };
 216 struct new_thread_reply
 217 {
 218     struct reply_header __header;
 219     thread_id_t  tid;
 220     obj_handle_t handle;
 221 };
 222
 223
 224
 225 struct boot_done_request
 226 {
 227     struct request_header __header;
 228     int          debug_level;
 229 };
 230 struct boot_done_reply
 231 {
 232     struct reply_header __header;
 233 };
 234
 235
 236
 237 struct init_process_request
 238 {
 239     struct request_header __header;
 240     void*        peb;
 241     void*        ldt_copy;
 242 };
 243 struct init_process_reply
 244 {
 245     struct reply_header __header;
 246     int          create_flags;
 247     unsigned int server_start;
 248     size_t       info_size;
 249     obj_handle_t exe_file;
 250     obj_handle_t hstdin;
 251     obj_handle_t hstdout;
 252     obj_handle_t hstderr;
 253 };
 254
 255
 256
 257 struct get_startup_info_request
 258 {
 259     struct request_header __header;
 260 };
 261 struct get_startup_info_reply
 262 {
 263     struct reply_header __header;
 264     /* VARARG(info,startup_info); */
 265     /* VARARG(env,unicode_str); */
 266 };
 267
 268
 269
 270 struct init_process_done_request
 271 {
 272     struct request_header __header;
 273     void*        module;
 274     size_t       module_size;
 275     void*        entry;
 276     void*        name;
 277     obj_handle_t exe_file;
 278     int          gui;
 279     /* VARARG(filename,unicode_str); */
 280 };
 281 struct init_process_done_reply
 282 {
 283     struct reply_header __header;
 284 };
 285
 286
 287
 288 struct init_thread_request
 289 {
 290     struct request_header __header;
 291     int          unix_pid;
 292     int          unix_tid;
 293     void*        teb;
 294     void*        entry;
 295     int          reply_fd;
 296     int          wait_fd;
 297 };
 298 struct init_thread_reply
 299 {
 300     struct reply_header __header;
 301     process_id_t pid;
 302     thread_id_t  tid;
 303     int          boot;
 304     int          version;
 305 };
 306
 307
 308
 309 struct terminate_process_request
 310 {
 311     struct request_header __header;
 312     obj_handle_t handle;
 313     int          exit_code;
 314 };
 315 struct terminate_process_reply
 316 {
 317     struct reply_header __header;
 318     int          self;
 319 };
 320
 321
 322
 323 struct terminate_thread_request
 324 {
 325     struct request_header __header;
 326     obj_handle_t handle;
 327     int          exit_code;
 328 };
 329 struct terminate_thread_reply
 330 {
 331     struct reply_header __header;
 332     int          self;
 333     int          last;
 334 };
 335
 336
 337
 338 struct get_process_info_request
 339 {
 340     struct request_header __header;
 341     obj_handle_t handle;
 342 };
 343 struct get_process_info_reply
 344 {
 345     struct reply_header __header;
 346     process_id_t pid;
 347     process_id_t ppid;
 348     int          exit_code;
 349     int          priority;
 350     int          process_affinity;
 351     int          system_affinity;
 352     void*        peb;
 353 };
 354
 355
 356
 357 struct set_process_info_request
 358 {
 359     struct request_header __header;
 360     obj_handle_t handle;
 361     int          mask;
 362     int          priority;
 363     int          affinity;
 364 };
 365 struct set_process_info_reply
 366 {
 367     struct reply_header __header;
 368 };
 369 #define SET_PROCESS_INFO_PRIORITY 0x01
 370 #define SET_PROCESS_INFO_AFFINITY 0x02
 371
 372
 373
 374 struct get_thread_info_request
 375 {
 376     struct request_header __header;
 377     obj_handle_t handle;
 378     thread_id_t  tid_in;
 379 };
 380 struct get_thread_info_reply
 381 {
 382     struct reply_header __header;
 383     process_id_t pid;
 384     thread_id_t  tid;
 385     void*        teb;
 386     int          exit_code;
 387     int          priority;
 388     int          affinity;
 389     time_t       creation_time;
 390     time_t       exit_time;
 391 };
 392
 393
 394
 395 struct set_thread_info_request
 396 {
 397     struct request_header __header;
 398     obj_handle_t handle;
 399     int          mask;
 400     int          priority;
 401     int          affinity;
 402 };
 403 struct set_thread_info_reply
 404 {
 405     struct reply_header __header;
 406 };
 407 #define SET_THREAD_INFO_PRIORITY 0x01
 408 #define SET_THREAD_INFO_AFFINITY 0x02
 409
 410
 411
 412 struct get_dll_info_request
 413 {
 414     struct request_header __header;
 415     obj_handle_t handle;
 416     void*        base_address;
 417 };
 418 struct get_dll_info_reply
 419 {
 420     struct reply_header __header;
 421     size_t       size;
 422     void*        entry_point;
 423     /* VARARG(filename,unicode_str); */
 424 };
 425
 426
 427
 428 struct suspend_thread_request
 429 {
 430     struct request_header __header;
 431     obj_handle_t handle;
 432 };
 433 struct suspend_thread_reply
 434 {
 435     struct reply_header __header;
 436     int          count;
 437 };
 438
 439
 440
 441 struct resume_thread_request
 442 {
 443     struct request_header __header;
 444     obj_handle_t handle;
 445 };
 446 struct resume_thread_reply
 447 {
 448     struct reply_header __header;
 449     int          count;
 450 };
 451
 452
 453
 454 struct load_dll_request
 455 {
 456     struct request_header __header;
 457     obj_handle_t handle;
 458     void*        base;
 459     size_t       size;
 460     int          dbg_offset;
 461     int          dbg_size;
 462     void*        name;
 463     /* VARARG(filename,unicode_str); */
 464 };
 465 struct load_dll_reply
 466 {
 467     struct reply_header __header;
 468 };
 469
 470
 471
 472 struct unload_dll_request
 473 {
 474     struct request_header __header;
 475     void*        base;
 476 };
 477 struct unload_dll_reply
 478 {
 479     struct reply_header __header;
 480 };
 481
 482
 483
 484 struct queue_apc_request
 485 {
 486     struct request_header __header;
 487     obj_handle_t handle;
 488     int          user;
 489     void*        func;
 490     void*        arg1;
 491     void*        arg2;
 492     void*        arg3;
 493 };
 494 struct queue_apc_reply
 495 {
 496     struct reply_header __header;
 497 };
 498
 499
 500
 501 struct get_apc_request
 502 {
 503     struct request_header __header;
 504     int          alertable;
 505 };
 506 struct get_apc_reply
 507 {
 508     struct reply_header __header;
 509     void*        func;
 510     int          type;
 511     void*        arg1;
 512     void*        arg2;
 513     void*        arg3;
 514 };
 515 enum apc_type { APC_NONE, APC_USER, APC_TIMER, APC_ASYNC_IO };
 516
 517
 518
 519 struct close_handle_request
 520 {
 521     struct request_header __header;
 522     obj_handle_t handle;
 523 };
 524 struct close_handle_reply
 525 {
 526     struct reply_header __header;
 527     int          fd;
 528 };
 529
 530
 531
 532 struct set_handle_info_request
 533 {
 534     struct request_header __header;
 535     obj_handle_t handle;
 536     int          flags;
 537     int          mask;
 538     int          fd;
 539 };
 540 struct set_handle_info_reply
 541 {
 542     struct reply_header __header;
 543     int          old_flags;
 544     int          cur_fd;
 545 };
 546
 547
 548
 549 struct dup_handle_request
 550 {
 551     struct request_header __header;
 552     obj_handle_t src_process;
 553     obj_handle_t src_handle;
 554     obj_handle_t dst_process;
 555     unsigned int access;
 556     int          inherit;
 557     int          options;
 558 };
 559 struct dup_handle_reply
 560 {
 561     struct reply_header __header;
 562     obj_handle_t handle;
 563     int          fd;
 564 };
 565 #define DUP_HANDLE_CLOSE_SOURCE  DUPLICATE_CLOSE_SOURCE
 566 #define DUP_HANDLE_SAME_ACCESS   DUPLICATE_SAME_ACCESS
 567 #define DUP_HANDLE_MAKE_GLOBAL   0x80000000
 568
 569
 570
 571 struct open_process_request
 572 {
 573     struct request_header __header;
 574     process_id_t pid;
 575     unsigned int access;
 576     int          inherit;
 577 };
 578 struct open_process_reply
 579 {
 580     struct reply_header __header;
 581     obj_handle_t handle;
 582 };
 583
 584
 585
 586 struct open_thread_request
 587 {
 588     struct request_header __header;
 589     thread_id_t  tid;
 590     unsigned int access;
 591     int          inherit;
 592 };
 593 struct open_thread_reply
 594 {
 595     struct reply_header __header;
 596     obj_handle_t handle;
 597 };
 598
 599
 600
 601 struct select_request
 602 {
 603     struct request_header __header;
 604     int          flags;
 605     void*        cookie;
 606     abs_time_t   timeout;
 607     /* VARARG(handles,handles); */
 608 };
 609 struct select_reply
 610 {
 611     struct reply_header __header;
 612 };
 613 #define SELECT_ALL           1
 614 #define SELECT_ALERTABLE     2
 615 #define SELECT_INTERRUPTIBLE 4
 616 #define SELECT_TIMEOUT       8
 617
 618
 619
 620 struct create_event_request
 621 {
 622     struct request_header __header;
 623     unsigned int access;
 624     int          manual_reset;
 625     int          initial_state;
 626     int          inherit;
 627     /* VARARG(name,unicode_str); */
 628 };
 629 struct create_event_reply
 630 {
 631     struct reply_header __header;
 632     obj_handle_t handle;
 633 };
 634
 635
 636 struct event_op_request
 637 {
 638     struct request_header __header;
 639     obj_handle_t  handle;
 640     int           op;
 641 };
 642 struct event_op_reply
 643 {
 644     struct reply_header __header;
 645 };
 646 enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT };
 647
 648
 649
 650 struct open_event_request
 651 {
 652     struct request_header __header;
 653     unsigned int access;
 654     int          inherit;
 655     /* VARARG(name,unicode_str); */
 656 };
 657 struct open_event_reply
 658 {
 659     struct reply_header __header;
 660     obj_handle_t handle;
 661 };
 662
 663
 664
 665 struct create_mutex_request
 666 {
 667     struct request_header __header;
 668     unsigned int access;
 669     int          owned;
 670     int          inherit;
 671     /* VARARG(name,unicode_str); */
 672 };
 673 struct create_mutex_reply
 674 {
 675     struct reply_header __header;
 676     obj_handle_t handle;
 677 };
 678
 679
 680
 681 struct release_mutex_request
 682 {
 683     struct request_header __header;
 684     obj_handle_t handle;
 685 };
 686 struct release_mutex_reply
 687 {
 688     struct reply_header __header;
 689     unsigned int prev_count;
 690 };
 691
 692
 693
 694 struct open_mutex_request
 695 {
 696     struct request_header __header;
 697     unsigned int access;
 698     int          inherit;
 699     /* VARARG(name,unicode_str); */
 700 };
 701 struct open_mutex_reply
 702 {
 703     struct reply_header __header;
 704     obj_handle_t handle;
 705 };
 706
 707
 708
 709 struct create_semaphore_request
 710 {
 711     struct request_header __header;
 712     unsigned int access;
 713     unsigned int initial;
 714     unsigned int max;
 715     int          inherit;
 716     /* VARARG(name,unicode_str); */
 717 };
 718 struct create_semaphore_reply
 719 {
 720     struct reply_header __header;
 721     obj_handle_t handle;
 722 };
 723
 724
 725
 726 struct release_semaphore_request
 727 {
 728     struct request_header __header;
 729     obj_handle_t handle;
 730     unsigned int count;
 731 };
 732 struct release_semaphore_reply
 733 {
 734     struct reply_header __header;
 735     unsigned int prev_count;
 736 };
 737
 738
 739
 740 struct open_semaphore_request
 741 {
 742     struct request_header __header;
 743     unsigned int access;
 744     int          inherit;
 745     /* VARARG(name,unicode_str); */
 746 };
 747 struct open_semaphore_reply
 748 {
 749     struct reply_header __header;
 750     obj_handle_t handle;
 751 };
 752
 753
 754
 755 struct create_file_request
 756 {
 757     struct request_header __header;
 758     unsigned int access;
 759     int          inherit;
 760     unsigned int sharing;
 761     int          create;
 762     unsigned int options;
 763     unsigned int attrs;
 764     /* VARARG(filename,string); */
 765 };
 766 struct create_file_reply
 767 {
 768     struct reply_header __header;
 769     obj_handle_t handle;
 770 };
 771
 772
 773
 774 struct alloc_file_handle_request
 775 {
 776     struct request_header __header;
 777     unsigned int access;
 778     int          inherit;
 779     int          fd;
 780 };
 781 struct alloc_file_handle_reply
 782 {
 783     struct reply_header __header;
 784     obj_handle_t handle;
 785 };
 786
 787
 788
 789 struct get_handle_fd_request
 790 {
 791     struct request_header __header;
 792     obj_handle_t handle;
 793     unsigned int access;
 794 };
 795 struct get_handle_fd_reply
 796 {
 797     struct reply_header __header;
 798     int          fd;
 799     int          flags;
 800 };
 801 #define FD_FLAG_OVERLAPPED         0x01
 802 #define FD_FLAG_TIMEOUT            0x02
 803 #define FD_FLAG_RECV_SHUTDOWN      0x04
 804 #define FD_FLAG_SEND_SHUTDOWN      0x08
 805 #define FD_FLAG_AVAILABLE          0x10 /* in overlap read/write operation,
 806                                          * only handle available data (don't wait) */
 807
 808
 809
 810 struct flush_file_request
 811 {
 812     struct request_header __header;
 813     obj_handle_t handle;
 814 };
 815 struct flush_file_reply
 816 {
 817     struct reply_header __header;
 818     obj_handle_t event;
 819 };
 820
 821
 822
 823 struct lock_file_request
 824 {
 825     struct request_header __header;
 826     obj_handle_t handle;
 827     unsigned int offset_low;
 828     unsigned int offset_high;
 829     unsigned int count_low;
 830     unsigned int count_high;
 831     int          shared;
 832     int          wait;
 833 };
 834 struct lock_file_reply
 835 {
 836     struct reply_header __header;
 837     obj_handle_t handle;
 838     int          overlapped;
 839 };
 840
 841
 842
 843 struct unlock_file_request
 844 {
 845     struct request_header __header;
 846     obj_handle_t handle;
 847     unsigned int offset_low;
 848     unsigned int offset_high;
 849     unsigned int count_low;
 850     unsigned int count_high;
 851 };
 852 struct unlock_file_reply
 853 {
 854     struct reply_header __header;
 855 };
 856
 857
 858
 859 struct create_socket_request
 860 {
 861     struct request_header __header;
 862     unsigned int access;
 863     int          inherit;
 864     int          family;
 865     int          type;
 866     int          protocol;
 867     unsigned int flags;
 868 };
 869 struct create_socket_reply
 870 {
 871     struct reply_header __header;
 872     obj_handle_t handle;
 873 };
 874
 875
 876
 877 struct accept_socket_request
 878 {
 879     struct request_header __header;
 880     obj_handle_t lhandle;
 881     unsigned int access;
 882     int          inherit;
 883 };
 884 struct accept_socket_reply
 885 {
 886     struct reply_header __header;
 887     obj_handle_t handle;
 888 };
 889
 890
 891
 892 struct set_socket_event_request
 893 {
 894     struct request_header __header;
 895     obj_handle_t  handle;
 896     unsigned int  mask;
 897     obj_handle_t  event;
 898     user_handle_t window;
 899     unsigned int  msg;
 900 };
 901 struct set_socket_event_reply
 902 {
 903     struct reply_header __header;
 904 };
 905
 906
 907
 908 struct get_socket_event_request
 909 {
 910     struct request_header __header;
 911     obj_handle_t handle;
 912     int          service;
 913     obj_handle_t c_event;
 914 };
 915 struct get_socket_event_reply
 916 {
 917     struct reply_header __header;
 918     unsigned int mask;
 919     unsigned int pmask;
 920     unsigned int state;
 921     /* VARARG(errors,ints); */
 922 };
 923
 924
 925
 926 struct enable_socket_event_request
 927 {
 928     struct request_header __header;
 929     obj_handle_t handle;
 930     unsigned int mask;
 931     unsigned int sstate;
 932     unsigned int cstate;
 933 };
 934 struct enable_socket_event_reply
 935 {
 936     struct reply_header __header;
 937 };
 938
 939 struct set_socket_deferred_request
 940 {
 941     struct request_header __header;
 942     obj_handle_t handle;
 943     obj_handle_t deferred;
 944 };
 945 struct set_socket_deferred_reply
 946 {
 947     struct reply_header __header;
 948 };
 949
 950
 951 struct alloc_console_request
 952 {
 953     struct request_header __header;
 954     unsigned int access;
 955     int          inherit;
 956     process_id_t pid;
 957 };
 958 struct alloc_console_reply
 959 {
 960     struct reply_header __header;
 961     obj_handle_t handle_in;
 962     obj_handle_t event;
 963 };
 964
 965
 966
 967 struct free_console_request
 968 {
 969     struct request_header __header;
 970 };
 971 struct free_console_reply
 972 {
 973     struct reply_header __header;
 974 };
 975
 976
 977 #define CONSOLE_RENDERER_NONE_EVENT        0x00
 978 #define CONSOLE_RENDERER_TITLE_EVENT       0x01
 979 #define CONSOLE_RENDERER_ACTIVE_SB_EVENT   0x02
 980 #define CONSOLE_RENDERER_SB_RESIZE_EVENT   0x03
 981 #define CONSOLE_RENDERER_UPDATE_EVENT      0x04
 982 #define CONSOLE_RENDERER_CURSOR_POS_EVENT  0x05
 983 #define CONSOLE_RENDERER_CURSOR_GEOM_EVENT 0x06
 984 #define CONSOLE_RENDERER_DISPLAY_EVENT     0x07
 985 #define CONSOLE_RENDERER_EXIT_EVENT        0x08
 986 struct console_renderer_event
 987 {
 988     short event;
 989     union
 990     {
 991         struct update
 992         {
 993             short top;
 994             short bottom;
 995         } update;
 996         struct resize
 997         {
 998             short width;
 999             short height;
1000         } resize;
1001         struct cursor_pos
1002         {
1003             short x;
1004             short y;
1005         } cursor_pos;
1006         struct cursor_geom
1007         {
1008             short visible;
1009             short size;
1010         } cursor_geom;
1011         struct display
1012         {
1013             short left;
1014             short top;
1015             short width;
1016             short height;
1017         } display;
1018     } u;
1019 };
1020
1021
1022 struct get_console_renderer_events_request
1023 {
1024     struct request_header __header;
1025     obj_handle_t handle;
1026 };
1027 struct get_console_renderer_events_reply
1028 {
1029     struct reply_header __header;
1030     /* VARARG(data,bytes); */
1031 };
1032
1033
1034
1035 struct open_console_request
1036 {
1037     struct request_header __header;
1038     int          from;
1039
1040     unsigned int access;
1041     int          inherit;
1042     int          share;
1043 };
1044 struct open_console_reply
1045 {
1046     struct reply_header __header;
1047     obj_handle_t handle;
1048 };
1049
1050
1051
1052 struct get_console_wait_event_request
1053 {
1054     struct request_header __header;
1055 };
1056 struct get_console_wait_event_reply
1057 {
1058     struct reply_header __header;
1059     obj_handle_t handle;
1060 };
1061
1062
1063 struct get_console_mode_request
1064 {
1065     struct request_header __header;
1066     obj_handle_t handle;
1067 };
1068 struct get_console_mode_reply
1069 {
1070     struct reply_header __header;
1071     int          mode;
1072 };
1073
1074
1075
1076 struct set_console_mode_request
1077 {
1078     struct request_header __header;
1079     obj_handle_t handle;
1080     int          mode;
1081 };
1082 struct set_console_mode_reply
1083 {
1084     struct reply_header __header;
1085 };
1086
1087
1088
1089 struct set_console_input_info_request
1090 {
1091     struct request_header __header;
1092     obj_handle_t handle;
1093     int          mask;
1094     obj_handle_t active_sb;
1095     int          history_mode;
1096     int          history_size;
1097     int          edition_mode;
1098     /* VARARG(title,unicode_str); */
1099 };
1100 struct set_console_input_info_reply
1101 {
1102     struct reply_header __header;
1103 };
1104 #define SET_CONSOLE_INPUT_INFO_ACTIVE_SB        0x01
1105 #define SET_CONSOLE_INPUT_INFO_TITLE            0x02
1106 #define SET_CONSOLE_INPUT_INFO_HISTORY_MODE     0x04
1107 #define SET_CONSOLE_INPUT_INFO_HISTORY_SIZE     0x08
1108 #define SET_CONSOLE_INPUT_INFO_EDITION_MODE     0x10
1109
1110
1111
1112 struct get_console_input_info_request
1113 {
1114     struct request_header __header;
1115     obj_handle_t handle;
1116 };
1117 struct get_console_input_info_reply
1118 {
1119     struct reply_header __header;
1120     int          history_mode;
1121     int          history_size;
1122     int          history_index;
1123     int          edition_mode;
1124     /* VARARG(title,unicode_str); */
1125 };
1126
1127
1128
1129 struct append_console_input_history_request
1130 {
1131     struct request_header __header;
1132     obj_handle_t handle;
1133     /* VARARG(line,unicode_str); */
1134 };
1135 struct append_console_input_history_reply
1136 {
1137     struct reply_header __header;
1138 };
1139
1140
1141
1142 struct get_console_input_history_request
1143 {
1144     struct request_header __header;
1145     obj_handle_t handle;
1146     int          index;
1147 };
1148 struct get_console_input_history_reply
1149 {
1150     struct reply_header __header;
1151     int          total;
1152     /* VARARG(line,unicode_str); */
1153 };
1154
1155
1156
1157 struct create_console_output_request
1158 {
1159     struct request_header __header;
1160     obj_handle_t handle_in;
1161     int          access;
1162     int          share;
1163     int          inherit;
1164 };
1165 struct create_console_output_reply
1166 {
1167     struct reply_header __header;
1168     obj_handle_t handle_out;
1169 };
1170
1171
1172
1173 struct set_console_output_info_request
1174 {
1175     struct request_header __header;
1176     obj_handle_t handle;
1177     int          mask;
1178     short int    cursor_size;
1179     short int    cursor_visible;
1180     short int    cursor_x;
1181     short int    cursor_y;
1182     short int    width;
1183     short int    height;
1184     short int    attr;
1185     short int    win_left;
1186     short int    win_top;
1187     short int    win_right;
1188     short int    win_bottom;
1189     short int    max_width;
1190     short int    max_height;
1191 };
1192 struct set_console_output_info_reply
1193 {
1194     struct reply_header __header;
1195 };
1196 #define SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM     0x01
1197 #define SET_CONSOLE_OUTPUT_INFO_CURSOR_POS      0x02
1198 #define SET_CONSOLE_OUTPUT_INFO_SIZE            0x04
1199 #define SET_CONSOLE_OUTPUT_INFO_ATTR            0x08
1200 #define SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW  0x10
1201 #define SET_CONSOLE_OUTPUT_INFO_MAX_SIZE        0x20
1202
1203
1204
1205 struct get_console_output_info_request
1206 {
1207     struct request_header __header;
1208     obj_handle_t handle;
1209 };
1210 struct get_console_output_info_reply
1211 {
1212     struct reply_header __header;
1213     short int    cursor_size;
1214     short int    cursor_visible;
1215     short int    cursor_x;
1216     short int    cursor_y;
1217     short int    width;
1218     short int    height;
1219     short int    attr;
1220     short int    win_left;
1221     short int    win_top;
1222     short int    win_right;
1223     short int    win_bottom;
1224     short int    max_width;
1225     short int    max_height;
1226 };
1227
1228
1229 struct write_console_input_request
1230 {
1231     struct request_header __header;
1232     obj_handle_t handle;
1233     /* VARARG(rec,input_records); */
1234 };
1235 struct write_console_input_reply
1236 {
1237     struct reply_header __header;
1238     int          written;
1239 };
1240
1241
1242
1243 struct read_console_input_request
1244 {
1245     struct request_header __header;
1246     obj_handle_t handle;
1247     int          flush;
1248 };
1249 struct read_console_input_reply
1250 {
1251     struct reply_header __header;
1252     int          read;
1253     /* VARARG(rec,input_records); */
1254 };
1255
1256
1257
1258 struct write_console_output_request
1259 {
1260     struct request_header __header;
1261     obj_handle_t handle;
1262     int          x;
1263     int          y;
1264     int          mode;
1265     int          wrap;
1266     /* VARARG(data,bytes); */
1267 };
1268 struct write_console_output_reply
1269 {
1270     struct reply_header __header;
1271     int          written;
1272     int          width;
1273     int          height;
1274 };
1275 enum char_info_mode
1276 {
1277     CHAR_INFO_MODE_TEXT,
1278     CHAR_INFO_MODE_ATTR,
1279     CHAR_INFO_MODE_TEXTATTR,
1280     CHAR_INFO_MODE_TEXTSTDATTR
1281 };
1282
1283
1284
1285 struct fill_console_output_request
1286 {
1287     struct request_header __header;
1288     obj_handle_t handle;
1289     int          x;
1290     int          y;
1291     int          mode;
1292     int          count;
1293     int          wrap;
1294     char_info_t  data;
1295 };
1296 struct fill_console_output_reply
1297 {
1298     struct reply_header __header;
1299     int          written;
1300 };
1301
1302
1303
1304 struct read_console_output_request
1305 {
1306     struct request_header __header;
1307     obj_handle_t handle;
1308     int          x;
1309     int          y;
1310     int          mode;
1311     int          wrap;
1312 };
1313 struct read_console_output_reply
1314 {
1315     struct reply_header __header;
1316     int          width;
1317     int          height;
1318     /* VARARG(data,bytes); */
1319 };
1320
1321
1322
1323 struct move_console_output_request
1324 {
1325     struct request_header __header;
1326     obj_handle_t handle;
1327     short int    x_src;
1328     short int    y_src;
1329     short int    x_dst;
1330     short int    y_dst;
1331     short int    w;
1332     short int    h;
1333 };
1334 struct move_console_output_reply
1335 {
1336     struct reply_header __header;
1337 };
1338
1339
1340
1341 struct send_console_signal_request
1342 {
1343     struct request_header __header;
1344     int          signal;
1345     process_id_t group_id;
1346 };
1347 struct send_console_signal_reply
1348 {
1349     struct reply_header __header;
1350 };
1351
1352
1353
1354 struct create_change_notification_request
1355 {
1356     struct request_header __header;
1357     obj_handle_t handle;
1358     int          subtree;
1359     unsigned int filter;
1360 };
1361 struct create_change_notification_reply
1362 {
1363     struct reply_header __header;
1364     obj_handle_t handle;
1365 };
1366
1367
1368
1369 struct next_change_notification_request
1370 {
1371     struct request_header __header;
1372     obj_handle_t handle;
1373 };
1374 struct next_change_notification_reply
1375 {
1376     struct reply_header __header;
1377 };
1378
1379
1380 struct create_mapping_request
1381 {
1382     struct request_header __header;
1383     int          size_high;
1384     int          size_low;
1385     int          protect;
1386     unsigned int access;
1387     int          inherit;
1388     obj_handle_t file_handle;
1389     /* VARARG(name,unicode_str); */
1390 };
1391 struct create_mapping_reply
1392 {
1393     struct reply_header __header;
1394     obj_handle_t handle;
1395 };
1396
1397 #define VPROT_READ       0x01
1398 #define VPROT_WRITE      0x02
1399 #define VPROT_EXEC       0x04
1400 #define VPROT_WRITECOPY  0x08
1401 #define VPROT_GUARD      0x10
1402 #define VPROT_NOCACHE    0x20
1403 #define VPROT_COMMITTED  0x40
1404 #define VPROT_IMAGE      0x80
1405
1406
1407
1408 struct open_mapping_request
1409 {
1410     struct request_header __header;
1411     unsigned int access;
1412     int          inherit;
1413     /* VARARG(name,unicode_str); */
1414 };
1415 struct open_mapping_reply
1416 {
1417     struct reply_header __header;
1418     obj_handle_t handle;
1419 };
1420
1421
1422
1423 struct get_mapping_info_request
1424 {
1425     struct request_header __header;
1426     obj_handle_t handle;
1427 };
1428 struct get_mapping_info_reply
1429 {
1430     struct reply_header __header;
1431     int          size_high;
1432     int          size_low;
1433     int          protect;
1434     int          header_size;
1435     void*        base;
1436     obj_handle_t shared_file;
1437     int          shared_size;
1438 };
1439
1440
1441 #define SNAP_HEAPLIST   0x00000001
1442 #define SNAP_PROCESS    0x00000002
1443 #define SNAP_THREAD     0x00000004
1444 #define SNAP_MODULE     0x00000008
1445
1446 struct create_snapshot_request
1447 {
1448     struct request_header __header;
1449     int          inherit;
1450     int          flags;
1451     process_id_t pid;
1452 };
1453 struct create_snapshot_reply
1454 {
1455     struct reply_header __header;
1456     obj_handle_t handle;
1457 };
1458
1459
1460
1461 struct next_process_request
1462 {
1463     struct request_header __header;
1464     obj_handle_t handle;
1465     int          reset;
1466 };
1467 struct next_process_reply
1468 {
1469     struct reply_header __header;
1470     int          count;
1471     process_id_t pid;
1472     process_id_t ppid;
1473     void*        heap;
1474     void*        module;
1475     int          threads;
1476     int          priority;
1477     int          handles;
1478     /* VARARG(filename,unicode_str); */
1479 };
1480
1481
1482
1483 struct next_thread_request
1484 {
1485     struct request_header __header;
1486     obj_handle_t handle;
1487     int          reset;
1488 };
1489 struct next_thread_reply
1490 {
1491     struct reply_header __header;
1492     int          count;
1493     process_id_t pid;
1494     thread_id_t  tid;
1495     int          base_pri;
1496     int          delta_pri;
1497 };
1498
1499
1500
1501 struct next_module_request
1502 {
1503     struct request_header __header;
1504     obj_handle_t handle;
1505     int          reset;
1506 };
1507 struct next_module_reply
1508 {
1509     struct reply_header __header;
1510     process_id_t pid;
1511     void*        base;
1512     size_t       size;
1513     /* VARARG(filename,unicode_str); */
1514 };
1515
1516
1517
1518 struct wait_debug_event_request
1519 {
1520     struct request_header __header;
1521     int           get_handle;
1522 };
1523 struct wait_debug_event_reply
1524 {
1525     struct reply_header __header;
1526     process_id_t  pid;
1527     thread_id_t   tid;
1528     obj_handle_t  wait;
1529     /* VARARG(event,debug_event); */
1530 };
1531
1532
1533
1534 struct queue_exception_event_request
1535 {
1536     struct request_header __header;
1537     int              first;
1538     /* VARARG(record,exc_event); */
1539 };
1540 struct queue_exception_event_reply
1541 {
1542     struct reply_header __header;
1543     obj_handle_t     handle;
1544 };
1545
1546
1547
1548 struct get_exception_status_request
1549 {
1550     struct request_header __header;
1551     obj_handle_t     handle;
1552 };
1553 struct get_exception_status_reply
1554 {
1555     struct reply_header __header;
1556     int              status;
1557     /* VARARG(context,context); */
1558 };
1559
1560
1561
1562 struct output_debug_string_request
1563 {
1564     struct request_header __header;
1565     void*         string;
1566     int           unicode;
1567     int           length;
1568 };
1569 struct output_debug_string_reply
1570 {
1571     struct reply_header __header;
1572 };
1573
1574
1575
1576 struct continue_debug_event_request
1577 {
1578     struct request_header __header;
1579     process_id_t pid;
1580     thread_id_t  tid;
1581     int          status;
1582 };
1583 struct continue_debug_event_reply
1584 {
1585     struct reply_header __header;
1586 };
1587
1588
1589
1590 struct debug_process_request
1591 {
1592     struct request_header __header;
1593     process_id_t pid;
1594     int          attach;
1595 };
1596 struct debug_process_reply
1597 {
1598     struct reply_header __header;
1599 };
1600
1601
1602
1603 struct debug_break_request
1604 {
1605     struct request_header __header;
1606     obj_handle_t handle;
1607 };
1608 struct debug_break_reply
1609 {
1610     struct reply_header __header;
1611     int          self;
1612 };
1613
1614
1615
1616 struct set_debugger_kill_on_exit_request
1617 {
1618     struct request_header __header;
1619     int          kill_on_exit;
1620 };
1621 struct set_debugger_kill_on_exit_reply
1622 {
1623     struct reply_header __header;
1624 };
1625
1626
1627
1628 struct read_process_memory_request
1629 {
1630     struct request_header __header;
1631     obj_handle_t handle;
1632     void*        addr;
1633 };
1634 struct read_process_memory_reply
1635 {
1636     struct reply_header __header;
1637     /* VARARG(data,bytes); */
1638 };
1639
1640
1641
1642 struct write_process_memory_request
1643 {
1644     struct request_header __header;
1645     obj_handle_t handle;
1646     void*        addr;
1647     unsigned int first_mask;
1648     unsigned int last_mask;
1649     /* VARARG(data,bytes); */
1650 };
1651 struct write_process_memory_reply
1652 {
1653     struct reply_header __header;
1654 };
1655
1656
1657
1658 struct create_key_request
1659 {
1660     struct request_header __header;
1661     obj_handle_t parent;
1662     unsigned int access;
1663     unsigned int options;
1664     time_t       modif;
1665     size_t       namelen;
1666     /* VARARG(name,unicode_str,namelen); */
1667     /* VARARG(class,unicode_str); */
1668 };
1669 struct create_key_reply
1670 {
1671     struct reply_header __header;
1672     obj_handle_t hkey;
1673     int          created;
1674 };
1675
1676
1677 struct open_key_request
1678 {
1679     struct request_header __header;
1680     obj_handle_t parent;
1681     unsigned int access;
1682     /* VARARG(name,unicode_str); */
1683 };
1684 struct open_key_reply
1685 {
1686     struct reply_header __header;
1687     obj_handle_t hkey;
1688 };
1689
1690
1691
1692 struct delete_key_request
1693 {
1694     struct request_header __header;
1695     obj_handle_t hkey;
1696 };
1697 struct delete_key_reply
1698 {
1699     struct reply_header __header;
1700 };
1701
1702
1703
1704 struct flush_key_request
1705 {
1706     struct request_header __header;
1707     obj_handle_t hkey;
1708 };
1709 struct flush_key_reply
1710 {
1711     struct reply_header __header;
1712 };
1713
1714
1715
1716 struct enum_key_request
1717 {
1718     struct request_header __header;
1719     obj_handle_t hkey;
1720     int          index;
1721     int          info_class;
1722 };
1723 struct enum_key_reply
1724 {
1725     struct reply_header __header;
1726     int          subkeys;
1727     int          max_subkey;
1728     int          max_class;
1729     int          values;
1730     int          max_value;
1731     int          max_data;
1732     time_t       modif;
1733     size_t       total;
1734     size_t       namelen;
1735     /* VARARG(name,unicode_str,namelen); */
1736     /* VARARG(class,unicode_str); */
1737 };
1738
1739
1740
1741 struct set_key_value_request
1742 {
1743     struct request_header __header;
1744     obj_handle_t hkey;
1745     int          type;
1746     size_t       namelen;
1747     /* VARARG(name,unicode_str,namelen); */
1748     /* VARARG(data,bytes); */
1749 };
1750 struct set_key_value_reply
1751 {
1752     struct reply_header __header;
1753 };
1754
1755
1756
1757 struct get_key_value_request
1758 {
1759     struct request_header __header;
1760     obj_handle_t hkey;
1761     /* VARARG(name,unicode_str); */
1762 };
1763 struct get_key_value_reply
1764 {
1765     struct reply_header __header;
1766     int          type;
1767     size_t       total;
1768     /* VARARG(data,bytes); */
1769 };
1770
1771
1772
1773 struct enum_key_value_request
1774 {
1775     struct request_header __header;
1776     obj_handle_t hkey;
1777     int          index;
1778     int          info_class;
1779 };
1780 struct enum_key_value_reply
1781 {
1782     struct reply_header __header;
1783     int          type;
1784     size_t       total;
1785     size_t       namelen;
1786     /* VARARG(name,unicode_str,namelen); */
1787     /* VARARG(data,bytes); */
1788 };
1789
1790
1791
1792 struct delete_key_value_request
1793 {
1794     struct request_header __header;
1795     obj_handle_t hkey;
1796     /* VARARG(name,unicode_str); */
1797 };
1798 struct delete_key_value_reply
1799 {
1800     struct reply_header __header;
1801 };
1802
1803
1804
1805 struct load_registry_request
1806 {
1807     struct request_header __header;
1808     obj_handle_t hkey;
1809     obj_handle_t file;
1810     /* VARARG(name,unicode_str); */
1811 };
1812 struct load_registry_reply
1813 {
1814     struct reply_header __header;
1815 };
1816
1817
1818
1819 struct unload_registry_request
1820 {
1821     struct request_header __header;
1822     obj_handle_t hkey;
1823 };
1824 struct unload_registry_reply
1825 {
1826     struct reply_header __header;
1827 };
1828
1829
1830
1831 struct save_registry_request
1832 {
1833     struct request_header __header;
1834     obj_handle_t hkey;
1835     obj_handle_t file;
1836 };
1837 struct save_registry_reply
1838 {
1839     struct reply_header __header;
1840 };
1841
1842
1843
1844 struct load_user_registries_request
1845 {
1846     struct request_header __header;
1847     obj_handle_t hkey;
1848     int          saving;
1849     int          period;
1850 };
1851 struct load_user_registries_reply
1852 {
1853     struct reply_header __header;
1854 };
1855
1856
1857
1858 struct set_registry_notification_request
1859 {
1860     struct request_header __header;
1861     obj_handle_t hkey;
1862     obj_handle_t event;
1863     int          subtree;
1864     unsigned int filter;
1865 };
1866 struct set_registry_notification_reply
1867 {
1868     struct reply_header __header;
1869 };
1870
1871
1872
1873 struct create_timer_request
1874 {
1875     struct request_header __header;
1876     unsigned int access;
1877     int          inherit;
1878     int          manual;
1879     /* VARARG(name,unicode_str); */
1880 };
1881 struct create_timer_reply
1882 {
1883     struct reply_header __header;
1884     obj_handle_t handle;
1885 };
1886
1887
1888
1889 struct open_timer_request
1890 {
1891     struct request_header __header;
1892     unsigned int access;
1893     int          inherit;
1894     /* VARARG(name,unicode_str); */
1895 };
1896 struct open_timer_reply
1897 {
1898     struct reply_header __header;
1899     obj_handle_t handle;
1900 };
1901
1902
1903 struct set_timer_request
1904 {
1905     struct request_header __header;
1906     obj_handle_t handle;
1907     abs_time_t   expire;
1908     int          period;
1909     void*        callback;
1910     void*        arg;
1911 };
1912 struct set_timer_reply
1913 {
1914     struct reply_header __header;
1915     int          signaled;
1916 };
1917
1918
1919 struct cancel_timer_request
1920 {
1921     struct request_header __header;
1922     obj_handle_t handle;
1923 };
1924 struct cancel_timer_reply
1925 {
1926     struct reply_header __header;
1927      int         signaled;
1928 };
1929
1930
1931 struct get_timer_info_request
1932 {
1933     struct request_header __header;
1934     obj_handle_t handle;
1935 };
1936 struct get_timer_info_reply
1937 {
1938     struct reply_header __header;
1939     abs_time_t   when;
1940     int          signaled;
1941 };
1942
1943
1944
1945 struct get_thread_context_request
1946 {
1947     struct request_header __header;
1948     obj_handle_t handle;
1949     unsigned int flags;
1950 };
1951 struct get_thread_context_reply
1952 {
1953     struct reply_header __header;
1954     /* VARARG(context,context); */
1955 };
1956
1957
1958
1959 struct set_thread_context_request
1960 {
1961     struct request_header __header;
1962     obj_handle_t handle;
1963     unsigned int flags;
1964     /* VARARG(context,context); */
1965 };
1966 struct set_thread_context_reply
1967 {
1968     struct reply_header __header;
1969 };
1970
1971
1972
1973 struct get_selector_entry_request
1974 {
1975     struct request_header __header;
1976     obj_handle_t  handle;
1977     int           entry;
1978 };
1979 struct get_selector_entry_reply
1980 {
1981     struct reply_header __header;
1982     unsigned int  base;
1983     unsigned int  limit;
1984     unsigned char flags;
1985 };
1986
1987
1988
1989 struct add_atom_request
1990 {
1991     struct request_header __header;
1992     int           local;
1993     /* VARARG(name,unicode_str); */
1994 };
1995 struct add_atom_reply
1996 {
1997     struct reply_header __header;
1998     atom_t        atom;
1999 };
2000
2001
2002
2003 struct delete_atom_request
2004 {
2005     struct request_header __header;
2006     atom_t        atom;
2007     int           local;
2008 };
2009 struct delete_atom_reply
2010 {
2011     struct reply_header __header;
2012 };
2013
2014
2015
2016 struct find_atom_request
2017 {
2018     struct request_header __header;
2019     int          local;
2020     /* VARARG(name,unicode_str); */
2021 };
2022 struct find_atom_reply
2023 {
2024     struct reply_header __header;
2025     atom_t       atom;
2026 };
2027
2028
2029
2030 struct get_atom_name_request
2031 {
2032     struct request_header __header;
2033     atom_t       atom;
2034     int          local;
2035 };
2036 struct get_atom_name_reply
2037 {
2038     struct reply_header __header;
2039     int          count;
2040     /* VARARG(name,unicode_str); */
2041 };
2042
2043
2044
2045 struct init_atom_table_request
2046 {
2047     struct request_header __header;
2048     int          entries;
2049 };
2050 struct init_atom_table_reply
2051 {
2052     struct reply_header __header;
2053 };
2054
2055
2056
2057 struct get_msg_queue_request
2058 {
2059     struct request_header __header;
2060 };
2061 struct get_msg_queue_reply
2062 {
2063     struct reply_header __header;
2064     obj_handle_t handle;
2065 };
2066
2067
2068
2069 struct set_queue_mask_request
2070 {
2071     struct request_header __header;
2072     unsigned int wake_mask;
2073     unsigned int changed_mask;
2074     int          skip_wait;
2075 };
2076 struct set_queue_mask_reply
2077 {
2078     struct reply_header __header;
2079     unsigned int wake_bits;
2080     unsigned int changed_bits;
2081 };
2082
2083
2084
2085 struct get_queue_status_request
2086 {
2087     struct request_header __header;
2088     int          clear;
2089 };
2090 struct get_queue_status_reply
2091 {
2092     struct reply_header __header;
2093     unsigned int wake_bits;
2094     unsigned int changed_bits;
2095 };
2096
2097
2098
2099 struct wait_input_idle_request
2100 {
2101     struct request_header __header;
2102     obj_handle_t handle;
2103     int          timeout;
2104 };
2105 struct wait_input_idle_reply
2106 {
2107     struct reply_header __header;
2108     obj_handle_t event;
2109 };
2110
2111
2112
2113 struct send_message_request
2114 {
2115     struct request_header __header;
2116     thread_id_t     id;
2117     int             type;
2118     int             flags;
2119     user_handle_t   win;
2120     unsigned int    msg;
2121     unsigned int    wparam;
2122     unsigned int    lparam;
2123     int             x;
2124     int             y;
2125     unsigned int    time;
2126     unsigned int    info;
2127     int             timeout;
2128     void*           callback;
2129     /* VARARG(data,bytes); */
2130 };
2131 struct send_message_reply
2132 {
2133     struct reply_header __header;
2134 };
2135
2136 enum message_type
2137 {
2138     MSG_ASCII,
2139     MSG_UNICODE,
2140     MSG_NOTIFY,
2141     MSG_CALLBACK,
2142     MSG_CALLBACK_RESULT,
2143     MSG_OTHER_PROCESS,
2144     MSG_POSTED,
2145     MSG_HARDWARE,
2146     MSG_WINEVENT
2147 };
2148 #define SEND_MSG_ABORT_IF_HUNG  0x01
2149
2150
2151
2152 struct get_message_request
2153 {
2154     struct request_header __header;
2155     int             flags;
2156     user_handle_t   get_win;
2157     unsigned int    get_first;
2158     unsigned int    get_last;
2159     unsigned int    hw_id;
2160 };
2161 struct get_message_reply
2162 {
2163     struct reply_header __header;
2164     int             type;
2165     user_handle_t   win;
2166     unsigned int    msg;
2167     unsigned int    wparam;
2168     unsigned int    lparam;
2169     int             x;
2170     int             y;
2171     user_handle_t   hook;
2172     void*           hook_proc;
2173     unsigned int    time;
2174     unsigned int    info;
2175     unsigned int    hw_id;
2176     size_t          total;
2177     /* VARARG(data,bytes); */
2178 };
2179 #define GET_MSG_REMOVE      1
2180 #define GET_MSG_SENT_ONLY   2
2181
2182
2183 struct reply_message_request
2184 {
2185     struct request_header __header;
2186     unsigned int    result;
2187     int             remove;
2188     /* VARARG(data,bytes); */
2189 };
2190 struct reply_message_reply
2191 {
2192     struct reply_header __header;
2193 };
2194
2195
2196
2197 struct accept_hardware_message_request
2198 {
2199     struct request_header __header;
2200     unsigned int    hw_id;
2201     int             remove;
2202     user_handle_t   new_win;
2203 };
2204 struct accept_hardware_message_reply
2205 {
2206     struct reply_header __header;
2207 };
2208
2209
2210
2211 struct get_message_reply_request
2212 {
2213     struct request_header __header;
2214     int             cancel;
2215 };
2216 struct get_message_reply_reply
2217 {
2218     struct reply_header __header;
2219     unsigned int    result;
2220     /* VARARG(data,bytes); */
2221 };
2222
2223
2224
2225 struct set_win_timer_request
2226 {
2227     struct request_header __header;
2228     user_handle_t   win;
2229     unsigned int    msg;
2230     unsigned int    id;
2231     unsigned int    rate;
2232     unsigned int    lparam;
2233 };
2234 struct set_win_timer_reply
2235 {
2236     struct reply_header __header;
2237     unsigned int    id;
2238 };
2239
2240
2241
2242 struct kill_win_timer_request
2243 {
2244     struct request_header __header;
2245     user_handle_t   win;
2246     unsigned int    msg;
2247     unsigned int    id;
2248 };
2249 struct kill_win_timer_reply
2250 {
2251     struct reply_header __header;
2252 };
2253
2254
2255
2256 struct get_serial_info_request
2257 {
2258     struct request_header __header;
2259     obj_handle_t handle;
2260 };
2261 struct get_serial_info_reply
2262 {
2263     struct reply_header __header;
2264     unsigned int readinterval;
2265     unsigned int readconst;
2266     unsigned int readmult;
2267     unsigned int writeconst;
2268     unsigned int writemult;
2269     unsigned int eventmask;
2270     unsigned int commerror;
2271 };
2272
2273
2274
2275 struct set_serial_info_request
2276 {
2277     struct request_header __header;
2278     obj_handle_t handle;
2279     int          flags;
2280     unsigned int readinterval;
2281     unsigned int readconst;
2282     unsigned int readmult;
2283     unsigned int writeconst;
2284     unsigned int writemult;
2285     unsigned int eventmask;
2286     unsigned int commerror;
2287 };
2288 struct set_serial_info_reply
2289 {
2290     struct reply_header __header;
2291 };
2292 #define SERIALINFO_SET_TIMEOUTS  0x01
2293 #define SERIALINFO_SET_MASK      0x02
2294 #define SERIALINFO_SET_ERROR     0x04
2295
2296
2297
2298 struct register_async_request
2299 {
2300     struct request_header __header;
2301     obj_handle_t handle;
2302     int          type;
2303     void*        io_apc;
2304     void*        io_sb;
2305     void*        io_user;
2306     int          count;
2307 };
2308 struct register_async_reply
2309 {
2310     struct reply_header __header;
2311 };
2312 #define ASYNC_TYPE_READ  0x01
2313 #define ASYNC_TYPE_WRITE 0x02
2314 #define ASYNC_TYPE_WAIT  0x03
2315
2316
2317
2318 struct cancel_async_request
2319 {
2320     struct request_header __header;
2321     obj_handle_t handle;
2322 };
2323 struct cancel_async_reply
2324 {
2325     struct reply_header __header;
2326 };
2327
2328
2329
2330 struct create_named_pipe_request
2331 {
2332     struct request_header __header;
2333     unsigned int   options;
2334     unsigned int   flags;
2335     unsigned int   maxinstances;
2336     unsigned int   outsize;
2337     unsigned int   insize;
2338     unsigned int   timeout;
2339     int            inherit;
2340     /* VARARG(name,unicode_str); */
2341 };
2342 struct create_named_pipe_reply
2343 {
2344     struct reply_header __header;
2345     obj_handle_t   handle;
2346 };
2347
2348
2349 #define NAMED_PIPE_MESSAGE_STREAM_WRITE 0x0001
2350 #define NAMED_PIPE_MESSAGE_STREAM_READ  0x0002
2351 #define NAMED_PIPE_NONBLOCKING_MODE     0x0004
2352
2353
2354
2355 struct open_named_pipe_request
2356 {
2357     struct request_header __header;
2358     unsigned int   access;
2359     int            inherit;
2360     /* VARARG(name,unicode_str); */
2361 };
2362 struct open_named_pipe_reply
2363 {
2364     struct reply_header __header;
2365     obj_handle_t   handle;
2366 };
2367
2368
2369
2370 struct connect_named_pipe_request
2371 {
2372     struct request_header __header;
2373     obj_handle_t   handle;
2374     void*          overlapped;
2375     void*          func;
2376 };
2377 struct connect_named_pipe_reply
2378 {
2379     struct reply_header __header;
2380 };
2381
2382
2383
2384 struct wait_named_pipe_request
2385 {
2386     struct request_header __header;
2387     unsigned int   timeout;
2388     void*          overlapped;
2389     void*          func;
2390     /* VARARG(name,unicode_str); */
2391 };
2392 struct wait_named_pipe_reply
2393 {
2394     struct reply_header __header;
2395 };
2396
2397
2398
2399 struct disconnect_named_pipe_request
2400 {
2401     struct request_header __header;
2402     obj_handle_t   handle;
2403 };
2404 struct disconnect_named_pipe_reply
2405 {
2406     struct reply_header __header;
2407     int            fd;
2408 };
2409
2410
2411 struct get_named_pipe_info_request
2412 {
2413     struct request_header __header;
2414     obj_handle_t   handle;
2415 };
2416 struct get_named_pipe_info_reply
2417 {
2418     struct reply_header __header;
2419     unsigned int   flags;
2420     unsigned int   maxinstances;
2421     unsigned int   outsize;
2422     unsigned int   insize;
2423 };
2424
2425
2426
2427 struct create_window_request
2428 {
2429     struct request_header __header;
2430     user_handle_t  parent;
2431     user_handle_t  owner;
2432     atom_t         atom;
2433     void*          instance;
2434 };
2435 struct create_window_reply
2436 {
2437     struct reply_header __header;
2438     user_handle_t  handle;
2439     int            extra;
2440     void*          class_ptr;
2441 };
2442
2443
2444
2445 struct destroy_window_request
2446 {
2447     struct request_header __header;
2448     user_handle_t  handle;
2449 };
2450 struct destroy_window_reply
2451 {
2452     struct reply_header __header;
2453 };
2454
2455
2456
2457 struct set_window_owner_request
2458 {
2459     struct request_header __header;
2460     user_handle_t  handle;
2461     user_handle_t  owner;
2462 };
2463 struct set_window_owner_reply
2464 {
2465     struct reply_header __header;
2466     user_handle_t  full_owner;
2467     user_handle_t  prev_owner;
2468 };
2469
2470
2471
2472 struct get_window_info_request
2473 {
2474     struct request_header __header;
2475     user_handle_t  handle;
2476 };
2477 struct get_window_info_reply
2478 {
2479     struct reply_header __header;
2480     user_handle_t  full_handle;
2481     user_handle_t  last_active;
2482     process_id_t   pid;
2483     thread_id_t    tid;
2484     atom_t         atom;
2485 };
2486
2487
2488
2489 struct set_window_info_request
2490 {
2491     struct request_header __header;
2492     user_handle_t  handle;
2493     unsigned int   flags;
2494     unsigned int   style;
2495     unsigned int   ex_style;
2496     unsigned int   id;
2497     void*          instance;
2498     void*          user_data;
2499     int            extra_offset;
2500     size_t         extra_size;
2501     unsigned int   extra_value;
2502 };
2503 struct set_window_info_reply
2504 {
2505     struct reply_header __header;
2506     unsigned int   old_style;
2507     unsigned int   old_ex_style;
2508     unsigned int   old_id;
2509     void*          old_instance;
2510     void*          old_user_data;
2511     unsigned int   old_extra_value;
2512 };
2513 #define SET_WIN_STYLE     0x01
2514 #define SET_WIN_EXSTYLE   0x02
2515 #define SET_WIN_ID        0x04
2516 #define SET_WIN_INSTANCE  0x08
2517 #define SET_WIN_USERDATA  0x10
2518 #define SET_WIN_EXTRA     0x20
2519
2520
2521
2522 struct set_parent_request
2523 {
2524     struct request_header __header;
2525     user_handle_t  handle;
2526     user_handle_t  parent;
2527 };
2528 struct set_parent_reply
2529 {
2530     struct reply_header __header;
2531     user_handle_t  old_parent;
2532     user_handle_t  full_parent;
2533 };
2534
2535
2536
2537 struct get_window_parents_request
2538 {
2539     struct request_header __header;
2540     user_handle_t  handle;
2541 };
2542 struct get_window_parents_reply
2543 {
2544     struct reply_header __header;
2545     int            count;
2546     /* VARARG(parents,user_handles); */
2547 };
2548
2549
2550
2551 struct get_window_children_request
2552 {
2553     struct request_header __header;
2554     user_handle_t  parent;
2555     atom_t         atom;
2556     thread_id_t    tid;
2557 };
2558 struct get_window_children_reply
2559 {
2560     struct reply_header __header;
2561     int            count;
2562     /* VARARG(children,user_handles); */
2563 };
2564
2565
2566
2567 struct get_window_children_from_point_request
2568 {
2569     struct request_header __header;
2570     user_handle_t  parent;
2571     int            x;
2572     int            y;
2573 };
2574 struct get_window_children_from_point_reply
2575 {
2576     struct reply_header __header;
2577     int            count;
2578     /* VARARG(children,user_handles); */
2579 };
2580
2581
2582
2583 struct get_window_tree_request
2584 {
2585     struct request_header __header;
2586     user_handle_t  handle;
2587 };
2588 struct get_window_tree_reply
2589 {
2590     struct reply_header __header;
2591     user_handle_t  parent;
2592     user_handle_t  owner;
2593     user_handle_t  next_sibling;
2594     user_handle_t  prev_sibling;
2595     user_handle_t  first_sibling;
2596     user_handle_t  last_sibling;
2597     user_handle_t  first_child;
2598     user_handle_t  last_child;
2599 };
2600
2601
2602 struct set_window_pos_request
2603 {
2604     struct request_header __header;
2605     user_handle_t  handle;
2606     user_handle_t  previous;
2607     unsigned int   flags;
2608     rectangle_t    window;
2609     rectangle_t    client;
2610     /* VARARG(valid,rectangles); */
2611 };
2612 struct set_window_pos_reply
2613 {
2614     struct reply_header __header;
2615     unsigned int   new_style;
2616 };
2617
2618
2619
2620 struct get_window_rectangles_request
2621 {
2622     struct request_header __header;
2623     user_handle_t  handle;
2624 };
2625 struct get_window_rectangles_reply
2626 {
2627     struct reply_header __header;
2628     rectangle_t    window;
2629     rectangle_t    visible;
2630     rectangle_t    client;
2631 };
2632
2633
2634
2635 struct get_window_text_request
2636 {
2637     struct request_header __header;
2638     user_handle_t  handle;
2639 };
2640 struct get_window_text_reply
2641 {
2642     struct reply_header __header;
2643     /* VARARG(text,unicode_str); */
2644 };
2645
2646
2647
2648 struct set_window_text_request
2649 {
2650     struct request_header __header;
2651     user_handle_t  handle;
2652     /* VARARG(text,unicode_str); */
2653 };
2654 struct set_window_text_reply
2655 {
2656     struct reply_header __header;
2657 };
2658
2659
2660
2661 struct get_windows_offset_request
2662 {
2663     struct request_header __header;
2664     user_handle_t  from;
2665     user_handle_t  to;
2666 };
2667 struct get_windows_offset_reply
2668 {
2669     struct reply_header __header;
2670     int            x;
2671     int            y;
2672 };
2673
2674
2675
2676 struct get_visible_region_request
2677 {
2678     struct request_header __header;
2679     user_handle_t  window;
2680     unsigned int   flags;
2681 };
2682 struct get_visible_region_reply
2683 {
2684     struct reply_header __header;
2685     user_handle_t  top_win;
2686     int            top_org_x;
2687     int            top_org_y;
2688     int            win_org_x;
2689     int            win_org_y;
2690     size_t         total_size;
2691     /* VARARG(region,rectangles); */
2692 };
2693
2694
2695
2696 struct get_window_region_request
2697 {
2698     struct request_header __header;
2699     user_handle_t  window;
2700 };
2701 struct get_window_region_reply
2702 {
2703     struct reply_header __header;
2704     size_t         total_size;
2705     /* VARARG(region,rectangles); */
2706 };
2707
2708
2709
2710 struct set_window_region_request
2711 {
2712     struct request_header __header;
2713     user_handle_t  window;
2714     /* VARARG(region,rectangles); */
2715 };
2716 struct set_window_region_reply
2717 {
2718     struct reply_header __header;
2719 };
2720
2721
2722
2723 struct get_update_region_request
2724 {
2725     struct request_header __header;
2726     user_handle_t  window;
2727     unsigned int   flags;
2728 };
2729 struct get_update_region_reply
2730 {
2731     struct reply_header __header;
2732     user_handle_t  child;
2733     unsigned int   flags;
2734     size_t         total_size;
2735     /* VARARG(region,rectangles); */
2736 };
2737 #define UPDATE_NONCLIENT       0x01
2738 #define UPDATE_ERASE           0x02
2739 #define UPDATE_PAINT           0x04
2740 #define UPDATE_INTERNALPAINT   0x08
2741 #define UPDATE_ALLCHILDREN     0x10
2742 #define UPDATE_NOCHILDREN      0x20
2743 #define UPDATE_NOREGION        0x40
2744
2745
2746
2747 struct update_window_zorder_request
2748 {
2749     struct request_header __header;
2750     user_handle_t  window;
2751     rectangle_t    rect;
2752 };
2753 struct update_window_zorder_reply
2754 {
2755     struct reply_header __header;
2756 };
2757
2758
2759
2760 struct redraw_window_request
2761 {
2762     struct request_header __header;
2763     user_handle_t  window;
2764     unsigned int   flags;
2765     /* VARARG(region,rectangles); */
2766 };
2767 struct redraw_window_reply
2768 {
2769     struct reply_header __header;
2770 };
2771
2772
2773
2774 struct set_window_property_request
2775 {
2776     struct request_header __header;
2777     user_handle_t  window;
2778     atom_t         atom;
2779     int            string;
2780     obj_handle_t   handle;
2781 };
2782 struct set_window_property_reply
2783 {
2784     struct reply_header __header;
2785 };
2786
2787
2788
2789 struct remove_window_property_request
2790 {
2791     struct request_header __header;
2792     user_handle_t  window;
2793     atom_t         atom;
2794 };
2795 struct remove_window_property_reply
2796 {
2797     struct reply_header __header;
2798     obj_handle_t   handle;
2799 };
2800
2801
2802
2803 struct get_window_property_request
2804 {
2805     struct request_header __header;
2806     user_handle_t  window;
2807     atom_t         atom;
2808 };
2809 struct get_window_property_reply
2810 {
2811     struct reply_header __header;
2812     obj_handle_t   handle;
2813 };
2814
2815
2816
2817 struct get_window_properties_request
2818 {
2819     struct request_header __header;
2820     user_handle_t  window;
2821 };
2822 struct get_window_properties_reply
2823 {
2824     struct reply_header __header;
2825     int            total;
2826     /* VARARG(props,properties); */
2827 };
2828
2829
2830
2831 struct attach_thread_input_request
2832 {
2833     struct request_header __header;
2834     thread_id_t    tid_from;
2835     thread_id_t    tid_to;
2836     int            attach;
2837 };
2838 struct attach_thread_input_reply
2839 {
2840     struct reply_header __header;
2841 };
2842
2843
2844
2845 struct get_thread_input_request
2846 {
2847     struct request_header __header;
2848     thread_id_t    tid;
2849 };
2850 struct get_thread_input_reply
2851 {
2852     struct reply_header __header;
2853     user_handle_t  focus;
2854     user_handle_t  capture;
2855     user_handle_t  active;
2856     user_handle_t  foreground;
2857     user_handle_t  menu_owner;
2858     user_handle_t  move_size;
2859     user_handle_t  caret;
2860     rectangle_t    rect;
2861 };
2862
2863
2864 struct get_key_state_request
2865 {
2866     struct request_header __header;
2867     thread_id_t    tid;
2868     int            key;
2869 };
2870 struct get_key_state_reply
2871 {
2872     struct reply_header __header;
2873     unsigned char  state;
2874     /* VARARG(keystate,bytes); */
2875 };
2876
2877
2878 struct set_key_state_request
2879 {
2880     struct request_header __header;
2881     thread_id_t    tid;
2882     /* VARARG(keystate,bytes); */
2883 };
2884 struct set_key_state_reply
2885 {
2886     struct reply_header __header;
2887 };
2888
2889
2890 struct set_foreground_window_request
2891 {
2892     struct request_header __header;
2893     user_handle_t  handle;
2894 };
2895 struct set_foreground_window_reply
2896 {
2897     struct reply_header __header;
2898     user_handle_t  previous;
2899     int            send_msg_old;
2900     int            send_msg_new;
2901 };
2902
2903
2904 struct set_focus_window_request
2905 {
2906     struct request_header __header;
2907     user_handle_t  handle;
2908 };
2909 struct set_focus_window_reply
2910 {
2911     struct reply_header __header;
2912     user_handle_t  previous;
2913 };
2914
2915
2916 struct set_active_window_request
2917 {
2918     struct request_header __header;
2919     user_handle_t  handle;
2920 };
2921 struct set_active_window_reply
2922 {
2923     struct reply_header __header;
2924     user_handle_t  previous;
2925 };
2926
2927
2928 struct set_capture_window_request
2929 {
2930     struct request_header __header;
2931     user_handle_t  handle;
2932     unsigned int   flags;
2933 };
2934 struct set_capture_window_reply
2935 {
2936     struct reply_header __header;
2937     user_handle_t  previous;
2938     user_handle_t  full_handle;
2939 };
2940 #define CAPTURE_MENU     0x01
2941 #define CAPTURE_MOVESIZE 0x02
2942
2943
2944
2945 struct set_caret_window_request
2946 {
2947     struct request_header __header;
2948     user_handle_t  handle;
2949     int            width;
2950     int            height;
2951 };
2952 struct set_caret_window_reply
2953 {
2954     struct reply_header __header;
2955     user_handle_t  previous;
2956     rectangle_t    old_rect;
2957     int            old_hide;
2958     int            old_state;
2959 };
2960
2961
2962
2963 struct set_caret_info_request
2964 {
2965     struct request_header __header;
2966     unsigned int   flags;
2967     user_handle_t  handle;
2968     int            x;
2969     int            y;
2970     int            hide;
2971     int            state;
2972 };
2973 struct set_caret_info_reply
2974 {
2975     struct reply_header __header;
2976     user_handle_t  full_handle;
2977     rectangle_t    old_rect;
2978     int            old_hide;
2979     int            old_state;
2980 };
2981 #define SET_CARET_POS        0x01
2982 #define SET_CARET_HIDE       0x02
2983 #define SET_CARET_STATE      0x04
2984
2985
2986
2987 struct set_hook_request
2988 {
2989     struct request_header __header;
2990     int            id;
2991     process_id_t   pid;
2992     thread_id_t    tid;
2993     int            event_min;
2994     int            event_max;
2995     int            flags;
2996     void*          proc;
2997     int            unicode;
2998     /* VARARG(module,unicode_str); */
2999 };
3000 struct set_hook_reply
3001 {
3002     struct reply_header __header;
3003     user_handle_t  handle;
3004 };
3005
3006
3007
3008 struct remove_hook_request
3009 {
3010     struct request_header __header;
3011     user_handle_t  handle;
3012     int            id;
3013     void*          proc;
3014 };
3015 struct remove_hook_reply
3016 {
3017     struct reply_header __header;
3018 };
3019
3020
3021
3022 struct start_hook_chain_request
3023 {
3024     struct request_header __header;
3025     int            id;
3026     int            event;
3027     user_handle_t  window;
3028     int            object_id;
3029     int            child_id;
3030 };
3031 struct start_hook_chain_reply
3032 {
3033     struct reply_header __header;
3034     user_handle_t  handle;
3035     process_id_t   pid;
3036     thread_id_t    tid;
3037     void*          proc;
3038     int            unicode;
3039     /* VARARG(module,unicode_str); */
3040 };
3041
3042
3043
3044 struct finish_hook_chain_request
3045 {
3046     struct request_header __header;
3047     int            id;
3048 };
3049 struct finish_hook_chain_reply
3050 {
3051     struct reply_header __header;
3052 };
3053
3054
3055
3056 struct get_next_hook_request
3057 {
3058     struct request_header __header;
3059     user_handle_t  handle;
3060     int            event;
3061     user_handle_t  window;
3062     int            object_id;
3063     int            child_id;
3064 };
3065 struct get_next_hook_reply
3066 {
3067     struct reply_header __header;
3068     user_handle_t  next;
3069     int            id;
3070     process_id_t   pid;
3071     thread_id_t    tid;
3072     void*          proc;
3073     int            prev_unicode;
3074     int            next_unicode;
3075     /* VARARG(module,unicode_str); */
3076 };
3077
3078
3079
3080 struct create_class_request
3081 {
3082     struct request_header __header;
3083     int            local;
3084     atom_t         atom;
3085     unsigned int   style;
3086     void*          instance;
3087     int            extra;
3088     int            win_extra;
3089     void*          client_ptr;
3090 };
3091 struct create_class_reply
3092 {
3093     struct reply_header __header;
3094 };
3095
3096
3097
3098 struct destroy_class_request
3099 {
3100     struct request_header __header;
3101     atom_t         atom;
3102     void*          instance;
3103 };
3104 struct destroy_class_reply
3105 {
3106     struct reply_header __header;
3107     void*          client_ptr;
3108 };
3109
3110
3111
3112 struct set_class_info_request
3113 {
3114     struct request_header __header;
3115     user_handle_t  window;
3116     unsigned int   flags;
3117     atom_t         atom;
3118     unsigned int   style;
3119     int            win_extra;
3120     void*          instance;
3121     int            extra_offset;
3122     size_t         extra_size;
3123     unsigned int   extra_value;
3124 };
3125 struct set_class_info_reply
3126 {
3127     struct reply_header __header;
3128     atom_t         old_atom;
3129     unsigned int   old_style;
3130     int            old_extra;
3131     int            old_win_extra;
3132     void*          old_instance;
3133     unsigned int   old_extra_value;
3134 };
3135 #define SET_CLASS_ATOM      0x0001
3136 #define SET_CLASS_STYLE     0x0002
3137 #define SET_CLASS_WINEXTRA  0x0004
3138 #define SET_CLASS_INSTANCE  0x0008
3139 #define SET_CLASS_EXTRA     0x0010
3140
3141
3142
3143 struct set_clipboard_info_request
3144 {
3145     struct request_header __header;
3146     unsigned int   flags;
3147     user_handle_t  clipboard;
3148     user_handle_t  owner;
3149     user_handle_t  viewer;
3150     unsigned int   seqno;
3151 };
3152 struct set_clipboard_info_reply
3153 {
3154     struct reply_header __header;
3155     unsigned int   flags;
3156     user_handle_t  old_clipboard;
3157     user_handle_t  old_owner;
3158     user_handle_t  old_viewer;
3159     unsigned int   seqno;
3160 };
3161
3162 #define SET_CB_OPEN      0x001
3163 #define SET_CB_OWNER     0x002
3164 #define SET_CB_VIEWER    0x004
3165 #define SET_CB_SEQNO     0x008
3166 #define SET_CB_RELOWNER  0x010
3167 #define SET_CB_CLOSE     0x020
3168 #define CB_OPEN          0x040
3169 #define CB_OWNER         0x080
3170 #define CB_PROCESS       0x100
3171
3172
3173
3174 struct open_token_request
3175 {
3176     struct request_header __header;
3177     obj_handle_t   handle;
3178     unsigned int   flags;
3179 };
3180 struct open_token_reply
3181 {
3182     struct reply_header __header;
3183     obj_handle_t   token;
3184 };
3185 #define OPEN_TOKEN_THREAD   1
3186 #define OPEN_TOKEN_AS_SELF  2
3187
3188
3189
3190 struct set_global_windows_request
3191 {
3192     struct request_header __header;
3193     unsigned int   flags;
3194     user_handle_t  shell_window;
3195     user_handle_t  shell_listview;
3196     user_handle_t  progman_window;
3197     user_handle_t  taskman_window;
3198 };
3199 struct set_global_windows_reply
3200 {
3201     struct reply_header __header;
3202     user_handle_t  old_shell_window;
3203     user_handle_t  old_shell_listview;
3204     user_handle_t  old_progman_window;
3205     user_handle_t  old_taskman_window;
3206 };
3207 #define SET_GLOBAL_SHELL_WINDOWS   0x01
3208 #define SET_GLOBAL_PROGMAN_WINDOW  0x02
3209 #define SET_GLOBAL_TASKMAN_WINDOW  0x04
3210
3211
3212 struct adjust_token_privileges_request
3213 {
3214     struct request_header __header;
3215     obj_handle_t  handle;
3216     int           disable_all;
3217     int           get_modified_state;
3218     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
3219 };
3220 struct adjust_token_privileges_reply
3221 {
3222     struct reply_header __header;
3223     unsigned int  len;
3224     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
3225 };
3226
3227
3228 struct get_token_privileges_request
3229 {
3230     struct request_header __header;
3231     obj_handle_t  handle;
3232 };
3233 struct get_token_privileges_reply
3234 {
3235     struct reply_header __header;
3236     unsigned int  len;
3237     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
3238 };
3239
3240 struct duplicate_token_request
3241 {
3242     struct request_header __header;
3243     obj_handle_t  handle;
3244     unsigned int  access;
3245     int           inherit;
3246     int           primary;
3247     int           impersonation_level;
3248 };
3249 struct duplicate_token_reply
3250 {
3251     struct reply_header __header;
3252     obj_handle_t  new_handle;
3253 };
3254
3255
3256
3257 struct create_mailslot_request
3258 {
3259     struct request_header __header;
3260     unsigned int   max_msgsize;
3261     unsigned int   read_timeout;
3262     int            inherit;
3263     /* VARARG(name,unicode_str); */
3264 };
3265 struct create_mailslot_reply
3266 {
3267     struct reply_header __header;
3268     obj_handle_t   handle;
3269 };
3270
3271
3272
3273 struct open_mailslot_request
3274 {
3275     struct request_header __header;
3276     unsigned int   access;
3277     int            inherit;
3278     unsigned int   sharing;
3279     /* VARARG(name,unicode_str); */
3280 };
3281 struct open_mailslot_reply
3282 {
3283     struct reply_header __header;
3284     obj_handle_t   handle;
3285 };
3286
3287
3288
3289 struct set_mailslot_info_request
3290 {
3291     struct request_header __header;
3292     obj_handle_t   handle;
3293     unsigned int   flags;
3294     unsigned int   read_timeout;
3295 };
3296 struct set_mailslot_info_reply
3297 {
3298     struct reply_header __header;
3299     unsigned int   max_msgsize;
3300     unsigned int   read_timeout;
3301     unsigned int   msg_count;
3302     unsigned int   next_msgsize;
3303 };
3304 #define MAILSLOT_SET_READ_TIMEOUT  1
3305
3306
3307 enum request
3308 {
3309     REQ_new_process,
3310     REQ_get_new_process_info,
3311     REQ_new_thread,
3312     REQ_boot_done,
3313     REQ_init_process,
3314     REQ_get_startup_info,
3315     REQ_init_process_done,
3316     REQ_init_thread,
3317     REQ_terminate_process,
3318     REQ_terminate_thread,
3319     REQ_get_process_info,
3320     REQ_set_process_info,
3321     REQ_get_thread_info,
3322     REQ_set_thread_info,
3323     REQ_get_dll_info,
3324     REQ_suspend_thread,
3325     REQ_resume_thread,
3326     REQ_load_dll,
3327     REQ_unload_dll,
3328     REQ_queue_apc,
3329     REQ_get_apc,
3330     REQ_close_handle,
3331     REQ_set_handle_info,
3332     REQ_dup_handle,
3333     REQ_open_process,
3334     REQ_open_thread,
3335     REQ_select,
3336     REQ_create_event,
3337     REQ_event_op,
3338     REQ_open_event,
3339     REQ_create_mutex,
3340     REQ_release_mutex,
3341     REQ_open_mutex,
3342     REQ_create_semaphore,
3343     REQ_release_semaphore,
3344     REQ_open_semaphore,
3345     REQ_create_file,
3346     REQ_alloc_file_handle,
3347     REQ_get_handle_fd,
3348     REQ_flush_file,
3349     REQ_lock_file,
3350     REQ_unlock_file,
3351     REQ_create_socket,
3352     REQ_accept_socket,
3353     REQ_set_socket_event,
3354     REQ_get_socket_event,
3355     REQ_enable_socket_event,
3356     REQ_set_socket_deferred,
3357     REQ_alloc_console,
3358     REQ_free_console,
3359     REQ_get_console_renderer_events,
3360     REQ_open_console,
3361     REQ_get_console_wait_event,
3362     REQ_get_console_mode,
3363     REQ_set_console_mode,
3364     REQ_set_console_input_info,
3365     REQ_get_console_input_info,
3366     REQ_append_console_input_history,
3367     REQ_get_console_input_history,
3368     REQ_create_console_output,
3369     REQ_set_console_output_info,
3370     REQ_get_console_output_info,
3371     REQ_write_console_input,
3372     REQ_read_console_input,
3373     REQ_write_console_output,
3374     REQ_fill_console_output,
3375     REQ_read_console_output,
3376     REQ_move_console_output,
3377     REQ_send_console_signal,
3378     REQ_create_change_notification,
3379     REQ_next_change_notification,
3380     REQ_create_mapping,
3381     REQ_open_mapping,
3382     REQ_get_mapping_info,
3383     REQ_create_snapshot,
3384     REQ_next_process,
3385     REQ_next_thread,
3386     REQ_next_module,
3387     REQ_wait_debug_event,
3388     REQ_queue_exception_event,
3389     REQ_get_exception_status,
3390     REQ_output_debug_string,
3391     REQ_continue_debug_event,
3392     REQ_debug_process,
3393     REQ_debug_break,
3394     REQ_set_debugger_kill_on_exit,
3395     REQ_read_process_memory,
3396     REQ_write_process_memory,
3397     REQ_create_key,
3398     REQ_open_key,
3399     REQ_delete_key,
3400     REQ_flush_key,
3401     REQ_enum_key,
3402     REQ_set_key_value,
3403     REQ_get_key_value,
3404     REQ_enum_key_value,
3405     REQ_delete_key_value,
3406     REQ_load_registry,
3407     REQ_unload_registry,
3408     REQ_save_registry,
3409     REQ_load_user_registries,
3410     REQ_set_registry_notification,
3411     REQ_create_timer,
3412     REQ_open_timer,
3413     REQ_set_timer,
3414     REQ_cancel_timer,
3415     REQ_get_timer_info,
3416     REQ_get_thread_context,
3417     REQ_set_thread_context,
3418     REQ_get_selector_entry,
3419     REQ_add_atom,
3420     REQ_delete_atom,
3421     REQ_find_atom,
3422     REQ_get_atom_name,
3423     REQ_init_atom_table,
3424     REQ_get_msg_queue,
3425     REQ_set_queue_mask,
3426     REQ_get_queue_status,
3427     REQ_wait_input_idle,
3428     REQ_send_message,
3429     REQ_get_message,
3430     REQ_reply_message,
3431     REQ_accept_hardware_message,
3432     REQ_get_message_reply,
3433     REQ_set_win_timer,
3434     REQ_kill_win_timer,
3435     REQ_get_serial_info,
3436     REQ_set_serial_info,
3437     REQ_register_async,
3438     REQ_cancel_async,
3439     REQ_create_named_pipe,
3440     REQ_open_named_pipe,
3441     REQ_connect_named_pipe,
3442     REQ_wait_named_pipe,
3443     REQ_disconnect_named_pipe,
3444     REQ_get_named_pipe_info,
3445     REQ_create_window,
3446     REQ_destroy_window,
3447     REQ_set_window_owner,
3448     REQ_get_window_info,
3449     REQ_set_window_info,
3450     REQ_set_parent,
3451     REQ_get_window_parents,
3452     REQ_get_window_children,
3453     REQ_get_window_children_from_point,
3454     REQ_get_window_tree,
3455     REQ_set_window_pos,
3456     REQ_get_window_rectangles,
3457     REQ_get_window_text,
3458     REQ_set_window_text,
3459     REQ_get_windows_offset,
3460     REQ_get_visible_region,
3461     REQ_get_window_region,
3462     REQ_set_window_region,
3463     REQ_get_update_region,
3464     REQ_update_window_zorder,
3465     REQ_redraw_window,
3466     REQ_set_window_property,
3467     REQ_remove_window_property,
3468     REQ_get_window_property,
3469     REQ_get_window_properties,
3470     REQ_attach_thread_input,
3471     REQ_get_thread_input,
3472     REQ_get_key_state,
3473     REQ_set_key_state,
3474     REQ_set_foreground_window,
3475     REQ_set_focus_window,
3476     REQ_set_active_window,
3477     REQ_set_capture_window,
3478     REQ_set_caret_window,
3479     REQ_set_caret_info,
3480     REQ_set_hook,
3481     REQ_remove_hook,
3482     REQ_start_hook_chain,
3483     REQ_finish_hook_chain,
3484     REQ_get_next_hook,
3485     REQ_create_class,
3486     REQ_destroy_class,
3487     REQ_set_class_info,
3488     REQ_set_clipboard_info,
3489     REQ_open_token,
3490     REQ_set_global_windows,
3491     REQ_adjust_token_privileges,
3492     REQ_get_token_privileges,
3493     REQ_duplicate_token,
3494     REQ_create_mailslot,
3495     REQ_open_mailslot,
3496     REQ_set_mailslot_info,
3497     REQ_NB_REQUESTS
3498 };
3499
3500 union generic_request
3501 {
3502     struct request_max_size max_size;
3503     struct request_header request_header;
3504     struct new_process_request new_process_request;
3505     struct get_new_process_info_request get_new_process_info_request;
3506     struct new_thread_request new_thread_request;
3507     struct boot_done_request boot_done_request;
3508     struct init_process_request init_process_request;
3509     struct get_startup_info_request get_startup_info_request;
3510     struct init_process_done_request init_process_done_request;
3511     struct init_thread_request init_thread_request;
3512     struct terminate_process_request terminate_process_request;
3513     struct terminate_thread_request terminate_thread_request;
3514     struct get_process_info_request get_process_info_request;
3515     struct set_process_info_request set_process_info_request;
3516     struct get_thread_info_request get_thread_info_request;
3517     struct set_thread_info_request set_thread_info_request;
3518     struct get_dll_info_request get_dll_info_request;
3519     struct suspend_thread_request suspend_thread_request;
3520     struct resume_thread_request resume_thread_request;
3521     struct load_dll_request load_dll_request;
3522     struct unload_dll_request unload_dll_request;
3523     struct queue_apc_request queue_apc_request;
3524     struct get_apc_request get_apc_request;
3525     struct close_handle_request close_handle_request;
3526     struct set_handle_info_request set_handle_info_request;
3527     struct dup_handle_request dup_handle_request;
3528     struct open_process_request open_process_request;
3529     struct open_thread_request open_thread_request;
3530     struct select_request select_request;
3531     struct create_event_request create_event_request;
3532     struct event_op_request event_op_request;
3533     struct open_event_request open_event_request;
3534     struct create_mutex_request create_mutex_request;
3535     struct release_mutex_request release_mutex_request;
3536     struct open_mutex_request open_mutex_request;
3537     struct create_semaphore_request create_semaphore_request;
3538     struct release_semaphore_request release_semaphore_request;
3539     struct open_semaphore_request open_semaphore_request;
3540     struct create_file_request create_file_request;
3541     struct alloc_file_handle_request alloc_file_handle_request;
3542     struct get_handle_fd_request get_handle_fd_request;
3543     struct flush_file_request flush_file_request;
3544     struct lock_file_request lock_file_request;
3545     struct unlock_file_request unlock_file_request;
3546     struct create_socket_request create_socket_request;
3547     struct accept_socket_request accept_socket_request;
3548     struct set_socket_event_request set_socket_event_request;
3549     struct get_socket_event_request get_socket_event_request;
3550     struct enable_socket_event_request enable_socket_event_request;
3551     struct set_socket_deferred_request set_socket_deferred_request;
3552     struct alloc_console_request alloc_console_request;
3553     struct free_console_request free_console_request;
3554     struct get_console_renderer_events_request get_console_renderer_events_request;
3555     struct open_console_request open_console_request;
3556     struct get_console_wait_event_request get_console_wait_event_request;
3557     struct get_console_mode_request get_console_mode_request;
3558     struct set_console_mode_request set_console_mode_request;
3559     struct set_console_input_info_request set_console_input_info_request;
3560     struct get_console_input_info_request get_console_input_info_request;
3561     struct append_console_input_history_request append_console_input_history_request;
3562     struct get_console_input_history_request get_console_input_history_request;
3563     struct create_console_output_request create_console_output_request;
3564     struct set_console_output_info_request set_console_output_info_request;
3565     struct get_console_output_info_request get_console_output_info_request;
3566     struct write_console_input_request write_console_input_request;
3567     struct read_console_input_request read_console_input_request;
3568     struct write_console_output_request write_console_output_request;
3569     struct fill_console_output_request fill_console_output_request;
3570     struct read_console_output_request read_console_output_request;
3571     struct move_console_output_request move_console_output_request;
3572     struct send_console_signal_request send_console_signal_request;
3573     struct create_change_notification_request create_change_notification_request;
3574     struct next_change_notification_request next_change_notification_request;
3575     struct create_mapping_request create_mapping_request;
3576     struct open_mapping_request open_mapping_request;
3577     struct get_mapping_info_request get_mapping_info_request;
3578     struct create_snapshot_request create_snapshot_request;
3579     struct next_process_request next_process_request;
3580     struct next_thread_request next_thread_request;
3581     struct next_module_request next_module_request;
3582     struct wait_debug_event_request wait_debug_event_request;
3583     struct queue_exception_event_request queue_exception_event_request;
3584     struct get_exception_status_request get_exception_status_request;
3585     struct output_debug_string_request output_debug_string_request;
3586     struct continue_debug_event_request continue_debug_event_request;
3587     struct debug_process_request debug_process_request;
3588     struct debug_break_request debug_break_request;
3589     struct set_debugger_kill_on_exit_request set_debugger_kill_on_exit_request;
3590     struct read_process_memory_request read_process_memory_request;
3591     struct write_process_memory_request write_process_memory_request;
3592     struct create_key_request create_key_request;
3593     struct open_key_request open_key_request;
3594     struct delete_key_request delete_key_request;
3595     struct flush_key_request flush_key_request;
3596     struct enum_key_request enum_key_request;
3597     struct set_key_value_request set_key_value_request;
3598     struct get_key_value_request get_key_value_request;
3599     struct enum_key_value_request enum_key_value_request;
3600     struct delete_key_value_request delete_key_value_request;
3601     struct load_registry_request load_registry_request;
3602     struct unload_registry_request unload_registry_request;
3603     struct save_registry_request save_registry_request;
3604     struct load_user_registries_request load_user_registries_request;
3605     struct set_registry_notification_request set_registry_notification_request;
3606     struct create_timer_request create_timer_request;
3607     struct open_timer_request open_timer_request;
3608     struct set_timer_request set_timer_request;
3609     struct cancel_timer_request cancel_timer_request;
3610     struct get_timer_info_request get_timer_info_request;
3611     struct get_thread_context_request get_thread_context_request;
3612     struct set_thread_context_request set_thread_context_request;
3613     struct get_selector_entry_request get_selector_entry_request;
3614     struct add_atom_request add_atom_request;
3615     struct delete_atom_request delete_atom_request;
3616     struct find_atom_request find_atom_request;
3617     struct get_atom_name_request get_atom_name_request;
3618     struct init_atom_table_request init_atom_table_request;
3619     struct get_msg_queue_request get_msg_queue_request;
3620     struct set_queue_mask_request set_queue_mask_request;
3621     struct get_queue_status_request get_queue_status_request;
3622     struct wait_input_idle_request wait_input_idle_request;
3623     struct send_message_request send_message_request;
3624     struct get_message_request get_message_request;
3625     struct reply_message_request reply_message_request;
3626     struct accept_hardware_message_request accept_hardware_message_request;
3627     struct get_message_reply_request get_message_reply_request;
3628     struct set_win_timer_request set_win_timer_request;
3629     struct kill_win_timer_request kill_win_timer_request;
3630     struct get_serial_info_request get_serial_info_request;
3631     struct set_serial_info_request set_serial_info_request;
3632     struct register_async_request register_async_request;
3633     struct cancel_async_request cancel_async_request;
3634     struct create_named_pipe_request create_named_pipe_request;
3635     struct open_named_pipe_request open_named_pipe_request;
3636     struct connect_named_pipe_request connect_named_pipe_request;
3637     struct wait_named_pipe_request wait_named_pipe_request;
3638     struct disconnect_named_pipe_request disconnect_named_pipe_request;
3639     struct get_named_pipe_info_request get_named_pipe_info_request;
3640     struct create_window_request create_window_request;
3641     struct destroy_window_request destroy_window_request;
3642     struct set_window_owner_request set_window_owner_request;
3643     struct get_window_info_request get_window_info_request;
3644     struct set_window_info_request set_window_info_request;
3645     struct set_parent_request set_parent_request;
3646     struct get_window_parents_request get_window_parents_request;
3647     struct get_window_children_request get_window_children_request;
3648     struct get_window_children_from_point_request get_window_children_from_point_request;
3649     struct get_window_tree_request get_window_tree_request;
3650     struct set_window_pos_request set_window_pos_request;
3651     struct get_window_rectangles_request get_window_rectangles_request;
3652     struct get_window_text_request get_window_text_request;
3653     struct set_window_text_request set_window_text_request;
3654     struct get_windows_offset_request get_windows_offset_request;
3655     struct get_visible_region_request get_visible_region_request;
3656     struct get_window_region_request get_window_region_request;
3657     struct set_window_region_request set_window_region_request;
3658     struct get_update_region_request get_update_region_request;
3659     struct update_window_zorder_request update_window_zorder_request;
3660     struct redraw_window_request redraw_window_request;
3661     struct set_window_property_request set_window_property_request;
3662     struct remove_window_property_request remove_window_property_request;
3663     struct get_window_property_request get_window_property_request;
3664     struct get_window_properties_request get_window_properties_request;
3665     struct attach_thread_input_request attach_thread_input_request;
3666     struct get_thread_input_request get_thread_input_request;
3667     struct get_key_state_request get_key_state_request;
3668     struct set_key_state_request set_key_state_request;
3669     struct set_foreground_window_request set_foreground_window_request;
3670     struct set_focus_window_request set_focus_window_request;
3671     struct set_active_window_request set_active_window_request;
3672     struct set_capture_window_request set_capture_window_request;
3673     struct set_caret_window_request set_caret_window_request;
3674     struct set_caret_info_request set_caret_info_request;
3675     struct set_hook_request set_hook_request;
3676     struct remove_hook_request remove_hook_request;
3677     struct start_hook_chain_request start_hook_chain_request;
3678     struct finish_hook_chain_request finish_hook_chain_request;
3679     struct get_next_hook_request get_next_hook_request;
3680     struct create_class_request create_class_request;
3681     struct destroy_class_request destroy_class_request;
3682     struct set_class_info_request set_class_info_request;
3683     struct set_clipboard_info_request set_clipboard_info_request;
3684     struct open_token_request open_token_request;
3685     struct set_global_windows_request set_global_windows_request;
3686     struct adjust_token_privileges_request adjust_token_privileges_request;
3687     struct get_token_privileges_request get_token_privileges_request;
3688     struct duplicate_token_request duplicate_token_request;
3689     struct create_mailslot_request create_mailslot_request;
3690     struct open_mailslot_request open_mailslot_request;
3691     struct set_mailslot_info_request set_mailslot_info_request;
3692 };
3693 union generic_reply
3694 {
3695     struct request_max_size max_size;
3696     struct reply_header reply_header;
3697     struct new_process_reply new_process_reply;
3698     struct get_new_process_info_reply get_new_process_info_reply;
3699     struct new_thread_reply new_thread_reply;
3700     struct boot_done_reply boot_done_reply;
3701     struct init_process_reply init_process_reply;
3702     struct get_startup_info_reply get_startup_info_reply;
3703     struct init_process_done_reply init_process_done_reply;
3704     struct init_thread_reply init_thread_reply;
3705     struct terminate_process_reply terminate_process_reply;
3706     struct terminate_thread_reply terminate_thread_reply;
3707     struct get_process_info_reply get_process_info_reply;
3708     struct set_process_info_reply set_process_info_reply;
3709     struct get_thread_info_reply get_thread_info_reply;
3710     struct set_thread_info_reply set_thread_info_reply;
3711     struct get_dll_info_reply get_dll_info_reply;
3712     struct suspend_thread_reply suspend_thread_reply;
3713     struct resume_thread_reply resume_thread_reply;
3714     struct load_dll_reply load_dll_reply;
3715     struct unload_dll_reply unload_dll_reply;
3716     struct queue_apc_reply queue_apc_reply;
3717     struct get_apc_reply get_apc_reply;
3718     struct close_handle_reply close_handle_reply;
3719     struct set_handle_info_reply set_handle_info_reply;
3720     struct dup_handle_reply dup_handle_reply;
3721     struct open_process_reply open_process_reply;
3722     struct open_thread_reply open_thread_reply;
3723     struct select_reply select_reply;
3724     struct create_event_reply create_event_reply;
3725     struct event_op_reply event_op_reply;
3726     struct open_event_reply open_event_reply;
3727     struct create_mutex_reply create_mutex_reply;
3728     struct release_mutex_reply release_mutex_reply;
3729     struct open_mutex_reply open_mutex_reply;
3730     struct create_semaphore_reply create_semaphore_reply;
3731     struct release_semaphore_reply release_semaphore_reply;
3732     struct open_semaphore_reply open_semaphore_reply;
3733     struct create_file_reply create_file_reply;
3734     struct alloc_file_handle_reply alloc_file_handle_reply;
3735     struct get_handle_fd_reply get_handle_fd_reply;
3736     struct flush_file_reply flush_file_reply;
3737     struct lock_file_reply lock_file_reply;
3738     struct unlock_file_reply unlock_file_reply;
3739     struct create_socket_reply create_socket_reply;
3740     struct accept_socket_reply accept_socket_reply;
3741     struct set_socket_event_reply set_socket_event_reply;
3742     struct get_socket_event_reply get_socket_event_reply;
3743     struct enable_socket_event_reply enable_socket_event_reply;
3744     struct set_socket_deferred_reply set_socket_deferred_reply;
3745     struct alloc_console_reply alloc_console_reply;
3746     struct free_console_reply free_console_reply;
3747     struct get_console_renderer_events_reply get_console_renderer_events_reply;
3748     struct open_console_reply open_console_reply;
3749     struct get_console_wait_event_reply get_console_wait_event_reply;
3750     struct get_console_mode_reply get_console_mode_reply;
3751     struct set_console_mode_reply set_console_mode_reply;
3752     struct set_console_input_info_reply set_console_input_info_reply;
3753     struct get_console_input_info_reply get_console_input_info_reply;
3754     struct append_console_input_history_reply append_console_input_history_reply;
3755     struct get_console_input_history_reply get_console_input_history_reply;
3756     struct create_console_output_reply create_console_output_reply;
3757     struct set_console_output_info_reply set_console_output_info_reply;
3758     struct get_console_output_info_reply get_console_output_info_reply;
3759     struct write_console_input_reply write_console_input_reply;
3760     struct read_console_input_reply read_console_input_reply;
3761     struct write_console_output_reply write_console_output_reply;
3762     struct fill_console_output_reply fill_console_output_reply;
3763     struct read_console_output_reply read_console_output_reply;
3764     struct move_console_output_reply move_console_output_reply;
3765     struct send_console_signal_reply send_console_signal_reply;
3766     struct create_change_notification_reply create_change_notification_reply;
3767     struct next_change_notification_reply next_change_notification_reply;
3768     struct create_mapping_reply create_mapping_reply;
3769     struct open_mapping_reply open_mapping_reply;
3770     struct get_mapping_info_reply get_mapping_info_reply;
3771     struct create_snapshot_reply create_snapshot_reply;
3772     struct next_process_reply next_process_reply;
3773     struct next_thread_reply next_thread_reply;
3774     struct next_module_reply next_module_reply;
3775     struct wait_debug_event_reply wait_debug_event_reply;
3776     struct queue_exception_event_reply queue_exception_event_reply;
3777     struct get_exception_status_reply get_exception_status_reply;
3778     struct output_debug_string_reply output_debug_string_reply;
3779     struct continue_debug_event_reply continue_debug_event_reply;
3780     struct debug_process_reply debug_process_reply;
3781     struct debug_break_reply debug_break_reply;
3782     struct set_debugger_kill_on_exit_reply set_debugger_kill_on_exit_reply;
3783     struct read_process_memory_reply read_process_memory_reply;
3784     struct write_process_memory_reply write_process_memory_reply;
3785     struct create_key_reply create_key_reply;
3786     struct open_key_reply open_key_reply;
3787     struct delete_key_reply delete_key_reply;
3788     struct flush_key_reply flush_key_reply;
3789     struct enum_key_reply enum_key_reply;
3790     struct set_key_value_reply set_key_value_reply;
3791     struct get_key_value_reply get_key_value_reply;
3792     struct enum_key_value_reply enum_key_value_reply;
3793     struct delete_key_value_reply delete_key_value_reply;
3794     struct load_registry_reply load_registry_reply;
3795     struct unload_registry_reply unload_registry_reply;
3796     struct save_registry_reply save_registry_reply;
3797     struct load_user_registries_reply load_user_registries_reply;
3798     struct set_registry_notification_reply set_registry_notification_reply;
3799     struct create_timer_reply create_timer_reply;
3800     struct open_timer_reply open_timer_reply;
3801     struct set_timer_reply set_timer_reply;
3802     struct cancel_timer_reply cancel_timer_reply;
3803     struct get_timer_info_reply get_timer_info_reply;
3804     struct get_thread_context_reply get_thread_context_reply;
3805     struct set_thread_context_reply set_thread_context_reply;
3806     struct get_selector_entry_reply get_selector_entry_reply;
3807     struct add_atom_reply add_atom_reply;
3808     struct delete_atom_reply delete_atom_reply;
3809     struct find_atom_reply find_atom_reply;
3810     struct get_atom_name_reply get_atom_name_reply;
3811     struct init_atom_table_reply init_atom_table_reply;
3812     struct get_msg_queue_reply get_msg_queue_reply;
3813     struct set_queue_mask_reply set_queue_mask_reply;
3814     struct get_queue_status_reply get_queue_status_reply;
3815     struct wait_input_idle_reply wait_input_idle_reply;
3816     struct send_message_reply send_message_reply;
3817     struct get_message_reply get_message_reply;
3818     struct reply_message_reply reply_message_reply;
3819     struct accept_hardware_message_reply accept_hardware_message_reply;
3820     struct get_message_reply_reply get_message_reply_reply;
3821     struct set_win_timer_reply set_win_timer_reply;
3822     struct kill_win_timer_reply kill_win_timer_reply;
3823     struct get_serial_info_reply get_serial_info_reply;
3824     struct set_serial_info_reply set_serial_info_reply;
3825     struct register_async_reply register_async_reply;
3826     struct cancel_async_reply cancel_async_reply;
3827     struct create_named_pipe_reply create_named_pipe_reply;
3828     struct open_named_pipe_reply open_named_pipe_reply;
3829     struct connect_named_pipe_reply connect_named_pipe_reply;
3830     struct wait_named_pipe_reply wait_named_pipe_reply;
3831     struct disconnect_named_pipe_reply disconnect_named_pipe_reply;
3832     struct get_named_pipe_info_reply get_named_pipe_info_reply;
3833     struct create_window_reply create_window_reply;
3834     struct destroy_window_reply destroy_window_reply;
3835     struct set_window_owner_reply set_window_owner_reply;
3836     struct get_window_info_reply get_window_info_reply;
3837     struct set_window_info_reply set_window_info_reply;
3838     struct set_parent_reply set_parent_reply;
3839     struct get_window_parents_reply get_window_parents_reply;
3840     struct get_window_children_reply get_window_children_reply;
3841     struct get_window_children_from_point_reply get_window_children_from_point_reply;
3842     struct get_window_tree_reply get_window_tree_reply;
3843     struct set_window_pos_reply set_window_pos_reply;
3844     struct get_window_rectangles_reply get_window_rectangles_reply;
3845     struct get_window_text_reply get_window_text_reply;
3846     struct set_window_text_reply set_window_text_reply;
3847     struct get_windows_offset_reply get_windows_offset_reply;
3848     struct get_visible_region_reply get_visible_region_reply;
3849     struct get_window_region_reply get_window_region_reply;
3850     struct set_window_region_reply set_window_region_reply;
3851     struct get_update_region_reply get_update_region_reply;
3852     struct update_window_zorder_reply update_window_zorder_reply;
3853     struct redraw_window_reply redraw_window_reply;
3854     struct set_window_property_reply set_window_property_reply;
3855     struct remove_window_property_reply remove_window_property_reply;
3856     struct get_window_property_reply get_window_property_reply;
3857     struct get_window_properties_reply get_window_properties_reply;
3858     struct attach_thread_input_reply attach_thread_input_reply;
3859     struct get_thread_input_reply get_thread_input_reply;
3860     struct get_key_state_reply get_key_state_reply;
3861     struct set_key_state_reply set_key_state_reply;
3862     struct set_foreground_window_reply set_foreground_window_reply;
3863     struct set_focus_window_reply set_focus_window_reply;
3864     struct set_active_window_reply set_active_window_reply;
3865     struct set_capture_window_reply set_capture_window_reply;
3866     struct set_caret_window_reply set_caret_window_reply;
3867     struct set_caret_info_reply set_caret_info_reply;
3868     struct set_hook_reply set_hook_reply;
3869     struct remove_hook_reply remove_hook_reply;
3870     struct start_hook_chain_reply start_hook_chain_reply;
3871     struct finish_hook_chain_reply finish_hook_chain_reply;
3872     struct get_next_hook_reply get_next_hook_reply;
3873     struct create_class_reply create_class_reply;
3874     struct destroy_class_reply destroy_class_reply;
3875     struct set_class_info_reply set_class_info_reply;
3876     struct set_clipboard_info_reply set_clipboard_info_reply;
3877     struct open_token_reply open_token_reply;
3878     struct set_global_windows_reply set_global_windows_reply;
3879     struct adjust_token_privileges_reply adjust_token_privileges_reply;
3880     struct get_token_privileges_reply get_token_privileges_reply;
3881     struct duplicate_token_reply duplicate_token_reply;
3882     struct create_mailslot_reply create_mailslot_reply;
3883     struct open_mailslot_reply open_mailslot_reply;
3884     struct set_mailslot_info_reply set_mailslot_info_reply;
3885 };
3886
3887 #define SERVER_PROTOCOL_VERSION 169
3888
3889 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */