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

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