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 <stdlib.h>
  12 #include <time.h>
  13 #include "winbase.h"
  14
  15 struct request_header
  16 {
  17     int            req;
  18     unsigned short var_offset;
  19     unsigned short var_size;
  20     unsigned int   error;
  21 };
  22
  23 struct reply_header
  24 {
  25     unsigned int   error;
  26     unsigned short var_offset;
  27     unsigned short var_size;
  28 };
  29
  30
  31
  32 struct request_max_size
  33 {
  34     int pad[16];
  35 };
  36
  37
  38 #define REQUEST_MAX_VAR_SIZE  1024
  39
  40 typedef int handle_t;
  41
  42
  43 struct debug_event_exception
  44 {
  45     EXCEPTION_RECORD record;
  46     int              first;
  47 };
  48 struct debug_event_create_thread
  49 {
  50     handle_t    handle;
  51     void       *teb;
  52     void       *start;
  53 };
  54 struct debug_event_create_process
  55 {
  56     handle_t    file;
  57     handle_t    process;
  58     handle_t    thread;
  59     void       *base;
  60     int         dbg_offset;
  61     int         dbg_size;
  62     void       *teb;
  63     void       *start;
  64     void       *name;
  65     int         unicode;
  66 };
  67 struct debug_event_exit
  68 {
  69     int         exit_code;
  70 };
  71 struct debug_event_load_dll
  72 {
  73     handle_t    handle;
  74     void       *base;
  75     int         dbg_offset;
  76     int         dbg_size;
  77     void       *name;
  78     int         unicode;
  79 };
  80 struct debug_event_unload_dll
  81 {
  82     void       *base;
  83 };
  84 struct debug_event_output_string
  85 {
  86     void       *string;
  87     int         unicode;
  88     int         length;
  89 };
  90 struct debug_event_rip_info
  91 {
  92     int         error;
  93     int         type;
  94 };
  95 union debug_event_data
  96 {
  97     struct debug_event_exception      exception;
  98     struct debug_event_create_thread  create_thread;
  99     struct debug_event_create_process create_process;
 100     struct debug_event_exit           exit;
 101     struct debug_event_load_dll       load_dll;
 102     struct debug_event_unload_dll     unload_dll;
 103     struct debug_event_output_string  output_string;
 104     struct debug_event_rip_info       rip_info;
 105 };
 106
 107
 108 typedef struct
 109 {
 110     int                      code;
 111     union debug_event_data   info;
 112 } debug_event_t;
 113
 114
 115 struct send_fd
 116 {
 117     void  *tid;
 118     int    fd;
 119 };
 120
 121
 122 struct wake_up_reply
 123 {
 124     void *cookie;
 125     int   signaled;
 126 };
 127
 128
 129
 130
 131
 132 struct new_process_request
 133 {
 134     struct request_header __header;
 135     int          inherit_all;
 136     int          create_flags;
 137     int          start_flags;
 138     handle_t     exe_file;
 139     handle_t     hstdin;
 140     handle_t     hstdout;
 141     handle_t     hstderr;
 142     int          cmd_show;
 143     /* VARARG(filename,string); */
 144     handle_t     info;
 145 };
 146
 147
 148
 149 struct get_new_process_info_request
 150 {
 151     struct request_header __header;
 152     handle_t     info;
 153     int          pinherit;
 154     int          tinherit;
 155     void*        pid;
 156     handle_t     phandle;
 157     void*        tid;
 158     handle_t     thandle;
 159     handle_t     event;
 160 };
 161
 162
 163
 164 struct new_thread_request
 165 {
 166     struct request_header __header;
 167     int          suspend;
 168     int          inherit;
 169     int          request_fd;
 170     void*        tid;
 171     handle_t     handle;
 172 };
 173
 174
 175
 176 struct boot_done_request
 177 {
 178     struct request_header __header;
 179     int          debug_level;
 180 };
 181
 182
 183
 184 struct init_process_request
 185 {
 186     struct request_header __header;
 187     void*        ldt_copy;
 188     int          ppid;
 189     int          create_flags;
 190     int          start_flags;
 191     unsigned int server_start;
 192     handle_t     exe_file;
 193     handle_t     hstdin;
 194     handle_t     hstdout;
 195     handle_t     hstderr;
 196     int          cmd_show;
 197     /* VARARG(filename,string); */
 198 };
 199
 200
 201
 202 struct init_process_done_request
 203 {
 204     struct request_header __header;
 205     void*        module;
 206     void*        entry;
 207     void*        name;
 208     handle_t     exe_file;
 209     int          gui;
 210     int          debugged;
 211 };
 212
 213
 214
 215 struct init_thread_request
 216 {
 217     struct request_header __header;
 218     int          unix_pid;
 219     void*        teb;
 220     void*        entry;
 221     int          reply_fd;
 222     int          wait_fd;
 223     void*        pid;
 224     void*        tid;
 225     int          boot;
 226     int          version;
 227 };
 228
 229
 230
 231 struct set_thread_buffer_request
 232 {
 233     struct request_header __header;
 234     int          fd;
 235     unsigned int offset;
 236     unsigned int size;
 237 };
 238
 239
 240
 241 struct terminate_process_request
 242 {
 243     struct request_header __header;
 244     handle_t     handle;
 245     int          exit_code;
 246     int          self;
 247 };
 248
 249
 250
 251 struct terminate_thread_request
 252 {
 253     struct request_header __header;
 254     handle_t     handle;
 255     int          exit_code;
 256     int          self;
 257     int          last;
 258 };
 259
 260
 261
 262 struct get_process_info_request
 263 {
 264     struct request_header __header;
 265     handle_t     handle;
 266     void*        pid;
 267     int          debugged;
 268     int          exit_code;
 269     int          priority;
 270     int          process_affinity;
 271     int          system_affinity;
 272 };
 273
 274
 275
 276 struct set_process_info_request
 277 {
 278     struct request_header __header;
 279     handle_t     handle;
 280     int          mask;
 281     int          priority;
 282     int          affinity;
 283 };
 284 #define SET_PROCESS_INFO_PRIORITY 0x01
 285 #define SET_PROCESS_INFO_AFFINITY 0x02
 286
 287
 288
 289 struct get_thread_info_request
 290 {
 291     struct request_header __header;
 292     handle_t     handle;
 293     void*        tid_in;
 294     void*        tid;
 295     void*        teb;
 296     int          exit_code;
 297     int          priority;
 298 };
 299
 300
 301
 302 struct set_thread_info_request
 303 {
 304     struct request_header __header;
 305     handle_t     handle;
 306     int          mask;
 307     int          priority;
 308     int          affinity;
 309 };
 310 #define SET_THREAD_INFO_PRIORITY 0x01
 311 #define SET_THREAD_INFO_AFFINITY 0x02
 312
 313
 314
 315 struct suspend_thread_request
 316 {
 317     struct request_header __header;
 318     handle_t     handle;
 319     int          count;
 320 };
 321
 322
 323
 324 struct resume_thread_request
 325 {
 326     struct request_header __header;
 327     handle_t     handle;
 328     int          count;
 329 };
 330
 331
 332
 333 struct load_dll_request
 334 {
 335     struct request_header __header;
 336     handle_t     handle;
 337     void*        base;
 338     int          dbg_offset;
 339     int          dbg_size;
 340     void*        name;
 341 };
 342
 343
 344
 345 struct unload_dll_request
 346 {
 347     struct request_header __header;
 348     void*        base;
 349 };
 350
 351
 352
 353 struct queue_apc_request
 354 {
 355     struct request_header __header;
 356     handle_t     handle;
 357     int          user;
 358     void*        func;
 359     void*        param;
 360 };
 361
 362
 363
 364 struct get_apc_request
 365 {
 366     struct request_header __header;
 367     int          alertable;
 368     void*        func;
 369     int          type;
 370     /* VARARG(args,ptrs); */
 371 };
 372 enum apc_type { APC_NONE, APC_USER, APC_TIMER, APC_ASYNC };
 373
 374
 375
 376 struct close_handle_request
 377 {
 378     struct request_header __header;
 379     handle_t     handle;
 380     int          fd;
 381 };
 382
 383
 384
 385 struct set_handle_info_request
 386 {
 387     struct request_header __header;
 388     handle_t     handle;
 389     int          flags;
 390     int          mask;
 391     int          fd;
 392     int          old_flags;
 393     int          cur_fd;
 394 };
 395
 396
 397
 398 struct dup_handle_request
 399 {
 400     struct request_header __header;
 401     handle_t     src_process;
 402     handle_t     src_handle;
 403     handle_t     dst_process;
 404     unsigned int access;
 405     int          inherit;
 406     int          options;
 407     handle_t     handle;
 408     int          fd;
 409 };
 410 #define DUP_HANDLE_CLOSE_SOURCE  DUPLICATE_CLOSE_SOURCE
 411 #define DUP_HANDLE_SAME_ACCESS   DUPLICATE_SAME_ACCESS
 412 #define DUP_HANDLE_MAKE_GLOBAL   0x80000000
 413
 414
 415
 416 struct open_process_request
 417 {
 418     struct request_header __header;
 419     void*        pid;
 420     unsigned int access;
 421     int          inherit;
 422     handle_t     handle;
 423 };
 424
 425
 426
 427 struct select_request
 428 {
 429     struct request_header __header;
 430     int          flags;
 431     void*        cookie;
 432     int          sec;
 433     int          usec;
 434     /* VARARG(handles,handles); */
 435 };
 436 #define SELECT_ALL           1
 437 #define SELECT_ALERTABLE     2
 438 #define SELECT_INTERRUPTIBLE 4
 439 #define SELECT_TIMEOUT       8
 440
 441
 442
 443 struct create_event_request
 444 {
 445     struct request_header __header;
 446     int          manual_reset;
 447     int          initial_state;
 448     int          inherit;
 449     /* VARARG(name,unicode_str); */
 450     handle_t     handle;
 451 };
 452
 453
 454 struct event_op_request
 455 {
 456     struct request_header __header;
 457     handle_t      handle;
 458     int           op;
 459 };
 460 enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT };
 461
 462
 463
 464 struct open_event_request
 465 {
 466     struct request_header __header;
 467     unsigned int access;
 468     int          inherit;
 469     /* VARARG(name,unicode_str); */
 470     handle_t     handle;
 471 };
 472
 473
 474
 475 struct create_mutex_request
 476 {
 477     struct request_header __header;
 478     int          owned;
 479     int          inherit;
 480     /* VARARG(name,unicode_str); */
 481     handle_t     handle;
 482 };
 483
 484
 485
 486 struct release_mutex_request
 487 {
 488     struct request_header __header;
 489     handle_t     handle;
 490 };
 491
 492
 493
 494 struct open_mutex_request
 495 {
 496     struct request_header __header;
 497     unsigned int access;
 498     int          inherit;
 499     /* VARARG(name,unicode_str); */
 500     handle_t     handle;
 501 };
 502
 503
 504
 505 struct create_semaphore_request
 506 {
 507     struct request_header __header;
 508     unsigned int initial;
 509     unsigned int max;
 510     int          inherit;
 511     /* VARARG(name,unicode_str); */
 512     handle_t     handle;
 513 };
 514
 515
 516
 517 struct release_semaphore_request
 518 {
 519     struct request_header __header;
 520     handle_t     handle;
 521     unsigned int count;
 522     unsigned int prev_count;
 523 };
 524
 525
 526
 527 struct open_semaphore_request
 528 {
 529     struct request_header __header;
 530     unsigned int access;
 531     int          inherit;
 532     /* VARARG(name,unicode_str); */
 533     handle_t     handle;
 534 };
 535
 536
 537
 538 struct create_file_request
 539 {
 540     struct request_header __header;
 541     unsigned int access;
 542     int          inherit;
 543     unsigned int sharing;
 544     int          create;
 545     unsigned int attrs;
 546     /* VARARG(filename,string); */
 547     handle_t     handle;
 548 };
 549
 550
 551
 552 struct alloc_file_handle_request
 553 {
 554     struct request_header __header;
 555     unsigned int access;
 556     int          fd;
 557     handle_t     handle;
 558 };
 559
 560
 561
 562 struct get_handle_fd_request
 563 {
 564     struct request_header __header;
 565     handle_t     handle;
 566     unsigned int access;
 567     int          fd;
 568 };
 569
 570
 571
 572 struct set_file_pointer_request
 573 {
 574     struct request_header __header;
 575     handle_t     handle;
 576     int          low;
 577     int          high;
 578     int          whence;
 579     int          new_low;
 580     int          new_high;
 581 };
 582
 583
 584
 585 struct truncate_file_request
 586 {
 587     struct request_header __header;
 588     handle_t     handle;
 589 };
 590
 591
 592
 593 struct set_file_time_request
 594 {
 595     struct request_header __header;
 596     handle_t     handle;
 597     time_t       access_time;
 598     time_t       write_time;
 599 };
 600
 601
 602
 603 struct flush_file_request
 604 {
 605     struct request_header __header;
 606     handle_t     handle;
 607 };
 608
 609
 610
 611 struct get_file_info_request
 612 {
 613     struct request_header __header;
 614     handle_t     handle;
 615     int          type;
 616     int          attr;
 617     time_t       access_time;
 618     time_t       write_time;
 619     int          size_high;
 620     int          size_low;
 621     int          links;
 622     int          index_high;
 623     int          index_low;
 624     unsigned int serial;
 625 };
 626
 627
 628
 629 struct lock_file_request
 630 {
 631     struct request_header __header;
 632     handle_t     handle;
 633     unsigned int offset_low;
 634     unsigned int offset_high;
 635     unsigned int count_low;
 636     unsigned int count_high;
 637 };
 638
 639
 640
 641 struct unlock_file_request
 642 {
 643     struct request_header __header;
 644     handle_t     handle;
 645     unsigned int offset_low;
 646     unsigned int offset_high;
 647     unsigned int count_low;
 648     unsigned int count_high;
 649 };
 650
 651
 652
 653 struct create_pipe_request
 654 {
 655     struct request_header __header;
 656     int          inherit;
 657     handle_t     handle_read;
 658     handle_t     handle_write;
 659 };
 660
 661
 662
 663 struct create_socket_request
 664 {
 665     struct request_header __header;
 666     unsigned int access;
 667     int          inherit;
 668     int          family;
 669     int          type;
 670     int          protocol;
 671     handle_t     handle;
 672 };
 673
 674
 675
 676 struct accept_socket_request
 677 {
 678     struct request_header __header;
 679     handle_t     lhandle;
 680     unsigned int access;
 681     int          inherit;
 682     handle_t     handle;
 683 };
 684
 685
 686
 687 struct set_socket_event_request
 688 {
 689     struct request_header __header;
 690     handle_t     handle;
 691     unsigned int mask;
 692     handle_t     event;
 693 };
 694
 695
 696
 697 struct get_socket_event_request
 698 {
 699     struct request_header __header;
 700     handle_t     handle;
 701     int          service;
 702     handle_t     s_event;
 703     handle_t     c_event;
 704     unsigned int mask;
 705     unsigned int pmask;
 706     unsigned int state;
 707     /* VARARG(errors,ints); */
 708 };
 709
 710
 711
 712 struct enable_socket_event_request
 713 {
 714     struct request_header __header;
 715     handle_t     handle;
 716     unsigned int mask;
 717     unsigned int sstate;
 718     unsigned int cstate;
 719 };
 720
 721
 722
 723 struct alloc_console_request
 724 {
 725     struct request_header __header;
 726     unsigned int access;
 727     int          inherit;
 728     handle_t     handle_in;
 729     handle_t     handle_out;
 730 };
 731
 732
 733
 734 struct free_console_request
 735 {
 736     struct request_header __header;
 737 };
 738
 739
 740
 741 struct open_console_request
 742 {
 743     struct request_header __header;
 744     int          output;
 745     unsigned int access;
 746     int          inherit;
 747     handle_t     handle;
 748 };
 749
 750
 751
 752 struct set_console_fd_request
 753 {
 754     struct request_header __header;
 755     handle_t     handle;
 756     int          fd_in;
 757     int          fd_out;
 758     int          pid;
 759 };
 760
 761
 762
 763 struct get_console_mode_request
 764 {
 765     struct request_header __header;
 766     handle_t     handle;
 767     int          mode;
 768 };
 769
 770
 771
 772 struct set_console_mode_request
 773 {
 774     struct request_header __header;
 775     handle_t     handle;
 776     int          mode;
 777 };
 778
 779
 780
 781 struct set_console_info_request
 782 {
 783     struct request_header __header;
 784     handle_t     handle;
 785     int          mask;
 786     int          cursor_size;
 787     int          cursor_visible;
 788     /* VARARG(title,string); */
 789 };
 790 #define SET_CONSOLE_INFO_CURSOR 0x01
 791 #define SET_CONSOLE_INFO_TITLE  0x02
 792
 793
 794 struct get_console_info_request
 795 {
 796     struct request_header __header;
 797     handle_t     handle;
 798     int          cursor_size;
 799     int          cursor_visible;
 800     int          pid;
 801     /* VARARG(title,string); */
 802 };
 803
 804
 805
 806 struct write_console_input_request
 807 {
 808     struct request_header __header;
 809     handle_t     handle;
 810     /* VARARG(rec,input_records); */
 811     int          written;
 812 };
 813
 814
 815 struct read_console_input_request
 816 {
 817     struct request_header __header;
 818     handle_t     handle;
 819     int          flush;
 820     int          read;
 821     /* VARARG(rec,input_records); */
 822 };
 823
 824
 825
 826 struct create_change_notification_request
 827 {
 828     struct request_header __header;
 829     int          subtree;
 830     int          filter;
 831     handle_t     handle;
 832 };
 833
 834
 835
 836 struct create_mapping_request
 837 {
 838     struct request_header __header;
 839     int          size_high;
 840     int          size_low;
 841     int          protect;
 842     int          inherit;
 843     handle_t     file_handle;
 844     /* VARARG(name,unicode_str); */
 845     handle_t     handle;
 846 };
 847
 848 #define VPROT_READ       0x01
 849 #define VPROT_WRITE      0x02
 850 #define VPROT_EXEC       0x04
 851 #define VPROT_WRITECOPY  0x08
 852 #define VPROT_GUARD      0x10
 853 #define VPROT_NOCACHE    0x20
 854 #define VPROT_COMMITTED  0x40
 855 #define VPROT_IMAGE      0x80
 856
 857
 858
 859 struct open_mapping_request
 860 {
 861     struct request_header __header;
 862     unsigned int access;
 863     int          inherit;
 864     /* VARARG(name,unicode_str); */
 865     handle_t     handle;
 866 };
 867
 868
 869
 870 struct get_mapping_info_request
 871 {
 872     struct request_header __header;
 873     handle_t     handle;
 874     int          size_high;
 875     int          size_low;
 876     int          protect;
 877     int          header_size;
 878     void*        base;
 879     handle_t     shared_file;
 880     int          shared_size;
 881 };
 882
 883
 884
 885 struct create_device_request
 886 {
 887     struct request_header __header;
 888     unsigned int access;
 889     int          inherit;
 890     int          id;
 891     handle_t     handle;
 892 };
 893
 894
 895
 896 struct create_snapshot_request
 897 {
 898     struct request_header __header;
 899     int          inherit;
 900     int          flags;
 901     void*        pid;
 902     handle_t     handle;
 903 };
 904
 905
 906
 907 struct next_process_request
 908 {
 909     struct request_header __header;
 910     handle_t     handle;
 911     int          reset;
 912     int          count;
 913     void*        pid;
 914     int          threads;
 915     int          priority;
 916 };
 917
 918
 919
 920 struct next_thread_request
 921 {
 922     struct request_header __header;
 923     handle_t     handle;
 924     int          reset;
 925     int          count;
 926     void*        pid;
 927     void*        tid;
 928     int          base_pri;
 929     int          delta_pri;
 930 };
 931
 932
 933
 934 struct next_module_request
 935 {
 936     struct request_header __header;
 937     handle_t     handle;
 938     int          reset;
 939     void*        pid;
 940     void*        base;
 941 };
 942
 943
 944
 945 struct wait_debug_event_request
 946 {
 947     struct request_header __header;
 948     int           get_handle;
 949     void*         pid;
 950     void*         tid;
 951     handle_t      wait;
 952     /* VARARG(event,debug_event); */
 953 };
 954
 955
 956
 957 struct queue_exception_event_request
 958 {
 959     struct request_header __header;
 960     int              first;
 961     /* VARARG(record,exc_event); */
 962     handle_t         handle;
 963 };
 964
 965
 966
 967 struct get_exception_status_request
 968 {
 969     struct request_header __header;
 970     handle_t         handle;
 971     int              status;
 972     /* VARARG(context,context); */
 973 };
 974
 975
 976
 977 struct output_debug_string_request
 978 {
 979     struct request_header __header;
 980     void*         string;
 981     int           unicode;
 982     int           length;
 983 };
 984
 985
 986
 987 struct continue_debug_event_request
 988 {
 989     struct request_header __header;
 990     void*        pid;
 991     void*        tid;
 992     int          status;
 993 };
 994
 995
 996
 997 struct debug_process_request
 998 {
 999     struct request_header __header;
1000     void*        pid;
1001 };
1002
1003
1004
1005 struct read_process_memory_request
1006 {
1007     struct request_header __header;
1008     handle_t     handle;
1009     void*        addr;
1010     int          len;
1011     /* VARARG(data,bytes); */
1012 };
1013
1014
1015
1016 struct write_process_memory_request
1017 {
1018     struct request_header __header;
1019     handle_t     handle;
1020     void*        addr;
1021     int          len;
1022     unsigned int first_mask;
1023     unsigned int last_mask;
1024     /* VARARG(data,bytes); */
1025 };
1026
1027
1028
1029 struct create_key_request
1030 {
1031     struct request_header __header;
1032     handle_t     parent;
1033     unsigned int access;
1034     unsigned int options;
1035     time_t       modif;
1036     /* VARARG(name,unicode_len_str); */
1037     /* VARARG(class,unicode_str); */
1038     handle_t     hkey;
1039     int          created;
1040 };
1041
1042
1043 struct open_key_request
1044 {
1045     struct request_header __header;
1046     handle_t     parent;
1047     unsigned int access;
1048     /* VARARG(name,unicode_str); */
1049     handle_t     hkey;
1050 };
1051
1052
1053
1054 struct delete_key_request
1055 {
1056     struct request_header __header;
1057     handle_t     hkey;
1058 };
1059
1060
1061
1062 struct enum_key_request
1063 {
1064     struct request_header __header;
1065     handle_t     hkey;
1066     int          index;
1067     int          full;
1068     int          subkeys;
1069     int          max_subkey;
1070     int          max_class;
1071     int          values;
1072     int          max_value;
1073     int          max_data;
1074     time_t       modif;
1075     /* VARARG(name,unicode_len_str); */
1076     /* VARARG(class,unicode_str); */
1077 };
1078
1079
1080
1081 struct set_key_value_request
1082 {
1083     struct request_header __header;
1084     handle_t     hkey;
1085     int          type;
1086     unsigned int total;
1087     unsigned int offset;
1088     /* VARARG(name,unicode_len_str); */
1089     /* VARARG(data,bytes); */
1090 };
1091
1092
1093
1094 struct get_key_value_request
1095 {
1096     struct request_header __header;
1097     handle_t     hkey;
1098     unsigned int offset;
1099     /* VARARG(name,unicode_len_str); */
1100     int          type;
1101     int          len;
1102     /* VARARG(data,bytes); */
1103 };
1104
1105
1106
1107 struct enum_key_value_request
1108 {
1109     struct request_header __header;
1110     handle_t     hkey;
1111     int          index;
1112     unsigned int offset;
1113     int          type;
1114     int          len;
1115     /* VARARG(name,unicode_len_str); */
1116     /* VARARG(data,bytes); */
1117 };
1118
1119
1120
1121 struct delete_key_value_request
1122 {
1123     struct request_header __header;
1124     handle_t     hkey;
1125     /* VARARG(name,unicode_str); */
1126 };
1127
1128
1129
1130 struct load_registry_request
1131 {
1132     struct request_header __header;
1133     handle_t     hkey;
1134     handle_t     file;
1135     /* VARARG(name,unicode_str); */
1136 };
1137
1138
1139
1140 struct save_registry_request
1141 {
1142     struct request_header __header;
1143     handle_t     hkey;
1144     handle_t     file;
1145 };
1146
1147
1148
1149 struct save_registry_atexit_request
1150 {
1151     struct request_header __header;
1152     handle_t     hkey;
1153     /* VARARG(file,string); */
1154 };
1155
1156
1157
1158 struct set_registry_levels_request
1159 {
1160     struct request_header __header;
1161     int          current;
1162     int          saving;
1163     int          period;
1164 };
1165
1166
1167
1168 struct create_timer_request
1169 {
1170     struct request_header __header;
1171     int          inherit;
1172     int          manual;
1173     /* VARARG(name,unicode_str); */
1174     handle_t     handle;
1175 };
1176
1177
1178
1179 struct open_timer_request
1180 {
1181     struct request_header __header;
1182     unsigned int access;
1183     int          inherit;
1184     /* VARARG(name,unicode_str); */
1185     handle_t     handle;
1186 };
1187
1188
1189 struct set_timer_request
1190 {
1191     struct request_header __header;
1192     handle_t     handle;
1193     int          sec;
1194     int          usec;
1195     int          period;
1196     void*        callback;
1197     void*        arg;
1198 };
1199
1200
1201 struct cancel_timer_request
1202 {
1203     struct request_header __header;
1204     handle_t     handle;
1205 };
1206
1207
1208
1209 struct get_thread_context_request
1210 {
1211     struct request_header __header;
1212     handle_t     handle;
1213     unsigned int flags;
1214     /* VARARG(context,context); */
1215 };
1216
1217
1218
1219 struct set_thread_context_request
1220 {
1221     struct request_header __header;
1222     handle_t     handle;
1223     unsigned int flags;
1224     /* VARARG(context,context); */
1225 };
1226
1227
1228
1229 struct get_selector_entry_request
1230 {
1231     struct request_header __header;
1232     handle_t      handle;
1233     int           entry;
1234     unsigned int  base;
1235     unsigned int  limit;
1236     unsigned char flags;
1237 };
1238
1239
1240
1241 struct add_atom_request
1242 {
1243     struct request_header __header;
1244     int           local;
1245     /* VARARG(name,unicode_str); */
1246     int           atom;
1247 };
1248
1249
1250
1251 struct delete_atom_request
1252 {
1253     struct request_header __header;
1254     int           atom;
1255     int           local;
1256 };
1257
1258
1259
1260 struct find_atom_request
1261 {
1262     struct request_header __header;
1263     int          local;
1264     /* VARARG(name,unicode_str); */
1265     int          atom;
1266 };
1267
1268
1269
1270 struct get_atom_name_request
1271 {
1272     struct request_header __header;
1273     int          atom;
1274     int          local;
1275     int          count;
1276     /* VARARG(name,unicode_str); */
1277 };
1278
1279
1280
1281 struct init_atom_table_request
1282 {
1283     struct request_header __header;
1284     int          entries;
1285 };
1286
1287
1288
1289 struct get_msg_queue_request
1290 {
1291     struct request_header __header;
1292     handle_t     handle;
1293 };
1294
1295
1296
1297 struct inc_queue_paint_count_request
1298 {
1299     struct request_header __header;
1300     void*           id;
1301     int             incr;
1302 };
1303
1304
1305
1306 struct set_queue_mask_request
1307 {
1308     struct request_header __header;
1309     unsigned int wake_mask;
1310     unsigned int changed_mask;
1311     int          skip_wait;
1312     unsigned int wake_bits;
1313     unsigned int changed_bits;
1314 };
1315
1316
1317
1318 struct get_queue_status_request
1319 {
1320     struct request_header __header;
1321     int          clear;
1322     unsigned int wake_bits;
1323     unsigned int changed_bits;
1324 };
1325
1326
1327
1328 struct wait_input_idle_request
1329 {
1330     struct request_header __header;
1331     handle_t     handle;
1332     int          timeout;
1333     handle_t     event;
1334 };
1335
1336
1337
1338 struct send_message_request
1339 {
1340     struct request_header __header;
1341     void*           id;
1342     int             type;
1343     handle_t        win;
1344     unsigned int    msg;
1345     unsigned int    wparam;
1346     unsigned int    lparam;
1347     int             x;
1348     int             y;
1349     unsigned int    time;
1350     unsigned int    info;
1351     int             timeout;
1352     /* VARARG(data,bytes); */
1353 };
1354
1355 enum message_type
1356 {
1357     MSG_ASCII,
1358     MSG_UNICODE,
1359     MSG_NOTIFY,
1360     MSG_CALLBACK,
1361     MSG_OTHER_PROCESS,
1362     MSG_POSTED,
1363     MSG_HARDWARE_RAW,
1364     MSG_HARDWARE_COOKED
1365 };
1366
1367
1368
1369 struct get_message_request
1370 {
1371     struct request_header __header;
1372     int             flags;
1373     handle_t        get_win;
1374     unsigned int    get_first;
1375     unsigned int    get_last;
1376     int             type;
1377     handle_t        win;
1378     unsigned int    msg;
1379     unsigned int    wparam;
1380     unsigned int    lparam;
1381     int             x;
1382     int             y;
1383     unsigned int    time;
1384     unsigned int    info;
1385     /* VARARG(data,bytes); */
1386 };
1387 #define GET_MSG_REMOVE      1
1388 #define GET_MSG_SENT_ONLY   2
1389 #define GET_MSG_REMOVE_LAST 4
1390
1391
1392 struct reply_message_request
1393 {
1394     struct request_header __header;
1395     unsigned int    result;
1396     int             remove;
1397     /* VARARG(data,bytes); */
1398 };
1399
1400
1401
1402 struct get_message_reply_request
1403 {
1404     struct request_header __header;
1405     int             cancel;
1406     unsigned int    result;
1407     /* VARARG(data,bytes); */
1408 };
1409
1410
1411
1412 struct cleanup_window_queue_request
1413 {
1414     struct request_header __header;
1415     handle_t        win;
1416 };
1417
1418
1419
1420 struct set_win_timer_request
1421 {
1422     struct request_header __header;
1423     handle_t        win;
1424     unsigned int    msg;
1425     unsigned int    id;
1426     unsigned int    rate;
1427     unsigned int    lparam;
1428 };
1429
1430
1431
1432 struct kill_win_timer_request
1433 {
1434     struct request_header __header;
1435     handle_t        win;
1436     unsigned int    msg;
1437     unsigned int    id;
1438 };
1439
1440
1441
1442 struct create_serial_request
1443 {
1444     struct request_header __header;
1445     unsigned int access;
1446     int          inherit;
1447     unsigned int sharing;
1448     /* VARARG(name,string); */
1449     handle_t     handle;
1450 };
1451
1452
1453
1454 struct get_serial_info_request
1455 {
1456     struct request_header __header;
1457     handle_t     handle;
1458     unsigned int readinterval;
1459     unsigned int readconst;
1460     unsigned int readmult;
1461     unsigned int writeconst;
1462     unsigned int writemult;
1463     unsigned int eventmask;
1464     unsigned int commerror;
1465 };
1466
1467
1468
1469 struct set_serial_info_request
1470 {
1471     struct request_header __header;
1472     handle_t     handle;
1473     int          flags;
1474     unsigned int readinterval;
1475     unsigned int readconst;
1476     unsigned int readmult;
1477     unsigned int writeconst;
1478     unsigned int writemult;
1479     unsigned int eventmask;
1480     unsigned int commerror;
1481 };
1482 #define SERIALINFO_SET_TIMEOUTS  0x01
1483 #define SERIALINFO_SET_MASK      0x02
1484 #define SERIALINFO_SET_ERROR     0x04
1485
1486
1487
1488 struct create_async_request
1489 {
1490     struct request_header __header;
1491     handle_t     file_handle;
1492     int          count;
1493     int          type;
1494     int          timeout;
1495 };
1496 #define ASYNC_TYPE_READ  0x01
1497 #define ASYNC_TYPE_WRITE 0x02
1498 #define ASYNC_TYPE_WAIT  0x03
1499
1500
1501
1502 struct create_named_pipe_request
1503 {
1504     struct request_header __header;
1505     unsigned int   openmode;
1506     unsigned int   pipemode;
1507     unsigned int   maxinstances;
1508     unsigned int   outsize;
1509     unsigned int   insize;
1510     unsigned int   timeout;
1511     /* VARARG(filename,string); */
1512     handle_t       handle;
1513 };
1514
1515
1516
1517 struct open_named_pipe_request
1518 {
1519     struct request_header __header;
1520     unsigned int   access;
1521     /* VARARG(filename,string); */
1522     handle_t       handle;
1523 };
1524
1525
1526
1527 struct connect_named_pipe_request
1528 {
1529     struct request_header __header;
1530     handle_t       handle;
1531     handle_t       event;
1532 };
1533
1534
1535 enum request
1536 {
1537     REQ_new_process,
1538     REQ_get_new_process_info,
1539     REQ_new_thread,
1540     REQ_boot_done,
1541     REQ_init_process,
1542     REQ_init_process_done,
1543     REQ_init_thread,
1544     REQ_set_thread_buffer,
1545     REQ_terminate_process,
1546     REQ_terminate_thread,
1547     REQ_get_process_info,
1548     REQ_set_process_info,
1549     REQ_get_thread_info,
1550     REQ_set_thread_info,
1551     REQ_suspend_thread,
1552     REQ_resume_thread,
1553     REQ_load_dll,
1554     REQ_unload_dll,
1555     REQ_queue_apc,
1556     REQ_get_apc,
1557     REQ_close_handle,
1558     REQ_set_handle_info,
1559     REQ_dup_handle,
1560     REQ_open_process,
1561     REQ_select,
1562     REQ_create_event,
1563     REQ_event_op,
1564     REQ_open_event,
1565     REQ_create_mutex,
1566     REQ_release_mutex,
1567     REQ_open_mutex,
1568     REQ_create_semaphore,
1569     REQ_release_semaphore,
1570     REQ_open_semaphore,
1571     REQ_create_file,
1572     REQ_alloc_file_handle,
1573     REQ_get_handle_fd,
1574     REQ_set_file_pointer,
1575     REQ_truncate_file,
1576     REQ_set_file_time,
1577     REQ_flush_file,
1578     REQ_get_file_info,
1579     REQ_lock_file,
1580     REQ_unlock_file,
1581     REQ_create_pipe,
1582     REQ_create_socket,
1583     REQ_accept_socket,
1584     REQ_set_socket_event,
1585     REQ_get_socket_event,
1586     REQ_enable_socket_event,
1587     REQ_alloc_console,
1588     REQ_free_console,
1589     REQ_open_console,
1590     REQ_set_console_fd,
1591     REQ_get_console_mode,
1592     REQ_set_console_mode,
1593     REQ_set_console_info,
1594     REQ_get_console_info,
1595     REQ_write_console_input,
1596     REQ_read_console_input,
1597     REQ_create_change_notification,
1598     REQ_create_mapping,
1599     REQ_open_mapping,
1600     REQ_get_mapping_info,
1601     REQ_create_device,
1602     REQ_create_snapshot,
1603     REQ_next_process,
1604     REQ_next_thread,
1605     REQ_next_module,
1606     REQ_wait_debug_event,
1607     REQ_queue_exception_event,
1608     REQ_get_exception_status,
1609     REQ_output_debug_string,
1610     REQ_continue_debug_event,
1611     REQ_debug_process,
1612     REQ_read_process_memory,
1613     REQ_write_process_memory,
1614     REQ_create_key,
1615     REQ_open_key,
1616     REQ_delete_key,
1617     REQ_enum_key,
1618     REQ_set_key_value,
1619     REQ_get_key_value,
1620     REQ_enum_key_value,
1621     REQ_delete_key_value,
1622     REQ_load_registry,
1623     REQ_save_registry,
1624     REQ_save_registry_atexit,
1625     REQ_set_registry_levels,
1626     REQ_create_timer,
1627     REQ_open_timer,
1628     REQ_set_timer,
1629     REQ_cancel_timer,
1630     REQ_get_thread_context,
1631     REQ_set_thread_context,
1632     REQ_get_selector_entry,
1633     REQ_add_atom,
1634     REQ_delete_atom,
1635     REQ_find_atom,
1636     REQ_get_atom_name,
1637     REQ_init_atom_table,
1638     REQ_get_msg_queue,
1639     REQ_inc_queue_paint_count,
1640     REQ_set_queue_mask,
1641     REQ_get_queue_status,
1642     REQ_wait_input_idle,
1643     REQ_send_message,
1644     REQ_get_message,
1645     REQ_reply_message,
1646     REQ_get_message_reply,
1647     REQ_cleanup_window_queue,
1648     REQ_set_win_timer,
1649     REQ_kill_win_timer,
1650     REQ_create_serial,
1651     REQ_get_serial_info,
1652     REQ_set_serial_info,
1653     REQ_create_async,
1654     REQ_create_named_pipe,
1655     REQ_open_named_pipe,
1656     REQ_connect_named_pipe,
1657     REQ_NB_REQUESTS
1658 };
1659
1660 union generic_request
1661 {
1662     struct request_max_size max_size;
1663     struct request_header header;
1664     struct new_process_request new_process;
1665     struct get_new_process_info_request get_new_process_info;
1666     struct new_thread_request new_thread;
1667     struct boot_done_request boot_done;
1668     struct init_process_request init_process;
1669     struct init_process_done_request init_process_done;
1670     struct init_thread_request init_thread;
1671     struct set_thread_buffer_request set_thread_buffer;
1672     struct terminate_process_request terminate_process;
1673     struct terminate_thread_request terminate_thread;
1674     struct get_process_info_request get_process_info;
1675     struct set_process_info_request set_process_info;
1676     struct get_thread_info_request get_thread_info;
1677     struct set_thread_info_request set_thread_info;
1678     struct suspend_thread_request suspend_thread;
1679     struct resume_thread_request resume_thread;
1680     struct load_dll_request load_dll;
1681     struct unload_dll_request unload_dll;
1682     struct queue_apc_request queue_apc;
1683     struct get_apc_request get_apc;
1684     struct close_handle_request close_handle;
1685     struct set_handle_info_request set_handle_info;
1686     struct dup_handle_request dup_handle;
1687     struct open_process_request open_process;
1688     struct select_request select;
1689     struct create_event_request create_event;
1690     struct event_op_request event_op;
1691     struct open_event_request open_event;
1692     struct create_mutex_request create_mutex;
1693     struct release_mutex_request release_mutex;
1694     struct open_mutex_request open_mutex;
1695     struct create_semaphore_request create_semaphore;
1696     struct release_semaphore_request release_semaphore;
1697     struct open_semaphore_request open_semaphore;
1698     struct create_file_request create_file;
1699     struct alloc_file_handle_request alloc_file_handle;
1700     struct get_handle_fd_request get_handle_fd;
1701     struct set_file_pointer_request set_file_pointer;
1702     struct truncate_file_request truncate_file;
1703     struct set_file_time_request set_file_time;
1704     struct flush_file_request flush_file;
1705     struct get_file_info_request get_file_info;
1706     struct lock_file_request lock_file;
1707     struct unlock_file_request unlock_file;
1708     struct create_pipe_request create_pipe;
1709     struct create_socket_request create_socket;
1710     struct accept_socket_request accept_socket;
1711     struct set_socket_event_request set_socket_event;
1712     struct get_socket_event_request get_socket_event;
1713     struct enable_socket_event_request enable_socket_event;
1714     struct alloc_console_request alloc_console;
1715     struct free_console_request free_console;
1716     struct open_console_request open_console;
1717     struct set_console_fd_request set_console_fd;
1718     struct get_console_mode_request get_console_mode;
1719     struct set_console_mode_request set_console_mode;
1720     struct set_console_info_request set_console_info;
1721     struct get_console_info_request get_console_info;
1722     struct write_console_input_request write_console_input;
1723     struct read_console_input_request read_console_input;
1724     struct create_change_notification_request create_change_notification;
1725     struct create_mapping_request create_mapping;
1726     struct open_mapping_request open_mapping;
1727     struct get_mapping_info_request get_mapping_info;
1728     struct create_device_request create_device;
1729     struct create_snapshot_request create_snapshot;
1730     struct next_process_request next_process;
1731     struct next_thread_request next_thread;
1732     struct next_module_request next_module;
1733     struct wait_debug_event_request wait_debug_event;
1734     struct queue_exception_event_request queue_exception_event;
1735     struct get_exception_status_request get_exception_status;
1736     struct output_debug_string_request output_debug_string;
1737     struct continue_debug_event_request continue_debug_event;
1738     struct debug_process_request debug_process;
1739     struct read_process_memory_request read_process_memory;
1740     struct write_process_memory_request write_process_memory;
1741     struct create_key_request create_key;
1742     struct open_key_request open_key;
1743     struct delete_key_request delete_key;
1744     struct enum_key_request enum_key;
1745     struct set_key_value_request set_key_value;
1746     struct get_key_value_request get_key_value;
1747     struct enum_key_value_request enum_key_value;
1748     struct delete_key_value_request delete_key_value;
1749     struct load_registry_request load_registry;
1750     struct save_registry_request save_registry;
1751     struct save_registry_atexit_request save_registry_atexit;
1752     struct set_registry_levels_request set_registry_levels;
1753     struct create_timer_request create_timer;
1754     struct open_timer_request open_timer;
1755     struct set_timer_request set_timer;
1756     struct cancel_timer_request cancel_timer;
1757     struct get_thread_context_request get_thread_context;
1758     struct set_thread_context_request set_thread_context;
1759     struct get_selector_entry_request get_selector_entry;
1760     struct add_atom_request add_atom;
1761     struct delete_atom_request delete_atom;
1762     struct find_atom_request find_atom;
1763     struct get_atom_name_request get_atom_name;
1764     struct init_atom_table_request init_atom_table;
1765     struct get_msg_queue_request get_msg_queue;
1766     struct inc_queue_paint_count_request inc_queue_paint_count;
1767     struct set_queue_mask_request set_queue_mask;
1768     struct get_queue_status_request get_queue_status;
1769     struct wait_input_idle_request wait_input_idle;
1770     struct send_message_request send_message;
1771     struct get_message_request get_message;
1772     struct reply_message_request reply_message;
1773     struct get_message_reply_request get_message_reply;
1774     struct cleanup_window_queue_request cleanup_window_queue;
1775     struct set_win_timer_request set_win_timer;
1776     struct kill_win_timer_request kill_win_timer;
1777     struct create_serial_request create_serial;
1778     struct get_serial_info_request get_serial_info;
1779     struct set_serial_info_request set_serial_info;
1780     struct create_async_request create_async;
1781     struct create_named_pipe_request create_named_pipe;
1782     struct open_named_pipe_request open_named_pipe;
1783     struct connect_named_pipe_request connect_named_pipe;
1784 };
1785
1786 #define SERVER_PROTOCOL_VERSION 49
1787
1788 #endif /* __WINE_WINE_SERVER_PROTOCOL_H */