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

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