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_SOCKET,
 795     FD_TYPE_SMB
 796 };
 797 #define FD_FLAG_OVERLAPPED         0x01
 798 #define FD_FLAG_TIMEOUT            0x02
 799 #define FD_FLAG_RECV_SHUTDOWN      0x04
 800 #define FD_FLAG_SEND_SHUTDOWN      0x08
 801
 802
 803 struct set_file_pointer_request
 804 {
 805     struct request_header __header;
 806     handle_t     handle;
 807     int          low;
 808     int          high;
 809     int          whence;
 810 };
 811 struct set_file_pointer_reply
 812 {
 813     struct reply_header __header;
 814     int          new_low;
 815     int          new_high;
 816 };
 817
 818
 819
 820 struct truncate_file_request
 821 {
 822     struct request_header __header;
 823     handle_t     handle;
 824 };
 825 struct truncate_file_reply
 826 {
 827     struct reply_header __header;
 828 };
 829
 830
 831
 832 struct set_file_time_request
 833 {
 834     struct request_header __header;
 835     handle_t     handle;
 836     time_t       access_time;
 837     time_t       write_time;
 838 };
 839 struct set_file_time_reply
 840 {
 841     struct reply_header __header;
 842 };
 843
 844
 845
 846 struct flush_file_request
 847 {
 848     struct request_header __header;
 849     handle_t     handle;
 850 };
 851 struct flush_file_reply
 852 {
 853     struct reply_header __header;
 854 };
 855
 856
 857
 858 struct get_file_info_request
 859 {
 860     struct request_header __header;
 861     handle_t     handle;
 862 };
 863 struct get_file_info_reply
 864 {
 865     struct reply_header __header;
 866     int          type;
 867     int          attr;
 868     time_t       access_time;
 869     time_t       write_time;
 870     int          size_high;
 871     int          size_low;
 872     int          links;
 873     int          index_high;
 874     int          index_low;
 875     unsigned int serial;
 876 };
 877
 878
 879
 880 struct lock_file_request
 881 {
 882     struct request_header __header;
 883     handle_t     handle;
 884     unsigned int offset_low;
 885     unsigned int offset_high;
 886     unsigned int count_low;
 887     unsigned int count_high;
 888 };
 889 struct lock_file_reply
 890 {
 891     struct reply_header __header;
 892 };
 893
 894
 895
 896 struct unlock_file_request
 897 {
 898     struct request_header __header;
 899     handle_t     handle;
 900     unsigned int offset_low;
 901     unsigned int offset_high;
 902     unsigned int count_low;
 903     unsigned int count_high;
 904 };
 905 struct unlock_file_reply
 906 {
 907     struct reply_header __header;
 908 };
 909
 910
 911
 912 struct create_pipe_request
 913 {
 914     struct request_header __header;
 915     int          inherit;
 916 };
 917 struct create_pipe_reply
 918 {
 919     struct reply_header __header;
 920     handle_t     handle_read;
 921     handle_t     handle_write;
 922 };
 923
 924
 925
 926 struct create_socket_request
 927 {
 928     struct request_header __header;
 929     unsigned int access;
 930     int          inherit;
 931     int          family;
 932     int          type;
 933     int          protocol;
 934     unsigned int flags;
 935 };
 936 struct create_socket_reply
 937 {
 938     struct reply_header __header;
 939     handle_t     handle;
 940 };
 941
 942
 943
 944 struct accept_socket_request
 945 {
 946     struct request_header __header;
 947     handle_t     lhandle;
 948     unsigned int access;
 949     int          inherit;
 950 };
 951 struct accept_socket_reply
 952 {
 953     struct reply_header __header;
 954     handle_t     handle;
 955 };
 956
 957
 958
 959 struct set_socket_event_request
 960 {
 961     struct request_header __header;
 962     handle_t      handle;
 963     unsigned int  mask;
 964     handle_t      event;
 965     user_handle_t window;
 966     unsigned int  msg;
 967 };
 968 struct set_socket_event_reply
 969 {
 970     struct reply_header __header;
 971 };
 972
 973
 974
 975 struct get_socket_event_request
 976 {
 977     struct request_header __header;
 978     handle_t     handle;
 979     int          service;
 980     handle_t     c_event;
 981 };
 982 struct get_socket_event_reply
 983 {
 984     struct reply_header __header;
 985     unsigned int mask;
 986     unsigned int pmask;
 987     unsigned int state;
 988     /* VARARG(errors,ints); */
 989 };
 990
 991
 992
 993 struct enable_socket_event_request
 994 {
 995     struct request_header __header;
 996     handle_t     handle;
 997     unsigned int mask;
 998     unsigned int sstate;
 999     unsigned int cstate;
1000 };
1001 struct enable_socket_event_reply
1002 {
1003     struct reply_header __header;
1004 };
1005
1006 struct set_socket_deferred_request
1007 {
1008     struct request_header __header;
1009     handle_t     handle;
1010     handle_t     deferred;
1011 };
1012 struct set_socket_deferred_reply
1013 {
1014     struct reply_header __header;
1015 };
1016
1017
1018 struct alloc_console_request
1019 {
1020     struct request_header __header;
1021     unsigned int access;
1022     int          inherit;
1023     void*        pid;
1024 };
1025 struct alloc_console_reply
1026 {
1027     struct reply_header __header;
1028     handle_t     handle_in;
1029     handle_t     event;
1030 };
1031
1032
1033
1034 struct free_console_request
1035 {
1036     struct request_header __header;
1037 };
1038 struct free_console_reply
1039 {
1040     struct reply_header __header;
1041 };
1042
1043
1044 #define CONSOLE_RENDERER_NONE_EVENT        0x00
1045 #define CONSOLE_RENDERER_TITLE_EVENT       0x01
1046 #define CONSOLE_RENDERER_ACTIVE_SB_EVENT   0x02
1047 #define CONSOLE_RENDERER_SB_RESIZE_EVENT   0x03
1048 #define CONSOLE_RENDERER_UPDATE_EVENT      0x04
1049 #define CONSOLE_RENDERER_CURSOR_POS_EVENT  0x05
1050 #define CONSOLE_RENDERER_CURSOR_GEOM_EVENT 0x06
1051 #define CONSOLE_RENDERER_DISPLAY_EVENT     0x07
1052 #define CONSOLE_RENDERER_EXIT_EVENT        0x08
1053 struct console_renderer_event
1054 {
1055     short event;
1056     union
1057     {
1058         struct update
1059         {
1060             short top;
1061             short bottom;
1062         } update;
1063         struct resize
1064         {
1065             short width;
1066             short height;
1067         } resize;
1068         struct cursor_pos
1069         {
1070             short x;
1071             short y;
1072         } cursor_pos;
1073         struct cursor_geom
1074         {
1075             short visible;
1076             short size;
1077         } cursor_geom;
1078         struct display
1079         {
1080             short left;
1081             short top;
1082             short width;
1083             short height;
1084         } display;
1085     } u;
1086 };
1087
1088
1089 struct get_console_renderer_events_request
1090 {
1091     struct request_header __header;
1092     handle_t     handle;
1093 };
1094 struct get_console_renderer_events_reply
1095 {
1096     struct reply_header __header;
1097     /* VARARG(data,bytes); */
1098 };
1099
1100
1101
1102 struct open_console_request
1103 {
1104     struct request_header __header;
1105     int          from;
1106
1107     unsigned int access;
1108     int          inherit;
1109     int          share;
1110 };
1111 struct open_console_reply
1112 {
1113     struct reply_header __header;
1114     handle_t     handle;
1115 };
1116
1117
1118
1119 struct get_console_mode_request
1120 {
1121     struct request_header __header;
1122     handle_t     handle;
1123 };
1124 struct get_console_mode_reply
1125 {
1126     struct reply_header __header;
1127     int          mode;
1128 };
1129
1130
1131
1132 struct set_console_mode_request
1133 {
1134     struct request_header __header;
1135     handle_t     handle;
1136     int          mode;
1137 };
1138 struct set_console_mode_reply
1139 {
1140     struct reply_header __header;
1141 };
1142
1143
1144
1145 struct set_console_input_info_request
1146 {
1147     struct request_header __header;
1148     handle_t     handle;
1149     int          mask;
1150     handle_t     active_sb;
1151     int          history_mode;
1152     int          history_size;
1153     /* VARARG(title,unicode_str); */
1154 };
1155 struct set_console_input_info_reply
1156 {
1157     struct reply_header __header;
1158 };
1159 #define SET_CONSOLE_INPUT_INFO_ACTIVE_SB        0x01
1160 #define SET_CONSOLE_INPUT_INFO_TITLE            0x02
1161 #define SET_CONSOLE_INPUT_INFO_HISTORY_MODE     0x04
1162 #define SET_CONSOLE_INPUT_INFO_HISTORY_SIZE     0x08
1163
1164
1165
1166 struct get_console_input_info_request
1167 {
1168     struct request_header __header;
1169     handle_t     handle;
1170 };
1171 struct get_console_input_info_reply
1172 {
1173     struct reply_header __header;
1174     int          history_mode;
1175     int          history_size;
1176     int          history_index;
1177     /* VARARG(title,unicode_str); */
1178 };
1179
1180
1181
1182 struct append_console_input_history_request
1183 {
1184     struct request_header __header;
1185     handle_t     handle;
1186     /* VARARG(line,unicode_str); */
1187 };
1188 struct append_console_input_history_reply
1189 {
1190     struct reply_header __header;
1191 };
1192
1193
1194
1195 struct get_console_input_history_request
1196 {
1197     struct request_header __header;
1198     handle_t     handle;
1199     int          index;
1200 };
1201 struct get_console_input_history_reply
1202 {
1203     struct reply_header __header;
1204     int          total;
1205     /* VARARG(line,unicode_str); */
1206 };
1207
1208
1209
1210 struct create_console_output_request
1211 {
1212     struct request_header __header;
1213     handle_t     handle_in;
1214     int          access;
1215     int          share;
1216     int          inherit;
1217 };
1218 struct create_console_output_reply
1219 {
1220     struct reply_header __header;
1221     handle_t     handle_out;
1222 };
1223
1224
1225
1226 struct set_console_output_info_request
1227 {
1228     struct request_header __header;
1229     handle_t     handle;
1230     int          mask;
1231     short int    cursor_size;
1232     short int    cursor_visible;
1233     short int    cursor_x;
1234     short int    cursor_y;
1235     short int    width;
1236     short int    height;
1237     short int    attr;
1238     short int    win_left;
1239     short int    win_top;
1240     short int    win_right;
1241     short int    win_bottom;
1242     short int    max_width;
1243     short int    max_height;
1244 };
1245 struct set_console_output_info_reply
1246 {
1247     struct reply_header __header;
1248 };
1249 #define SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM     0x01
1250 #define SET_CONSOLE_OUTPUT_INFO_CURSOR_POS      0x02
1251 #define SET_CONSOLE_OUTPUT_INFO_SIZE            0x04
1252 #define SET_CONSOLE_OUTPUT_INFO_ATTR            0x08
1253 #define SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW  0x10
1254 #define SET_CONSOLE_OUTPUT_INFO_MAX_SIZE        0x20
1255
1256
1257
1258 struct get_console_output_info_request
1259 {
1260     struct request_header __header;
1261     handle_t     handle;
1262 };
1263 struct get_console_output_info_reply
1264 {
1265     struct reply_header __header;
1266     short int    cursor_size;
1267     short int    cursor_visible;
1268     short int    cursor_x;
1269     short int    cursor_y;
1270     short int    width;
1271     short int    height;
1272     short int    attr;
1273     short int    win_left;
1274     short int    win_top;
1275     short int    win_right;
1276     short int    win_bottom;
1277     short int    max_width;
1278     short int    max_height;
1279 };
1280
1281
1282 struct write_console_input_request
1283 {
1284     struct request_header __header;
1285     handle_t     handle;
1286     /* VARARG(rec,input_records); */
1287 };
1288 struct write_console_input_reply
1289 {
1290     struct reply_header __header;
1291     int          written;
1292 };
1293
1294
1295
1296 struct read_console_input_request
1297 {
1298     struct request_header __header;
1299     handle_t     handle;
1300     int          flush;
1301 };
1302 struct read_console_input_reply
1303 {
1304     struct reply_header __header;
1305     int          read;
1306     /* VARARG(rec,input_records); */
1307 };
1308
1309
1310
1311 struct write_console_output_request
1312 {
1313     struct request_header __header;
1314     handle_t     handle;
1315     int          x;
1316     int          y;
1317     int          mode;
1318     int          wrap;
1319     /* VARARG(data,bytes); */
1320 };
1321 struct write_console_output_reply
1322 {
1323     struct reply_header __header;
1324     int          written;
1325     int          width;
1326     int          height;
1327 };
1328 enum char_info_mode
1329 {
1330     CHAR_INFO_MODE_TEXT,
1331     CHAR_INFO_MODE_ATTR,
1332     CHAR_INFO_MODE_TEXTATTR,
1333     CHAR_INFO_MODE_TEXTSTDATTR
1334 };
1335
1336
1337
1338 struct fill_console_output_request
1339 {
1340     struct request_header __header;
1341     handle_t     handle;
1342     int          x;
1343     int          y;
1344     int          mode;
1345     int          count;
1346     int          wrap;
1347     char_info_t  data;
1348 };
1349 struct fill_console_output_reply
1350 {
1351     struct reply_header __header;
1352     int          written;
1353 };
1354
1355
1356
1357 struct read_console_output_request
1358 {
1359     struct request_header __header;
1360     handle_t     handle;
1361     int          x;
1362     int          y;
1363     int          mode;
1364     int          wrap;
1365 };
1366 struct read_console_output_reply
1367 {
1368     struct reply_header __header;
1369     int          width;
1370     int          height;
1371     /* VARARG(data,bytes); */
1372 };
1373
1374
1375 struct move_console_output_request
1376 {
1377     struct request_header __header;
1378     handle_t     handle;
1379     short int    x_src;
1380     short int    y_src;
1381     short int    x_dst;
1382     short int    y_dst;
1383     short int    w;
1384     short int    h;
1385 };
1386 struct move_console_output_reply
1387 {
1388     struct reply_header __header;
1389 };
1390
1391
1392
1393 struct create_change_notification_request
1394 {
1395     struct request_header __header;
1396     int          subtree;
1397     int          filter;
1398 };
1399 struct create_change_notification_reply
1400 {
1401     struct reply_header __header;
1402     handle_t     handle;
1403 };
1404
1405
1406
1407 struct create_mapping_request
1408 {
1409     struct request_header __header;
1410     int          size_high;
1411     int          size_low;
1412     int          protect;
1413     int          inherit;
1414     handle_t     file_handle;
1415     /* VARARG(name,unicode_str); */
1416 };
1417 struct create_mapping_reply
1418 {
1419     struct reply_header __header;
1420     handle_t     handle;
1421 };
1422
1423 #define VPROT_READ       0x01
1424 #define VPROT_WRITE      0x02
1425 #define VPROT_EXEC       0x04
1426 #define VPROT_WRITECOPY  0x08
1427 #define VPROT_GUARD      0x10
1428 #define VPROT_NOCACHE    0x20
1429 #define VPROT_COMMITTED  0x40
1430 #define VPROT_IMAGE      0x80
1431
1432
1433
1434 struct open_mapping_request
1435 {
1436     struct request_header __header;
1437     unsigned int access;
1438     int          inherit;
1439     /* VARARG(name,unicode_str); */
1440 };
1441 struct open_mapping_reply
1442 {
1443     struct reply_header __header;
1444     handle_t     handle;
1445 };
1446
1447
1448
1449 struct get_mapping_info_request
1450 {
1451     struct request_header __header;
1452     handle_t     handle;
1453 };
1454 struct get_mapping_info_reply
1455 {
1456     struct reply_header __header;
1457     int          size_high;
1458     int          size_low;
1459     int          protect;
1460     int          header_size;
1461     void*        base;
1462     handle_t     shared_file;
1463     int          shared_size;
1464     int          drive_type;
1465 };
1466
1467
1468
1469 struct create_device_request
1470 {
1471     struct request_header __header;
1472     unsigned int access;
1473     int          inherit;
1474     int          id;
1475 };
1476 struct create_device_reply
1477 {
1478     struct reply_header __header;
1479     handle_t     handle;
1480 };
1481
1482
1483
1484 struct create_snapshot_request
1485 {
1486     struct request_header __header;
1487     int          inherit;
1488     int          flags;
1489     void*        pid;
1490 };
1491 struct create_snapshot_reply
1492 {
1493     struct reply_header __header;
1494     handle_t     handle;
1495 };
1496
1497
1498
1499 struct next_process_request
1500 {
1501     struct request_header __header;
1502     handle_t     handle;
1503     int          reset;
1504 };
1505 struct next_process_reply
1506 {
1507     struct reply_header __header;
1508     int          count;
1509     void*        pid;
1510     void*        ppid;
1511     void*        heap;
1512     void*        module;
1513     int          threads;
1514     int          priority;
1515     /* VARARG(filename,string); */
1516 };
1517
1518
1519
1520 struct next_thread_request
1521 {
1522     struct request_header __header;
1523     handle_t     handle;
1524     int          reset;
1525 };
1526 struct next_thread_reply
1527 {
1528     struct reply_header __header;
1529     int          count;
1530     void*        pid;
1531     void*        tid;
1532     int          base_pri;
1533     int          delta_pri;
1534 };
1535
1536
1537
1538 struct next_module_request
1539 {
1540     struct request_header __header;
1541     handle_t     handle;
1542     int          reset;
1543 };
1544 struct next_module_reply
1545 {
1546     struct reply_header __header;
1547     void*        pid;
1548     void*        base;
1549     size_t       size;
1550     /* VARARG(filename,string); */
1551 };
1552
1553
1554
1555 struct wait_debug_event_request
1556 {
1557     struct request_header __header;
1558     int           get_handle;
1559 };
1560 struct wait_debug_event_reply
1561 {
1562     struct reply_header __header;
1563     void*         pid;
1564     void*         tid;
1565     handle_t      wait;
1566     /* VARARG(event,debug_event); */
1567 };
1568
1569
1570
1571 struct queue_exception_event_request
1572 {
1573     struct request_header __header;
1574     int              first;
1575     /* VARARG(record,exc_event); */
1576 };
1577 struct queue_exception_event_reply
1578 {
1579     struct reply_header __header;
1580     handle_t         handle;
1581 };
1582
1583
1584
1585 struct get_exception_status_request
1586 {
1587     struct request_header __header;
1588     handle_t         handle;
1589 };
1590 struct get_exception_status_reply
1591 {
1592     struct reply_header __header;
1593     int              status;
1594     /* VARARG(context,context); */
1595 };
1596
1597
1598
1599 struct output_debug_string_request
1600 {
1601     struct request_header __header;
1602     void*         string;
1603     int           unicode;
1604     int           length;
1605 };
1606 struct output_debug_string_reply
1607 {
1608     struct reply_header __header;
1609 };
1610
1611
1612
1613 struct continue_debug_event_request
1614 {
1615     struct request_header __header;
1616     void*        pid;
1617     void*        tid;
1618     int          status;
1619 };
1620 struct continue_debug_event_reply
1621 {
1622     struct reply_header __header;
1623 };
1624
1625
1626
1627 struct debug_process_request
1628 {
1629     struct request_header __header;
1630     void*        pid;
1631     int          attach;
1632 };
1633 struct debug_process_reply
1634 {
1635     struct reply_header __header;
1636 };
1637
1638
1639
1640 struct debug_break_request
1641 {
1642     struct request_header __header;
1643     handle_t     handle;
1644 };
1645 struct debug_break_reply
1646 {
1647     struct reply_header __header;
1648     int          self;
1649 };
1650
1651
1652
1653 struct set_debugger_kill_on_exit_request
1654 {
1655     struct request_header __header;
1656     int          kill_on_exit;
1657 };
1658 struct set_debugger_kill_on_exit_reply
1659 {
1660     struct reply_header __header;
1661 };
1662
1663
1664
1665 struct read_process_memory_request
1666 {
1667     struct request_header __header;
1668     handle_t     handle;
1669     void*        addr;
1670 };
1671 struct read_process_memory_reply
1672 {
1673     struct reply_header __header;
1674     /* VARARG(data,bytes); */
1675 };
1676
1677
1678
1679 struct write_process_memory_request
1680 {
1681     struct request_header __header;
1682     handle_t     handle;
1683     void*        addr;
1684     unsigned int first_mask;
1685     unsigned int last_mask;
1686     /* VARARG(data,bytes); */
1687 };
1688 struct write_process_memory_reply
1689 {
1690     struct reply_header __header;
1691 };
1692
1693
1694
1695 struct create_key_request
1696 {
1697     struct request_header __header;
1698     handle_t     parent;
1699     unsigned int access;
1700     unsigned int options;
1701     time_t       modif;
1702     size_t       namelen;
1703     /* VARARG(name,unicode_str,namelen); */
1704     /* VARARG(class,unicode_str); */
1705 };
1706 struct create_key_reply
1707 {
1708     struct reply_header __header;
1709     handle_t     hkey;
1710     int          created;
1711 };
1712
1713
1714 struct open_key_request
1715 {
1716     struct request_header __header;
1717     handle_t     parent;
1718     unsigned int access;
1719     /* VARARG(name,unicode_str); */
1720 };
1721 struct open_key_reply
1722 {
1723     struct reply_header __header;
1724     handle_t     hkey;
1725 };
1726
1727
1728
1729 struct delete_key_request
1730 {
1731     struct request_header __header;
1732     handle_t     hkey;
1733 };
1734 struct delete_key_reply
1735 {
1736     struct reply_header __header;
1737 };
1738
1739
1740
1741 struct enum_key_request
1742 {
1743     struct request_header __header;
1744     handle_t     hkey;
1745     int          index;
1746     int          info_class;
1747 };
1748 struct enum_key_reply
1749 {
1750     struct reply_header __header;
1751     int          subkeys;
1752     int          max_subkey;
1753     int          max_class;
1754     int          values;
1755     int          max_value;
1756     int          max_data;
1757     time_t       modif;
1758     size_t       total;
1759     size_t       namelen;
1760     /* VARARG(name,unicode_str,namelen); */
1761     /* VARARG(class,unicode_str); */
1762 };
1763
1764
1765
1766 struct set_key_value_request
1767 {
1768     struct request_header __header;
1769     handle_t     hkey;
1770     int          type;
1771     size_t       namelen;
1772     /* VARARG(name,unicode_str,namelen); */
1773     /* VARARG(data,bytes); */
1774 };
1775 struct set_key_value_reply
1776 {
1777     struct reply_header __header;
1778 };
1779
1780
1781
1782 struct get_key_value_request
1783 {
1784     struct request_header __header;
1785     handle_t     hkey;
1786     /* VARARG(name,unicode_str); */
1787 };
1788 struct get_key_value_reply
1789 {
1790     struct reply_header __header;
1791     int          type;
1792     size_t       total;
1793     /* VARARG(data,bytes); */
1794 };
1795
1796
1797
1798 struct enum_key_value_request
1799 {
1800     struct request_header __header;
1801     handle_t     hkey;
1802     int          index;
1803     int          info_class;
1804 };
1805 struct enum_key_value_reply
1806 {
1807     struct reply_header __header;
1808     int          type;
1809     size_t       total;
1810     size_t       namelen;
1811     /* VARARG(name,unicode_str,namelen); */
1812     /* VARARG(data,bytes); */
1813 };
1814
1815
1816
1817 struct delete_key_value_request
1818 {
1819     struct request_header __header;
1820     handle_t     hkey;
1821     /* VARARG(name,unicode_str); */
1822 };
1823 struct delete_key_value_reply
1824 {
1825     struct reply_header __header;
1826 };
1827
1828
1829
1830 struct load_registry_request
1831 {
1832     struct request_header __header;
1833     handle_t     hkey;
1834     handle_t     file;
1835     /* VARARG(name,unicode_str); */
1836 };
1837 struct load_registry_reply
1838 {
1839     struct reply_header __header;
1840 };
1841
1842
1843
1844 struct save_registry_request
1845 {
1846     struct request_header __header;
1847     handle_t     hkey;
1848     handle_t     file;
1849 };
1850 struct save_registry_reply
1851 {
1852     struct reply_header __header;
1853 };
1854
1855
1856
1857 struct save_registry_atexit_request
1858 {
1859     struct request_header __header;
1860     handle_t     hkey;
1861     /* VARARG(file,string); */
1862 };
1863 struct save_registry_atexit_reply
1864 {
1865     struct reply_header __header;
1866 };
1867
1868
1869
1870 struct set_registry_levels_request
1871 {
1872     struct request_header __header;
1873     int          current;
1874     int          saving;
1875     int          period;
1876 };
1877 struct set_registry_levels_reply
1878 {
1879     struct reply_header __header;
1880 };
1881
1882
1883
1884 struct create_timer_request
1885 {
1886     struct request_header __header;
1887     int          inherit;
1888     int          manual;
1889     /* VARARG(name,unicode_str); */
1890 };
1891 struct create_timer_reply
1892 {
1893     struct reply_header __header;
1894     handle_t     handle;
1895 };
1896
1897
1898
1899 struct open_timer_request
1900 {
1901     struct request_header __header;
1902     unsigned int access;
1903     int          inherit;
1904     /* VARARG(name,unicode_str); */
1905 };
1906 struct open_timer_reply
1907 {
1908     struct reply_header __header;
1909     handle_t     handle;
1910 };
1911
1912
1913 struct set_timer_request
1914 {
1915     struct request_header __header;
1916     handle_t     handle;
1917     int          sec;
1918     int          usec;
1919     int          period;
1920     void*        callback;
1921     void*        arg;
1922 };
1923 struct set_timer_reply
1924 {
1925     struct reply_header __header;
1926 };
1927
1928
1929 struct cancel_timer_request
1930 {
1931     struct request_header __header;
1932     handle_t     handle;
1933 };
1934 struct cancel_timer_reply
1935 {
1936     struct reply_header __header;
1937 };
1938
1939
1940
1941 struct get_thread_context_request
1942 {
1943     struct request_header __header;
1944     handle_t     handle;
1945     unsigned int flags;
1946 };
1947 struct get_thread_context_reply
1948 {
1949     struct reply_header __header;
1950     /* VARARG(context,context); */
1951 };
1952
1953
1954
1955 struct set_thread_context_request
1956 {
1957     struct request_header __header;
1958     handle_t     handle;
1959     unsigned int flags;
1960     /* VARARG(context,context); */
1961 };
1962 struct set_thread_context_reply
1963 {
1964     struct reply_header __header;
1965 };
1966
1967
1968
1969 struct get_selector_entry_request
1970 {
1971     struct request_header __header;
1972     handle_t      handle;
1973     int           entry;
1974 };
1975 struct get_selector_entry_reply
1976 {
1977     struct reply_header __header;
1978     unsigned int  base;
1979     unsigned int  limit;
1980     unsigned char flags;
1981 };
1982
1983
1984
1985 struct add_atom_request
1986 {
1987     struct request_header __header;
1988     int           local;
1989     /* VARARG(name,unicode_str); */
1990 };
1991 struct add_atom_reply
1992 {
1993     struct reply_header __header;
1994     atom_t        atom;
1995 };
1996
1997
1998
1999 struct delete_atom_request
2000 {
2001     struct request_header __header;
2002     atom_t        atom;
2003     int           local;
2004 };
2005 struct delete_atom_reply
2006 {
2007     struct reply_header __header;
2008 };
2009
2010
2011
2012 struct find_atom_request
2013 {
2014     struct request_header __header;
2015     int          local;
2016     /* VARARG(name,unicode_str); */
2017 };
2018 struct find_atom_reply
2019 {
2020     struct reply_header __header;
2021     atom_t       atom;
2022 };
2023
2024
2025
2026 struct get_atom_name_request
2027 {
2028     struct request_header __header;
2029     atom_t       atom;
2030     int          local;
2031 };
2032 struct get_atom_name_reply
2033 {
2034     struct reply_header __header;
2035     int          count;
2036     /* VARARG(name,unicode_str); */
2037 };
2038
2039
2040
2041 struct init_atom_table_request
2042 {
2043     struct request_header __header;
2044     int          entries;
2045 };
2046 struct init_atom_table_reply
2047 {
2048     struct reply_header __header;
2049 };
2050
2051
2052
2053 struct get_msg_queue_request
2054 {
2055     struct request_header __header;
2056 };
2057 struct get_msg_queue_reply
2058 {
2059     struct reply_header __header;
2060     handle_t     handle;
2061 };
2062
2063
2064
2065 struct set_queue_mask_request
2066 {
2067     struct request_header __header;
2068     unsigned int wake_mask;
2069     unsigned int changed_mask;
2070     int          skip_wait;
2071 };
2072 struct set_queue_mask_reply
2073 {
2074     struct reply_header __header;
2075     unsigned int wake_bits;
2076     unsigned int changed_bits;
2077 };
2078
2079
2080
2081 struct get_queue_status_request
2082 {
2083     struct request_header __header;
2084     int          clear;
2085 };
2086 struct get_queue_status_reply
2087 {
2088     struct reply_header __header;
2089     unsigned int wake_bits;
2090     unsigned int changed_bits;
2091 };
2092
2093
2094
2095 struct wait_input_idle_request
2096 {
2097     struct request_header __header;
2098     handle_t     handle;
2099     int          timeout;
2100 };
2101 struct wait_input_idle_reply
2102 {
2103     struct reply_header __header;
2104     handle_t     event;
2105 };
2106
2107
2108
2109 struct send_message_request
2110 {
2111     struct request_header __header;
2112     void*           id;
2113     int             type;
2114     user_handle_t   win;
2115     unsigned int    msg;
2116     unsigned int    wparam;
2117     unsigned int    lparam;
2118     int             x;
2119     int             y;
2120     unsigned int    time;
2121     unsigned int    info;
2122     int             timeout;
2123     /* VARARG(data,bytes); */
2124 };
2125 struct send_message_reply
2126 {
2127     struct reply_header __header;
2128 };
2129
2130 enum message_type
2131 {
2132     MSG_ASCII,
2133     MSG_UNICODE,
2134     MSG_NOTIFY,
2135     MSG_CALLBACK,
2136     MSG_OTHER_PROCESS,
2137     MSG_POSTED,
2138     MSG_HARDWARE_RAW,
2139     MSG_HARDWARE_COOKED
2140 };
2141
2142
2143
2144 struct get_message_request
2145 {
2146     struct request_header __header;
2147     int             flags;
2148     user_handle_t   get_win;
2149     unsigned int    get_first;
2150     unsigned int    get_last;
2151 };
2152 struct get_message_reply
2153 {
2154     struct reply_header __header;
2155     int             type;
2156     user_handle_t   win;
2157     unsigned int    msg;
2158     unsigned int    wparam;
2159     unsigned int    lparam;
2160     int             x;
2161     int             y;
2162     unsigned int    time;
2163     unsigned int    info;
2164     size_t          total;
2165     /* VARARG(data,bytes); */
2166 };
2167 #define GET_MSG_REMOVE      1
2168 #define GET_MSG_SENT_ONLY   2
2169 #define GET_MSG_REMOVE_LAST 4
2170
2171
2172 struct reply_message_request
2173 {
2174     struct request_header __header;
2175     unsigned int    result;
2176     int             remove;
2177     /* VARARG(data,bytes); */
2178 };
2179 struct reply_message_reply
2180 {
2181     struct reply_header __header;
2182 };
2183
2184
2185
2186 struct get_message_reply_request
2187 {
2188     struct request_header __header;
2189     int             cancel;
2190 };
2191 struct get_message_reply_reply
2192 {
2193     struct reply_header __header;
2194     unsigned int    result;
2195     /* VARARG(data,bytes); */
2196 };
2197
2198
2199
2200 struct set_win_timer_request
2201 {
2202     struct request_header __header;
2203     user_handle_t   win;
2204     unsigned int    msg;
2205     unsigned int    id;
2206     unsigned int    rate;
2207     unsigned int    lparam;
2208 };
2209 struct set_win_timer_reply
2210 {
2211     struct reply_header __header;
2212 };
2213
2214
2215
2216 struct kill_win_timer_request
2217 {
2218     struct request_header __header;
2219     user_handle_t   win;
2220     unsigned int    msg;
2221     unsigned int    id;
2222 };
2223 struct kill_win_timer_reply
2224 {
2225     struct reply_header __header;
2226 };
2227
2228
2229
2230 struct create_serial_request
2231 {
2232     struct request_header __header;
2233     unsigned int access;
2234     int          inherit;
2235     unsigned int attributes;
2236     unsigned int sharing;
2237     /* VARARG(name,string); */
2238 };
2239 struct create_serial_reply
2240 {
2241     struct reply_header __header;
2242     handle_t     handle;
2243 };
2244
2245
2246
2247 struct get_serial_info_request
2248 {
2249     struct request_header __header;
2250     handle_t     handle;
2251 };
2252 struct get_serial_info_reply
2253 {
2254     struct reply_header __header;
2255     unsigned int readinterval;
2256     unsigned int readconst;
2257     unsigned int readmult;
2258     unsigned int writeconst;
2259     unsigned int writemult;
2260     unsigned int eventmask;
2261     unsigned int commerror;
2262 };
2263
2264
2265
2266 struct set_serial_info_request
2267 {
2268     struct request_header __header;
2269     handle_t     handle;
2270     int          flags;
2271     unsigned int readinterval;
2272     unsigned int readconst;
2273     unsigned int readmult;
2274     unsigned int writeconst;
2275     unsigned int writemult;
2276     unsigned int eventmask;
2277     unsigned int commerror;
2278 };
2279 struct set_serial_info_reply
2280 {
2281     struct reply_header __header;
2282 };
2283 #define SERIALINFO_SET_TIMEOUTS  0x01
2284 #define SERIALINFO_SET_MASK      0x02
2285 #define SERIALINFO_SET_ERROR     0x04
2286
2287
2288
2289 struct register_async_request
2290 {
2291     struct request_header __header;
2292     handle_t     handle;
2293     int          type;
2294     void*        overlapped;
2295     int          count;
2296     unsigned int status;
2297 };
2298 struct register_async_reply
2299 {
2300     struct reply_header __header;
2301 };
2302 #define ASYNC_TYPE_NONE  0x00
2303 #define ASYNC_TYPE_READ  0x01
2304 #define ASYNC_TYPE_WRITE 0x02
2305 #define ASYNC_TYPE_WAIT  0x03
2306
2307
2308
2309 struct create_named_pipe_request
2310 {
2311     struct request_header __header;
2312     unsigned int   openmode;
2313     unsigned int   pipemode;
2314     unsigned int   maxinstances;
2315     unsigned int   outsize;
2316     unsigned int   insize;
2317     unsigned int   timeout;
2318     /* VARARG(name,unicode_str); */
2319 };
2320 struct create_named_pipe_reply
2321 {
2322     struct reply_header __header;
2323     handle_t       handle;
2324 };
2325
2326
2327
2328 struct open_named_pipe_request
2329 {
2330     struct request_header __header;
2331     unsigned int   access;
2332     /* VARARG(name,unicode_str); */
2333 };
2334 struct open_named_pipe_reply
2335 {
2336     struct reply_header __header;
2337     handle_t       handle;
2338 };
2339
2340
2341
2342 struct connect_named_pipe_request
2343 {
2344     struct request_header __header;
2345     handle_t       handle;
2346     void*          overlapped;
2347     void*          func;
2348 };
2349 struct connect_named_pipe_reply
2350 {
2351     struct reply_header __header;
2352 };
2353
2354
2355
2356 struct wait_named_pipe_request
2357 {
2358     struct request_header __header;
2359     unsigned int   timeout;
2360     void*          overlapped;
2361     void*          func;
2362     /* VARARG(name,unicode_str); */
2363 };
2364 struct wait_named_pipe_reply
2365 {
2366     struct reply_header __header;
2367 };
2368
2369
2370
2371 struct disconnect_named_pipe_request
2372 {
2373     struct request_header __header;
2374     handle_t       handle;
2375 };
2376 struct disconnect_named_pipe_reply
2377 {
2378     struct reply_header __header;
2379 };
2380
2381
2382 struct get_named_pipe_info_request
2383 {
2384     struct request_header __header;
2385     handle_t       handle;
2386 };
2387 struct get_named_pipe_info_reply
2388 {
2389     struct reply_header __header;
2390     unsigned int   flags;
2391     unsigned int   maxinstances;
2392     unsigned int   outsize;
2393     unsigned int   insize;
2394 };
2395
2396
2397 struct create_smb_request
2398 {
2399     struct request_header __header;
2400     int            fd;
2401     unsigned int   tree_id;
2402     unsigned int   user_id;
2403     unsigned int   file_id;
2404     unsigned int   dialect;
2405 };
2406 struct create_smb_reply
2407 {
2408     struct reply_header __header;
2409     handle_t       handle;
2410 };
2411
2412
2413 struct get_smb_info_request
2414 {
2415     struct request_header __header;
2416     handle_t       handle;
2417     unsigned int   flags;
2418     unsigned int   offset;
2419 };
2420 struct get_smb_info_reply
2421 {
2422     struct reply_header __header;
2423     unsigned int   tree_id;
2424     unsigned int   user_id;
2425     unsigned int   dialect;
2426     unsigned int   file_id;
2427     unsigned int   offset;
2428 };
2429 #define SMBINFO_SET_OFFSET    0x01
2430
2431
2432
2433 struct create_window_request
2434 {
2435     struct request_header __header;
2436     user_handle_t  parent;
2437     user_handle_t  owner;
2438     atom_t         atom;
2439 };
2440 struct create_window_reply
2441 {
2442     struct reply_header __header;
2443     user_handle_t  handle;
2444 };
2445
2446
2447
2448 struct link_window_request
2449 {
2450     struct request_header __header;
2451     user_handle_t  handle;
2452     user_handle_t  parent;
2453     user_handle_t  previous;
2454 };
2455 struct link_window_reply
2456 {
2457     struct reply_header __header;
2458     user_handle_t  full_parent;
2459 };
2460
2461
2462
2463 struct destroy_window_request
2464 {
2465     struct request_header __header;
2466     user_handle_t  handle;
2467 };
2468 struct destroy_window_reply
2469 {
2470     struct reply_header __header;
2471 };
2472
2473
2474
2475 struct set_window_owner_request
2476 {
2477     struct request_header __header;
2478     user_handle_t  handle;
2479     user_handle_t  owner;
2480 };
2481 struct set_window_owner_reply
2482 {
2483     struct reply_header __header;
2484     user_handle_t  full_owner;
2485 };
2486
2487
2488
2489 struct get_window_info_request
2490 {
2491     struct request_header __header;
2492     user_handle_t  handle;
2493 };
2494 struct get_window_info_reply
2495 {
2496     struct reply_header __header;
2497     user_handle_t  full_handle;
2498     void*          pid;
2499     void*          tid;
2500     atom_t         atom;
2501 };
2502
2503
2504
2505 struct set_window_info_request
2506 {
2507     struct request_header __header;
2508     user_handle_t  handle;
2509     unsigned int   flags;
2510     unsigned int   style;
2511     unsigned int   ex_style;
2512     unsigned int   id;
2513     void*          instance;
2514     void*          user_data;
2515 };
2516 struct set_window_info_reply
2517 {
2518     struct reply_header __header;
2519     unsigned int   old_style;
2520     unsigned int   old_ex_style;
2521     unsigned int   old_id;
2522     void*          old_instance;
2523     void*          old_user_data;
2524 };
2525 #define SET_WIN_STYLE     0x01
2526 #define SET_WIN_EXSTYLE   0x02
2527 #define SET_WIN_ID        0x04
2528 #define SET_WIN_INSTANCE  0x08
2529 #define SET_WIN_USERDATA  0x10
2530
2531
2532
2533 struct get_window_parents_request
2534 {
2535     struct request_header __header;
2536     user_handle_t  handle;
2537 };
2538 struct get_window_parents_reply
2539 {
2540     struct reply_header __header;
2541     int            count;
2542     /* VARARG(parents,user_handles); */
2543 };
2544
2545
2546
2547 struct get_window_children_request
2548 {
2549     struct request_header __header;
2550     user_handle_t  parent;
2551     atom_t         atom;
2552     void*          tid;
2553 };
2554 struct get_window_children_reply
2555 {
2556     struct reply_header __header;
2557     int            count;
2558     /* VARARG(children,user_handles); */
2559 };
2560
2561
2562
2563 struct get_window_tree_request
2564 {
2565     struct request_header __header;
2566     user_handle_t  handle;
2567 };
2568 struct get_window_tree_reply
2569 {
2570     struct reply_header __header;
2571     user_handle_t  parent;
2572     user_handle_t  owner;
2573     user_handle_t  next_sibling;
2574     user_handle_t  prev_sibling;
2575     user_handle_t  first_sibling;
2576     user_handle_t  last_sibling;
2577     user_handle_t  first_child;
2578     user_handle_t  last_child;
2579 };
2580
2581
2582 struct set_window_rectangles_request
2583 {
2584     struct request_header __header;
2585     user_handle_t  handle;
2586     rectangle_t    window;
2587     rectangle_t    client;
2588 };
2589 struct set_window_rectangles_reply
2590 {
2591     struct reply_header __header;
2592 };
2593
2594
2595
2596 struct get_window_rectangles_request
2597 {
2598     struct request_header __header;
2599     user_handle_t  handle;
2600 };
2601 struct get_window_rectangles_reply
2602 {
2603     struct reply_header __header;
2604     rectangle_t    window;
2605     rectangle_t    client;
2606 };
2607
2608
2609
2610 struct get_window_text_request
2611 {
2612     struct request_header __header;
2613     user_handle_t  handle;
2614 };
2615 struct get_window_text_reply
2616 {
2617     struct reply_header __header;
2618     /* VARARG(text,unicode_str); */
2619 };
2620
2621
2622
2623 struct set_window_text_request
2624 {
2625     struct request_header __header;
2626     user_handle_t  handle;
2627     /* VARARG(text,unicode_str); */
2628 };
2629 struct set_window_text_reply
2630 {
2631     struct reply_header __header;
2632 };
2633
2634
2635
2636 struct inc_window_paint_count_request
2637 {
2638     struct request_header __header;
2639     user_handle_t  handle;
2640     int             incr;
2641 };
2642 struct inc_window_paint_count_reply
2643 {
2644     struct reply_header __header;
2645 };
2646
2647
2648
2649 struct get_windows_offset_request
2650 {
2651     struct request_header __header;
2652     user_handle_t  from;
2653     user_handle_t  to;
2654 };
2655 struct get_windows_offset_reply
2656 {
2657     struct reply_header __header;
2658     int            x;
2659     int            y;
2660 };
2661
2662
2663
2664 struct set_window_property_request
2665 {
2666     struct request_header __header;
2667     user_handle_t  window;
2668     atom_t         atom;
2669     int            string;
2670     handle_t       handle;
2671 };
2672 struct set_window_property_reply
2673 {
2674     struct reply_header __header;
2675 };
2676
2677
2678
2679 struct remove_window_property_request
2680 {
2681     struct request_header __header;
2682     user_handle_t  window;
2683     atom_t         atom;
2684 };
2685 struct remove_window_property_reply
2686 {
2687     struct reply_header __header;
2688     handle_t       handle;
2689 };
2690
2691
2692
2693 struct get_window_property_request
2694 {
2695     struct request_header __header;
2696     user_handle_t  window;
2697     atom_t         atom;
2698 };
2699 struct get_window_property_reply
2700 {
2701     struct reply_header __header;
2702     handle_t       handle;
2703 };
2704
2705
2706
2707 struct get_window_properties_request
2708 {
2709     struct request_header __header;
2710     user_handle_t  window;
2711 };
2712 struct get_window_properties_reply
2713 {
2714     struct reply_header __header;
2715     int            total;
2716     /* VARARG(props,properties); */
2717 };
2718
2719
2720 enum request
2721 {
2722     REQ_new_process,
2723     REQ_get_new_process_info,
2724     REQ_new_thread,
2725     REQ_boot_done,
2726     REQ_init_process,
2727     REQ_get_startup_info,
2728     REQ_init_process_done,
2729     REQ_init_thread,
2730     REQ_terminate_process,
2731     REQ_terminate_thread,
2732     REQ_get_process_info,
2733     REQ_set_process_info,
2734     REQ_get_thread_info,
2735     REQ_set_thread_info,
2736     REQ_suspend_thread,
2737     REQ_resume_thread,
2738     REQ_load_dll,
2739     REQ_unload_dll,
2740     REQ_queue_apc,
2741     REQ_get_apc,
2742     REQ_close_handle,
2743     REQ_set_handle_info,
2744     REQ_dup_handle,
2745     REQ_open_process,
2746     REQ_open_thread,
2747     REQ_select,
2748     REQ_create_event,
2749     REQ_event_op,
2750     REQ_open_event,
2751     REQ_create_mutex,
2752     REQ_release_mutex,
2753     REQ_open_mutex,
2754     REQ_create_semaphore,
2755     REQ_release_semaphore,
2756     REQ_open_semaphore,
2757     REQ_create_file,
2758     REQ_alloc_file_handle,
2759     REQ_get_handle_fd,
2760     REQ_set_file_pointer,
2761     REQ_truncate_file,
2762     REQ_set_file_time,
2763     REQ_flush_file,
2764     REQ_get_file_info,
2765     REQ_lock_file,
2766     REQ_unlock_file,
2767     REQ_create_pipe,
2768     REQ_create_socket,
2769     REQ_accept_socket,
2770     REQ_set_socket_event,
2771     REQ_get_socket_event,
2772     REQ_enable_socket_event,
2773     REQ_set_socket_deferred,
2774     REQ_alloc_console,
2775     REQ_free_console,
2776     REQ_get_console_renderer_events,
2777     REQ_open_console,
2778     REQ_get_console_mode,
2779     REQ_set_console_mode,
2780     REQ_set_console_input_info,
2781     REQ_get_console_input_info,
2782     REQ_append_console_input_history,
2783     REQ_get_console_input_history,
2784     REQ_create_console_output,
2785     REQ_set_console_output_info,
2786     REQ_get_console_output_info,
2787     REQ_write_console_input,
2788     REQ_read_console_input,
2789     REQ_write_console_output,
2790     REQ_fill_console_output,
2791     REQ_read_console_output,
2792     REQ_move_console_output,
2793     REQ_create_change_notification,
2794     REQ_create_mapping,
2795     REQ_open_mapping,
2796     REQ_get_mapping_info,
2797     REQ_create_device,
2798     REQ_create_snapshot,
2799     REQ_next_process,
2800     REQ_next_thread,
2801     REQ_next_module,
2802     REQ_wait_debug_event,
2803     REQ_queue_exception_event,
2804     REQ_get_exception_status,
2805     REQ_output_debug_string,
2806     REQ_continue_debug_event,
2807     REQ_debug_process,
2808     REQ_debug_break,
2809     REQ_set_debugger_kill_on_exit,
2810     REQ_read_process_memory,
2811     REQ_write_process_memory,
2812     REQ_create_key,
2813     REQ_open_key,
2814     REQ_delete_key,
2815     REQ_enum_key,
2816     REQ_set_key_value,
2817     REQ_get_key_value,
2818     REQ_enum_key_value,
2819     REQ_delete_key_value,
2820     REQ_load_registry,
2821     REQ_save_registry,
2822     REQ_save_registry_atexit,
2823     REQ_set_registry_levels,
2824     REQ_create_timer,
2825     REQ_open_timer,
2826     REQ_set_timer,
2827     REQ_cancel_timer,
2828     REQ_get_thread_context,
2829     REQ_set_thread_context,
2830     REQ_get_selector_entry,
2831     REQ_add_atom,
2832     REQ_delete_atom,
2833     REQ_find_atom,
2834     REQ_get_atom_name,
2835     REQ_init_atom_table,
2836     REQ_get_msg_queue,
2837     REQ_set_queue_mask,
2838     REQ_get_queue_status,
2839     REQ_wait_input_idle,
2840     REQ_send_message,
2841     REQ_get_message,
2842     REQ_reply_message,
2843     REQ_get_message_reply,
2844     REQ_set_win_timer,
2845     REQ_kill_win_timer,
2846     REQ_create_serial,
2847     REQ_get_serial_info,
2848     REQ_set_serial_info,
2849     REQ_register_async,
2850     REQ_create_named_pipe,
2851     REQ_open_named_pipe,
2852     REQ_connect_named_pipe,
2853     REQ_wait_named_pipe,
2854     REQ_disconnect_named_pipe,
2855     REQ_get_named_pipe_info,
2856     REQ_create_smb,
2857     REQ_get_smb_info,
2858     REQ_create_window,
2859     REQ_link_window,
2860     REQ_destroy_window,
2861     REQ_set_window_owner,
2862     REQ_get_window_info,
2863     REQ_set_window_info,
2864     REQ_get_window_parents,
2865     REQ_get_window_children,
2866     REQ_get_window_tree,
2867     REQ_set_window_rectangles,
2868     REQ_get_window_rectangles,
2869     REQ_get_window_text,
2870     REQ_set_window_text,
2871     REQ_inc_window_paint_count,
2872     REQ_get_windows_offset,
2873     REQ_set_window_property,
2874     REQ_remove_window_property,
2875     REQ_get_window_property,
2876     REQ_get_window_properties,
2877     REQ_NB_REQUESTS
2878 };
2879
2880 union generic_request
2881 {
2882     struct request_max_size max_size;
2883     struct request_header request_header;
2884     struct new_process_request new_process_request;
2885     struct get_new_process_info_request get_new_process_info_request;
2886     struct new_thread_request new_thread_request;
2887     struct boot_done_request boot_done_request;
2888     struct init_process_request init_process_request;
2889     struct get_startup_info_request get_startup_info_request;
2890     struct init_process_done_request init_process_done_request;
2891     struct init_thread_request init_thread_request;
2892     struct terminate_process_request terminate_process_request;
2893     struct terminate_thread_request terminate_thread_request;
2894     struct get_process_info_request get_process_info_request;
2895     struct set_process_info_request set_process_info_request;
2896     struct get_thread_info_request get_thread_info_request;
2897     struct set_thread_info_request set_thread_info_request;
2898     struct suspend_thread_request suspend_thread_request;
2899     struct resume_thread_request resume_thread_request;
2900     struct load_dll_request load_dll_request;
2901     struct unload_dll_request unload_dll_request;
2902     struct queue_apc_request queue_apc_request;
2903     struct get_apc_request get_apc_request;
2904     struct close_handle_request close_handle_request;
2905     struct set_handle_info_request set_handle_info_request;
2906     struct dup_handle_request dup_handle_request;
2907     struct open_process_request open_process_request;
2908     struct open_thread_request open_thread_request;
2909     struct select_request select_request;
2910     struct create_event_request create_event_request;
2911     struct event_op_request event_op_request;
2912     struct open_event_request open_event_request;
2913     struct create_mutex_request create_mutex_request;
2914     struct release_mutex_request release_mutex_request;
2915     struct open_mutex_request open_mutex_request;
2916     struct create_semaphore_request create_semaphore_request;
2917     struct release_semaphore_request release_semaphore_request;
2918     struct open_semaphore_request open_semaphore_request;
2919     struct create_file_request create_file_request;
2920     struct alloc_file_handle_request alloc_file_handle_request;
2921     struct get_handle_fd_request get_handle_fd_request;
2922     struct set_file_pointer_request set_file_pointer_request;
2923     struct truncate_file_request truncate_file_request;
2924     struct set_file_time_request set_file_time_request;
2925     struct flush_file_request flush_file_request;
2926     struct get_file_info_request get_file_info_request;
2927     struct lock_file_request lock_file_request;
2928     struct unlock_file_request unlock_file_request;
2929     struct create_pipe_request create_pipe_request;
2930     struct create_socket_request create_socket_request;
2931     struct accept_socket_request accept_socket_request;
2932     struct set_socket_event_request set_socket_event_request;
2933     struct get_socket_event_request get_socket_event_request;
2934     struct enable_socket_event_request enable_socket_event_request;
2935     struct set_socket_deferred_request set_socket_deferred_request;
2936     struct alloc_console_request alloc_console_request;
2937     struct free_console_request free_console_request;
2938     struct get_console_renderer_events_request get_console_renderer_events_request;
2939     struct open_console_request open_console_request;
2940     struct get_console_mode_request get_console_mode_request;
2941     struct set_console_mode_request set_console_mode_request;
2942     struct set_console_input_info_request set_console_input_info_request;
2943     struct get_console_input_info_request get_console_input_info_request;
2944     struct append_console_input_history_request append_console_input_history_request;
2945     struct get_console_input_history_request get_console_input_history_request;
2946     struct create_console_output_request create_console_output_request;
2947     struct set_console_output_info_request set_console_output_info_request;
2948     struct get_console_output_info_request get_console_output_info_request;
2949     struct write_console_input_request write_console_input_request;
2950     struct read_console_input_request read_console_input_request;
2951     struct write_console_output_request write_console_output_request;
2952     struct fill_console_output_request fill_console_output_request;
2953     struct read_console_output_request read_console_output_request;
2954     struct move_console_output_request move_console_output_request;
2955     struct create_change_notification_request create_change_notification_request;
2956     struct create_mapping_request create_mapping_request;
2957     struct open_mapping_request open_mapping_request;
2958     struct get_mapping_info_request get_mapping_info_request;
2959     struct create_device_request create_device_request;
2960     struct create_snapshot_request create_snapshot_request;
2961     struct next_process_request next_process_request;
2962     struct next_thread_request next_thread_request;
2963     struct next_module_request next_module_request;
2964     struct wait_debug_event_request wait_debug_event_request;
2965     struct queue_exception_event_request queue_exception_event_request;
2966     struct get_exception_status_request get_exception_status_request;
2967     struct output_debug_string_request output_debug_string_request;
2968     struct continue_debug_event_request continue_debug_event_request;
2969     struct debug_process_request debug_process_request;
2970     struct debug_break_request debug_break_request;
2971     struct set_debugger_kill_on_exit_request set_debugger_kill_on_exit_request;
2972     struct read_process_memory_request read_process_memory_request;
2973     struct write_process_memory_request write_process_memory_request;
2974     struct create_key_request create_key_request;
2975     struct open_key_request open_key_request;
2976     struct delete_key_request delete_key_request;
2977     struct enum_key_request enum_key_request;
2978     struct set_key_value_request set_key_value_request;
2979     struct get_key_value_request get_key_value_request;
2980     struct enum_key_value_request enum_key_value_request;
2981     struct delete_key_value_request delete_key_value_request;
2982     struct load_registry_request load_registry_request;
2983     struct save_registry_request save_registry_request;
2984     struct save_registry_atexit_request save_registry_atexit_request;
2985     struct set_registry_levels_request set_registry_levels_request;
2986     struct create_timer_request create_timer_request;
2987     struct open_timer_request open_timer_request;
2988     struct set_timer_request set_timer_request;
2989     struct cancel_timer_request cancel_timer_request;
2990     struct get_thread_context_request get_thread_context_request;
2991     struct set_thread_context_request set_thread_context_request;
2992     struct get_selector_entry_request get_selector_entry_request;
2993     struct add_atom_request add_atom_request;
2994     struct delete_atom_request delete_atom_request;
2995     struct find_atom_request find_atom_request;
2996     struct get_atom_name_request get_atom_name_request;
2997     struct init_atom_table_request init_atom_table_request;
2998     struct get_msg_queue_request get_msg_queue_request;
2999     struct set_queue_mask_request set_queue_mask_request;
3000     struct get_queue_status_request get_queue_status_request;
3001     struct wait_input_idle_request wait_input_idle_request;
3002     struct send_message_request send_message_request;
3003     struct get_message_request get_message_request;
3004     struct reply_message_request reply_message_request;
3005     struct get_message_reply_request get_message_reply_request;
3006     struct set_win_timer_request set_win_timer_request;
3007     struct kill_win_timer_request kill_win_timer_request;
3008     struct create_serial_request create_serial_request;
3009     struct get_serial_info_request get_serial_info_request;
3010     struct set_serial_info_request set_serial_info_request;
3011     struct register_async_request register_async_request;
3012     struct create_named_pipe_request create_named_pipe_request;
3013     struct open_named_pipe_request open_named_pipe_request;
3014     struct connect_named_pipe_request connect_named_pipe_request;
3015     struct wait_named_pipe_request wait_named_pipe_request;
3016     struct disconnect_named_pipe_request disconnect_named_pipe_request;
3017     struct get_named_pipe_info_request get_named_pipe_info_request;
3018     struct create_smb_request create_smb_request;
3019     struct get_smb_info_request get_smb_info_request;
3020     struct create_window_request create_window_request;
3021     struct link_window_request link_window_request;
3022     struct destroy_window_request destroy_window_request;
3023     struct set_window_owner_request set_window_owner_request;
3024     struct get_window_info_request get_window_info_request;
3025     struct set_window_info_request set_window_info_request;
3026     struct get_window_parents_request get_window_parents_request;
3027     struct get_window_children_request get_window_children_request;
3028     struct get_window_tree_request get_window_tree_request;
3029     struct set_window_rectangles_request set_window_rectangles_request;
3030     struct get_window_rectangles_request get_window_rectangles_request;
3031     struct get_window_text_request get_window_text_request;
3032     struct set_window_text_request set_window_text_request;
3033     struct inc_window_paint_count_request inc_window_paint_count_request;
3034     struct get_windows_offset_request get_windows_offset_request;
3035     struct set_window_property_request set_window_property_request;
3036     struct remove_window_property_request remove_window_property_request;
3037     struct get_window_property_request get_window_property_request;
3038     struct get_window_properties_request get_window_properties_request;
3039 };
3040 union generic_reply
3041 {
3042     struct request_max_size max_size;
3043     struct reply_header reply_header;
3044     struct new_process_reply new_process_reply;
3045     struct get_new_process_info_reply get_new_process_info_reply;
3046     struct new_thread_reply new_thread_reply;
3047     struct boot_done_reply boot_done_reply;
3048     struct init_process_reply init_process_reply;
3049     struct get_startup_info_reply get_startup_info_reply;
3050     struct init_process_done_reply init_process_done_reply;
3051     struct init_thread_reply init_thread_reply;
3052     struct terminate_process_reply terminate_process_reply;
3053     struct terminate_thread_reply terminate_thread_reply;
3054     struct get_process_info_reply get_process_info_reply;
3055     struct set_process_info_reply set_process_info_reply;
3056     struct get_thread_info_reply get_thread_info_reply;
3057     struct set_thread_info_reply set_thread_info_reply;
3058     struct suspend_thread_reply suspend_thread_reply;
3059     struct resume_thread_reply resume_thread_reply;
3060     struct load_dll_reply load_dll_reply;
3061     struct unload_dll_reply unload_dll_reply;
3062     struct queue_apc_reply queue_apc_reply;
3063     struct get_apc_reply get_apc_reply;
3064     struct close_handle_reply close_handle_reply;
3065     struct set_handle_info_reply set_handle_info_reply;
3066     struct dup_handle_reply dup_handle_reply;
3067     struct open_process_reply open_process_reply;
3068     struct open_thread_reply open_thread_reply;
3069     struct select_reply select_reply;
3070     struct create_event_reply create_event_reply;
3071     struct event_op_reply event_op_reply;
3072     struct open_event_reply open_event_reply;
3073     struct create_mutex_reply create_mutex_reply;
3074     struct release_mutex_reply release_mutex_reply;
3075     struct open_mutex_reply open_mutex_reply;
3076     struct create_semaphore_reply create_semaphore_reply;
3077     struct release_semaphore_reply release_semaphore_reply;
3078     struct open_semaphore_reply open_semaphore_reply;
3079     struct create_file_reply create_file_reply;
3080     struct alloc_file_handle_reply alloc_file_handle_reply;
3081     struct get_handle_fd_reply get_handle_fd_reply;
3082     struct set_file_pointer_reply set_file_pointer_reply;
3083     struct truncate_file_reply truncate_file_reply;
3084     struct set_file_time_reply set_file_time_reply;
3085     struct flush_file_reply flush_file_reply;
3086     struct get_file_info_reply get_file_info_reply;
3087     struct lock_file_reply lock_file_reply;
3088     struct unlock_file_reply unlock_file_reply;
3089     struct create_pipe_reply create_pipe_reply;
3090     struct create_socket_reply create_socket_reply;
3091     struct accept_socket_reply accept_socket_reply;
3092     struct set_socket_event_reply set_socket_event_reply;
3093     struct get_socket_event_reply get_socket_event_reply;
3094     struct enable_socket_event_reply enable_socket_event_reply;
3095     struct set_socket_deferred_reply set_socket_deferred_reply;
3096     struct alloc_console_reply alloc_console_reply;
3097     struct free_console_reply free_console_reply;
3098     struct get_console_renderer_events_reply get_console_renderer_events_reply;
3099     struct open_console_reply open_console_reply;
3100     struct get_console_mode_reply get_console_mode_reply;
3101     struct set_console_mode_reply set_console_mode_reply;
3102     struct set_console_input_info_reply set_console_input_info_reply;
3103     struct get_console_input_info_reply get_console_input_info_reply;
3104     struct append_console_input_history_reply append_console_input_history_reply;
3105     struct get_console_input_history_reply get_console_input_history_reply;
3106     struct create_console_output_reply create_console_output_reply;
3107     struct set_console_output_info_reply set_console_output_info_reply;
3108     struct get_console_output_info_reply get_console_output_info_reply;
3109     struct write_console_input_reply write_console_input_reply;
3110     struct read_console_input_reply read_console_input_reply;
3111     struct write_console_output_reply write_console_output_reply;
3112     struct fill_console_output_reply fill_console_output_reply;
3113     struct read_console_output_reply read_console_output_reply;
3114     struct move_console_output_reply move_console_output_reply;
3115     struct create_change_notification_reply create_change_notification_reply;
3116     struct create_mapping_reply create_mapping_reply;
3117     struct open_mapping_reply open_mapping_reply;
3118     struct get_mapping_info_reply get_mapping_info_reply;
3119     struct create_device_reply create_device_reply;
3120     struct create_snapshot_reply create_snapshot_reply;
3121     struct next_process_reply next_process_reply;
3122     struct next_thread_reply next_thread_reply;
3123     struct next_module_reply next_module_reply;
3124     struct wait_debug_event_reply wait_debug_event_reply;
3125     struct queue_exception_event_reply queue_exception_event_reply;
3126     struct get_exception_status_reply get_exception_status_reply;
3127     struct output_debug_string_reply output_debug_string_reply;
3128     struct continue_debug_event_reply continue_debug_event_reply;
3129     struct debug_process_reply debug_process_reply;
3130     struct debug_break_reply debug_break_reply;
3131     struct set_debugger_kill_on_exit_reply set_debugger_kill_on_exit_reply;
3132     struct read_process_memory_reply read_process_memory_reply;
3133     struct write_process_memory_reply write_process_memory_reply;
3134     struct create_key_reply create_key_reply;
3135     struct open_key_reply open_key_reply;
3136     struct delete_key_reply delete_key_reply;
3137     struct enum_key_reply enum_key_reply;
3138     struct set_key_value_reply set_key_value_reply;
3139     struct get_key_value_reply get_key_value_reply;
3140     struct enum_key_value_reply enum_key_value_reply;
3141     struct delete_key_value_reply delete_key_value_reply;
3142     struct load_registry_reply load_registry_reply;
3143     struct save_registry_reply save_registry_reply;
3144     struct save_registry_atexit_reply save_registry_atexit_reply;
3145     struct set_registry_levels_reply set_registry_levels_reply;
3146     struct create_timer_reply create_timer_reply;
3147     struct open_timer_reply open_timer_reply;
3148     struct set_timer_reply set_timer_reply;
3149     struct cancel_timer_reply cancel_timer_reply;
3150     struct get_thread_context_reply get_thread_context_reply;
3151     struct set_thread_context_reply set_thread_context_reply;
3152     struct get_selector_entry_reply get_selector_entry_reply;
3153     struct add_atom_reply add_atom_reply;
3154     struct delete_atom_reply delete_atom_reply;
3155     struct find_atom_reply find_atom_reply;
3156     struct get_atom_name_reply get_atom_name_reply;
3157     struct init_atom_table_reply init_atom_table_reply;
3158     struct get_msg_queue_reply get_msg_queue_reply;
3159     struct set_queue_mask_reply set_queue_mask_reply;
3160     struct get_queue_status_reply get_queue_status_reply;
3161     struct wait_input_idle_reply wait_input_idle_reply;
3162     struct send_message_reply send_message_reply;
3163     struct get_message_reply get_message_reply;
3164     struct reply_message_reply reply_message_reply;
3165     struct get_message_reply_reply get_message_reply_reply;
3166     struct set_win_timer_reply set_win_timer_reply;
3167     struct kill_win_timer_reply kill_win_timer_reply;
3168     struct create_serial_reply create_serial_reply;
3169     struct get_serial_info_reply get_serial_info_reply;
3170     struct set_serial_info_reply set_serial_info_reply;
3171     struct register_async_reply register_async_reply;
3172     struct create_named_pipe_reply create_named_pipe_reply;
3173     struct open_named_pipe_reply open_named_pipe_reply;
3174     struct connect_named_pipe_reply connect_named_pipe_reply;
3175     struct wait_named_pipe_reply wait_named_pipe_reply;
3176     struct disconnect_named_pipe_reply disconnect_named_pipe_reply;
3177     struct get_named_pipe_info_reply get_named_pipe_info_reply;
3178     struct create_smb_reply create_smb_reply;
3179     struct get_smb_info_reply get_smb_info_reply;
3180     struct create_window_reply create_window_reply;
3181     struct link_window_reply link_window_reply;
3182     struct destroy_window_reply destroy_window_reply;
3183     struct set_window_owner_reply set_window_owner_reply;
3184     struct get_window_info_reply get_window_info_reply;
3185     struct set_window_info_reply set_window_info_reply;
3186     struct get_window_parents_reply get_window_parents_reply;
3187     struct get_window_children_reply get_window_children_reply;
3188     struct get_window_tree_reply get_window_tree_reply;
3189     struct set_window_rectangles_reply set_window_rectangles_reply;
3190     struct get_window_rectangles_reply get_window_rectangles_reply;
3191     struct get_window_text_reply get_window_text_reply;
3192     struct set_window_text_reply set_window_text_reply;
3193     struct inc_window_paint_count_reply inc_window_paint_count_reply;
3194     struct get_windows_offset_reply get_windows_offset_reply;
3195     struct set_window_property_reply set_window_property_reply;
3196     struct remove_window_property_reply remove_window_property_reply;
3197     struct get_window_property_reply get_window_property_reply;
3198     struct get_window_properties_reply get_window_properties_reply;
3199 };
3200
3201 #define SERVER_PROTOCOL_VERSION 79
3202
3203 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */