protocol.def 71.4 KB
Newer Older
1 2 3 4 5 6 7 8
/* -*- C -*-
 *
 * Wine server protocol definition
 *
 * Copyright (C) 2001 Alexandre Julliard
 *
 * This file is used by tools/make_requests to build the
 * protocol structures in include/wine/server_protocol.h
9 10 11 12 13 14 15 16 17 18 19 20 21 22
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
23 24 25 26
 */

@HEADER  /* start of C declarations */

27
#include <stdarg.h>
28 29
#include <stdlib.h>
#include <time.h>
30 31 32

#include <windef.h>
#include <winbase.h>
33 34 35

struct request_header
{
36 37 38
    int          req;          /* request code */
    size_t       request_size; /* request variable part size */
    size_t       reply_size;   /* reply variable part maximum size */
39 40 41 42
};

struct reply_header
{
43 44
    unsigned int error;        /* error result */
    size_t       reply_size;   /* reply variable part size */
45 46 47 48 49 50 51 52 53
};

/* placeholder structure for the maximum allowed request size */
/* this is used to construct the generic_request union */
struct request_max_size
{
    int pad[16]; /* the max request size is 16 ints */
};

54 55
typedef void *obj_handle_t;
typedef void *user_handle_t;
56
typedef unsigned short atom_t;
57 58
typedef unsigned int process_id_t;
typedef unsigned int thread_id_t;
59

60 61 62 63
#define FIRST_USER_HANDLE 0x0020  /* first possible value for low word of user handle */
#define LAST_USER_HANDLE  0xffef  /* last possible value for low word of user handle */


64 65 66 67 68 69 70 71
/* definitions of the event data depending on the event code */
struct debug_event_exception
{
    EXCEPTION_RECORD record;   /* exception record */
    int              first;    /* first chance exception? */
};
struct debug_event_create_thread
{
72 73 74
    obj_handle_t handle;     /* handle to the new thread */
    void        *teb;        /* thread teb (in debugged process address space) */
    void        *start;      /* thread startup routine */
75 76 77
};
struct debug_event_create_process
{
78 79 80 81 82 83 84 85 86 87
    obj_handle_t file;       /* handle to the process exe file */
    obj_handle_t process;    /* handle to the new process */
    obj_handle_t thread;     /* handle to the new thread */
    void        *base;       /* base of executable image */
    int          dbg_offset; /* offset of debug info in file */
    int          dbg_size;   /* size of debug info */
    void        *teb;        /* thread teb (in debugged process address space) */
    void        *start;      /* thread startup routine */
    void        *name;       /* image name (optional) */
    int          unicode;    /* is it Unicode? */
88 89 90
};
struct debug_event_exit
{
91
    int          exit_code;  /* thread or process exit code */
92 93 94
};
struct debug_event_load_dll
{
95 96 97 98 99 100
    obj_handle_t handle;     /* file handle for the dll */
    void        *base;       /* base address of the dll */
    int          dbg_offset; /* offset of debug info in file */
    int          dbg_size;   /* size of debug info */
    void        *name;       /* image name (optional) */
    int          unicode;    /* is it Unicode? */
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
};
struct debug_event_unload_dll
{
    void       *base;       /* base address of the dll */
};
struct debug_event_output_string
{
    void       *string;     /* string to display (in debugged process address space) */
    int         unicode;    /* is it Unicode? */
    int         length;     /* string length */
};
struct debug_event_rip_info
{
    int         error;      /* ??? */
    int         type;       /* ??? */
};
union debug_event_data
{
    struct debug_event_exception      exception;
    struct debug_event_create_thread  create_thread;
    struct debug_event_create_process create_process;
    struct debug_event_exit           exit;
    struct debug_event_load_dll       load_dll;
    struct debug_event_unload_dll     unload_dll;
    struct debug_event_output_string  output_string;
    struct debug_event_rip_info       rip_info;
};

/* debug event data */
typedef struct
{
    int                      code;   /* event code */
    union debug_event_data   info;   /* event information */
} debug_event_t;

/* structure used in sending an fd from client to server */
struct send_fd
{
139 140
    thread_id_t tid;  /* thread id */
    int         fd;   /* file descriptor on client-side */
141 142 143 144 145 146 147 148 149
};

/* structure sent by the server on the wait fifo */
struct wake_up_reply
{
    void *cookie;    /* magic cookie that was passed in select_request */
    int   signaled;  /* wait result */
};

150 151 152 153 154 155 156
/* structure for absolute timeouts */
typedef struct
{
    int            sec;      /* seconds since Unix epoch */
    int            usec;     /* microseconds */
} abs_time_t;

157 158 159 160 161
/* structure returned in the list of window properties */
typedef struct
{
    atom_t         atom;     /* property atom */
    short          string;   /* was atom a string originally? */
162
    obj_handle_t   handle;   /* handle stored in property */
163 164
} property_data_t;

165 166 167 168 169 170 171 172 173
/* structure to specify window rectangles */
typedef struct
{
    int  left;
    int  top;
    int  right;
    int  bottom;
} rectangle_t;

174 175 176 177 178 179 180
/* structure for console char/attribute info */
typedef struct
{
    WCHAR          ch;
    unsigned short attr;
} char_info_t;

181 182 183 184 185 186 187
/****************************************************************/
/* Request declarations */

/* Create a new process from the context of the parent */
@REQ(new_process)
    int          inherit_all;  /* inherit all handles from parent */
    int          create_flags; /* creation flags */
188
    int          unix_pid;     /* Unix pid of new process */
189 190 191 192
    obj_handle_t exe_file;     /* file handle for main exe */
    obj_handle_t hstdin;       /* handle for stdin */
    obj_handle_t hstdout;      /* handle for stdout */
    obj_handle_t hstderr;      /* handle for stderr */
193
    VARARG(info,startup_info); /* startup information */
194
@REPLY
195
    obj_handle_t info;         /* new process info handle */
196 197 198 199 200
@END


/* Retrieve information about a newly started process */
@REQ(get_new_process_info)
201
    obj_handle_t info;         /* info handle returned from new_process_request */
202 203 204
    int          pinherit;     /* process handle inherit flag */
    int          tinherit;     /* thread handle inherit flag */
@REPLY
205
    process_id_t pid;          /* process id */
206
    obj_handle_t phandle;      /* process handle (in the current process) */
207
    thread_id_t  tid;          /* thread id */
208
    obj_handle_t thandle;      /* thread handle (in the current process) */
209
    int          success;      /* did the process start successfully? */
210 211 212 213 214 215 216 217 218
@END


/* Create a new thread from the context of the parent */
@REQ(new_thread)
    int          suspend;      /* new thread should be suspended on creation */
    int          inherit;      /* inherit flag */
    int          request_fd;   /* fd for request pipe */
@REPLY
219
    thread_id_t  tid;          /* thread id */
220
    obj_handle_t handle;       /* thread handle (in the current process) */
221 222 223 224 225 226 227 228 229 230 231
@END


/* Signal that we are finished booting on the client side */
@REQ(boot_done)
    int          debug_level;  /* new debug level */
@END


/* Initialize a process; called from the new process context */
@REQ(init_process)
232
    void*        peb;          /* addr of PEB */
233 234 235 236
    void*        ldt_copy;     /* addr of LDT copy */
@REPLY
    int          create_flags; /* creation flags */
    unsigned int server_start; /* server start time (GetTickCount) */
237
    size_t       info_size;    /* total size of startup info */
238 239 240 241
    obj_handle_t exe_file;     /* file handle for main exe */
    obj_handle_t hstdin;       /* handle for stdin */
    obj_handle_t hstdout;      /* handle for stdout */
    obj_handle_t hstderr;      /* handle for stderr */
242 243 244 245 246 247 248
@END


/* Retrieve the new process startup info */
@REQ(get_startup_info)
@REPLY
    VARARG(info,startup_info); /* startup information */
249 250 251 252 253 254
@END


/* Signal the end of the process initialization */
@REQ(init_process_done)
    void*        module;       /* main module base address */
255
    size_t       module_size;  /* main module size */
256 257
    void*        entry;        /* process entry point */
    void*        name;         /* ptr to ptr to name (in process addr space) */
258
    obj_handle_t exe_file;     /* file handle for main exe */
259
    int          gui;          /* is it a GUI process? */
260
    VARARG(filename,unicode_str); /* file name of main exe */
261 262 263 264 265 266
@END


/* Initialize a thread; called from the child after fork()/clone() */
@REQ(init_thread)
    int          unix_pid;     /* Unix pid of new thread */
267
    int          unix_tid;     /* Unix tid of new thread */
268 269 270 271 272
    void*        teb;          /* TEB of new thread (in thread address space) */
    void*        entry;        /* thread entry point (in thread address space) */
    int          reply_fd;     /* fd for reply pipe */
    int          wait_fd;      /* fd for blocking calls pipe */
@REPLY
273 274
    process_id_t pid;          /* process id of the new thread's process */
    thread_id_t  tid;          /* thread id of the new thread */
275 276 277 278 279 280 281
    int          boot;         /* is this the boot thread? */
    int          version;      /* protocol version */
@END


/* Terminate a process */
@REQ(terminate_process)
282
    obj_handle_t handle;       /* process handle to terminate */
283 284 285 286 287 288 289 290
    int          exit_code;    /* process exit code */
@REPLY
    int          self;         /* suicide? */
@END


/* Terminate a thread */
@REQ(terminate_thread)
291
    obj_handle_t handle;       /* thread handle to terminate */
292 293 294 295 296 297 298 299 300
    int          exit_code;    /* thread exit code */
@REPLY
    int          self;         /* suicide? */
    int          last;         /* last thread in this process? */
@END


/* Retrieve information about a process */
@REQ(get_process_info)
301
    obj_handle_t handle;           /* process handle */
302
@REPLY
303
    process_id_t pid;              /* server process id */
304 305 306 307 308 309 310 311 312
    int          exit_code;        /* process exit code */
    int          priority;         /* priority class */
    int          process_affinity; /* process affinity mask */
    int          system_affinity;  /* system affinity mask */
@END


/* Set a process informations */
@REQ(set_process_info)
313
    obj_handle_t handle;       /* process handle */
314 315 316 317 318 319 320 321 322 323
    int          mask;         /* setting mask (see below) */
    int          priority;     /* priority class */
    int          affinity;     /* affinity mask */
@END
#define SET_PROCESS_INFO_PRIORITY 0x01
#define SET_PROCESS_INFO_AFFINITY 0x02


/* Retrieve information about a thread */
@REQ(get_thread_info)
324 325
    obj_handle_t handle;        /* thread handle */
    thread_id_t  tid_in;        /* thread id (optional) */
326
@REPLY
327
    process_id_t pid;           /* server process id */
328 329 330 331
    thread_id_t  tid;           /* server thread id */
    void*        teb;           /* thread teb pointer */
    int          exit_code;     /* thread exit code */
    int          priority;      /* thread priority level */
332
    int          affinity;      /* thread affinity mask */
333 334
    time_t       creation_time; /* thread creation time */
    time_t       exit_time;     /* thread exit time */
335 336 337 338 339
@END


/* Set a thread informations */
@REQ(set_thread_info)
340
    obj_handle_t handle;       /* thread handle */
341 342 343 344 345 346 347 348
    int          mask;         /* setting mask (see below) */
    int          priority;     /* priority class */
    int          affinity;     /* affinity mask */
@END
#define SET_THREAD_INFO_PRIORITY 0x01
#define SET_THREAD_INFO_AFFINITY 0x02


349 350 351 352 353 354 355
/* Retrieve information about a module */
@REQ(get_dll_info)
    obj_handle_t handle;       /* process handle */
    void*        base_address; /* base address of module */
@REPLY
    size_t       size;          /* module size */
    void*        entry_point;
356
    VARARG(filename,unicode_str); /* file name of module */
357 358 359
@END


360 361
/* Suspend a thread */
@REQ(suspend_thread)
362
    obj_handle_t handle;       /* thread handle */
363 364 365 366 367 368 369
@REPLY
    int          count;        /* new suspend count */
@END


/* Resume a thread */
@REQ(resume_thread)
370
    obj_handle_t handle;       /* thread handle */
371 372 373 374 375 376 377
@REPLY
    int          count;        /* new suspend count */
@END


/* Notify the server that a dll has been loaded */
@REQ(load_dll)
378
    obj_handle_t handle;       /* file handle */
379
    void*        base;         /* base address */
380
    size_t       size;         /* dll size */
381 382 383
    int          dbg_offset;   /* debug info offset */
    int          dbg_size;     /* debug info size */
    void*        name;         /* ptr to ptr to name (in process addr space) */
384
    VARARG(filename,unicode_str); /* file name of dll */
385 386 387 388 389 390 391 392 393 394 395
@END


/* Notify the server that a dll is being unloaded */
@REQ(unload_dll)
    void*        base;         /* base address */
@END


/* Queue an APC for a thread */
@REQ(queue_apc)
396
    obj_handle_t handle;       /* thread handle */
397 398
    int          user;         /* user or system apc? */
    void*        func;         /* function to call */
399 400 401
    void*        arg1;         /* params for function to call */
    void*        arg2;
    void*        arg3;
402 403 404 405 406 407 408 409 410
@END


/* Get next APC to call */
@REQ(get_apc)
    int          alertable;    /* is thread alertable? */
@REPLY
    void*        func;         /* function to call */
    int          type;         /* function type */
411 412 413
    void*        arg1;         /* function arguments */
    void*        arg2;
    void*        arg3;
414
@END
415
enum apc_type { APC_NONE, APC_USER, APC_TIMER, APC_ASYNC, APC_ASYNC_IO };
416 417 418 419


/* Close a handle for the current process */
@REQ(close_handle)
420
    obj_handle_t handle;       /* handle to close */
421 422 423 424 425 426 427
@REPLY
    int          fd;           /* associated fd to close */
@END


/* Set a handle information */
@REQ(set_handle_info)
428
    obj_handle_t handle;       /* handle we are interested in */
429 430 431 432 433 434 435 436 437 438 439
    int          flags;        /* new handle flags */
    int          mask;         /* mask for flags to set */
    int          fd;           /* file descriptor or -1 */
@REPLY
    int          old_flags;    /* old flag value */
    int          cur_fd;       /* current file descriptor */
@END


/* Duplicate a handle */
@REQ(dup_handle)
440 441 442
    obj_handle_t src_process;  /* src process handle */
    obj_handle_t src_handle;   /* src handle to duplicate */
    obj_handle_t dst_process;  /* dst process handle */
443 444 445 446
    unsigned int access;       /* wanted access rights */
    int          inherit;      /* inherit flag */
    int          options;      /* duplicate options (see below) */
@REPLY
447
    obj_handle_t handle;       /* duplicated handle in dst process */
448 449 450 451 452 453 454 455 456
    int          fd;           /* associated fd to close */
@END
#define DUP_HANDLE_CLOSE_SOURCE  DUPLICATE_CLOSE_SOURCE
#define DUP_HANDLE_SAME_ACCESS   DUPLICATE_SAME_ACCESS
#define DUP_HANDLE_MAKE_GLOBAL   0x80000000  /* Not a Windows flag */


/* Open a handle to a process */
@REQ(open_process)
457
    process_id_t pid;          /* process id to open */
458 459 460
    unsigned int access;       /* wanted access rights */
    int          inherit;      /* inherit flag */
@REPLY
461
    obj_handle_t handle;       /* handle to the process */
462 463 464
@END


465 466
/* Open a handle to a thread */
@REQ(open_thread)
467
    thread_id_t  tid;          /* thread id to open */
468 469 470
    unsigned int access;       /* wanted access rights */
    int          inherit;      /* inherit flag */
@REPLY
471
    obj_handle_t handle;       /* handle to the thread */
472 473 474
@END


475 476 477 478
/* Wait for handles */
@REQ(select)
    int          flags;        /* wait flags (see below) */
    void*        cookie;       /* magic cookie to return to client */
479
    abs_time_t   timeout;      /* absolute timeout */
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
    VARARG(handles,handles);   /* handles to select on */
@END
#define SELECT_ALL           1
#define SELECT_ALERTABLE     2
#define SELECT_INTERRUPTIBLE 4
#define SELECT_TIMEOUT       8


/* Create an event */
@REQ(create_event)
    int          manual_reset;  /* manual reset event */
    int          initial_state; /* initial state of the event */
    int          inherit;       /* inherit flag */
    VARARG(name,unicode_str);   /* object name */
@REPLY
495
    obj_handle_t handle;        /* handle to the event */
496 497 498 499
@END

/* Event operation */
@REQ(event_op)
500
    obj_handle_t  handle;       /* handle to event */
501 502 503 504 505 506 507 508 509 510 511
    int           op;           /* event operation (see below) */
@END
enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT };


/* Open an event */
@REQ(open_event)
    unsigned int access;        /* wanted access rights */
    int          inherit;       /* inherit flag */
    VARARG(name,unicode_str);   /* object name */
@REPLY
512
    obj_handle_t handle;        /* handle to the event */
513 514 515 516 517 518 519 520 521
@END


/* Create a mutex */
@REQ(create_mutex)
    int          owned;         /* initially owned? */
    int          inherit;       /* inherit flag */
    VARARG(name,unicode_str);   /* object name */
@REPLY
522
    obj_handle_t handle;        /* handle to the mutex */
523 524 525 526 527
@END


/* Release a mutex */
@REQ(release_mutex)
528
    obj_handle_t handle;        /* handle to the mutex */
529 530 531 532 533 534 535 536 537
@END


/* Open a mutex */
@REQ(open_mutex)
    unsigned int access;        /* wanted access rights */
    int          inherit;       /* inherit flag */
    VARARG(name,unicode_str);   /* object name */
@REPLY
538
    obj_handle_t handle;        /* handle to the mutex */
539 540 541 542 543 544 545 546 547 548
@END


/* Create a semaphore */
@REQ(create_semaphore)
    unsigned int initial;       /* initial count */
    unsigned int max;           /* maximum count */
    int          inherit;       /* inherit flag */
    VARARG(name,unicode_str);   /* object name */
@REPLY
549
    obj_handle_t handle;        /* handle to the semaphore */
550 551 552 553 554
@END


/* Release a semaphore */
@REQ(release_semaphore)
555
    obj_handle_t handle;        /* handle to the semaphore */
556 557 558 559 560 561 562 563 564 565 566 567
    unsigned int count;         /* count to add to semaphore */
@REPLY
    unsigned int prev_count;    /* previous semaphore count */
@END


/* Open a semaphore */
@REQ(open_semaphore)
    unsigned int access;        /* wanted access rights */
    int          inherit;       /* inherit flag */
    VARARG(name,unicode_str);   /* object name */
@REPLY
568
    obj_handle_t handle;        /* handle to the semaphore */
569 570 571 572 573 574 575 576 577 578
@END


/* Create a file */
@REQ(create_file)
    unsigned int access;        /* wanted access rights */
    int          inherit;       /* inherit flag */
    unsigned int sharing;       /* sharing flags */
    int          create;        /* file create action */
    unsigned int attrs;         /* file attributes for creation */
579
    int          removable;     /* is file on removable media? */
580 581
    VARARG(filename,string);    /* file name */
@REPLY
582
    obj_handle_t handle;        /* handle to the file */
583 584 585 586 587 588
@END


/* Allocate a file handle for a Unix fd */
@REQ(alloc_file_handle)
    unsigned int access;        /* wanted access rights */
589
    int          inherit;       /* inherit flag */
590 591
    int          fd;            /* file descriptor on the client side */
@REPLY
592
    obj_handle_t handle;        /* handle to the file */
593 594 595 596 597
@END


/* Get a Unix fd to access a file */
@REQ(get_handle_fd)
598
    obj_handle_t handle;        /* handle to the file */
599 600 601
    unsigned int access;        /* wanted access rights */
@REPLY
    int          fd;            /* file descriptor */
602 603
    int          type;          /* the type of file (see below) */
    int          flags;         /* file read/write flags (see below) */
604
@END
605 606 607 608
enum fd_type
{
    FD_TYPE_INVALID,
    FD_TYPE_DEFAULT,
609
    FD_TYPE_SOCKET,
610
    FD_TYPE_SMB
611
};
612 613 614 615
#define FD_FLAG_OVERLAPPED         0x01
#define FD_FLAG_TIMEOUT            0x02
#define FD_FLAG_RECV_SHUTDOWN      0x04
#define FD_FLAG_SEND_SHUTDOWN      0x08
616 617 618

/* Set a file current position */
@REQ(set_file_pointer)
619
    obj_handle_t handle;        /* handle to the file */
620 621 622 623 624 625 626 627 628 629 630
    int          low;           /* position low word */
    int          high;          /* position high word */
    int          whence;        /* whence to seek */
@REPLY
    int          new_low;       /* new position low word */
    int          new_high;      /* new position high word */
@END


/* Truncate (or extend) a file */
@REQ(truncate_file)
631
    obj_handle_t handle;        /* handle to the file */
632 633 634 635 636
@END


/* Set a file access and modification times */
@REQ(set_file_time)
637
    obj_handle_t handle;        /* handle to the file */
638 639 640 641 642 643 644
    time_t       access_time;   /* last access time */
    time_t       write_time;    /* last write time */
@END


/* Flush a file buffers */
@REQ(flush_file)
645
    obj_handle_t handle;        /* handle to the file */
646 647
@REPLY
    obj_handle_t event;         /* event set when finished */
648 649 650 651 652
@END


/* Get information about a file */
@REQ(get_file_info)
653
    obj_handle_t handle;        /* handle to the file */
654 655 656 657 658
@REPLY
    int          type;          /* file type */
    int          attr;          /* file attributes */
    time_t       access_time;   /* last access time */
    time_t       write_time;    /* last write time */
659
    time_t       change_time;   /* last change time */
660 661
    int          size_high;     /* file size */
    int          size_low;      /* file size */
662 663
    int          alloc_high;    /* size used on disk */
    int          alloc_low;     /* size used on disk */
664 665 666 667 668 669 670 671 672
    int          links;         /* number of links */
    int          index_high;    /* unique index */
    int          index_low;     /* unique index */
    unsigned int serial;        /* volume serial number */
@END


/* Lock a region of a file */
@REQ(lock_file)
673
    obj_handle_t handle;        /* handle to the file */
674 675 676 677
    unsigned int offset_low;    /* offset of start of lock */
    unsigned int offset_high;   /* offset of start of lock */
    unsigned int count_low;     /* count of bytes to lock */
    unsigned int count_high;    /* count of bytes to lock */
678 679 680 681 682
    int          shared;        /* shared or exclusive lock? */
    int          wait;          /* do we want to wait? */
@REPLY
    obj_handle_t handle;        /* handle to wait on */
    int          overlapped;    /* is it an overlapped I/O handle? */
683 684 685 686 687
@END


/* Unlock a region of a file */
@REQ(unlock_file)
688
    obj_handle_t handle;        /* handle to the file */
689 690 691 692 693 694 695 696 697 698 699 700 701 702
    unsigned int offset_low;    /* offset of start of unlock */
    unsigned int offset_high;   /* offset of start of unlock */
    unsigned int count_low;     /* count of bytes to unlock */
    unsigned int count_high;    /* count of bytes to unlock */
@END


/* Create a socket */
@REQ(create_socket)
    unsigned int access;        /* wanted access rights */
    int          inherit;       /* inherit flag */
    int          family;        /* family, see socket manpage */
    int          type;          /* type, see socket manpage */
    int          protocol;      /* protocol, see socket manpage */
703
    unsigned int flags;         /* socket flags */
704
@REPLY
705
    obj_handle_t handle;        /* handle to the new socket */
706 707 708 709 710
@END


/* Accept a socket */
@REQ(accept_socket)
711
    obj_handle_t lhandle;       /* handle to the listening socket */
712 713 714
    unsigned int access;        /* wanted access rights */
    int          inherit;       /* inherit flag */
@REPLY
715
    obj_handle_t handle;        /* handle to the new socket */
716 717 718 719 720
@END


/* Set socket event parameters */
@REQ(set_socket_event)
721
    obj_handle_t  handle;        /* handle to the socket */
722
    unsigned int  mask;          /* event mask */
723
    obj_handle_t  event;         /* event object */
724 725
    user_handle_t window;        /* window to send the message to */
    unsigned int  msg;           /* message to send */
726 727 728 729 730
@END


/* Get socket event parameters */
@REQ(get_socket_event)
731
    obj_handle_t handle;        /* handle to the socket */
732
    int          service;       /* clear pending? */
733
    obj_handle_t c_event;       /* event to clear */
734 735 736 737 738 739 740 741 742 743
@REPLY
    unsigned int mask;          /* event mask */
    unsigned int pmask;         /* pending events */
    unsigned int state;         /* status bits */
    VARARG(errors,ints);        /* event errors */
@END


/* Reenable pending socket events */
@REQ(enable_socket_event)
744
    obj_handle_t handle;        /* handle to the socket */
745 746 747 748 749
    unsigned int mask;          /* events to re-enable */
    unsigned int sstate;        /* status bits to set */
    unsigned int cstate;        /* status bits to clear */
@END

750
@REQ(set_socket_deferred)
751 752
    obj_handle_t handle;        /* handle to the socket */
    obj_handle_t deferred;      /* handle to the socket for which accept() is deferred */
753
@END
754

755
/* Allocate a console (only used by a console renderer) */
756 757 758
@REQ(alloc_console)
    unsigned int access;        /* wanted access rights */
    int          inherit;       /* inherit flag */
759
    process_id_t pid;           /* pid of process which shall be attached to the console */
760
@REPLY
761 762
    obj_handle_t handle_in;     /* handle to console input */
    obj_handle_t event;         /* handle to renderer events change notification */
763 764 765 766 767 768 769 770
@END


/* Free the console of the current process */
@REQ(free_console)
@END


771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816
#define CONSOLE_RENDERER_NONE_EVENT        0x00
#define CONSOLE_RENDERER_TITLE_EVENT       0x01
#define CONSOLE_RENDERER_ACTIVE_SB_EVENT   0x02
#define CONSOLE_RENDERER_SB_RESIZE_EVENT   0x03
#define CONSOLE_RENDERER_UPDATE_EVENT      0x04
#define CONSOLE_RENDERER_CURSOR_POS_EVENT  0x05
#define CONSOLE_RENDERER_CURSOR_GEOM_EVENT 0x06
#define CONSOLE_RENDERER_DISPLAY_EVENT     0x07
#define CONSOLE_RENDERER_EXIT_EVENT        0x08
struct console_renderer_event
{
    short event;
    union
    {
        struct update
        {
            short top;
            short bottom;
        } update;
        struct resize
        {
            short width;
            short height;
        } resize;
        struct cursor_pos
        {
            short x;
            short y;
        } cursor_pos;
        struct cursor_geom
        {
            short visible;
            short size;
        } cursor_geom;
        struct display
        {
            short left;
            short top;
            short width;
            short height;
        } display;
    } u;
};

/* retrieve console events for the renderer */
@REQ(get_console_renderer_events)
817
    obj_handle_t handle;        /* handle to console input events */
818 819 820 821 822
@REPLY
    VARARG(data,bytes);         /* the various console_renderer_events */
@END


823 824
/* Open a handle to the process console */
@REQ(open_console)
825 826
    int          from;          /* 0 (resp 1) input (resp output) of current process console */
                                /* otherwise console_in handle to get active screen buffer? */
827 828
    unsigned int access;        /* wanted access rights */
    int          inherit;       /* inherit flag */
829
    int          share;         /* share mask (only for output handles) */
830
@REPLY
831
    obj_handle_t handle;        /* handle to the console */
832 833 834
@END


835 836 837 838 839 840
/* Get the input queue wait event */
@REQ(get_console_wait_event)
@REPLY
    obj_handle_t handle;
@END

841 842
/* Get a console mode (input or output) */
@REQ(get_console_mode)
843
    obj_handle_t handle;        /* handle to the console */
844 845 846 847 848 849 850
@REPLY
    int          mode;          /* console mode */
@END


/* Set a console mode (input or output) */
@REQ(set_console_mode)
851
    obj_handle_t handle;        /* handle to the console */
852 853 854 855
    int          mode;          /* console mode */
@END


856 857
/* Set info about a console (input only) */
@REQ(set_console_input_info)
858
    obj_handle_t handle;        /* handle to console input, or 0 for process' console */
859
    int          mask;          /* setting mask (see below) */
860
    obj_handle_t active_sb;     /* active screen buffer */
861 862
    int          history_mode;  /* whether we duplicate lines in history */
    int          history_size;  /* number of lines in history */
863
    int          edition_mode;  /* index to the edition mode flavors */
864 865 866 867 868 869
    VARARG(title,unicode_str);  /* console title */
@END
#define SET_CONSOLE_INPUT_INFO_ACTIVE_SB        0x01
#define SET_CONSOLE_INPUT_INFO_TITLE            0x02
#define SET_CONSOLE_INPUT_INFO_HISTORY_MODE     0x04
#define SET_CONSOLE_INPUT_INFO_HISTORY_SIZE     0x08
870
#define SET_CONSOLE_INPUT_INFO_EDITION_MODE     0x10
871 872 873 874


/* Get info about a console (input only) */
@REQ(get_console_input_info)
875
    obj_handle_t handle;        /* handle to console input, or 0 for process' console */
876 877 878 879
@REPLY
    int          history_mode;  /* whether we duplicate lines in history */
    int          history_size;  /* number of lines in history */
    int          history_index; /* number of used lines in history */
880
    int          edition_mode;  /* index to the edition mode flavors */
881 882 883 884 885 886
    VARARG(title,unicode_str);  /* console title */
@END


/* appends a string to console's history */
@REQ(append_console_input_history)
887
    obj_handle_t handle;        /* handle to console input, or 0 for process' console */
888 889 890 891 892 893
    VARARG(line,unicode_str);   /* line to add */
@END


/* appends a string to console's history */
@REQ(get_console_input_history)
894
    obj_handle_t handle;        /* handle to console input, or 0 for process' console */
895 896
    int          index;         /* index to get line from */
@REPLY
897
    int          total;         /* total length of line in Unicode chars */
898 899 900 901 902 903
    VARARG(line,unicode_str);   /* line to add */
@END


/* creates a new screen buffer on process' console */
@REQ(create_console_output)
904
    obj_handle_t handle_in;     /* handle to console input, or 0 for process' console */
905 906 907 908
    int          access;        /* wanted access rights */
    int          share;         /* sharing credentials */
    int          inherit;       /* inherit flag */
@REPLY
909
    obj_handle_t handle_out;    /* handle to the screen buffer */
910 911 912
@END


913
/* Set info about a console (output only) */
914
@REQ(set_console_output_info)
915
    obj_handle_t handle;        /* handle to the console */
916
    int          mask;          /* setting mask (see below) */
917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937
    short int    cursor_size;   /* size of cursor (percentage filled) */
    short int    cursor_visible;/* cursor visibility flag */
    short int    cursor_x;      /* position of cursor (x, y) */
    short int    cursor_y;
    short int    width;         /* width of the screen buffer */
    short int    height;        /* height of the screen buffer */
    short int    attr;          /* default attribute */
    short int    win_left;      /* window actually displayed by renderer */
    short int    win_top;       /* the rect area is expressed withing the */
    short int    win_right;     /* boundaries of the screen buffer */
    short int    win_bottom;
    short int    max_width;     /* maximum size (width x height) for the window */
    short int    max_height;
@END
#define SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM     0x01
#define SET_CONSOLE_OUTPUT_INFO_CURSOR_POS      0x02
#define SET_CONSOLE_OUTPUT_INFO_SIZE            0x04
#define SET_CONSOLE_OUTPUT_INFO_ATTR            0x08
#define SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW  0x10
#define SET_CONSOLE_OUTPUT_INFO_MAX_SIZE        0x20

938 939

/* Get info about a console (output only) */
940
@REQ(get_console_output_info)
941
    obj_handle_t handle;        /* handle to the console */
942
@REPLY
943 944 945 946 947 948 949 950 951 952 953 954 955
    short int    cursor_size;   /* size of cursor (percentage filled) */
    short int    cursor_visible;/* cursor visibility flag */
    short int    cursor_x;      /* position of cursor (x, y) */
    short int    cursor_y;
    short int    width;         /* width of the screen buffer */
    short int    height;        /* height of the screen buffer */
    short int    attr;          /* default attribute */
    short int    win_left;      /* window actually displayed by renderer */
    short int    win_top;       /* the rect area is expressed withing the */
    short int    win_right;     /* boundaries of the screen buffer */
    short int    win_bottom;
    short int    max_width;     /* maximum size (width x height) for the window */
    short int    max_height;
956 957 958 959
@END

/* Add input records to a console input queue */
@REQ(write_console_input)
960
    obj_handle_t handle;        /* handle to the console input */
961 962 963 964 965
    VARARG(rec,input_records);  /* input records */
@REPLY
    int          written;       /* number of records written */
@END

966

967 968
/* Fetch input records from a console input queue */
@REQ(read_console_input)
969
    obj_handle_t handle;        /* handle to the console input */
970 971 972 973 974 975 976
    int          flush;         /* flush the retrieved records from the queue? */
@REPLY
    int          read;          /* number of records read */
    VARARG(rec,input_records);  /* input records */
@END


977 978
/* write data (chars and/or attributes) in a screen buffer */
@REQ(write_console_output)
979
    obj_handle_t handle;        /* handle to the console output */
980 981 982 983
    int          x;             /* position where to start writing */
    int          y;
    int          mode;          /* char info (see below) */
    int          wrap;          /* wrap around at end of line? */
984 985
    VARARG(data,bytes);         /* info to write */
@REPLY
986 987 988
    int          written;       /* number of char infos actually written */
    int          width;         /* width of screen buffer */
    int          height;        /* height of screen buffer */
989
@END
990 991 992 993 994 995 996
enum char_info_mode
{
    CHAR_INFO_MODE_TEXT,        /* characters only */
    CHAR_INFO_MODE_ATTR,        /* attributes only */
    CHAR_INFO_MODE_TEXTATTR,    /* both characters and attributes */
    CHAR_INFO_MODE_TEXTSTDATTR  /* characters but use standard attributes */
};
997 998


999 1000
/* fill a screen buffer with constant data (chars and/or attributes) */
@REQ(fill_console_output)
1001
    obj_handle_t handle;        /* handle to the console output */
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
    int          x;             /* position where to start writing */
    int          y;
    int          mode;          /* char info mode */
    int          count;         /* number to write */
    int          wrap;          /* wrap around at end of line? */
    char_info_t  data;          /* data to write */
@REPLY
    int          written;       /* number of char infos actually written */
@END


/* read data (chars and/or attributes) from a screen buffer */
1014
@REQ(read_console_output)
1015
    obj_handle_t handle;        /* handle to the console output */
1016 1017 1018 1019
    int          x;             /* position (x,y) where to start reading */
    int          y;
    int          mode;          /* char info mode */
    int          wrap;          /* wrap around at end of line? */
1020
@REPLY
1021 1022
    int          width;         /* width of screen buffer */
    int          height;        /* height of screen buffer */
1023 1024 1025
    VARARG(data,bytes);
@END

1026

1027 1028
/* move a rect (of data) in screen buffer content */
@REQ(move_console_output)
1029
    obj_handle_t handle;        /* handle to the console output */
1030 1031 1032 1033 1034 1035 1036 1037 1038
    short int    x_src;         /* position (x, y) of rect to start moving from */
    short int    y_src;
    short int    x_dst;         /* position (x, y) of rect to move to */
    short int    y_dst;
    short int    w;             /* size of the rect (width, height) to move */
    short int    h;
@END


1039 1040 1041
/* Sends a signal to a process group */
@REQ(send_console_signal)
    int          signal;        /* the signal to send */
1042
    process_id_t group_id;      /* the group to send the signal to */
1043 1044 1045
@END


1046 1047
/* Create a change notification */
@REQ(create_change_notification)
1048
    obj_handle_t handle;        /* handle to the directory */
1049
    int          subtree;       /* watch all the subtree */
1050
    unsigned int filter;        /* notification filter */
1051
@REPLY
1052
    obj_handle_t handle;        /* handle to the change notification */
1053 1054 1055
@END


1056 1057 1058 1059 1060
/* Move to the next change notification */
@REQ(next_change_notification)
    obj_handle_t handle;        /* handle to the change notification */
@END

1061 1062 1063 1064 1065
/* Create a file mapping */
@REQ(create_mapping)
    int          size_high;     /* mapping size */
    int          size_low;      /* mapping size */
    int          protect;       /* protection flags (see below) */
1066
    unsigned int access;        /* wanted access rights */
1067
    int          inherit;       /* inherit flag */
1068
    obj_handle_t file_handle;   /* file handle */
1069 1070
    VARARG(name,unicode_str);   /* object name */
@REPLY
1071
    obj_handle_t handle;        /* handle to the mapping */
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
@END
/* protection flags */
#define VPROT_READ       0x01
#define VPROT_WRITE      0x02
#define VPROT_EXEC       0x04
#define VPROT_WRITECOPY  0x08
#define VPROT_GUARD      0x10
#define VPROT_NOCACHE    0x20
#define VPROT_COMMITTED  0x40
#define VPROT_IMAGE      0x80


/* Open a mapping */
@REQ(open_mapping)
    unsigned int access;        /* wanted access rights */
    int          inherit;       /* inherit flag */
    VARARG(name,unicode_str);   /* object name */
@REPLY
1090
    obj_handle_t handle;        /* handle to the mapping */
1091 1092 1093 1094 1095
@END


/* Get information about a file mapping */
@REQ(get_mapping_info)
1096
    obj_handle_t handle;        /* handle to the mapping */
1097 1098 1099 1100 1101 1102
@REPLY
    int          size_high;     /* mapping size */
    int          size_low;      /* mapping size */
    int          protect;       /* protection flags */
    int          header_size;   /* header size (for VPROT_IMAGE mapping) */
    void*        base;          /* default base addr (for VPROT_IMAGE mapping) */
1103
    obj_handle_t shared_file;   /* shared mapping file handle */
1104
    int          shared_size;   /* shared mapping size */
1105
    int          removable;     /* is file on removable media? */
1106 1107 1108 1109 1110 1111 1112 1113 1114
@END


/* Create a device */
@REQ(create_device)
    unsigned int access;        /* wanted access rights */
    int          inherit;       /* inherit flag */
    int          id;            /* client private id */
@REPLY
1115
    obj_handle_t handle;        /* handle to the device */
1116 1117 1118
@END


1119 1120 1121 1122 1123 1124 1125 1126
/* Retrieve the client private id for a device */
@REQ(get_device_id)
    obj_handle_t handle;        /* handle to the device */
@REPLY
    int          id;            /* client private id */
@END


1127 1128 1129 1130
#define SNAP_HEAPLIST   0x00000001
#define SNAP_PROCESS    0x00000002
#define SNAP_THREAD     0x00000004
#define SNAP_MODULE     0x00000008
1131 1132 1133
/* Create a snapshot */
@REQ(create_snapshot)
    int          inherit;       /* inherit flag */
1134
    int          flags;         /* snapshot flags (SNAP_*) */
1135
    process_id_t pid;           /* process id */
1136
@REPLY
1137
    obj_handle_t handle;        /* handle to the snapshot */
1138 1139 1140 1141 1142
@END


/* Get the next process from a snapshot */
@REQ(next_process)
1143
    obj_handle_t handle;        /* handle to the snapshot */
1144 1145 1146
    int          reset;         /* reset snapshot position? */
@REPLY
    int          count;         /* process usage count */
1147 1148
    process_id_t pid;           /* process id */
    process_id_t ppid;          /* parent process id */
1149 1150
    void*        heap;          /* heap base */
    void*        module;        /* main module */
1151 1152
    int          threads;       /* number of threads */
    int          priority;      /* process priority */
1153
    int          handles;       /* number of handles */
1154
    VARARG(filename,unicode_str); /* file name of main exe */
1155 1156 1157 1158 1159
@END


/* Get the next thread from a snapshot */
@REQ(next_thread)
1160
    obj_handle_t handle;        /* handle to the snapshot */
1161 1162 1163
    int          reset;         /* reset snapshot position? */
@REPLY
    int          count;         /* thread usage count */
1164 1165
    process_id_t pid;           /* process id */
    thread_id_t  tid;           /* thread id */
1166 1167 1168 1169 1170 1171 1172
    int          base_pri;      /* base priority */
    int          delta_pri;     /* delta priority */
@END


/* Get the next module from a snapshot */
@REQ(next_module)
1173
    obj_handle_t handle;        /* handle to the snapshot */
1174 1175
    int          reset;         /* reset snapshot position? */
@REPLY
1176
    process_id_t pid;           /* process id */
1177
    void*        base;          /* module base address */
1178
    size_t       size;          /* module size */
1179
    VARARG(filename,unicode_str); /* file name of module */
1180 1181 1182 1183 1184 1185 1186
@END


/* Wait for a debug event */
@REQ(wait_debug_event)
    int           get_handle;  /* should we alloc a handle for waiting? */
@REPLY
1187 1188
    process_id_t  pid;         /* process id */
    thread_id_t   tid;         /* thread id */
1189
    obj_handle_t  wait;        /* wait handle if no event ready */
1190 1191 1192 1193 1194 1195 1196 1197 1198
    VARARG(event,debug_event); /* debug event data */
@END


/* Queue an exception event */
@REQ(queue_exception_event)
    int              first;    /* first chance exception? */
    VARARG(record,exc_event);  /* thread context followed by exception record */
@REPLY
1199
    obj_handle_t     handle;   /* handle to the queued event */
1200 1201 1202 1203 1204
@END


/* Retrieve the status of an exception event */
@REQ(get_exception_status)
1205
    obj_handle_t     handle;   /* handle to the queued event */
1206
@REPLY
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
    int              status;   /* event continuation status */
    VARARG(context,context);   /* modified thread context */
@END


/* Send an output string to the debugger */
@REQ(output_debug_string)
    void*         string;      /* string to display (in debugged process address space) */
    int           unicode;     /* is it Unicode? */
    int           length;      /* string length */
@END


/* Continue a debug event */
@REQ(continue_debug_event)
1222 1223
    process_id_t pid;          /* process id to continue */
    thread_id_t  tid;          /* thread id to continue */
1224 1225 1226 1227
    int          status;       /* continuation status */
@END


1228
/* Start/stop debugging an existing process */
1229
@REQ(debug_process)
1230
    process_id_t pid;          /* id of the process to debug */
1231 1232 1233 1234
    int          attach;       /* 1=attaching / 0=detaching from the process */
@END


1235 1236
/* Simulate a breakpoint in a process */
@REQ(debug_break)
1237
    obj_handle_t handle;       /* process handle */
1238 1239 1240 1241 1242
@REPLY
    int          self;         /* was it the caller itself? */
@END


1243 1244 1245
/* Set debugger kill on exit flag */
@REQ(set_debugger_kill_on_exit)
    int          kill_on_exit;  /* 0=detach/1=kill debuggee when debugger dies */
1246 1247 1248 1249 1250
@END


/* Read data from a process address space */
@REQ(read_process_memory)
1251
    obj_handle_t handle;       /* process handle */
1252
    void*        addr;         /* addr to read from */
1253 1254 1255 1256 1257 1258 1259
@REPLY
    VARARG(data,bytes);        /* result data */
@END


/* Write data to a process address space */
@REQ(write_process_memory)
1260
    obj_handle_t handle;       /* process handle */
1261 1262 1263
    void*        addr;         /* addr to write to (must be int-aligned) */
    unsigned int first_mask;   /* mask for first word */
    unsigned int last_mask;    /* mask for last word */
1264
    VARARG(data,bytes);        /* data to write */
1265 1266 1267 1268 1269
@END


/* Create a registry key */
@REQ(create_key)
1270
    obj_handle_t parent;       /* handle to the parent key */
1271 1272 1273
    unsigned int access;       /* desired access rights */
    unsigned int options;      /* creation options */
    time_t       modif;        /* last modification time */
1274 1275 1276
    size_t       namelen;      /* length of key name in bytes */
    VARARG(name,unicode_str,namelen);  /* key name */
    VARARG(class,unicode_str);         /* class name */
1277
@REPLY
1278
    obj_handle_t hkey;         /* handle to the created key */
1279 1280 1281 1282 1283
    int          created;      /* has it been newly created? */
@END

/* Open a registry key */
@REQ(open_key)
1284
    obj_handle_t parent;       /* handle to the parent key */
1285 1286 1287
    unsigned int access;       /* desired access rights */
    VARARG(name,unicode_str);  /* key name */
@REPLY
1288
    obj_handle_t hkey;         /* handle to the open key */
1289 1290 1291 1292 1293
@END


/* Delete a registry key */
@REQ(delete_key)
1294
    obj_handle_t hkey;         /* handle to the key */
1295 1296 1297 1298 1299
@END


/* Enumerate registry subkeys */
@REQ(enum_key)
1300
    obj_handle_t hkey;         /* handle to registry key */
1301
    int          index;        /* index of subkey (or -1 for current key) */
1302
    int          info_class;   /* requested information class */
1303 1304 1305 1306 1307 1308 1309 1310
@REPLY
    int          subkeys;      /* number of subkeys */
    int          max_subkey;   /* longest subkey name */
    int          max_class;    /* longest class name */
    int          values;       /* number of values */
    int          max_value;    /* longest value name */
    int          max_data;     /* longest value data */
    time_t       modif;        /* last modification time */
1311 1312 1313 1314
    size_t       total;        /* total length needed for full name and class */
    size_t       namelen;      /* length of key name in bytes */
    VARARG(name,unicode_str,namelen);  /* key name */
    VARARG(class,unicode_str);         /* class name */
1315 1316 1317 1318 1319
@END


/* Set a value of a registry key */
@REQ(set_key_value)
1320
    obj_handle_t hkey;         /* handle to registry key */
1321
    int          type;         /* value type */
1322 1323 1324
    size_t       namelen;      /* length of value name in bytes */
    VARARG(name,unicode_str,namelen);  /* value name */
    VARARG(data,bytes);                /* value data */
1325 1326 1327 1328 1329
@END


/* Retrieve the value of a registry key */
@REQ(get_key_value)
1330
    obj_handle_t hkey;         /* handle to registry key */
1331
    VARARG(name,unicode_str);  /* value name */
1332 1333
@REPLY
    int          type;         /* value type */
1334
    size_t       total;        /* total length needed for data */
1335 1336 1337 1338 1339 1340
    VARARG(data,bytes);        /* value data */
@END


/* Enumerate a value of a registry key */
@REQ(enum_key_value)
1341
    obj_handle_t hkey;         /* handle to registry key */
1342
    int          index;        /* value index */
1343
    int          info_class;   /* requested information class */
1344 1345
@REPLY
    int          type;         /* value type */
1346 1347 1348 1349
    size_t       total;        /* total length needed for full name and data */
    size_t       namelen;      /* length of value name in bytes */
    VARARG(name,unicode_str,namelen);  /* value name */
    VARARG(data,bytes);                /* value data */
1350 1351 1352 1353 1354
@END


/* Delete a value of a registry key */
@REQ(delete_key_value)
1355
    obj_handle_t hkey;         /* handle to registry key */
1356 1357 1358 1359 1360 1361
    VARARG(name,unicode_str);  /* value name */
@END


/* Load a registry branch from a file */
@REQ(load_registry)
1362 1363
    obj_handle_t hkey;         /* root key to load to */
    obj_handle_t file;         /* file to load from */
1364 1365 1366 1367
    VARARG(name,unicode_str);  /* subkey name */
@END


1368 1369 1370 1371 1372 1373
/* UnLoad a registry branch from a file */
@REQ(unload_registry)
    obj_handle_t hkey;         /* root key to unload to */
@END


1374 1375
/* Save a registry branch to a file */
@REQ(save_registry)
1376 1377
    obj_handle_t hkey;         /* key to save */
    obj_handle_t file;         /* file to save to */
1378 1379 1380 1381 1382
@END


/* Save a registry branch at server exit */
@REQ(save_registry_atexit)
1383
    obj_handle_t hkey;         /* key to save */
1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395
    VARARG(file,string);       /* file to save to */
@END


/* Set the current and saving level for the registry */
@REQ(set_registry_levels)
    int          current;      /* new current level */
    int          saving;       /* new saving level */
    int          period;       /* duration between periodic saves (milliseconds) */
@END


1396 1397 1398 1399 1400 1401 1402 1403
@REQ(set_registry_notification)
    obj_handle_t hkey;         /* key to watch for changes */
    obj_handle_t event;        /* event to set */
    int          subtree;      /* should we watch the whole subtree? */
    unsigned int filter;       /* things to watch */
@END


1404 1405 1406 1407 1408 1409
/* Create a waitable timer */
@REQ(create_timer)
    int          inherit;       /* inherit flag */
    int          manual;        /* manual reset */
    VARARG(name,unicode_str);   /* object name */
@REPLY
1410
    obj_handle_t handle;        /* handle to the timer */
1411 1412 1413 1414 1415 1416 1417 1418 1419
@END


/* Open a waitable timer */
@REQ(open_timer)
    unsigned int access;        /* wanted access rights */
    int          inherit;       /* inherit flag */
    VARARG(name,unicode_str);   /* object name */
@REPLY
1420
    obj_handle_t handle;        /* handle to the timer */
1421 1422 1423 1424
@END

/* Set a waitable timer */
@REQ(set_timer)
1425
    obj_handle_t handle;        /* handle to the timer */
1426
    abs_time_t   expire;        /* next expiration absolute time */
1427 1428 1429
    int          period;        /* timer period in ms */
    void*        callback;      /* callback function */
    void*        arg;           /* callback argument */
1430 1431
@REPLY
    int          signaled;      /* was the timer signaled before this call ? */
1432 1433 1434 1435
@END

/* Cancel a waitable timer */
@REQ(cancel_timer)
1436
    obj_handle_t handle;        /* handle to the timer */
1437 1438
@REPLY
     int         signaled;      /* was the timer signaled before this calltime ? */
1439 1440 1441 1442 1443
@END


/* Retrieve the current context of a thread */
@REQ(get_thread_context)
1444
    obj_handle_t handle;       /* thread handle */
1445 1446 1447 1448 1449 1450 1451 1452
    unsigned int flags;        /* context flags */
@REPLY
    VARARG(context,context);   /* thread context */
@END


/* Set the current context of a thread */
@REQ(set_thread_context)
1453
    obj_handle_t handle;       /* thread handle */
1454 1455 1456 1457 1458 1459 1460
    unsigned int flags;        /* context flags */
    VARARG(context,context);   /* thread context */
@END


/* Fetch a selector entry for a thread */
@REQ(get_selector_entry)
1461
    obj_handle_t  handle;      /* thread handle */
1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
    int           entry;       /* LDT entry */
@REPLY
    unsigned int  base;        /* selector base */
    unsigned int  limit;       /* selector limit */
    unsigned char flags;       /* selector flags */
@END


/* Add an atom */
@REQ(add_atom)
    int           local;       /* is atom in local process table? */
    VARARG(name,unicode_str);  /* atom name */
@REPLY
1475
    atom_t        atom;        /* resulting atom */
1476 1477 1478 1479 1480
@END


/* Delete an atom */
@REQ(delete_atom)
1481
    atom_t        atom;        /* atom handle */
1482 1483 1484 1485 1486 1487 1488 1489 1490
    int           local;       /* is atom in local process table? */
@END


/* Find an atom */
@REQ(find_atom)
    int          local;        /* is atom in local process table? */
    VARARG(name,unicode_str);  /* atom name */
@REPLY
1491
    atom_t       atom;         /* atom handle */
1492 1493 1494 1495 1496
@END


/* Get an atom name */
@REQ(get_atom_name)
1497
    atom_t       atom;         /* atom handle */
1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513
    int          local;        /* is atom in local process table? */
@REPLY
    int          count;        /* atom lock count */
    VARARG(name,unicode_str);  /* atom name */
@END


/* Init the process atom table */
@REQ(init_atom_table)
    int          entries;      /* number of entries */
@END


/* Get the message queue of the current thread */
@REQ(get_msg_queue)
@REPLY
1514
    obj_handle_t handle;       /* handle to the queue */
1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
@END


/* Set the current message queue wakeup mask */
@REQ(set_queue_mask)
    unsigned int wake_mask;    /* wakeup bits mask */
    unsigned int changed_mask; /* changed bits mask */
    int          skip_wait;    /* will we skip waiting if signaled? */
@REPLY
    unsigned int wake_bits;    /* current wake bits */
    unsigned int changed_bits; /* current changed bits */
@END


/* Get the current message queue status */
@REQ(get_queue_status)
    int          clear;        /* should we clear the change bits? */
@REPLY
    unsigned int wake_bits;    /* wake bits */
    unsigned int changed_bits; /* changed bits since last time */
@END


/* Wait for a process to start waiting on input */
@REQ(wait_input_idle)
1540
    obj_handle_t handle;       /* process handle */
1541 1542
    int          timeout;      /* timeout */
@REPLY
1543
    obj_handle_t event;        /* handle to idle event */
1544 1545 1546 1547 1548
@END


/* Send a message to a thread queue */
@REQ(send_message)
1549
    thread_id_t     id;        /* thread id */
1550
    int             type;      /* message type (see below) */
1551
    int             flags;     /* message flags (see below) */
1552
    user_handle_t   win;       /* window handle */
1553 1554 1555
    unsigned int    msg;       /* message code */
    unsigned int    wparam;    /* parameters */
    unsigned int    lparam;    /* parameters */
1556 1557
    int             x;         /* x position */
    int             y;         /* y position */
1558 1559
    unsigned int    time;      /* message time */
    unsigned int    info;      /* extra info */
1560
    int             timeout;   /* timeout for reply */
1561
    void*           callback;  /* callback address */
1562
    VARARG(data,bytes);        /* message data for sent messages */
1563
@END
1564 1565 1566 1567 1568 1569 1570

enum message_type
{
    MSG_ASCII,          /* Ascii message (from SendMessageA) */
    MSG_UNICODE,        /* Unicode message (from SendMessageW) */
    MSG_NOTIFY,         /* notify message (from SendNotifyMessageW), always Unicode */
    MSG_CALLBACK,       /* callback message (from SendMessageCallbackW), always Unicode */
1571
    MSG_CALLBACK_RESULT,/* result of a callback message */
1572 1573
    MSG_OTHER_PROCESS,  /* sent from other process, may include vararg data, always Unicode */
    MSG_POSTED,         /* posted message (from PostMessageW), always Unicode */
1574
    MSG_HARDWARE        /* hardware message */
1575
};
1576
#define SEND_MSG_ABORT_IF_HUNG  0x01
1577 1578 1579 1580 1581


/* Get a message from the current queue */
@REQ(get_message)
    int             flags;     /* see below */
1582
    user_handle_t   get_win;   /* window handle to get */
1583 1584 1585 1586
    unsigned int    get_first; /* first message code to get */
    unsigned int    get_last;  /* last message code to get */
@REPLY
    int             type;      /* message type */
1587
    user_handle_t   win;       /* window handle */
1588
    unsigned int    msg;       /* message code */
1589 1590
    unsigned int    wparam;    /* parameters (callback function for MSG_CALLBACK_RESULT) */
    unsigned int    lparam;    /* parameters (result for MSG_CALLBACK_RESULT) */
1591 1592
    int             x;         /* x position */
    int             y;         /* y position */
1593
    unsigned int    time;      /* message time */
1594
    unsigned int    info;      /* extra info (callback argument for MSG_CALLBACK_RESULT) */
1595
    size_t          total;     /* total size of extra data */
1596
    VARARG(data,bytes);        /* message data for sent messages */
1597 1598 1599 1600 1601 1602
@END
#define GET_MSG_REMOVE      1  /* remove the message */
#define GET_MSG_SENT_ONLY   2  /* only get sent messages */

/* Reply to a sent message */
@REQ(reply_message)
1603
    int             type;      /* type of original message */
1604 1605
    unsigned int    result;    /* message result */
    int             remove;    /* should we remove the message? */
1606
    VARARG(data,bytes);        /* message data for sent messages */
1607 1608 1609 1610 1611 1612 1613 1614
@END


/* Retrieve the reply for the last message sent */
@REQ(get_message_reply)
    int             cancel;    /* cancel message if not ready? */
@REPLY
    unsigned int    result;    /* message result */
1615
    VARARG(data,bytes);        /* message data for sent messages */
1616 1617 1618 1619 1620
@END


/* Set a window timer */
@REQ(set_win_timer)
1621
    user_handle_t   win;       /* window handle */
1622 1623 1624 1625 1626 1627 1628 1629 1630
    unsigned int    msg;       /* message to post */
    unsigned int    id;        /* timer id */
    unsigned int    rate;      /* timer rate in ms */
    unsigned int    lparam;    /* message lparam (callback proc) */
@END


/* Kill a window timer */
@REQ(kill_win_timer)
1631
    user_handle_t   win;       /* window handle */
1632 1633 1634 1635 1636 1637 1638 1639 1640
    unsigned int    msg;       /* message to post */
    unsigned int    id;        /* timer id */
@END


/* Open a serial port */
@REQ(create_serial)
    unsigned int access;       /* wanted access rights */
    int          inherit;      /* inherit flag */
1641
    unsigned int attributes;   /* eg. FILE_FLAG_OVERLAPPED */
1642 1643 1644
    unsigned int sharing;      /* sharing flags */
    VARARG(name,string);       /* file name */
@REPLY
1645
    obj_handle_t handle;       /* handle to the port */
1646 1647 1648 1649 1650
@END


/* Retrieve info about a serial port */
@REQ(get_serial_info)
1651
    obj_handle_t handle;       /* handle to comm port */
1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664
@REPLY
    unsigned int readinterval;
    unsigned int readconst;
    unsigned int readmult;
    unsigned int writeconst;
    unsigned int writemult;
    unsigned int eventmask;
    unsigned int commerror;
@END


/* Set info about a serial port */
@REQ(set_serial_info)
1665
    obj_handle_t handle;       /* handle to comm port */
1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679
    int          flags;        /* bitmask to set values (see below) */
    unsigned int readinterval;
    unsigned int readconst;
    unsigned int readmult;
    unsigned int writeconst;
    unsigned int writemult;
    unsigned int eventmask;
    unsigned int commerror;
@END
#define SERIALINFO_SET_TIMEOUTS  0x01
#define SERIALINFO_SET_MASK      0x02
#define SERIALINFO_SET_ERROR     0x04


1680
/* Create / reschedule an async I/O */
1681
@REQ(register_async)
1682
    obj_handle_t handle;  /* handle to comm port, socket or file */
1683
    int          type;
1684 1685 1686
    void*        overlapped;
    int          count;
    unsigned int status;
1687
@END
1688
#define ASYNC_TYPE_NONE  0x00
1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701
#define ASYNC_TYPE_READ  0x01
#define ASYNC_TYPE_WRITE 0x02
#define ASYNC_TYPE_WAIT  0x03


/* Create a named pipe */
@REQ(create_named_pipe)
    unsigned int   openmode;
    unsigned int   pipemode;
    unsigned int   maxinstances;
    unsigned int   outsize;
    unsigned int   insize;
    unsigned int   timeout;
1702
    VARARG(name,unicode_str);    /* pipe name */
1703
@REPLY
1704
    obj_handle_t   handle;       /* handle to the pipe */
1705 1706 1707 1708 1709 1710
@END


/* Open an existing named pipe */
@REQ(open_named_pipe)
    unsigned int   access;
1711
    int            inherit;      /* inherit flag */
1712
    VARARG(name,unicode_str);    /* pipe name */
1713
@REPLY
1714
    obj_handle_t   handle;       /* handle to the pipe */
1715 1716 1717 1718 1719
@END


/* Connect to a named pipe */
@REQ(connect_named_pipe)
1720
    obj_handle_t   handle;
1721 1722
    void*          overlapped;
    void*          func;
1723
@END
1724 1725 1726 1727 1728


/* Wait for a named pipe */
@REQ(wait_named_pipe)
    unsigned int   timeout;
1729 1730
    void*          overlapped;
    void*          func;
1731
    VARARG(name,unicode_str);    /* pipe name */
1732 1733 1734 1735 1736
@END


/* Disconnect a named pipe */
@REQ(disconnect_named_pipe)
1737
    obj_handle_t   handle;
1738 1739
@REPLY
    int            fd;           /* associated fd to close */
1740
@END
1741

1742

1743
@REQ(get_named_pipe_info)
1744
    obj_handle_t   handle;
1745 1746 1747 1748 1749 1750 1751
@REPLY
    unsigned int   flags;
    unsigned int   maxinstances;
    unsigned int   outsize;
    unsigned int   insize;
@END

1752

1753 1754 1755 1756 1757 1758 1759
@REQ(create_smb)
    int            fd;
    unsigned int   tree_id;
    unsigned int   user_id;
    unsigned int   file_id;
    unsigned int   dialect;
@REPLY
1760
    obj_handle_t   handle;
1761 1762 1763 1764
@END


@REQ(get_smb_info)
1765
    obj_handle_t   handle;
1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777
    unsigned int   flags;
    unsigned int   offset;
@REPLY
    unsigned int   tree_id;
    unsigned int   user_id;
    unsigned int   dialect;
    unsigned int   file_id;
    unsigned int   offset;
@END
#define SMBINFO_SET_OFFSET    0x01


1778 1779
/* Create a window */
@REQ(create_window)
1780 1781
    user_handle_t  parent;      /* parent window */
    user_handle_t  owner;       /* owner window */
1782
    atom_t         atom;        /* class atom */
1783
@REPLY
1784
    user_handle_t  handle;      /* created window */
1785 1786 1787 1788 1789 1790 1791 1792 1793
@END


/* Link a window into the tree */
@REQ(link_window)
    user_handle_t  handle;      /* handle to the window */
    user_handle_t  parent;      /* handle to the parent */
    user_handle_t  previous;    /* previous child in Z-order */
@REPLY
1794
    user_handle_t  full_parent; /* full handle of new parent */
1795 1796 1797 1798 1799 1800 1801 1802 1803
@END


/* Destroy a window */
@REQ(destroy_window)
    user_handle_t  handle;      /* handle to the window */
@END


1804 1805 1806 1807 1808 1809
/* Set a window owner */
@REQ(set_window_owner)
    user_handle_t  handle;      /* handle to the window */
    user_handle_t  owner;       /* new owner */
@REPLY
    user_handle_t  full_owner;  /* full handle of new owner */
1810
    user_handle_t  prev_owner;  /* full handle of previous owner */
1811 1812 1813
@END


1814 1815 1816 1817 1818
/* Get information from a window handle */
@REQ(get_window_info)
    user_handle_t  handle;      /* handle to the window */
@REPLY
    user_handle_t  full_handle; /* full 32-bit handle */
1819
    user_handle_t  last_active; /* last active popup */
1820 1821
    process_id_t   pid;         /* process owning the window */
    thread_id_t    tid;         /* thread owning the window */
1822
    atom_t         atom;        /* class atom */
1823
@END
1824 1825


1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848
/* Set some information in a window */
@REQ(set_window_info)
    user_handle_t  handle;        /* handle to the window */
    unsigned int   flags;         /* flags for fields to set (see below) */
    unsigned int   style;         /* window style */
    unsigned int   ex_style;      /* window extended style */
    unsigned int   id;            /* window id */
    void*          instance;      /* creator instance */
    void*          user_data;     /* user-specific data */
@REPLY
    unsigned int   old_style;     /* old window style */
    unsigned int   old_ex_style;  /* old window extended style */
    unsigned int   old_id;        /* old window id */
    void*          old_instance;  /* old creator instance */
    void*          old_user_data; /* old user-specific data */
@END
#define SET_WIN_STYLE     0x01
#define SET_WIN_EXSTYLE   0x02
#define SET_WIN_ID        0x04
#define SET_WIN_INSTANCE  0x08
#define SET_WIN_USERDATA  0x10


1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860
/* Get a list of the window parents, up to the root of the tree */
@REQ(get_window_parents)
    user_handle_t  handle;        /* handle to the window */
@REPLY
    int            count;         /* total count of parents */
    VARARG(parents,user_handles); /* parent handles */
@END


/* Get a list of the window children */
@REQ(get_window_children)
    user_handle_t  parent;        /* parent window */
1861
    atom_t         atom;          /* class atom for the listed children */
1862
    thread_id_t    tid;           /* thread owning the listed children */
1863 1864
@REPLY
    int            count;         /* total count of children */
1865
    VARARG(children,user_handles); /* children handles */
1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881
@END


/* Get window tree information from a window handle */
@REQ(get_window_tree)
    user_handle_t  handle;        /* handle to the window */
@REPLY
    user_handle_t  parent;        /* parent window */
    user_handle_t  owner;         /* owner window */
    user_handle_t  next_sibling;  /* next sibling in Z-order */
    user_handle_t  prev_sibling;  /* prev sibling in Z-order */
    user_handle_t  first_sibling; /* first sibling in Z-order */
    user_handle_t  last_sibling;  /* last sibling in Z-order */
    user_handle_t  first_child;   /* first child */
    user_handle_t  last_child;    /* last child */
@END
1882

1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899
/* Set the window and client rectangles of a window */
@REQ(set_window_rectangles)
    user_handle_t  handle;        /* handle to the window */
    rectangle_t    window;        /* window rectangle */
    rectangle_t    client;        /* client rectangle */
@END


/* Get the window and client rectangles of a window */
@REQ(get_window_rectangles)
    user_handle_t  handle;        /* handle to the window */
@REPLY
    rectangle_t    window;        /* window rectangle */
    rectangle_t    client;        /* client rectangle */
@END


1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921
/* Get the window text */
@REQ(get_window_text)
    user_handle_t  handle;        /* handle to the window */
@REPLY
    VARARG(text,unicode_str);     /* window text */
@END


/* Set the window text */
@REQ(set_window_text)
    user_handle_t  handle;        /* handle to the window */
    VARARG(text,unicode_str);     /* window text */
@END


/* Increment the window paint count */
@REQ(inc_window_paint_count)
    user_handle_t  handle;        /* handle to the window */
    int             incr;         /* increment (can be negative) */
@END


1922 1923 1924 1925 1926 1927 1928 1929 1930
/* Get the coordinates offset between two windows */
@REQ(get_windows_offset)
    user_handle_t  from;          /* handle to the first window */
    user_handle_t  to;            /* handle to the second window */
@REPLY
    int            x;             /* x coordinate offset */
    int            y;             /* y coordinate offset */
@END

1931 1932 1933 1934 1935 1936

/* Set a window property */
@REQ(set_window_property)
    user_handle_t  window;        /* handle to the window */
    atom_t         atom;          /* property atom (high-word set if it was a string) */
    int            string;        /* was atom a string originally? */
1937
    obj_handle_t   handle;        /* handle to store */
1938 1939 1940 1941 1942 1943 1944 1945
@END


/* Remove a window property */
@REQ(remove_window_property)
    user_handle_t  window;        /* handle to the window */
    atom_t         atom;          /* property atom */
@REPLY
1946
    obj_handle_t   handle;        /* handle stored in property */
1947 1948 1949 1950 1951 1952 1953 1954
@END


/* Get a window property */
@REQ(get_window_property)
    user_handle_t  window;        /* handle to the window */
    atom_t         atom;          /* property atom */
@REPLY
1955
    obj_handle_t   handle;        /* handle stored in property */
1956 1957 1958 1959 1960 1961 1962
@END


/* Get the list of properties of a window */
@REQ(get_window_properties)
    user_handle_t  window;        /* handle to the window */
@REPLY
1963
    int            total;         /* total number of properties */
1964 1965
    VARARG(props,properties);     /* list of properties */
@END
1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988


/* Attach (or detach) thread inputs */
@REQ(attach_thread_input)
    thread_id_t    tid_from;       /* thread to be attached */
    thread_id_t    tid_to;         /* thread to which tid_from should be attached */
    int            attach;         /* is it an attach? */
@END


/* Get input data for a given thread */
@REQ(get_thread_input)
    thread_id_t    tid;           /* id of thread */
@REPLY
    user_handle_t  focus;         /* handle to the focus window */
    user_handle_t  capture;       /* handle to the capture window */
    user_handle_t  active;        /* handle to the active window */
    user_handle_t  foreground;    /* handle to the global foreground window */
    user_handle_t  menu_owner;    /* handle to the menu owner */
    user_handle_t  move_size;     /* handle to the moving/resizing window */
    user_handle_t  caret;         /* handle to the caret window */
    rectangle_t    rect;          /* caret rectangle */
@END
1989

1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
/* Retrieve queue keyboard state for a given thread */
@REQ(get_key_state)
    thread_id_t    tid;           /* id of thread */
    int            key;           /* optional key code or -1 */
@REPLY
    unsigned char  state;         /* state of specified key */
    VARARG(keystate,bytes);       /* state array for all the keys */
@END

/* Set queue keyboard state for a given thread */
@REQ(set_key_state)
    thread_id_t    tid;           /* id of thread */
    VARARG(keystate,bytes);       /* state array for all the keys */
@END

2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026
/* Set the system foreground window */
@REQ(set_foreground_window)
    user_handle_t  handle;        /* handle to the foreground window */
@REPLY
    user_handle_t  previous;      /* handle to the previous foreground window */
    int            send_msg_old;  /* whether we have to send a msg to the old window */
    int            send_msg_new;  /* whether we have to send a msg to the new window */
@END

/* Set the current thread focus window */
@REQ(set_focus_window)
    user_handle_t  handle;        /* handle to the focus window */
@REPLY
    user_handle_t  previous;      /* handle to the previous focus window */
@END

/* Set the current thread active window */
@REQ(set_active_window)
    user_handle_t  handle;        /* handle to the active window */
@REPLY
    user_handle_t  previous;      /* handle to the previous active window */
@END
2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037

/* Set the current thread capture window */
@REQ(set_capture_window)
    user_handle_t  handle;        /* handle to the capture window */
    unsigned int   flags;         /* capture flags (see below) */
@REPLY
    user_handle_t  previous;      /* handle to the previous capture window */
    user_handle_t  full_handle;   /* full 32-bit handle of new capture window */
@END
#define CAPTURE_MENU     0x01  /* capture is for a menu */
#define CAPTURE_MOVESIZE 0x02  /* capture is for moving/resizing */
2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069


/* Set the current thread caret window */
@REQ(set_caret_window)
    user_handle_t  handle;        /* handle to the caret window */
    int            width;         /* caret width */
    int            height;        /* caret height */
@REPLY
    user_handle_t  previous;      /* handle to the previous caret window */
    rectangle_t    old_rect;      /* previous caret rectangle */
    int            old_hide;      /* previous hide count */
    int            old_state;     /* previous caret state (1=on, 0=off) */
@END


/* Set the current thread caret information */
@REQ(set_caret_info)
    unsigned int   flags;         /* caret flags (see below) */
    user_handle_t  handle;        /* handle to the caret window */
    int            x;             /* caret x position */
    int            y;             /* caret y position */
    int            hide;          /* increment for hide count (can be negative to show it) */
    int            state;         /* caret state (1=on, 0=off, -1=toggle current state) */
@REPLY
    user_handle_t  full_handle;   /* handle to the current caret window */
    rectangle_t    old_rect;      /* previous caret rectangle */
    int            old_hide;      /* previous hide count */
    int            old_state;     /* previous caret state (1=on, 0=off) */
@END
#define SET_CARET_POS        0x01  /* set the caret position from x,y */
#define SET_CARET_HIDE       0x02  /* increment the caret hide count */
#define SET_CARET_STATE      0x04  /* set the caret on/off state */
2070 2071 2072 2073 2074 2075 2076 2077


/* Set a window hook */
@REQ(set_hook)
    int            id;             /* id of the hook */
    thread_id_t    tid;            /* id of thread to set the hook into */
    void*          proc;           /* hook procedure */
    int            unicode;        /* is it a unicode hook? */
2078
    VARARG(module,unicode_str);    /* module name */
2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096
@REPLY
    user_handle_t  handle;         /* handle to the hook */
@END


/* Remove a window hook */
@REQ(remove_hook)
    user_handle_t  handle;         /* handle to the hook */
    int            id;             /* id of the hook if handle is 0 */
    void*          proc;           /* hook procedure if handle is 0 */
@END


/* Start calling a hook chain */
@REQ(start_hook_chain)
    int            id;             /* id of the hook */
@REPLY
    user_handle_t  handle;         /* handle to the next hook */
2097 2098
    process_id_t   pid;            /* process id for low-level keyboard/mouse hooks */
    thread_id_t    tid;            /* thread id for low-level keyboard/mouse hooks */
2099 2100
    void*          proc;           /* hook procedure */
    int            unicode;        /* is it a unicode hook? */
2101
    VARARG(module,unicode_str);    /* module name */
2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116
@END


/* Finished calling a hook chain */
@REQ(finish_hook_chain)
    int            id;             /* id of the hook */
@END


/* Get the next hook to call */
@REQ(get_next_hook)
    user_handle_t  handle;         /* handle to the current hook */
@REPLY
    user_handle_t  next;           /* handle to the next hook */
    int            id;             /* id of the next hook */
2117 2118
    process_id_t   pid;            /* process id for low-level keyboard/mouse hooks */
    thread_id_t    tid;            /* thread id for low-level keyboard/mouse hooks */
2119 2120 2121
    void*          proc;           /* next hook procedure */
    int            prev_unicode;   /* was the previous a unicode hook? */
    int            next_unicode;   /* is the next a unicode hook? */
2122
    VARARG(module,unicode_str);    /* module name */
2123
@END
2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148


/* Set/get clipboard information */
@REQ(set_clipboard_info)
    unsigned int   flags;       /* flags for fields to set (see below) */
    user_handle_t  clipboard;   /* clipboard window */
    user_handle_t  owner;       /* clipboard owner */
    user_handle_t  viewer;      /* first clipboard viewer */
    unsigned int   seqno;       /* change sequence number */
@REPLY
    unsigned int   flags;           /* status flags (see below) */
    user_handle_t  old_clipboard;   /* old clipboard window */
    user_handle_t  old_owner;       /* old clipboard owner */
    user_handle_t  old_viewer;      /* old clipboard viewer */
    unsigned int   seqno;           /* current sequence number */
@END

#define SET_CB_OPEN      0x001
#define SET_CB_OWNER     0x002
#define SET_CB_VIEWER    0x004
#define SET_CB_SEQNO     0x008
#define SET_CB_RELOWNER  0x010
#define SET_CB_CLOSE     0x020
#define CB_OPEN          0x040
#define CB_OWNER         0x080
2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159


/* Open a security token */
@REQ(open_token)
    obj_handle_t   handle;    /* handle to the thread or process */
    unsigned int   flags;     /* flags (see below) */
@REPLY
    obj_handle_t   token;    /* handle to the token */
@END
#define OPEN_TOKEN_THREAD   1
#define OPEN_TOKEN_AS_SELF  2
2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177


/* Set/get the global windows */
@REQ(set_global_windows)
    unsigned int   flags;               /* flags for fields to set (see below) */
    user_handle_t  shell_window;        /* handle to the new shell window */
    user_handle_t  shell_listview;      /* handle to the new shell listview window */
    user_handle_t  progman_window;      /* handle to the new program manager window */
    user_handle_t  taskman_window;      /* handle to the new task manager window */
@REPLY
    user_handle_t  old_shell_window;    /* handle to the shell window */
    user_handle_t  old_shell_listview;  /* handle to the shell listview window */
    user_handle_t  old_progman_window;  /* handle to the new program manager window */
    user_handle_t  old_taskman_window;  /* handle to the new task manager window */
@END
#define SET_GLOBAL_SHELL_WINDOWS   0x01  /* set both main shell and listview windows */
#define SET_GLOBAL_PROGMAN_WINDOW  0x02
#define SET_GLOBAL_TASKMAN_WINDOW  0x04