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