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

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