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 <stdlib.h>
  12 #include <time.h>
  13 #include "winbase.h"
  14
  15 struct request_header
  16 {
  17     int          req;
  18     size_t       request_size;
  19     size_t       reply_size;
  20 };
  21
  22 struct reply_header
  23 {
  24     unsigned int error;
  25     size_t       reply_size;
  26 };
  27
  28
  29
  30 struct request_max_size
  31 {
  32     int pad[16];
  33 };
  34
  35
  36 #define REQUEST_MAX_VAR_SIZE  1024
  37
  38 typedef int handle_t;
  39 typedef unsigned short atom_t;
  40 typedef unsigned int user_handle_t;
  41
  42 #define FIRST_USER_HANDLE 0x0020
  43 #define LAST_USER_HANDLE  0xffef
  44
  45
  46
  47 struct debug_event_exception
  48 {
  49     EXCEPTION_RECORD record;
  50     int              first;
  51 };
  52 struct debug_event_create_thread
  53 {
  54     handle_t    handle;
  55     void       *teb;
  56     void       *start;
  57 };
  58 struct debug_event_create_process
  59 {
  60     handle_t    file;
  61     handle_t    process;
  62     handle_t    thread;
  63     void       *base;
  64     int         dbg_offset;
  65     int         dbg_size;
  66     void       *teb;
  67     void       *start;
  68     void       *name;
  69     int         unicode;
  70 };
  71 struct debug_event_exit
  72 {
  73     int         exit_code;
  74 };
  75 struct debug_event_load_dll
  76 {
  77     handle_t    handle;
  78     void       *base;
  79     int         dbg_offset;
  80     int         dbg_size;
  81     void       *name;
  82     int         unicode;
  83 };
  84 struct debug_event_unload_dll
  85 {
  86     void       *base;
  87 };
  88 struct debug_event_output_string
  89 {
  90     void       *string;
  91     int         unicode;
  92     int         length;
  93 };
  94 struct debug_event_rip_info
  95 {
  96     int         error;
  97     int         type;
  98 };
  99 union debug_event_data
 100 {
 101     struct debug_event_exception      exception;
 102     struct debug_event_create_thread  create_thread;
 103     struct debug_event_create_process create_process;
 104     struct debug_event_exit           exit;
 105     struct debug_event_load_dll       load_dll;
 106     struct debug_event_unload_dll     unload_dll;
 107     struct debug_event_output_string  output_string;
 108     struct debug_event_rip_info       rip_info;
 109 };
 110
 111
 112 typedef struct
 113 {
 114     int                      code;
 115     union debug_event_data   info;
 116 } debug_event_t;
 117
 118
 119 struct send_fd
 120 {
 121     void  *tid;
 122     int    fd;
 123 };
 124
 125
 126 struct wake_up_reply
 127 {
 128     void *cookie;
 129     int   signaled;
 130 };
 131
 132
 133 typedef struct
 134 {
 135     size_t       size;
 136     size_t       filename_len;
 137     size_t       cmdline_len;
 138     size_t       desktop_len;
 139     size_t       title_len;
 140     int          x;
 141     int          y;
 142     int          cx;
 143     int          cy;
 144     int          x_chars;
 145     int          y_chars;
 146     int          attribute;
 147     int          cmd_show;
 148     unsigned int flags;
 149
 150
 151
 152
 153 } startup_info_t;
 154
 155
 156 typedef struct
 157 {
 158     atom_t         atom;
 159     short          string;
 160     handle_t       handle;
 161 } property_data_t;
 162
 163
 164 typedef struct
 165 {
 166     int  left;
 167     int  top;
 168     int  right;
 169     int  bottom;
 170 } rectangle_t;
 171
 172
 173 typedef struct
 174 {
 175     WCHAR          ch;
 176     unsigned short attr;
 177 } char_info_t;
 178
 179
 180
 181
 182
 183 struct new_process_request
 184 {
 185     struct request_header __header;
 186     int          inherit_all;
 187     int          use_handles;
 188     int          create_flags;
 189     handle_t     exe_file;
 190     handle_t     hstdin;
 191     handle_t     hstdout;
 192     handle_t     hstderr;
 193     /* VARARG(info,startup_info); */
 194 };
 195 struct new_process_reply
 196 {
 197     struct reply_header __header;
 198     handle_t     info;
 199 };
 200
 201
 202
 203 struct get_new_process_info_request
 204 {
 205     struct request_header __header;
 206     handle_t     info;
 207     int          pinherit;
 208     int          tinherit;
 209 };
 210 struct get_new_process_info_reply
 211 {
 212     struct reply_header __header;
 213     void*        pid;
 214     handle_t     phandle;
 215     void*        tid;
 216     handle_t     thandle;
 217     handle_t     event;
 218 };
 219
 220
 221
 222 struct new_thread_request
 223 {
 224     struct request_header __header;
 225     int          suspend;
 226     int          inherit;
 227     int          request_fd;
 228 };
 229 struct new_thread_reply
 230 {
 231     struct reply_header __header;
 232     void*        tid;
 233     handle_t     handle;
 234 };
 235
 236
 237
 238 struct boot_done_request
 239 {
 240     struct request_header __header;
 241     int          debug_level;
 242 };
 243 struct boot_done_reply
 244 {
 245     struct reply_header __header;
 246 };
 247
 248
 249
 250 struct init_process_request
 251 {
 252     struct request_header __header;
 253     void*        ldt_copy;
 254     int          ppid;
 255 };
 256 struct init_process_reply
 257 {
 258     struct reply_header __header;
 259     int          create_flags;
 260     unsigned int server_start;
 261     handle_t     info;
 262     size_t       info_size;
 263     handle_t     exe_file;
 264     handle_t     hstdin;
 265     handle_t     hstdout;
 266     handle_t     hstderr;
 267 };
 268
 269
 270
 271 struct get_startup_info_request
 272 {
 273     struct request_header __header;
 274     handle_t     info;
 275     int          close;
 276 };
 277 struct get_startup_info_reply
 278 {
 279     struct reply_header __header;
 280     /* VARARG(info,startup_info); */
 281 };
 282
 283
 284
 285 struct init_process_done_request
 286 {
 287     struct request_header __header;
 288     void*        module;
 289     size_t       module_size;
 290     void*        entry;
 291     void*        name;
 292     handle_t     exe_file;
 293     int          gui;
 294     /* VARARG(filename,string); */
 295 };
 296 struct init_process_done_reply
 297 {
 298     struct reply_header __header;
 299     int          debugged;
 300 };
 301
 302
 303
 304 struct init_thread_request
 305 {
 306     struct request_header __header;
 307     int          unix_pid;
 308     void*        teb;
 309     void*        entry;
 310     int          reply_fd;
 311     int          wait_fd;
 312 };
 313 struct init_thread_reply
 314 {
 315     struct reply_header __header;
 316     void*        pid;
 317     void*        tid;
 318     int          boot;
 319     int          version;
 320 };
 321
 322
 323
 324 struct terminate_process_request
 325 {
 326     struct request_header __header;
 327     handle_t     handle;
 328     int          exit_code;
 329 };
 330 struct terminate_process_reply
 331 {
 332     struct reply_header __header;
 333     int          self;
 334 };
 335
 336
 337
 338 struct terminate_thread_request
 339 {
 340     struct request_header __header;
 341     handle_t     handle;
 342     int          exit_code;
 343 };
 344 struct terminate_thread_reply
 345 {
 346     struct reply_header __header;
 347     int          self;
 348     int          last;
 349 };
 350
 351
 352
 353 struct get_process_info_request
 354 {
 355     struct request_header __header;
 356     handle_t     handle;
 357 };
 358 struct get_process_info_reply
 359 {
 360     struct reply_header __header;
 361     void*        pid;
 362     int          debugged;
 363     int          exit_code;
 364     int          priority;
 365     int          process_affinity;
 366     int          system_affinity;
 367 };
 368
 369
 370
 371 struct set_process_info_request
 372 {
 373     struct request_header __header;
 374     handle_t     handle;
 375     int          mask;
 376     int          priority;
 377     int          affinity;
 378 };
 379 struct set_process_info_reply
 380 {
 381     struct reply_header __header;
 382 };
 383 #define SET_PROCESS_INFO_PRIORITY 0x01
 384 #define SET_PROCESS_INFO_AFFINITY 0x02
 385
 386
 387
 388 struct get_thread_info_request
 389 {
 390     struct request_header __header;
 391     handle_t     handle;
 392     void*        tid_in;
 393 };
 394 struct get_thread_info_reply
 395 {
 396     struct reply_header __header;
 397     void*        tid;
 398     void*        teb;
 399     int          exit_code;
 400     int          priority;
 401 };
 402
 403
 404
 405 struct set_thread_info_request
 406 {
 407     struct request_header __header;
 408     handle_t     handle;
 409     int          mask;
 410     int          priority;
 411     int          affinity;
 412 };
 413 struct set_thread_info_reply
 414 {
 415     struct reply_header __header;
 416 };
 417 #define SET_THREAD_INFO_PRIORITY 0x01
 418 #define SET_THREAD_INFO_AFFINITY 0x02
 419
 420
 421
 422 struct suspend_thread_request
 423 {
 424     struct request_header __header;
 425     handle_t     handle;
 426 };
 427 struct suspend_thread_reply
 428 {
 429     struct reply_header __header;
 430     int          count;
 431 };
 432
 433
 434
 435 struct resume_thread_request
 436 {
 437     struct request_header __header;
 438     handle_t     handle;
 439 };
 440 struct resume_thread_reply
 441 {
 442     struct reply_header __header;
 443     int          count;
 444 };
 445
 446
 447
 448 struct load_dll_request
 449 {
 450     struct request_header __header;
 451     handle_t     handle;
 452     void*        base;
 453     size_t       size;
 454     int          dbg_offset;
 455     int          dbg_size;
 456     void*        name;
 457     /* VARARG(filename,string); */
 458 };
 459 struct load_dll_reply
 460 {
 461     struct reply_header __header;
 462 };
 463
 464
 465
 466 struct unload_dll_request
 467 {
 468     struct request_header __header;
 469     void*        base;
 470 };
 471 struct unload_dll_reply
 472 {
 473     struct reply_header __header;
 474 };
 475
 476
 477
 478 struct queue_apc_request
 479 {
 480     struct request_header __header;
 481     handle_t     handle;
 482     int          user;
 483     void*        func;
 484     void*        param;
 485 };
 486 struct queue_apc_reply
 487 {
 488     struct reply_header __header;
 489 };
 490
 491
 492
 493 struct get_apc_request
 494 {
 495     struct request_header __header;
 496     int          alertable;
 497 };
 498 struct get_apc_reply
 499 {
 500     struct reply_header __header;
 501     void*        func;
 502     int          type;
 503     /* VARARG(args,ptrs); */
 504 };
 505 enum apc_type { APC_NONE, APC_USER, APC_TIMER, APC_ASYNC, APC_ASYNC_IO };
 506
 507
 508
 509 struct close_handle_request
 510 {
 511     struct request_header __header;
 512     handle_t     handle;
 513 };
 514 struct close_handle_reply
 515 {
 516     struct reply_header __header;
 517     int          fd;
 518 };
 519
 520
 521
 522 struct set_handle_info_request
 523 {
 524     struct request_header __header;
 525     handle_t     handle;
 526     int          flags;
 527     int          mask;
 528     int          fd;
 529 };
 530 struct set_handle_info_reply
 531 {
 532     struct reply_header __header;
 533     int          old_flags;
 534     int          cur_fd;
 535 };
 536
 537
 538
 539 struct dup_handle_request
 540 {
 541     struct request_header __header;
 542     handle_t     src_process;
 543     handle_t     src_handle;
 544     handle_t     dst_process;
 545     unsigned int access;
 546     int          inherit;
 547     int          options;
 548 };
 549 struct dup_handle_reply
 550 {
 551     struct reply_header __header;
 552     handle_t     handle;
 553     int          fd;
 554 };
 555 #define DUP_HANDLE_CLOSE_SOURCE  DUPLICATE_CLOSE_SOURCE
 556 #define DUP_HANDLE_SAME_ACCESS   DUPLICATE_SAME_ACCESS
 557 #define DUP_HANDLE_MAKE_GLOBAL   0x80000000
 558
 559
 560
 561 struct open_process_request
 562 {
 563     struct request_header __header;
 564     void*        pid;
 565     unsigned int access;
 566     int          inherit;
 567 };
 568 struct open_process_reply
 569 {
 570     struct reply_header __header;
 571     handle_t     handle;
 572 };
 573
 574
 575
 576 struct open_thread_request
 577 {
 578     struct request_header __header;
 579     void*        tid;
 580     unsigned int access;
 581     int          inherit;
 582 };
 583 struct open_thread_reply
 584 {
 585     struct reply_header __header;
 586     handle_t     handle;
 587 };
 588
 589
 590
 591 struct select_request
 592 {
 593     struct request_header __header;
 594     int          flags;
 595     void*        cookie;
 596     int          sec;
 597     int          usec;
 598     /* VARARG(handles,handles); */
 599 };
 600 struct select_reply
 601 {
 602     struct reply_header __header;
 603 };
 604 #define SELECT_ALL           1
 605 #define SELECT_ALERTABLE     2
 606 #define SELECT_INTERRUPTIBLE 4
 607 #define SELECT_TIMEOUT       8
 608
 609
 610
 611 struct create_event_request
 612 {
 613     struct request_header __header;
 614     int          manual_reset;
 615     int          initial_state;
 616     int          inherit;
 617     /* VARARG(name,unicode_str); */
 618 };
 619 struct create_event_reply
 620 {
 621     struct reply_header __header;
 622     handle_t     handle;
 623 };
 624
 625
 626 struct event_op_request
 627 {
 628     struct request_header __header;
 629     handle_t      handle;
 630     int           op;
 631 };
 632 struct event_op_reply
 633 {
 634     struct reply_header __header;
 635 };
 636 enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT };
 637
 638
 639
 640 struct open_event_request
 641 {
 642     struct request_header __header;
 643     unsigned int access;
 644     int          inherit;
 645     /* VARARG(name,unicode_str); */
 646 };
 647 struct open_event_reply
 648 {
 649     struct reply_header __header;
 650     handle_t     handle;
 651 };
 652
 653
 654
 655 struct create_mutex_request
 656 {
 657     struct request_header __header;
 658     int          owned;
 659     int          inherit;
 660     /* VARARG(name,unicode_str); */
 661 };
 662 struct create_mutex_reply
 663 {
 664     struct reply_header __header;
 665     handle_t     handle;
 666 };
 667
 668
 669
 670 struct release_mutex_request
 671 {
 672     struct request_header __header;
 673     handle_t     handle;
 674 };
 675 struct release_mutex_reply
 676 {
 677     struct reply_header __header;
 678 };
 679
 680
 681
 682 struct open_mutex_request
 683 {
 684     struct request_header __header;
 685     unsigned int access;
 686     int          inherit;
 687     /* VARARG(name,unicode_str); */
 688 };
 689 struct open_mutex_reply
 690 {
 691     struct reply_header __header;
 692     handle_t     handle;
 693 };
 694
 695
 696
 697 struct create_semaphore_request
 698 {
 699     struct request_header __header;
 700     unsigned int initial;
 701     unsigned int max;
 702     int          inherit;
 703     /* VARARG(name,unicode_str); */
 704 };
 705 struct create_semaphore_reply
 706 {
 707     struct reply_header __header;
 708     handle_t     handle;
 709 };
 710
 711
 712
 713 struct release_semaphore_request
 714 {
 715     struct request_header __header;
 716     handle_t     handle;
 717     unsigned int count;
 718 };
 719 struct release_semaphore_reply
 720 {
 721     struct reply_header __header;
 722     unsigned int prev_count;
 723 };
 724
 725
 726
 727 struct open_semaphore_request
 728 {
 729     struct request_header __header;
 730     unsigned int access;
 731     int          inherit;
 732     /* VARARG(name,unicode_str); */
 733 };
 734 struct open_semaphore_reply
 735 {
 736     struct reply_header __header;
 737     handle_t     handle;
 738 };
 739
 740
 741
 742 struct create_file_request
 743 {
 744     struct request_header __header;
 745     unsigned int access;
 746     int          inherit;
 747     unsigned int sharing;
 748     int          create;
 749     unsigned int attrs;
 750     int          drive_type;
 751     /* VARARG(filename,string); */
 752 };
 753 struct create_file_reply
 754 {
 755     struct reply_header __header;
 756     handle_t     handle;
 757 };
 758
 759
 760
 761 struct alloc_file_handle_request
 762 {
 763     struct request_header __header;
 764     unsigned int access;
 765     int          inherit;
 766     int          fd;
 767 };
 768 struct alloc_file_handle_reply
 769 {
 770     struct reply_header __header;
 771     handle_t     handle;
 772 };
 773
 774
 775
 776 struct get_handle_fd_request
 777 {
 778     struct request_header __header;
 779     handle_t     handle;
 780     unsigned int access;
 781 };
 782 struct get_handle_fd_reply
 783 {
 784     struct reply_header __header;
 785     int          fd;
 786     int          type;
 787     int          flags;
 788 };
 789 enum fd_type
 790 {
 791     FD_TYPE_INVALID,
 792     FD_TYPE_DEFAULT,
 793     FD_TYPE_CONSOLE,
 794     FD_TYPE_SMB
 795 };
 796 #define FD_FLAG_OVERLAPPED 0x01
 797 #define FD_FLAG_TIMEOUT    0x02
 798
 799
 800
 801 struct set_file_pointer_request
 802 {
 803     struct request_header __header;
 804     handle_t     handle;
 805     int          low;
 806     int          high;
 807     int          whence;
 808 };
 809 struct set_file_pointer_reply
 810 {
 811     struct reply_header __header;
 812     int          new_low;
 813     int          new_high;
 814 };
 815
 816
 817
 818 struct truncate_file_request
 819 {
 820     struct request_header __header;
 821     handle_t     handle;
 822 };
 823 struct truncate_file_reply
 824 {
 825     struct reply_header __header;
 826 };
 827
 828
 829
 830 struct set_file_time_request
 831 {
 832     struct request_header __header;
 833     handle_t     handle;
 834     time_t       access_time;
 835     time_t       write_time;
 836 };
 837 struct set_file_time_reply
 838 {
 839     struct reply_header __header;
 840 };
 841
 842
 843
 844 struct flush_file_request
 845 {
 846     struct request_header __header;
 847     handle_t     handle;
 848 };
 849 struct flush_file_reply
 850 {
 851     struct reply_header __header;
 852 };
 853
 854
 855
 856 struct get_file_info_request
 857 {
 858     struct request_header __header;
 859     handle_t     handle;
 860 };
 861 struct get_file_info_reply
 862 {
 863     struct reply_header __header;
 864     int          type;
 865     int          attr;
 866     time_t       access_time;
 867     time_t       write_time;
 868     int          size_high;
 869     int          size_low;
 870     int          links;
 871     int          index_high;
 872     int          index_low;
 873     unsigned int serial;
 874 };
 875
 876
 877
 878 struct lock_file_request
 879 {
 880     struct request_header __header;
 881     handle_t     handle;
 882     unsigned int offset_low;
 883     unsigned int offset_high;
 884     unsigned int count_low;
 885     unsigned int count_high;
 886 };
 887 struct lock_file_reply
 888 {
 889     struct reply_header __header;
 890 };
 891
 892
 893
 894 struct unlock_file_request
 895 {
 896     struct request_header __header;
 897     handle_t     handle;
 898     unsigned int offset_low;
 899     unsigned int offset_high;
 900     unsigned int count_low;
 901     unsigned int count_high;
 902 };
 903 struct unlock_file_reply
 904 {
 905     struct reply_header __header;
 906 };
 907
 908
 909
 910 struct create_pipe_request
 911 {
 912     struct request_header __header;
 913     int          inherit;
 914 };
 915 struct create_pipe_reply
 916 {
 917     struct reply_header __header;
 918     handle_t     handle_read;
 919     handle_t     handle_write;
 920 };
 921
 922
 923
 924 struct create_socket_request
 925 {
 926     struct request_header __header;
 927     unsigned int access;
 928     int          inherit;
 929     int          family;
 930     int          type;
 931     int          protocol;
 932     unsigned int flags;
 933 };
 934 struct create_socket_reply
 935 {
 936     struct reply_header __header;
 937     handle_t     handle;
 938 };
 939
 940
 941
 942 struct accept_socket_request
 943 {
 944     struct request_header __header;
 945     handle_t     lhandle;
 946     unsigned int access;
 947     int          inherit;
 948 };
 949 struct accept_socket_reply
 950 {
 951     struct reply_header __header;
 952     handle_t     handle;
 953 };
 954
 955
 956
 957 struct set_socket_event_request
 958 {
 959     struct request_header __header;
 960     handle_t      handle;
 961     unsigned int  mask;
 962     handle_t      event;
 963     user_handle_t window;
 964     unsigned int  msg;
 965 };
 966 struct set_socket_event_reply
 967 {
 968     struct reply_header __header;
 969 };
 970
 971
 972
 973 struct get_socket_event_request
 974 {
 975     struct request_header __header;
 976     handle_t     handle;
 977     int          service;
 978     handle_t     c_event;
 979 };
 980 struct get_socket_event_reply
 981 {
 982     struct reply_header __header;
 983     unsigned int mask;
 984     unsigned int pmask;
 985     unsigned int state;
 986     /* VARARG(errors,ints); */
 987 };
 988
 989
 990
 991 struct enable_socket_event_request
 992 {
 993     struct request_header __header;
 994     handle_t     handle;
 995     unsigned int mask;
 996     unsigned int sstate;
 997     unsigned int cstate;
 998 };
 999 struct enable_socket_event_reply
1000 {
1001     struct reply_header __header;
1002 };
1003
1004
1005
1006 struct alloc_console_request
1007 {
1008     struct request_header __header;
1009     unsigned int access;
1010     int          inherit;
1011     void*        pid;
1012 };
1013 struct alloc_console_reply
1014 {
1015     struct reply_header __header;
1016     handle_t     handle_in;
1017     handle_t     event;
1018 };
1019
1020
1021
1022 struct free_console_request
1023 {
1024     struct request_header __header;
1025 };
1026 struct free_console_reply
1027 {
1028     struct reply_header __header;
1029 };
1030
1031
1032 #define CONSOLE_RENDERER_NONE_EVENT        0x00
1033 #define CONSOLE_RENDERER_TITLE_EVENT       0x01
1034 #define CONSOLE_RENDERER_ACTIVE_SB_EVENT   0x02
1035 #define CONSOLE_RENDERER_SB_RESIZE_EVENT   0x03
1036 #define CONSOLE_RENDERER_UPDATE_EVENT      0x04
1037 #define CONSOLE_RENDERER_CURSOR_POS_EVENT  0x05
1038 #define CONSOLE_RENDERER_CURSOR_GEOM_EVENT 0x06
1039 #define CONSOLE_RENDERER_DISPLAY_EVENT     0x07
1040 #define CONSOLE_RENDERER_EXIT_EVENT        0x08
1041 struct console_renderer_event
1042 {
1043     short event;
1044     union
1045     {
1046         struct update
1047         {
1048             short top;
1049             short bottom;
1050         } update;
1051         struct resize
1052         {
1053             short width;
1054             short height;
1055         } resize;
1056         struct cursor_pos
1057         {
1058             short x;
1059             short y;
1060         } cursor_pos;
1061         struct cursor_geom
1062         {
1063             short visible;
1064             short size;
1065         } cursor_geom;
1066         struct display
1067         {
1068             short left;
1069             short top;
1070             short width;
1071             short height;
1072         } display;
1073     } u;
1074 };
1075
1076
1077 struct get_console_renderer_events_request
1078 {
1079     struct request_header __header;
1080     handle_t     handle;
1081 };
1082 struct get_console_renderer_events_reply
1083 {
1084     struct reply_header __header;
1085     /* VARARG(data,bytes); */
1086 };
1087
1088
1089
1090 struct open_console_request
1091 {
1092     struct request_header __header;
1093     int          from;
1094
1095     unsigned int access;
1096     int          inherit;
1097     int          share;
1098 };
1099 struct open_console_reply
1100 {
1101     struct reply_header __header;
1102     handle_t     handle;
1103 };
1104
1105
1106
1107 struct get_console_mode_request
1108 {
1109     struct request_header __header;
1110     handle_t     handle;
1111 };
1112 struct get_console_mode_reply
1113 {
1114     struct reply_header __header;
1115     int          mode;
1116 };
1117
1118
1119
1120 struct set_console_mode_request
1121 {
1122     struct request_header __header;
1123     handle_t     handle;
1124     int          mode;
1125 };
1126 struct set_console_mode_reply
1127 {
1128     struct reply_header __header;
1129 };
1130
1131
1132
1133 struct set_console_input_info_request
1134 {
1135     struct request_header __header;
1136     handle_t     handle;
1137     int          mask;
1138     handle_t     active_sb;
1139     int          history_mode;
1140     int          history_size;
1141     /* VARARG(title,unicode_str); */
1142 };
1143 struct set_console_input_info_reply
1144 {
1145     struct reply_header __header;
1146 };
1147 #define SET_CONSOLE_INPUT_INFO_ACTIVE_SB        0x01
1148 #define SET_CONSOLE_INPUT_INFO_TITLE            0x02
1149 #define SET_CONSOLE_INPUT_INFO_HISTORY_MODE     0x04
1150 #define SET_CONSOLE_INPUT_INFO_HISTORY_SIZE     0x08
1151
1152
1153
1154 struct get_console_input_info_request
1155 {
1156     struct request_header __header;
1157     handle_t     handle;
1158 };
1159 struct get_console_input_info_reply
1160 {
1161     struct reply_header __header;
1162     int          history_mode;
1163     int          history_size;
1164     int          history_index;
1165     /* VARARG(title,unicode_str); */
1166 };
1167
1168
1169
1170 struct append_console_input_history_request
1171 {
1172     struct request_header __header;
1173     handle_t     handle;
1174     /* VARARG(line,unicode_str); */
1175 };
1176 struct append_console_input_history_reply
1177 {
1178     struct reply_header __header;
1179 };
1180
1181
1182
1183 struct get_console_input_history_request
1184 {
1185     struct request_header __header;
1186     handle_t     handle;
1187     int          index;
1188 };
1189 struct get_console_input_history_reply
1190 {
1191     struct reply_header __header;
1192     int          total;
1193     /* VARARG(line,unicode_str); */
1194 };
1195
1196
1197
1198 struct create_console_output_request
1199 {
1200     struct request_header __header;
1201     handle_t     handle_in;
1202     int          access;
1203     int          share;
1204     int          inherit;
1205 };
1206 struct create_console_output_reply
1207 {
1208     struct reply_header __header;
1209     handle_t     handle_out;
1210 };
1211
1212
1213
1214 struct set_console_output_info_request
1215 {
1216     struct request_header __header;
1217     handle_t     handle;
1218     int          mask;
1219     short int    cursor_size;
1220     short int    cursor_visible;
1221     short int    cursor_x;
1222     short int    cursor_y;
1223     short int    width;
1224     short int    height;
1225     short int    attr;
1226     short int    win_left;
1227     short int    win_top;
1228     short int    win_right;
1229     short int    win_bottom;
1230     short int    max_width;
1231     short int    max_height;
1232 };
1233 struct set_console_output_info_reply
1234 {
1235     struct reply_header __header;
1236 };
1237 #define SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM     0x01
1238 #define SET_CONSOLE_OUTPUT_INFO_CURSOR_POS      0x02
1239 #define SET_CONSOLE_OUTPUT_INFO_SIZE            0x04
1240 #define SET_CONSOLE_OUTPUT_INFO_ATTR            0x08
1241 #define SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW  0x10
1242 #define SET_CONSOLE_OUTPUT_INFO_MAX_SIZE        0x20
1243
1244
1245
1246 struct get_console_output_info_request
1247 {
1248     struct request_header __header;
1249     handle_t     handle;
1250 };
1251 struct get_console_output_info_reply
1252 {
1253     struct reply_header __header;
1254     short int    cursor_size;
1255     short int    cursor_visible;
1256     short int    cursor_x;
1257     short int    cursor_y;
1258     short int    width;
1259     short int    height;
1260     short int    attr;
1261     short int    win_left;
1262     short int    win_top;
1263     short int    win_right;
1264     short int    win_bottom;
1265     short int    max_width;
1266     short int    max_height;
1267 };
1268
1269
1270 struct write_console_input_request
1271 {
1272     struct request_header __header;
1273     handle_t     handle;
1274     /* VARARG(rec,input_records); */
1275 };
1276 struct write_console_input_reply
1277 {
1278     struct reply_header __header;
1279     int          written;
1280 };
1281
1282
1283
1284 struct read_console_input_request
1285 {
1286     struct request_header __header;
1287     handle_t     handle;
1288     int          flush;
1289 };
1290 struct read_console_input_reply
1291 {
1292     struct reply_header __header;
1293     int          read;
1294     /* VARARG(rec,input_records); */
1295 };
1296
1297
1298
1299 struct write_console_output_request
1300 {
1301     struct request_header __header;
1302     handle_t     handle;
1303     int          x;
1304     int          y;
1305     int          mode;
1306     int          wrap;
1307     /* VARARG(data,bytes); */
1308 };
1309 struct write_console_output_reply
1310 {
1311     struct reply_header __header;
1312     int          written;
1313     int          width;
1314     int          height;
1315 };
1316 enum char_info_mode
1317 {
1318     CHAR_INFO_MODE_TEXT,
1319     CHAR_INFO_MODE_ATTR,
1320     CHAR_INFO_MODE_TEXTATTR,
1321     CHAR_INFO_MODE_TEXTSTDATTR
1322 };
1323
1324
1325
1326 struct fill_console_output_request
1327 {
1328     struct request_header __header;
1329     handle_t     handle;
1330     int          x;
1331     int          y;
1332     int          mode;
1333     int          count;
1334     int          wrap;
1335     char_info_t  data;
1336 };
1337 struct fill_console_output_reply
1338 {
1339     struct reply_header __header;
1340     int          written;
1341 };
1342
1343
1344
1345 struct read_console_output_request
1346 {
1347     struct request_header __header;
1348     handle_t     handle;
1349     int          x;
1350     int          y;
1351     int          mode;
1352     int          wrap;
1353 };
1354 struct read_console_output_reply
1355 {
1356     struct reply_header __header;
1357     int          width;
1358     int          height;
1359     /* VARARG(data,bytes); */
1360 };
1361
1362
1363 struct move_console_output_request
1364 {
1365     struct request_header __header;
1366     handle_t     handle;
1367     short int    x_src;
1368     short int    y_src;
1369     short int    x_dst;
1370     short int    y_dst;
1371     short int    w;
1372     short int    h;
1373 };
1374 struct move_console_output_reply
1375 {
1376     struct reply_header __header;
1377 };
1378
1379
1380
1381 struct create_change_notification_request
1382 {
1383     struct request_header __header;
1384     int          subtree;
1385     int          filter;
1386 };
1387 struct create_change_notification_reply
1388 {
1389     struct reply_header __header;
1390     handle_t     handle;
1391 };
1392
1393
1394
1395 struct create_mapping_request
1396 {
1397     struct request_header __header;
1398     int          size_high;
1399     int          size_low;
1400     int          protect;
1401     int          inherit;
1402     handle_t     file_handle;
1403     /* VARARG(name,unicode_str); */
1404 };
1405 struct create_mapping_reply
1406 {
1407     struct reply_header __header;
1408     handle_t     handle;
1409 };
1410
1411 #define VPROT_READ       0x01
1412 #define VPROT_WRITE      0x02
1413 #define VPROT_EXEC       0x04
1414 #define VPROT_WRITECOPY  0x08
1415 #define VPROT_GUARD      0x10
1416 #define VPROT_NOCACHE    0x20
1417 #define VPROT_COMMITTED  0x40
1418 #define VPROT_IMAGE      0x80
1419
1420
1421
1422 struct open_mapping_request
1423 {
1424     struct request_header __header;
1425     unsigned int access;
1426     int          inherit;
1427     /* VARARG(name,unicode_str); */
1428 };
1429 struct open_mapping_reply
1430 {
1431     struct reply_header __header;
1432     handle_t     handle;
1433 };
1434
1435
1436
1437 struct get_mapping_info_request
1438 {
1439     struct request_header __header;
1440     handle_t     handle;
1441 };
1442 struct get_mapping_info_reply
1443 {
1444     struct reply_header __header;
1445     int          size_high;
1446     int          size_low;
1447     int          protect;
1448     int          header_size;
1449     void*        base;
1450     handle_t     shared_file;
1451     int          shared_size;
1452     int          drive_type;
1453 };
1454
1455
1456
1457 struct create_device_request
1458 {
1459     struct request_header __header;
1460     unsigned int access;
1461     int          inherit;
1462     int          id;
1463 };
1464 struct create_device_reply
1465 {
1466     struct reply_header __header;
1467     handle_t     handle;
1468 };
1469
1470
1471
1472 struct create_snapshot_request
1473 {
1474     struct request_header __header;
1475     int          inherit;
1476     int          flags;
1477     void*        pid;
1478 };
1479 struct create_snapshot_reply
1480 {
1481     struct reply_header __header;
1482     handle_t     handle;
1483 };
1484
1485
1486
1487 struct next_process_request
1488 {
1489     struct request_header __header;
1490     handle_t     handle;
1491     int          reset;
1492 };
1493 struct next_process_reply
1494 {
1495     struct reply_header __header;
1496     int          count;
1497     void*        pid;
1498     void*        ppid;
1499     void*        heap;
1500     void*        module;
1501     int          threads;
1502     int          priority;
1503     /* VARARG(filename,string); */
1504 };
1505
1506
1507
1508 struct next_thread_request
1509 {
1510     struct request_header __header;
1511     handle_t     handle;
1512     int          reset;
1513 };
1514 struct next_thread_reply
1515 {
1516     struct reply_header __header;
1517     int          count;
1518     void*        pid;
1519     void*        tid;
1520     int          base_pri;
1521     int          delta_pri;
1522 };
1523
1524
1525
1526 struct next_module_request
1527 {
1528     struct request_header __header;
1529     handle_t     handle;
1530     int          reset;
1531 };
1532 struct next_module_reply
1533 {
1534     struct reply_header __header;
1535     void*        pid;
1536     void*        base;
1537     size_t       size;
1538     /* VARARG(filename,string); */
1539 };
1540
1541
1542
1543 struct wait_debug_event_request
1544 {
1545     struct request_header __header;
1546     int           get_handle;
1547 };
1548 struct wait_debug_event_reply
1549 {
1550     struct reply_header __header;
1551     void*         pid;
1552     void*         tid;
1553     handle_t      wait;
1554     /* VARARG(event,debug_event); */
1555 };
1556
1557
1558
1559 struct queue_exception_event_request
1560 {
1561     struct request_header __header;
1562     int              first;
1563     /* VARARG(record,exc_event); */
1564 };
1565 struct queue_exception_event_reply
1566 {
1567     struct reply_header __header;
1568     handle_t         handle;
1569 };
1570
1571
1572
1573 struct get_exception_status_request
1574 {
1575     struct request_header __header;
1576     handle_t         handle;
1577 };
1578 struct get_exception_status_reply
1579 {
1580     struct reply_header __header;
1581     int              status;
1582     /* VARARG(context,context); */
1583 };
1584
1585
1586
1587 struct output_debug_string_request
1588 {
1589     struct request_header __header;
1590     void*         string;
1591     int           unicode;
1592     int           length;
1593 };
1594 struct output_debug_string_reply
1595 {
1596     struct reply_header __header;
1597 };
1598
1599
1600
1601 struct continue_debug_event_request
1602 {
1603     struct request_header __header;
1604     void*        pid;
1605     void*        tid;
1606     int          status;
1607 };
1608 struct continue_debug_event_reply
1609 {
1610     struct reply_header __header;
1611 };
1612
1613
1614
1615 struct debug_process_request
1616 {
1617     struct request_header __header;
1618     void*        pid;
1619     int          attach;
1620 };
1621 struct debug_process_reply
1622 {
1623     struct reply_header __header;
1624 };
1625
1626
1627
1628 struct debug_break_request
1629 {
1630     struct request_header __header;
1631     handle_t     handle;
1632 };
1633 struct debug_break_reply
1634 {
1635     struct reply_header __header;
1636     int          self;
1637 };
1638
1639
1640
1641 struct set_debugger_kill_on_exit_request
1642 {
1643     struct request_header __header;
1644     int          kill_on_exit;
1645 };
1646 struct set_debugger_kill_on_exit_reply
1647 {
1648     struct reply_header __header;
1649 };
1650
1651
1652
1653 struct read_process_memory_request
1654 {
1655     struct request_header __header;
1656     handle_t     handle;
1657     void*        addr;
1658 };
1659 struct read_process_memory_reply
1660 {
1661     struct reply_header __header;
1662     /* VARARG(data,bytes); */
1663 };
1664
1665
1666
1667 struct write_process_memory_request
1668 {
1669     struct request_header __header;
1670     handle_t     handle;
1671     void*        addr;
1672     unsigned int first_mask;
1673     unsigned int last_mask;
1674     /* VARARG(data,bytes); */
1675 };
1676 struct write_process_memory_reply
1677 {
1678     struct reply_header __header;
1679 };
1680
1681
1682
1683 struct create_key_request
1684 {
1685     struct request_header __header;
1686     handle_t     parent;
1687     unsigned int access;
1688     unsigned int options;
1689     time_t       modif;
1690     size_t       namelen;
1691     /* VARARG(name,unicode_str,namelen); */
1692     /* VARARG(class,unicode_str); */
1693 };
1694 struct create_key_reply
1695 {
1696     struct reply_header __header;
1697     handle_t     hkey;
1698     int          created;
1699 };
1700
1701
1702 struct open_key_request
1703 {
1704     struct request_header __header;
1705     handle_t     parent;
1706     unsigned int access;
1707     /* VARARG(name,unicode_str); */
1708 };
1709 struct open_key_reply
1710 {
1711     struct reply_header __header;
1712     handle_t     hkey;
1713 };
1714
1715
1716
1717 struct delete_key_request
1718 {
1719     struct request_header __header;
1720     handle_t     hkey;
1721 };
1722 struct delete_key_reply
1723 {
1724     struct reply_header __header;
1725 };
1726
1727
1728
1729 struct enum_key_request
1730 {
1731     struct request_header __header;
1732     handle_t     hkey;
1733     int          index;
1734     int          info_class;
1735 };
1736 struct enum_key_reply
1737 {
1738     struct reply_header __header;
1739     int          subkeys;
1740     int          max_subkey;
1741     int          max_class;
1742     int          values;
1743     int          max_value;
1744     int          max_data;
1745     time_t       modif;
1746     size_t       total;
1747     size_t       namelen;
1748     /* VARARG(name,unicode_str,namelen); */
1749     /* VARARG(class,unicode_str); */
1750 };
1751
1752
1753
1754 struct set_key_value_request
1755 {
1756     struct request_header __header;
1757     handle_t     hkey;
1758     int          type;
1759     size_t       namelen;
1760     /* VARARG(name,unicode_str,namelen); */
1761     /* VARARG(data,bytes); */
1762 };
1763 struct set_key_value_reply
1764 {
1765     struct reply_header __header;
1766 };
1767
1768
1769
1770 struct get_key_value_request
1771 {
1772     struct request_header __header;
1773     handle_t     hkey;
1774     /* VARARG(name,unicode_str); */
1775 };
1776 struct get_key_value_reply
1777 {
1778     struct reply_header __header;
1779     int          type;
1780     size_t       total;
1781     /* VARARG(data,bytes); */
1782 };
1783
1784
1785
1786 struct enum_key_value_request
1787 {
1788     struct request_header __header;
1789     handle_t     hkey;
1790     int          index;
1791     int          info_class;
1792 };
1793 struct enum_key_value_reply
1794 {
1795     struct reply_header __header;
1796     int          type;
1797     size_t       total;
1798     size_t       namelen;
1799     /* VARARG(name,unicode_str,namelen); */
1800     /* VARARG(data,bytes); */
1801 };
1802
1803
1804
1805 struct delete_key_value_request
1806 {
1807     struct request_header __header;
1808     handle_t     hkey;
1809     /* VARARG(name,unicode_str); */
1810 };
1811 struct delete_key_value_reply
1812 {
1813     struct reply_header __header;
1814 };
1815
1816
1817
1818 struct load_registry_request
1819 {
1820     struct request_header __header;
1821     handle_t     hkey;
1822     handle_t     file;
1823     /* VARARG(name,unicode_str); */
1824 };
1825 struct load_registry_reply
1826 {
1827     struct reply_header __header;
1828 };
1829
1830
1831
1832 struct save_registry_request
1833 {
1834     struct request_header __header;
1835     handle_t     hkey;
1836     handle_t     file;
1837 };
1838 struct save_registry_reply
1839 {
1840     struct reply_header __header;
1841 };
1842
1843
1844
1845 struct save_registry_atexit_request
1846 {
1847     struct request_header __header;
1848     handle_t     hkey;
1849     /* VARARG(file,string); */
1850 };
1851 struct save_registry_atexit_reply
1852 {
1853     struct reply_header __header;
1854 };
1855
1856
1857
1858 struct set_registry_levels_request
1859 {
1860     struct request_header __header;
1861     int          current;
1862     int          saving;
1863     int          period;
1864 };
1865 struct set_registry_levels_reply
1866 {
1867     struct reply_header __header;
1868 };
1869
1870
1871
1872 struct create_timer_request
1873 {
1874     struct request_header __header;
1875     int          inherit;
1876     int          manual;
1877     /* VARARG(name,unicode_str); */
1878 };
1879 struct create_timer_reply
1880 {
1881     struct reply_header __header;
1882     handle_t     handle;
1883 };
1884
1885
1886
1887 struct open_timer_request
1888 {
1889     struct request_header __header;
1890     unsigned int access;
1891     int          inherit;
1892     /* VARARG(name,unicode_str); */
1893 };
1894 struct open_timer_reply
1895 {
1896     struct reply_header __header;
1897     handle_t     handle;
1898 };
1899
1900
1901 struct set_timer_request
1902 {
1903     struct request_header __header;
1904     handle_t     handle;
1905     int          sec;
1906     int          usec;
1907     int          period;
1908     void*        callback;
1909     void*        arg;
1910 };
1911 struct set_timer_reply
1912 {
1913     struct reply_header __header;
1914 };
1915
1916
1917 struct cancel_timer_request
1918 {
1919     struct request_header __header;
1920     handle_t     handle;
1921 };
1922 struct cancel_timer_reply
1923 {
1924     struct reply_header __header;
1925 };
1926
1927
1928
1929 struct get_thread_context_request
1930 {
1931     struct request_header __header;
1932     handle_t     handle;
1933     unsigned int flags;
1934 };
1935 struct get_thread_context_reply
1936 {
1937     struct reply_header __header;
1938     /* VARARG(context,context); */
1939 };
1940
1941
1942
1943 struct set_thread_context_request
1944 {
1945     struct request_header __header;
1946     handle_t     handle;
1947     unsigned int flags;
1948     /* VARARG(context,context); */
1949 };
1950 struct set_thread_context_reply
1951 {
1952     struct reply_header __header;
1953 };
1954
1955
1956
1957 struct get_selector_entry_request
1958 {
1959     struct request_header __header;
1960     handle_t      handle;
1961     int           entry;
1962 };
1963 struct get_selector_entry_reply
1964 {
1965     struct reply_header __header;
1966     unsigned int  base;
1967     unsigned int  limit;
1968     unsigned char flags;
1969 };
1970
1971
1972
1973 struct add_atom_request
1974 {
1975     struct request_header __header;
1976     int           local;
1977     /* VARARG(name,unicode_str); */
1978 };
1979 struct add_atom_reply
1980 {
1981     struct reply_header __header;
1982     atom_t        atom;
1983 };
1984
1985
1986
1987 struct delete_atom_request
1988 {
1989     struct request_header __header;
1990     atom_t        atom;
1991     int           local;
1992 };
1993 struct delete_atom_reply
1994 {
1995     struct reply_header __header;
1996 };
1997
1998
1999
2000 struct find_atom_request
2001 {
2002     struct request_header __header;
2003     int          local;
2004     /* VARARG(name,unicode_str); */
2005 };
2006 struct find_atom_reply
2007 {
2008     struct reply_header __header;
2009     atom_t       atom;
2010 };
2011
2012
2013
2014 struct get_atom_name_request
2015 {
2016     struct request_header __header;
2017     atom_t       atom;
2018     int          local;
2019 };
2020 struct get_atom_name_reply
2021 {
2022     struct reply_header __header;
2023     int          count;
2024     /* VARARG(name,unicode_str); */
2025 };
2026
2027
2028
2029 struct init_atom_table_request
2030 {
2031     struct request_header __header;
2032     int          entries;
2033 };
2034 struct init_atom_table_reply
2035 {
2036     struct reply_header __header;
2037 };
2038
2039
2040
2041 struct get_msg_queue_request
2042 {
2043     struct request_header __header;
2044 };
2045 struct get_msg_queue_reply
2046 {
2047     struct reply_header __header;
2048     handle_t     handle;
2049 };
2050
2051
2052
2053 struct set_queue_mask_request
2054 {
2055     struct request_header __header;
2056     unsigned int wake_mask;
2057     unsigned int changed_mask;
2058     int          skip_wait;
2059 };
2060 struct set_queue_mask_reply
2061 {
2062     struct reply_header __header;
2063     unsigned int wake_bits;
2064     unsigned int changed_bits;
2065 };
2066
2067
2068
2069 struct get_queue_status_request
2070 {
2071     struct request_header __header;
2072     int          clear;
2073 };
2074 struct get_queue_status_reply
2075 {
2076     struct reply_header __header;
2077     unsigned int wake_bits;
2078     unsigned int changed_bits;
2079 };
2080
2081
2082
2083 struct wait_input_idle_request
2084 {
2085     struct request_header __header;
2086     handle_t     handle;
2087     int          timeout;
2088 };
2089 struct wait_input_idle_reply
2090 {
2091     struct reply_header __header;
2092     handle_t     event;
2093 };
2094
2095
2096
2097 struct send_message_request
2098 {
2099     struct request_header __header;
2100     void*           id;
2101     int             type;
2102     user_handle_t   win;
2103     unsigned int    msg;
2104     unsigned int    wparam;
2105     unsigned int    lparam;
2106     int             x;
2107     int             y;
2108     unsigned int    time;
2109     unsigned int    info;
2110     int             timeout;
2111     /* VARARG(data,bytes); */
2112 };
2113 struct send_message_reply
2114 {
2115     struct reply_header __header;
2116 };
2117
2118 enum message_type
2119 {
2120     MSG_ASCII,
2121     MSG_UNICODE,
2122     MSG_NOTIFY,
2123     MSG_CALLBACK,
2124     MSG_OTHER_PROCESS,
2125     MSG_POSTED,
2126     MSG_HARDWARE_RAW,
2127     MSG_HARDWARE_COOKED
2128 };
2129
2130
2131
2132 struct get_message_request
2133 {
2134     struct request_header __header;
2135     int             flags;
2136     user_handle_t   get_win;
2137     unsigned int    get_first;
2138     unsigned int    get_last;
2139 };
2140 struct get_message_reply
2141 {
2142     struct reply_header __header;
2143     int             type;
2144     user_handle_t   win;
2145     unsigned int    msg;
2146     unsigned int    wparam;
2147     unsigned int    lparam;
2148     int             x;
2149     int             y;
2150     unsigned int    time;
2151     unsigned int    info;
2152     size_t          total;
2153     /* VARARG(data,bytes); */
2154 };
2155 #define GET_MSG_REMOVE      1
2156 #define GET_MSG_SENT_ONLY   2
2157 #define GET_MSG_REMOVE_LAST 4
2158
2159
2160 struct reply_message_request
2161 {
2162     struct request_header __header;
2163     unsigned int    result;
2164     int             remove;
2165     /* VARARG(data,bytes); */
2166 };
2167 struct reply_message_reply
2168 {
2169     struct reply_header __header;
2170 };
2171
2172
2173
2174 struct get_message_reply_request
2175 {
2176     struct request_header __header;
2177     int             cancel;
2178 };
2179 struct get_message_reply_reply
2180 {
2181     struct reply_header __header;
2182     unsigned int    result;
2183     /* VARARG(data,bytes); */
2184 };
2185
2186
2187
2188 struct set_win_timer_request
2189 {
2190     struct request_header __header;
2191     user_handle_t   win;
2192     unsigned int    msg;
2193     unsigned int    id;
2194     unsigned int    rate;
2195     unsigned int    lparam;
2196 };
2197 struct set_win_timer_reply
2198 {
2199     struct reply_header __header;
2200 };
2201
2202
2203
2204 struct kill_win_timer_request
2205 {
2206     struct request_header __header;
2207     user_handle_t   win;
2208     unsigned int    msg;
2209     unsigned int    id;
2210 };
2211 struct kill_win_timer_reply
2212 {
2213     struct reply_header __header;
2214 };
2215
2216
2217
2218 struct create_serial_request
2219 {
2220     struct request_header __header;
2221     unsigned int access;
2222     int          inherit;
2223     unsigned int attributes;
2224     unsigned int sharing;
2225     /* VARARG(name,string); */
2226 };
2227 struct create_serial_reply
2228 {
2229     struct reply_header __header;
2230     handle_t     handle;
2231 };
2232
2233
2234
2235 struct get_serial_info_request
2236 {
2237     struct request_header __header;
2238     handle_t     handle;
2239 };
2240 struct get_serial_info_reply
2241 {
2242     struct reply_header __header;
2243     unsigned int readinterval;
2244     unsigned int readconst;
2245     unsigned int readmult;
2246     unsigned int writeconst;
2247     unsigned int writemult;
2248     unsigned int eventmask;
2249     unsigned int commerror;
2250 };
2251
2252
2253
2254 struct set_serial_info_request
2255 {
2256     struct request_header __header;
2257     handle_t     handle;
2258     int          flags;
2259     unsigned int readinterval;
2260     unsigned int readconst;
2261     unsigned int readmult;
2262     unsigned int writeconst;
2263     unsigned int writemult;
2264     unsigned int eventmask;
2265     unsigned int commerror;
2266 };
2267 struct set_serial_info_reply
2268 {
2269     struct reply_header __header;
2270 };
2271 #define SERIALINFO_SET_TIMEOUTS  0x01
2272 #define SERIALINFO_SET_MASK      0x02
2273 #define SERIALINFO_SET_ERROR     0x04
2274
2275
2276
2277 struct register_async_request
2278 {
2279     struct request_header __header;
2280     handle_t     handle;
2281     int          type;
2282     void*        overlapped;
2283     int          count;
2284     unsigned int status;
2285 };
2286 struct register_async_reply
2287 {
2288     struct reply_header __header;
2289 };
2290 #define ASYNC_TYPE_NONE  0x00
2291 #define ASYNC_TYPE_READ  0x01
2292 #define ASYNC_TYPE_WRITE 0x02
2293 #define ASYNC_TYPE_WAIT  0x03
2294
2295
2296
2297 struct create_named_pipe_request
2298 {
2299     struct request_header __header;
2300     unsigned int   openmode;
2301     unsigned int   pipemode;
2302     unsigned int   maxinstances;
2303     unsigned int   outsize;
2304     unsigned int   insize;
2305     unsigned int   timeout;
2306     /* VARARG(name,unicode_str); */
2307 };
2308 struct create_named_pipe_reply
2309 {
2310     struct reply_header __header;
2311     handle_t       handle;
2312 };
2313
2314
2315
2316 struct open_named_pipe_request
2317 {
2318     struct request_header __header;
2319     unsigned int   access;
2320     /* VARARG(name,unicode_str); */
2321 };
2322 struct open_named_pipe_reply
2323 {
2324     struct reply_header __header;
2325     handle_t       handle;
2326 };
2327
2328
2329
2330 struct connect_named_pipe_request
2331 {
2332     struct request_header __header;
2333     handle_t       handle;
2334     void*          overlapped;
2335     void*          func;
2336 };
2337 struct connect_named_pipe_reply
2338 {
2339     struct reply_header __header;
2340 };
2341
2342
2343
2344 struct wait_named_pipe_request
2345 {
2346     struct request_header __header;
2347     unsigned int   timeout;
2348     void*          overlapped;
2349     void*          func;
2350     /* VARARG(name,unicode_str); */
2351 };
2352 struct wait_named_pipe_reply
2353 {
2354     struct reply_header __header;
2355 };
2356
2357
2358
2359 struct disconnect_named_pipe_request
2360 {
2361     struct request_header __header;
2362     handle_t       handle;
2363 };
2364 struct disconnect_named_pipe_reply
2365 {
2366     struct reply_header __header;
2367 };
2368
2369
2370 struct get_named_pipe_info_request
2371 {
2372     struct request_header __header;
2373     handle_t       handle;
2374 };
2375 struct get_named_pipe_info_reply
2376 {
2377     struct reply_header __header;
2378     unsigned int   flags;
2379     unsigned int   maxinstances;
2380     unsigned int   outsize;
2381     unsigned int   insize;
2382 };
2383
2384
2385 struct create_smb_request
2386 {
2387     struct request_header __header;
2388     int            fd;
2389     unsigned int   tree_id;
2390     unsigned int   user_id;
2391     unsigned int   file_id;
2392     unsigned int   dialect;
2393 };
2394 struct create_smb_reply
2395 {
2396     struct reply_header __header;
2397     handle_t       handle;
2398 };
2399
2400
2401 struct get_smb_info_request
2402 {
2403     struct request_header __header;
2404     handle_t       handle;
2405     unsigned int   flags;
2406     unsigned int   offset;
2407 };
2408 struct get_smb_info_reply
2409 {
2410     struct reply_header __header;
2411     unsigned int   tree_id;
2412     unsigned int   user_id;
2413     unsigned int   dialect;
2414     unsigned int   file_id;
2415     unsigned int   offset;
2416 };
2417 #define SMBINFO_SET_OFFSET    0x01
2418
2419
2420
2421 struct create_window_request
2422 {
2423     struct request_header __header;
2424     user_handle_t  parent;
2425     user_handle_t  owner;
2426     atom_t         atom;
2427 };
2428 struct create_window_reply
2429 {
2430     struct reply_header __header;
2431     user_handle_t  handle;
2432 };
2433
2434
2435
2436 struct link_window_request
2437 {
2438     struct request_header __header;
2439     user_handle_t  handle;
2440     user_handle_t  parent;
2441     user_handle_t  previous;
2442 };
2443 struct link_window_reply
2444 {
2445     struct reply_header __header;
2446     user_handle_t  full_parent;
2447 };
2448
2449
2450
2451 struct destroy_window_request
2452 {
2453     struct request_header __header;
2454     user_handle_t  handle;
2455 };
2456 struct destroy_window_reply
2457 {
2458     struct reply_header __header;
2459 };
2460
2461
2462
2463 struct set_window_owner_request
2464 {
2465     struct request_header __header;
2466     user_handle_t  handle;
2467     user_handle_t  owner;
2468 };
2469 struct set_window_owner_reply
2470 {
2471     struct reply_header __header;
2472     user_handle_t  full_owner;
2473 };
2474
2475
2476
2477 struct get_window_info_request
2478 {
2479     struct request_header __header;
2480     user_handle_t  handle;
2481 };
2482 struct get_window_info_reply
2483 {
2484     struct reply_header __header;
2485     user_handle_t  full_handle;
2486     void*          pid;
2487     void*          tid;
2488     atom_t         atom;
2489 };
2490
2491
2492
2493 struct set_window_info_request
2494 {
2495     struct request_header __header;
2496     user_handle_t  handle;
2497     unsigned int   flags;
2498     unsigned int   style;
2499     unsigned int   ex_style;
2500     unsigned int   id;
2501     void*          instance;
2502     void*          user_data;
2503 };
2504 struct set_window_info_reply
2505 {
2506     struct reply_header __header;
2507     unsigned int   old_style;
2508     unsigned int   old_ex_style;
2509     unsigned int   old_id;
2510     void*          old_instance;
2511     void*          old_user_data;
2512 };
2513 #define SET_WIN_STYLE     0x01
2514 #define SET_WIN_EXSTYLE   0x02
2515 #define SET_WIN_ID        0x04
2516 #define SET_WIN_INSTANCE  0x08
2517 #define SET_WIN_USERDATA  0x10
2518
2519
2520
2521 struct get_window_parents_request
2522 {
2523     struct request_header __header;
2524     user_handle_t  handle;
2525 };
2526 struct get_window_parents_reply
2527 {
2528     struct reply_header __header;
2529     int            count;
2530     /* VARARG(parents,user_handles); */
2531 };
2532
2533
2534
2535 struct get_window_children_request
2536 {
2537     struct request_header __header;
2538     user_handle_t  parent;
2539     atom_t         atom;
2540     void*          tid;
2541 };
2542 struct get_window_children_reply
2543 {
2544     struct reply_header __header;
2545     int            count;
2546     /* VARARG(children,user_handles); */
2547 };
2548
2549
2550
2551 struct get_window_tree_request
2552 {
2553     struct request_header __header;
2554     user_handle_t  handle;
2555 };
2556 struct get_window_tree_reply
2557 {
2558     struct reply_header __header;
2559     user_handle_t  parent;
2560     user_handle_t  owner;
2561     user_handle_t  next_sibling;
2562     user_handle_t  prev_sibling;
2563     user_handle_t  first_sibling;
2564     user_handle_t  last_sibling;
2565     user_handle_t  first_child;
2566     user_handle_t  last_child;
2567 };
2568
2569
2570 struct set_window_rectangles_request
2571 {
2572     struct request_header __header;
2573     user_handle_t  handle;
2574     rectangle_t    window;
2575     rectangle_t    client;
2576 };
2577 struct set_window_rectangles_reply
2578 {
2579     struct reply_header __header;
2580 };
2581
2582
2583
2584 struct get_window_rectangles_request
2585 {
2586     struct request_header __header;
2587     user_handle_t  handle;
2588 };
2589 struct get_window_rectangles_reply
2590 {
2591     struct reply_header __header;
2592     rectangle_t    window;
2593     rectangle_t    client;
2594 };
2595
2596
2597
2598 struct get_window_text_request
2599 {
2600     struct request_header __header;
2601     user_handle_t  handle;
2602 };
2603 struct get_window_text_reply
2604 {
2605     struct reply_header __header;
2606     /* VARARG(text,unicode_str); */
2607 };
2608
2609
2610
2611 struct set_window_text_request
2612 {
2613     struct request_header __header;
2614     user_handle_t  handle;
2615     /* VARARG(text,unicode_str); */
2616 };
2617 struct set_window_text_reply
2618 {
2619     struct reply_header __header;
2620 };
2621
2622
2623
2624 struct inc_window_paint_count_request
2625 {
2626     struct request_header __header;
2627     user_handle_t  handle;
2628     int             incr;
2629 };
2630 struct inc_window_paint_count_reply
2631 {
2632     struct reply_header __header;
2633 };
2634
2635
2636
2637 struct get_windows_offset_request
2638 {
2639     struct request_header __header;
2640     user_handle_t  from;
2641     user_handle_t  to;
2642 };
2643 struct get_windows_offset_reply
2644 {
2645     struct reply_header __header;
2646     int            x;
2647     int            y;
2648 };
2649
2650
2651
2652 struct set_window_property_request
2653 {
2654     struct request_header __header;
2655     user_handle_t  window;
2656     atom_t         atom;
2657     int            string;
2658     handle_t       handle;
2659 };
2660 struct set_window_property_reply
2661 {
2662     struct reply_header __header;
2663 };
2664
2665
2666
2667 struct remove_window_property_request
2668 {
2669     struct request_header __header;
2670     user_handle_t  window;
2671     atom_t         atom;
2672 };
2673 struct remove_window_property_reply
2674 {
2675     struct reply_header __header;
2676     handle_t       handle;
2677 };
2678
2679
2680
2681 struct get_window_property_request
2682 {
2683     struct request_header __header;
2684     user_handle_t  window;
2685     atom_t         atom;
2686 };
2687 struct get_window_property_reply
2688 {
2689     struct reply_header __header;
2690     handle_t       handle;
2691 };
2692
2693
2694
2695 struct get_window_properties_request
2696 {
2697     struct request_header __header;
2698     user_handle_t  window;
2699 };
2700 struct get_window_properties_reply
2701 {
2702     struct reply_header __header;
2703     int            total;
2704     /* VARARG(props,properties); */
2705 };
2706
2707
2708 enum request
2709 {
2710     REQ_new_process,
2711     REQ_get_new_process_info,
2712     REQ_new_thread,
2713     REQ_boot_done,
2714     REQ_init_process,
2715     REQ_get_startup_info,
2716     REQ_init_process_done,
2717     REQ_init_thread,
2718     REQ_terminate_process,
2719     REQ_terminate_thread,
2720     REQ_get_process_info,
2721     REQ_set_process_info,
2722     REQ_get_thread_info,
2723     REQ_set_thread_info,
2724     REQ_suspend_thread,
2725     REQ_resume_thread,
2726     REQ_load_dll,
2727     REQ_unload_dll,
2728     REQ_queue_apc,
2729     REQ_get_apc,
2730     REQ_close_handle,
2731     REQ_set_handle_info,
2732     REQ_dup_handle,
2733     REQ_open_process,
2734     REQ_open_thread,
2735     REQ_select,
2736     REQ_create_event,
2737     REQ_event_op,
2738     REQ_open_event,
2739     REQ_create_mutex,
2740     REQ_release_mutex,
2741     REQ_open_mutex,
2742     REQ_create_semaphore,
2743     REQ_release_semaphore,
2744     REQ_open_semaphore,
2745     REQ_create_file,
2746     REQ_alloc_file_handle,
2747     REQ_get_handle_fd,
2748     REQ_set_file_pointer,
2749     REQ_truncate_file,
2750     REQ_set_file_time,
2751     REQ_flush_file,
2752     REQ_get_file_info,
2753     REQ_lock_file,
2754     REQ_unlock_file,
2755     REQ_create_pipe,
2756     REQ_create_socket,
2757     REQ_accept_socket,
2758     REQ_set_socket_event,
2759     REQ_get_socket_event,
2760     REQ_enable_socket_event,
2761     REQ_alloc_console,
2762     REQ_free_console,
2763     REQ_get_console_renderer_events,
2764     REQ_open_console,
2765     REQ_get_console_mode,
2766     REQ_set_console_mode,
2767     REQ_set_console_input_info,
2768     REQ_get_console_input_info,
2769     REQ_append_console_input_history,
2770     REQ_get_console_input_history,
2771     REQ_create_console_output,
2772     REQ_set_console_output_info,
2773     REQ_get_console_output_info,
2774     REQ_write_console_input,
2775     REQ_read_console_input,
2776     REQ_write_console_output,
2777     REQ_fill_console_output,
2778     REQ_read_console_output,
2779     REQ_move_console_output,
2780     REQ_create_change_notification,
2781     REQ_create_mapping,
2782     REQ_open_mapping,
2783     REQ_get_mapping_info,
2784     REQ_create_device,
2785     REQ_create_snapshot,
2786     REQ_next_process,
2787     REQ_next_thread,
2788     REQ_next_module,
2789     REQ_wait_debug_event,
2790     REQ_queue_exception_event,
2791     REQ_get_exception_status,
2792     REQ_output_debug_string,
2793     REQ_continue_debug_event,
2794     REQ_debug_process,
2795     REQ_debug_break,
2796     REQ_set_debugger_kill_on_exit,
2797     REQ_read_process_memory,
2798     REQ_write_process_memory,
2799     REQ_create_key,
2800     REQ_open_key,
2801     REQ_delete_key,
2802     REQ_enum_key,
2803     REQ_set_key_value,
2804     REQ_get_key_value,
2805     REQ_enum_key_value,
2806     REQ_delete_key_value,
2807     REQ_load_registry,
2808     REQ_save_registry,
2809     REQ_save_registry_atexit,
2810     REQ_set_registry_levels,
2811     REQ_create_timer,
2812     REQ_open_timer,
2813     REQ_set_timer,
2814     REQ_cancel_timer,
2815     REQ_get_thread_context,
2816     REQ_set_thread_context,
2817     REQ_get_selector_entry,
2818     REQ_add_atom,
2819     REQ_delete_atom,
2820     REQ_find_atom,
2821     REQ_get_atom_name,
2822     REQ_init_atom_table,
2823     REQ_get_msg_queue,
2824     REQ_set_queue_mask,
2825     REQ_get_queue_status,
2826     REQ_wait_input_idle,
2827     REQ_send_message,
2828     REQ_get_message,
2829     REQ_reply_message,
2830     REQ_get_message_reply,
2831     REQ_set_win_timer,
2832     REQ_kill_win_timer,
2833     REQ_create_serial,
2834     REQ_get_serial_info,
2835     REQ_set_serial_info,
2836     REQ_register_async,
2837     REQ_create_named_pipe,
2838     REQ_open_named_pipe,
2839     REQ_connect_named_pipe,
2840     REQ_wait_named_pipe,
2841     REQ_disconnect_named_pipe,
2842     REQ_get_named_pipe_info,
2843     REQ_create_smb,
2844     REQ_get_smb_info,
2845     REQ_create_window,
2846     REQ_link_window,
2847     REQ_destroy_window,
2848     REQ_set_window_owner,
2849     REQ_get_window_info,
2850     REQ_set_window_info,
2851     REQ_get_window_parents,
2852     REQ_get_window_children,
2853     REQ_get_window_tree,
2854     REQ_set_window_rectangles,
2855     REQ_get_window_rectangles,
2856     REQ_get_window_text,
2857     REQ_set_window_text,
2858     REQ_inc_window_paint_count,
2859     REQ_get_windows_offset,
2860     REQ_set_window_property,
2861     REQ_remove_window_property,
2862     REQ_get_window_property,
2863     REQ_get_window_properties,
2864     REQ_NB_REQUESTS
2865 };
2866
2867 union generic_request
2868 {
2869     struct request_max_size max_size;
2870     struct request_header request_header;
2871     struct new_process_request new_process_request;
2872     struct get_new_process_info_request get_new_process_info_request;
2873     struct new_thread_request new_thread_request;
2874     struct boot_done_request boot_done_request;
2875     struct init_process_request init_process_request;
2876     struct get_startup_info_request get_startup_info_request;
2877     struct init_process_done_request init_process_done_request;
2878     struct init_thread_request init_thread_request;
2879     struct terminate_process_request terminate_process_request;
2880     struct terminate_thread_request terminate_thread_request;
2881     struct get_process_info_request get_process_info_request;
2882     struct set_process_info_request set_process_info_request;
2883     struct get_thread_info_request get_thread_info_request;
2884     struct set_thread_info_request set_thread_info_request;
2885     struct suspend_thread_request suspend_thread_request;
2886     struct resume_thread_request resume_thread_request;
2887     struct load_dll_request load_dll_request;
2888     struct unload_dll_request unload_dll_request;
2889     struct queue_apc_request queue_apc_request;
2890     struct get_apc_request get_apc_request;
2891     struct close_handle_request close_handle_request;
2892     struct set_handle_info_request set_handle_info_request;
2893     struct dup_handle_request dup_handle_request;
2894     struct open_process_request open_process_request;
2895     struct open_thread_request open_thread_request;
2896     struct select_request select_request;
2897     struct create_event_request create_event_request;
2898     struct event_op_request event_op_request;
2899     struct open_event_request open_event_request;
2900     struct create_mutex_request create_mutex_request;
2901     struct release_mutex_request release_mutex_request;
2902     struct open_mutex_request open_mutex_request;
2903     struct create_semaphore_request create_semaphore_request;
2904     struct release_semaphore_request release_semaphore_request;
2905     struct open_semaphore_request open_semaphore_request;
2906     struct create_file_request create_file_request;
2907     struct alloc_file_handle_request alloc_file_handle_request;
2908     struct get_handle_fd_request get_handle_fd_request;
2909     struct set_file_pointer_request set_file_pointer_request;
2910     struct truncate_file_request truncate_file_request;
2911     struct set_file_time_request set_file_time_request;
2912     struct flush_file_request flush_file_request;
2913     struct get_file_info_request get_file_info_request;
2914     struct lock_file_request lock_file_request;
2915     struct unlock_file_request unlock_file_request;
2916     struct create_pipe_request create_pipe_request;
2917     struct create_socket_request create_socket_request;
2918     struct accept_socket_request accept_socket_request;
2919     struct set_socket_event_request set_socket_event_request;
2920     struct get_socket_event_request get_socket_event_request;
2921     struct enable_socket_event_request enable_socket_event_request;
2922     struct alloc_console_request alloc_console_request;
2923     struct free_console_request free_console_request;
2924     struct get_console_renderer_events_request get_console_renderer_events_request;
2925     struct open_console_request open_console_request;
2926     struct get_console_mode_request get_console_mode_request;
2927     struct set_console_mode_request set_console_mode_request;
2928     struct set_console_input_info_request set_console_input_info_request;
2929     struct get_console_input_info_request get_console_input_info_request;
2930     struct append_console_input_history_request append_console_input_history_request;
2931     struct get_console_input_history_request get_console_input_history_request;
2932     struct create_console_output_request create_console_output_request;
2933     struct set_console_output_info_request set_console_output_info_request;
2934     struct get_console_output_info_request get_console_output_info_request;
2935     struct write_console_input_request write_console_input_request;
2936     struct read_console_input_request read_console_input_request;
2937     struct write_console_output_request write_console_output_request;
2938     struct fill_console_output_request fill_console_output_request;
2939     struct read_console_output_request read_console_output_request;
2940     struct move_console_output_request move_console_output_request;
2941     struct create_change_notification_request create_change_notification_request;
2942     struct create_mapping_request create_mapping_request;
2943     struct open_mapping_request open_mapping_request;
2944     struct get_mapping_info_request get_mapping_info_request;
2945     struct create_device_request create_device_request;
2946     struct create_snapshot_request create_snapshot_request;
2947     struct next_process_request next_process_request;
2948     struct next_thread_request next_thread_request;
2949     struct next_module_request next_module_request;
2950     struct wait_debug_event_request wait_debug_event_request;
2951     struct queue_exception_event_request queue_exception_event_request;
2952     struct get_exception_status_request get_exception_status_request;
2953     struct output_debug_string_request output_debug_string_request;
2954     struct continue_debug_event_request continue_debug_event_request;
2955     struct debug_process_request debug_process_request;
2956     struct debug_break_request debug_break_request;
2957     struct set_debugger_kill_on_exit_request set_debugger_kill_on_exit_request;
2958     struct read_process_memory_request read_process_memory_request;
2959     struct write_process_memory_request write_process_memory_request;
2960     struct create_key_request create_key_request;
2961     struct open_key_request open_key_request;
2962     struct delete_key_request delete_key_request;
2963     struct enum_key_request enum_key_request;
2964     struct set_key_value_request set_key_value_request;
2965     struct get_key_value_request get_key_value_request;
2966     struct enum_key_value_request enum_key_value_request;
2967     struct delete_key_value_request delete_key_value_request;
2968     struct load_registry_request load_registry_request;
2969     struct save_registry_request save_registry_request;
2970     struct save_registry_atexit_request save_registry_atexit_request;
2971     struct set_registry_levels_request set_registry_levels_request;
2972     struct create_timer_request create_timer_request;
2973     struct open_timer_request open_timer_request;
2974     struct set_timer_request set_timer_request;
2975     struct cancel_timer_request cancel_timer_request;
2976     struct get_thread_context_request get_thread_context_request;
2977     struct set_thread_context_request set_thread_context_request;
2978     struct get_selector_entry_request get_selector_entry_request;
2979     struct add_atom_request add_atom_request;
2980     struct delete_atom_request delete_atom_request;
2981     struct find_atom_request find_atom_request;
2982     struct get_atom_name_request get_atom_name_request;
2983     struct init_atom_table_request init_atom_table_request;
2984     struct get_msg_queue_request get_msg_queue_request;
2985     struct set_queue_mask_request set_queue_mask_request;
2986     struct get_queue_status_request get_queue_status_request;
2987     struct wait_input_idle_request wait_input_idle_request;
2988     struct send_message_request send_message_request;
2989     struct get_message_request get_message_request;
2990     struct reply_message_request reply_message_request;
2991     struct get_message_reply_request get_message_reply_request;
2992     struct set_win_timer_request set_win_timer_request;
2993     struct kill_win_timer_request kill_win_timer_request;
2994     struct create_serial_request create_serial_request;
2995     struct get_serial_info_request get_serial_info_request;
2996     struct set_serial_info_request set_serial_info_request;
2997     struct register_async_request register_async_request;
2998     struct create_named_pipe_request create_named_pipe_request;
2999     struct open_named_pipe_request open_named_pipe_request;
3000     struct connect_named_pipe_request connect_named_pipe_request;
3001     struct wait_named_pipe_request wait_named_pipe_request;
3002     struct disconnect_named_pipe_request disconnect_named_pipe_request;
3003     struct get_named_pipe_info_request get_named_pipe_info_request;
3004     struct create_smb_request create_smb_request;
3005     struct get_smb_info_request get_smb_info_request;
3006     struct create_window_request create_window_request;
3007     struct link_window_request link_window_request;
3008     struct destroy_window_request destroy_window_request;
3009     struct set_window_owner_request set_window_owner_request;
3010     struct get_window_info_request get_window_info_request;
3011     struct set_window_info_request set_window_info_request;
3012     struct get_window_parents_request get_window_parents_request;
3013     struct get_window_children_request get_window_children_request;
3014     struct get_window_tree_request get_window_tree_request;
3015     struct set_window_rectangles_request set_window_rectangles_request;
3016     struct get_window_rectangles_request get_window_rectangles_request;
3017     struct get_window_text_request get_window_text_request;
3018     struct set_window_text_request set_window_text_request;
3019     struct inc_window_paint_count_request inc_window_paint_count_request;
3020     struct get_windows_offset_request get_windows_offset_request;
3021     struct set_window_property_request set_window_property_request;
3022     struct remove_window_property_request remove_window_property_request;
3023     struct get_window_property_request get_window_property_request;
3024     struct get_window_properties_request get_window_properties_request;
3025 };
3026 union generic_reply
3027 {
3028     struct request_max_size max_size;
3029     struct reply_header reply_header;
3030     struct new_process_reply new_process_reply;
3031     struct get_new_process_info_reply get_new_process_info_reply;
3032     struct new_thread_reply new_thread_reply;
3033     struct boot_done_reply boot_done_reply;
3034     struct init_process_reply init_process_reply;
3035     struct get_startup_info_reply get_startup_info_reply;
3036     struct init_process_done_reply init_process_done_reply;
3037     struct init_thread_reply init_thread_reply;
3038     struct terminate_process_reply terminate_process_reply;
3039     struct terminate_thread_reply terminate_thread_reply;
3040     struct get_process_info_reply get_process_info_reply;
3041     struct set_process_info_reply set_process_info_reply;
3042     struct get_thread_info_reply get_thread_info_reply;
3043     struct set_thread_info_reply set_thread_info_reply;
3044     struct suspend_thread_reply suspend_thread_reply;
3045     struct resume_thread_reply resume_thread_reply;
3046     struct load_dll_reply load_dll_reply;
3047     struct unload_dll_reply unload_dll_reply;
3048     struct queue_apc_reply queue_apc_reply;
3049     struct get_apc_reply get_apc_reply;
3050     struct close_handle_reply close_handle_reply;
3051     struct set_handle_info_reply set_handle_info_reply;
3052     struct dup_handle_reply dup_handle_reply;
3053     struct open_process_reply open_process_reply;
3054     struct open_thread_reply open_thread_reply;
3055     struct select_reply select_reply;
3056     struct create_event_reply create_event_reply;
3057     struct event_op_reply event_op_reply;
3058     struct open_event_reply open_event_reply;
3059     struct create_mutex_reply create_mutex_reply;
3060     struct release_mutex_reply release_mutex_reply;
3061     struct open_mutex_reply open_mutex_reply;
3062     struct create_semaphore_reply create_semaphore_reply;
3063     struct release_semaphore_reply release_semaphore_reply;
3064     struct open_semaphore_reply open_semaphore_reply;
3065     struct create_file_reply create_file_reply;
3066     struct alloc_file_handle_reply alloc_file_handle_reply;
3067     struct get_handle_fd_reply get_handle_fd_reply;
3068     struct set_file_pointer_reply set_file_pointer_reply;
3069     struct truncate_file_reply truncate_file_reply;
3070     struct set_file_time_reply set_file_time_reply;
3071     struct flush_file_reply flush_file_reply;
3072     struct get_file_info_reply get_file_info_reply;
3073     struct lock_file_reply lock_file_reply;
3074     struct unlock_file_reply unlock_file_reply;
3075     struct create_pipe_reply create_pipe_reply;
3076     struct create_socket_reply create_socket_reply;
3077     struct accept_socket_reply accept_socket_reply;
3078     struct set_socket_event_reply set_socket_event_reply;
3079     struct get_socket_event_reply get_socket_event_reply;
3080     struct enable_socket_event_reply enable_socket_event_reply;
3081     struct alloc_console_reply alloc_console_reply;
3082     struct free_console_reply free_console_reply;
3083     struct get_console_renderer_events_reply get_console_renderer_events_reply;
3084     struct open_console_reply open_console_reply;
3085     struct get_console_mode_reply get_console_mode_reply;
3086     struct set_console_mode_reply set_console_mode_reply;
3087     struct set_console_input_info_reply set_console_input_info_reply;
3088     struct get_console_input_info_reply get_console_input_info_reply;
3089     struct append_console_input_history_reply append_console_input_history_reply;
3090     struct get_console_input_history_reply get_console_input_history_reply;
3091     struct create_console_output_reply create_console_output_reply;
3092     struct set_console_output_info_reply set_console_output_info_reply;
3093     struct get_console_output_info_reply get_console_output_info_reply;
3094     struct write_console_input_reply write_console_input_reply;
3095     struct read_console_input_reply read_console_input_reply;
3096     struct write_console_output_reply write_console_output_reply;
3097     struct fill_console_output_reply fill_console_output_reply;
3098     struct read_console_output_reply read_console_output_reply;
3099     struct move_console_output_reply move_console_output_reply;
3100     struct create_change_notification_reply create_change_notification_reply;
3101     struct create_mapping_reply create_mapping_reply;
3102     struct open_mapping_reply open_mapping_reply;
3103     struct get_mapping_info_reply get_mapping_info_reply;
3104     struct create_device_reply create_device_reply;
3105     struct create_snapshot_reply create_snapshot_reply;
3106     struct next_process_reply next_process_reply;
3107     struct next_thread_reply next_thread_reply;
3108     struct next_module_reply next_module_reply;
3109     struct wait_debug_event_reply wait_debug_event_reply;
3110     struct queue_exception_event_reply queue_exception_event_reply;
3111     struct get_exception_status_reply get_exception_status_reply;
3112     struct output_debug_string_reply output_debug_string_reply;
3113     struct continue_debug_event_reply continue_debug_event_reply;
3114     struct debug_process_reply debug_process_reply;
3115     struct debug_break_reply debug_break_reply;
3116     struct set_debugger_kill_on_exit_reply set_debugger_kill_on_exit_reply;
3117     struct read_process_memory_reply read_process_memory_reply;
3118     struct write_process_memory_reply write_process_memory_reply;
3119     struct create_key_reply create_key_reply;
3120     struct open_key_reply open_key_reply;
3121     struct delete_key_reply delete_key_reply;
3122     struct enum_key_reply enum_key_reply;
3123     struct set_key_value_reply set_key_value_reply;
3124     struct get_key_value_reply get_key_value_reply;
3125     struct enum_key_value_reply enum_key_value_reply;
3126     struct delete_key_value_reply delete_key_value_reply;
3127     struct load_registry_reply load_registry_reply;
3128     struct save_registry_reply save_registry_reply;
3129     struct save_registry_atexit_reply save_registry_atexit_reply;
3130     struct set_registry_levels_reply set_registry_levels_reply;
3131     struct create_timer_reply create_timer_reply;
3132     struct open_timer_reply open_timer_reply;
3133     struct set_timer_reply set_timer_reply;
3134     struct cancel_timer_reply cancel_timer_reply;
3135     struct get_thread_context_reply get_thread_context_reply;
3136     struct set_thread_context_reply set_thread_context_reply;
3137     struct get_selector_entry_reply get_selector_entry_reply;
3138     struct add_atom_reply add_atom_reply;
3139     struct delete_atom_reply delete_atom_reply;
3140     struct find_atom_reply find_atom_reply;
3141     struct get_atom_name_reply get_atom_name_reply;
3142     struct init_atom_table_reply init_atom_table_reply;
3143     struct get_msg_queue_reply get_msg_queue_reply;
3144     struct set_queue_mask_reply set_queue_mask_reply;
3145     struct get_queue_status_reply get_queue_status_reply;
3146     struct wait_input_idle_reply wait_input_idle_reply;
3147     struct send_message_reply send_message_reply;
3148     struct get_message_reply get_message_reply;
3149     struct reply_message_reply reply_message_reply;
3150     struct get_message_reply_reply get_message_reply_reply;
3151     struct set_win_timer_reply set_win_timer_reply;
3152     struct kill_win_timer_reply kill_win_timer_reply;
3153     struct create_serial_reply create_serial_reply;
3154     struct get_serial_info_reply get_serial_info_reply;
3155     struct set_serial_info_reply set_serial_info_reply;
3156     struct register_async_reply register_async_reply;
3157     struct create_named_pipe_reply create_named_pipe_reply;
3158     struct open_named_pipe_reply open_named_pipe_reply;
3159     struct connect_named_pipe_reply connect_named_pipe_reply;
3160     struct wait_named_pipe_reply wait_named_pipe_reply;
3161     struct disconnect_named_pipe_reply disconnect_named_pipe_reply;
3162     struct get_named_pipe_info_reply get_named_pipe_info_reply;
3163     struct create_smb_reply create_smb_reply;
3164     struct get_smb_info_reply get_smb_info_reply;
3165     struct create_window_reply create_window_reply;
3166     struct link_window_reply link_window_reply;
3167     struct destroy_window_reply destroy_window_reply;
3168     struct set_window_owner_reply set_window_owner_reply;
3169     struct get_window_info_reply get_window_info_reply;
3170     struct set_window_info_reply set_window_info_reply;
3171     struct get_window_parents_reply get_window_parents_reply;
3172     struct get_window_children_reply get_window_children_reply;
3173     struct get_window_tree_reply get_window_tree_reply;
3174     struct set_window_rectangles_reply set_window_rectangles_reply;
3175     struct get_window_rectangles_reply get_window_rectangles_reply;
3176     struct get_window_text_reply get_window_text_reply;
3177     struct set_window_text_reply set_window_text_reply;
3178     struct inc_window_paint_count_reply inc_window_paint_count_reply;
3179     struct get_windows_offset_reply get_windows_offset_reply;
3180     struct set_window_property_reply set_window_property_reply;
3181     struct remove_window_property_reply remove_window_property_reply;
3182     struct get_window_property_reply get_window_property_reply;
3183     struct get_window_properties_reply get_window_properties_reply;
3184 };
3185
3186 #define SERVER_PROTOCOL_VERSION 78
3187
3188 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */