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