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