include/server.h

   1 /*
   2  * Wine server definitions
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  */
   6
   7 #ifndef __WINE_SERVER_H
   8 #define __WINE_SERVER_H
   9
  10 #include <stdlib.h>
  11 #include <time.h>
  12
  13 /* message header as sent on the wire */
  14 struct header
  15 {
  16     unsigned int  len;     /* total msg length (including this header) */
  17     unsigned int  type;    /* msg type */
  18 };
  19
  20 /* max msg length (including the header) */
  21 #define MAX_MSG_LENGTH  16384
  22
  23 /* data structure used to pass an fd with sendmsg/recvmsg */
  24 struct cmsg_fd
  25 {
  26     int len;   /* sizeof structure */
  27     int level; /* SOL_SOCKET */
  28     int type;  /* SCM_RIGHTS */
  29     int fd;    /* fd to pass */
  30 };
  31
  32 /* Request structures */
  33
  34 /* following are the definitions of all the client<->server  */
  35 /* communication format; requests are from client to server, */
  36 /* replies are from server to client. All requests must have */
  37 /* a corresponding structure; the replies can be empty in    */
  38 /* which case it isn't necessary to define a structure.      */
  39
  40
  41 /* Create a new process from the context of the parent */
  42 struct new_process_request
  43 {
  44     int          inherit;      /* inherit flag */
  45     int          inherit_all;  /* inherit all handles from parent */
  46     int          create_flags; /* creation flags */
  47     int          start_flags;  /* flags from startup info */
  48     int          hstdin;       /* handle for stdin */
  49     int          hstdout;      /* handle for stdout */
  50     int          hstderr;      /* handle for stderr */
  51     int          cmd_show;     /* main window show mode */
  52     void*        env_ptr;      /* pointer to environment (FIXME: hack) */
  53     char         cmd_line[0];  /* command line */
  54 };
  55 struct new_process_reply
  56 {
  57     void*        pid;          /* process id */
  58     int          handle;       /* process handle (in the current process) */
  59 };
  60
  61
  62 /* Create a new thread from the context of the parent */
  63 struct new_thread_request
  64 {
  65     void*        pid;          /* process id for the new thread */
  66     int          suspend;      /* new thread should be suspended on creation */
  67     int          inherit;      /* inherit flag */
  68 };
  69 struct new_thread_reply
  70 {
  71     void*        tid;          /* thread id */
  72     int          handle;       /* thread handle (in the current process) */
  73 };
  74
  75
  76 /* Set the server debug level */
  77 struct set_debug_request
  78 {
  79     int          level;        /* New debug level */
  80 };
  81
  82
  83 /* Initialize a process; called from the new process context */
  84 struct init_process_request
  85 {
  86     int          dummy;
  87 };
  88 struct init_process_reply
  89 {
  90     int          start_flags;  /* flags from startup info */
  91     int          hstdin;       /* handle for stdin */
  92     int          hstdout;      /* handle for stdout */
  93     int          hstderr;      /* handle for stderr */
  94     int          cmd_show;     /* main window show mode */
  95     void*        env_ptr;      /* pointer to environment (FIXME: hack) */
  96     char         cmdline[0];   /* command line */
  97 };
  98
  99
 100 /* Initialize a thread; called from the child after fork()/clone() */
 101 struct init_thread_request
 102 {
 103     int          unix_pid;     /* Unix pid of new thread */
 104     void*        teb;          /* TEB of new thread (in thread address space) */
 105 };
 106 struct init_thread_reply
 107 {
 108     void*        pid;          /* process id of the new thread's process */
 109     void*        tid;          /* thread id of the new thread */
 110 };
 111
 112
 113 /* Terminate a process */
 114 struct terminate_process_request
 115 {
 116     int          handle;       /* process handle to terminate */
 117     int          exit_code;    /* process exit code */
 118 };
 119
 120
 121 /* Terminate a thread */
 122 struct terminate_thread_request
 123 {
 124     int          handle;       /* thread handle to terminate */
 125     int          exit_code;    /* thread exit code */
 126 };
 127
 128
 129 /* Retrieve information about a process */
 130 struct get_process_info_request
 131 {
 132     int          handle;       /* process handle */
 133 };
 134 struct get_process_info_reply
 135 {
 136     void*        pid;              /* server process id */
 137     int          exit_code;        /* process exit code */
 138     int          priority;         /* priority class */
 139     int          process_affinity; /* process affinity mask */
 140     int          system_affinity;  /* system affinity mask */
 141 };
 142
 143
 144 /* Set a process informations */
 145 struct set_process_info_request
 146 {
 147     int          handle;       /* process handle */
 148     int          mask;         /* setting mask (see below) */
 149     int          priority;     /* priority class */
 150     int          affinity;     /* affinity mask */
 151 };
 152 #define SET_PROCESS_INFO_PRIORITY 0x01
 153 #define SET_PROCESS_INFO_AFFINITY 0x02
 154
 155
 156 /* Retrieve information about a thread */
 157 struct get_thread_info_request
 158 {
 159     int          handle;       /* thread handle */
 160 };
 161 struct get_thread_info_reply
 162 {
 163     void*        tid;          /* server thread id */
 164     int          exit_code;    /* thread exit code */
 165     int          priority;     /* thread priority level */
 166 };
 167
 168
 169 /* Set a thread informations */
 170 struct set_thread_info_request
 171 {
 172     int          handle;       /* thread handle */
 173     int          mask;         /* setting mask (see below) */
 174     int          priority;     /* priority class */
 175     int          affinity;     /* affinity mask */
 176 };
 177 #define SET_THREAD_INFO_PRIORITY 0x01
 178 #define SET_THREAD_INFO_AFFINITY 0x02
 179
 180
 181 /* Suspend a thread */
 182 struct suspend_thread_request
 183 {
 184     int          handle;       /* thread handle */
 185 };
 186 struct suspend_thread_reply
 187 {
 188     int          count;        /* new suspend count */
 189 };
 190
 191
 192 /* Resume a thread */
 193 struct resume_thread_request
 194 {
 195     int          handle;       /* thread handle */
 196 };
 197 struct resume_thread_reply
 198 {
 199     int          count;        /* new suspend count */
 200 };
 201
 202
 203 /* Debugger support: freeze / unfreeze */
 204 struct debugger_request
 205 {
 206     int          op;           /* operation type */
 207 };
 208
 209 enum debugger_op { DEBUGGER_FREEZE_ALL, DEBUGGER_UNFREEZE_ALL };
 210
 211
 212 /* Queue an APC for a thread */
 213 struct queue_apc_request
 214 {
 215     int          handle;       /* thread handle */
 216     void*        func;         /* function to call */
 217     void*        param;        /* param for function to call */
 218 };
 219
 220
 221 /* Close a handle for the current process */
 222 struct close_handle_request
 223 {
 224     int          handle;       /* handle to close */
 225 };
 226
 227
 228 /* Get information about a handle */
 229 struct get_handle_info_request
 230 {
 231     int          handle;       /* handle we are interested in */
 232 };
 233 struct get_handle_info_reply
 234 {
 235     int          flags;        /* handle flags */
 236 };
 237
 238
 239 /* Set a handle information */
 240 struct set_handle_info_request
 241 {
 242     int          handle;       /* handle we are interested in */
 243     int          flags;        /* new handle flags */
 244     int          mask;         /* mask for flags to set */
 245 };
 246
 247
 248 /* Duplicate a handle */
 249 struct dup_handle_request
 250 {
 251     int          src_process;  /* src process handle */
 252     int          src_handle;   /* src handle to duplicate */
 253     int          dst_process;  /* dst process handle */
 254     unsigned int access;       /* wanted access rights */
 255     int          inherit;      /* inherit flag */
 256     int          options;      /* duplicate options (see below) */
 257 };
 258 #define DUP_HANDLE_CLOSE_SOURCE  DUPLICATE_CLOSE_SOURCE
 259 #define DUP_HANDLE_SAME_ACCESS   DUPLICATE_SAME_ACCESS
 260 #define DUP_HANDLE_MAKE_GLOBAL   0x80000000  /* Not a Windows flag */
 261 struct dup_handle_reply
 262 {
 263     int          handle;       /* duplicated handle in dst process */
 264 };
 265
 266
 267 /* Open a handle to a process */
 268 struct open_process_request
 269 {
 270     void*        pid;          /* process id to open */
 271     unsigned int access;       /* wanted access rights */
 272     int          inherit;      /* inherit flag */
 273 };
 274 struct open_process_reply
 275 {
 276     int          handle;       /* handle to the process */
 277 };
 278
 279
 280 /* Wait for handles */
 281 struct select_request
 282 {
 283     int          count;        /* handles count */
 284     int          flags;        /* wait flags (see below) */
 285     int          timeout;      /* timeout in ms */
 286     int          handles[0];   /* handles to select on */
 287 };
 288 struct select_reply
 289 {
 290     int          signaled;     /* signaled handle */
 291     void*        apcs[0];      /* async procedures to call */
 292 };
 293 #define SELECT_ALL       1
 294 #define SELECT_ALERTABLE 2
 295 #define SELECT_TIMEOUT   4
 296
 297
 298 /* Create an event */
 299 struct create_event_request
 300 {
 301     int          manual_reset;  /* manual reset event */
 302     int          initial_state; /* initial state of the event */
 303     int          inherit;       /* inherit flag */
 304     char         name[0];       /* event name */
 305 };
 306 struct create_event_reply
 307 {
 308     int          handle;        /* handle to the event */
 309 };
 310
 311 /* Event operation */
 312 struct event_op_request
 313 {
 314     int           handle;       /* handle to event */
 315     int           op;           /* event operation (see below) */
 316 };
 317 enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT };
 318
 319
 320 /* Open an event */
 321 struct open_event_request
 322 {
 323     unsigned int access;        /* wanted access rights */
 324     int          inherit;       /* inherit flag */
 325     char         name[0];       /* object name */
 326 };
 327 struct open_event_reply
 328 {
 329     int          handle;        /* handle to the event */
 330 };
 331
 332
 333 /* Create a mutex */
 334 struct create_mutex_request
 335 {
 336     int          owned;         /* initially owned? */
 337     int          inherit;       /* inherit flag */
 338     char         name[0];       /* mutex name */
 339 };
 340 struct create_mutex_reply
 341 {
 342     int          handle;        /* handle to the mutex */
 343 };
 344
 345
 346 /* Release a mutex */
 347 struct release_mutex_request
 348 {
 349     int          handle;        /* handle to the mutex */
 350 };
 351
 352
 353 /* Open a mutex */
 354 struct open_mutex_request
 355 {
 356     unsigned int access;        /* wanted access rights */
 357     int          inherit;       /* inherit flag */
 358     char         name[0];       /* object name */
 359 };
 360 struct open_mutex_reply
 361 {
 362     int          handle;        /* handle to the mutex */
 363 };
 364
 365
 366 /* Create a semaphore */
 367 struct create_semaphore_request
 368 {
 369     unsigned int initial;       /* initial count */
 370     unsigned int max;           /* maximum count */
 371     int          inherit;       /* inherit flag */
 372     char         name[0];       /* semaphore name */
 373 };
 374 struct create_semaphore_reply
 375 {
 376     int          handle;        /* handle to the semaphore */
 377 };
 378
 379
 380 /* Release a semaphore */
 381 struct release_semaphore_request
 382 {
 383     int          handle;        /* handle to the semaphore */
 384     unsigned int count;         /* count to add to semaphore */
 385 };
 386 struct release_semaphore_reply
 387 {
 388     unsigned int prev_count;    /* previous semaphore count */
 389 };
 390
 391
 392 /* Open a semaphore */
 393 struct open_semaphore_request
 394 {
 395     unsigned int access;        /* wanted access rights */
 396     int          inherit;       /* inherit flag */
 397     char         name[0];       /* object name */
 398 };
 399 struct open_semaphore_reply
 400 {
 401     int          handle;        /* handle to the semaphore */
 402 };
 403
 404
 405 /* Create a file */
 406 struct create_file_request
 407 {
 408     unsigned int access;        /* wanted access rights */
 409     int          inherit;       /* inherit flag */
 410     unsigned int sharing;       /* sharing flags */
 411     int          create;        /* file create action */
 412     unsigned int attrs;         /* file attributes for creation */
 413     char         name[0];       /* file name */
 414 };
 415 struct create_file_reply
 416 {
 417     int          handle;        /* handle to the file */
 418 };
 419
 420
 421 /* Get a Unix fd to read from a file */
 422 struct get_read_fd_request
 423 {
 424     int          handle;        /* handle to the file */
 425 };
 426
 427
 428 /* Get a Unix fd to write to a file */
 429 struct get_write_fd_request
 430 {
 431     int          handle;        /* handle to the file */
 432 };
 433
 434
 435 /* Set a file current position */
 436 struct set_file_pointer_request
 437 {
 438     int          handle;        /* handle to the file */
 439     int          low;           /* position low word */
 440     int          high;          /* position high word */
 441     int          whence;        /* whence to seek */
 442 };
 443 struct set_file_pointer_reply
 444 {
 445     int          low;           /* new position low word */
 446     int          high;          /* new position high word */
 447 };
 448
 449
 450 /* Truncate (or extend) a file */
 451 struct truncate_file_request
 452 {
 453     int          handle;        /* handle to the file */
 454 };
 455
 456
 457 /* Set a file access and modification times */
 458 struct set_file_time_request
 459 {
 460     int          handle;        /* handle to the file */
 461     time_t       access_time;   /* last access time */
 462     time_t       write_time;    /* last write time */
 463 };
 464
 465
 466 /* Flush a file buffers */
 467 struct flush_file_request
 468 {
 469     int          handle;        /* handle to the file */
 470 };
 471
 472
 473 /* Get information about a file */
 474 struct get_file_info_request
 475 {
 476     int          handle;        /* handle to the file */
 477 };
 478 struct get_file_info_reply
 479 {
 480     int          type;          /* file type */
 481     int          attr;          /* file attributes */
 482     time_t       access_time;   /* last access time */
 483     time_t       write_time;    /* last write time */
 484     int          size_high;     /* file size */
 485     int          size_low;      /* file size */
 486     int          links;         /* number of links */
 487     int          index_high;    /* unique index */
 488     int          index_low;     /* unique index */
 489     unsigned int serial;        /* volume serial number */
 490 };
 491
 492
 493 /* Lock a region of a file */
 494 struct lock_file_request
 495 {
 496     int          handle;        /* handle to the file */
 497     unsigned int offset_low;    /* offset of start of lock */
 498     unsigned int offset_high;   /* offset of start of lock */
 499     unsigned int count_low;     /* count of bytes to lock */
 500     unsigned int count_high;    /* count of bytes to lock */
 501 };
 502
 503
 504 /* Unlock a region of a file */
 505 struct unlock_file_request
 506 {
 507     int          handle;        /* handle to the file */
 508     unsigned int offset_low;    /* offset of start of unlock */
 509     unsigned int offset_high;   /* offset of start of unlock */
 510     unsigned int count_low;     /* count of bytes to unlock */
 511     unsigned int count_high;    /* count of bytes to unlock */
 512 };
 513
 514
 515 /* Create an anonymous pipe */
 516 struct create_pipe_request
 517 {
 518     int          inherit;       /* inherit flag */
 519 };
 520 struct create_pipe_reply
 521 {
 522     int          handle_read;   /* handle to the read-side of the pipe */
 523     int          handle_write;  /* handle to the write-side of the pipe */
 524 };
 525
 526
 527 /* Allocate a console for the current process */
 528 struct alloc_console_request
 529 {
 530     unsigned int access;        /* wanted access rights */
 531     int          inherit;       /* inherit flag */
 532 };
 533 struct alloc_console_reply
 534 {
 535     int          handle_in;     /* handle to console input */
 536     int          handle_out;    /* handle to console output */
 537 };
 538
 539
 540 /* Free the console of the current process */
 541 struct free_console_request
 542 {
 543     int dummy;
 544 };
 545
 546
 547 /* Open a handle to the process console */
 548 struct open_console_request
 549 {
 550     int          output;        /* input or output? */
 551     unsigned int access;        /* wanted access rights */
 552     int          inherit;       /* inherit flag */
 553 };
 554 struct open_console_reply
 555 {
 556     int          handle;        /* handle to the console */
 557 };
 558
 559
 560 /* Set a console file descriptor */
 561 struct set_console_fd_request
 562 {
 563     int          handle;        /* handle to the console */
 564     int          pid;           /* pid of xterm (hack) */
 565 };
 566
 567
 568 /* Get a console mode (input or output) */
 569 struct get_console_mode_request
 570 {
 571     int          handle;        /* handle to the console */
 572 };
 573 struct get_console_mode_reply
 574 {
 575     int          mode;          /* console mode */
 576 };
 577
 578
 579 /* Set a console mode (input or output) */
 580 struct set_console_mode_request
 581 {
 582     int          handle;        /* handle to the console */
 583     int          mode;          /* console mode */
 584 };
 585
 586
 587 /* Set info about a console (output only) */
 588 struct set_console_info_request
 589 {
 590     int          handle;        /* handle to the console */
 591     int          mask;          /* setting mask (see below) */
 592     int          cursor_size;   /* size of cursor (percentage filled) */
 593     int          cursor_visible;/* cursor visibility flag */
 594     char         title[0];      /* console title */
 595 };
 596 #define SET_CONSOLE_INFO_CURSOR 0x01
 597 #define SET_CONSOLE_INFO_TITLE  0x02
 598
 599 /* Get info about a console (output only) */
 600 struct get_console_info_request
 601 {
 602     int          handle;        /* handle to the console */
 603 };
 604 struct get_console_info_reply
 605 {
 606     int          cursor_size;   /* size of cursor (percentage filled) */
 607     int          cursor_visible;/* cursor visibility flag */
 608     int          pid;           /* pid of xterm (hack) */
 609     char         title[0];      /* console title */
 610 };
 611
 612
 613 /* Add input records to a console input queue */
 614 struct write_console_input_request
 615 {
 616     int          handle;        /* handle to the console input */
 617     int          count;         /* number of input records */
 618 /*  INPUT_RECORD records[0]; */ /* input records */
 619 };
 620 struct write_console_input_reply
 621 {
 622     int          written;       /* number of records written */
 623 };
 624
 625 /* Fetch input records from a console input queue */
 626 struct read_console_input_request
 627 {
 628     int          handle;        /* handle to the console input */
 629     int          count;         /* max number of records to retrieve */
 630     int          flush;         /* flush the retrieved records from the queue? */
 631 };
 632 struct read_console_input_reply
 633 {
 634     int dummy;
 635 /*  INPUT_RECORD records[0]; */ /* input records */
 636 };
 637
 638
 639 /* Create a change notification */
 640 struct create_change_notification_request
 641 {
 642     int          subtree;       /* watch all the subtree */
 643     int          filter;        /* notification filter */
 644 };
 645 struct create_change_notification_reply
 646 {
 647     int          handle;        /* handle to the change notification */
 648 };
 649
 650
 651 /* Create a file mapping */
 652 struct create_mapping_request
 653 {
 654     int          size_high;     /* mapping size */
 655     int          size_low;      /* mapping size */
 656     int          protect;       /* protection flags (see below) */
 657     int          inherit;       /* inherit flag */
 658     int          handle;        /* file handle */
 659     char         name[0];       /* object name */
 660 };
 661 struct create_mapping_reply
 662 {
 663     int          handle;        /* handle to the mapping */
 664 };
 665 /* protection flags */
 666 #define VPROT_READ       0x01
 667 #define VPROT_WRITE      0x02
 668 #define VPROT_EXEC       0x04
 669 #define VPROT_WRITECOPY  0x08
 670 #define VPROT_GUARD      0x10
 671 #define VPROT_NOCACHE    0x20
 672 #define VPROT_COMMITTED  0x40
 673
 674
 675 /* Open a mapping */
 676 struct open_mapping_request
 677 {
 678     unsigned int access;        /* wanted access rights */
 679     int          inherit;       /* inherit flag */
 680     char         name[0];       /* object name */
 681 };
 682 struct open_mapping_reply
 683 {
 684     int          handle;        /* handle to the mapping */
 685 };
 686
 687
 688 /* Get information about a file mapping */
 689 struct get_mapping_info_request
 690 {
 691     int          handle;        /* handle to the mapping */
 692 };
 693 struct get_mapping_info_reply
 694 {
 695     int          size_high;     /* mapping size */
 696     int          size_low;      /* mapping size */
 697     int          protect;       /* protection flags */
 698 };
 699
 700
 701 /* Create a device */
 702 struct create_device_request
 703 {
 704     unsigned int access;        /* wanted access rights */
 705     int          inherit;       /* inherit flag */
 706     int          id;            /* client private id */
 707 };
 708 struct create_device_reply
 709 {
 710     int          handle;        /* handle to the device */
 711 };
 712
 713
 714 /* Create a snapshot */
 715 struct create_snapshot_request
 716 {
 717     int          inherit;       /* inherit flag */
 718     int          flags;         /* snapshot flags (TH32CS_*) */
 719 };
 720 struct create_snapshot_reply
 721 {
 722     int          handle;        /* handle to the snapshot */
 723 };
 724
 725
 726 /* Get the next process from a snapshot */
 727 struct next_process_request
 728 {
 729     int          handle;        /* handle to the snapshot */
 730     int          reset;         /* reset snapshot position? */
 731 };
 732 struct next_process_reply
 733 {
 734     void*        pid;          /* process id */
 735     int          threads;      /* number of threads */
 736     int          priority;     /* process priority */
 737 };
 738
 739
 740 /* Wait for a debug event */
 741 struct wait_debug_event_request
 742 {
 743     int          timeout;      /* timeout in ms */
 744 };
 745 struct wait_debug_event_reply
 746 {
 747     int          code;         /* event code */
 748     void*        pid;          /* process id */
 749     void*        tid;          /* thread id */
 750     /* followed by the event data (see below) */
 751 };
 752
 753
 754 /* Send a debug event */
 755 struct send_debug_event_request
 756 {
 757     int          code;         /* event code */
 758     /* followed by the event data (see below) */
 759 };
 760 struct send_debug_event_reply
 761 {
 762     int          status;       /* event continuation status */
 763 };
 764
 765
 766 /* definitions of the event data depending on the event code */
 767 struct debug_event_exception
 768 {
 769     int        code;           /* exception code */
 770     int        flags;          /* exception flags */
 771     void      *record;         /* exception record ptr */
 772     void      *addr;           /* exception address */
 773     int        nb_params;      /* exceptions parameters */
 774     int        params[15];
 775     int        first_chance;   /* first chance to handle it? */
 776 };
 777 struct debug_event_create_thread
 778 {
 779     int         handle;     /* handle to the new thread */
 780     void       *teb;        /* thread teb (in debugged process address space) */
 781     void       *start;      /* thread startup routine */
 782 };
 783 struct debug_event_create_process
 784 {
 785     int         file;       /* handle to the process exe file */
 786     int         process;    /* handle to the new process */
 787     int         thread;     /* handle to the new thread */
 788     void       *base;       /* base of executable image */
 789     int         dbg_offset; /* offset of debug info in file */
 790     int         dbg_size;   /* size of debug info */
 791     void       *teb;        /* thread teb (in debugged process address space) */
 792     void       *start;      /* thread startup routine */
 793     void       *name;       /* image name (optional) */
 794     int         unicode;    /* is it Unicode? */
 795 };
 796 struct debug_event_exit
 797 {
 798     int         exit_code;  /* thread or process exit code */
 799 };
 800 struct debug_event_load_dll
 801 {
 802     int         handle;     /* file handle for the dll */
 803     void       *base;       /* base address of the dll */
 804     int         dbg_offset; /* offset of debug info in file */
 805     int         dbg_size;   /* size of debug info */
 806     void       *name;       /* image name (optional) */
 807     int         unicode;    /* is it Unicode? */
 808 };
 809 struct debug_event_unload_dll
 810 {
 811     void       *base;       /* base address of the dll */
 812 };
 813 struct debug_event_output_string
 814 {
 815     void       *string;     /* string to display (in debugged process address space) */
 816     int         unicode;    /* is it Unicode? */
 817     int         length;     /* string length */
 818 };
 819 struct debug_event_rip_info
 820 {
 821     int         error;      /* ??? */
 822     int         type;       /* ??? */
 823 };
 824 union debug_event_data
 825 {
 826     struct debug_event_exception      exception;
 827     struct debug_event_create_thread  create_thread;
 828     struct debug_event_create_process create_process;
 829     struct debug_event_exit           exit;
 830     struct debug_event_load_dll       load_dll;
 831     struct debug_event_unload_dll     unload_dll;
 832     struct debug_event_output_string  output_string;
 833     struct debug_event_rip_info       rip_info;
 834 };
 835
 836
 837 /* Continue a debug event */
 838 struct continue_debug_event_request
 839 {
 840     void*        pid;          /* process id to continue */
 841     void*        tid;          /* thread id to continue */
 842     int          status;       /* continuation status */
 843 };
 844
 845
 846 /* Start debugging an existing process */
 847 struct debug_process_request
 848 {
 849     void*        pid;          /* id of the process to debug */
 850 };
 851
 852
 853 /* Everything below this line is generated automatically by tools/make_requests */
 854 /* ### make_requests begin ### */
 855
 856 enum request
 857 {
 858     REQ_NEW_PROCESS,
 859     REQ_NEW_THREAD,
 860     REQ_SET_DEBUG,
 861     REQ_INIT_PROCESS,
 862     REQ_INIT_THREAD,
 863     REQ_TERMINATE_PROCESS,
 864     REQ_TERMINATE_THREAD,
 865     REQ_GET_PROCESS_INFO,
 866     REQ_SET_PROCESS_INFO,
 867     REQ_GET_THREAD_INFO,
 868     REQ_SET_THREAD_INFO,
 869     REQ_SUSPEND_THREAD,
 870     REQ_RESUME_THREAD,
 871     REQ_DEBUGGER,
 872     REQ_QUEUE_APC,
 873     REQ_CLOSE_HANDLE,
 874     REQ_GET_HANDLE_INFO,
 875     REQ_SET_HANDLE_INFO,
 876     REQ_DUP_HANDLE,
 877     REQ_OPEN_PROCESS,
 878     REQ_SELECT,
 879     REQ_CREATE_EVENT,
 880     REQ_EVENT_OP,
 881     REQ_OPEN_EVENT,
 882     REQ_CREATE_MUTEX,
 883     REQ_RELEASE_MUTEX,
 884     REQ_OPEN_MUTEX,
 885     REQ_CREATE_SEMAPHORE,
 886     REQ_RELEASE_SEMAPHORE,
 887     REQ_OPEN_SEMAPHORE,
 888     REQ_CREATE_FILE,
 889     REQ_GET_READ_FD,
 890     REQ_GET_WRITE_FD,
 891     REQ_SET_FILE_POINTER,
 892     REQ_TRUNCATE_FILE,
 893     REQ_SET_FILE_TIME,
 894     REQ_FLUSH_FILE,
 895     REQ_GET_FILE_INFO,
 896     REQ_LOCK_FILE,
 897     REQ_UNLOCK_FILE,
 898     REQ_CREATE_PIPE,
 899     REQ_ALLOC_CONSOLE,
 900     REQ_FREE_CONSOLE,
 901     REQ_OPEN_CONSOLE,
 902     REQ_SET_CONSOLE_FD,
 903     REQ_GET_CONSOLE_MODE,
 904     REQ_SET_CONSOLE_MODE,
 905     REQ_SET_CONSOLE_INFO,
 906     REQ_GET_CONSOLE_INFO,
 907     REQ_WRITE_CONSOLE_INPUT,
 908     REQ_READ_CONSOLE_INPUT,
 909     REQ_CREATE_CHANGE_NOTIFICATION,
 910     REQ_CREATE_MAPPING,
 911     REQ_OPEN_MAPPING,
 912     REQ_GET_MAPPING_INFO,
 913     REQ_CREATE_DEVICE,
 914     REQ_CREATE_SNAPSHOT,
 915     REQ_NEXT_PROCESS,
 916     REQ_WAIT_DEBUG_EVENT,
 917     REQ_SEND_DEBUG_EVENT,
 918     REQ_CONTINUE_DEBUG_EVENT,
 919     REQ_DEBUG_PROCESS,
 920     REQ_NB_REQUESTS
 921 };
 922
 923 /* ### make_requests end ### */
 924 /* Everything above this line is generated automatically by tools/make_requests */
 925
 926
 927 /* client-side functions */
 928
 929 #ifndef __WINE_SERVER__
 930
 931 #include "thread.h"
 932
 933 /* make space for some data in the server arguments buffer */
 934 static inline void *server_add_data( int len )
 935 {
 936     void *old = NtCurrentTeb()->buffer_args;
 937     NtCurrentTeb()->buffer_args = (char *)old + len;
 938     return old;
 939 }
 940
 941 /* maximum remaining size in the server arguments buffer */
 942 static inline int server_remaining(void)
 943 {
 944     TEB *teb = NtCurrentTeb();
 945     return (char *)teb->buffer + teb->buffer_size - (char *)teb->buffer_args;
 946 }
 947
 948 extern unsigned int server_call( enum request req );
 949 extern unsigned int server_call_fd( enum request req, int *fd );
 950
 951 /* client communication functions */
 952 extern void CLIENT_ProtocolError( const char *err, ... );
 953 extern void CLIENT_SendRequest( enum request req, int pass_fd,
 954                                 int n, ... /* arg_1, len_1, etc. */ );
 955 extern unsigned int CLIENT_WaitReply( int *len, int *passed_fd,
 956                                       int n, ... /* arg_1, len_1, etc. */ );
 957 extern unsigned int CLIENT_WaitSimpleReply( void *reply, int len, int *passed_fd );
 958 extern int CLIENT_InitServer(void);
 959 extern int CLIENT_SetDebug( int level );
 960 extern int CLIENT_DebuggerRequest( int op );
 961 extern int CLIENT_InitThread(void);
 962 #endif  /* __WINE_SERVER__ */
 963
 964 #endif  /* __WINE_SERVER_H */