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
  34 /* Request structures */
  35
  36 /* following are the definitions of all the client<->server  */
  37 /* communication format; requests are from client to server, */
  38 /* replies are from server to client. All requests must have */
  39 /* a corresponding structure; the replies can be empty in    */
  40 /* which case it isn't necessary to define a structure.      */
  41
  42
  43 /* Create a new process from the context of the parent */
  44 struct new_process_request
  45 {
  46     int          inherit;      /* inherit flag */
  47     int          inherit_all;  /* inherit all handles from parent */
  48     int          start_flags;  /* flags from startup info */
  49     int          hstdin;       /* handle for stdin */
  50     int          hstdout;      /* handle for stdout */
  51     int          hstderr;      /* handle for stderr */
  52 };
  53 struct new_process_reply
  54 {
  55     void*        pid;          /* process id */
  56     int          handle;       /* process handle (in the current process) */
  57 };
  58
  59
  60 /* Create a new thread from the context of the parent */
  61 struct new_thread_request
  62 {
  63     void*        pid;          /* process id for the new thread */
  64     int          suspend;      /* new thread should be suspended on creation */
  65     int          inherit;      /* inherit flag */
  66 };
  67 struct new_thread_reply
  68 {
  69     void*        tid;          /* thread id */
  70     int          handle;       /* thread handle (in the current process) */
  71 };
  72
  73
  74 /* Set the server debug level */
  75 struct set_debug_request
  76 {
  77     int          level;        /* New debug level */
  78 };
  79
  80
  81 /* Initialize a process; called from the new process context */
  82 struct init_process_request
  83 {
  84     int          dummy;
  85 };
  86 struct init_process_reply
  87 {
  88     int          start_flags;  /* flags from startup info */
  89     int          hstdin;       /* handle for stdin */
  90     int          hstdout;      /* handle for stdout */
  91     int          hstderr;      /* handle for stderr */
  92 };
  93
  94
  95 /* Initialize a thread; called from the child after fork()/clone() */
  96 struct init_thread_request
  97 {
  98     int          unix_pid;     /* Unix pid of new thread */
  99 };
 100 struct init_thread_reply
 101 {
 102     void*        pid;          /* process id of the new thread's process */
 103     void*        tid;          /* thread id of the new thread */
 104 };
 105
 106
 107 /* Terminate a process */
 108 struct terminate_process_request
 109 {
 110     int          handle;       /* process handle to terminate */
 111     int          exit_code;    /* process exit code */
 112 };
 113
 114
 115 /* Terminate a thread */
 116 struct terminate_thread_request
 117 {
 118     int          handle;       /* thread handle to terminate */
 119     int          exit_code;    /* thread exit code */
 120 };
 121
 122
 123 /* Retrieve information about a process */
 124 struct get_process_info_request
 125 {
 126     int          handle;       /* process handle */
 127 };
 128 struct get_process_info_reply
 129 {
 130     void*        pid;              /* server process id */
 131     int          exit_code;        /* process exit code */
 132     int          priority;         /* priority class */
 133     int          process_affinity; /* process affinity mask */
 134     int          system_affinity;  /* system affinity mask */
 135 };
 136
 137
 138 /* Set a process informations */
 139 struct set_process_info_request
 140 {
 141     int          handle;       /* process handle */
 142     int          mask;         /* setting mask (see below) */
 143     int          priority;     /* priority class */
 144     int          affinity;     /* affinity mask */
 145 };
 146 #define SET_PROCESS_INFO_PRIORITY 0x01
 147 #define SET_PROCESS_INFO_AFFINITY 0x02
 148
 149
 150 /* Retrieve information about a thread */
 151 struct get_thread_info_request
 152 {
 153     int          handle;       /* thread handle */
 154 };
 155 struct get_thread_info_reply
 156 {
 157     void*        tid;          /* server thread id */
 158     int          exit_code;    /* thread exit code */
 159     int          priority;     /* thread priority level */
 160 };
 161
 162
 163 /* Set a thread informations */
 164 struct set_thread_info_request
 165 {
 166     int          handle;       /* thread handle */
 167     int          mask;         /* setting mask (see below) */
 168     int          priority;     /* priority class */
 169     int          affinity;     /* affinity mask */
 170 };
 171 #define SET_THREAD_INFO_PRIORITY 0x01
 172 #define SET_THREAD_INFO_AFFINITY 0x02
 173
 174
 175 /* Suspend a thread */
 176 struct suspend_thread_request
 177 {
 178     int          handle;       /* thread handle */
 179 };
 180 struct suspend_thread_reply
 181 {
 182     int          count;        /* new suspend count */
 183 };
 184
 185
 186 /* Resume a thread */
 187 struct resume_thread_request
 188 {
 189     int          handle;       /* thread handle */
 190 };
 191 struct resume_thread_reply
 192 {
 193     int          count;        /* new suspend count */
 194 };
 195
 196
 197 /* Queue an APC for a thread */
 198 struct queue_apc_request
 199 {
 200     int          handle;       /* thread handle */
 201     void*        func;         /* function to call */
 202     void*        param;        /* param for function to call */
 203 };
 204
 205
 206 /* Close a handle for the current process */
 207 struct close_handle_request
 208 {
 209     int          handle;       /* handle to close */
 210 };
 211
 212
 213 /* Get information about a handle */
 214 struct get_handle_info_request
 215 {
 216     int          handle;       /* handle we are interested in */
 217 };
 218 struct get_handle_info_reply
 219 {
 220     int          flags;        /* handle flags */
 221 };
 222
 223
 224 /* Set a handle information */
 225 struct set_handle_info_request
 226 {
 227     int          handle;       /* handle we are interested in */
 228     int          flags;        /* new handle flags */
 229     int          mask;         /* mask for flags to set */
 230 };
 231
 232
 233 /* Duplicate a handle */
 234 struct dup_handle_request
 235 {
 236     int          src_process;  /* src process handle */
 237     int          src_handle;   /* src handle to duplicate */
 238     int          dst_process;  /* dst process handle */
 239     unsigned int access;       /* wanted access rights */
 240     int          inherit;      /* inherit flag */
 241     int          options;      /* duplicate options (see below) */
 242 };
 243 #define DUP_HANDLE_CLOSE_SOURCE  DUPLICATE_CLOSE_SOURCE
 244 #define DUP_HANDLE_SAME_ACCESS   DUPLICATE_SAME_ACCESS
 245 #define DUP_HANDLE_MAKE_GLOBAL   0x80000000  /* Not a Windows flag */
 246 struct dup_handle_reply
 247 {
 248     int          handle;       /* duplicated handle in dst process */
 249 };
 250
 251
 252 /* Open a handle to a process */
 253 struct open_process_request
 254 {
 255     void*        pid;          /* process id to open */
 256     unsigned int access;       /* wanted access rights */
 257     int          inherit;      /* inherit flag */
 258 };
 259 struct open_process_reply
 260 {
 261     int          handle;       /* handle to the process */
 262 };
 263
 264
 265 /* Wait for handles */
 266 struct select_request
 267 {
 268     int          count;        /* handles count */
 269     int          flags;        /* wait flags (see below) */
 270     int          timeout;      /* timeout in ms */
 271     /* int handles[] */
 272 };
 273 struct select_reply
 274 {
 275     int          signaled;     /* signaled handle */
 276 /*  void*        apcs[]; */    /* async procedures to call */
 277 };
 278 #define SELECT_ALL       1
 279 #define SELECT_ALERTABLE 2
 280 #define SELECT_TIMEOUT   4
 281
 282
 283 /* Create an event */
 284 struct create_event_request
 285 {
 286     int          manual_reset;  /* manual reset event */
 287     int          initial_state; /* initial state of the event */
 288     int          inherit;       /* inherit flag */
 289     char         name[0];       /* event name */
 290 };
 291 struct create_event_reply
 292 {
 293     int          handle;        /* handle to the event */
 294 };
 295
 296 /* Event operation */
 297 struct event_op_request
 298 {
 299     int           handle;       /* handle to event */
 300     int           op;           /* event operation (see below) */
 301 };
 302 enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT };
 303
 304
 305 /* Create a mutex */
 306 struct create_mutex_request
 307 {
 308     int          owned;         /* initially owned? */
 309     int          inherit;       /* inherit flag */
 310     char         name[0];       /* mutex name */
 311 };
 312 struct create_mutex_reply
 313 {
 314     int          handle;        /* handle to the mutex */
 315 };
 316
 317
 318 /* Release a mutex */
 319 struct release_mutex_request
 320 {
 321     int          handle;        /* handle to the mutex */
 322 };
 323
 324
 325 /* Create a semaphore */
 326 struct create_semaphore_request
 327 {
 328     unsigned int initial;       /* initial count */
 329     unsigned int max;           /* maximum count */
 330     int          inherit;       /* inherit flag */
 331     char         name[0];       /* semaphore name */
 332 };
 333 struct create_semaphore_reply
 334 {
 335     int          handle;        /* handle to the semaphore */
 336 };
 337
 338
 339 /* Release a semaphore */
 340 struct release_semaphore_request
 341 {
 342     int          handle;        /* handle to the semaphore */
 343     unsigned int count;         /* count to add to semaphore */
 344 };
 345 struct release_semaphore_reply
 346 {
 347     unsigned int prev_count;    /* previous semaphore count */
 348 };
 349
 350
 351 /* Open a named object (event, mutex, semaphore) */
 352 struct open_named_obj_request
 353 {
 354     int          type;          /* object type (see below) */
 355     unsigned int access;        /* wanted access rights */
 356     int          inherit;       /* inherit flag */
 357     char         name[0];       /* object name */
 358 };
 359 enum open_named_obj { OPEN_EVENT, OPEN_MUTEX, OPEN_SEMAPHORE, OPEN_MAPPING };
 360
 361 struct open_named_obj_reply
 362 {
 363     int          handle;        /* handle to the object */
 364 };
 365
 366
 367 /* Create a file */
 368 struct create_file_request
 369 {
 370     unsigned int access;        /* wanted access rights */
 371     int          inherit;       /* inherit flag */
 372     unsigned int sharing;       /* sharing flags */
 373     int          create;        /* file create action */
 374     unsigned int attrs;         /* file attributes for creation */
 375     char         name[0];       /* file name */
 376 };
 377 struct create_file_reply
 378 {
 379     int          handle;        /* handle to the file */
 380 };
 381
 382
 383 /* Get a Unix fd to read from a file */
 384 struct get_read_fd_request
 385 {
 386     int          handle;        /* handle to the file */
 387 };
 388
 389
 390 /* Get a Unix fd to write to a file */
 391 struct get_write_fd_request
 392 {
 393     int          handle;        /* handle to the file */
 394 };
 395
 396
 397 /* Set a file current position */
 398 struct set_file_pointer_request
 399 {
 400     int          handle;        /* handle to the file */
 401     int          low;           /* position low word */
 402     int          high;          /* position high word */
 403     int          whence;        /* whence to seek */
 404 };
 405 struct set_file_pointer_reply
 406 {
 407     int          low;           /* new position low word */
 408     int          high;          /* new position high word */
 409 };
 410
 411
 412 /* Truncate (or extend) a file */
 413 struct truncate_file_request
 414 {
 415     int          handle;        /* handle to the file */
 416 };
 417
 418
 419 /* Set a file access and modification times */
 420 struct set_file_time_request
 421 {
 422     int          handle;        /* handle to the file */
 423     time_t       access_time;   /* last access time */
 424     time_t       write_time;    /* last write time */
 425 };
 426
 427
 428 /* Flush a file buffers */
 429 struct flush_file_request
 430 {
 431     int          handle;        /* handle to the file */
 432 };
 433
 434
 435 /* Get information about a file */
 436 struct get_file_info_request
 437 {
 438     int          handle;        /* handle to the file */
 439 };
 440 struct get_file_info_reply
 441 {
 442     int          type;          /* file type */
 443     int          attr;          /* file attributes */
 444     time_t       access_time;   /* last access time */
 445     time_t       write_time;    /* last write time */
 446     int          size_high;     /* file size */
 447     int          size_low;      /* file size */
 448     int          links;         /* number of links */
 449     int          index_high;    /* unique index */
 450     int          index_low;     /* unique index */
 451     unsigned int serial;        /* volume serial number */
 452 };
 453
 454
 455 /* Lock a region of a file */
 456 struct lock_file_request
 457 {
 458     int          handle;        /* handle to the file */
 459     unsigned int offset_low;    /* offset of start of lock */
 460     unsigned int offset_high;   /* offset of start of lock */
 461     unsigned int count_low;     /* count of bytes to lock */
 462     unsigned int count_high;    /* count of bytes to lock */
 463 };
 464
 465
 466 /* Unlock a region of a file */
 467 struct unlock_file_request
 468 {
 469     int          handle;        /* handle to the file */
 470     unsigned int offset_low;    /* offset of start of unlock */
 471     unsigned int offset_high;   /* offset of start of unlock */
 472     unsigned int count_low;     /* count of bytes to unlock */
 473     unsigned int count_high;    /* count of bytes to unlock */
 474 };
 475
 476
 477 /* Create an anonymous pipe */
 478 struct create_pipe_request
 479 {
 480     int          inherit;       /* inherit flag */
 481 };
 482 struct create_pipe_reply
 483 {
 484     int          handle_read;   /* handle to the read-side of the pipe */
 485     int          handle_write;  /* handle to the write-side of the pipe */
 486 };
 487
 488
 489 /* Allocate a console for the current process */
 490 struct alloc_console_request
 491 {
 492 };
 493
 494
 495 /* Free the console of the current process */
 496 struct free_console_request
 497 {
 498 };
 499
 500
 501 /* Open a handle to the process console */
 502 struct open_console_request
 503 {
 504     int          output;        /* input or output? */
 505     unsigned int access;        /* wanted access rights */
 506     int          inherit;       /* inherit flag */
 507 };
 508 struct open_console_reply
 509 {
 510     int          handle;        /* handle to the console */
 511 };
 512
 513
 514 /* Set a console file descriptor */
 515 struct set_console_fd_request
 516 {
 517     int          handle;        /* handle to the console */
 518     int          pid;           /* pid of xterm (hack) */
 519 };
 520
 521
 522 /* Get a console mode (input or output) */
 523 struct get_console_mode_request
 524 {
 525     int          handle;        /* handle to the console */
 526 };
 527 struct get_console_mode_reply
 528 {
 529     int          mode;          /* console mode */
 530 };
 531
 532
 533 /* Set a console mode (input or output) */
 534 struct set_console_mode_request
 535 {
 536     int          handle;        /* handle to the console */
 537     int          mode;          /* console mode */
 538 };
 539
 540
 541 /* Set info about a console (output only) */
 542 struct set_console_info_request
 543 {
 544     int          handle;        /* handle to the console */
 545     int          mask;          /* setting mask (see below) */
 546     int          cursor_size;   /* size of cursor (percentage filled) */
 547     int          cursor_visible;/* cursor visibility flag */
 548     char         title[0];      /* console title */
 549 };
 550 #define SET_CONSOLE_INFO_CURSOR 0x01
 551 #define SET_CONSOLE_INFO_TITLE  0x02
 552
 553 /* Get info about a console (output only) */
 554 struct get_console_info_request
 555 {
 556     int          handle;        /* handle to the console */
 557 };
 558 struct get_console_info_reply
 559 {
 560     int          cursor_size;   /* size of cursor (percentage filled) */
 561     int          cursor_visible;/* cursor visibility flag */
 562     int          pid;           /* pid of xterm (hack) */
 563 /*  char         title[0]; */   /* console title */
 564 };
 565
 566
 567 /* Add input records to a console input queue */
 568 struct write_console_input_request
 569 {
 570     int          handle;        /* handle to the console input */
 571     int          count;         /* number of input records */
 572 /*  INPUT_RECORD records[0]; */ /* input records */
 573 };
 574 struct write_console_input_reply
 575 {
 576     int          written;       /* number of records written */
 577 };
 578
 579 /* Fetch input records from a console input queue */
 580 struct read_console_input_request
 581 {
 582     int          handle;        /* handle to the console input */
 583     int          count;         /* max number of records to retrieve */
 584     int          flush;         /* flush the retrieved records from the queue? */
 585 };
 586 struct read_console_input_reply
 587 {
 588 /*  INPUT_RECORD records[0]; */ /* input records */
 589 };
 590
 591
 592 /* Create a change notification */
 593 struct create_change_notification_request
 594 {
 595     int          subtree;       /* watch all the subtree */
 596     int          filter;        /* notification filter */
 597 };
 598 struct create_change_notification_reply
 599 {
 600     int          handle;        /* handle to the change notification */
 601 };
 602
 603
 604 /* Create a file mapping */
 605 struct create_mapping_request
 606 {
 607     int          size_high;     /* mapping size */
 608     int          size_low;      /* mapping size */
 609     int          protect;       /* protection flags (see below) */
 610     int          inherit;       /* inherit flag */
 611     int          handle;        /* file handle */
 612     char         name[0];       /* object name */
 613 };
 614 struct create_mapping_reply
 615 {
 616     int          handle;        /* handle to the mapping */
 617 };
 618 /* protection flags */
 619 #define VPROT_READ       0x01
 620 #define VPROT_WRITE      0x02
 621 #define VPROT_EXEC       0x04
 622 #define VPROT_WRITECOPY  0x08
 623 #define VPROT_GUARD      0x10
 624 #define VPROT_NOCACHE    0x20
 625 #define VPROT_COMMITTED  0x40
 626
 627
 628 /* Get information about a file mapping */
 629 struct get_mapping_info_request
 630 {
 631     int          handle;        /* handle to the mapping */
 632 };
 633 struct get_mapping_info_reply
 634 {
 635     int          size_high;     /* mapping size */
 636     int          size_low;      /* mapping size */
 637     int          protect;       /* protection flags */
 638 };
 639
 640
 641 /* Create a device */
 642 struct create_device_request
 643 {
 644     unsigned int access;        /* wanted access rights */
 645     int          inherit;       /* inherit flag */
 646     int          id;            /* client private id */
 647 };
 648 struct create_device_reply
 649 {
 650     int          handle;        /* handle to the device */
 651 };
 652
 653
 654 /* Create a snapshot */
 655 struct create_snapshot_request
 656 {
 657     int          inherit;       /* inherit flag */
 658     int          flags;         /* snapshot flags (TH32CS_*) */
 659 };
 660 struct create_snapshot_reply
 661 {
 662     int          handle;        /* handle to the snapshot */
 663 };
 664
 665
 666 /* Get the next process from a snapshot */
 667 struct next_process_request
 668 {
 669     int          handle;        /* handle to the snapshot */
 670     int          reset;         /* reset snapshot position? */
 671 };
 672 struct next_process_reply
 673 {
 674     void*        pid;          /* process id */
 675     int          threads;      /* number of threads */
 676     int          priority;     /* process priority */
 677 };
 678
 679
 680 /* client-side functions */
 681
 682 #ifndef __WINE_SERVER__
 683
 684 #include "server/request.h"
 685
 686 /* client communication functions */
 687 extern void CLIENT_SendRequest( enum request req, int pass_fd,
 688                                 int n, ... /* arg_1, len_1, etc. */ );
 689 extern unsigned int CLIENT_WaitReply( int *len, int *passed_fd,
 690                                       int n, ... /* arg_1, len_1, etc. */ );
 691 extern unsigned int CLIENT_WaitSimpleReply( void *reply, int len, int *passed_fd );
 692 extern int CLIENT_InitServer(void);
 693
 694 struct _THDB;
 695 extern int CLIENT_SetDebug( int level );
 696 extern int CLIENT_InitThread(void);
 697 #endif  /* __WINE_SERVER__ */
 698
 699 #endif  /* __WINE_SERVER_H */