protocol.def 110 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
 *
 * 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
22
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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
typedef unsigned int obj_handle_t;
35
typedef unsigned int user_handle_t;
36
typedef unsigned int atom_t;
37 38 39
typedef unsigned int process_id_t;
typedef unsigned int thread_id_t;
typedef unsigned int data_size_t;
40
typedef unsigned int ioctl_code_t;
41
typedef unsigned __int64 lparam_t;
42
typedef unsigned __int64 apc_param_t;
43
typedef unsigned __int64 mem_size_t;
44
typedef unsigned __int64 file_pos_t;
45
typedef unsigned __int64 client_ptr_t;
46
typedef unsigned __int64 affinity_t;
47
typedef client_ptr_t mod_handle_t;
48

49 50
struct request_header
{
51
    int          req;          /* request code */
52 53
    data_size_t  request_size; /* request variable part size */
    data_size_t  reply_size;   /* reply variable part maximum size */
54 55 56 57
};

struct reply_header
{
58
    unsigned int error;        /* error result */
59
    data_size_t  reply_size;   /* reply variable part size */
60 61 62 63 64 65 66 67 68
};

/* 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 */
};

69 70 71 72
#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 */


73
/* debug event data */
74 75 76 77 78
typedef union
{
    int code;   /* event code */
    struct
    {
79 80 81 82 83 84 85 86 87
        int              code;       /* EXCEPTION_DEBUG_EVENT */
        int              first;      /* first chance exception? */
        unsigned int     exc_code;   /* exception code */
        unsigned int     flags;      /* exception flags */
        client_ptr_t     record;     /* exception record */
        client_ptr_t     address;    /* exception address */
        int              nb_params;  /* number of parameters */
        int              __pad;
        client_ptr_t     params[15]; /* parameters */
88 89 90 91 92 93 94 95 96 97 98 99 100 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 139 140 141 142 143
    } exception;
    struct
    {
        int          code;       /* CREATE_THREAD_DEBUG_EVENT */
        obj_handle_t handle;     /* handle to the new thread */
        client_ptr_t teb;        /* thread teb (in debugged process address space) */
        client_ptr_t start;      /* thread startup routine */
    } create_thread;
    struct
    {
        int          code;       /* CREATE_PROCESS_DEBUG_EVENT */
        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 */
        mod_handle_t base;       /* base of executable image */
        int          dbg_offset; /* offset of debug info in file */
        int          dbg_size;   /* size of debug info */
        client_ptr_t teb;        /* thread teb (in debugged process address space) */
        client_ptr_t start;      /* thread startup routine */
        client_ptr_t name;       /* image name (optional) */
        int          unicode;    /* is it Unicode? */
    } create_process;
    struct
    {
        int          code;       /* EXIT_THREAD_DEBUG_EVENT/EXIT_PROCESS_DEBUG_EVENT */
        int          exit_code;  /* thread or process exit code */
    } exit;
    struct
    {
        int          code;       /* LOAD_DLL_DEBUG_EVENT */
        obj_handle_t handle;     /* file handle for the dll */
        mod_handle_t base;       /* base address of the dll */
        int          dbg_offset; /* offset of debug info in file */
        int          dbg_size;   /* size of debug info */
        client_ptr_t name;       /* image name (optional) */
        int          unicode;    /* is it Unicode? */
    } load_dll;
    struct
    {
        int          code;       /* UNLOAD_DLL_DEBUG_EVENT */
        int          __pad;
        mod_handle_t base;       /* base address of the dll */
    } unload_dll;
    struct
    {
        int          code;       /* OUTPUT_DEBUG_STRING_EVENT */
        int          unicode;    /* is it Unicode? */
        client_ptr_t string;     /* string to display (in debugged process address space) */
        data_size_t  length;     /* string length */
    } output_string;
    struct
    {
        int          code;       /* RIP_EVENT */
        int          error;      /* ??? */
        int          type;       /* ??? */
    } rip_info;
144 145
} debug_event_t;

146 147 148 149 150 151 152
/* supported CPU types */
enum cpu_type
{
    CPU_x86, CPU_x86_64, CPU_ALPHA, CPU_POWERPC, CPU_SPARC
};
typedef int cpu_type_t;

153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
/* context data */
typedef struct
{
    cpu_type_t       cpu;        /* cpu type */
    unsigned int     flags;      /* SERVER_CTX_* flags */
    union
    {
        struct { unsigned int eip, ebp, esp, eflags, cs, ss; } i386_regs;
        struct { unsigned __int64 rip, rbp, rsp;
                 unsigned int cs, ss, flags, mxcsr; } x86_64_regs;
        struct { unsigned __int64 fir;
                 unsigned int psr; } alpha_regs;
        struct { unsigned int iar, msr, ctr, lr, dar, dsisr, trap; } powerpc_regs;
        struct { unsigned int psr, pc, npc, y, wim, tbr; } sparc_regs;
    } ctl;  /* selected by SERVER_CTX_CONTROL */
    union
    {
        struct { unsigned int eax, ebx, ecx, edx, esi, edi; } i386_regs;
        struct { unsigned __int64 rax,rbx, rcx, rdx, rsi, rdi,
                                  r8, r9, r10, r11, r12, r13, r14, r15; } x86_64_regs;
        struct { unsigned __int64 v0, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12,
                                  s0, s1, s2, s3, s4, s5, s6, a0, a1, a2, a3, a4, a5, at; } alpha_regs;
        struct { unsigned int gpr[32], cr, xer; } powerpc_regs;
        struct { unsigned int g[8], o[8], l[8], i[8]; } sparc_regs;
    } integer;  /* selected by SERVER_CTX_INTEGER */
    union
    {
        struct { unsigned int ds, es, fs, gs; } i386_regs;
        struct { unsigned int ds, es, fs, gs; } x86_64_regs;
    } seg;  /* selected by SERVER_CTX_SEGMENTS */
    union
    {
        struct { unsigned int ctrl, status, tag, err_off, err_sel, data_off, data_sel, cr0npx;
                 unsigned char regs[80]; } i386_regs;
        struct { struct { unsigned __int64 low, high; } fpregs[32]; } x86_64_regs;
        struct { unsigned __int64 f[32], fpcr, softfpcr; } alpha_regs;
        struct { double fpr[32], fpscr; } powerpc_regs;
    } fp;  /* selected by SERVER_CTX_FLOATING_POINT */
    union
    {
        struct { unsigned int dr0, dr1, dr2, dr3, dr6, dr7; } i386_regs;
        struct { unsigned __int64 dr0, dr1, dr2, dr3, dr6, dr7; } x86_64_regs;
        struct { unsigned int dr[8]; } powerpc_regs;
    } debug;  /* selected by SERVER_CTX_DEBUG_REGISTERS */
    union
    {
        unsigned char i386_regs[512];
    } ext;                       /* selected by SERVER_CTX_EXTENDED_REGISTERS */
} context_t;

#define SERVER_CTX_CONTROL            0x01
#define SERVER_CTX_INTEGER            0x02
#define SERVER_CTX_SEGMENTS           0x04
#define SERVER_CTX_FLOATING_POINT     0x08
#define SERVER_CTX_DEBUG_REGISTERS    0x10
#define SERVER_CTX_EXTENDED_REGISTERS 0x20

210 211 212
/* structure used in sending an fd from client to server */
struct send_fd
{
213 214
    thread_id_t tid;  /* thread id */
    int         fd;   /* file descriptor on client-side */
215 216 217 218 219
};

/* structure sent by the server on the wait fifo */
struct wake_up_reply
{
220 221
    client_ptr_t cookie;    /* magic cookie that was passed in select_request */
    int          signaled;  /* wait result */
222
    int          __pad;
223 224
};

225 226 227
/* NT-style timeout, in 100ns units, negative means relative timeout */
typedef __int64 timeout_t;
#define TIMEOUT_INFINITE (((timeout_t)0x7fffffff) << 32 | 0xffffffff)
228

229 230 231 232
/* structure returned in the list of window properties */
typedef struct
{
    atom_t         atom;     /* property atom */
233
    int            string;   /* was atom a string originally? */
234
    lparam_t       data;     /* data stored in property */
235 236
} property_data_t;

237 238 239 240 241 242 243 244 245
/* structure to specify window rectangles */
typedef struct
{
    int  left;
    int  top;
    int  right;
    int  bottom;
} rectangle_t;

246 247 248
/* structure for parameters of async I/O calls */
typedef struct
{
249 250
    obj_handle_t    handle;        /* object to perform I/O on */
    obj_handle_t    event;         /* event to signal when done */
251 252 253
    client_ptr_t    callback;      /* client-side callback to call upon end of async */
    client_ptr_t    iosb;          /* I/O status block in client addr space */
    client_ptr_t    arg;           /* opaque user data to pass to callback */
254
    apc_param_t     cvalue;        /* completion value to use for completion events */
255 256
} async_data_t;

257
/* structures for extra message data */
258

259 260 261 262 263 264
struct hardware_msg_data
{
    lparam_t        info;      /* extra info */
    int             x;         /* x position */
    int             y;         /* y position */
    unsigned int    hw_id;     /* unique id */
265
    int             __pad;
266 267
};

268 269
struct callback_msg_data
{
270
    client_ptr_t    callback;   /* callback function */
271 272
    lparam_t        data;       /* user data for callback */
    lparam_t        result;     /* message result */
273 274
};

275 276 277 278
struct winevent_msg_data
{
    user_handle_t   hook;       /* hook handle */
    thread_id_t     tid;        /* thread id */
279
    client_ptr_t    hook_proc;  /* hook proc address */
280 281 282 283 284 285
    /* followed by module name if any */
};

typedef union
{
    unsigned char            bytes[1];   /* raw data for sent messages */
286
    struct hardware_msg_data hardware;
287
    struct callback_msg_data callback;
288 289 290
    struct winevent_msg_data winevent;
} message_data_t;

291 292 293 294 295 296 297
/* structure for console char/attribute info */
typedef struct
{
    WCHAR          ch;
    unsigned short attr;
} char_info_t;

298 299 300 301 302 303
typedef struct
{
    unsigned int low_part;
    int          high_part;
} luid_t;

304 305 306 307 308
#define MAX_ACL_LEN 65535

struct security_descriptor
{
    unsigned int control;       /* SE_ flags */
309 310 311 312
    data_size_t  owner_len;
    data_size_t  group_len;
    data_size_t  sacl_len;
    data_size_t  dacl_len;
313 314 315 316 317 318 319 320 321 322
    /* VARARG(owner,SID); */
    /* VARARG(group,SID); */
    /* VARARG(sacl,ACL); */
    /* VARARG(dacl,ACL); */
};

struct object_attributes
{
    obj_handle_t rootdir; /* root directory */
    data_size_t sd_len;   /* length of security_descriptor data. may be 0 */
323
    data_size_t name_len; /* length of the name string. may be 0 */
324 325
    /* VARARG(sd,security_descriptor); */
    /* VARARG(name,unicode_str); */
326 327
};

328 329 330 331
struct token_groups
{
    unsigned int count;
    /* unsigned int attributes[count]; */
332
    /* VARARG(sids,SID); */
333 334
};

335 336 337 338 339 340 341
enum apc_type
{
    APC_NONE,
    APC_USER,
    APC_TIMER,
    APC_ASYNC_IO,
    APC_VIRTUAL_ALLOC,
342
    APC_VIRTUAL_FREE,
343
    APC_VIRTUAL_QUERY,
344
    APC_VIRTUAL_PROTECT,
345 346
    APC_VIRTUAL_FLUSH,
    APC_VIRTUAL_LOCK,
347
    APC_VIRTUAL_UNLOCK,
348 349
    APC_MAP_VIEW,
    APC_UNMAP_VIEW,
350
    APC_CREATE_THREAD
351
};
352 353 354 355 356 357 358

typedef union
{
    enum apc_type type;
    struct
    {
        enum apc_type    type;     /* APC_USER */
359 360
        int              __pad;
        client_ptr_t     func;     /* void (__stdcall *func)(ULONG_PTR,ULONG_PTR,ULONG_PTR); */
361
        apc_param_t      args[3];  /* arguments for user function */
362 363 364
    } user;
    struct
    {
365
        enum apc_type    type;     /* APC_TIMER */
366
        int              __pad;
367
        client_ptr_t     func;     /* void (__stdcall *func)(void*, unsigned int, unsigned int); */
368
        timeout_t        time;     /* absolute time of expiration */
369
        client_ptr_t     arg;      /* user argument */
370 371 372 373 374
    } timer;
    struct
    {
        enum apc_type    type;     /* APC_ASYNC_IO */
        unsigned int     status;   /* I/O status */
375 376 377
        client_ptr_t     func;     /* unsigned int (*func)(void*, void*, unsigned int, void **); */
        client_ptr_t     user;     /* user pointer */
        client_ptr_t     sb;       /* status block */
378
    } async_io;
379 380 381
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_ALLOC */
382 383
        unsigned int     op_type;   /* type of operation */
        client_ptr_t     addr;      /* requested address */
384
        mem_size_t       size;      /* allocation size */
385 386 387 388 389 390 391
        unsigned int     zero_bits; /* allocation alignment */
        unsigned int     prot;      /* memory protection flags */
    } virtual_alloc;
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_FREE */
        unsigned int     op_type;   /* type of operation */
392 393
        client_ptr_t     addr;      /* requested address */
        mem_size_t       size;      /* allocation size */
394
    } virtual_free;
395 396 397
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_QUERY */
398 399
        int              __pad;
        client_ptr_t     addr;      /* requested address */
400
    } virtual_query;
401 402 403 404
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_PROTECT */
        unsigned int     prot;      /* new protection flags */
405 406
        client_ptr_t     addr;      /* requested address */
        mem_size_t       size;      /* requested size */
407
    } virtual_protect;
408 409 410
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_FLUSH */
411 412
        int              __pad;
        client_ptr_t     addr;      /* requested address */
413
        mem_size_t       size;      /* requested size */
414
    } virtual_flush;
415 416 417
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_LOCK */
418 419
        int              __pad;
        client_ptr_t     addr;      /* requested address */
420
        mem_size_t       size;      /* requested size */
421 422 423 424
    } virtual_lock;
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_UNLOCK */
425 426
        int              __pad;
        client_ptr_t     addr;      /* requested address */
427
        mem_size_t       size;      /* requested size */
428
    } virtual_unlock;
429
    struct
430 431 432
    {
        enum apc_type    type;      /* APC_MAP_VIEW */
        obj_handle_t     handle;    /* mapping handle */
433
        client_ptr_t     addr;      /* requested address */
434
        mem_size_t       size;      /* allocation size */
435
        file_pos_t       offset;    /* file offset */
436
        unsigned int     alloc_type;/* allocation type */
437 438
        unsigned short   zero_bits; /* allocation alignment */
        unsigned short   prot;      /* memory protection flags */
439 440 441 442
    } map_view;
    struct
    {
        enum apc_type    type;      /* APC_UNMAP_VIEW */
443 444
        int              __pad;
        client_ptr_t     addr;      /* view address */
445 446
    } unmap_view;
    struct
447 448
    {
        enum apc_type    type;      /* APC_CREATE_THREAD */
449 450 451
        int              suspend;   /* suspended thread? */
        client_ptr_t     func;      /* void (__stdcall *func)(void*);  start function */
        client_ptr_t     arg;       /* argument for start function */
452 453
        mem_size_t       reserve;   /* reserve size for thread stack */
        mem_size_t       commit;    /* commit size for thread stack */
454
    } create_thread;
455 456
} apc_call_t;

457 458 459 460
typedef union
{
    enum apc_type type;
    struct
461 462 463
    {
        enum apc_type    type;      /* APC_ASYNC_IO */
        unsigned int     status;    /* new status of async operation */
464
        client_ptr_t     apc;       /* user APC to call */
465
        unsigned int     total;     /* bytes transferred */
466 467
    } async_io;
    struct
468 469 470
    {
        enum apc_type    type;      /* APC_VIRTUAL_ALLOC */
        unsigned int     status;    /* status returned by call */
471
        client_ptr_t     addr;      /* resulting address */
472
        mem_size_t       size;      /* resulting size */
473 474 475 476 477
    } virtual_alloc;
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_FREE */
        unsigned int     status;    /* status returned by call */
478
        client_ptr_t     addr;      /* resulting address */
479
        mem_size_t       size;      /* resulting size */
480
    } virtual_free;
481 482 483 484
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_QUERY */
        unsigned int     status;    /* status returned by call */
485 486
        client_ptr_t     base;      /* resulting base address */
        client_ptr_t     alloc_base;/* resulting allocation base */
487
        mem_size_t       size;      /* resulting region size */
488 489 490 491
        unsigned short   state;     /* resulting region state */
        unsigned short   prot;      /* resulting region protection */
        unsigned short   alloc_prot;/* resulting allocation protection */
        unsigned short   alloc_type;/* resulting region allocation type */
492
    } virtual_query;
493 494 495 496
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_PROTECT */
        unsigned int     status;    /* status returned by call */
497
        client_ptr_t     addr;      /* resulting address */
498
        mem_size_t       size;      /* resulting size */
499 500
        unsigned int     prot;      /* old protection flags */
    } virtual_protect;
501 502 503 504
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_FLUSH */
        unsigned int     status;    /* status returned by call */
505
        client_ptr_t     addr;      /* resulting address */
506
        mem_size_t       size;      /* resulting size */
507
    } virtual_flush;
508 509 510 511
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_LOCK */
        unsigned int     status;    /* status returned by call */
512
        client_ptr_t     addr;      /* resulting address */
513
        mem_size_t       size;      /* resulting size */
514 515 516 517 518
    } virtual_lock;
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_UNLOCK */
        unsigned int     status;    /* status returned by call */
519
        client_ptr_t     addr;      /* resulting address */
520
        mem_size_t       size;      /* resulting size */
521
    } virtual_unlock;
522
    struct
523 524 525
    {
        enum apc_type    type;      /* APC_MAP_VIEW */
        unsigned int     status;    /* status returned by call */
526
        client_ptr_t     addr;      /* resulting address */
527
        mem_size_t       size;      /* resulting size */
528 529 530 531 532 533 534
    } map_view;
    struct
    {
        enum apc_type    type;      /* APC_MAP_VIEW */
        unsigned int     status;    /* status returned by call */
    } unmap_view;
    struct
535 536 537 538 539 540
    {
        enum apc_type    type;      /* APC_CREATE_THREAD */
        unsigned int     status;    /* status returned by call */
        thread_id_t      tid;       /* thread id */
        obj_handle_t     handle;    /* handle to new thread */
    } create_thread;
541 542
} apc_result_t;

543 544 545 546 547
/****************************************************************/
/* Request declarations */

/* Create a new process from the context of the parent */
@REQ(new_process)
548 549 550 551 552 553 554 555 556 557 558 559 560
    int          inherit_all;    /* inherit all handles from parent */
    unsigned int create_flags;   /* creation flags */
    int          socket_fd;      /* file descriptor for process socket */
    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 */
    unsigned int process_access; /* access rights for process object */
    unsigned int process_attr;   /* attributes for process object */
    unsigned int thread_access;  /* access rights for thread object */
    unsigned int thread_attr;    /* attributes for thread object */
    VARARG(info,startup_info);   /* startup information */
    VARARG(env,unicode_str);     /* environment for new process */
561
@REPLY
562 563 564 565 566
    obj_handle_t info;           /* new process info handle */
    process_id_t pid;            /* process id */
    obj_handle_t phandle;        /* process handle (in the current process) */
    thread_id_t  tid;            /* thread id */
    obj_handle_t thandle;        /* thread handle (in the current process) */
567 568 569 570 571
@END


/* Retrieve information about a newly started process */
@REQ(get_new_process_info)
572
    obj_handle_t info;           /* info handle returned from new_process_request */
573
@REPLY
574
    int          success;      /* did the process start successfully? */
575
    int          exit_code;    /* process exit code if failed */
576 577 578 579 580
@END


/* Create a new thread from the context of the parent */
@REQ(new_thread)
581 582
    unsigned int access;       /* wanted access rights */
    unsigned int attributes;   /* object attributes */
583 584 585
    int          suspend;      /* new thread should be suspended on creation */
    int          request_fd;   /* fd for request pipe */
@REPLY
586
    thread_id_t  tid;          /* thread id */
587
    obj_handle_t handle;       /* thread handle (in the current process) */
588 589 590
@END


591 592 593
/* Retrieve the new process startup info */
@REQ(get_startup_info)
@REPLY
594 595 596 597
    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 */
598
    VARARG(info,startup_info); /* startup information */
599
    VARARG(env,unicode_str);   /* environment */
600 601 602 603 604
@END


/* Signal the end of the process initialization */
@REQ(init_process_done)
605
    int          gui;          /* is it a GUI process? */
606
    mod_handle_t module;       /* main module base address */
607
    client_ptr_t ldt_copy;     /* address of LDT copy (in thread address space) */
608
    client_ptr_t entry;        /* process entry point */
609 610 611 612 613 614
@END


/* Initialize a thread; called from the child after fork()/clone() */
@REQ(init_thread)
    int          unix_pid;     /* Unix pid of new thread */
615
    int          unix_tid;     /* Unix tid of new thread */
616
    int          debug_level;  /* new debug level */
617
    client_ptr_t teb;          /* TEB of new thread (in thread address space) */
618
    client_ptr_t entry;        /* entry point or PEB if initial thread (in thread address space) */
619 620
    int          reply_fd;     /* fd for reply pipe */
    int          wait_fd;      /* fd for blocking calls pipe */
621
    cpu_type_t   cpu;          /* CPU that this thread is running on */
622
@REPLY
623 624
    process_id_t pid;          /* process id of the new thread's process */
    thread_id_t  tid;          /* thread id of the new thread */
625
    timeout_t    server_start; /* server start time */
626
    data_size_t  info_size;    /* total size of startup info */
627
    int          version;      /* protocol version */
628
    unsigned int all_cpus;     /* bitset of supported CPUs */
629 630 631 632 633
@END


/* Terminate a process */
@REQ(terminate_process)
634
    obj_handle_t handle;       /* process handle to terminate */
635 636 637 638 639 640 641 642
    int          exit_code;    /* process exit code */
@REPLY
    int          self;         /* suicide? */
@END


/* Terminate a thread */
@REQ(terminate_thread)
643
    obj_handle_t handle;       /* thread handle to terminate */
644 645 646 647 648 649 650 651 652
    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)
653
    obj_handle_t handle;           /* process handle */
654
@REPLY
655
    process_id_t pid;              /* server process id */
656
    process_id_t ppid;             /* server process id of parent */
657
    affinity_t   affinity;         /* process affinity mask */
658
    client_ptr_t peb;              /* PEB address in process address space */
659 660
    timeout_t    start_time;       /* process start time */
    timeout_t    end_time;         /* process end time */
661
    int          exit_code;        /* process exit code */
662
    int          priority;         /* priority class */
663 664 665 666 667
@END


/* Set a process informations */
@REQ(set_process_info)
668
    obj_handle_t handle;       /* process handle */
669 670
    int          mask;         /* setting mask (see below) */
    int          priority;     /* priority class */
671
    affinity_t   affinity;     /* affinity mask */
672 673 674 675 676 677 678
@END
#define SET_PROCESS_INFO_PRIORITY 0x01
#define SET_PROCESS_INFO_AFFINITY 0x02


/* Retrieve information about a thread */
@REQ(get_thread_info)
679 680
    obj_handle_t handle;        /* thread handle */
    thread_id_t  tid_in;        /* thread id (optional) */
681
@REPLY
682
    process_id_t pid;           /* server process id */
683
    thread_id_t  tid;           /* server thread id */
684
    client_ptr_t teb;           /* thread teb pointer */
685
    affinity_t   affinity;      /* thread affinity mask */
686 687
    timeout_t    creation_time; /* thread creation time */
    timeout_t    exit_time;     /* thread exit time */
688
    int          exit_code;     /* thread exit code */
689
    int          priority;      /* thread priority level */
690
    int          last;          /* last thread in process */
691 692 693 694 695
@END


/* Set a thread informations */
@REQ(set_thread_info)
696
    obj_handle_t handle;       /* thread handle */
697 698
    int          mask;         /* setting mask (see below) */
    int          priority;     /* priority class */
699
    affinity_t   affinity;     /* affinity mask */
700
    obj_handle_t token;        /* impersonation token */
701 702 703
@END
#define SET_THREAD_INFO_PRIORITY 0x01
#define SET_THREAD_INFO_AFFINITY 0x02
704
#define SET_THREAD_INFO_TOKEN    0x04
705 706


707 708 709
/* Retrieve information about a module */
@REQ(get_dll_info)
    obj_handle_t handle;       /* process handle */
710
    mod_handle_t base_address; /* base address of module */
711
@REPLY
712
    client_ptr_t entry_point;
713
    data_size_t  size;            /* module size */
714
    data_size_t  filename_len;    /* buffer len in bytes required to store filename */
715
    VARARG(filename,unicode_str); /* file name of module */
716 717 718
@END


719 720
/* Suspend a thread */
@REQ(suspend_thread)
721
    obj_handle_t handle;       /* thread handle */
722 723 724 725 726 727 728
@REPLY
    int          count;        /* new suspend count */
@END


/* Resume a thread */
@REQ(resume_thread)
729
    obj_handle_t handle;       /* thread handle */
730 731 732 733 734 735 736
@REPLY
    int          count;        /* new suspend count */
@END


/* Notify the server that a dll has been loaded */
@REQ(load_dll)
737
    obj_handle_t handle;       /* file handle */
738
    mod_handle_t base;         /* base address */
739
    client_ptr_t name;         /* ptr to ptr to name (in process addr space) */
740
    data_size_t  size;         /* dll size */
741 742
    int          dbg_offset;   /* debug info offset */
    int          dbg_size;     /* debug info size */
743
    VARARG(filename,unicode_str); /* file name of dll */
744 745 746 747 748
@END


/* Notify the server that a dll is being unloaded */
@REQ(unload_dll)
749
    mod_handle_t base;         /* base address */
750 751 752
@END


753
/* Queue an APC for a thread or process */
754
@REQ(queue_apc)
755
    obj_handle_t handle;       /* thread or process handle */
756
    apc_call_t   call;         /* call arguments */
757 758
@REPLY
    obj_handle_t handle;       /* APC handle */
759
    int          self;         /* run APC in caller itself? */
760 761 762
@END


763 764 765 766 767 768 769 770
/* Get the result of an APC call */
@REQ(get_apc_result)
    obj_handle_t handle;       /* handle to the APC */
@REPLY
    apc_result_t result;       /* result of the APC */
@END


771 772
/* Close a handle for the current process */
@REQ(close_handle)
773
    obj_handle_t handle;       /* handle to close */
774 775 776 777 778
@END


/* Set a handle information */
@REQ(set_handle_info)
779
    obj_handle_t handle;       /* handle we are interested in */
780 781 782 783
    int          flags;        /* new handle flags */
    int          mask;         /* mask for flags to set */
@REPLY
    int          old_flags;    /* old flag value */
784 785 786
@END


787 788
/* Duplicate a handle */
@REQ(dup_handle)
789 790 791
    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 */
792
    unsigned int access;       /* wanted access rights */
793 794
    unsigned int attributes;   /* object attributes */
    unsigned int options;      /* duplicate options (see below) */
795
@REPLY
796
    obj_handle_t handle;       /* duplicated handle in dst process */
797
    int          self;         /* is the source the current process? */
798
    int          closed;       /* whether the source handle has been closed */
799 800 801 802 803 804 805 806
@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)
807
    process_id_t pid;          /* process id to open */
808
    unsigned int access;       /* wanted access rights */
809
    unsigned int attributes;   /* object attributes */
810
@REPLY
811
    obj_handle_t handle;       /* handle to the process */
812 813 814
@END


815 816
/* Open a handle to a thread */
@REQ(open_thread)
817
    thread_id_t  tid;          /* thread id to open */
818
    unsigned int access;       /* wanted access rights */
819
    unsigned int attributes;   /* object attributes */
820
@REPLY
821
    obj_handle_t handle;       /* handle to the thread */
822 823 824
@END


825 826 827
/* Wait for handles */
@REQ(select)
    int          flags;        /* wait flags (see below) */
828
    client_ptr_t cookie;       /* magic cookie to return to client */
829
    obj_handle_t signal;       /* object to signal (0 if none) */
830
    obj_handle_t prev_apc;     /* handle to previous APC */
831
    timeout_t    timeout;      /* timeout */
832
    VARARG(result,apc_result); /* result of previous APC */
833
    VARARG(handles,handles);   /* handles to select on */
834 835
@REPLY
    timeout_t    timeout;      /* timeout converted to absolute */
836
    apc_call_t   call;         /* APC call arguments */
837
    obj_handle_t apc_handle;   /* handle to next APC */
838 839 840 841 842 843 844 845
@END
#define SELECT_ALL           1
#define SELECT_ALERTABLE     2
#define SELECT_INTERRUPTIBLE 4


/* Create an event */
@REQ(create_event)
846
    unsigned int access;        /* wanted access rights */
847
    unsigned int attributes;    /* object attributes */
848 849
    int          manual_reset;  /* manual reset event */
    int          initial_state; /* initial state of the event */
850
    VARARG(objattr,object_attributes); /* object attributes */
851
@REPLY
852
    obj_handle_t handle;        /* handle to the event */
853 854 855 856
@END

/* Event operation */
@REQ(event_op)
857
    obj_handle_t  handle;       /* handle to event */
858 859 860 861 862 863 864 865
    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 */
866
    unsigned int attributes;    /* object attributes */
867
    obj_handle_t rootdir;       /* root directory */
868 869
    VARARG(name,unicode_str);   /* object name */
@REPLY
870
    obj_handle_t handle;        /* handle to the event */
871 872 873 874 875
@END


/* Create a mutex */
@REQ(create_mutex)
876
    unsigned int access;        /* wanted access rights */
877
    unsigned int attributes;    /* object attributes */
878
    int          owned;         /* initially owned? */
879
    VARARG(objattr,object_attributes); /* object attributes */
880
@REPLY
881
    obj_handle_t handle;        /* handle to the mutex */
882 883 884 885 886
@END


/* Release a mutex */
@REQ(release_mutex)
887
    obj_handle_t handle;        /* handle to the mutex */
888 889
@REPLY
    unsigned int prev_count;    /* value of internal counter, before release */
890 891 892 893 894 895
@END


/* Open a mutex */
@REQ(open_mutex)
    unsigned int access;        /* wanted access rights */
896
    unsigned int attributes;    /* object attributes */
897
    obj_handle_t rootdir;       /* root directory */
898 899
    VARARG(name,unicode_str);   /* object name */
@REPLY
900
    obj_handle_t handle;        /* handle to the mutex */
901 902 903 904 905
@END


/* Create a semaphore */
@REQ(create_semaphore)
906
    unsigned int access;        /* wanted access rights */
907
    unsigned int attributes;    /* object attributes */
908 909
    unsigned int initial;       /* initial count */
    unsigned int max;           /* maximum count */
910
    VARARG(objattr,object_attributes); /* object attributes */
911
@REPLY
912
    obj_handle_t handle;        /* handle to the semaphore */
913 914 915 916 917
@END


/* Release a semaphore */
@REQ(release_semaphore)
918
    obj_handle_t handle;        /* handle to the semaphore */
919 920 921 922 923 924 925 926 927
    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 */
928
    unsigned int attributes;    /* object attributes */
929
    obj_handle_t rootdir;       /* root directory */
930 931
    VARARG(name,unicode_str);   /* object name */
@REPLY
932
    obj_handle_t handle;        /* handle to the semaphore */
933 934 935 936 937 938
@END


/* Create a file */
@REQ(create_file)
    unsigned int access;        /* wanted access rights */
939
    unsigned int attributes;    /* object attributes */
940 941
    unsigned int sharing;       /* sharing flags */
    int          create;        /* file create action */
942
    unsigned int options;       /* file options */
943
    unsigned int attrs;         /* file attributes for creation */
944
    VARARG(objattr,object_attributes); /* object attributes */
945 946
    VARARG(filename,string);    /* file name */
@REPLY
947
    obj_handle_t handle;        /* handle to the file */
948 949 950
@END


951 952 953 954 955 956
/* Open a file object */
@REQ(open_file_object)
    unsigned int access;        /* wanted access rights */
    unsigned int attributes;    /* open attributes */
    obj_handle_t rootdir;       /* root directory */
    unsigned int sharing;       /* sharing flags */
957
    unsigned int options;       /* file options */
958 959 960 961 962 963
    VARARG(filename,unicode_str); /* file name */
@REPLY
    obj_handle_t handle;        /* handle to the file */
@END


964 965 966
/* Allocate a file handle for a Unix fd */
@REQ(alloc_file_handle)
    unsigned int access;        /* wanted access rights */
967
    unsigned int attributes;    /* object attributes */
968 969
    int          fd;            /* file descriptor on the client side */
@REPLY
970
    obj_handle_t handle;        /* handle to the file */
971 972 973 974 975
@END


/* Get a Unix fd to access a file */
@REQ(get_handle_fd)
976
    obj_handle_t handle;        /* handle to the file */
977
@REPLY
978
    int          type;          /* file type (see below) */
979 980 981
    int          removable;     /* is file removable? */
    unsigned int access;        /* file access rights */
    unsigned int options;       /* file open options */
982
@END
983 984 985 986 987 988 989 990 991
enum server_fd_type
{
    FD_TYPE_INVALID,  /* invalid file (no associated fd) */
    FD_TYPE_FILE,     /* regular file */
    FD_TYPE_DIR,      /* directory */
    FD_TYPE_SOCKET,   /* socket */
    FD_TYPE_SERIAL,   /* serial port */
    FD_TYPE_PIPE,     /* named pipe */
    FD_TYPE_MAILSLOT, /* mailslot */
992
    FD_TYPE_CHAR,     /* unspecified char device */
993 994 995
    FD_TYPE_DEVICE,   /* Windows device file */
    FD_TYPE_NB_TYPES
};
996

997 998 999

/* Flush a file buffers */
@REQ(flush_file)
1000
    obj_handle_t handle;        /* handle to the file */
1001 1002
@REPLY
    obj_handle_t event;         /* event set when finished */
1003 1004 1005 1006 1007
@END


/* Lock a region of a file */
@REQ(lock_file)
1008
    obj_handle_t handle;        /* handle to the file */
1009 1010
    file_pos_t   offset;        /* offset of start of lock */
    file_pos_t   count;         /* count of bytes to lock */
1011 1012 1013 1014 1015
    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? */
1016 1017 1018 1019 1020
@END


/* Unlock a region of a file */
@REQ(unlock_file)
1021
    obj_handle_t handle;        /* handle to the file */
1022 1023
    file_pos_t   offset;        /* offset of start of unlock */
    file_pos_t   count;         /* count of bytes to unlock */
1024 1025 1026 1027 1028 1029
@END


/* Create a socket */
@REQ(create_socket)
    unsigned int access;        /* wanted access rights */
1030
    unsigned int attributes;    /* object attributes */
1031 1032 1033
    int          family;        /* family, see socket manpage */
    int          type;          /* type, see socket manpage */
    int          protocol;      /* protocol, see socket manpage */
1034
    unsigned int flags;         /* socket flags */
1035
@REPLY
1036
    obj_handle_t handle;        /* handle to the new socket */
1037 1038 1039 1040 1041
@END


/* Accept a socket */
@REQ(accept_socket)
1042
    obj_handle_t lhandle;       /* handle to the listening socket */
1043
    unsigned int access;        /* wanted access rights */
1044
    unsigned int attributes;    /* object attributes */
1045
@REPLY
1046
    obj_handle_t handle;        /* handle to the new socket */
1047 1048 1049 1050 1051
@END


/* Set socket event parameters */
@REQ(set_socket_event)
1052
    obj_handle_t  handle;        /* handle to the socket */
1053
    unsigned int  mask;          /* event mask */
1054
    obj_handle_t  event;         /* event object */
1055 1056
    user_handle_t window;        /* window to send the message to */
    unsigned int  msg;           /* message to send */
1057 1058 1059 1060 1061
@END


/* Get socket event parameters */
@REQ(get_socket_event)
1062
    obj_handle_t handle;        /* handle to the socket */
1063
    int          service;       /* clear pending? */
1064
    obj_handle_t c_event;       /* event to clear */
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
@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)
1075
    obj_handle_t handle;        /* handle to the socket */
1076 1077 1078 1079 1080
    unsigned int mask;          /* events to re-enable */
    unsigned int sstate;        /* status bits to set */
    unsigned int cstate;        /* status bits to clear */
@END

1081
@REQ(set_socket_deferred)
1082 1083
    obj_handle_t handle;        /* handle to the socket */
    obj_handle_t deferred;      /* handle to the socket for which accept() is deferred */
1084
@END
1085

1086
/* Allocate a console (only used by a console renderer) */
1087 1088
@REQ(alloc_console)
    unsigned int access;        /* wanted access rights */
1089
    unsigned int attributes;    /* object attributes */
1090
    process_id_t pid;           /* pid of process which shall be attached to the console */
1091
@REPLY
1092 1093
    obj_handle_t handle_in;     /* handle to console input */
    obj_handle_t event;         /* handle to renderer events change notification */
1094 1095 1096 1097 1098 1099 1100 1101
@END


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


1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
#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)
1148
    obj_handle_t handle;        /* handle to console input events */
1149 1150 1151 1152 1153
@REPLY
    VARARG(data,bytes);         /* the various console_renderer_events */
@END


1154 1155
/* Open a handle to the process console */
@REQ(open_console)
1156
    obj_handle_t from;          /* 0 (resp 1) input (resp output) of current process console */
1157
                                /* otherwise console_in handle to get active screen buffer? */
1158
    unsigned int access;        /* wanted access rights */
1159
    unsigned int attributes;    /* object attributes */
1160
    int          share;         /* share mask (only for output handles) */
1161
@REPLY
1162
    obj_handle_t handle;        /* handle to the console */
1163 1164 1165
@END


1166 1167 1168 1169 1170 1171
/* Get the input queue wait event */
@REQ(get_console_wait_event)
@REPLY
    obj_handle_t handle;
@END

1172 1173
/* Get a console mode (input or output) */
@REQ(get_console_mode)
1174
    obj_handle_t handle;        /* handle to the console */
1175 1176 1177 1178 1179 1180 1181
@REPLY
    int          mode;          /* console mode */
@END


/* Set a console mode (input or output) */
@REQ(set_console_mode)
1182
    obj_handle_t handle;        /* handle to the console */
1183 1184 1185 1186
    int          mode;          /* console mode */
@END


1187 1188
/* Set info about a console (input only) */
@REQ(set_console_input_info)
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
    obj_handle_t  handle;        /* handle to console input, or 0 for process' console */
    int           mask;          /* setting mask (see below) */
    obj_handle_t  active_sb;     /* active screen buffer */
    int           history_mode;  /* whether we duplicate lines in history */
    int           history_size;  /* number of lines in history */
    int           edition_mode;  /* index to the edition mode flavors */
    int           input_cp;      /* console input codepage */
    int           output_cp;     /* console output codepage */
    user_handle_t win;           /* console window if backend supports it */
    VARARG(title,unicode_str);   /* console title */
1199 1200 1201 1202 1203
@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
1204
#define SET_CONSOLE_INPUT_INFO_EDITION_MODE     0x10
1205 1206
#define SET_CONSOLE_INPUT_INFO_INPUT_CODEPAGE   0x20
#define SET_CONSOLE_INPUT_INFO_OUTPUT_CODEPAGE  0x40
1207
#define SET_CONSOLE_INPUT_INFO_WIN              0x80
1208 1209 1210 1211


/* Get info about a console (input only) */
@REQ(get_console_input_info)
1212
    obj_handle_t  handle;         /* handle to console input, or 0 for process' console */
1213
@REPLY
1214 1215 1216 1217 1218 1219 1220 1221
    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 */
    int           edition_mode;   /* index to the edition mode flavors */
    int           input_cp;       /* console input codepage */
    int           output_cp;      /* console output codepage */
    user_handle_t win;            /* console window if backend supports it */
    VARARG(title,unicode_str);    /* console title */
1222 1223 1224 1225 1226
@END


/* appends a string to console's history */
@REQ(append_console_input_history)
1227
    obj_handle_t handle;        /* handle to console input, or 0 for process' console */
1228 1229 1230 1231 1232 1233
    VARARG(line,unicode_str);   /* line to add */
@END


/* appends a string to console's history */
@REQ(get_console_input_history)
1234
    obj_handle_t handle;        /* handle to console input, or 0 for process' console */
1235 1236
    int          index;         /* index to get line from */
@REPLY
1237
    int          total;         /* total length of line in Unicode chars */
1238 1239 1240 1241 1242 1243
    VARARG(line,unicode_str);   /* line to add */
@END


/* creates a new screen buffer on process' console */
@REQ(create_console_output)
1244
    obj_handle_t handle_in;     /* handle to console input, or 0 for process' console */
1245 1246 1247
    unsigned int access;        /* wanted access rights */
    unsigned int attributes;    /* object attributes */
    unsigned int share;         /* sharing credentials */
1248
@REPLY
1249
    obj_handle_t handle_out;    /* handle to the screen buffer */
1250 1251 1252
@END


1253
/* Set info about a console (output only) */
1254
@REQ(set_console_output_info)
1255
    obj_handle_t handle;        /* handle to the console */
1256
    int          mask;          /* setting mask (see below) */
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
    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

1278 1279

/* Get info about a console (output only) */
1280
@REQ(get_console_output_info)
1281
    obj_handle_t handle;        /* handle to the console */
1282
@REPLY
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
    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;
1296 1297 1298 1299
@END

/* Add input records to a console input queue */
@REQ(write_console_input)
1300
    obj_handle_t handle;        /* handle to the console input */
1301 1302 1303 1304 1305
    VARARG(rec,input_records);  /* input records */
@REPLY
    int          written;       /* number of records written */
@END

1306

1307 1308
/* Fetch input records from a console input queue */
@REQ(read_console_input)
1309
    obj_handle_t handle;        /* handle to the console input */
1310 1311 1312 1313 1314 1315 1316
    int          flush;         /* flush the retrieved records from the queue? */
@REPLY
    int          read;          /* number of records read */
    VARARG(rec,input_records);  /* input records */
@END


1317 1318
/* write data (chars and/or attributes) in a screen buffer */
@REQ(write_console_output)
1319
    obj_handle_t handle;        /* handle to the console output */
1320 1321 1322 1323
    int          x;             /* position where to start writing */
    int          y;
    int          mode;          /* char info (see below) */
    int          wrap;          /* wrap around at end of line? */
1324 1325
    VARARG(data,bytes);         /* info to write */
@REPLY
1326 1327 1328
    int          written;       /* number of char infos actually written */
    int          width;         /* width of screen buffer */
    int          height;        /* height of screen buffer */
1329
@END
1330 1331 1332 1333 1334 1335 1336
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 */
};
1337 1338


1339 1340
/* fill a screen buffer with constant data (chars and/or attributes) */
@REQ(fill_console_output)
1341
    obj_handle_t handle;        /* handle to the console output */
1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
    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 */
1354
@REQ(read_console_output)
1355
    obj_handle_t handle;        /* handle to the console output */
1356 1357 1358 1359
    int          x;             /* position (x,y) where to start reading */
    int          y;
    int          mode;          /* char info mode */
    int          wrap;          /* wrap around at end of line? */
1360
@REPLY
1361 1362
    int          width;         /* width of screen buffer */
    int          height;        /* height of screen buffer */
1363 1364 1365
    VARARG(data,bytes);
@END

1366

1367 1368
/* move a rect (of data) in screen buffer content */
@REQ(move_console_output)
1369
    obj_handle_t handle;        /* handle to the console output */
1370 1371 1372 1373 1374 1375 1376 1377 1378
    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


1379 1380 1381
/* Sends a signal to a process group */
@REQ(send_console_signal)
    int          signal;        /* the signal to send */
1382
    process_id_t group_id;      /* the group to send the signal to */
1383 1384 1385
@END


1386 1387
/* enable directory change notifications */
@REQ(read_directory_changes)
1388
    unsigned int filter;        /* notification filter */
1389
    int          subtree;       /* watch the subtree? */
1390
    int          want_data;     /* flag indicating whether change data should be collected */
1391
    async_data_t async;         /* async I/O parameters */
1392 1393 1394 1395 1396 1397 1398 1399
@END


@REQ(read_change)
    obj_handle_t handle;
@REPLY
    int          action;        /* type of change */
    VARARG(name,string);        /* name of directory entry that changed */
1400 1401 1402 1403 1404
@END


/* Create a file mapping */
@REQ(create_mapping)
1405 1406
    unsigned int access;        /* wanted access rights */
    unsigned int attributes;    /* object attributes */
1407
    unsigned int protect;       /* protection flags (see below) */
1408
    mem_size_t   size;          /* mapping size */
1409
    obj_handle_t file_handle;   /* file handle */
1410
    VARARG(objattr,object_attributes); /* object attributes */
1411
@REPLY
1412
    obj_handle_t handle;        /* handle to the mapping */
1413
@END
1414
/* per-page protection flags */
1415 1416 1417 1418 1419 1420 1421
#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
1422
#define VPROT_WRITEWATCH 0x80
1423 1424 1425 1426
/* per-mapping protection flags */
#define VPROT_IMAGE      0x0100  /* mapping for an exe image */
#define VPROT_SYSTEM     0x0200  /* system view (underlying mmap not under our control) */
#define VPROT_VALLOC     0x0400  /* allocated by VirtualAlloc */
1427
#define VPROT_NOEXEC     0x0800  /* don't force exec permission */
1428 1429 1430 1431 1432


/* Open a mapping */
@REQ(open_mapping)
    unsigned int access;        /* wanted access rights */
1433
    unsigned int attributes;    /* object attributes */
1434
    obj_handle_t rootdir;       /* root directory */
1435 1436
    VARARG(name,unicode_str);   /* object name */
@REPLY
1437
    obj_handle_t handle;        /* handle to the mapping */
1438 1439 1440 1441 1442
@END


/* Get information about a file mapping */
@REQ(get_mapping_info)
1443
    obj_handle_t handle;        /* handle to the mapping */
1444
    unsigned int access;        /* wanted access rights */
1445
@REPLY
1446
    mem_size_t   size;          /* mapping size */
1447 1448
    int          protect;       /* protection flags */
    int          header_size;   /* header size (for VPROT_IMAGE mapping) */
1449
    client_ptr_t base;          /* default base addr (for VPROT_IMAGE mapping) */
1450
    obj_handle_t mapping;       /* duplicate mapping handle unless removable */
1451
    obj_handle_t shared_file;   /* shared mapping file handle */
1452 1453 1454
@END


1455 1456 1457 1458 1459
/* Get a range of committed pages in a file mapping */
@REQ(get_mapping_committed_range)
    obj_handle_t handle;        /* handle to the mapping */
    file_pos_t   offset;        /* starting offset (page-aligned, in bytes) */
@REPLY
1460
    mem_size_t   size;          /* size of range starting at offset (page-aligned, in bytes) */
1461 1462 1463 1464 1465 1466 1467 1468
    int          committed;     /* whether it is a committed range */
@END


/* Add a range to the committed pages in a file mapping */
@REQ(add_mapping_committed_range)
    obj_handle_t handle;        /* handle to the mapping */
    file_pos_t   offset;        /* starting offset (page-aligned, in bytes) */
1469
    mem_size_t   size;          /* size to set (page-aligned, in bytes) or 0 if only retrieving */
1470 1471 1472
@END


1473 1474
#define SNAP_PROCESS    0x00000001
#define SNAP_THREAD     0x00000002
1475 1476
/* Create a snapshot */
@REQ(create_snapshot)
1477
    unsigned int attributes;    /* object attributes */
1478
    unsigned int flags;         /* snapshot flags (SNAP_*) */
1479
@REPLY
1480
    obj_handle_t handle;        /* handle to the snapshot */
1481 1482 1483 1484 1485
@END


/* Get the next process from a snapshot */
@REQ(next_process)
1486
    obj_handle_t handle;        /* handle to the snapshot */
1487 1488 1489
    int          reset;         /* reset snapshot position? */
@REPLY
    int          count;         /* process usage count */
1490 1491
    process_id_t pid;           /* process id */
    process_id_t ppid;          /* parent process id */
1492 1493
    int          threads;       /* number of threads */
    int          priority;      /* process priority */
1494
    int          handles;       /* number of handles */
1495
    VARARG(filename,unicode_str); /* file name of main exe */
1496 1497 1498 1499 1500
@END


/* Get the next thread from a snapshot */
@REQ(next_thread)
1501
    obj_handle_t handle;        /* handle to the snapshot */
1502 1503 1504
    int          reset;         /* reset snapshot position? */
@REPLY
    int          count;         /* thread usage count */
1505 1506
    process_id_t pid;           /* process id */
    thread_id_t  tid;           /* thread id */
1507 1508 1509 1510 1511 1512 1513 1514 1515
    int          base_pri;      /* base priority */
    int          delta_pri;     /* delta priority */
@END


/* Wait for a debug event */
@REQ(wait_debug_event)
    int           get_handle;  /* should we alloc a handle for waiting? */
@REPLY
1516 1517
    process_id_t  pid;         /* process id */
    thread_id_t   tid;         /* thread id */
1518
    obj_handle_t  wait;        /* wait handle if no event ready */
1519 1520 1521 1522 1523 1524
    VARARG(event,debug_event); /* debug event data */
@END


/* Queue an exception event */
@REQ(queue_exception_event)
1525 1526 1527 1528 1529 1530 1531 1532
    int           first;       /* first chance exception? */
    unsigned int  code;        /* exception code */
    unsigned int  flags;       /* exception flags */
    client_ptr_t  record;      /* exception record */
    client_ptr_t  address;     /* exception address */
    data_size_t   len;         /* size of parameters */
    VARARG(params,uints64,len);/* exception parameters */
    VARARG(context,context);   /* thread context */
1533
@REPLY
1534
    obj_handle_t     handle;   /* handle to the queued event */
1535 1536 1537 1538 1539
@END


/* Retrieve the status of an exception event */
@REQ(get_exception_status)
1540
    obj_handle_t     handle;   /* handle to the queued event */
1541
@REPLY
1542 1543 1544 1545 1546 1547
    VARARG(context,context);   /* modified thread context */
@END


/* Send an output string to the debugger */
@REQ(output_debug_string)
1548 1549
    data_size_t   length;      /* string length */
    client_ptr_t  string;      /* string to display (in debugged process address space) */
1550 1551 1552 1553 1554 1555
    int           unicode;     /* is it Unicode? */
@END


/* Continue a debug event */
@REQ(continue_debug_event)
1556 1557
    process_id_t pid;          /* process id to continue */
    thread_id_t  tid;          /* thread id to continue */
1558 1559 1560 1561
    int          status;       /* continuation status */
@END


1562
/* Start/stop debugging an existing process */
1563
@REQ(debug_process)
1564
    process_id_t pid;          /* id of the process to debug */
1565 1566 1567 1568
    int          attach;       /* 1=attaching / 0=detaching from the process */
@END


1569 1570
/* Simulate a breakpoint in a process */
@REQ(debug_break)
1571
    obj_handle_t handle;       /* process handle */
1572 1573 1574 1575 1576
@REPLY
    int          self;         /* was it the caller itself? */
@END


1577 1578 1579
/* Set debugger kill on exit flag */
@REQ(set_debugger_kill_on_exit)
    int          kill_on_exit;  /* 0=detach/1=kill debuggee when debugger dies */
1580 1581 1582 1583 1584
@END


/* Read data from a process address space */
@REQ(read_process_memory)
1585
    obj_handle_t handle;       /* process handle */
1586
    client_ptr_t addr;         /* addr to read from */
1587 1588 1589 1590 1591 1592 1593
@REPLY
    VARARG(data,bytes);        /* result data */
@END


/* Write data to a process address space */
@REQ(write_process_memory)
1594
    obj_handle_t handle;       /* process handle */
1595
    client_ptr_t addr;         /* addr to write to */
1596
    VARARG(data,bytes);        /* data to write */
1597 1598 1599 1600 1601
@END


/* Create a registry key */
@REQ(create_key)
1602
    obj_handle_t parent;       /* handle to the parent key */
1603
    unsigned int access;       /* desired access rights */
1604
    unsigned int attributes;   /* object attributes */
1605
    unsigned int options;      /* creation options */
1606
    data_size_t  namelen;      /* length of key name in bytes */
1607 1608
    VARARG(name,unicode_str,namelen);  /* key name */
    VARARG(class,unicode_str);         /* class name */
1609
@REPLY
1610
    obj_handle_t hkey;         /* handle to the created key */
1611 1612 1613 1614 1615
    int          created;      /* has it been newly created? */
@END

/* Open a registry key */
@REQ(open_key)
1616
    obj_handle_t parent;       /* handle to the parent key */
1617
    unsigned int access;       /* desired access rights */
1618
    unsigned int attributes;   /* object attributes */
1619 1620
    VARARG(name,unicode_str);  /* key name */
@REPLY
1621
    obj_handle_t hkey;         /* handle to the open key */
1622 1623 1624 1625 1626
@END


/* Delete a registry key */
@REQ(delete_key)
1627
    obj_handle_t hkey;         /* handle to the key */
1628 1629 1630
@END


1631 1632 1633 1634 1635 1636
/* Flush a registry key */
@REQ(flush_key)
    obj_handle_t hkey;         /* handle to the key */
@END


1637 1638
/* Enumerate registry subkeys */
@REQ(enum_key)
1639
    obj_handle_t hkey;         /* handle to registry key */
1640
    int          index;        /* index of subkey (or -1 for current key) */
1641
    int          info_class;   /* requested information class */
1642 1643 1644 1645 1646 1647 1648
@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 */
1649
    timeout_t    modif;        /* last modification time */
1650 1651
    data_size_t  total;        /* total length needed for full name and class */
    data_size_t  namelen;      /* length of key name in bytes */
1652 1653
    VARARG(name,unicode_str,namelen);  /* key name */
    VARARG(class,unicode_str);         /* class name */
1654 1655 1656 1657 1658
@END


/* Set a value of a registry key */
@REQ(set_key_value)
1659
    obj_handle_t hkey;         /* handle to registry key */
1660
    int          type;         /* value type */
1661
    data_size_t  namelen;      /* length of value name in bytes */
1662 1663
    VARARG(name,unicode_str,namelen);  /* value name */
    VARARG(data,bytes);                /* value data */
1664 1665 1666 1667 1668
@END


/* Retrieve the value of a registry key */
@REQ(get_key_value)
1669
    obj_handle_t hkey;         /* handle to registry key */
1670
    VARARG(name,unicode_str);  /* value name */
1671 1672
@REPLY
    int          type;         /* value type */
1673
    data_size_t  total;        /* total length needed for data */
1674 1675 1676 1677 1678 1679
    VARARG(data,bytes);        /* value data */
@END


/* Enumerate a value of a registry key */
@REQ(enum_key_value)
1680
    obj_handle_t hkey;         /* handle to registry key */
1681
    int          index;        /* value index */
1682
    int          info_class;   /* requested information class */
1683 1684
@REPLY
    int          type;         /* value type */
1685 1686
    data_size_t  total;        /* total length needed for full name and data */
    data_size_t  namelen;      /* length of value name in bytes */
1687 1688
    VARARG(name,unicode_str,namelen);  /* value name */
    VARARG(data,bytes);                /* value data */
1689 1690 1691 1692 1693
@END


/* Delete a value of a registry key */
@REQ(delete_key_value)
1694
    obj_handle_t hkey;         /* handle to registry key */
1695 1696 1697 1698 1699 1700
    VARARG(name,unicode_str);  /* value name */
@END


/* Load a registry branch from a file */
@REQ(load_registry)
1701 1702
    obj_handle_t hkey;         /* root key to load to */
    obj_handle_t file;         /* file to load from */
1703 1704 1705 1706
    VARARG(name,unicode_str);  /* subkey name */
@END


1707 1708 1709 1710 1711 1712
/* UnLoad a registry branch from a file */
@REQ(unload_registry)
    obj_handle_t hkey;         /* root key to unload to */
@END


1713 1714
/* Save a registry branch to a file */
@REQ(save_registry)
1715 1716
    obj_handle_t hkey;         /* key to save */
    obj_handle_t file;         /* file to save to */
1717 1718 1719
@END


1720
/* Add a registry key change notification */
1721 1722 1723 1724 1725 1726 1727 1728
@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


1729 1730
/* Create a waitable timer */
@REQ(create_timer)
1731
    unsigned int access;        /* wanted access rights */
1732
    unsigned int attributes;    /* object attributes */
1733
    obj_handle_t rootdir;       /* root directory */
1734 1735 1736
    int          manual;        /* manual reset */
    VARARG(name,unicode_str);   /* object name */
@REPLY
1737
    obj_handle_t handle;        /* handle to the timer */
1738 1739 1740 1741 1742 1743
@END


/* Open a waitable timer */
@REQ(open_timer)
    unsigned int access;        /* wanted access rights */
1744
    unsigned int attributes;    /* object attributes */
1745
    obj_handle_t rootdir;       /* root directory */
1746 1747
    VARARG(name,unicode_str);   /* object name */
@REPLY
1748
    obj_handle_t handle;        /* handle to the timer */
1749 1750 1751 1752
@END

/* Set a waitable timer */
@REQ(set_timer)
1753
    obj_handle_t handle;        /* handle to the timer */
1754
    timeout_t    expire;        /* next expiration absolute time */
1755 1756
    client_ptr_t callback;      /* callback function */
    client_ptr_t arg;           /* callback argument */
1757
    int          period;        /* timer period in ms */
1758 1759
@REPLY
    int          signaled;      /* was the timer signaled before this call ? */
1760 1761 1762 1763
@END

/* Cancel a waitable timer */
@REQ(cancel_timer)
1764
    obj_handle_t handle;        /* handle to the timer */
1765 1766
@REPLY
     int         signaled;      /* was the timer signaled before this calltime ? */
1767 1768
@END

1769 1770 1771 1772
/* Get information on a waitable timer */
@REQ(get_timer_info)
    obj_handle_t handle;        /* handle to the timer */
@REPLY
1773
    timeout_t    when;          /* absolute time when the timer next expires */
1774 1775 1776
    int          signaled;      /* is the timer signaled? */
@END

1777 1778 1779

/* Retrieve the current context of a thread */
@REQ(get_thread_context)
1780
    obj_handle_t handle;       /* thread handle */
1781
    unsigned int flags;        /* context flags */
1782
    int          suspend;      /* if getting context during suspend */
1783
@REPLY
1784
    int          self;         /* was it a handle to the current thread? */
1785 1786 1787 1788 1789 1790
    VARARG(context,context);   /* thread context */
@END


/* Set the current context of a thread */
@REQ(set_thread_context)
1791
    obj_handle_t handle;       /* thread handle */
1792
    int          suspend;      /* if setting context during suspend */
1793
    VARARG(context,context);   /* thread context */
1794 1795
@REPLY
    int          self;         /* was it a handle to the current thread? */
1796 1797 1798 1799 1800
@END


/* Fetch a selector entry for a thread */
@REQ(get_selector_entry)
1801
    obj_handle_t  handle;      /* thread handle */
1802 1803 1804 1805 1806 1807 1808 1809 1810 1811
    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)
1812
    obj_handle_t  table;       /* which table to add atom to */
1813 1814
    VARARG(name,unicode_str);  /* atom name */
@REPLY
1815
    atom_t        atom;        /* resulting atom */
1816 1817 1818 1819 1820
@END


/* Delete an atom */
@REQ(delete_atom)
1821
    obj_handle_t  table;       /* which table to delete atom from */
1822
    atom_t        atom;        /* atom handle */
1823 1824 1825 1826 1827
@END


/* Find an atom */
@REQ(find_atom)
1828
    obj_handle_t table;        /* which table to find atom from */
1829 1830
    VARARG(name,unicode_str);  /* atom name */
@REPLY
1831
    atom_t       atom;         /* atom handle */
1832 1833 1834
@END


1835 1836 1837
/* Get information about an atom */
@REQ(get_atom_information)
    obj_handle_t table;        /* which table to find atom from */
1838
    atom_t       atom;         /* atom handle */
1839 1840
@REPLY
    int          count;        /* atom lock count */
1841
    int          pinned;       /* whether the atom has been pinned */
1842
    data_size_t  total;        /* actual length of atom name */
1843 1844 1845 1846
    VARARG(name,unicode_str);  /* atom name */
@END


1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862
/* Set information about an atom */
@REQ(set_atom_information)
    obj_handle_t table;        /* which table to find atom from */
    atom_t       atom;         /* atom handle */
    int          pinned;       /* whether to bump atom information */
@END


/* Empty an atom table */
@REQ(empty_atom_table)
    obj_handle_t table;        /* which table to find atom from */
    int          if_pinned;    /* whether to delete pinned atoms */
@END


/* Init an atom table */
1863
@REQ(init_atom_table)
1864 1865 1866
    int          entries;      /* number of entries (only for local) */
@REPLY
    obj_handle_t table;        /* handle to the atom table */
1867 1868 1869 1870 1871 1872
@END


/* Get the message queue of the current thread */
@REQ(get_msg_queue)
@REPLY
1873
    obj_handle_t handle;       /* handle to the queue */
1874 1875 1876
@END


1877 1878 1879 1880 1881 1882
/* Set the file descriptor associated to the current thread queue */
@REQ(set_queue_fd)
    obj_handle_t handle;       /* handle to the file descriptor */
@END


1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902
/* 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


1903 1904
/* Retrieve the process idle event */
@REQ(get_process_idle_event)
1905
    obj_handle_t handle;       /* process handle */
1906
@REPLY
1907
    obj_handle_t event;        /* handle to idle event */
1908 1909 1910 1911 1912
@END


/* Send a message to a thread queue */
@REQ(send_message)
1913
    thread_id_t     id;        /* thread id */
1914
    int             type;      /* message type (see below) */
1915
    int             flags;     /* message flags (see below) */
1916
    user_handle_t   win;       /* window handle */
1917
    unsigned int    msg;       /* message code */
1918 1919
    lparam_t        wparam;    /* parameters */
    lparam_t        lparam;    /* parameters */
1920
    timeout_t       timeout;   /* timeout for reply */
1921
    VARARG(data,message_data); /* message data for sent messages */
1922
@END
1923

1924 1925 1926 1927
@REQ(post_quit_message)
    int             exit_code; /* exit code to return */
@END

1928 1929 1930 1931 1932 1933
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 */
1934
    MSG_CALLBACK_RESULT,/* result of a callback message */
1935 1936
    MSG_OTHER_PROCESS,  /* sent from other process, may include vararg data, always Unicode */
    MSG_POSTED,         /* posted message (from PostMessageW), always Unicode */
1937 1938
    MSG_HARDWARE,       /* hardware message */
    MSG_WINEVENT        /* winevent message */
1939
};
1940
#define SEND_MSG_ABORT_IF_HUNG  0x01
1941 1942


1943 1944 1945 1946 1947
/* Send a hardware message to a thread queue */
@REQ(send_hardware_message)
    thread_id_t     id;        /* thread id */
    user_handle_t   win;       /* window handle */
    unsigned int    msg;       /* message code */
1948 1949 1950
    lparam_t        wparam;    /* parameters */
    lparam_t        lparam;    /* parameters */
    lparam_t        info;      /* extra info */
1951 1952
    int             x;         /* x position */
    int             y;         /* y position */
1953
    unsigned int    time;      /* message time */
1954 1955 1956
@END


1957 1958
/* Get a message from the current queue */
@REQ(get_message)
1959
    unsigned int    flags;     /* PM_* flags */
1960
    user_handle_t   get_win;   /* window handle to get */
1961 1962
    unsigned int    get_first; /* first message code to get */
    unsigned int    get_last;  /* last message code to get */
1963
    unsigned int    hw_id;     /* id of the previous hardware message (or 0) */
1964 1965
    unsigned int    wake_mask; /* wakeup bits mask */
    unsigned int    changed_mask; /* changed bits mask */
1966
@REPLY
1967
    user_handle_t   win;       /* window handle */
1968
    unsigned int    msg;       /* message code */
1969 1970
    lparam_t        wparam;    /* parameters */
    lparam_t        lparam;    /* parameters */
1971
    int             type;      /* message type */
1972
    unsigned int    time;      /* message time */
1973
    unsigned int    active_hooks; /* active hooks bitmap */
1974
    data_size_t     total;     /* total size of extra data */
1975
    VARARG(data,message_data); /* message data for sent messages */
1976
@END
1977

1978 1979 1980 1981

/* Reply to a sent message */
@REQ(reply_message)
    int             remove;    /* should we remove the message? */
1982
    lparam_t        result;    /* message result */
1983
    VARARG(data,bytes);        /* message data for sent messages */
1984 1985 1986
@END


1987 1988
/* Accept the current hardware message */
@REQ(accept_hardware_message)
1989
    unsigned int    hw_id;     /* id of the hardware message */
1990 1991 1992 1993 1994
    int             remove;    /* should we remove the message? */
    user_handle_t   new_win;   /* new destination window for current message */
@END


1995 1996 1997 1998
/* Retrieve the reply for the last message sent */
@REQ(get_message_reply)
    int             cancel;    /* cancel message if not ready? */
@REPLY
1999
    lparam_t        result;    /* message result */
2000
    VARARG(data,bytes);        /* message data for sent messages */
2001 2002 2003 2004 2005
@END


/* Set a window timer */
@REQ(set_win_timer)
2006
    user_handle_t   win;       /* window handle */
2007 2008
    unsigned int    msg;       /* message to post */
    unsigned int    rate;      /* timer rate in ms */
2009 2010
    lparam_t        id;        /* timer id */
    lparam_t        lparam;    /* message lparam (callback proc) */
2011
@REPLY
2012
    lparam_t        id;        /* timer id */
2013 2014 2015 2016 2017
@END


/* Kill a window timer */
@REQ(kill_win_timer)
2018
    user_handle_t   win;       /* window handle */
2019
    lparam_t        id;        /* timer id */
2020
    unsigned int    msg;       /* message to post */
2021 2022 2023
@END


2024 2025 2026 2027 2028 2029 2030 2031
/* check if the thread owning the window is hung */
@REQ(is_window_hung)
    user_handle_t   win;       /* window handle */
@REPLY
    int is_hung;
@END


2032 2033
/* Retrieve info about a serial port */
@REQ(get_serial_info)
2034
    obj_handle_t handle;       /* handle to comm port */
2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046
@REPLY
    unsigned int readinterval;
    unsigned int readconst;
    unsigned int readmult;
    unsigned int writeconst;
    unsigned int writemult;
    unsigned int eventmask;
@END


/* Set info about a serial port */
@REQ(set_serial_info)
2047
    obj_handle_t handle;       /* handle to comm port */
2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059
    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;
@END
#define SERIALINFO_SET_TIMEOUTS  0x01
#define SERIALINFO_SET_MASK      0x02


2060
/* Create an async I/O */
2061
@REQ(register_async)
2062
    int          type;          /* type of queue to look after */
2063
    async_data_t async;         /* async I/O parameters */
2064
    int          count;         /* count - usually # of bytes to be read/written */
2065 2066 2067 2068 2069 2070
@END
#define ASYNC_TYPE_READ  0x01
#define ASYNC_TYPE_WRITE 0x02
#define ASYNC_TYPE_WAIT  0x03


2071 2072 2073 2074 2075 2076
/* Cancel all async op on a fd */
@REQ(cancel_async)
    obj_handle_t handle;        /* handle to comm port, socket or file */
@END


2077 2078
/* Perform an ioctl on a file */
@REQ(ioctl)
2079
    ioctl_code_t   code;          /* ioctl code */
2080
    async_data_t   async;         /* async I/O parameters */
2081
    int            blocking;      /* whether it's a blocking ioctl */
2082 2083
    VARARG(in_data,bytes);        /* ioctl input data */
@REPLY
2084 2085
    obj_handle_t   wait;          /* handle to wait on for blocking ioctl */
    unsigned int   options;       /* device open options */
2086 2087 2088 2089
    VARARG(out_data,bytes);       /* ioctl output data */
@END


2090 2091 2092
/* Retrieve results of an async ioctl */
@REQ(get_ioctl_result)
    obj_handle_t   handle;        /* handle to the device */
2093
    client_ptr_t   user_arg;      /* user arg used to identify the request */
2094 2095 2096 2097 2098
@REPLY
    VARARG(out_data,bytes);       /* ioctl output data */
@END


2099 2100
/* Create a named pipe */
@REQ(create_named_pipe)
2101
    unsigned int   access;
2102
    unsigned int   attributes;   /* object attributes */
2103
    obj_handle_t   rootdir;      /* root directory */
2104
    unsigned int   options;
2105 2106 2107
    unsigned int   maxinstances;
    unsigned int   outsize;
    unsigned int   insize;
2108
    timeout_t      timeout;
2109
    unsigned int   flags;
2110
    VARARG(name,unicode_str);    /* pipe name */
2111
@REPLY
2112
    obj_handle_t   handle;       /* handle to the pipe */
2113 2114
@END

2115 2116 2117 2118
/* flags in create_named_pipe and get_named_pipe_info */
#define NAMED_PIPE_MESSAGE_STREAM_WRITE 0x0001
#define NAMED_PIPE_MESSAGE_STREAM_READ  0x0002
#define NAMED_PIPE_NONBLOCKING_MODE     0x0004
2119
#define NAMED_PIPE_SERVER_END           0x8000
2120

2121

2122
@REQ(get_named_pipe_info)
2123
    obj_handle_t   handle;
2124 2125 2126
@REPLY
    unsigned int   flags;
    unsigned int   maxinstances;
2127
    unsigned int   instances;
2128 2129 2130 2131
    unsigned int   outsize;
    unsigned int   insize;
@END

2132 2133 2134

/* Create a window */
@REQ(create_window)
2135 2136
    user_handle_t  parent;      /* parent window */
    user_handle_t  owner;       /* owner window */
2137
    atom_t         atom;        /* class atom */
2138
    mod_handle_t   instance;    /* module instance */
2139
    VARARG(class,unicode_str);  /* class name */
2140
@REPLY
2141
    user_handle_t  handle;      /* created window */
2142 2143
    user_handle_t  parent;      /* full handle of parent */
    user_handle_t  owner;       /* full handle of owner */
2144
    int            extra;       /* number of extra bytes */
2145
    client_ptr_t   class_ptr;   /* pointer to class in client address space */
2146 2147 2148 2149 2150 2151 2152 2153 2154
@END


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


2155 2156
/* Retrieve the desktop window for the current thread */
@REQ(get_desktop_window)
2157
    int            force;       /* force creation if it doesn't exist */
2158
@REPLY
2159 2160
    user_handle_t  top_window;  /* handle to the desktop window */
    user_handle_t  msg_window;  /* handle to the top-level HWND_MESSAGE parent */
2161 2162 2163
@END


2164 2165 2166 2167 2168 2169
/* 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 */
2170
    user_handle_t  prev_owner;  /* full handle of previous owner */
2171 2172 2173
@END


2174 2175 2176 2177 2178
/* 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 */
2179
    user_handle_t  last_active; /* last active popup */
2180 2181
    process_id_t   pid;         /* process owning the window */
    thread_id_t    tid;         /* thread owning the window */
2182
    atom_t         atom;        /* class atom */
2183
    int            is_unicode;  /* ANSI or unicode */
2184
@END
2185 2186


2187 2188
/* Set some information in a window */
@REQ(set_window_info)
2189 2190
    unsigned short flags;         /* flags for fields to set (see below) */
    short int      is_unicode;    /* ANSI or unicode */
2191
    user_handle_t  handle;        /* handle to the window */
2192 2193 2194
    unsigned int   style;         /* window style */
    unsigned int   ex_style;      /* window extended style */
    unsigned int   id;            /* window id */
2195
    mod_handle_t   instance;      /* creator instance */
2196
    lparam_t       user_data;     /* user-specific data */
2197
    int            extra_offset;  /* offset to set in extra bytes */
2198
    data_size_t    extra_size;    /* size to set in extra bytes */
2199
    lparam_t       extra_value;   /* value to set in extra bytes */
2200 2201 2202
@REPLY
    unsigned int   old_style;     /* old window style */
    unsigned int   old_ex_style;  /* old window extended style */
2203
    mod_handle_t   old_instance;  /* old creator instance */
2204 2205
    lparam_t       old_user_data; /* old user-specific data */
    lparam_t       old_extra_value; /* old value in extra bytes */
2206
    unsigned int   old_id;        /* old window id */
2207 2208 2209 2210 2211 2212
@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
2213
#define SET_WIN_EXTRA     0x20
2214
#define SET_WIN_UNICODE   0x40
2215 2216


2217 2218 2219 2220 2221 2222 2223 2224 2225 2226
/* Set the parent of a window */
@REQ(set_parent)
    user_handle_t  handle;      /* handle to the window */
    user_handle_t  parent;      /* handle to the parent */
@REPLY
    user_handle_t  old_parent;  /* old parent window */
    user_handle_t  full_parent; /* full handle of new parent */
@END


2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237
/* 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)
2238
    obj_handle_t   desktop;       /* handle to desktop */
2239
    user_handle_t  parent;        /* parent window */
2240
    atom_t         atom;          /* class atom for the listed children */
2241
    thread_id_t    tid;           /* thread owning the listed children */
2242
    VARARG(class,unicode_str);    /* class name */
2243 2244
@REPLY
    int            count;         /* total count of children */
2245
    VARARG(children,user_handles); /* children handles */
2246 2247 2248
@END


2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259
/* Get a list of the window children that contain a given point */
@REQ(get_window_children_from_point)
    user_handle_t  parent;        /* parent window */
    int            x;             /* point in parent coordinates */
    int            y;
@REPLY
    int            count;         /* total count of children */
    VARARG(children,user_handles); /* children handles */
@END


2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272
/* 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
2273

2274 2275
/* Set the position and Z order of a window */
@REQ(set_window_pos)
2276
    unsigned int   flags;         /* SWP_* flags */
2277
    user_handle_t  handle;        /* handle to the window */
2278
    user_handle_t  previous;      /* previous window in Z order */
2279 2280
    rectangle_t    window;        /* window rectangle */
    rectangle_t    client;        /* client rectangle */
2281
    VARARG(valid,rectangles);     /* valid rectangles from WM_NCCALCSIZE */
2282 2283
@REPLY
    unsigned int   new_style;     /* new window style */
2284
    unsigned int   new_ex_style;  /* new window extended style */
2285 2286 2287 2288 2289 2290 2291 2292
@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 */
2293
    rectangle_t    visible;       /* visible part of the window rectangle */
2294 2295 2296 2297
    rectangle_t    client;        /* client rectangle */
@END


2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312
/* 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


2313 2314 2315 2316 2317 2318 2319 2320 2321
/* 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

2322

2323 2324 2325 2326 2327
/* Get the visible region of a window */
@REQ(get_visible_region)
    user_handle_t  window;        /* handle to the window */
    unsigned int   flags;         /* DCX flags */
@REPLY
2328
    user_handle_t  top_win;       /* top window to clip against */
2329 2330
    rectangle_t    top_rect;      /* top window visible rect with screen coords */
    rectangle_t    win_rect;      /* window rect in screen coords */
2331
    data_size_t    total_size;    /* total size of the resulting region */
2332
    VARARG(region,rectangles);    /* list of rectangles for the region (in screen coords) */
2333 2334 2335
@END


2336 2337 2338 2339
/* Get the window region */
@REQ(get_window_region)
    user_handle_t  window;        /* handle to the window */
@REPLY
2340
    data_size_t    total_size;    /* total size of the resulting region */
2341 2342 2343 2344 2345 2346 2347
    VARARG(region,rectangles);    /* list of rectangles for the region */
@END


/* Set the window region */
@REQ(set_window_region)
    user_handle_t  window;        /* handle to the window */
2348
    int            redraw;        /* redraw the window? */
2349 2350 2351 2352
    VARARG(region,rectangles);    /* list of rectangles for the region */
@END


2353 2354 2355
/* Get the window update region */
@REQ(get_update_region)
    user_handle_t  window;        /* handle to the window */
2356
    user_handle_t  from_child;    /* child to start searching from */
2357 2358 2359 2360
    unsigned int   flags;         /* update flags (see below) */
@REPLY
    user_handle_t  child;         /* child to repaint (or window itself) */
    unsigned int   flags;         /* resulting update flags (see below) */
2361
    data_size_t    total_size;    /* total size of the resulting region */
2362 2363 2364 2365 2366 2367 2368 2369 2370
    VARARG(region,rectangles);    /* list of rectangles for the region */
@END
#define UPDATE_NONCLIENT       0x01  /* get region for repainting non-client area */
#define UPDATE_ERASE           0x02  /* get region for erasing client area */
#define UPDATE_PAINT           0x04  /* get region for painting client area */
#define UPDATE_INTERNALPAINT   0x08  /* get region if internal paint is pending */
#define UPDATE_ALLCHILDREN     0x10  /* force repaint of all children */
#define UPDATE_NOCHILDREN      0x20  /* don't try to repaint any children */
#define UPDATE_NOREGION        0x40  /* don't return a region, only the flags */
2371
#define UPDATE_DELAYED_ERASE   0x80  /* still needs erase after BeginPaint */
2372 2373


2374 2375 2376 2377 2378 2379 2380
/* Update the z order of a window so that a given rectangle is fully visible */
@REQ(update_window_zorder)
    user_handle_t  window;        /* handle to the window */
    rectangle_t    rect;          /* rectangle that must be visible */
@END


2381 2382 2383 2384 2385 2386 2387 2388
/* Mark parts of a window as needing a redraw */
@REQ(redraw_window)
    user_handle_t  window;        /* handle to the window */
    unsigned int   flags;         /* RDW_* flags */
    VARARG(region,rectangles);    /* list of rectangles for the region */
@END


2389 2390 2391
/* Set a window property */
@REQ(set_window_property)
    user_handle_t  window;        /* handle to the window */
2392
    lparam_t       data;          /* data to store */
2393
    atom_t         atom;          /* property atom (if no name specified) */
2394
    VARARG(name,unicode_str);     /* property name */
2395 2396 2397 2398 2399 2400
@END


/* Remove a window property */
@REQ(remove_window_property)
    user_handle_t  window;        /* handle to the window */
2401 2402
    atom_t         atom;          /* property atom (if no name specified) */
    VARARG(name,unicode_str);     /* property name */
2403
@REPLY
2404
    lparam_t       data;          /* data stored in property */
2405 2406 2407 2408 2409 2410
@END


/* Get a window property */
@REQ(get_window_property)
    user_handle_t  window;        /* handle to the window */
2411 2412
    atom_t         atom;          /* property atom (if no name specified) */
    VARARG(name,unicode_str);     /* property name */
2413
@REPLY
2414
    lparam_t       data;          /* data stored in property */
2415 2416 2417 2418 2419 2420 2421
@END


/* Get the list of properties of a window */
@REQ(get_window_properties)
    user_handle_t  window;        /* handle to the window */
@REPLY
2422
    int            total;         /* total number of properties */
2423 2424
    VARARG(props,properties);     /* list of properties */
@END
2425 2426


2427 2428 2429 2430
/* Create a window station */
@REQ(create_winstation)
    unsigned int flags;           /* window station flags */
    unsigned int access;          /* wanted access rights */
2431
    unsigned int attributes;      /* object attributes */
2432 2433 2434 2435 2436 2437 2438 2439 2440
    VARARG(name,unicode_str);     /* object name */
@REPLY
    obj_handle_t handle;          /* handle to the window station */
@END


/* Open a handle to a window station */
@REQ(open_winstation)
    unsigned int access;          /* wanted access rights */
2441
    unsigned int attributes;      /* object attributes */
2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466
    VARARG(name,unicode_str);     /* object name */
@REPLY
    obj_handle_t handle;          /* handle to the window station */
@END


/* Close a window station */
@REQ(close_winstation)
    obj_handle_t handle;          /* handle to the window station */
@END


/* Get the process current window station */
@REQ(get_process_winstation)
@REPLY
    obj_handle_t handle;          /* handle to the window station */
@END


/* Set the process current window station */
@REQ(set_process_winstation)
    obj_handle_t handle;          /* handle to the window station */
@END


2467 2468 2469 2470 2471 2472 2473 2474 2475
/* Enumerate window stations */
@REQ(enum_winstation)
    unsigned int index;           /* current index */
@REPLY
    unsigned int next;            /* next index */
    VARARG(name,unicode_str);     /* window station name */
@END


2476 2477 2478 2479
/* Create a desktop */
@REQ(create_desktop)
    unsigned int flags;           /* desktop flags */
    unsigned int access;          /* wanted access rights */
2480
    unsigned int attributes;      /* object attributes */
2481 2482 2483 2484 2485 2486 2487 2488
    VARARG(name,unicode_str);     /* object name */
@REPLY
    obj_handle_t handle;          /* handle to the desktop */
@END


/* Open a handle to a desktop */
@REQ(open_desktop)
2489
    obj_handle_t winsta;          /* window station to open (null allowed) */
2490 2491
    unsigned int flags;           /* desktop flags */
    unsigned int access;          /* wanted access rights */
2492
    unsigned int attributes;      /* object attributes */
2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518
    VARARG(name,unicode_str);     /* object name */
@REPLY
    obj_handle_t handle;          /* handle to the desktop */
@END


/* Close a desktop */
@REQ(close_desktop)
    obj_handle_t handle;          /* handle to the desktop */
@END


/* Get the thread current desktop */
@REQ(get_thread_desktop)
    thread_id_t  tid;             /* thread id */
@REPLY
    obj_handle_t handle;          /* handle to the desktop */
@END


/* Set the thread current desktop */
@REQ(set_thread_desktop)
    obj_handle_t handle;          /* handle to the desktop */
@END


2519 2520 2521 2522 2523 2524 2525 2526 2527 2528
/* Enumerate desktops */
@REQ(enum_desktop)
    obj_handle_t winstation;      /* handle to the window station */
    unsigned int index;           /* current index */
@REPLY
    unsigned int next;            /* next index */
    VARARG(name,unicode_str);     /* window station name */
@END


2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541
/* Get/set information about a user object (window station or desktop) */
@REQ(set_user_object_info)
    obj_handle_t handle;          /* handle to the object */
    unsigned int flags;           /* information to set */
    unsigned int obj_flags;       /* new object flags */
@REPLY
    int          is_desktop;      /* is object a desktop? */
    unsigned int old_obj_flags;   /* old object flags */
    VARARG(name,unicode_str);     /* object name */
@END
#define SET_USER_OBJECT_FLAGS 1


2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562
/* 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
2563

2564 2565 2566 2567 2568 2569 2570 2571

/* Get the time of the last input event */
@REQ(get_last_input_time)
@REPLY
    unsigned int time;
@END


2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586
/* 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

2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608
/* 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
2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619

/* 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 */
2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651


/* 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 */
2652 2653 2654 2655 2656


/* Set a window hook */
@REQ(set_hook)
    int            id;             /* id of the hook */
2657
    process_id_t   pid;            /* id of process to set the hook into */
2658
    thread_id_t    tid;            /* id of thread to set the hook into */
2659 2660
    int            event_min;
    int            event_max;
2661
    client_ptr_t   proc;           /* hook procedure */
2662
    int            flags;
2663
    int            unicode;        /* is it a unicode hook? */
2664
    VARARG(module,unicode_str);    /* module name */
2665 2666
@REPLY
    user_handle_t  handle;         /* handle to the hook */
2667
    unsigned int   active_hooks;   /* active hooks bitmap */
2668 2669 2670 2671 2672 2673
@END


/* Remove a window hook */
@REQ(remove_hook)
    user_handle_t  handle;         /* handle to the hook */
2674
    client_ptr_t   proc;           /* hook procedure if handle is 0 */
2675
    int            id;             /* id of the hook if handle is 0 */
2676 2677
@REPLY
    unsigned int   active_hooks;   /* active hooks bitmap */
2678 2679 2680 2681 2682 2683
@END


/* Start calling a hook chain */
@REQ(start_hook_chain)
    int            id;             /* id of the hook */
2684 2685 2686 2687
    int            event;          /* signalled event */
    user_handle_t  window;         /* handle to the event window */
    int            object_id;      /* object id for out of context winevent */
    int            child_id;       /* child id for out of context winevent */
2688 2689
@REPLY
    user_handle_t  handle;         /* handle to the next hook */
2690 2691
    process_id_t   pid;            /* process id for low-level keyboard/mouse hooks */
    thread_id_t    tid;            /* thread id for low-level keyboard/mouse hooks */
2692
    int            unicode;        /* is it a unicode hook? */
2693
    client_ptr_t   proc;           /* hook procedure */
2694
    unsigned int   active_hooks;   /* active hooks bitmap */
2695
    VARARG(module,unicode_str);    /* module name */
2696 2697 2698 2699 2700 2701 2702 2703 2704
@END


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


2705 2706
/* Get the hook information */
@REQ(get_hook_info)
2707
    user_handle_t  handle;         /* handle to the current hook */
2708
    int            get_next;       /* do we want info about current or next hook? */
2709 2710 2711 2712
    int            event;          /* signalled event */
    user_handle_t  window;         /* handle to the event window */
    int            object_id;      /* object id for out of context winevent */
    int            child_id;       /* child id for out of context winevent */
2713
@REPLY
2714 2715
    user_handle_t  handle;         /* handle to the hook */
    int            id;             /* id of the hook */
2716 2717
    process_id_t   pid;            /* process id for low-level keyboard/mouse hooks */
    thread_id_t    tid;            /* thread id for low-level keyboard/mouse hooks */
2718
    client_ptr_t   proc;           /* hook procedure */
2719
    int            unicode;        /* is it a unicode hook? */
2720
    VARARG(module,unicode_str);    /* module name */
2721
@END
2722 2723


2724 2725 2726 2727 2728
/* Create a window class */
@REQ(create_class)
    int            local;          /* is it a local class? */
    atom_t         atom;           /* class atom */
    unsigned int   style;          /* class style */
2729
    mod_handle_t   instance;       /* module instance */
2730 2731
    int            extra;          /* number of extra class bytes */
    int            win_extra;      /* number of window extra bytes */
2732
    client_ptr_t   client_ptr;     /* pointer to class in client address space */
2733 2734 2735
    VARARG(name,unicode_str);      /* class name */
@REPLY
    atom_t         atom;           /* resulting class atom */
2736 2737 2738 2739 2740 2741
@END


/* Destroy a window class */
@REQ(destroy_class)
    atom_t         atom;           /* class atom */
2742
    mod_handle_t   instance;       /* module instance */
2743
    VARARG(name,unicode_str);      /* class name */
2744
@REPLY
2745
    client_ptr_t   client_ptr;     /* pointer to class in client address space */
2746 2747 2748 2749 2750 2751 2752 2753 2754 2755
@END


/* Set some information in a class */
@REQ(set_class_info)
    user_handle_t  window;         /* handle to the window */
    unsigned int   flags;          /* flags for info to set (see below) */
    atom_t         atom;           /* class atom */
    unsigned int   style;          /* class style */
    int            win_extra;      /* number of window extra bytes */
2756
    mod_handle_t   instance;       /* module instance */
2757
    int            extra_offset;   /* offset to set in extra bytes */
2758
    data_size_t    extra_size;     /* size to set in extra bytes */
2759
    lparam_t       extra_value;    /* value to set in extra bytes */
2760 2761 2762 2763 2764
@REPLY
    atom_t         old_atom;       /* previous class atom */
    unsigned int   old_style;      /* previous class style */
    int            old_extra;      /* previous number of class extra bytes */
    int            old_win_extra;  /* previous number of window extra bytes */
2765
    mod_handle_t   old_instance;   /* previous module instance */
2766
    lparam_t       old_extra_value; /* old value in extra bytes */
2767 2768 2769 2770 2771 2772 2773 2774
@END
#define SET_CLASS_ATOM      0x0001
#define SET_CLASS_STYLE     0x0002
#define SET_CLASS_WINEXTRA  0x0004
#define SET_CLASS_INSTANCE  0x0008
#define SET_CLASS_EXTRA     0x0010


2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797
/* 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
2798
#define CB_PROCESS       0x100
2799 2800 2801 2802 2803


/* Open a security token */
@REQ(open_token)
    obj_handle_t   handle;    /* handle to the thread or process */
2804 2805
    unsigned int   access;    /* access rights to the new token */
    unsigned int   attributes;/* object attributes */
2806 2807 2808 2809 2810 2811
    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
2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829


/* 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
2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849

/* Adjust the privileges held by a token */
@REQ(adjust_token_privileges)
    obj_handle_t  handle; /* handle to the token */
    int           disable_all; /* disable all privileges? */
    int           get_modified_state; /* get modified privileges? */
    VARARG(privileges,LUID_AND_ATTRIBUTES); /* privileges to enable/disable/remove */
@REPLY
    unsigned int  len; /* total length in bytes required to store token privileges */
    VARARG(privileges,LUID_AND_ATTRIBUTES); /* modified privileges */
@END

/* Retrieves the set of privileges held by or available to a token */
@REQ(get_token_privileges)
    obj_handle_t  handle; /* handle to the token */
@REPLY
    unsigned int  len; /* total length in bytes required to store token privileges */
    VARARG(privileges,LUID_AND_ATTRIBUTES); /* privileges held by or available to a token */
@END

2850 2851 2852 2853 2854 2855 2856 2857 2858 2859
/* Check the token has the required privileges */
@REQ(check_token_privileges)
    obj_handle_t  handle; /* handle to the token */
    int           all_required; /* are all the privileges required for the check to succeed? */
    VARARG(privileges,LUID_AND_ATTRIBUTES); /* privileges to check */
@REPLY
    int           has_privileges; /* does the token have the required privileges? */
    VARARG(privileges,LUID_AND_ATTRIBUTES); /* privileges held by or available to a token */
@END

2860
@REQ(duplicate_token)
2861 2862 2863 2864
    obj_handle_t  handle;        /* handle to the token to duplicate */
    unsigned int  access;        /* access rights to the new token */
    unsigned int  attributes;    /* object attributes */
    int           primary;       /* is the new token to be a primary one? */
2865 2866 2867 2868
    int           impersonation_level; /* impersonation level of the new token */
@REPLY
    obj_handle_t  new_handle; /* duplicated handle */
@END
Mike McCormack's avatar
Mike McCormack committed
2869

2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883
@REQ(access_check)
    obj_handle_t    handle; /* handle to the token */
    unsigned int    desired_access; /* desired access to the object */
    unsigned int    mapping_read; /* mapping from generic read to specific rights */
    unsigned int    mapping_write; /* mapping from generic write to specific rights */
    unsigned int    mapping_execute; /* mapping from generic execute to specific rights */
    unsigned int    mapping_all; /* mapping from generic all to specific rights */
    VARARG(sd,security_descriptor); /* security descriptor to check */
@REPLY
    unsigned int    access_granted; /* access rights actually granted */
    unsigned int    access_status; /* was access granted? */
    unsigned int    privileges_len; /* length needed to store privileges */
    VARARG(privileges,LUID_AND_ATTRIBUTES); /* privileges used during access check */
@END
Mike McCormack's avatar
Mike McCormack committed
2884

2885 2886 2887
@REQ(get_token_user)
    obj_handle_t    handle;       /* handle to the token */
@REPLY
2888
    data_size_t     user_len;     /* length needed to store user */
2889 2890 2891
    VARARG(user,SID);             /* sid of the user the token represents */
@END

2892 2893 2894
@REQ(get_token_groups)
    obj_handle_t    handle;       /* handle to the token */
@REPLY
2895
    data_size_t     user_len;     /* length needed to store user */
2896 2897 2898
    VARARG(user,token_groups); /* groups the token's user belongs to */
@END

2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910
@REQ(get_token_default_dacl)
    obj_handle_t    handle;     /* handle to the token */
@REPLY
    data_size_t     acl_len;    /* length needed to store access control list */
    VARARG(acl,ACL);            /* access control list */
@END

@REQ(set_token_default_dacl)
    obj_handle_t    handle;     /* handle to the token */
    VARARG(acl,ACL);            /* default dacl to set */
@END

2911 2912 2913 2914 2915 2916
@REQ(set_security_object)
    obj_handle_t    handle;       /* handle to the object */
    unsigned int    security_info; /* which parts of security descriptor to set */
    VARARG(sd,security_descriptor); /* security descriptor to set */
@END

2917 2918 2919 2920 2921 2922 2923 2924
@REQ(get_security_object)
    obj_handle_t    handle;       /* handle to the object */
    unsigned int    security_info; /* which parts of security descriptor to get */
@REPLY
    unsigned int    sd_len;         /* buffer size needed for sd */
    VARARG(sd,security_descriptor); /* retrieved security descriptor */
@END

Mike McCormack's avatar
Mike McCormack committed
2925 2926
/* Create a mailslot */
@REQ(create_mailslot)
2927 2928
    unsigned int   access;        /* wanted access rights */
    unsigned int   attributes;    /* object attributes */
2929
    obj_handle_t   rootdir;       /* root directory */
2930
    timeout_t      read_timeout;
2931
    unsigned int   max_msgsize;
Mike McCormack's avatar
Mike McCormack committed
2932 2933 2934 2935 2936 2937 2938 2939 2940
    VARARG(name,unicode_str);     /* mailslot name */
@REPLY
    obj_handle_t   handle;        /* handle to the mailslot */
@END


/* Set mailslot information */
@REQ(set_mailslot_info)
    obj_handle_t   handle;        /* handle to the mailslot */
2941
    timeout_t      read_timeout;
2942
    unsigned int   flags;
Mike McCormack's avatar
Mike McCormack committed
2943
@REPLY
2944
    timeout_t      read_timeout;
2945
    unsigned int   max_msgsize;
Mike McCormack's avatar
Mike McCormack committed
2946 2947
@END
#define MAILSLOT_SET_READ_TIMEOUT  1
2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969


/* Create a directory object */
@REQ(create_directory)
    unsigned int   access;        /* access flags */
    unsigned int   attributes;    /* object attributes */
    obj_handle_t   rootdir;       /* root directory */
    VARARG(directory_name,unicode_str); /* Directory name */
@REPLY
    obj_handle_t   handle;        /* handle to the directory */
@END


/* Open a directory object */
@REQ(open_directory)
    unsigned int   access;        /* access flags */
    unsigned int   attributes;    /* object attributes */
    obj_handle_t   rootdir;       /* root directory */
    VARARG(directory_name,unicode_str); /* Directory name */
@REPLY
    obj_handle_t   handle;        /* handle to the directory */
@END
2970 2971


2972 2973 2974 2975 2976
/* Get a directory entry by index */
@REQ(get_directory_entry)
    obj_handle_t   handle;             /* handle to the directory */
    unsigned int   index;              /* entry index */
@REPLY
2977
    data_size_t    name_len;           /* length of the entry name in bytes */
2978 2979 2980 2981 2982
    VARARG(name,unicode_str,name_len); /* entry name */
    VARARG(type,unicode_str);          /* entry type */
@END


2983 2984 2985 2986 2987
/* Create a symbolic link object */
@REQ(create_symlink)
    unsigned int   access;        /* access flags */
    unsigned int   attributes;    /* object attributes */
    obj_handle_t   rootdir;       /* root directory */
2988
    data_size_t    name_len;      /* length of the symlink name in bytes */
2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012
    VARARG(name,unicode_str,name_len); /* symlink name */
    VARARG(target_name,unicode_str);   /* target name */
@REPLY
    obj_handle_t   handle;        /* handle to the symlink */
@END


/* Open a symbolic link object */
@REQ(open_symlink)
    unsigned int   access;        /* access flags */
    unsigned int   attributes;    /* object attributes */
    obj_handle_t   rootdir;       /* root directory */
    VARARG(name,unicode_str);     /* symlink name */
@REPLY
    obj_handle_t   handle;        /* handle to the symlink */
@END


/* Query a symbolic link object */
@REQ(query_symlink)
    obj_handle_t   handle;        /* handle to the symlink */
@REPLY
    VARARG(target_name,unicode_str); /* target name */
@END
3013 3014 3015 3016 3017 3018 3019 3020 3021


/* Query basic object information */
@REQ(get_object_info)
    obj_handle_t   handle;        /* handle to the object */
@REPLY
    unsigned int   access;        /* granted access mask */
    unsigned int   ref_count;     /* object ref count */
@END
3022

3023 3024 3025 3026 3027 3028 3029

/* Unlink a named object */
@REQ(unlink_object)
    obj_handle_t   handle;        /* handle to the object */
@END


3030 3031 3032 3033 3034 3035
/* Query the impersonation level of an impersonation token */
@REQ(get_token_impersonation_level)
    obj_handle_t   handle;        /* handle to the object */
@REPLY
    int            impersonation_level; /* impersonation level of the impersonation token */
@END
3036 3037 3038 3039 3040 3041

/* Allocate a locally-unique identifier */
@REQ(allocate_locally_unique_id)
@REPLY
    luid_t         luid;
@END
3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057


/* Create a device manager */
@REQ(create_device_manager)
    unsigned int access;          /* wanted access rights */
    unsigned int attributes;      /* object attributes */
@REPLY
    obj_handle_t handle;          /* handle to the device */
@END


/* Create a device */
@REQ(create_device)
    unsigned int access;          /* wanted access rights */
    unsigned int attributes;      /* object attributes */
    obj_handle_t rootdir;         /* root directory */
3058
    client_ptr_t user_ptr;        /* opaque ptr for use by client */
3059
    obj_handle_t manager;         /* device manager */
3060 3061 3062 3063 3064 3065 3066 3067 3068 3069
    VARARG(name,unicode_str);     /* object name */
@REPLY
    obj_handle_t handle;          /* handle to the device */
@END


/* Delete a device */
@REQ(delete_device)
    obj_handle_t handle;          /* handle to the device */
@END
3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080


/* Retrieve the next pending device ioctl request */
@REQ(get_next_device_request)
    obj_handle_t manager;         /* handle to the device manager */
    obj_handle_t prev;            /* handle to the previous ioctl */
    unsigned int status;          /* status of the previous ioctl */
    VARARG(prev_data,bytes);      /* output data of the previous ioctl */
@REPLY
    obj_handle_t next;            /* handle to the next ioctl */
    ioctl_code_t code;            /* ioctl code */
3081
    client_ptr_t user_ptr;        /* opaque ptr for the device */
3082 3083 3084 3085
    data_size_t  in_size;         /* total needed input size */
    data_size_t  out_size;        /* needed output size */
    VARARG(next_data,bytes);      /* input data of the next ioctl */
@END
3086 3087 3088 3089 3090 3091 3092


/* Make the current process a system process */
@REQ(make_process_system)
@REPLY
    obj_handle_t event;           /* event signaled when all user processes have exited */
@END
3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105


/* Get detailed fixed-size information about a token */
@REQ(get_token_statistics)
    obj_handle_t   handle;        /* handle to the object */
@REPLY
    luid_t         token_id;      /* locally-unique identifier of the token */
    luid_t         modified_id;   /* locally-unique identifier of the modified version of the token */
    int            primary;       /* is the token primary or impersonation? */
    int            impersonation_level; /* level of impersonation */
    int            group_count;   /* the number of groups the token is a member of */
    int            privilege_count; /* the number of privileges the token has */
@END
3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133


/* Create I/O completion port */
@REQ(create_completion)
    unsigned int access;          /* desired access to a port */
    unsigned int attributes;      /* object attributes */
    unsigned int concurrent;      /* max number of concurrent active threads */
    obj_handle_t rootdir;         /* root directory */
    VARARG(filename,string);      /* port name */
@REPLY
    obj_handle_t handle;          /* port handle */
@END


/* Open I/O completion port */
@REQ(open_completion)
    unsigned int access;          /* desired access to a port */
    unsigned int attributes;      /* object attributes */
    obj_handle_t rootdir;         /* root directory */
    VARARG(filename,string);      /* port name */
@REPLY
    obj_handle_t handle;          /* port handle */
@END


/* add completion to completion port */
@REQ(add_completion)
    obj_handle_t  handle;         /* port handle */
3134 3135
    apc_param_t   ckey;           /* completion key */
    apc_param_t   cvalue;         /* completion value */
3136
    unsigned int  information;    /* IO_STATUS_BLOCK Information */
3137 3138 3139 3140 3141 3142 3143 3144
    unsigned int  status;         /* completion result */
@END


/* get completion from completion port queue */
@REQ(remove_completion)
    obj_handle_t handle;          /* port handle */
@REPLY
3145 3146
    apc_param_t   ckey;           /* completion key */
    apc_param_t   cvalue;         /* completion value */
3147
    unsigned int  information;    /* IO_STATUS_BLOCK Information */
3148 3149 3150 3151 3152 3153 3154 3155 3156 3157
    unsigned int  status;         /* completion result */
@END


/* get completion queue depth */
@REQ(query_completion)
    obj_handle_t  handle;         /* port handle */
@REPLY
    unsigned int  depth;          /* completion queue depth */
@END
3158 3159 3160 3161 3162


/* associate object with completion port */
@REQ(set_completion_info)
    obj_handle_t  handle;         /* object handle */
3163
    apc_param_t   ckey;           /* completion key */
3164
    obj_handle_t  chandle;        /* port handle */
3165
@END
3166 3167 3168 3169 3170


/* check for associated completion and push msg */
@REQ(add_fd_completion)
    obj_handle_t   handle;        /* async' object */
3171
    apc_param_t    cvalue;        /* completion value */
3172
    unsigned int   status;        /* completion status */
3173
    unsigned int   information;   /* IO_STATUS_BLOCK Information */
3174
@END
3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193


/* Retrieve layered info for a window */
@REQ(get_window_layered_info)
    user_handle_t  handle;        /* handle to the window */
@REPLY
    unsigned int   color_key;     /* color key */
    unsigned int   alpha;         /* alpha (0..255) */
    unsigned int   flags;         /* LWA_* flags */
@END


/* Set layered info for a window */
@REQ(set_window_layered_info)
    user_handle_t  handle;        /* handle to the window */
    unsigned int   color_key;     /* color key */
    unsigned int   alpha;         /* alpha (0..255) */
    unsigned int   flags;         /* LWA_* flags */
@END