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