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     /* VARARG(title,unicode_str); */
1371 };
1372 struct set_console_input_info_reply
1373 {
1374     struct reply_header __header;
1375 };
1376 #define SET_CONSOLE_INPUT_INFO_ACTIVE_SB        0x01
1377 #define SET_CONSOLE_INPUT_INFO_TITLE            0x02
1378 #define SET_CONSOLE_INPUT_INFO_HISTORY_MODE     0x04
1379 #define SET_CONSOLE_INPUT_INFO_HISTORY_SIZE     0x08
1380 #define SET_CONSOLE_INPUT_INFO_EDITION_MODE     0x10
1381 #define SET_CONSOLE_INPUT_INFO_INPUT_CODEPAGE   0x20
1382 #define SET_CONSOLE_INPUT_INFO_OUTPUT_CODEPAGE  0x40
1383
1384
1385
1386 struct get_console_input_info_request
1387 {
1388     struct request_header __header;
1389     obj_handle_t handle;
1390 };
1391 struct get_console_input_info_reply
1392 {
1393     struct reply_header __header;
1394     int          history_mode;
1395     int          history_size;
1396     int          history_index;
1397     int          edition_mode;
1398     int          input_cp;
1399     int          output_cp;
1400     /* VARARG(title,unicode_str); */
1401 };
1402
1403
1404
1405 struct append_console_input_history_request
1406 {
1407     struct request_header __header;
1408     obj_handle_t handle;
1409     /* VARARG(line,unicode_str); */
1410 };
1411 struct append_console_input_history_reply
1412 {
1413     struct reply_header __header;
1414 };
1415
1416
1417
1418 struct get_console_input_history_request
1419 {
1420     struct request_header __header;
1421     obj_handle_t handle;
1422     int          index;
1423 };
1424 struct get_console_input_history_reply
1425 {
1426     struct reply_header __header;
1427     int          total;
1428     /* VARARG(line,unicode_str); */
1429 };
1430
1431
1432
1433 struct create_console_output_request
1434 {
1435     struct request_header __header;
1436     obj_handle_t handle_in;
1437     unsigned int access;
1438     unsigned int attributes;
1439     unsigned int share;
1440 };
1441 struct create_console_output_reply
1442 {
1443     struct reply_header __header;
1444     obj_handle_t handle_out;
1445 };
1446
1447
1448
1449 struct set_console_output_info_request
1450 {
1451     struct request_header __header;
1452     obj_handle_t handle;
1453     int          mask;
1454     short int    cursor_size;
1455     short int    cursor_visible;
1456     short int    cursor_x;
1457     short int    cursor_y;
1458     short int    width;
1459     short int    height;
1460     short int    attr;
1461     short int    win_left;
1462     short int    win_top;
1463     short int    win_right;
1464     short int    win_bottom;
1465     short int    max_width;
1466     short int    max_height;
1467 };
1468 struct set_console_output_info_reply
1469 {
1470     struct reply_header __header;
1471 };
1472 #define SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM     0x01
1473 #define SET_CONSOLE_OUTPUT_INFO_CURSOR_POS      0x02
1474 #define SET_CONSOLE_OUTPUT_INFO_SIZE            0x04
1475 #define SET_CONSOLE_OUTPUT_INFO_ATTR            0x08
1476 #define SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW  0x10
1477 #define SET_CONSOLE_OUTPUT_INFO_MAX_SIZE        0x20
1478
1479
1480
1481 struct get_console_output_info_request
1482 {
1483     struct request_header __header;
1484     obj_handle_t handle;
1485 };
1486 struct get_console_output_info_reply
1487 {
1488     struct reply_header __header;
1489     short int    cursor_size;
1490     short int    cursor_visible;
1491     short int    cursor_x;
1492     short int    cursor_y;
1493     short int    width;
1494     short int    height;
1495     short int    attr;
1496     short int    win_left;
1497     short int    win_top;
1498     short int    win_right;
1499     short int    win_bottom;
1500     short int    max_width;
1501     short int    max_height;
1502 };
1503
1504
1505 struct write_console_input_request
1506 {
1507     struct request_header __header;
1508     obj_handle_t handle;
1509     /* VARARG(rec,input_records); */
1510 };
1511 struct write_console_input_reply
1512 {
1513     struct reply_header __header;
1514     int          written;
1515 };
1516
1517
1518
1519 struct read_console_input_request
1520 {
1521     struct request_header __header;
1522     obj_handle_t handle;
1523     int          flush;
1524 };
1525 struct read_console_input_reply
1526 {
1527     struct reply_header __header;
1528     int          read;
1529     /* VARARG(rec,input_records); */
1530 };
1531
1532
1533
1534 struct write_console_output_request
1535 {
1536     struct request_header __header;
1537     obj_handle_t handle;
1538     int          x;
1539     int          y;
1540     int          mode;
1541     int          wrap;
1542     /* VARARG(data,bytes); */
1543 };
1544 struct write_console_output_reply
1545 {
1546     struct reply_header __header;
1547     int          written;
1548     int          width;
1549     int          height;
1550 };
1551 enum char_info_mode
1552 {
1553     CHAR_INFO_MODE_TEXT,
1554     CHAR_INFO_MODE_ATTR,
1555     CHAR_INFO_MODE_TEXTATTR,
1556     CHAR_INFO_MODE_TEXTSTDATTR
1557 };
1558
1559
1560
1561 struct fill_console_output_request
1562 {
1563     struct request_header __header;
1564     obj_handle_t handle;
1565     int          x;
1566     int          y;
1567     int          mode;
1568     int          count;
1569     int          wrap;
1570     char_info_t  data;
1571 };
1572 struct fill_console_output_reply
1573 {
1574     struct reply_header __header;
1575     int          written;
1576 };
1577
1578
1579
1580 struct read_console_output_request
1581 {
1582     struct request_header __header;
1583     obj_handle_t handle;
1584     int          x;
1585     int          y;
1586     int          mode;
1587     int          wrap;
1588 };
1589 struct read_console_output_reply
1590 {
1591     struct reply_header __header;
1592     int          width;
1593     int          height;
1594     /* VARARG(data,bytes); */
1595 };
1596
1597
1598
1599 struct move_console_output_request
1600 {
1601     struct request_header __header;
1602     obj_handle_t handle;
1603     short int    x_src;
1604     short int    y_src;
1605     short int    x_dst;
1606     short int    y_dst;
1607     short int    w;
1608     short int    h;
1609 };
1610 struct move_console_output_reply
1611 {
1612     struct reply_header __header;
1613 };
1614
1615
1616
1617 struct send_console_signal_request
1618 {
1619     struct request_header __header;
1620     int          signal;
1621     process_id_t group_id;
1622 };
1623 struct send_console_signal_reply
1624 {
1625     struct reply_header __header;
1626 };
1627
1628
1629
1630 struct read_directory_changes_request
1631 {
1632     struct request_header __header;
1633     unsigned int filter;
1634     obj_handle_t handle;
1635     int          subtree;
1636     int          want_data;
1637     async_data_t async;
1638 };
1639 struct read_directory_changes_reply
1640 {
1641     struct reply_header __header;
1642 };
1643
1644
1645 struct read_change_request
1646 {
1647     struct request_header __header;
1648     obj_handle_t handle;
1649 };
1650 struct read_change_reply
1651 {
1652     struct reply_header __header;
1653     int          action;
1654     /* VARARG(name,string); */
1655 };
1656
1657
1658
1659 struct create_mapping_request
1660 {
1661     struct request_header __header;
1662     unsigned int access;
1663     unsigned int attributes;
1664     obj_handle_t rootdir;
1665     int          size_high;
1666     int          size_low;
1667     int          protect;
1668     obj_handle_t file_handle;
1669     /* VARARG(name,unicode_str); */
1670 };
1671 struct create_mapping_reply
1672 {
1673     struct reply_header __header;
1674     obj_handle_t handle;
1675 };
1676
1677 #define VPROT_READ       0x01
1678 #define VPROT_WRITE      0x02
1679 #define VPROT_EXEC       0x04
1680 #define VPROT_WRITECOPY  0x08
1681 #define VPROT_GUARD      0x10
1682 #define VPROT_NOCACHE    0x20
1683 #define VPROT_COMMITTED  0x40
1684 #define VPROT_IMAGE      0x80
1685
1686
1687
1688 struct open_mapping_request
1689 {
1690     struct request_header __header;
1691     unsigned int access;
1692     unsigned int attributes;
1693     obj_handle_t rootdir;
1694     /* VARARG(name,unicode_str); */
1695 };
1696 struct open_mapping_reply
1697 {
1698     struct reply_header __header;
1699     obj_handle_t handle;
1700 };
1701
1702
1703
1704 struct get_mapping_info_request
1705 {
1706     struct request_header __header;
1707     obj_handle_t handle;
1708 };
1709 struct get_mapping_info_reply
1710 {
1711     struct reply_header __header;
1712     int          size_high;
1713     int          size_low;
1714     int          protect;
1715     int          header_size;
1716     void*        base;
1717     obj_handle_t mapping;
1718     obj_handle_t shared_file;
1719     int          shared_size;
1720 };
1721
1722
1723 #define SNAP_HEAPLIST   0x00000001
1724 #define SNAP_PROCESS    0x00000002
1725 #define SNAP_THREAD     0x00000004
1726 #define SNAP_MODULE     0x00000008
1727
1728 struct create_snapshot_request
1729 {
1730     struct request_header __header;
1731     unsigned int attributes;
1732     int          flags;
1733     process_id_t pid;
1734 };
1735 struct create_snapshot_reply
1736 {
1737     struct reply_header __header;
1738     obj_handle_t handle;
1739 };
1740
1741
1742
1743 struct next_process_request
1744 {
1745     struct request_header __header;
1746     obj_handle_t handle;
1747     int          reset;
1748 };
1749 struct next_process_reply
1750 {
1751     struct reply_header __header;
1752     int          count;
1753     process_id_t pid;
1754     process_id_t ppid;
1755     void*        heap;
1756     void*        module;
1757     int          threads;
1758     int          priority;
1759     int          handles;
1760     /* VARARG(filename,unicode_str); */
1761 };
1762
1763
1764
1765 struct next_thread_request
1766 {
1767     struct request_header __header;
1768     obj_handle_t handle;
1769     int          reset;
1770 };
1771 struct next_thread_reply
1772 {
1773     struct reply_header __header;
1774     int          count;
1775     process_id_t pid;
1776     thread_id_t  tid;
1777     int          base_pri;
1778     int          delta_pri;
1779 };
1780
1781
1782
1783 struct next_module_request
1784 {
1785     struct request_header __header;
1786     obj_handle_t handle;
1787     int          reset;
1788 };
1789 struct next_module_reply
1790 {
1791     struct reply_header __header;
1792     process_id_t pid;
1793     void*        base;
1794     size_t       size;
1795     /* VARARG(filename,unicode_str); */
1796 };
1797
1798
1799
1800 struct wait_debug_event_request
1801 {
1802     struct request_header __header;
1803     int           get_handle;
1804 };
1805 struct wait_debug_event_reply
1806 {
1807     struct reply_header __header;
1808     process_id_t  pid;
1809     thread_id_t   tid;
1810     obj_handle_t  wait;
1811     /* VARARG(event,debug_event); */
1812 };
1813
1814
1815
1816 struct queue_exception_event_request
1817 {
1818     struct request_header __header;
1819     int              first;
1820     /* VARARG(record,exc_event); */
1821 };
1822 struct queue_exception_event_reply
1823 {
1824     struct reply_header __header;
1825     obj_handle_t     handle;
1826 };
1827
1828
1829
1830 struct get_exception_status_request
1831 {
1832     struct request_header __header;
1833     obj_handle_t     handle;
1834 };
1835 struct get_exception_status_reply
1836 {
1837     struct reply_header __header;
1838     /* VARARG(context,context); */
1839 };
1840
1841
1842
1843 struct output_debug_string_request
1844 {
1845     struct request_header __header;
1846     void*         string;
1847     int           unicode;
1848     int           length;
1849 };
1850 struct output_debug_string_reply
1851 {
1852     struct reply_header __header;
1853 };
1854
1855
1856
1857 struct continue_debug_event_request
1858 {
1859     struct request_header __header;
1860     process_id_t pid;
1861     thread_id_t  tid;
1862     int          status;
1863 };
1864 struct continue_debug_event_reply
1865 {
1866     struct reply_header __header;
1867 };
1868
1869
1870
1871 struct debug_process_request
1872 {
1873     struct request_header __header;
1874     process_id_t pid;
1875     int          attach;
1876 };
1877 struct debug_process_reply
1878 {
1879     struct reply_header __header;
1880 };
1881
1882
1883
1884 struct debug_break_request
1885 {
1886     struct request_header __header;
1887     obj_handle_t handle;
1888 };
1889 struct debug_break_reply
1890 {
1891     struct reply_header __header;
1892     int          self;
1893 };
1894
1895
1896
1897 struct set_debugger_kill_on_exit_request
1898 {
1899     struct request_header __header;
1900     int          kill_on_exit;
1901 };
1902 struct set_debugger_kill_on_exit_reply
1903 {
1904     struct reply_header __header;
1905 };
1906
1907
1908
1909 struct read_process_memory_request
1910 {
1911     struct request_header __header;
1912     obj_handle_t handle;
1913     void*        addr;
1914 };
1915 struct read_process_memory_reply
1916 {
1917     struct reply_header __header;
1918     /* VARARG(data,bytes); */
1919 };
1920
1921
1922
1923 struct write_process_memory_request
1924 {
1925     struct request_header __header;
1926     obj_handle_t handle;
1927     void*        addr;
1928     /* VARARG(data,bytes); */
1929 };
1930 struct write_process_memory_reply
1931 {
1932     struct reply_header __header;
1933 };
1934
1935
1936
1937 struct create_key_request
1938 {
1939     struct request_header __header;
1940     obj_handle_t parent;
1941     unsigned int access;
1942     unsigned int attributes;
1943     unsigned int options;
1944     time_t       modif;
1945     data_size_t  namelen;
1946     /* VARARG(name,unicode_str,namelen); */
1947     /* VARARG(class,unicode_str); */
1948 };
1949 struct create_key_reply
1950 {
1951     struct reply_header __header;
1952     obj_handle_t hkey;
1953     int          created;
1954 };
1955
1956
1957 struct open_key_request
1958 {
1959     struct request_header __header;
1960     obj_handle_t parent;
1961     unsigned int access;
1962     unsigned int attributes;
1963     /* VARARG(name,unicode_str); */
1964 };
1965 struct open_key_reply
1966 {
1967     struct reply_header __header;
1968     obj_handle_t hkey;
1969 };
1970
1971
1972
1973 struct delete_key_request
1974 {
1975     struct request_header __header;
1976     obj_handle_t hkey;
1977 };
1978 struct delete_key_reply
1979 {
1980     struct reply_header __header;
1981 };
1982
1983
1984
1985 struct flush_key_request
1986 {
1987     struct request_header __header;
1988     obj_handle_t hkey;
1989 };
1990 struct flush_key_reply
1991 {
1992     struct reply_header __header;
1993 };
1994
1995
1996
1997 struct enum_key_request
1998 {
1999     struct request_header __header;
2000     obj_handle_t hkey;
2001     int          index;
2002     int          info_class;
2003 };
2004 struct enum_key_reply
2005 {
2006     struct reply_header __header;
2007     int          subkeys;
2008     int          max_subkey;
2009     int          max_class;
2010     int          values;
2011     int          max_value;
2012     int          max_data;
2013     time_t       modif;
2014     data_size_t  total;
2015     data_size_t  namelen;
2016     /* VARARG(name,unicode_str,namelen); */
2017     /* VARARG(class,unicode_str); */
2018 };
2019
2020
2021
2022 struct set_key_value_request
2023 {
2024     struct request_header __header;
2025     obj_handle_t hkey;
2026     int          type;
2027     data_size_t  namelen;
2028     /* VARARG(name,unicode_str,namelen); */
2029     /* VARARG(data,bytes); */
2030 };
2031 struct set_key_value_reply
2032 {
2033     struct reply_header __header;
2034 };
2035
2036
2037
2038 struct get_key_value_request
2039 {
2040     struct request_header __header;
2041     obj_handle_t hkey;
2042     /* VARARG(name,unicode_str); */
2043 };
2044 struct get_key_value_reply
2045 {
2046     struct reply_header __header;
2047     int          type;
2048     data_size_t  total;
2049     /* VARARG(data,bytes); */
2050 };
2051
2052
2053
2054 struct enum_key_value_request
2055 {
2056     struct request_header __header;
2057     obj_handle_t hkey;
2058     int          index;
2059     int          info_class;
2060 };
2061 struct enum_key_value_reply
2062 {
2063     struct reply_header __header;
2064     int          type;
2065     data_size_t  total;
2066     data_size_t  namelen;
2067     /* VARARG(name,unicode_str,namelen); */
2068     /* VARARG(data,bytes); */
2069 };
2070
2071
2072
2073 struct delete_key_value_request
2074 {
2075     struct request_header __header;
2076     obj_handle_t hkey;
2077     /* VARARG(name,unicode_str); */
2078 };
2079 struct delete_key_value_reply
2080 {
2081     struct reply_header __header;
2082 };
2083
2084
2085
2086 struct load_registry_request
2087 {
2088     struct request_header __header;
2089     obj_handle_t hkey;
2090     obj_handle_t file;
2091     /* VARARG(name,unicode_str); */
2092 };
2093 struct load_registry_reply
2094 {
2095     struct reply_header __header;
2096 };
2097
2098
2099
2100 struct unload_registry_request
2101 {
2102     struct request_header __header;
2103     obj_handle_t hkey;
2104 };
2105 struct unload_registry_reply
2106 {
2107     struct reply_header __header;
2108 };
2109
2110
2111
2112 struct save_registry_request
2113 {
2114     struct request_header __header;
2115     obj_handle_t hkey;
2116     obj_handle_t file;
2117 };
2118 struct save_registry_reply
2119 {
2120     struct reply_header __header;
2121 };
2122
2123
2124
2125 struct set_registry_notification_request
2126 {
2127     struct request_header __header;
2128     obj_handle_t hkey;
2129     obj_handle_t event;
2130     int          subtree;
2131     unsigned int filter;
2132 };
2133 struct set_registry_notification_reply
2134 {
2135     struct reply_header __header;
2136 };
2137
2138
2139
2140 struct create_timer_request
2141 {
2142     struct request_header __header;
2143     unsigned int access;
2144     unsigned int attributes;
2145     obj_handle_t rootdir;
2146     int          manual;
2147     /* VARARG(name,unicode_str); */
2148 };
2149 struct create_timer_reply
2150 {
2151     struct reply_header __header;
2152     obj_handle_t handle;
2153 };
2154
2155
2156
2157 struct open_timer_request
2158 {
2159     struct request_header __header;
2160     unsigned int access;
2161     unsigned int attributes;
2162     obj_handle_t rootdir;
2163     /* VARARG(name,unicode_str); */
2164 };
2165 struct open_timer_reply
2166 {
2167     struct reply_header __header;
2168     obj_handle_t handle;
2169 };
2170
2171
2172 struct set_timer_request
2173 {
2174     struct request_header __header;
2175     obj_handle_t handle;
2176     timeout_t    expire;
2177     int          period;
2178     void*        callback;
2179     void*        arg;
2180 };
2181 struct set_timer_reply
2182 {
2183     struct reply_header __header;
2184     int          signaled;
2185 };
2186
2187
2188 struct cancel_timer_request
2189 {
2190     struct request_header __header;
2191     obj_handle_t handle;
2192 };
2193 struct cancel_timer_reply
2194 {
2195     struct reply_header __header;
2196      int         signaled;
2197 };
2198
2199
2200 struct get_timer_info_request
2201 {
2202     struct request_header __header;
2203     obj_handle_t handle;
2204 };
2205 struct get_timer_info_reply
2206 {
2207     struct reply_header __header;
2208     timeout_t    when;
2209     int          signaled;
2210 };
2211
2212
2213
2214 struct get_thread_context_request
2215 {
2216     struct request_header __header;
2217     obj_handle_t handle;
2218     unsigned int flags;
2219     int          suspend;
2220 };
2221 struct get_thread_context_reply
2222 {
2223     struct reply_header __header;
2224     int          self;
2225     /* VARARG(context,context); */
2226 };
2227
2228
2229
2230 struct set_thread_context_request
2231 {
2232     struct request_header __header;
2233     obj_handle_t handle;
2234     unsigned int flags;
2235     int          suspend;
2236     /* VARARG(context,context); */
2237 };
2238 struct set_thread_context_reply
2239 {
2240     struct reply_header __header;
2241     int          self;
2242 };
2243
2244
2245
2246 struct get_selector_entry_request
2247 {
2248     struct request_header __header;
2249     obj_handle_t  handle;
2250     int           entry;
2251 };
2252 struct get_selector_entry_reply
2253 {
2254     struct reply_header __header;
2255     unsigned int  base;
2256     unsigned int  limit;
2257     unsigned char flags;
2258 };
2259
2260
2261
2262 struct add_atom_request
2263 {
2264     struct request_header __header;
2265     obj_handle_t  table;
2266     /* VARARG(name,unicode_str); */
2267 };
2268 struct add_atom_reply
2269 {
2270     struct reply_header __header;
2271     atom_t        atom;
2272 };
2273
2274
2275
2276 struct delete_atom_request
2277 {
2278     struct request_header __header;
2279     obj_handle_t  table;
2280     atom_t        atom;
2281 };
2282 struct delete_atom_reply
2283 {
2284     struct reply_header __header;
2285 };
2286
2287
2288
2289 struct find_atom_request
2290 {
2291     struct request_header __header;
2292     obj_handle_t table;
2293     /* VARARG(name,unicode_str); */
2294 };
2295 struct find_atom_reply
2296 {
2297     struct reply_header __header;
2298     atom_t       atom;
2299 };
2300
2301
2302
2303 struct get_atom_information_request
2304 {
2305     struct request_header __header;
2306     obj_handle_t table;
2307     atom_t       atom;
2308 };
2309 struct get_atom_information_reply
2310 {
2311     struct reply_header __header;
2312     int          count;
2313     int          pinned;
2314     data_size_t  total;
2315     /* VARARG(name,unicode_str); */
2316 };
2317
2318
2319
2320 struct set_atom_information_request
2321 {
2322     struct request_header __header;
2323     obj_handle_t table;
2324     atom_t       atom;
2325     int          pinned;
2326 };
2327 struct set_atom_information_reply
2328 {
2329     struct reply_header __header;
2330 };
2331
2332
2333
2334 struct empty_atom_table_request
2335 {
2336     struct request_header __header;
2337     obj_handle_t table;
2338     int          if_pinned;
2339 };
2340 struct empty_atom_table_reply
2341 {
2342     struct reply_header __header;
2343 };
2344
2345
2346
2347 struct init_atom_table_request
2348 {
2349     struct request_header __header;
2350     int          entries;
2351 };
2352 struct init_atom_table_reply
2353 {
2354     struct reply_header __header;
2355     obj_handle_t table;
2356 };
2357
2358
2359
2360 struct get_msg_queue_request
2361 {
2362     struct request_header __header;
2363 };
2364 struct get_msg_queue_reply
2365 {
2366     struct reply_header __header;
2367     obj_handle_t handle;
2368 };
2369
2370
2371
2372 struct set_queue_fd_request
2373 {
2374     struct request_header __header;
2375     obj_handle_t handle;
2376 };
2377 struct set_queue_fd_reply
2378 {
2379     struct reply_header __header;
2380 };
2381
2382
2383
2384 struct set_queue_mask_request
2385 {
2386     struct request_header __header;
2387     unsigned int wake_mask;
2388     unsigned int changed_mask;
2389     int          skip_wait;
2390 };
2391 struct set_queue_mask_reply
2392 {
2393     struct reply_header __header;
2394     unsigned int wake_bits;
2395     unsigned int changed_bits;
2396 };
2397
2398
2399
2400 struct get_queue_status_request
2401 {
2402     struct request_header __header;
2403     int          clear;
2404 };
2405 struct get_queue_status_reply
2406 {
2407     struct reply_header __header;
2408     unsigned int wake_bits;
2409     unsigned int changed_bits;
2410 };
2411
2412
2413
2414 struct get_process_idle_event_request
2415 {
2416     struct request_header __header;
2417     obj_handle_t handle;
2418 };
2419 struct get_process_idle_event_reply
2420 {
2421     struct reply_header __header;
2422     obj_handle_t event;
2423 };
2424
2425
2426
2427 struct send_message_request
2428 {
2429     struct request_header __header;
2430     thread_id_t     id;
2431     int             type;
2432     int             flags;
2433     user_handle_t   win;
2434     unsigned int    msg;
2435     unsigned long   wparam;
2436     unsigned long   lparam;
2437     timeout_t       timeout;
2438     /* VARARG(data,message_data); */
2439 };
2440 struct send_message_reply
2441 {
2442     struct reply_header __header;
2443 };
2444
2445 struct post_quit_message_request
2446 {
2447     struct request_header __header;
2448     int             exit_code;
2449 };
2450 struct post_quit_message_reply
2451 {
2452     struct reply_header __header;
2453 };
2454
2455 enum message_type
2456 {
2457     MSG_ASCII,
2458     MSG_UNICODE,
2459     MSG_NOTIFY,
2460     MSG_CALLBACK,
2461     MSG_CALLBACK_RESULT,
2462     MSG_OTHER_PROCESS,
2463     MSG_POSTED,
2464     MSG_HARDWARE,
2465     MSG_WINEVENT
2466 };
2467 #define SEND_MSG_ABORT_IF_HUNG  0x01
2468
2469
2470
2471 struct send_hardware_message_request
2472 {
2473     struct request_header __header;
2474     thread_id_t     id;
2475     user_handle_t   win;
2476     unsigned int    msg;
2477     unsigned int    time;
2478     unsigned long   wparam;
2479     unsigned long   lparam;
2480     unsigned long   info;
2481     int             x;
2482     int             y;
2483 };
2484 struct send_hardware_message_reply
2485 {
2486     struct reply_header __header;
2487 };
2488
2489
2490
2491 struct get_message_request
2492 {
2493     struct request_header __header;
2494     unsigned int    flags;
2495     user_handle_t   get_win;
2496     unsigned int    get_first;
2497     unsigned int    get_last;
2498     unsigned int    hw_id;
2499 };
2500 struct get_message_reply
2501 {
2502     struct reply_header __header;
2503     user_handle_t   win;
2504     int             type;
2505     unsigned int    msg;
2506     unsigned long   wparam;
2507     unsigned long   lparam;
2508     unsigned long   info;
2509     int             x;
2510     int             y;
2511     unsigned int    time;
2512     unsigned int    hw_id;
2513     unsigned int    active_hooks;
2514     data_size_t     total;
2515     /* VARARG(data,message_data); */
2516 };
2517
2518
2519
2520 struct reply_message_request
2521 {
2522     struct request_header __header;
2523     unsigned int    result;
2524     int             remove;
2525     /* VARARG(data,bytes); */
2526 };
2527 struct reply_message_reply
2528 {
2529     struct reply_header __header;
2530 };
2531
2532
2533
2534 struct accept_hardware_message_request
2535 {
2536     struct request_header __header;
2537     unsigned int    hw_id;
2538     int             remove;
2539     user_handle_t   new_win;
2540 };
2541 struct accept_hardware_message_reply
2542 {
2543     struct reply_header __header;
2544 };
2545
2546
2547
2548 struct get_message_reply_request
2549 {
2550     struct request_header __header;
2551     int             cancel;
2552 };
2553 struct get_message_reply_reply
2554 {
2555     struct reply_header __header;
2556     unsigned int    result;
2557     /* VARARG(data,bytes); */
2558 };
2559
2560
2561
2562 struct set_win_timer_request
2563 {
2564     struct request_header __header;
2565     user_handle_t   win;
2566     unsigned int    msg;
2567     unsigned int    rate;
2568     unsigned long   id;
2569     unsigned long   lparam;
2570 };
2571 struct set_win_timer_reply
2572 {
2573     struct reply_header __header;
2574     unsigned long   id;
2575 };
2576
2577
2578
2579 struct kill_win_timer_request
2580 {
2581     struct request_header __header;
2582     user_handle_t   win;
2583     unsigned int    msg;
2584     unsigned long   id;
2585 };
2586 struct kill_win_timer_reply
2587 {
2588     struct reply_header __header;
2589 };
2590
2591
2592
2593 struct get_serial_info_request
2594 {
2595     struct request_header __header;
2596     obj_handle_t handle;
2597 };
2598 struct get_serial_info_reply
2599 {
2600     struct reply_header __header;
2601     unsigned int readinterval;
2602     unsigned int readconst;
2603     unsigned int readmult;
2604     unsigned int writeconst;
2605     unsigned int writemult;
2606     unsigned int eventmask;
2607 };
2608
2609
2610
2611 struct set_serial_info_request
2612 {
2613     struct request_header __header;
2614     obj_handle_t handle;
2615     int          flags;
2616     unsigned int readinterval;
2617     unsigned int readconst;
2618     unsigned int readmult;
2619     unsigned int writeconst;
2620     unsigned int writemult;
2621     unsigned int eventmask;
2622 };
2623 struct set_serial_info_reply
2624 {
2625     struct reply_header __header;
2626 };
2627 #define SERIALINFO_SET_TIMEOUTS  0x01
2628 #define SERIALINFO_SET_MASK      0x02
2629
2630
2631
2632 struct register_async_request
2633 {
2634     struct request_header __header;
2635     obj_handle_t handle;
2636     int          type;
2637     int          count;
2638     async_data_t async;
2639 };
2640 struct register_async_reply
2641 {
2642     struct reply_header __header;
2643 };
2644 #define ASYNC_TYPE_READ  0x01
2645 #define ASYNC_TYPE_WRITE 0x02
2646 #define ASYNC_TYPE_WAIT  0x03
2647
2648
2649
2650 struct cancel_async_request
2651 {
2652     struct request_header __header;
2653     obj_handle_t handle;
2654 };
2655 struct cancel_async_reply
2656 {
2657     struct reply_header __header;
2658 };
2659
2660
2661
2662 struct ioctl_request
2663 {
2664     struct request_header __header;
2665     obj_handle_t   handle;
2666     ioctl_code_t   code;
2667     async_data_t   async;
2668     /* VARARG(in_data,bytes); */
2669 };
2670 struct ioctl_reply
2671 {
2672     struct reply_header __header;
2673     obj_handle_t   wait;
2674     unsigned int   options;
2675     /* VARARG(out_data,bytes); */
2676 };
2677
2678
2679
2680 struct get_ioctl_result_request
2681 {
2682     struct request_header __header;
2683     obj_handle_t   handle;
2684     void*          user_arg;
2685 };
2686 struct get_ioctl_result_reply
2687 {
2688     struct reply_header __header;
2689     /* VARARG(out_data,bytes); */
2690 };
2691
2692
2693
2694 struct create_named_pipe_request
2695 {
2696     struct request_header __header;
2697     unsigned int   access;
2698     unsigned int   attributes;
2699     obj_handle_t   rootdir;
2700     unsigned int   options;
2701     unsigned int   flags;
2702     unsigned int   maxinstances;
2703     unsigned int   outsize;
2704     unsigned int   insize;
2705     timeout_t      timeout;
2706     /* VARARG(name,unicode_str); */
2707 };
2708 struct create_named_pipe_reply
2709 {
2710     struct reply_header __header;
2711     obj_handle_t   handle;
2712 };
2713
2714
2715 #define NAMED_PIPE_MESSAGE_STREAM_WRITE 0x0001
2716 #define NAMED_PIPE_MESSAGE_STREAM_READ  0x0002
2717 #define NAMED_PIPE_NONBLOCKING_MODE     0x0004
2718 #define NAMED_PIPE_SERVER_END           0x8000
2719
2720
2721 struct get_named_pipe_info_request
2722 {
2723     struct request_header __header;
2724     obj_handle_t   handle;
2725 };
2726 struct get_named_pipe_info_reply
2727 {
2728     struct reply_header __header;
2729     unsigned int   flags;
2730     unsigned int   maxinstances;
2731     unsigned int   instances;
2732     unsigned int   outsize;
2733     unsigned int   insize;
2734 };
2735
2736
2737
2738 struct create_window_request
2739 {
2740     struct request_header __header;
2741     user_handle_t  parent;
2742     user_handle_t  owner;
2743     atom_t         atom;
2744     void*          instance;
2745 };
2746 struct create_window_reply
2747 {
2748     struct reply_header __header;
2749     user_handle_t  handle;
2750     user_handle_t  parent;
2751     user_handle_t  owner;
2752     int            extra;
2753     void*          class_ptr;
2754 };
2755
2756
2757
2758 struct destroy_window_request
2759 {
2760     struct request_header __header;
2761     user_handle_t  handle;
2762 };
2763 struct destroy_window_reply
2764 {
2765     struct reply_header __header;
2766 };
2767
2768
2769
2770 struct get_desktop_window_request
2771 {
2772     struct request_header __header;
2773     int            force;
2774 };
2775 struct get_desktop_window_reply
2776 {
2777     struct reply_header __header;
2778     user_handle_t  handle;
2779 };
2780
2781
2782
2783 struct set_window_owner_request
2784 {
2785     struct request_header __header;
2786     user_handle_t  handle;
2787     user_handle_t  owner;
2788 };
2789 struct set_window_owner_reply
2790 {
2791     struct reply_header __header;
2792     user_handle_t  full_owner;
2793     user_handle_t  prev_owner;
2794 };
2795
2796
2797
2798 struct get_window_info_request
2799 {
2800     struct request_header __header;
2801     user_handle_t  handle;
2802 };
2803 struct get_window_info_reply
2804 {
2805     struct reply_header __header;
2806     user_handle_t  full_handle;
2807     user_handle_t  last_active;
2808     process_id_t   pid;
2809     thread_id_t    tid;
2810     atom_t         atom;
2811     int            is_unicode;
2812 };
2813
2814
2815
2816 struct set_window_info_request
2817 {
2818     struct request_header __header;
2819     unsigned int   flags;
2820     user_handle_t  handle;
2821     unsigned int   style;
2822     unsigned int   ex_style;
2823     unsigned int   id;
2824     int            is_unicode;
2825     void*          instance;
2826     unsigned long  user_data;
2827     int            extra_offset;
2828     data_size_t    extra_size;
2829     unsigned long  extra_value;
2830 };
2831 struct set_window_info_reply
2832 {
2833     struct reply_header __header;
2834     unsigned int   old_style;
2835     unsigned int   old_ex_style;
2836     unsigned int   old_id;
2837     void*          old_instance;
2838     unsigned long  old_user_data;
2839     unsigned long  old_extra_value;
2840 };
2841 #define SET_WIN_STYLE     0x01
2842 #define SET_WIN_EXSTYLE   0x02
2843 #define SET_WIN_ID        0x04
2844 #define SET_WIN_INSTANCE  0x08
2845 #define SET_WIN_USERDATA  0x10
2846 #define SET_WIN_EXTRA     0x20
2847 #define SET_WIN_UNICODE   0x40
2848
2849
2850
2851 struct set_parent_request
2852 {
2853     struct request_header __header;
2854     user_handle_t  handle;
2855     user_handle_t  parent;
2856 };
2857 struct set_parent_reply
2858 {
2859     struct reply_header __header;
2860     user_handle_t  old_parent;
2861     user_handle_t  full_parent;
2862 };
2863
2864
2865
2866 struct get_window_parents_request
2867 {
2868     struct request_header __header;
2869     user_handle_t  handle;
2870 };
2871 struct get_window_parents_reply
2872 {
2873     struct reply_header __header;
2874     int            count;
2875     /* VARARG(parents,user_handles); */
2876 };
2877
2878
2879
2880 struct get_window_children_request
2881 {
2882     struct request_header __header;
2883     user_handle_t  parent;
2884     atom_t         atom;
2885     thread_id_t    tid;
2886 };
2887 struct get_window_children_reply
2888 {
2889     struct reply_header __header;
2890     int            count;
2891     /* VARARG(children,user_handles); */
2892 };
2893
2894
2895
2896 struct get_window_children_from_point_request
2897 {
2898     struct request_header __header;
2899     user_handle_t  parent;
2900     int            x;
2901     int            y;
2902 };
2903 struct get_window_children_from_point_reply
2904 {
2905     struct reply_header __header;
2906     int            count;
2907     /* VARARG(children,user_handles); */
2908 };
2909
2910
2911
2912 struct get_window_tree_request
2913 {
2914     struct request_header __header;
2915     user_handle_t  handle;
2916 };
2917 struct get_window_tree_reply
2918 {
2919     struct reply_header __header;
2920     user_handle_t  parent;
2921     user_handle_t  owner;
2922     user_handle_t  next_sibling;
2923     user_handle_t  prev_sibling;
2924     user_handle_t  first_sibling;
2925     user_handle_t  last_sibling;
2926     user_handle_t  first_child;
2927     user_handle_t  last_child;
2928 };
2929
2930
2931 struct set_window_pos_request
2932 {
2933     struct request_header __header;
2934     unsigned int   flags;
2935     user_handle_t  handle;
2936     user_handle_t  previous;
2937     rectangle_t    window;
2938     rectangle_t    client;
2939     /* VARARG(valid,rectangles); */
2940 };
2941 struct set_window_pos_reply
2942 {
2943     struct reply_header __header;
2944     unsigned int   new_style;
2945 };
2946
2947
2948
2949 struct get_window_rectangles_request
2950 {
2951     struct request_header __header;
2952     user_handle_t  handle;
2953 };
2954 struct get_window_rectangles_reply
2955 {
2956     struct reply_header __header;
2957     rectangle_t    window;
2958     rectangle_t    visible;
2959     rectangle_t    client;
2960 };
2961
2962
2963
2964 struct get_window_text_request
2965 {
2966     struct request_header __header;
2967     user_handle_t  handle;
2968 };
2969 struct get_window_text_reply
2970 {
2971     struct reply_header __header;
2972     /* VARARG(text,unicode_str); */
2973 };
2974
2975
2976
2977 struct set_window_text_request
2978 {
2979     struct request_header __header;
2980     user_handle_t  handle;
2981     /* VARARG(text,unicode_str); */
2982 };
2983 struct set_window_text_reply
2984 {
2985     struct reply_header __header;
2986 };
2987
2988
2989
2990 struct get_windows_offset_request
2991 {
2992     struct request_header __header;
2993     user_handle_t  from;
2994     user_handle_t  to;
2995 };
2996 struct get_windows_offset_reply
2997 {
2998     struct reply_header __header;
2999     int            x;
3000     int            y;
3001 };
3002
3003
3004
3005 struct get_visible_region_request
3006 {
3007     struct request_header __header;
3008     user_handle_t  window;
3009     unsigned int   flags;
3010 };
3011 struct get_visible_region_reply
3012 {
3013     struct reply_header __header;
3014     user_handle_t  top_win;
3015     rectangle_t    top_rect;
3016     rectangle_t    win_rect;
3017     data_size_t    total_size;
3018     /* VARARG(region,rectangles); */
3019 };
3020
3021
3022
3023 struct get_window_region_request
3024 {
3025     struct request_header __header;
3026     user_handle_t  window;
3027 };
3028 struct get_window_region_reply
3029 {
3030     struct reply_header __header;
3031     data_size_t    total_size;
3032     /* VARARG(region,rectangles); */
3033 };
3034
3035
3036
3037 struct set_window_region_request
3038 {
3039     struct request_header __header;
3040     user_handle_t  window;
3041     int            redraw;
3042     /* VARARG(region,rectangles); */
3043 };
3044 struct set_window_region_reply
3045 {
3046     struct reply_header __header;
3047 };
3048
3049
3050
3051 struct get_update_region_request
3052 {
3053     struct request_header __header;
3054     user_handle_t  window;
3055     user_handle_t  from_child;
3056     unsigned int   flags;
3057 };
3058 struct get_update_region_reply
3059 {
3060     struct reply_header __header;
3061     user_handle_t  child;
3062     unsigned int   flags;
3063     data_size_t    total_size;
3064     /* VARARG(region,rectangles); */
3065 };
3066 #define UPDATE_NONCLIENT       0x01
3067 #define UPDATE_ERASE           0x02
3068 #define UPDATE_PAINT           0x04
3069 #define UPDATE_INTERNALPAINT   0x08
3070 #define UPDATE_ALLCHILDREN     0x10
3071 #define UPDATE_NOCHILDREN      0x20
3072 #define UPDATE_NOREGION        0x40
3073
3074
3075
3076 struct update_window_zorder_request
3077 {
3078     struct request_header __header;
3079     user_handle_t  window;
3080     rectangle_t    rect;
3081 };
3082 struct update_window_zorder_reply
3083 {
3084     struct reply_header __header;
3085 };
3086
3087
3088
3089 struct redraw_window_request
3090 {
3091     struct request_header __header;
3092     user_handle_t  window;
3093     unsigned int   flags;
3094     /* VARARG(region,rectangles); */
3095 };
3096 struct redraw_window_reply
3097 {
3098     struct reply_header __header;
3099 };
3100
3101
3102
3103 struct set_window_property_request
3104 {
3105     struct request_header __header;
3106     user_handle_t  window;
3107     atom_t         atom;
3108     obj_handle_t   handle;
3109     /* VARARG(name,unicode_str); */
3110 };
3111 struct set_window_property_reply
3112 {
3113     struct reply_header __header;
3114 };
3115
3116
3117
3118 struct remove_window_property_request
3119 {
3120     struct request_header __header;
3121     user_handle_t  window;
3122     atom_t         atom;
3123     /* VARARG(name,unicode_str); */
3124 };
3125 struct remove_window_property_reply
3126 {
3127     struct reply_header __header;
3128     obj_handle_t   handle;
3129 };
3130
3131
3132
3133 struct get_window_property_request
3134 {
3135     struct request_header __header;
3136     user_handle_t  window;
3137     atom_t         atom;
3138     /* VARARG(name,unicode_str); */
3139 };
3140 struct get_window_property_reply
3141 {
3142     struct reply_header __header;
3143     obj_handle_t   handle;
3144 };
3145
3146
3147
3148 struct get_window_properties_request
3149 {
3150     struct request_header __header;
3151     user_handle_t  window;
3152 };
3153 struct get_window_properties_reply
3154 {
3155     struct reply_header __header;
3156     int            total;
3157     /* VARARG(props,properties); */
3158 };
3159
3160
3161
3162 struct create_winstation_request
3163 {
3164     struct request_header __header;
3165     unsigned int flags;
3166     unsigned int access;
3167     unsigned int attributes;
3168     /* VARARG(name,unicode_str); */
3169 };
3170 struct create_winstation_reply
3171 {
3172     struct reply_header __header;
3173     obj_handle_t handle;
3174 };
3175
3176
3177
3178 struct open_winstation_request
3179 {
3180     struct request_header __header;
3181     unsigned int access;
3182     unsigned int attributes;
3183     /* VARARG(name,unicode_str); */
3184 };
3185 struct open_winstation_reply
3186 {
3187     struct reply_header __header;
3188     obj_handle_t handle;
3189 };
3190
3191
3192
3193 struct close_winstation_request
3194 {
3195     struct request_header __header;
3196     obj_handle_t handle;
3197 };
3198 struct close_winstation_reply
3199 {
3200     struct reply_header __header;
3201 };
3202
3203
3204
3205 struct get_process_winstation_request
3206 {
3207     struct request_header __header;
3208 };
3209 struct get_process_winstation_reply
3210 {
3211     struct reply_header __header;
3212     obj_handle_t handle;
3213 };
3214
3215
3216
3217 struct set_process_winstation_request
3218 {
3219     struct request_header __header;
3220     obj_handle_t handle;
3221 };
3222 struct set_process_winstation_reply
3223 {
3224     struct reply_header __header;
3225 };
3226
3227
3228
3229 struct create_desktop_request
3230 {
3231     struct request_header __header;
3232     unsigned int flags;
3233     unsigned int access;
3234     unsigned int attributes;
3235     /* VARARG(name,unicode_str); */
3236 };
3237 struct create_desktop_reply
3238 {
3239     struct reply_header __header;
3240     obj_handle_t handle;
3241 };
3242
3243
3244
3245 struct open_desktop_request
3246 {
3247     struct request_header __header;
3248     unsigned int flags;
3249     unsigned int access;
3250     unsigned int attributes;
3251     /* VARARG(name,unicode_str); */
3252 };
3253 struct open_desktop_reply
3254 {
3255     struct reply_header __header;
3256     obj_handle_t handle;
3257 };
3258
3259
3260
3261 struct close_desktop_request
3262 {
3263     struct request_header __header;
3264     obj_handle_t handle;
3265 };
3266 struct close_desktop_reply
3267 {
3268     struct reply_header __header;
3269 };
3270
3271
3272
3273 struct get_thread_desktop_request
3274 {
3275     struct request_header __header;
3276     thread_id_t  tid;
3277 };
3278 struct get_thread_desktop_reply
3279 {
3280     struct reply_header __header;
3281     obj_handle_t handle;
3282 };
3283
3284
3285
3286 struct set_thread_desktop_request
3287 {
3288     struct request_header __header;
3289     obj_handle_t handle;
3290 };
3291 struct set_thread_desktop_reply
3292 {
3293     struct reply_header __header;
3294 };
3295
3296
3297
3298 struct set_user_object_info_request
3299 {
3300     struct request_header __header;
3301     obj_handle_t handle;
3302     unsigned int flags;
3303     unsigned int obj_flags;
3304 };
3305 struct set_user_object_info_reply
3306 {
3307     struct reply_header __header;
3308     int          is_desktop;
3309     unsigned int old_obj_flags;
3310     /* VARARG(name,unicode_str); */
3311 };
3312 #define SET_USER_OBJECT_FLAGS 1
3313
3314
3315
3316 struct attach_thread_input_request
3317 {
3318     struct request_header __header;
3319     thread_id_t    tid_from;
3320     thread_id_t    tid_to;
3321     int            attach;
3322 };
3323 struct attach_thread_input_reply
3324 {
3325     struct reply_header __header;
3326 };
3327
3328
3329
3330 struct get_thread_input_request
3331 {
3332     struct request_header __header;
3333     thread_id_t    tid;
3334 };
3335 struct get_thread_input_reply
3336 {
3337     struct reply_header __header;
3338     user_handle_t  focus;
3339     user_handle_t  capture;
3340     user_handle_t  active;
3341     user_handle_t  foreground;
3342     user_handle_t  menu_owner;
3343     user_handle_t  move_size;
3344     user_handle_t  caret;
3345     rectangle_t    rect;
3346 };
3347
3348
3349
3350 struct get_last_input_time_request
3351 {
3352     struct request_header __header;
3353 };
3354 struct get_last_input_time_reply
3355 {
3356     struct reply_header __header;
3357     unsigned int time;
3358 };
3359
3360
3361
3362 struct get_key_state_request
3363 {
3364     struct request_header __header;
3365     thread_id_t    tid;
3366     int            key;
3367 };
3368 struct get_key_state_reply
3369 {
3370     struct reply_header __header;
3371     unsigned char  state;
3372     /* VARARG(keystate,bytes); */
3373 };
3374
3375
3376 struct set_key_state_request
3377 {
3378     struct request_header __header;
3379     thread_id_t    tid;
3380     /* VARARG(keystate,bytes); */
3381 };
3382 struct set_key_state_reply
3383 {
3384     struct reply_header __header;
3385 };
3386
3387
3388 struct set_foreground_window_request
3389 {
3390     struct request_header __header;
3391     user_handle_t  handle;
3392 };
3393 struct set_foreground_window_reply
3394 {
3395     struct reply_header __header;
3396     user_handle_t  previous;
3397     int            send_msg_old;
3398     int            send_msg_new;
3399 };
3400
3401
3402 struct set_focus_window_request
3403 {
3404     struct request_header __header;
3405     user_handle_t  handle;
3406 };
3407 struct set_focus_window_reply
3408 {
3409     struct reply_header __header;
3410     user_handle_t  previous;
3411 };
3412
3413
3414 struct set_active_window_request
3415 {
3416     struct request_header __header;
3417     user_handle_t  handle;
3418 };
3419 struct set_active_window_reply
3420 {
3421     struct reply_header __header;
3422     user_handle_t  previous;
3423 };
3424
3425
3426 struct set_capture_window_request
3427 {
3428     struct request_header __header;
3429     user_handle_t  handle;
3430     unsigned int   flags;
3431 };
3432 struct set_capture_window_reply
3433 {
3434     struct reply_header __header;
3435     user_handle_t  previous;
3436     user_handle_t  full_handle;
3437 };
3438 #define CAPTURE_MENU     0x01
3439 #define CAPTURE_MOVESIZE 0x02
3440
3441
3442
3443 struct set_caret_window_request
3444 {
3445     struct request_header __header;
3446     user_handle_t  handle;
3447     int            width;
3448     int            height;
3449 };
3450 struct set_caret_window_reply
3451 {
3452     struct reply_header __header;
3453     user_handle_t  previous;
3454     rectangle_t    old_rect;
3455     int            old_hide;
3456     int            old_state;
3457 };
3458
3459
3460
3461 struct set_caret_info_request
3462 {
3463     struct request_header __header;
3464     unsigned int   flags;
3465     user_handle_t  handle;
3466     int            x;
3467     int            y;
3468     int            hide;
3469     int            state;
3470 };
3471 struct set_caret_info_reply
3472 {
3473     struct reply_header __header;
3474     user_handle_t  full_handle;
3475     rectangle_t    old_rect;
3476     int            old_hide;
3477     int            old_state;
3478 };
3479 #define SET_CARET_POS        0x01
3480 #define SET_CARET_HIDE       0x02
3481 #define SET_CARET_STATE      0x04
3482
3483
3484
3485 struct set_hook_request
3486 {
3487     struct request_header __header;
3488     int            id;
3489     process_id_t   pid;
3490     thread_id_t    tid;
3491     int            event_min;
3492     int            event_max;
3493     int            flags;
3494     void*          proc;
3495     int            unicode;
3496     /* VARARG(module,unicode_str); */
3497 };
3498 struct set_hook_reply
3499 {
3500     struct reply_header __header;
3501     user_handle_t  handle;
3502     unsigned int   active_hooks;
3503 };
3504
3505
3506
3507 struct remove_hook_request
3508 {
3509     struct request_header __header;
3510     user_handle_t  handle;
3511     int            id;
3512     void*          proc;
3513 };
3514 struct remove_hook_reply
3515 {
3516     struct reply_header __header;
3517     unsigned int   active_hooks;
3518 };
3519
3520
3521
3522 struct start_hook_chain_request
3523 {
3524     struct request_header __header;
3525     int            id;
3526     int            event;
3527     user_handle_t  window;
3528     int            object_id;
3529     int            child_id;
3530 };
3531 struct start_hook_chain_reply
3532 {
3533     struct reply_header __header;
3534     user_handle_t  handle;
3535     process_id_t   pid;
3536     thread_id_t    tid;
3537     void*          proc;
3538     int            unicode;
3539     unsigned int   active_hooks;
3540     /* VARARG(module,unicode_str); */
3541 };
3542
3543
3544
3545 struct finish_hook_chain_request
3546 {
3547     struct request_header __header;
3548     int            id;
3549 };
3550 struct finish_hook_chain_reply
3551 {
3552     struct reply_header __header;
3553 };
3554
3555
3556
3557 struct get_hook_info_request
3558 {
3559     struct request_header __header;
3560     user_handle_t  handle;
3561     int            get_next;
3562     int            event;
3563     user_handle_t  window;
3564     int            object_id;
3565     int            child_id;
3566 };
3567 struct get_hook_info_reply
3568 {
3569     struct reply_header __header;
3570     user_handle_t  handle;
3571     int            id;
3572     process_id_t   pid;
3573     thread_id_t    tid;
3574     void*          proc;
3575     int            unicode;
3576     /* VARARG(module,unicode_str); */
3577 };
3578
3579
3580
3581 struct create_class_request
3582 {
3583     struct request_header __header;
3584     int            local;
3585     atom_t         atom;
3586     unsigned int   style;
3587     void*          instance;
3588     int            extra;
3589     int            win_extra;
3590     void*          client_ptr;
3591 };
3592 struct create_class_reply
3593 {
3594     struct reply_header __header;
3595 };
3596
3597
3598
3599 struct destroy_class_request
3600 {
3601     struct request_header __header;
3602     atom_t         atom;
3603     void*          instance;
3604 };
3605 struct destroy_class_reply
3606 {
3607     struct reply_header __header;
3608     void*          client_ptr;
3609 };
3610
3611
3612
3613 struct set_class_info_request
3614 {
3615     struct request_header __header;
3616     user_handle_t  window;
3617     unsigned int   flags;
3618     atom_t         atom;
3619     unsigned int   style;
3620     int            win_extra;
3621     void*          instance;
3622     int            extra_offset;
3623     data_size_t    extra_size;
3624     unsigned long  extra_value;
3625 };
3626 struct set_class_info_reply
3627 {
3628     struct reply_header __header;
3629     atom_t         old_atom;
3630     unsigned int   old_style;
3631     int            old_extra;
3632     int            old_win_extra;
3633     void*          old_instance;
3634     unsigned long  old_extra_value;
3635 };
3636 #define SET_CLASS_ATOM      0x0001
3637 #define SET_CLASS_STYLE     0x0002
3638 #define SET_CLASS_WINEXTRA  0x0004
3639 #define SET_CLASS_INSTANCE  0x0008
3640 #define SET_CLASS_EXTRA     0x0010
3641
3642
3643
3644 struct set_clipboard_info_request
3645 {
3646     struct request_header __header;
3647     unsigned int   flags;
3648     user_handle_t  clipboard;
3649     user_handle_t  owner;
3650     user_handle_t  viewer;
3651     unsigned int   seqno;
3652 };
3653 struct set_clipboard_info_reply
3654 {
3655     struct reply_header __header;
3656     unsigned int   flags;
3657     user_handle_t  old_clipboard;
3658     user_handle_t  old_owner;
3659     user_handle_t  old_viewer;
3660     unsigned int   seqno;
3661 };
3662
3663 #define SET_CB_OPEN      0x001
3664 #define SET_CB_OWNER     0x002
3665 #define SET_CB_VIEWER    0x004
3666 #define SET_CB_SEQNO     0x008
3667 #define SET_CB_RELOWNER  0x010
3668 #define SET_CB_CLOSE     0x020
3669 #define CB_OPEN          0x040
3670 #define CB_OWNER         0x080
3671 #define CB_PROCESS       0x100
3672
3673
3674
3675 struct open_token_request
3676 {
3677     struct request_header __header;
3678     obj_handle_t   handle;
3679     unsigned int   access;
3680     unsigned int   attributes;
3681     unsigned int   flags;
3682 };
3683 struct open_token_reply
3684 {
3685     struct reply_header __header;
3686     obj_handle_t   token;
3687 };
3688 #define OPEN_TOKEN_THREAD   1
3689 #define OPEN_TOKEN_AS_SELF  2
3690
3691
3692
3693 struct set_global_windows_request
3694 {
3695     struct request_header __header;
3696     unsigned int   flags;
3697     user_handle_t  shell_window;
3698     user_handle_t  shell_listview;
3699     user_handle_t  progman_window;
3700     user_handle_t  taskman_window;
3701 };
3702 struct set_global_windows_reply
3703 {
3704     struct reply_header __header;
3705     user_handle_t  old_shell_window;
3706     user_handle_t  old_shell_listview;
3707     user_handle_t  old_progman_window;
3708     user_handle_t  old_taskman_window;
3709 };
3710 #define SET_GLOBAL_SHELL_WINDOWS   0x01
3711 #define SET_GLOBAL_PROGMAN_WINDOW  0x02
3712 #define SET_GLOBAL_TASKMAN_WINDOW  0x04
3713
3714
3715 struct adjust_token_privileges_request
3716 {
3717     struct request_header __header;
3718     obj_handle_t  handle;
3719     int           disable_all;
3720     int           get_modified_state;
3721     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
3722 };
3723 struct adjust_token_privileges_reply
3724 {
3725     struct reply_header __header;
3726     unsigned int  len;
3727     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
3728 };
3729
3730
3731 struct get_token_privileges_request
3732 {
3733     struct request_header __header;
3734     obj_handle_t  handle;
3735 };
3736 struct get_token_privileges_reply
3737 {
3738     struct reply_header __header;
3739     unsigned int  len;
3740     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
3741 };
3742
3743
3744 struct check_token_privileges_request
3745 {
3746     struct request_header __header;
3747     obj_handle_t  handle;
3748     int           all_required;
3749     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
3750 };
3751 struct check_token_privileges_reply
3752 {
3753     struct reply_header __header;
3754     int           has_privileges;
3755     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
3756 };
3757
3758 struct duplicate_token_request
3759 {
3760     struct request_header __header;
3761     obj_handle_t  handle;
3762     unsigned int  access;
3763     unsigned int  attributes;
3764     int           primary;
3765     int           impersonation_level;
3766 };
3767 struct duplicate_token_reply
3768 {
3769     struct reply_header __header;
3770     obj_handle_t  new_handle;
3771 };
3772
3773 struct access_check_request
3774 {
3775     struct request_header __header;
3776     obj_handle_t    handle;
3777     unsigned int    desired_access;
3778     unsigned int    mapping_read;
3779     unsigned int    mapping_write;
3780     unsigned int    mapping_execute;
3781     unsigned int    mapping_all;
3782     /* VARARG(sd,security_descriptor); */
3783 };
3784 struct access_check_reply
3785 {
3786     struct reply_header __header;
3787     unsigned int    access_granted;
3788     unsigned int    access_status;
3789     unsigned int    privileges_len;
3790     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
3791 };
3792
3793 struct get_token_user_request
3794 {
3795     struct request_header __header;
3796     obj_handle_t    handle;
3797 };
3798 struct get_token_user_reply
3799 {
3800     struct reply_header __header;
3801     data_size_t     user_len;
3802     /* VARARG(user,SID); */
3803 };
3804
3805 struct get_token_groups_request
3806 {
3807     struct request_header __header;
3808     obj_handle_t    handle;
3809 };
3810 struct get_token_groups_reply
3811 {
3812     struct reply_header __header;
3813     data_size_t     user_len;
3814     /* VARARG(user,token_groups); */
3815 };
3816
3817 struct set_security_object_request
3818 {
3819     struct request_header __header;
3820     obj_handle_t    handle;
3821     unsigned int    security_info;
3822     /* VARARG(sd,security_descriptor); */
3823 };
3824 struct set_security_object_reply
3825 {
3826     struct reply_header __header;
3827 };
3828
3829
3830 struct create_mailslot_request
3831 {
3832     struct request_header __header;
3833     unsigned int   access;
3834     unsigned int   attributes;
3835     obj_handle_t   rootdir;
3836     unsigned int   max_msgsize;
3837     timeout_t      read_timeout;
3838     /* VARARG(name,unicode_str); */
3839 };
3840 struct create_mailslot_reply
3841 {
3842     struct reply_header __header;
3843     obj_handle_t   handle;
3844 };
3845
3846
3847
3848 struct set_mailslot_info_request
3849 {
3850     struct request_header __header;
3851     obj_handle_t   handle;
3852     unsigned int   flags;
3853     timeout_t      read_timeout;
3854 };
3855 struct set_mailslot_info_reply
3856 {
3857     struct reply_header __header;
3858     unsigned int   max_msgsize;
3859     timeout_t      read_timeout;
3860 };
3861 #define MAILSLOT_SET_READ_TIMEOUT  1
3862
3863
3864
3865 struct create_directory_request
3866 {
3867     struct request_header __header;
3868     unsigned int   access;
3869     unsigned int   attributes;
3870     obj_handle_t   rootdir;
3871     /* VARARG(directory_name,unicode_str); */
3872 };
3873 struct create_directory_reply
3874 {
3875     struct reply_header __header;
3876     obj_handle_t   handle;
3877 };
3878
3879
3880
3881 struct open_directory_request
3882 {
3883     struct request_header __header;
3884     unsigned int   access;
3885     unsigned int   attributes;
3886     obj_handle_t   rootdir;
3887     /* VARARG(directory_name,unicode_str); */
3888 };
3889 struct open_directory_reply
3890 {
3891     struct reply_header __header;
3892     obj_handle_t   handle;
3893 };
3894
3895
3896
3897 struct create_symlink_request
3898 {
3899     struct request_header __header;
3900     unsigned int   access;
3901     unsigned int   attributes;
3902     obj_handle_t   rootdir;
3903     data_size_t    name_len;
3904     /* VARARG(name,unicode_str,name_len); */
3905     /* VARARG(target_name,unicode_str); */
3906 };
3907 struct create_symlink_reply
3908 {
3909     struct reply_header __header;
3910     obj_handle_t   handle;
3911 };
3912
3913
3914
3915 struct open_symlink_request
3916 {
3917     struct request_header __header;
3918     unsigned int   access;
3919     unsigned int   attributes;
3920     obj_handle_t   rootdir;
3921     /* VARARG(name,unicode_str); */
3922 };
3923 struct open_symlink_reply
3924 {
3925     struct reply_header __header;
3926     obj_handle_t   handle;
3927 };
3928
3929
3930
3931 struct query_symlink_request
3932 {
3933     struct request_header __header;
3934     obj_handle_t   handle;
3935 };
3936 struct query_symlink_reply
3937 {
3938     struct reply_header __header;
3939     /* VARARG(target_name,unicode_str); */
3940 };
3941
3942
3943
3944 struct get_object_info_request
3945 {
3946     struct request_header __header;
3947     obj_handle_t   handle;
3948 };
3949 struct get_object_info_reply
3950 {
3951     struct reply_header __header;
3952     unsigned int   access;
3953     unsigned int   ref_count;
3954 };
3955
3956
3957 struct get_token_impersonation_level_request
3958 {
3959     struct request_header __header;
3960     obj_handle_t   handle;
3961 };
3962 struct get_token_impersonation_level_reply
3963 {
3964     struct reply_header __header;
3965     int            impersonation_level;
3966 };
3967
3968
3969 struct allocate_locally_unique_id_request
3970 {
3971     struct request_header __header;
3972 };
3973 struct allocate_locally_unique_id_reply
3974 {
3975     struct reply_header __header;
3976     luid_t         luid;
3977 };
3978
3979
3980
3981 struct create_device_manager_request
3982 {
3983     struct request_header __header;
3984     unsigned int access;
3985     unsigned int attributes;
3986 };
3987 struct create_device_manager_reply
3988 {
3989     struct reply_header __header;
3990     obj_handle_t handle;
3991 };
3992
3993
3994
3995 struct create_device_request
3996 {
3997     struct request_header __header;
3998     unsigned int access;
3999     unsigned int attributes;
4000     obj_handle_t rootdir;
4001     obj_handle_t manager;
4002     void*        user_ptr;
4003     /* VARARG(name,unicode_str); */
4004 };
4005 struct create_device_reply
4006 {
4007     struct reply_header __header;
4008     obj_handle_t handle;
4009 };
4010
4011
4012
4013 struct delete_device_request
4014 {
4015     struct request_header __header;
4016     obj_handle_t handle;
4017 };
4018 struct delete_device_reply
4019 {
4020     struct reply_header __header;
4021 };
4022
4023
4024
4025 struct get_next_device_request_request
4026 {
4027     struct request_header __header;
4028     obj_handle_t manager;
4029     obj_handle_t prev;
4030     unsigned int status;
4031     /* VARARG(prev_data,bytes); */
4032 };
4033 struct get_next_device_request_reply
4034 {
4035     struct reply_header __header;
4036     obj_handle_t next;
4037     ioctl_code_t code;
4038     void*        user_ptr;
4039     data_size_t  in_size;
4040     data_size_t  out_size;
4041     /* VARARG(next_data,bytes); */
4042 };
4043
4044
4045
4046 struct make_process_system_request
4047 {
4048     struct request_header __header;
4049 };
4050 struct make_process_system_reply
4051 {
4052     struct reply_header __header;
4053     obj_handle_t event;
4054 };
4055
4056
4057 enum request
4058 {
4059     REQ_new_process,
4060     REQ_get_new_process_info,
4061     REQ_new_thread,
4062     REQ_get_startup_info,
4063     REQ_init_process_done,
4064     REQ_init_thread,
4065     REQ_terminate_process,
4066     REQ_terminate_thread,
4067     REQ_get_process_info,
4068     REQ_set_process_info,
4069     REQ_get_thread_info,
4070     REQ_set_thread_info,
4071     REQ_get_dll_info,
4072     REQ_suspend_thread,
4073     REQ_resume_thread,
4074     REQ_load_dll,
4075     REQ_unload_dll,
4076     REQ_queue_apc,
4077     REQ_get_apc_result,
4078     REQ_close_handle,
4079     REQ_set_handle_info,
4080     REQ_dup_handle,
4081     REQ_open_process,
4082     REQ_open_thread,
4083     REQ_select,
4084     REQ_create_event,
4085     REQ_event_op,
4086     REQ_open_event,
4087     REQ_create_mutex,
4088     REQ_release_mutex,
4089     REQ_open_mutex,
4090     REQ_create_semaphore,
4091     REQ_release_semaphore,
4092     REQ_open_semaphore,
4093     REQ_create_file,
4094     REQ_open_file_object,
4095     REQ_alloc_file_handle,
4096     REQ_get_handle_fd,
4097     REQ_flush_file,
4098     REQ_lock_file,
4099     REQ_unlock_file,
4100     REQ_create_socket,
4101     REQ_accept_socket,
4102     REQ_set_socket_event,
4103     REQ_get_socket_event,
4104     REQ_enable_socket_event,
4105     REQ_set_socket_deferred,
4106     REQ_alloc_console,
4107     REQ_free_console,
4108     REQ_get_console_renderer_events,
4109     REQ_open_console,
4110     REQ_get_console_wait_event,
4111     REQ_get_console_mode,
4112     REQ_set_console_mode,
4113     REQ_set_console_input_info,
4114     REQ_get_console_input_info,
4115     REQ_append_console_input_history,
4116     REQ_get_console_input_history,
4117     REQ_create_console_output,
4118     REQ_set_console_output_info,
4119     REQ_get_console_output_info,
4120     REQ_write_console_input,
4121     REQ_read_console_input,
4122     REQ_write_console_output,
4123     REQ_fill_console_output,
4124     REQ_read_console_output,
4125     REQ_move_console_output,
4126     REQ_send_console_signal,
4127     REQ_read_directory_changes,
4128     REQ_read_change,
4129     REQ_create_mapping,
4130     REQ_open_mapping,
4131     REQ_get_mapping_info,
4132     REQ_create_snapshot,
4133     REQ_next_process,
4134     REQ_next_thread,
4135     REQ_next_module,
4136     REQ_wait_debug_event,
4137     REQ_queue_exception_event,
4138     REQ_get_exception_status,
4139     REQ_output_debug_string,
4140     REQ_continue_debug_event,
4141     REQ_debug_process,
4142     REQ_debug_break,
4143     REQ_set_debugger_kill_on_exit,
4144     REQ_read_process_memory,
4145     REQ_write_process_memory,
4146     REQ_create_key,
4147     REQ_open_key,
4148     REQ_delete_key,
4149     REQ_flush_key,
4150     REQ_enum_key,
4151     REQ_set_key_value,
4152     REQ_get_key_value,
4153     REQ_enum_key_value,
4154     REQ_delete_key_value,
4155     REQ_load_registry,
4156     REQ_unload_registry,
4157     REQ_save_registry,
4158     REQ_set_registry_notification,
4159     REQ_create_timer,
4160     REQ_open_timer,
4161     REQ_set_timer,
4162     REQ_cancel_timer,
4163     REQ_get_timer_info,
4164     REQ_get_thread_context,
4165     REQ_set_thread_context,
4166     REQ_get_selector_entry,
4167     REQ_add_atom,
4168     REQ_delete_atom,
4169     REQ_find_atom,
4170     REQ_get_atom_information,
4171     REQ_set_atom_information,
4172     REQ_empty_atom_table,
4173     REQ_init_atom_table,
4174     REQ_get_msg_queue,
4175     REQ_set_queue_fd,
4176     REQ_set_queue_mask,
4177     REQ_get_queue_status,
4178     REQ_get_process_idle_event,
4179     REQ_send_message,
4180     REQ_post_quit_message,
4181     REQ_send_hardware_message,
4182     REQ_get_message,
4183     REQ_reply_message,
4184     REQ_accept_hardware_message,
4185     REQ_get_message_reply,
4186     REQ_set_win_timer,
4187     REQ_kill_win_timer,
4188     REQ_get_serial_info,
4189     REQ_set_serial_info,
4190     REQ_register_async,
4191     REQ_cancel_async,
4192     REQ_ioctl,
4193     REQ_get_ioctl_result,
4194     REQ_create_named_pipe,
4195     REQ_get_named_pipe_info,
4196     REQ_create_window,
4197     REQ_destroy_window,
4198     REQ_get_desktop_window,
4199     REQ_set_window_owner,
4200     REQ_get_window_info,
4201     REQ_set_window_info,
4202     REQ_set_parent,
4203     REQ_get_window_parents,
4204     REQ_get_window_children,
4205     REQ_get_window_children_from_point,
4206     REQ_get_window_tree,
4207     REQ_set_window_pos,
4208     REQ_get_window_rectangles,
4209     REQ_get_window_text,
4210     REQ_set_window_text,
4211     REQ_get_windows_offset,
4212     REQ_get_visible_region,
4213     REQ_get_window_region,
4214     REQ_set_window_region,
4215     REQ_get_update_region,
4216     REQ_update_window_zorder,
4217     REQ_redraw_window,
4218     REQ_set_window_property,
4219     REQ_remove_window_property,
4220     REQ_get_window_property,
4221     REQ_get_window_properties,
4222     REQ_create_winstation,
4223     REQ_open_winstation,
4224     REQ_close_winstation,
4225     REQ_get_process_winstation,
4226     REQ_set_process_winstation,
4227     REQ_create_desktop,
4228     REQ_open_desktop,
4229     REQ_close_desktop,
4230     REQ_get_thread_desktop,
4231     REQ_set_thread_desktop,
4232     REQ_set_user_object_info,
4233     REQ_attach_thread_input,
4234     REQ_get_thread_input,
4235     REQ_get_last_input_time,
4236     REQ_get_key_state,
4237     REQ_set_key_state,
4238     REQ_set_foreground_window,
4239     REQ_set_focus_window,
4240     REQ_set_active_window,
4241     REQ_set_capture_window,
4242     REQ_set_caret_window,
4243     REQ_set_caret_info,
4244     REQ_set_hook,
4245     REQ_remove_hook,
4246     REQ_start_hook_chain,
4247     REQ_finish_hook_chain,
4248     REQ_get_hook_info,
4249     REQ_create_class,
4250     REQ_destroy_class,
4251     REQ_set_class_info,
4252     REQ_set_clipboard_info,
4253     REQ_open_token,
4254     REQ_set_global_windows,
4255     REQ_adjust_token_privileges,
4256     REQ_get_token_privileges,
4257     REQ_check_token_privileges,
4258     REQ_duplicate_token,
4259     REQ_access_check,
4260     REQ_get_token_user,
4261     REQ_get_token_groups,
4262     REQ_set_security_object,
4263     REQ_create_mailslot,
4264     REQ_set_mailslot_info,
4265     REQ_create_directory,
4266     REQ_open_directory,
4267     REQ_create_symlink,
4268     REQ_open_symlink,
4269     REQ_query_symlink,
4270     REQ_get_object_info,
4271     REQ_get_token_impersonation_level,
4272     REQ_allocate_locally_unique_id,
4273     REQ_create_device_manager,
4274     REQ_create_device,
4275     REQ_delete_device,
4276     REQ_get_next_device_request,
4277     REQ_make_process_system,
4278     REQ_NB_REQUESTS
4279 };
4280
4281 union generic_request
4282 {
4283     struct request_max_size max_size;
4284     struct request_header request_header;
4285     struct new_process_request new_process_request;
4286     struct get_new_process_info_request get_new_process_info_request;
4287     struct new_thread_request new_thread_request;
4288     struct get_startup_info_request get_startup_info_request;
4289     struct init_process_done_request init_process_done_request;
4290     struct init_thread_request init_thread_request;
4291     struct terminate_process_request terminate_process_request;
4292     struct terminate_thread_request terminate_thread_request;
4293     struct get_process_info_request get_process_info_request;
4294     struct set_process_info_request set_process_info_request;
4295     struct get_thread_info_request get_thread_info_request;
4296     struct set_thread_info_request set_thread_info_request;
4297     struct get_dll_info_request get_dll_info_request;
4298     struct suspend_thread_request suspend_thread_request;
4299     struct resume_thread_request resume_thread_request;
4300     struct load_dll_request load_dll_request;
4301     struct unload_dll_request unload_dll_request;
4302     struct queue_apc_request queue_apc_request;
4303     struct get_apc_result_request get_apc_result_request;
4304     struct close_handle_request close_handle_request;
4305     struct set_handle_info_request set_handle_info_request;
4306     struct dup_handle_request dup_handle_request;
4307     struct open_process_request open_process_request;
4308     struct open_thread_request open_thread_request;
4309     struct select_request select_request;
4310     struct create_event_request create_event_request;
4311     struct event_op_request event_op_request;
4312     struct open_event_request open_event_request;
4313     struct create_mutex_request create_mutex_request;
4314     struct release_mutex_request release_mutex_request;
4315     struct open_mutex_request open_mutex_request;
4316     struct create_semaphore_request create_semaphore_request;
4317     struct release_semaphore_request release_semaphore_request;
4318     struct open_semaphore_request open_semaphore_request;
4319     struct create_file_request create_file_request;
4320     struct open_file_object_request open_file_object_request;
4321     struct alloc_file_handle_request alloc_file_handle_request;
4322     struct get_handle_fd_request get_handle_fd_request;
4323     struct flush_file_request flush_file_request;
4324     struct lock_file_request lock_file_request;
4325     struct unlock_file_request unlock_file_request;
4326     struct create_socket_request create_socket_request;
4327     struct accept_socket_request accept_socket_request;
4328     struct set_socket_event_request set_socket_event_request;
4329     struct get_socket_event_request get_socket_event_request;
4330     struct enable_socket_event_request enable_socket_event_request;
4331     struct set_socket_deferred_request set_socket_deferred_request;
4332     struct alloc_console_request alloc_console_request;
4333     struct free_console_request free_console_request;
4334     struct get_console_renderer_events_request get_console_renderer_events_request;
4335     struct open_console_request open_console_request;
4336     struct get_console_wait_event_request get_console_wait_event_request;
4337     struct get_console_mode_request get_console_mode_request;
4338     struct set_console_mode_request set_console_mode_request;
4339     struct set_console_input_info_request set_console_input_info_request;
4340     struct get_console_input_info_request get_console_input_info_request;
4341     struct append_console_input_history_request append_console_input_history_request;
4342     struct get_console_input_history_request get_console_input_history_request;
4343     struct create_console_output_request create_console_output_request;
4344     struct set_console_output_info_request set_console_output_info_request;
4345     struct get_console_output_info_request get_console_output_info_request;
4346     struct write_console_input_request write_console_input_request;
4347     struct read_console_input_request read_console_input_request;
4348     struct write_console_output_request write_console_output_request;
4349     struct fill_console_output_request fill_console_output_request;
4350     struct read_console_output_request read_console_output_request;
4351     struct move_console_output_request move_console_output_request;
4352     struct send_console_signal_request send_console_signal_request;
4353     struct read_directory_changes_request read_directory_changes_request;
4354     struct read_change_request read_change_request;
4355     struct create_mapping_request create_mapping_request;
4356     struct open_mapping_request open_mapping_request;
4357     struct get_mapping_info_request get_mapping_info_request;
4358     struct create_snapshot_request create_snapshot_request;
4359     struct next_process_request next_process_request;
4360     struct next_thread_request next_thread_request;
4361     struct next_module_request next_module_request;
4362     struct wait_debug_event_request wait_debug_event_request;
4363     struct queue_exception_event_request queue_exception_event_request;
4364     struct get_exception_status_request get_exception_status_request;
4365     struct output_debug_string_request output_debug_string_request;
4366     struct continue_debug_event_request continue_debug_event_request;
4367     struct debug_process_request debug_process_request;
4368     struct debug_break_request debug_break_request;
4369     struct set_debugger_kill_on_exit_request set_debugger_kill_on_exit_request;
4370     struct read_process_memory_request read_process_memory_request;
4371     struct write_process_memory_request write_process_memory_request;
4372     struct create_key_request create_key_request;
4373     struct open_key_request open_key_request;
4374     struct delete_key_request delete_key_request;
4375     struct flush_key_request flush_key_request;
4376     struct enum_key_request enum_key_request;
4377     struct set_key_value_request set_key_value_request;
4378     struct get_key_value_request get_key_value_request;
4379     struct enum_key_value_request enum_key_value_request;
4380     struct delete_key_value_request delete_key_value_request;
4381     struct load_registry_request load_registry_request;
4382     struct unload_registry_request unload_registry_request;
4383     struct save_registry_request save_registry_request;
4384     struct set_registry_notification_request set_registry_notification_request;
4385     struct create_timer_request create_timer_request;
4386     struct open_timer_request open_timer_request;
4387     struct set_timer_request set_timer_request;
4388     struct cancel_timer_request cancel_timer_request;
4389     struct get_timer_info_request get_timer_info_request;
4390     struct get_thread_context_request get_thread_context_request;
4391     struct set_thread_context_request set_thread_context_request;
4392     struct get_selector_entry_request get_selector_entry_request;
4393     struct add_atom_request add_atom_request;
4394     struct delete_atom_request delete_atom_request;
4395     struct find_atom_request find_atom_request;
4396     struct get_atom_information_request get_atom_information_request;
4397     struct set_atom_information_request set_atom_information_request;
4398     struct empty_atom_table_request empty_atom_table_request;
4399     struct init_atom_table_request init_atom_table_request;
4400     struct get_msg_queue_request get_msg_queue_request;
4401     struct set_queue_fd_request set_queue_fd_request;
4402     struct set_queue_mask_request set_queue_mask_request;
4403     struct get_queue_status_request get_queue_status_request;
4404     struct get_process_idle_event_request get_process_idle_event_request;
4405     struct send_message_request send_message_request;
4406     struct post_quit_message_request post_quit_message_request;
4407     struct send_hardware_message_request send_hardware_message_request;
4408     struct get_message_request get_message_request;
4409     struct reply_message_request reply_message_request;
4410     struct accept_hardware_message_request accept_hardware_message_request;
4411     struct get_message_reply_request get_message_reply_request;
4412     struct set_win_timer_request set_win_timer_request;
4413     struct kill_win_timer_request kill_win_timer_request;
4414     struct get_serial_info_request get_serial_info_request;
4415     struct set_serial_info_request set_serial_info_request;
4416     struct register_async_request register_async_request;
4417     struct cancel_async_request cancel_async_request;
4418     struct ioctl_request ioctl_request;
4419     struct get_ioctl_result_request get_ioctl_result_request;
4420     struct create_named_pipe_request create_named_pipe_request;
4421     struct get_named_pipe_info_request get_named_pipe_info_request;
4422     struct create_window_request create_window_request;
4423     struct destroy_window_request destroy_window_request;
4424     struct get_desktop_window_request get_desktop_window_request;
4425     struct set_window_owner_request set_window_owner_request;
4426     struct get_window_info_request get_window_info_request;
4427     struct set_window_info_request set_window_info_request;
4428     struct set_parent_request set_parent_request;
4429     struct get_window_parents_request get_window_parents_request;
4430     struct get_window_children_request get_window_children_request;
4431     struct get_window_children_from_point_request get_window_children_from_point_request;
4432     struct get_window_tree_request get_window_tree_request;
4433     struct set_window_pos_request set_window_pos_request;
4434     struct get_window_rectangles_request get_window_rectangles_request;
4435     struct get_window_text_request get_window_text_request;
4436     struct set_window_text_request set_window_text_request;
4437     struct get_windows_offset_request get_windows_offset_request;
4438     struct get_visible_region_request get_visible_region_request;
4439     struct get_window_region_request get_window_region_request;
4440     struct set_window_region_request set_window_region_request;
4441     struct get_update_region_request get_update_region_request;
4442     struct update_window_zorder_request update_window_zorder_request;
4443     struct redraw_window_request redraw_window_request;
4444     struct set_window_property_request set_window_property_request;
4445     struct remove_window_property_request remove_window_property_request;
4446     struct get_window_property_request get_window_property_request;
4447     struct get_window_properties_request get_window_properties_request;
4448     struct create_winstation_request create_winstation_request;
4449     struct open_winstation_request open_winstation_request;
4450     struct close_winstation_request close_winstation_request;
4451     struct get_process_winstation_request get_process_winstation_request;
4452     struct set_process_winstation_request set_process_winstation_request;
4453     struct create_desktop_request create_desktop_request;
4454     struct open_desktop_request open_desktop_request;
4455     struct close_desktop_request close_desktop_request;
4456     struct get_thread_desktop_request get_thread_desktop_request;
4457     struct set_thread_desktop_request set_thread_desktop_request;
4458     struct set_user_object_info_request set_user_object_info_request;
4459     struct attach_thread_input_request attach_thread_input_request;
4460     struct get_thread_input_request get_thread_input_request;
4461     struct get_last_input_time_request get_last_input_time_request;
4462     struct get_key_state_request get_key_state_request;
4463     struct set_key_state_request set_key_state_request;
4464     struct set_foreground_window_request set_foreground_window_request;
4465     struct set_focus_window_request set_focus_window_request;
4466     struct set_active_window_request set_active_window_request;
4467     struct set_capture_window_request set_capture_window_request;
4468     struct set_caret_window_request set_caret_window_request;
4469     struct set_caret_info_request set_caret_info_request;
4470     struct set_hook_request set_hook_request;
4471     struct remove_hook_request remove_hook_request;
4472     struct start_hook_chain_request start_hook_chain_request;
4473     struct finish_hook_chain_request finish_hook_chain_request;
4474     struct get_hook_info_request get_hook_info_request;
4475     struct create_class_request create_class_request;
4476     struct destroy_class_request destroy_class_request;
4477     struct set_class_info_request set_class_info_request;
4478     struct set_clipboard_info_request set_clipboard_info_request;
4479     struct open_token_request open_token_request;
4480     struct set_global_windows_request set_global_windows_request;
4481     struct adjust_token_privileges_request adjust_token_privileges_request;
4482     struct get_token_privileges_request get_token_privileges_request;
4483     struct check_token_privileges_request check_token_privileges_request;
4484     struct duplicate_token_request duplicate_token_request;
4485     struct access_check_request access_check_request;
4486     struct get_token_user_request get_token_user_request;
4487     struct get_token_groups_request get_token_groups_request;
4488     struct set_security_object_request set_security_object_request;
4489     struct create_mailslot_request create_mailslot_request;
4490     struct set_mailslot_info_request set_mailslot_info_request;
4491     struct create_directory_request create_directory_request;
4492     struct open_directory_request open_directory_request;
4493     struct create_symlink_request create_symlink_request;
4494     struct open_symlink_request open_symlink_request;
4495     struct query_symlink_request query_symlink_request;
4496     struct get_object_info_request get_object_info_request;
4497     struct get_token_impersonation_level_request get_token_impersonation_level_request;
4498     struct allocate_locally_unique_id_request allocate_locally_unique_id_request;
4499     struct create_device_manager_request create_device_manager_request;
4500     struct create_device_request create_device_request;
4501     struct delete_device_request delete_device_request;
4502     struct get_next_device_request_request get_next_device_request_request;
4503     struct make_process_system_request make_process_system_request;
4504 };
4505 union generic_reply
4506 {
4507     struct request_max_size max_size;
4508     struct reply_header reply_header;
4509     struct new_process_reply new_process_reply;
4510     struct get_new_process_info_reply get_new_process_info_reply;
4511     struct new_thread_reply new_thread_reply;
4512     struct get_startup_info_reply get_startup_info_reply;
4513     struct init_process_done_reply init_process_done_reply;
4514     struct init_thread_reply init_thread_reply;
4515     struct terminate_process_reply terminate_process_reply;
4516     struct terminate_thread_reply terminate_thread_reply;
4517     struct get_process_info_reply get_process_info_reply;
4518     struct set_process_info_reply set_process_info_reply;
4519     struct get_thread_info_reply get_thread_info_reply;
4520     struct set_thread_info_reply set_thread_info_reply;
4521     struct get_dll_info_reply get_dll_info_reply;
4522     struct suspend_thread_reply suspend_thread_reply;
4523     struct resume_thread_reply resume_thread_reply;
4524     struct load_dll_reply load_dll_reply;
4525     struct unload_dll_reply unload_dll_reply;
4526     struct queue_apc_reply queue_apc_reply;
4527     struct get_apc_result_reply get_apc_result_reply;
4528     struct close_handle_reply close_handle_reply;
4529     struct set_handle_info_reply set_handle_info_reply;
4530     struct dup_handle_reply dup_handle_reply;
4531     struct open_process_reply open_process_reply;
4532     struct open_thread_reply open_thread_reply;
4533     struct select_reply select_reply;
4534     struct create_event_reply create_event_reply;
4535     struct event_op_reply event_op_reply;
4536     struct open_event_reply open_event_reply;
4537     struct create_mutex_reply create_mutex_reply;
4538     struct release_mutex_reply release_mutex_reply;
4539     struct open_mutex_reply open_mutex_reply;
4540     struct create_semaphore_reply create_semaphore_reply;
4541     struct release_semaphore_reply release_semaphore_reply;
4542     struct open_semaphore_reply open_semaphore_reply;
4543     struct create_file_reply create_file_reply;
4544     struct open_file_object_reply open_file_object_reply;
4545     struct alloc_file_handle_reply alloc_file_handle_reply;
4546     struct get_handle_fd_reply get_handle_fd_reply;
4547     struct flush_file_reply flush_file_reply;
4548     struct lock_file_reply lock_file_reply;
4549     struct unlock_file_reply unlock_file_reply;
4550     struct create_socket_reply create_socket_reply;
4551     struct accept_socket_reply accept_socket_reply;
4552     struct set_socket_event_reply set_socket_event_reply;
4553     struct get_socket_event_reply get_socket_event_reply;
4554     struct enable_socket_event_reply enable_socket_event_reply;
4555     struct set_socket_deferred_reply set_socket_deferred_reply;
4556     struct alloc_console_reply alloc_console_reply;
4557     struct free_console_reply free_console_reply;
4558     struct get_console_renderer_events_reply get_console_renderer_events_reply;
4559     struct open_console_reply open_console_reply;
4560     struct get_console_wait_event_reply get_console_wait_event_reply;
4561     struct get_console_mode_reply get_console_mode_reply;
4562     struct set_console_mode_reply set_console_mode_reply;
4563     struct set_console_input_info_reply set_console_input_info_reply;
4564     struct get_console_input_info_reply get_console_input_info_reply;
4565     struct append_console_input_history_reply append_console_input_history_reply;
4566     struct get_console_input_history_reply get_console_input_history_reply;
4567     struct create_console_output_reply create_console_output_reply;
4568     struct set_console_output_info_reply set_console_output_info_reply;
4569     struct get_console_output_info_reply get_console_output_info_reply;
4570     struct write_console_input_reply write_console_input_reply;
4571     struct read_console_input_reply read_console_input_reply;
4572     struct write_console_output_reply write_console_output_reply;
4573     struct fill_console_output_reply fill_console_output_reply;
4574     struct read_console_output_reply read_console_output_reply;
4575     struct move_console_output_reply move_console_output_reply;
4576     struct send_console_signal_reply send_console_signal_reply;
4577     struct read_directory_changes_reply read_directory_changes_reply;
4578     struct read_change_reply read_change_reply;
4579     struct create_mapping_reply create_mapping_reply;
4580     struct open_mapping_reply open_mapping_reply;
4581     struct get_mapping_info_reply get_mapping_info_reply;
4582     struct create_snapshot_reply create_snapshot_reply;
4583     struct next_process_reply next_process_reply;
4584     struct next_thread_reply next_thread_reply;
4585     struct next_module_reply next_module_reply;
4586     struct wait_debug_event_reply wait_debug_event_reply;
4587     struct queue_exception_event_reply queue_exception_event_reply;
4588     struct get_exception_status_reply get_exception_status_reply;
4589     struct output_debug_string_reply output_debug_string_reply;
4590     struct continue_debug_event_reply continue_debug_event_reply;
4591     struct debug_process_reply debug_process_reply;
4592     struct debug_break_reply debug_break_reply;
4593     struct set_debugger_kill_on_exit_reply set_debugger_kill_on_exit_reply;
4594     struct read_process_memory_reply read_process_memory_reply;
4595     struct write_process_memory_reply write_process_memory_reply;
4596     struct create_key_reply create_key_reply;
4597     struct open_key_reply open_key_reply;
4598     struct delete_key_reply delete_key_reply;
4599     struct flush_key_reply flush_key_reply;
4600     struct enum_key_reply enum_key_reply;
4601     struct set_key_value_reply set_key_value_reply;
4602     struct get_key_value_reply get_key_value_reply;
4603     struct enum_key_value_reply enum_key_value_reply;
4604     struct delete_key_value_reply delete_key_value_reply;
4605     struct load_registry_reply load_registry_reply;
4606     struct unload_registry_reply unload_registry_reply;
4607     struct save_registry_reply save_registry_reply;
4608     struct set_registry_notification_reply set_registry_notification_reply;
4609     struct create_timer_reply create_timer_reply;
4610     struct open_timer_reply open_timer_reply;
4611     struct set_timer_reply set_timer_reply;
4612     struct cancel_timer_reply cancel_timer_reply;
4613     struct get_timer_info_reply get_timer_info_reply;
4614     struct get_thread_context_reply get_thread_context_reply;
4615     struct set_thread_context_reply set_thread_context_reply;
4616     struct get_selector_entry_reply get_selector_entry_reply;
4617     struct add_atom_reply add_atom_reply;
4618     struct delete_atom_reply delete_atom_reply;
4619     struct find_atom_reply find_atom_reply;
4620     struct get_atom_information_reply get_atom_information_reply;
4621     struct set_atom_information_reply set_atom_information_reply;
4622     struct empty_atom_table_reply empty_atom_table_reply;
4623     struct init_atom_table_reply init_atom_table_reply;
4624     struct get_msg_queue_reply get_msg_queue_reply;
4625     struct set_queue_fd_reply set_queue_fd_reply;
4626     struct set_queue_mask_reply set_queue_mask_reply;
4627     struct get_queue_status_reply get_queue_status_reply;
4628     struct get_process_idle_event_reply get_process_idle_event_reply;
4629     struct send_message_reply send_message_reply;
4630     struct post_quit_message_reply post_quit_message_reply;
4631     struct send_hardware_message_reply send_hardware_message_reply;
4632     struct get_message_reply get_message_reply;
4633     struct reply_message_reply reply_message_reply;
4634     struct accept_hardware_message_reply accept_hardware_message_reply;
4635     struct get_message_reply_reply get_message_reply_reply;
4636     struct set_win_timer_reply set_win_timer_reply;
4637     struct kill_win_timer_reply kill_win_timer_reply;
4638     struct get_serial_info_reply get_serial_info_reply;
4639     struct set_serial_info_reply set_serial_info_reply;
4640     struct register_async_reply register_async_reply;
4641     struct cancel_async_reply cancel_async_reply;
4642     struct ioctl_reply ioctl_reply;
4643     struct get_ioctl_result_reply get_ioctl_result_reply;
4644     struct create_named_pipe_reply create_named_pipe_reply;
4645     struct get_named_pipe_info_reply get_named_pipe_info_reply;
4646     struct create_window_reply create_window_reply;
4647     struct destroy_window_reply destroy_window_reply;
4648     struct get_desktop_window_reply get_desktop_window_reply;
4649     struct set_window_owner_reply set_window_owner_reply;
4650     struct get_window_info_reply get_window_info_reply;
4651     struct set_window_info_reply set_window_info_reply;
4652     struct set_parent_reply set_parent_reply;
4653     struct get_window_parents_reply get_window_parents_reply;
4654     struct get_window_children_reply get_window_children_reply;
4655     struct get_window_children_from_point_reply get_window_children_from_point_reply;
4656     struct get_window_tree_reply get_window_tree_reply;
4657     struct set_window_pos_reply set_window_pos_reply;
4658     struct get_window_rectangles_reply get_window_rectangles_reply;
4659     struct get_window_text_reply get_window_text_reply;
4660     struct set_window_text_reply set_window_text_reply;
4661     struct get_windows_offset_reply get_windows_offset_reply;
4662     struct get_visible_region_reply get_visible_region_reply;
4663     struct get_window_region_reply get_window_region_reply;
4664     struct set_window_region_reply set_window_region_reply;
4665     struct get_update_region_reply get_update_region_reply;
4666     struct update_window_zorder_reply update_window_zorder_reply;
4667     struct redraw_window_reply redraw_window_reply;
4668     struct set_window_property_reply set_window_property_reply;
4669     struct remove_window_property_reply remove_window_property_reply;
4670     struct get_window_property_reply get_window_property_reply;
4671     struct get_window_properties_reply get_window_properties_reply;
4672     struct create_winstation_reply create_winstation_reply;
4673     struct open_winstation_reply open_winstation_reply;
4674     struct close_winstation_reply close_winstation_reply;
4675     struct get_process_winstation_reply get_process_winstation_reply;
4676     struct set_process_winstation_reply set_process_winstation_reply;
4677     struct create_desktop_reply create_desktop_reply;
4678     struct open_desktop_reply open_desktop_reply;
4679     struct close_desktop_reply close_desktop_reply;
4680     struct get_thread_desktop_reply get_thread_desktop_reply;
4681     struct set_thread_desktop_reply set_thread_desktop_reply;
4682     struct set_user_object_info_reply set_user_object_info_reply;
4683     struct attach_thread_input_reply attach_thread_input_reply;
4684     struct get_thread_input_reply get_thread_input_reply;
4685     struct get_last_input_time_reply get_last_input_time_reply;
4686     struct get_key_state_reply get_key_state_reply;
4687     struct set_key_state_reply set_key_state_reply;
4688     struct set_foreground_window_reply set_foreground_window_reply;
4689     struct set_focus_window_reply set_focus_window_reply;
4690     struct set_active_window_reply set_active_window_reply;
4691     struct set_capture_window_reply set_capture_window_reply;
4692     struct set_caret_window_reply set_caret_window_reply;
4693     struct set_caret_info_reply set_caret_info_reply;
4694     struct set_hook_reply set_hook_reply;
4695     struct remove_hook_reply remove_hook_reply;
4696     struct start_hook_chain_reply start_hook_chain_reply;
4697     struct finish_hook_chain_reply finish_hook_chain_reply;
4698     struct get_hook_info_reply get_hook_info_reply;
4699     struct create_class_reply create_class_reply;
4700     struct destroy_class_reply destroy_class_reply;
4701     struct set_class_info_reply set_class_info_reply;
4702     struct set_clipboard_info_reply set_clipboard_info_reply;
4703     struct open_token_reply open_token_reply;
4704     struct set_global_windows_reply set_global_windows_reply;
4705     struct adjust_token_privileges_reply adjust_token_privileges_reply;
4706     struct get_token_privileges_reply get_token_privileges_reply;
4707     struct check_token_privileges_reply check_token_privileges_reply;
4708     struct duplicate_token_reply duplicate_token_reply;
4709     struct access_check_reply access_check_reply;
4710     struct get_token_user_reply get_token_user_reply;
4711     struct get_token_groups_reply get_token_groups_reply;
4712     struct set_security_object_reply set_security_object_reply;
4713     struct create_mailslot_reply create_mailslot_reply;
4714     struct set_mailslot_info_reply set_mailslot_info_reply;
4715     struct create_directory_reply create_directory_reply;
4716     struct open_directory_reply open_directory_reply;
4717     struct create_symlink_reply create_symlink_reply;
4718     struct open_symlink_reply open_symlink_reply;
4719     struct query_symlink_reply query_symlink_reply;
4720     struct get_object_info_reply get_object_info_reply;
4721     struct get_token_impersonation_level_reply get_token_impersonation_level_reply;
4722     struct allocate_locally_unique_id_reply allocate_locally_unique_id_reply;
4723     struct create_device_manager_reply create_device_manager_reply;
4724     struct create_device_reply create_device_reply;
4725     struct delete_device_reply delete_device_reply;
4726     struct get_next_device_request_reply get_next_device_request_reply;
4727     struct make_process_system_reply make_process_system_reply;
4728 };
4729
4730 #define SERVER_PROTOCOL_VERSION 307
4731
4732 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */