protocol.def 130 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
    } 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;
131 132
} debug_event_t;

133 134 135
/* supported CPU types */
enum cpu_type
{
136
    CPU_x86, CPU_x86_64, CPU_POWERPC, CPU_ARM, CPU_ARM64
137 138 139
};
typedef int cpu_type_t;

140 141 142 143 144 145 146 147 148
/* 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;
149 150
                 unsigned int cs, ss, flags, __pad; } x86_64_regs;
        struct { unsigned int iar, msr, ctr, lr, dar, dsisr, trap, __pad; } powerpc_regs;
151
        struct { unsigned int sp, lr, pc, cpsr; } arm_regs;
152
        struct { unsigned __int64 sp, pc, pstate; } arm64_regs;
153 154 155 156 157 158 159
    } 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 int gpr[32], cr, xer; } powerpc_regs;
160
        struct { unsigned int r[13]; } arm_regs;
161
        struct { unsigned __int64 x[31]; } arm64_regs;
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
    } 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 { 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

194 195 196
/* structure used in sending an fd from client to server */
struct send_fd
{
197 198
    thread_id_t tid;  /* thread id */
    int         fd;   /* file descriptor on client-side */
199 200 201 202 203
};

/* structure sent by the server on the wait fifo */
struct wake_up_reply
{
204 205
    client_ptr_t cookie;    /* magic cookie that was passed in select_request */
    int          signaled;  /* wait result */
206
    int          __pad;
207 208
};

209 210 211
/* NT-style timeout, in 100ns units, negative means relative timeout */
typedef __int64 timeout_t;
#define TIMEOUT_INFINITE (((timeout_t)0x7fffffff) << 32 | 0xffffffff)
212

213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
/* structure for process startup info */
typedef struct
{
    unsigned int debug_flags;
    unsigned int console_flags;
    obj_handle_t console;
    obj_handle_t hstdin;
    obj_handle_t hstdout;
    obj_handle_t hstderr;
    unsigned int x;
    unsigned int y;
    unsigned int xsize;
    unsigned int ysize;
    unsigned int xchars;
    unsigned int ychars;
    unsigned int attribute;
    unsigned int flags;
    unsigned int show;
    data_size_t  curdir_len;
    data_size_t  dllpath_len;
    data_size_t  imagepath_len;
    data_size_t  cmdline_len;
    data_size_t  title_len;
    data_size_t  desktop_len;
    data_size_t  shellinfo_len;
    data_size_t  runtime_len;
    /* VARARG(curdir,unicode_str,curdir_len); */
    /* VARARG(dllpath,unicode_str,dllpath_len); */
    /* VARARG(imagepath,unicode_str,imagepath_len); */
    /* VARARG(cmdline,unicode_str,cmdline_len); */
    /* VARARG(title,unicode_str,title_len); */
    /* VARARG(desktop,unicode_str,desktop_len); */
    /* VARARG(shellinfo,unicode_str,shellinfo_len); */
    /* VARARG(runtime,unicode_str,runtime_len); */
} startup_info_t;

249 250 251 252
/* structure returned in the list of window properties */
typedef struct
{
    atom_t         atom;     /* property atom */
253
    int            string;   /* was atom a string originally? */
254
    lparam_t       data;     /* data stored in property */
255 256
} property_data_t;

257 258 259 260 261 262 263 264 265
/* structure to specify window rectangles */
typedef struct
{
    int  left;
    int  top;
    int  right;
    int  bottom;
} rectangle_t;

266 267 268
/* structure for parameters of async I/O calls */
typedef struct
{
269 270
    obj_handle_t    handle;        /* object to perform I/O on */
    obj_handle_t    event;         /* event to signal when done */
271
    client_ptr_t    iosb;          /* I/O status block in client addr space */
272 273 274
    client_ptr_t    user;          /* opaque user data containing callback pointer and async-specific data */
    client_ptr_t    apc;           /* user APC to call */
    apc_param_t     apc_context;   /* user APC context or completion value */
275 276
} async_data_t;

277
/* structures for extra message data */
278

279 280 281 282
struct hardware_msg_data
{
    lparam_t        info;      /* extra info */
    unsigned int    hw_id;     /* unique id */
283
    unsigned int    flags;     /* hook flags */
284 285 286 287
    union
    {
        int type;
        struct
288 289 290 291 292 293 294
        {
            int            type;    /* RIM_TYPEKEYBOARD */
            unsigned int   message; /* message generated by this rawinput event */
            unsigned short vkey;    /* virtual key code */
            unsigned short scan;    /* scan code */
        } kbd;
        struct
295 296 297 298 299 300 301
        {
            int            type;    /* RIM_TYPEMOUSE */
            int            x;       /* x coordinate */
            int            y;       /* y coordinate */
            unsigned int   data;    /* mouse data */
        } mouse;
    } rawinput;
302 303
};

304 305
struct callback_msg_data
{
306
    client_ptr_t    callback;   /* callback function */
307 308
    lparam_t        data;       /* user data for callback */
    lparam_t        result;     /* message result */
309 310
};

311 312 313 314
struct winevent_msg_data
{
    user_handle_t   hook;       /* hook handle */
    thread_id_t     tid;        /* thread id */
315
    client_ptr_t    hook_proc;  /* hook proc address */
316 317 318
    /* followed by module name if any */
};

319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
typedef union
{
    int type;
    struct
    {
        int            type;    /* INPUT_KEYBOARD */
        unsigned short vkey;    /* virtual key code */
        unsigned short scan;    /* scan code */
        unsigned int   flags;   /* event flags */
        unsigned int   time;    /* event time */
        lparam_t       info;    /* extra info */
    } kbd;
    struct
    {
        int            type;    /* INPUT_MOUSE */
        int            x;       /* coordinates */
        int            y;
        unsigned int   data;    /* mouse data */
        unsigned int   flags;   /* event flags */
        unsigned int   time;    /* event time */
        lparam_t       info;    /* extra info */
    } mouse;
    struct
    {
        int            type;    /* INPUT_HARDWARE */
        unsigned int   msg;     /* message code */
        lparam_t       lparam;  /* message param */
    } hw;
} hw_input_t;

349 350 351
typedef union
{
    unsigned char            bytes[1];   /* raw data for sent messages */
352
    struct hardware_msg_data hardware;
353
    struct callback_msg_data callback;
354 355 356
    struct winevent_msg_data winevent;
} message_data_t;

357 358 359 360 361 362 363
/* structure for console char/attribute info */
typedef struct
{
    WCHAR          ch;
    unsigned short attr;
} char_info_t;

364 365 366 367 368 369 370 371
/* structure returned in filesystem events */
struct filesystem_event
{
    int         action;
    data_size_t len;
    char        name[1];
};

372 373 374 375 376 377
typedef struct
{
    unsigned int low_part;
    int          high_part;
} luid_t;

378 379 380 381 382
#define MAX_ACL_LEN 65535

struct security_descriptor
{
    unsigned int control;       /* SE_ flags */
383 384 385 386
    data_size_t  owner_len;
    data_size_t  group_len;
    data_size_t  sacl_len;
    data_size_t  dacl_len;
387 388 389 390 391 392 393 394
    /* VARARG(owner,SID); */
    /* VARARG(group,SID); */
    /* VARARG(sacl,ACL); */
    /* VARARG(dacl,ACL); */
};

struct object_attributes
{
395 396 397 398
    obj_handle_t rootdir;       /* root directory */
    unsigned int attributes;    /* object attributes */
    data_size_t  sd_len;        /* length of security_descriptor data. may be 0 */
    data_size_t  name_len;      /* length of the name string. may be 0 */
399 400
    /* VARARG(sd,security_descriptor); */
    /* VARARG(name,unicode_str); */
401 402
};

403 404 405 406
struct token_groups
{
    unsigned int count;
    /* unsigned int attributes[count]; */
407
    /* VARARG(sids,SID); */
408 409
};

410 411 412
enum select_op
{
    SELECT_NONE,
413
    SELECT_WAIT,
414
    SELECT_WAIT_ALL,
415 416 417
    SELECT_SIGNAL_AND_WAIT,
    SELECT_KEYED_EVENT_WAIT,
    SELECT_KEYED_EVENT_RELEASE
418 419 420 421 422 423 424
};

typedef union
{
    enum select_op op;
    struct
    {
425
        enum select_op  op;      /* SELECT_WAIT or SELECT_WAIT_ALL */
426 427
        obj_handle_t    handles[MAXIMUM_WAIT_OBJECTS];
    } wait;
428 429 430 431 432 433
    struct
    {
        enum select_op  op;      /* SELECT_SIGNAL_AND_WAIT */
        obj_handle_t    wait;
        obj_handle_t    signal;  /* must be last in the structure so we can remove it on retries */
    } signal_and_wait;
434 435 436 437 438 439
    struct
    {
        enum select_op  op;      /* SELECT_KEYED_EVENT_WAIT or SELECT_KEYED_EVENT_RELEASE */
        obj_handle_t    handle;
        client_ptr_t    key;
    } keyed_event;
440 441
} select_op_t;

442 443 444 445 446 447 448
enum apc_type
{
    APC_NONE,
    APC_USER,
    APC_TIMER,
    APC_ASYNC_IO,
    APC_VIRTUAL_ALLOC,
449
    APC_VIRTUAL_FREE,
450
    APC_VIRTUAL_QUERY,
451
    APC_VIRTUAL_PROTECT,
452 453
    APC_VIRTUAL_FLUSH,
    APC_VIRTUAL_LOCK,
454
    APC_VIRTUAL_UNLOCK,
455 456
    APC_MAP_VIEW,
    APC_UNMAP_VIEW,
457
    APC_CREATE_THREAD
458
};
459 460 461 462 463 464 465

typedef union
{
    enum apc_type type;
    struct
    {
        enum apc_type    type;     /* APC_USER */
466 467
        int              __pad;
        client_ptr_t     func;     /* void (__stdcall *func)(ULONG_PTR,ULONG_PTR,ULONG_PTR); */
468
        apc_param_t      args[3];  /* arguments for user function */
469 470 471
    } user;
    struct
    {
472
        enum apc_type    type;     /* APC_TIMER */
473
        int              __pad;
474
        client_ptr_t     func;     /* void (__stdcall *func)(void*, unsigned int, unsigned int); */
475
        timeout_t        time;     /* absolute time of expiration */
476
        client_ptr_t     arg;      /* user argument */
477 478 479 480 481
    } timer;
    struct
    {
        enum apc_type    type;     /* APC_ASYNC_IO */
        unsigned int     status;   /* I/O status */
482 483
        client_ptr_t     user;     /* user pointer */
        client_ptr_t     sb;       /* status block */
484
    } async_io;
485 486 487
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_ALLOC */
488 489
        unsigned int     op_type;   /* type of operation */
        client_ptr_t     addr;      /* requested address */
490
        mem_size_t       size;      /* allocation size */
491 492 493 494 495 496 497
        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 */
498 499
        client_ptr_t     addr;      /* requested address */
        mem_size_t       size;      /* allocation size */
500
    } virtual_free;
501 502 503
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_QUERY */
504 505
        int              __pad;
        client_ptr_t     addr;      /* requested address */
506
    } virtual_query;
507 508 509 510
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_PROTECT */
        unsigned int     prot;      /* new protection flags */
511 512
        client_ptr_t     addr;      /* requested address */
        mem_size_t       size;      /* requested size */
513
    } virtual_protect;
514 515 516
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_FLUSH */
517 518
        int              __pad;
        client_ptr_t     addr;      /* requested address */
519
        mem_size_t       size;      /* requested size */
520
    } virtual_flush;
521 522 523
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_LOCK */
524 525
        int              __pad;
        client_ptr_t     addr;      /* requested address */
526
        mem_size_t       size;      /* requested size */
527 528 529 530
    } virtual_lock;
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_UNLOCK */
531 532
        int              __pad;
        client_ptr_t     addr;      /* requested address */
533
        mem_size_t       size;      /* requested size */
534
    } virtual_unlock;
535
    struct
536 537 538
    {
        enum apc_type    type;      /* APC_MAP_VIEW */
        obj_handle_t     handle;    /* mapping handle */
539
        client_ptr_t     addr;      /* requested address */
540
        mem_size_t       size;      /* allocation size */
541
        file_pos_t       offset;    /* file offset */
542
        unsigned int     alloc_type;/* allocation type */
543 544
        unsigned short   zero_bits; /* allocation alignment */
        unsigned short   prot;      /* memory protection flags */
545 546 547 548
    } map_view;
    struct
    {
        enum apc_type    type;      /* APC_UNMAP_VIEW */
549 550
        int              __pad;
        client_ptr_t     addr;      /* view address */
551 552
    } unmap_view;
    struct
553 554
    {
        enum apc_type    type;      /* APC_CREATE_THREAD */
555 556 557
        int              suspend;   /* suspended thread? */
        client_ptr_t     func;      /* void (__stdcall *func)(void*);  start function */
        client_ptr_t     arg;       /* argument for start function */
558 559
        mem_size_t       reserve;   /* reserve size for thread stack */
        mem_size_t       commit;    /* commit size for thread stack */
560
    } create_thread;
561 562
} apc_call_t;

563 564 565 566
typedef union
{
    enum apc_type type;
    struct
567 568 569
    {
        enum apc_type    type;      /* APC_ASYNC_IO */
        unsigned int     status;    /* new status of async operation */
570
        unsigned int     total;     /* bytes transferred */
571 572
    } async_io;
    struct
573 574 575
    {
        enum apc_type    type;      /* APC_VIRTUAL_ALLOC */
        unsigned int     status;    /* status returned by call */
576
        client_ptr_t     addr;      /* resulting address */
577
        mem_size_t       size;      /* resulting size */
578 579 580 581 582
    } virtual_alloc;
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_FREE */
        unsigned int     status;    /* status returned by call */
583
        client_ptr_t     addr;      /* resulting address */
584
        mem_size_t       size;      /* resulting size */
585
    } virtual_free;
586 587 588 589
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_QUERY */
        unsigned int     status;    /* status returned by call */
590 591
        client_ptr_t     base;      /* resulting base address */
        client_ptr_t     alloc_base;/* resulting allocation base */
592
        mem_size_t       size;      /* resulting region size */
593 594 595 596
        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 */
597
    } virtual_query;
598 599 600 601
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_PROTECT */
        unsigned int     status;    /* status returned by call */
602
        client_ptr_t     addr;      /* resulting address */
603
        mem_size_t       size;      /* resulting size */
604 605
        unsigned int     prot;      /* old protection flags */
    } virtual_protect;
606 607 608 609
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_FLUSH */
        unsigned int     status;    /* status returned by call */
610
        client_ptr_t     addr;      /* resulting address */
611
        mem_size_t       size;      /* resulting size */
612
    } virtual_flush;
613 614 615 616
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_LOCK */
        unsigned int     status;    /* status returned by call */
617
        client_ptr_t     addr;      /* resulting address */
618
        mem_size_t       size;      /* resulting size */
619 620 621 622 623
    } virtual_lock;
    struct
    {
        enum apc_type    type;      /* APC_VIRTUAL_UNLOCK */
        unsigned int     status;    /* status returned by call */
624
        client_ptr_t     addr;      /* resulting address */
625
        mem_size_t       size;      /* resulting size */
626
    } virtual_unlock;
627
    struct
628 629 630
    {
        enum apc_type    type;      /* APC_MAP_VIEW */
        unsigned int     status;    /* status returned by call */
631
        client_ptr_t     addr;      /* resulting address */
632
        mem_size_t       size;      /* resulting size */
633 634 635 636 637 638 639
    } map_view;
    struct
    {
        enum apc_type    type;      /* APC_MAP_VIEW */
        unsigned int     status;    /* status returned by call */
    } unmap_view;
    struct
640 641 642 643 644 645
    {
        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;
646 647
} apc_result_t;

648 649 650 651
typedef union
{
    unsigned int         major;     /* irp major function */
    struct
652 653 654 655 656 657 658 659
    {
        unsigned int     major;     /* IRP_MJ_CREATE */
        unsigned int     access;    /* access rights */
        unsigned int     sharing;   /* sharing flags */
        unsigned int     options;   /* file options */
        client_ptr_t     device;    /* opaque ptr for the device */
    } create;
    struct
660 661 662
    {
        unsigned int     major;     /* IRP_MJ_CLOSE */
        int              __pad;
663
        client_ptr_t     file;      /* opaque ptr for the file object */
664 665
    } close;
    struct
666 667 668
    {
        unsigned int     major;     /* IRP_MJ_READ */
        unsigned int     key;       /* driver key */
669
        client_ptr_t     file;      /* opaque ptr for the file object */
670 671 672 673 674 675
        file_pos_t       pos;       /* file position */
    } read;
    struct
    {
        unsigned int     major;     /* IRP_MJ_WRITE */
        unsigned int     key;       /* driver key */
676
        client_ptr_t     file;      /* opaque ptr for the file object */
677 678 679
        file_pos_t       pos;       /* file position */
    } write;
    struct
680 681 682
    {
        unsigned int     major;     /* IRP_MJ_FLUSH_BUFFERS */
        int              __pad;
683
        client_ptr_t     file;      /* opaque ptr for the file object */
684 685
    } flush;
    struct
686 687 688
    {
        unsigned int     major;     /* IRP_MJ_DEVICE_CONTROL */
        ioctl_code_t     code;      /* ioctl code */
689
        client_ptr_t     file;      /* opaque ptr for the file object */
690 691 692
    } ioctl;
} irp_params_t;

693 694 695 696 697
/* information about a PE image mapping, roughly equivalent to SECTION_IMAGE_INFORMATION */
typedef struct
{
    client_ptr_t   base;
    client_ptr_t   entry_point;
698
    mem_size_t     map_size;
699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
    mem_size_t     stack_size;
    mem_size_t     stack_commit;
    unsigned int   zerobits;
    unsigned int   subsystem;
    unsigned short subsystem_low;
    unsigned short subsystem_high;
    unsigned int   gp;
    unsigned short image_charact;
    unsigned short dll_charact;
    unsigned short machine;
    unsigned char  contains_code;
    unsigned char  image_flags;
    unsigned int   loader_flags;
    unsigned int   header_size;
    unsigned int   file_size;
    unsigned int   checksum;
} pe_image_info_t;

717 718 719 720 721 722 723 724
struct rawinput_device
{
    unsigned short usage_page;
    unsigned short usage;
    unsigned int   flags;
    user_handle_t  target;
};

725 726 727 728 729
/****************************************************************/
/* Request declarations */

/* Create a new process from the context of the parent */
@REQ(new_process)
730 731 732 733 734 735 736 737
    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 */
    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 */
738
    cpu_type_t   cpu;            /* CPU that the new process will use */
739 740
    data_size_t  info_size;      /* size of startup info */
    VARARG(info,startup_info,info_size); /* startup information */
741
    VARARG(env,unicode_str);     /* environment for new process */
742
@REPLY
743 744 745 746 747
    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) */
748 749 750 751 752
@END


/* Retrieve information about a newly started process */
@REQ(get_new_process_info)
753
    obj_handle_t info;           /* info handle returned from new_process_request */
754
@REPLY
755
    int          success;      /* did the process start successfully? */
756
    int          exit_code;    /* process exit code if failed */
757 758 759 760 761
@END


/* Create a new thread from the context of the parent */
@REQ(new_thread)
762 763
    unsigned int access;       /* wanted access rights */
    unsigned int attributes;   /* object attributes */
764 765 766
    int          suspend;      /* new thread should be suspended on creation */
    int          request_fd;   /* fd for request pipe */
@REPLY
767
    thread_id_t  tid;          /* thread id */
768
    obj_handle_t handle;       /* thread handle (in the current process) */
769 770 771
@END


772 773 774
/* Retrieve the new process startup info */
@REQ(get_startup_info)
@REPLY
775
    obj_handle_t exe_file;     /* file handle for main exe */
776 777
    data_size_t  info_size;    /* size of startup info */
    VARARG(info,startup_info,info_size); /* startup information */
778
    VARARG(env,unicode_str);   /* environment */
779 780 781 782 783
@END


/* Signal the end of the process initialization */
@REQ(init_process_done)
784
    int          gui;          /* is it a GUI process? */
785
    mod_handle_t module;       /* main module base address */
786
    client_ptr_t ldt_copy;     /* address of LDT copy (in thread address space) */
787
    client_ptr_t entry;        /* process entry point */
788 789
@REPLY
    int          suspend;      /* is process suspended? */
790 791 792 793 794 795
@END


/* Initialize a thread; called from the child after fork()/clone() */
@REQ(init_thread)
    int          unix_pid;     /* Unix pid of new thread */
796
    int          unix_tid;     /* Unix tid of new thread */
797
    int          debug_level;  /* new debug level */
798
    client_ptr_t teb;          /* TEB of new thread (in thread address space) */
799
    client_ptr_t entry;        /* entry point or PEB if initial thread (in thread address space) */
800 801
    int          reply_fd;     /* fd for reply pipe */
    int          wait_fd;      /* fd for blocking calls pipe */
802
    cpu_type_t   cpu;          /* CPU that this thread is running on */
803
@REPLY
804 805
    process_id_t pid;          /* process id of the new thread's process */
    thread_id_t  tid;          /* thread id of the new thread */
806
    timeout_t    server_start; /* server start time */
807
    data_size_t  info_size;    /* total size of startup info */
808
    int          version;      /* protocol version */
809
    unsigned int all_cpus;     /* bitset of supported CPUs */
810
    int          suspend;      /* is thread suspended? */
811 812 813 814 815
@END


/* Terminate a process */
@REQ(terminate_process)
816
    obj_handle_t handle;       /* process handle to terminate */
817 818 819 820 821 822 823 824
    int          exit_code;    /* process exit code */
@REPLY
    int          self;         /* suicide? */
@END


/* Terminate a thread */
@REQ(terminate_thread)
825
    obj_handle_t handle;       /* thread handle to terminate */
826 827 828 829 830 831 832 833 834
    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)
835
    obj_handle_t handle;           /* process handle */
836
@REPLY
837
    process_id_t pid;              /* server process id */
838
    process_id_t ppid;             /* server process id of parent */
839
    affinity_t   affinity;         /* process affinity mask */
840
    client_ptr_t peb;              /* PEB address in process address space */
841 842
    timeout_t    start_time;       /* process start time */
    timeout_t    end_time;         /* process end time */
843
    int          exit_code;        /* process exit code */
844
    int          priority;         /* priority class */
845
    cpu_type_t   cpu;              /* CPU that this process is running on */
846 847
    short int    debugger_present; /* process is being debugged */
    short int    debug_children;   /* inherit debugger to child processes */
848 849 850
@END


851 852 853 854 855 856 857 858
/* Retrieve information about a process memory usage */
@REQ(get_process_vm_counters)
    obj_handle_t handle;                        /* process handle */
@REPLY
    mem_size_t peak_virtual_size;               /* peak virtual memory in bytes */
    mem_size_t virtual_size;                    /* virtual memory in bytes */
    mem_size_t peak_working_set_size;           /* peak real memory in bytes */
    mem_size_t working_set_size;                /* real memory in bytes */
859 860
    mem_size_t pagefile_usage;                  /* commit charge in bytes */
    mem_size_t peak_pagefile_usage;             /* peak commit charge in bytes */
861 862 863
@END


864
/* Set a process information */
865
@REQ(set_process_info)
866
    obj_handle_t handle;       /* process handle */
867 868
    int          mask;         /* setting mask (see below) */
    int          priority;     /* priority class */
869
    affinity_t   affinity;     /* affinity mask */
870 871 872 873 874 875 876
@END
#define SET_PROCESS_INFO_PRIORITY 0x01
#define SET_PROCESS_INFO_AFFINITY 0x02


/* Retrieve information about a thread */
@REQ(get_thread_info)
877 878
    obj_handle_t handle;        /* thread handle */
    thread_id_t  tid_in;        /* thread id (optional) */
879
@REPLY
880
    process_id_t pid;           /* server process id */
881
    thread_id_t  tid;           /* server thread id */
882
    client_ptr_t teb;           /* thread teb pointer */
883
    client_ptr_t entry_point;   /* thread entry point */
884
    affinity_t   affinity;      /* thread affinity mask */
885
    int          exit_code;     /* thread exit code */
886
    int          priority;      /* thread priority level */
887
    int          last;          /* last thread in process */
888 889 890
@END


891 892 893 894 895 896 897 898 899
/* Retrieve information about thread times */
@REQ(get_thread_times)
    obj_handle_t handle;        /* thread handle */
@REPLY
    timeout_t    creation_time; /* thread creation time */
    timeout_t    exit_time;     /* thread exit time */
@END


900
/* Set a thread information */
901
@REQ(set_thread_info)
902
    obj_handle_t handle;       /* thread handle */
903 904
    int          mask;         /* setting mask (see below) */
    int          priority;     /* priority class */
905
    affinity_t   affinity;     /* affinity mask */
906
    client_ptr_t entry_point;  /* thread entry point */
907
    obj_handle_t token;        /* impersonation token */
908
@END
909 910 911 912
#define SET_THREAD_INFO_PRIORITY   0x01
#define SET_THREAD_INFO_AFFINITY   0x02
#define SET_THREAD_INFO_TOKEN      0x04
#define SET_THREAD_INFO_ENTRYPOINT 0x08
913 914


915 916 917
/* Retrieve information about a module */
@REQ(get_dll_info)
    obj_handle_t handle;       /* process handle */
918
    mod_handle_t base_address; /* base address of module */
919
@REPLY
920
    client_ptr_t entry_point;
921
    data_size_t  filename_len;    /* buffer len in bytes required to store filename */
922
    VARARG(filename,unicode_str); /* file name of module */
923 924 925
@END


926 927
/* Suspend a thread */
@REQ(suspend_thread)
928
    obj_handle_t handle;       /* thread handle */
929 930 931 932 933 934 935
@REPLY
    int          count;        /* new suspend count */
@END


/* Resume a thread */
@REQ(resume_thread)
936
    obj_handle_t handle;       /* thread handle */
937 938 939 940 941 942 943
@REPLY
    int          count;        /* new suspend count */
@END


/* Notify the server that a dll has been loaded */
@REQ(load_dll)
944
    data_size_t  dbg_offset;   /* debug info offset */
945
    mod_handle_t base;         /* base address */
946
    client_ptr_t name;         /* ptr to ptr to name (in process addr space) */
947
    data_size_t  dbg_size;     /* debug info size */
948
    VARARG(filename,unicode_str); /* file name of dll */
949 950 951 952 953
@END


/* Notify the server that a dll is being unloaded */
@REQ(unload_dll)
954
    mod_handle_t base;         /* base address */
955 956 957
@END


958
/* Queue an APC for a thread or process */
959
@REQ(queue_apc)
960
    obj_handle_t handle;       /* thread or process handle */
961
    apc_call_t   call;         /* call arguments */
962 963
@REPLY
    obj_handle_t handle;       /* APC handle */
964
    int          self;         /* run APC in caller itself? */
965 966 967
@END


968 969 970 971 972 973 974 975
/* 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


976 977
/* Close a handle for the current process */
@REQ(close_handle)
978
    obj_handle_t handle;       /* handle to close */
979 980 981 982 983
@END


/* Set a handle information */
@REQ(set_handle_info)
984
    obj_handle_t handle;       /* handle we are interested in */
985 986 987 988
    int          flags;        /* new handle flags */
    int          mask;         /* mask for flags to set */
@REPLY
    int          old_flags;    /* old flag value */
989 990 991
@END


992 993
/* Duplicate a handle */
@REQ(dup_handle)
994 995 996
    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 */
997
    unsigned int access;       /* wanted access rights */
998 999
    unsigned int attributes;   /* object attributes */
    unsigned int options;      /* duplicate options (see below) */
1000
@REPLY
1001
    obj_handle_t handle;       /* duplicated handle in dst process */
1002
    int          self;         /* is the source the current process? */
1003
    int          closed;       /* whether the source handle has been closed */
1004 1005 1006 1007 1008 1009 1010 1011
@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)
1012
    process_id_t pid;          /* process id to open */
1013
    unsigned int access;       /* wanted access rights */
1014
    unsigned int attributes;   /* object attributes */
1015
@REPLY
1016
    obj_handle_t handle;       /* handle to the process */
1017 1018 1019
@END


1020 1021
/* Open a handle to a thread */
@REQ(open_thread)
1022
    thread_id_t  tid;          /* thread id to open */
1023
    unsigned int access;       /* wanted access rights */
1024
    unsigned int attributes;   /* object attributes */
1025
@REPLY
1026
    obj_handle_t handle;       /* handle to the thread */
1027 1028 1029
@END


1030 1031 1032
/* Wait for handles */
@REQ(select)
    int          flags;        /* wait flags (see below) */
1033
    client_ptr_t cookie;       /* magic cookie to return to client */
1034
    timeout_t    timeout;      /* timeout */
1035
    obj_handle_t prev_apc;     /* handle to previous APC */
1036
    VARARG(result,apc_result); /* result of previous APC */
1037
    VARARG(data,select_op);    /* operation-specific data */
1038 1039
@REPLY
    timeout_t    timeout;      /* timeout converted to absolute */
1040
    apc_call_t   call;         /* APC call arguments */
1041
    obj_handle_t apc_handle;   /* handle to next APC */
1042
@END
1043 1044
#define SELECT_ALERTABLE     1
#define SELECT_INTERRUPTIBLE 2
1045 1046 1047 1048


/* Create an event */
@REQ(create_event)
1049
    unsigned int access;        /* wanted access rights */
1050 1051
    int          manual_reset;  /* manual reset event */
    int          initial_state; /* initial state of the event */
1052
    VARARG(objattr,object_attributes); /* object attributes */
1053
@REPLY
1054
    obj_handle_t handle;        /* handle to the event */
1055 1056 1057 1058
@END

/* Event operation */
@REQ(event_op)
1059
    obj_handle_t  handle;       /* handle to event */
1060 1061 1062 1063
    int           op;           /* event operation (see below) */
@END
enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT };

1064 1065 1066 1067 1068 1069
@REQ(query_event)
    obj_handle_t  handle;       /* handle to event */
@REPLY
    int          manual_reset;  /* manual reset event */
    int          state;         /* current state of the event */
@END
1070 1071 1072 1073

/* Open an event */
@REQ(open_event)
    unsigned int access;        /* wanted access rights */
1074
    unsigned int attributes;    /* object attributes */
1075
    obj_handle_t rootdir;       /* root directory */
1076 1077
    VARARG(name,unicode_str);   /* object name */
@REPLY
1078
    obj_handle_t handle;        /* handle to the event */
1079 1080 1081
@END


1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
/* Create a keyed event */
@REQ(create_keyed_event)
    unsigned int access;        /* wanted access rights */
    VARARG(objattr,object_attributes); /* object attributes */
@REPLY
    obj_handle_t handle;        /* handle to the event */
@END

/* Open a keyed event */
@REQ(open_keyed_event)
    unsigned int access;        /* wanted access rights */
    unsigned int attributes;    /* object attributes */
    obj_handle_t rootdir;       /* root directory */
    VARARG(name,unicode_str);   /* object name */
@REPLY
    obj_handle_t handle;        /* handle to the event */
@END


1101 1102
/* Create a mutex */
@REQ(create_mutex)
1103
    unsigned int access;        /* wanted access rights */
1104
    int          owned;         /* initially owned? */
1105
    VARARG(objattr,object_attributes); /* object attributes */
1106
@REPLY
1107
    obj_handle_t handle;        /* handle to the mutex */
1108 1109 1110 1111 1112
@END


/* Release a mutex */
@REQ(release_mutex)
1113
    obj_handle_t handle;        /* handle to the mutex */
1114 1115
@REPLY
    unsigned int prev_count;    /* value of internal counter, before release */
1116 1117 1118 1119 1120 1121
@END


/* Open a mutex */
@REQ(open_mutex)
    unsigned int access;        /* wanted access rights */
1122
    unsigned int attributes;    /* object attributes */
1123
    obj_handle_t rootdir;       /* root directory */
1124 1125
    VARARG(name,unicode_str);   /* object name */
@REPLY
1126
    obj_handle_t handle;        /* handle to the mutex */
1127 1128 1129
@END


1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
/* Query a mutex */
@REQ(query_mutex)
    obj_handle_t  handle;       /* handle to mutex */
@REPLY
    unsigned int count;         /* current count of mutex */
    int          owned;         /* true if owned by current thread */
    int          abandoned;     /* true if abandoned */
@END


1140 1141
/* Create a semaphore */
@REQ(create_semaphore)
1142
    unsigned int access;        /* wanted access rights */
1143 1144
    unsigned int initial;       /* initial count */
    unsigned int max;           /* maximum count */
1145
    VARARG(objattr,object_attributes); /* object attributes */
1146
@REPLY
1147
    obj_handle_t handle;        /* handle to the semaphore */
1148 1149 1150 1151 1152
@END


/* Release a semaphore */
@REQ(release_semaphore)
1153
    obj_handle_t handle;        /* handle to the semaphore */
1154 1155 1156 1157 1158
    unsigned int count;         /* count to add to semaphore */
@REPLY
    unsigned int prev_count;    /* previous semaphore count */
@END

1159 1160 1161 1162 1163 1164
@REQ(query_semaphore)
    obj_handle_t handle;       /* handle to the semaphore */
@REPLY
    unsigned int current;      /* current count */
    unsigned int max;          /* maximum count */
@END
1165 1166 1167 1168

/* Open a semaphore */
@REQ(open_semaphore)
    unsigned int access;        /* wanted access rights */
1169
    unsigned int attributes;    /* object attributes */
1170
    obj_handle_t rootdir;       /* root directory */
1171 1172
    VARARG(name,unicode_str);   /* object name */
@REPLY
1173
    obj_handle_t handle;        /* handle to the semaphore */
1174 1175 1176 1177 1178 1179 1180 1181
@END


/* Create a file */
@REQ(create_file)
    unsigned int access;        /* wanted access rights */
    unsigned int sharing;       /* sharing flags */
    int          create;        /* file create action */
1182
    unsigned int options;       /* file options */
1183
    unsigned int attrs;         /* file attributes for creation */
1184
    VARARG(objattr,object_attributes); /* object attributes */
1185 1186
    VARARG(filename,string);    /* file name */
@REPLY
1187
    obj_handle_t handle;        /* handle to the file */
1188 1189 1190
@END


1191 1192 1193 1194 1195 1196
/* 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 */
1197
    unsigned int options;       /* file options */
1198 1199 1200 1201 1202 1203
    VARARG(filename,unicode_str); /* file name */
@REPLY
    obj_handle_t handle;        /* handle to the file */
@END


1204 1205 1206
/* Allocate a file handle for a Unix fd */
@REQ(alloc_file_handle)
    unsigned int access;        /* wanted access rights */
1207
    unsigned int attributes;    /* object attributes */
1208 1209
    int          fd;            /* file descriptor on the client side */
@REPLY
1210
    obj_handle_t handle;        /* handle to the file */
1211 1212 1213
@END


1214 1215 1216 1217 1218 1219 1220 1221 1222
/* Get the Unix name from a file handle */
@REQ(get_handle_unix_name)
    obj_handle_t   handle;      /* file handle */
@REPLY
    data_size_t    name_len;    /* unix name length */
    VARARG(name,string);        /* unix name */
@END


1223 1224
/* Get a Unix fd to access a file */
@REQ(get_handle_fd)
1225
    obj_handle_t handle;        /* handle to the file */
1226
@REPLY
1227
    int          type;          /* file type (see below) */
1228
    int          cacheable;     /* can fd be cached in the client? */
1229 1230
    unsigned int access;        /* file access rights */
    unsigned int options;       /* file open options */
1231
@END
1232 1233 1234 1235 1236 1237 1238 1239 1240
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 */
1241
    FD_TYPE_CHAR,     /* unspecified char device */
1242 1243 1244
    FD_TYPE_DEVICE,   /* Windows device file */
    FD_TYPE_NB_TYPES
};
1245

1246

1247 1248 1249 1250 1251 1252 1253 1254 1255
/* Retrieve (or allocate) the client-side directory cache entry */
@REQ(get_directory_cache_entry)
    obj_handle_t handle;        /* handle to the directory */
@REPLY
    int          entry;         /* cache entry on the client side */
    VARARG(free,ints);          /* entries that can be freed */
@END


1256
/* Flush a file buffers */
1257 1258
@REQ(flush)
    async_data_t   async;       /* async I/O parameters */
1259 1260
@REPLY
    obj_handle_t event;         /* event set when finished */
1261 1262
@END

1263 1264 1265 1266 1267 1268 1269
/* Queries volume information */
@REQ(get_volume_info)
    obj_handle_t handle;        /* handle to the file */
    unsigned int info_class;    /* queried information class */
@REPLY
    VARARG(data,bytes);         /* volume info data */
@END
1270 1271 1272

/* Lock a region of a file */
@REQ(lock_file)
1273
    obj_handle_t handle;        /* handle to the file */
1274 1275
    file_pos_t   offset;        /* offset of start of lock */
    file_pos_t   count;         /* count of bytes to lock */
1276 1277 1278 1279 1280
    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? */
1281 1282 1283 1284 1285
@END


/* Unlock a region of a file */
@REQ(unlock_file)
1286
    obj_handle_t handle;        /* handle to the file */
1287 1288
    file_pos_t   offset;        /* offset of start of unlock */
    file_pos_t   count;         /* count of bytes to unlock */
1289 1290 1291 1292 1293 1294
@END


/* Create a socket */
@REQ(create_socket)
    unsigned int access;        /* wanted access rights */
1295
    unsigned int attributes;    /* object attributes */
1296 1297 1298
    int          family;        /* family, see socket manpage */
    int          type;          /* type, see socket manpage */
    int          protocol;      /* protocol, see socket manpage */
1299
    unsigned int flags;         /* socket flags */
1300
@REPLY
1301
    obj_handle_t handle;        /* handle to the new socket */
1302 1303 1304 1305 1306
@END


/* Accept a socket */
@REQ(accept_socket)
1307
    obj_handle_t lhandle;       /* handle to the listening socket */
1308
    unsigned int access;        /* wanted access rights */
1309
    unsigned int attributes;    /* object attributes */
1310
@REPLY
1311
    obj_handle_t handle;        /* handle to the new socket */
1312 1313 1314
@END


1315 1316 1317 1318 1319 1320 1321
/* Accept into an initialized socket */
@REQ(accept_into_socket)
    obj_handle_t lhandle;       /* handle to the listening socket */
    obj_handle_t ahandle;       /* handle to the accepting socket */
@END


1322 1323
/* Set socket event parameters */
@REQ(set_socket_event)
1324
    obj_handle_t  handle;        /* handle to the socket */
1325
    unsigned int  mask;          /* event mask */
1326
    obj_handle_t  event;         /* event object */
1327 1328
    user_handle_t window;        /* window to send the message to */
    unsigned int  msg;           /* message to send */
1329 1330 1331 1332 1333
@END


/* Get socket event parameters */
@REQ(get_socket_event)
1334
    obj_handle_t handle;        /* handle to the socket */
1335
    int          service;       /* clear pending? */
1336
    obj_handle_t c_event;       /* event to clear */
1337 1338 1339 1340 1341 1342 1343 1344
@REPLY
    unsigned int mask;          /* event mask */
    unsigned int pmask;         /* pending events */
    unsigned int state;         /* status bits */
    VARARG(errors,ints);        /* event errors */
@END


1345 1346 1347 1348 1349 1350 1351 1352 1353 1354
/* Get socket info */
@REQ(get_socket_info)
    obj_handle_t handle;        /* handle to the socket */
@REPLY
    int family;                 /* family, see socket manpage */
    int type;                   /* type, see socket manpage */
    int protocol;               /* protocol, see socket manpage */
@END


1355
/* Re-enable pending socket events */
1356
@REQ(enable_socket_event)
1357
    obj_handle_t handle;        /* handle to the socket */
1358 1359 1360 1361 1362
    unsigned int mask;          /* events to re-enable */
    unsigned int sstate;        /* status bits to set */
    unsigned int cstate;        /* status bits to clear */
@END

1363
@REQ(set_socket_deferred)
1364 1365
    obj_handle_t handle;        /* handle to the socket */
    obj_handle_t deferred;      /* handle to the socket for which accept() is deferred */
1366
@END
1367

1368
/* Allocate a console (only used by a console renderer) */
1369 1370
@REQ(alloc_console)
    unsigned int access;        /* wanted access rights */
1371
    unsigned int attributes;    /* object attributes */
1372
    process_id_t pid;           /* pid of process which shall be attached to the console */
1373
    int          input_fd;      /* if pid=-1 (bare console to current process), fd for input */
1374
@REPLY
1375 1376
    obj_handle_t handle_in;     /* handle to console input */
    obj_handle_t event;         /* handle to renderer events change notification */
1377 1378 1379 1380 1381 1382 1383 1384
@END


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


1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430
#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)
1431
    obj_handle_t handle;        /* handle to console input events */
1432 1433 1434 1435 1436
@REPLY
    VARARG(data,bytes);         /* the various console_renderer_events */
@END


1437 1438
/* Open a handle to the process console */
@REQ(open_console)
1439
    obj_handle_t from;          /* 0 (resp 1) input (resp output) of current process console */
1440
                                /* otherwise console_in handle to get active screen buffer? */
1441
    unsigned int access;        /* wanted access rights */
1442
    unsigned int attributes;    /* object attributes */
1443
    int          share;         /* share mask (only for output handles) */
1444
@REPLY
1445
    obj_handle_t handle;        /* handle to the console */
1446 1447 1448
@END


1449 1450 1451 1452 1453 1454
/* Get the input queue wait event */
@REQ(get_console_wait_event)
@REPLY
    obj_handle_t handle;
@END

1455 1456
/* Get a console mode (input or output) */
@REQ(get_console_mode)
1457
    obj_handle_t handle;        /* handle to the console */
1458 1459 1460 1461 1462 1463 1464
@REPLY
    int          mode;          /* console mode */
@END


/* Set a console mode (input or output) */
@REQ(set_console_mode)
1465
    obj_handle_t handle;        /* handle to the console */
1466 1467 1468 1469
    int          mode;          /* console mode */
@END


1470 1471
/* Set info about a console (input only) */
@REQ(set_console_input_info)
1472 1473 1474 1475 1476 1477 1478 1479 1480 1481
    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 */
1482 1483 1484 1485 1486
@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
1487
#define SET_CONSOLE_INPUT_INFO_EDITION_MODE     0x10
1488 1489
#define SET_CONSOLE_INPUT_INFO_INPUT_CODEPAGE   0x20
#define SET_CONSOLE_INPUT_INFO_OUTPUT_CODEPAGE  0x40
1490
#define SET_CONSOLE_INPUT_INFO_WIN              0x80
1491 1492 1493 1494


/* Get info about a console (input only) */
@REQ(get_console_input_info)
1495
    obj_handle_t  handle;         /* handle to console input, or 0 for process' console */
1496
@REPLY
1497 1498 1499 1500 1501 1502 1503 1504
    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 */
1505 1506 1507 1508 1509
@END


/* appends a string to console's history */
@REQ(append_console_input_history)
1510
    obj_handle_t handle;        /* handle to console input, or 0 for process' console */
1511 1512 1513 1514 1515 1516
    VARARG(line,unicode_str);   /* line to add */
@END


/* appends a string to console's history */
@REQ(get_console_input_history)
1517
    obj_handle_t handle;        /* handle to console input, or 0 for process' console */
1518 1519
    int          index;         /* index to get line from */
@REPLY
1520
    int          total;         /* total length of line in Unicode chars */
1521 1522 1523 1524 1525 1526
    VARARG(line,unicode_str);   /* line to add */
@END


/* creates a new screen buffer on process' console */
@REQ(create_console_output)
1527
    obj_handle_t handle_in;     /* handle to console input, or 0 for process' console */
1528 1529 1530
    unsigned int access;        /* wanted access rights */
    unsigned int attributes;    /* object attributes */
    unsigned int share;         /* sharing credentials */
1531
    int          fd;            /* for bare consoles, fd the screen-buffer is attached to */
1532
@REPLY
1533
    obj_handle_t handle_out;    /* handle to the screen buffer */
1534 1535 1536
@END


1537
/* Set info about a console (output only) */
1538
@REQ(set_console_output_info)
1539
    obj_handle_t handle;        /* handle to the console */
1540
    int          mask;          /* setting mask (see below) */
1541 1542 1543 1544 1545 1546
    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 */
1547 1548
    short int    attr;          /* default fill attributes (screen colors) */
    short int    popup_attr;    /* pop-up color attributes */
1549
    short int    win_left;      /* window actually displayed by renderer */
1550
    short int    win_top;       /* the rect area is expressed within the */
1551 1552 1553 1554
    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;
1555 1556
    short int    font_width;    /* font size (width x height) */
    short int    font_height;
1557
    VARARG(colors,uints);       /* color table */
1558
@END
1559 1560 1561 1562 1563 1564 1565 1566 1567
#define SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM     0x0001
#define SET_CONSOLE_OUTPUT_INFO_CURSOR_POS      0x0002
#define SET_CONSOLE_OUTPUT_INFO_SIZE            0x0004
#define SET_CONSOLE_OUTPUT_INFO_ATTR            0x0008
#define SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW  0x0010
#define SET_CONSOLE_OUTPUT_INFO_MAX_SIZE        0x0020
#define SET_CONSOLE_OUTPUT_INFO_FONT            0x0040
#define SET_CONSOLE_OUTPUT_INFO_COLORTABLE      0x0080
#define SET_CONSOLE_OUTPUT_INFO_POPUP_ATTR      0x0100
1568

1569 1570

/* Get info about a console (output only) */
1571
@REQ(get_console_output_info)
1572
    obj_handle_t handle;        /* handle to the console */
1573
@REPLY
1574 1575 1576 1577 1578 1579
    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 */
1580 1581
    short int    attr;          /* default fill attributes (screen colors) */
    short int    popup_attr;    /* pop-up color attributes */
1582
    short int    win_left;      /* window actually displayed by renderer */
1583
    short int    win_top;       /* the rect area is expressed within the */
1584 1585 1586 1587
    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;
1588 1589
    short int    font_width;    /* font size (width x height) */
    short int    font_height;
1590
    VARARG(colors,uints);       /* color table */
1591 1592 1593 1594
@END

/* Add input records to a console input queue */
@REQ(write_console_input)
1595
    obj_handle_t handle;        /* handle to the console input */
1596 1597 1598 1599 1600
    VARARG(rec,input_records);  /* input records */
@REPLY
    int          written;       /* number of records written */
@END

1601

1602 1603
/* Fetch input records from a console input queue */
@REQ(read_console_input)
1604
    obj_handle_t handle;        /* handle to the console input */
1605 1606 1607 1608 1609 1610 1611
    int          flush;         /* flush the retrieved records from the queue? */
@REPLY
    int          read;          /* number of records read */
    VARARG(rec,input_records);  /* input records */
@END


1612 1613
/* write data (chars and/or attributes) in a screen buffer */
@REQ(write_console_output)
1614
    obj_handle_t handle;        /* handle to the console output */
1615 1616 1617 1618
    int          x;             /* position where to start writing */
    int          y;
    int          mode;          /* char info (see below) */
    int          wrap;          /* wrap around at end of line? */
1619 1620
    VARARG(data,bytes);         /* info to write */
@REPLY
1621 1622 1623
    int          written;       /* number of char infos actually written */
    int          width;         /* width of screen buffer */
    int          height;        /* height of screen buffer */
1624
@END
1625 1626 1627 1628 1629 1630 1631
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 */
};
1632 1633


1634 1635
/* fill a screen buffer with constant data (chars and/or attributes) */
@REQ(fill_console_output)
1636
    obj_handle_t handle;        /* handle to the console output */
1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648
    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 */
1649
@REQ(read_console_output)
1650
    obj_handle_t handle;        /* handle to the console output */
1651 1652 1653 1654
    int          x;             /* position (x,y) where to start reading */
    int          y;
    int          mode;          /* char info mode */
    int          wrap;          /* wrap around at end of line? */
1655
@REPLY
1656 1657
    int          width;         /* width of screen buffer */
    int          height;        /* height of screen buffer */
1658 1659 1660
    VARARG(data,bytes);
@END

1661

1662 1663
/* move a rect (of data) in screen buffer content */
@REQ(move_console_output)
1664
    obj_handle_t handle;        /* handle to the console output */
1665 1666 1667 1668 1669 1670 1671 1672 1673
    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


1674 1675 1676
/* Sends a signal to a process group */
@REQ(send_console_signal)
    int          signal;        /* the signal to send */
1677
    process_id_t group_id;      /* the group to send the signal to */
1678 1679 1680
@END


1681 1682
/* enable directory change notifications */
@REQ(read_directory_changes)
1683
    unsigned int filter;        /* notification filter */
1684
    int          subtree;       /* watch the subtree? */
1685
    int          want_data;     /* flag indicating whether change data should be collected */
1686
    async_data_t async;         /* async I/O parameters */
1687 1688 1689 1690 1691 1692
@END


@REQ(read_change)
    obj_handle_t handle;
@REPLY
1693
    VARARG(events,filesystem_event);  /* collected filesystem events */
1694 1695 1696 1697 1698
@END


/* Create a file mapping */
@REQ(create_mapping)
1699
    unsigned int access;        /* wanted access rights */
1700
    unsigned int flags;         /* SEC_* flags */
1701
    unsigned int file_access;   /* file access rights */
1702
    mem_size_t   size;          /* mapping size */
1703
    obj_handle_t file_handle;   /* file handle */
1704
    VARARG(objattr,object_attributes); /* object attributes */
1705
@REPLY
1706
    obj_handle_t handle;        /* handle to the mapping */
1707 1708 1709 1710 1711 1712
@END


/* Open a mapping */
@REQ(open_mapping)
    unsigned int access;        /* wanted access rights */
1713
    unsigned int attributes;    /* object attributes */
1714
    obj_handle_t rootdir;       /* root directory */
1715 1716
    VARARG(name,unicode_str);   /* object name */
@REPLY
1717
    obj_handle_t handle;        /* handle to the mapping */
1718 1719 1720 1721 1722
@END


/* Get information about a file mapping */
@REQ(get_mapping_info)
1723
    obj_handle_t handle;        /* handle to the mapping */
1724
    unsigned int access;        /* wanted access rights */
1725
@REPLY
1726
    mem_size_t   size;          /* mapping size */
1727
    unsigned int flags;         /* SEC_* flags */
1728
    obj_handle_t shared_file;   /* shared mapping file handle */
1729
    VARARG(image,pe_image_info);/* image info for SEC_IMAGE mappings */
1730 1731 1732
@END


1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748
/* Add a memory view in the current process */
@REQ(map_view)
    obj_handle_t mapping;       /* file mapping handle */
    unsigned int access;        /* wanted access rights */
    client_ptr_t base;          /* view base address (page-aligned) */
    mem_size_t   size;          /* view size */
    file_pos_t   start;         /* start offset in mapping */
@END


/* Unmap a memory view from the current process */
@REQ(unmap_view)
    client_ptr_t base;          /* view base address */
@END


1749 1750
/* Get a range of committed pages in a file mapping */
@REQ(get_mapping_committed_range)
1751
    client_ptr_t base;          /* view base address */
1752 1753
    file_pos_t   offset;        /* starting offset (page-aligned, in bytes) */
@REPLY
1754
    mem_size_t   size;          /* size of range starting at offset (page-aligned, in bytes) */
1755 1756 1757 1758 1759 1760
    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)
1761
    client_ptr_t base;          /* view base address */
1762
    file_pos_t   offset;        /* starting offset (page-aligned, in bytes) */
1763
    mem_size_t   size;          /* size to set (page-aligned, in bytes) or 0 if only retrieving */
1764 1765 1766
@END


1767 1768 1769 1770 1771 1772 1773
/* Check if two memory maps are for the same file */
@REQ(is_same_mapping)
    client_ptr_t base1;         /* first view base address */
    client_ptr_t base2;         /* second view base address */
@END


1774 1775
#define SNAP_PROCESS    0x00000001
#define SNAP_THREAD     0x00000002
1776 1777
/* Create a snapshot */
@REQ(create_snapshot)
1778
    unsigned int attributes;    /* object attributes */
1779
    unsigned int flags;         /* snapshot flags (SNAP_*) */
1780
@REPLY
1781
    obj_handle_t handle;        /* handle to the snapshot */
1782 1783 1784 1785 1786
@END


/* Get the next process from a snapshot */
@REQ(next_process)
1787
    obj_handle_t handle;        /* handle to the snapshot */
1788 1789 1790
    int          reset;         /* reset snapshot position? */
@REPLY
    int          count;         /* process usage count */
1791 1792
    process_id_t pid;           /* process id */
    process_id_t ppid;          /* parent process id */
1793 1794
    int          threads;       /* number of threads */
    int          priority;      /* process priority */
1795
    int          handles;       /* number of handles */
1796
    int          unix_pid;      /* Unix pid */
1797
    VARARG(filename,unicode_str); /* file name of main exe */
1798 1799 1800 1801 1802
@END


/* Get the next thread from a snapshot */
@REQ(next_thread)
1803
    obj_handle_t handle;        /* handle to the snapshot */
1804 1805 1806
    int          reset;         /* reset snapshot position? */
@REPLY
    int          count;         /* thread usage count */
1807 1808
    process_id_t pid;           /* process id */
    thread_id_t  tid;           /* thread id */
1809 1810 1811 1812 1813 1814 1815 1816 1817
    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
1818 1819
    process_id_t  pid;         /* process id */
    thread_id_t   tid;         /* thread id */
1820
    obj_handle_t  wait;        /* wait handle if no event ready */
1821 1822 1823 1824 1825 1826
    VARARG(event,debug_event); /* debug event data */
@END


/* Queue an exception event */
@REQ(queue_exception_event)
1827 1828 1829 1830 1831 1832 1833 1834
    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 */
1835
@REPLY
1836
    obj_handle_t     handle;   /* handle to the queued event */
1837 1838 1839 1840 1841
@END


/* Retrieve the status of an exception event */
@REQ(get_exception_status)
1842
    obj_handle_t     handle;   /* handle to the queued event */
1843
@REPLY
1844 1845 1846 1847 1848 1849
    VARARG(context,context);   /* modified thread context */
@END


/* Continue a debug event */
@REQ(continue_debug_event)
1850 1851
    process_id_t pid;          /* process id to continue */
    thread_id_t  tid;          /* thread id to continue */
1852 1853 1854 1855
    int          status;       /* continuation status */
@END


1856
/* Start/stop debugging an existing process */
1857
@REQ(debug_process)
1858
    process_id_t pid;          /* id of the process to debug */
1859 1860 1861 1862
    int          attach;       /* 1=attaching / 0=detaching from the process */
@END


1863 1864
/* Simulate a breakpoint in a process */
@REQ(debug_break)
1865
    obj_handle_t handle;       /* process handle */
1866 1867 1868 1869 1870
@REPLY
    int          self;         /* was it the caller itself? */
@END


1871 1872 1873
/* Set debugger kill on exit flag */
@REQ(set_debugger_kill_on_exit)
    int          kill_on_exit;  /* 0=detach/1=kill debuggee when debugger dies */
1874 1875 1876 1877 1878
@END


/* Read data from a process address space */
@REQ(read_process_memory)
1879
    obj_handle_t handle;       /* process handle */
1880
    client_ptr_t addr;         /* addr to read from */
1881 1882 1883 1884 1885 1886 1887
@REPLY
    VARARG(data,bytes);        /* result data */
@END


/* Write data to a process address space */
@REQ(write_process_memory)
1888
    obj_handle_t handle;       /* process handle */
1889
    client_ptr_t addr;         /* addr to write to */
1890
    VARARG(data,bytes);        /* data to write */
1891 1892 1893 1894 1895 1896 1897
@END


/* Create a registry key */
@REQ(create_key)
    unsigned int access;       /* desired access rights */
    unsigned int options;      /* creation options */
1898
    VARARG(objattr,object_attributes); /* object attributes */
1899
    VARARG(class,unicode_str);         /* class name */
1900
@REPLY
1901
    obj_handle_t hkey;         /* handle to the created key */
1902 1903 1904 1905 1906
    int          created;      /* has it been newly created? */
@END

/* Open a registry key */
@REQ(open_key)
1907
    obj_handle_t parent;       /* handle to the parent key */
1908
    unsigned int access;       /* desired access rights */
1909
    unsigned int attributes;   /* object attributes */
1910 1911
    VARARG(name,unicode_str);  /* key name */
@REPLY
1912
    obj_handle_t hkey;         /* handle to the open key */
1913 1914 1915 1916 1917
@END


/* Delete a registry key */
@REQ(delete_key)
1918
    obj_handle_t hkey;         /* handle to the key */
1919 1920 1921
@END


1922 1923 1924 1925 1926 1927
/* Flush a registry key */
@REQ(flush_key)
    obj_handle_t hkey;         /* handle to the key */
@END


1928 1929
/* Enumerate registry subkeys */
@REQ(enum_key)
1930
    obj_handle_t hkey;         /* handle to registry key */
1931
    int          index;        /* index of subkey (or -1 for current key) */
1932
    int          info_class;   /* requested information class */
1933 1934 1935 1936 1937 1938 1939
@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 */
1940
    timeout_t    modif;        /* last modification time */
1941 1942
    data_size_t  total;        /* total length needed for full name and class */
    data_size_t  namelen;      /* length of key name in bytes */
1943 1944
    VARARG(name,unicode_str,namelen);  /* key name */
    VARARG(class,unicode_str);         /* class name */
1945 1946 1947 1948 1949
@END


/* Set a value of a registry key */
@REQ(set_key_value)
1950
    obj_handle_t hkey;         /* handle to registry key */
1951
    int          type;         /* value type */
1952
    data_size_t  namelen;      /* length of value name in bytes */
1953 1954
    VARARG(name,unicode_str,namelen);  /* value name */
    VARARG(data,bytes);                /* value data */
1955 1956 1957 1958 1959
@END


/* Retrieve the value of a registry key */
@REQ(get_key_value)
1960
    obj_handle_t hkey;         /* handle to registry key */
1961
    VARARG(name,unicode_str);  /* value name */
1962 1963
@REPLY
    int          type;         /* value type */
1964
    data_size_t  total;        /* total length needed for data */
1965 1966 1967 1968 1969 1970
    VARARG(data,bytes);        /* value data */
@END


/* Enumerate a value of a registry key */
@REQ(enum_key_value)
1971
    obj_handle_t hkey;         /* handle to registry key */
1972
    int          index;        /* value index */
1973
    int          info_class;   /* requested information class */
1974 1975
@REPLY
    int          type;         /* value type */
1976 1977
    data_size_t  total;        /* total length needed for full name and data */
    data_size_t  namelen;      /* length of value name in bytes */
1978 1979
    VARARG(name,unicode_str,namelen);  /* value name */
    VARARG(data,bytes);                /* value data */
1980 1981 1982 1983 1984
@END


/* Delete a value of a registry key */
@REQ(delete_key_value)
1985
    obj_handle_t hkey;         /* handle to registry key */
1986 1987 1988 1989 1990 1991
    VARARG(name,unicode_str);  /* value name */
@END


/* Load a registry branch from a file */
@REQ(load_registry)
1992
    obj_handle_t file;         /* file to load from */
1993
    VARARG(objattr,object_attributes); /* object attributes */
1994 1995 1996
@END


1997 1998 1999 2000 2001 2002
/* UnLoad a registry branch from a file */
@REQ(unload_registry)
    obj_handle_t hkey;         /* root key to unload to */
@END


2003 2004
/* Save a registry branch to a file */
@REQ(save_registry)
2005 2006
    obj_handle_t hkey;         /* key to save */
    obj_handle_t file;         /* file to save to */
2007 2008 2009
@END


2010
/* Add a registry key change notification */
2011 2012 2013 2014 2015 2016 2017 2018
@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


2019 2020
/* Create a waitable timer */
@REQ(create_timer)
2021
    unsigned int access;        /* wanted access rights */
2022
    int          manual;        /* manual reset */
2023
    VARARG(objattr,object_attributes); /* object attributes */
2024
@REPLY
2025
    obj_handle_t handle;        /* handle to the timer */
2026 2027 2028 2029 2030 2031
@END


/* Open a waitable timer */
@REQ(open_timer)
    unsigned int access;        /* wanted access rights */
2032
    unsigned int attributes;    /* object attributes */
2033
    obj_handle_t rootdir;       /* root directory */
2034 2035
    VARARG(name,unicode_str);   /* object name */
@REPLY
2036
    obj_handle_t handle;        /* handle to the timer */
2037 2038 2039 2040
@END

/* Set a waitable timer */
@REQ(set_timer)
2041
    obj_handle_t handle;        /* handle to the timer */
2042
    timeout_t    expire;        /* next expiration absolute time */
2043 2044
    client_ptr_t callback;      /* callback function */
    client_ptr_t arg;           /* callback argument */
2045
    int          period;        /* timer period in ms */
2046 2047
@REPLY
    int          signaled;      /* was the timer signaled before this call ? */
2048 2049 2050 2051
@END

/* Cancel a waitable timer */
@REQ(cancel_timer)
2052
    obj_handle_t handle;        /* handle to the timer */
2053 2054
@REPLY
     int         signaled;      /* was the timer signaled before this calltime ? */
2055 2056
@END

2057 2058 2059 2060
/* Get information on a waitable timer */
@REQ(get_timer_info)
    obj_handle_t handle;        /* handle to the timer */
@REPLY
2061
    timeout_t    when;          /* absolute time when the timer next expires */
2062 2063 2064
    int          signaled;      /* is the timer signaled? */
@END

2065 2066 2067

/* Retrieve the current context of a thread */
@REQ(get_thread_context)
2068
    obj_handle_t handle;       /* thread handle */
2069
    unsigned int flags;        /* context flags */
2070
    int          suspend;      /* suspend the thread if needed */
2071
@REPLY
2072
    int          self;         /* was it a handle to the current thread? */
2073 2074 2075 2076 2077 2078
    VARARG(context,context);   /* thread context */
@END


/* Set the current context of a thread */
@REQ(set_thread_context)
2079
    obj_handle_t handle;       /* thread handle */
2080
    int          suspend;      /* suspend the thread if needed */
2081
    VARARG(context,context);   /* thread context */
2082 2083
@REPLY
    int          self;         /* was it a handle to the current thread? */
2084 2085 2086 2087 2088
@END


/* Fetch a selector entry for a thread */
@REQ(get_selector_entry)
2089
    obj_handle_t  handle;      /* thread handle */
2090 2091 2092 2093 2094 2095 2096 2097 2098 2099
    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)
2100
    obj_handle_t  table;       /* which table to add atom to */
2101 2102
    VARARG(name,unicode_str);  /* atom name */
@REPLY
2103
    atom_t        atom;        /* resulting atom */
2104 2105 2106 2107 2108
@END


/* Delete an atom */
@REQ(delete_atom)
2109
    obj_handle_t  table;       /* which table to delete atom from */
2110
    atom_t        atom;        /* atom handle */
2111 2112 2113 2114 2115
@END


/* Find an atom */
@REQ(find_atom)
2116
    obj_handle_t table;        /* which table to find atom from */
2117 2118
    VARARG(name,unicode_str);  /* atom name */
@REPLY
2119
    atom_t       atom;         /* atom handle */
2120 2121 2122
@END


2123 2124 2125
/* Get information about an atom */
@REQ(get_atom_information)
    obj_handle_t table;        /* which table to find atom from */
2126
    atom_t       atom;         /* atom handle */
2127 2128
@REPLY
    int          count;        /* atom lock count */
2129
    int          pinned;       /* whether the atom has been pinned */
2130
    data_size_t  total;        /* actual length of atom name */
2131 2132 2133 2134
    VARARG(name,unicode_str);  /* atom name */
@END


2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
/* 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 */
2151
@REQ(init_atom_table)
2152 2153 2154
    int          entries;      /* number of entries (only for local) */
@REPLY
    obj_handle_t table;        /* handle to the atom table */
2155 2156 2157 2158 2159 2160
@END


/* Get the message queue of the current thread */
@REQ(get_msg_queue)
@REPLY
2161
    obj_handle_t handle;       /* handle to the queue */
2162 2163 2164
@END


2165 2166 2167 2168 2169 2170
/* Set the file descriptor associated to the current thread queue */
@REQ(set_queue_fd)
    obj_handle_t handle;       /* handle to the file descriptor */
@END


2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183
/* 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)
2184
    unsigned int clear_bits;   /* should we clear the change bits? */
2185 2186 2187 2188 2189 2190
@REPLY
    unsigned int wake_bits;    /* wake bits */
    unsigned int changed_bits; /* changed bits since last time */
@END


2191 2192
/* Retrieve the process idle event */
@REQ(get_process_idle_event)
2193
    obj_handle_t handle;       /* process handle */
2194
@REPLY
2195
    obj_handle_t event;        /* handle to idle event */
2196 2197 2198 2199 2200
@END


/* Send a message to a thread queue */
@REQ(send_message)
2201
    thread_id_t     id;        /* thread id */
2202
    int             type;      /* message type (see below) */
2203
    int             flags;     /* message flags (see below) */
2204
    user_handle_t   win;       /* window handle */
2205
    unsigned int    msg;       /* message code */
2206 2207
    lparam_t        wparam;    /* parameters */
    lparam_t        lparam;    /* parameters */
2208
    timeout_t       timeout;   /* timeout for reply */
2209
    VARARG(data,message_data); /* message data for sent messages */
2210
@END
2211

2212 2213 2214 2215
@REQ(post_quit_message)
    int             exit_code; /* exit code to return */
@END

2216 2217 2218 2219 2220 2221
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 */
2222
    MSG_CALLBACK_RESULT,/* result of a callback message */
2223 2224
    MSG_OTHER_PROCESS,  /* sent from other process, may include vararg data, always Unicode */
    MSG_POSTED,         /* posted message (from PostMessageW), always Unicode */
2225
    MSG_HARDWARE,       /* hardware message */
2226 2227
    MSG_WINEVENT,       /* winevent message */
    MSG_HOOK_LL         /* low-level hardware hook */
2228
};
2229
#define SEND_MSG_ABORT_IF_HUNG  0x01
2230 2231


2232 2233 2234
/* Send a hardware message to a thread queue */
@REQ(send_hardware_message)
    user_handle_t   win;       /* window handle */
2235 2236
    hw_input_t      input;     /* input data */
    unsigned int    flags;     /* flags (see below) */
2237 2238
@REPLY
    int             wait;      /* do we need to wait for a reply? */
2239 2240 2241 2242
    int             prev_x;    /* previous cursor position */
    int             prev_y;
    int             new_x;     /* new cursor position */
    int             new_y;
2243
    VARARG(keystate,bytes);    /* global state array for all the keys */
2244
@END
2245
#define SEND_HWMSG_INJECTED    0x01
2246 2247


2248 2249
/* Get a message from the current queue */
@REQ(get_message)
2250
    unsigned int    flags;     /* PM_* flags */
2251
    user_handle_t   get_win;   /* window handle to get */
2252 2253
    unsigned int    get_first; /* first message code to get */
    unsigned int    get_last;  /* last message code to get */
2254
    unsigned int    hw_id;     /* id of the previous hardware message (or 0) */
2255 2256
    unsigned int    wake_mask; /* wakeup bits mask */
    unsigned int    changed_mask; /* changed bits mask */
2257
@REPLY
2258
    user_handle_t   win;       /* window handle */
2259
    unsigned int    msg;       /* message code */
2260 2261
    lparam_t        wparam;    /* parameters */
    lparam_t        lparam;    /* parameters */
2262
    int             type;      /* message type */
2263 2264
    int             x;         /* message x position */
    int             y;         /* message y position */
2265
    unsigned int    time;      /* message time */
2266
    unsigned int    active_hooks; /* active hooks bitmap */
2267
    data_size_t     total;     /* total size of extra data */
2268
    VARARG(data,message_data); /* message data for sent messages */
2269
@END
2270

2271 2272 2273 2274

/* Reply to a sent message */
@REQ(reply_message)
    int             remove;    /* should we remove the message? */
2275
    lparam_t        result;    /* message result */
2276
    VARARG(data,bytes);        /* message data for sent messages */
2277 2278 2279
@END


2280 2281
/* Accept the current hardware message */
@REQ(accept_hardware_message)
2282
    unsigned int    hw_id;     /* id of the hardware message */
2283 2284 2285 2286
    int             remove;    /* should we remove the message? */
@END


2287 2288 2289 2290
/* Retrieve the reply for the last message sent */
@REQ(get_message_reply)
    int             cancel;    /* cancel message if not ready? */
@REPLY
2291
    lparam_t        result;    /* message result */
2292
    VARARG(data,bytes);        /* message data for sent messages */
2293 2294 2295 2296 2297
@END


/* Set a window timer */
@REQ(set_win_timer)
2298
    user_handle_t   win;       /* window handle */
2299 2300
    unsigned int    msg;       /* message to post */
    unsigned int    rate;      /* timer rate in ms */
2301 2302
    lparam_t        id;        /* timer id */
    lparam_t        lparam;    /* message lparam (callback proc) */
2303
@REPLY
2304
    lparam_t        id;        /* timer id */
2305 2306 2307 2308 2309
@END


/* Kill a window timer */
@REQ(kill_win_timer)
2310
    user_handle_t   win;       /* window handle */
2311
    lparam_t        id;        /* timer id */
2312
    unsigned int    msg;       /* message to post */
2313 2314 2315
@END


2316 2317 2318 2319 2320 2321 2322 2323
/* check if the thread owning the window is hung */
@REQ(is_window_hung)
    user_handle_t   win;       /* window handle */
@REPLY
    int is_hung;
@END


2324 2325
/* Retrieve info about a serial port */
@REQ(get_serial_info)
2326
    obj_handle_t handle;       /* handle to comm port */
2327
    int          flags;
2328 2329
@REPLY
    unsigned int eventmask;
2330
    unsigned int cookie;
2331
    unsigned int pending_write;
2332 2333 2334 2335 2336
@END


/* Set info about a serial port */
@REQ(set_serial_info)
2337
    obj_handle_t handle;       /* handle to comm port */
2338 2339
    int          flags;        /* bitmask to set values (see below) */
@END
2340
#define SERIALINFO_PENDING_WRITE 0x04
2341
#define SERIALINFO_PENDING_WAIT  0x08
2342 2343


2344
/* Create an async I/O */
2345
@REQ(register_async)
2346
    int          type;          /* type of queue to look after */
2347
    async_data_t async;         /* async I/O parameters */
2348
    int          count;         /* count - usually # of bytes to be read/written */
2349 2350 2351 2352 2353 2354
@END
#define ASYNC_TYPE_READ  0x01
#define ASYNC_TYPE_WRITE 0x02
#define ASYNC_TYPE_WAIT  0x03


2355 2356 2357
/* Cancel all async op on a fd */
@REQ(cancel_async)
    obj_handle_t handle;        /* handle to comm port, socket or file */
2358 2359
    client_ptr_t iosb;          /* I/O status block (NULL=all) */
    int          only_thread;   /* cancel matching this thread */
2360 2361 2362
@END


2363 2364 2365 2366 2367 2368 2369 2370 2371
/* Retrieve results of an async */
@REQ(get_async_result)
    client_ptr_t   user_arg;      /* user arg used to identify async */
@REPLY
    data_size_t    size;          /* result size (input or output depending on the operation) */
    VARARG(out_data,bytes);       /* iosb output data */
@END


2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394
/* Perform a read on a file object */
@REQ(read)
    async_data_t   async;         /* async I/O parameters */
    file_pos_t     pos;           /* read position */
@REPLY
    obj_handle_t   wait;          /* handle to wait on for blocking read */
    unsigned int   options;       /* device open options */
    VARARG(data,bytes);           /* read data */
@END


/* Perform a write on a file object */
@REQ(write)
    async_data_t   async;         /* async I/O parameters */
    file_pos_t     pos;           /* write position */
    VARARG(data,bytes);           /* write data */
@REPLY
    obj_handle_t   wait;          /* handle to wait on for blocking write */
    unsigned int   options;       /* device open options */
    data_size_t    size;          /* size written */
@END


2395 2396
/* Perform an ioctl on a file */
@REQ(ioctl)
2397
    ioctl_code_t   code;          /* ioctl code */
2398 2399 2400
    async_data_t   async;         /* async I/O parameters */
    VARARG(in_data,bytes);        /* ioctl input data */
@REPLY
2401 2402
    obj_handle_t   wait;          /* handle to wait on for blocking ioctl */
    unsigned int   options;       /* device open options */
2403 2404 2405 2406
    VARARG(out_data,bytes);       /* ioctl output data */
@END


2407 2408 2409 2410
/* Store results of an async irp */
@REQ(set_irp_result)
    obj_handle_t handle;          /* handle to the irp */
    unsigned int status;          /* status of the irp */
2411
    data_size_t  size;            /* result size (input or output depending on the operation) */
2412
    client_ptr_t file_ptr;        /* opaque pointer to the file object */
2413
    VARARG(data,bytes);           /* output data of the irp */
2414 2415 2416
@END


2417 2418
/* Create a named pipe */
@REQ(create_named_pipe)
2419
    unsigned int   access;
2420
    unsigned int   options;
2421
    unsigned int   sharing;
2422 2423 2424
    unsigned int   maxinstances;
    unsigned int   outsize;
    unsigned int   insize;
2425
    timeout_t      timeout;
2426
    unsigned int   flags;
2427
    VARARG(objattr,object_attributes); /* object attributes */
2428
@REPLY
2429
    obj_handle_t   handle;       /* handle to the pipe */
2430 2431
@END

2432 2433 2434 2435
/* 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
2436
#define NAMED_PIPE_SERVER_END           0x8000
2437

2438
/* Get named pipe information by handle */
2439
@REQ(get_named_pipe_info)
2440
    obj_handle_t   handle;
2441 2442
@REPLY
    unsigned int   flags;
2443
    unsigned int   sharing;
2444
    unsigned int   maxinstances;
2445
    unsigned int   instances;
2446 2447 2448 2449
    unsigned int   outsize;
    unsigned int   insize;
@END

2450 2451 2452 2453 2454
/* Set named pipe information by handle */
@REQ(set_named_pipe_info)
    obj_handle_t   handle;
    unsigned int   flags;
@END
2455 2456 2457

/* Create a window */
@REQ(create_window)
2458 2459
    user_handle_t  parent;      /* parent window */
    user_handle_t  owner;       /* owner window */
2460
    atom_t         atom;        /* class atom */
2461
    mod_handle_t   instance;    /* module instance */
2462
    VARARG(class,unicode_str);  /* class name */
2463
@REPLY
2464
    user_handle_t  handle;      /* created window */
2465 2466
    user_handle_t  parent;      /* full handle of parent */
    user_handle_t  owner;       /* full handle of owner */
2467
    int            extra;       /* number of extra bytes */
2468
    client_ptr_t   class_ptr;   /* pointer to class in client address space */
2469 2470 2471 2472 2473 2474 2475 2476 2477
@END


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


2478 2479
/* Retrieve the desktop window for the current thread */
@REQ(get_desktop_window)
2480
    int            force;       /* force creation if it doesn't exist */
2481
@REPLY
2482 2483
    user_handle_t  top_window;  /* handle to the desktop window */
    user_handle_t  msg_window;  /* handle to the top-level HWND_MESSAGE parent */
2484 2485 2486
@END


2487 2488 2489 2490 2491 2492
/* 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 */
2493
    user_handle_t  prev_owner;  /* full handle of previous owner */
2494 2495 2496
@END


2497 2498 2499 2500 2501
/* 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 */
2502
    user_handle_t  last_active; /* last active popup */
2503 2504
    process_id_t   pid;         /* process owning the window */
    thread_id_t    tid;         /* thread owning the window */
2505
    atom_t         atom;        /* class atom */
2506
    int            is_unicode;  /* ANSI or unicode */
2507
@END
2508 2509


2510 2511
/* Set some information in a window */
@REQ(set_window_info)
2512 2513
    unsigned short flags;         /* flags for fields to set (see below) */
    short int      is_unicode;    /* ANSI or unicode */
2514
    user_handle_t  handle;        /* handle to the window */
2515 2516 2517
    unsigned int   style;         /* window style */
    unsigned int   ex_style;      /* window extended style */
    unsigned int   id;            /* window id */
2518
    mod_handle_t   instance;      /* creator instance */
2519
    lparam_t       user_data;     /* user-specific data */
2520
    int            extra_offset;  /* offset to set in extra bytes */
2521
    data_size_t    extra_size;    /* size to set in extra bytes */
2522
    lparam_t       extra_value;   /* value to set in extra bytes */
2523 2524 2525
@REPLY
    unsigned int   old_style;     /* old window style */
    unsigned int   old_ex_style;  /* old window extended style */
2526
    mod_handle_t   old_instance;  /* old creator instance */
2527 2528
    lparam_t       old_user_data; /* old user-specific data */
    lparam_t       old_extra_value; /* old value in extra bytes */
2529
    unsigned int   old_id;        /* old window id */
2530 2531 2532 2533 2534 2535
@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
2536
#define SET_WIN_EXTRA     0x20
2537
#define SET_WIN_UNICODE   0x40
2538 2539


2540 2541 2542 2543 2544 2545 2546 2547 2548 2549
/* 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


2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
/* 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)
2561
    obj_handle_t   desktop;       /* handle to desktop */
2562
    user_handle_t  parent;        /* parent window */
2563
    atom_t         atom;          /* class atom for the listed children */
2564
    thread_id_t    tid;           /* thread owning the listed children */
2565
    VARARG(class,unicode_str);    /* class name */
2566 2567
@REPLY
    int            count;         /* total count of children */
2568
    VARARG(children,user_handles); /* children handles */
2569 2570 2571
@END


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


2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595
/* 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
2596

2597 2598
/* Set the position and Z order of a window */
@REQ(set_window_pos)
2599 2600
    unsigned short swp_flags;     /* SWP_* flags */
    unsigned short paint_flags;   /* paint flags (see below) */
2601
    user_handle_t  handle;        /* handle to the window */
2602
    user_handle_t  previous;      /* previous window in Z order */
2603 2604
    rectangle_t    window;        /* window rectangle (in parent coords) */
    rectangle_t    client;        /* client rectangle (in parent coords) */
2605
    VARARG(valid,rectangles);     /* valid rectangles from WM_NCCALCSIZE (in parent coords) */
2606 2607
@REPLY
    unsigned int   new_style;     /* new window style */
2608
    unsigned int   new_ex_style;  /* new window extended style */
2609 2610
    user_handle_t  surface_win;   /* parent window that holds the surface */
    int            needs_update;  /* whether the surface region needs an update */
2611
@END
2612 2613
#define SET_WINPOS_PAINT_SURFACE 0x01  /* window has a paintable surface */
#define SET_WINPOS_PIXEL_FORMAT  0x02  /* window has a custom pixel format */
2614 2615 2616 2617

/* Get the window and client rectangles of a window */
@REQ(get_window_rectangles)
    user_handle_t  handle;        /* handle to the window */
2618
    int            relative;      /* coords relative to (see below) */
2619 2620
@REPLY
    rectangle_t    window;        /* window rectangle */
2621
    rectangle_t    visible;       /* visible part of the window rectangle */
2622 2623
    rectangle_t    client;        /* client rectangle */
@END
2624 2625 2626 2627 2628 2629 2630
enum coords_relative
{
    COORDS_CLIENT,   /* relative to client area */
    COORDS_WINDOW,   /* relative to whole window area */
    COORDS_PARENT,   /* relative to parent's client area */
    COORDS_SCREEN    /* relative to screen origin */
};
2631 2632


2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647
/* 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


2648 2649 2650 2651 2652 2653 2654
/* 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 */
2655
    int            mirror;        /* whether to mirror the x coordinate */
2656 2657
@END

2658

2659 2660 2661 2662 2663
/* 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
2664
    user_handle_t  top_win;       /* top window to clip against */
2665 2666
    rectangle_t    top_rect;      /* top window visible rect with screen coords */
    rectangle_t    win_rect;      /* window rect in screen coords */
2667
    unsigned int   paint_flags;   /* paint flags (from SET_WINPOS_* flags) */
2668
    data_size_t    total_size;    /* total size of the resulting region */
2669
    VARARG(region,rectangles);    /* list of rectangles for the region (in screen coords) */
2670 2671 2672
@END


2673 2674 2675 2676 2677 2678 2679 2680 2681 2682
/* Get the visible surface region of a window */
@REQ(get_surface_region)
    user_handle_t  window;        /* handle to the window */
@REPLY
    rectangle_t    visible_rect;  /* window visible rect in screen coords */
    data_size_t    total_size;    /* total size of the resulting region */
    VARARG(region,rectangles);    /* list of rectangles for the region (in screen coords) */
@END


2683 2684 2685 2686
/* Get the window region */
@REQ(get_window_region)
    user_handle_t  window;        /* handle to the window */
@REPLY
2687
    data_size_t    total_size;    /* total size of the resulting region */
2688
    VARARG(region,rectangles);    /* list of rectangles for the region (in window coords) */
2689 2690 2691 2692 2693 2694
@END


/* Set the window region */
@REQ(set_window_region)
    user_handle_t  window;        /* handle to the window */
2695
    int            redraw;        /* redraw the window? */
2696
    VARARG(region,rectangles);    /* list of rectangles for the region (in window coords) */
2697 2698 2699
@END


2700 2701 2702
/* Get the window update region */
@REQ(get_update_region)
    user_handle_t  window;        /* handle to the window */
2703
    user_handle_t  from_child;    /* child to start searching from */
2704 2705 2706 2707
    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) */
2708
    data_size_t    total_size;    /* total size of the resulting region */
2709
    VARARG(region,rectangles);    /* list of rectangles for the region (in screen coords) */
2710
@END
2711 2712 2713 2714 2715 2716 2717 2718 2719
#define UPDATE_NONCLIENT       0x001  /* get region for repainting non-client area */
#define UPDATE_ERASE           0x002  /* get region for erasing client area */
#define UPDATE_PAINT           0x004  /* get region for painting client area */
#define UPDATE_INTERNALPAINT   0x008  /* get region if internal paint is pending */
#define UPDATE_ALLCHILDREN     0x010  /* force repaint of all children */
#define UPDATE_NOCHILDREN      0x020  /* don't try to repaint any children */
#define UPDATE_NOREGION        0x040  /* don't return a region, only the flags */
#define UPDATE_DELAYED_ERASE   0x080  /* still needs erase after BeginPaint */
#define UPDATE_CLIPCHILDREN    0x100  /* remove clipped children from the update region */
2720 2721


2722 2723 2724
/* 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 */
2725
    rectangle_t    rect;          /* rectangle that must be visible (in client coords) */
2726 2727 2728
@END


2729 2730 2731 2732
/* 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 */
2733
    VARARG(region,rectangles);    /* list of rectangles for the region (in window coords) */
2734 2735 2736
@END


2737 2738 2739
/* Set a window property */
@REQ(set_window_property)
    user_handle_t  window;        /* handle to the window */
2740
    lparam_t       data;          /* data to store */
2741
    atom_t         atom;          /* property atom (if no name specified) */
2742
    VARARG(name,unicode_str);     /* property name */
2743 2744 2745 2746 2747 2748
@END


/* Remove a window property */
@REQ(remove_window_property)
    user_handle_t  window;        /* handle to the window */
2749 2750
    atom_t         atom;          /* property atom (if no name specified) */
    VARARG(name,unicode_str);     /* property name */
2751
@REPLY
2752
    lparam_t       data;          /* data stored in property */
2753 2754 2755 2756 2757 2758
@END


/* Get a window property */
@REQ(get_window_property)
    user_handle_t  window;        /* handle to the window */
2759 2760
    atom_t         atom;          /* property atom (if no name specified) */
    VARARG(name,unicode_str);     /* property name */
2761
@REPLY
2762
    lparam_t       data;          /* data stored in property */
2763 2764 2765 2766 2767 2768 2769
@END


/* Get the list of properties of a window */
@REQ(get_window_properties)
    user_handle_t  window;        /* handle to the window */
@REPLY
2770
    int            total;         /* total number of properties */
2771 2772
    VARARG(props,properties);     /* list of properties */
@END
2773 2774


2775 2776 2777 2778
/* Create a window station */
@REQ(create_winstation)
    unsigned int flags;           /* window station flags */
    unsigned int access;          /* wanted access rights */
2779
    unsigned int attributes;      /* object attributes */
2780
    obj_handle_t rootdir;         /* root directory */
2781 2782 2783 2784 2785 2786 2787 2788 2789
    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 */
2790
    unsigned int attributes;      /* object attributes */
2791
    obj_handle_t rootdir;         /* root directory */
2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816
    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


2817 2818 2819 2820 2821 2822 2823 2824 2825
/* 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


2826 2827 2828 2829
/* Create a desktop */
@REQ(create_desktop)
    unsigned int flags;           /* desktop flags */
    unsigned int access;          /* wanted access rights */
2830
    unsigned int attributes;      /* object attributes */
2831 2832 2833 2834 2835 2836 2837 2838
    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)
2839
    obj_handle_t winsta;          /* window station to open (null allowed) */
2840 2841
    unsigned int flags;           /* desktop flags */
    unsigned int access;          /* wanted access rights */
2842
    unsigned int attributes;      /* object attributes */
2843 2844 2845 2846 2847 2848
    VARARG(name,unicode_str);     /* object name */
@REPLY
    obj_handle_t handle;          /* handle to the desktop */
@END


2849 2850 2851 2852 2853 2854 2855 2856 2857 2858
/* Open a handle to current input desktop */
@REQ(open_input_desktop)
    unsigned int flags;           /* desktop flags */
    unsigned int access;          /* wanted access rights */
    unsigned int attributes;      /* object attributes */
@REPLY
    obj_handle_t handle;          /* handle to the desktop */
@END


2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878
/* 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


2879 2880 2881 2882 2883 2884 2885 2886 2887 2888
/* 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


2889 2890 2891
/* Get/set information about a user object (window station or desktop) */
@REQ(set_user_object_info)
    obj_handle_t handle;          /* handle to the object */
2892
    unsigned int flags;           /* information to set/get */
2893 2894 2895 2896 2897 2898
    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
2899 2900
#define SET_USER_OBJECT_SET_FLAGS       1
#define SET_USER_OBJECT_GET_FULL_NAME   2
2901 2902


2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925
/* Register a hotkey */
@REQ(register_hotkey)
    user_handle_t  window;        /* handle to the window */
    int            id;            /* hotkey identifier */
    unsigned int   flags;         /* modifier keys */
    unsigned int   vkey;          /* virtual key code */
@REPLY
    int            replaced;      /* did we replace an existing hotkey? */
    unsigned int   flags;         /* flags of replaced hotkey */
    unsigned int   vkey;          /* virtual key code of replaced hotkey */
@END


/* Unregister a hotkey */
@REQ(unregister_hotkey)
    user_handle_t  window;        /* handle to the window */
    int            id;            /* hotkey identifier */
@REPLY
    unsigned int   flags;         /* flags of removed hotkey */
    unsigned int   vkey;          /* virtual key code of removed hotkey */
@END


2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944
/* 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 */
2945 2946
    user_handle_t  cursor;        /* handle to the cursor */
    int            show_count;    /* cursor show count */
2947 2948
    rectangle_t    rect;          /* caret rectangle */
@END
2949

2950 2951 2952 2953 2954 2955 2956 2957

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


2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969
/* 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 */
2970
    int            async;         /* whether to change the async state too */
2971 2972 2973
    VARARG(keystate,bytes);       /* state array for all the keys */
@END

2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995
/* 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
2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006

/* 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 */
3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028


/* 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) */
3029
    int            state;         /* caret state (see below) */
3030 3031 3032 3033 3034 3035 3036 3037 3038
@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 */
3039 3040 3041 3042 3043 3044 3045
enum caret_state
{
    CARET_STATE_OFF,        /* off */
    CARET_STATE_ON,         /* on */
    CARET_STATE_TOGGLE,     /* toggle current state */
    CARET_STATE_ON_IF_MOVED /* on if the position differs, unchanged otherwise */
};
3046 3047 3048 3049 3050


/* Set a window hook */
@REQ(set_hook)
    int            id;             /* id of the hook */
3051
    process_id_t   pid;            /* id of process to set the hook into */
3052
    thread_id_t    tid;            /* id of thread to set the hook into */
3053 3054
    int            event_min;
    int            event_max;
3055
    client_ptr_t   proc;           /* hook procedure */
3056
    int            flags;
3057
    int            unicode;        /* is it a unicode hook? */
3058
    VARARG(module,unicode_str);    /* module name */
3059 3060
@REPLY
    user_handle_t  handle;         /* handle to the hook */
3061
    unsigned int   active_hooks;   /* active hooks bitmap */
3062 3063 3064 3065 3066 3067
@END


/* Remove a window hook */
@REQ(remove_hook)
    user_handle_t  handle;         /* handle to the hook */
3068
    client_ptr_t   proc;           /* hook procedure if handle is 0 */
3069
    int            id;             /* id of the hook if handle is 0 */
3070 3071
@REPLY
    unsigned int   active_hooks;   /* active hooks bitmap */
3072 3073 3074 3075 3076 3077
@END


/* Start calling a hook chain */
@REQ(start_hook_chain)
    int            id;             /* id of the hook */
3078 3079 3080 3081
    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 */
3082 3083
@REPLY
    user_handle_t  handle;         /* handle to the next hook */
3084 3085
    process_id_t   pid;            /* process id for low-level keyboard/mouse hooks */
    thread_id_t    tid;            /* thread id for low-level keyboard/mouse hooks */
3086
    int            unicode;        /* is it a unicode hook? */
3087
    client_ptr_t   proc;           /* hook procedure */
3088
    unsigned int   active_hooks;   /* active hooks bitmap */
3089
    VARARG(module,unicode_str);    /* module name */
3090 3091 3092 3093 3094 3095 3096 3097 3098
@END


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


3099 3100
/* Get the hook information */
@REQ(get_hook_info)
3101
    user_handle_t  handle;         /* handle to the current hook */
3102
    int            get_next;       /* do we want info about current or next hook? */
3103 3104 3105 3106
    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 */
3107
@REPLY
3108 3109
    user_handle_t  handle;         /* handle to the hook */
    int            id;             /* id of the hook */
3110 3111
    process_id_t   pid;            /* process id for low-level keyboard/mouse hooks */
    thread_id_t    tid;            /* thread id for low-level keyboard/mouse hooks */
3112
    client_ptr_t   proc;           /* hook procedure */
3113
    int            unicode;        /* is it a unicode hook? */
3114
    VARARG(module,unicode_str);    /* module name */
3115
@END
3116 3117


3118 3119 3120 3121 3122
/* Create a window class */
@REQ(create_class)
    int            local;          /* is it a local class? */
    atom_t         atom;           /* class atom */
    unsigned int   style;          /* class style */
3123
    mod_handle_t   instance;       /* module instance */
3124 3125
    int            extra;          /* number of extra class bytes */
    int            win_extra;      /* number of window extra bytes */
3126
    client_ptr_t   client_ptr;     /* pointer to class in client address space */
3127 3128 3129
    VARARG(name,unicode_str);      /* class name */
@REPLY
    atom_t         atom;           /* resulting class atom */
3130 3131 3132 3133 3134 3135
@END


/* Destroy a window class */
@REQ(destroy_class)
    atom_t         atom;           /* class atom */
3136
    mod_handle_t   instance;       /* module instance */
3137
    VARARG(name,unicode_str);      /* class name */
3138
@REPLY
3139
    client_ptr_t   client_ptr;     /* pointer to class in client address space */
3140 3141 3142 3143 3144 3145 3146 3147 3148 3149
@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 */
3150
    mod_handle_t   instance;       /* module instance */
3151
    int            extra_offset;   /* offset to set in extra bytes */
3152
    data_size_t    extra_size;     /* size to set in extra bytes */
3153
    lparam_t       extra_value;    /* value to set in extra bytes */
3154 3155 3156 3157 3158
@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 */
3159
    mod_handle_t   old_instance;   /* previous module instance */
3160
    lparam_t       old_extra_value; /* old value in extra bytes */
3161 3162 3163 3164 3165 3166 3167 3168
@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


3169 3170 3171 3172
/* Open the clipboard */
@REQ(open_clipboard)
    user_handle_t  window;         /* clipboard window */
@REPLY
3173
    user_handle_t  owner;          /* current clipboard owner */
3174 3175 3176 3177 3178 3179 3180
@END


/* Close the clipboard */
@REQ(close_clipboard)
@REPLY
    user_handle_t  viewer;         /* first clipboard viewer */
3181
    user_handle_t  owner;          /* current clipboard owner */
3182 3183 3184
@END


3185 3186 3187 3188 3189
/* Empty the clipboard and grab ownership */
@REQ(empty_clipboard)
@END


3190 3191 3192
/* Add a data format to the clipboard */
@REQ(set_clipboard_data)
    unsigned int   format;         /* clipboard format of the data */
3193
    unsigned int   lcid;           /* locale id to use for synthesizing text formats */
3194
    VARARG(data,bytes);            /* data contents */
3195 3196
@REPLY
    unsigned int   seqno;          /* sequence number for the set data */
3197 3198 3199
@END


3200 3201 3202
/* Fetch a data format from the clipboard */
@REQ(get_clipboard_data)
    unsigned int   format;         /* clipboard format of the data */
3203
    int            render;         /* will we try to render it if missing? */
3204 3205
    int            cached;         /* do we already have it in the client-side cache? */
    unsigned int   seqno;          /* sequence number for the data in the cache */
3206
@REPLY
3207
    unsigned int   from;           /* for synthesized data, format to generate it from */
3208
    user_handle_t  owner;          /* clipboard owner for delayed-rendered formats */
3209
    unsigned int   seqno;          /* sequence number for the originally set data */
3210 3211 3212 3213 3214
    data_size_t    total;          /* total data size */
    VARARG(data,bytes);            /* data contents */
@END


3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231
/* Retrieve a list of available formats */
@REQ(get_clipboard_formats)
    unsigned int   format;         /* specific format to query, return all if 0 */
@REPLY
    unsigned int   count;          /* count of available formats */
    VARARG(formats,uints);         /* array of available formats */
@END


/* Retrieve the next available format */
@REQ(enum_clipboard_formats)
    unsigned int   previous;       /* previous format, or first if 0 */
@REPLY
    unsigned int   format;         /* next format */
@END


3232 3233 3234 3235 3236
/* Release ownership of the clipboard */
@REQ(release_clipboard)
    user_handle_t  owner;          /* clipboard owner to release */
@REPLY
    user_handle_t  viewer;         /* first clipboard viewer */
3237
    user_handle_t  owner;          /* current clipboard owner */
3238 3239 3240
@END


3241 3242 3243 3244 3245 3246 3247 3248 3249 3250
/* Get clipboard information */
@REQ(get_clipboard_info)
@REPLY
    user_handle_t  window;         /* clipboard window */
    user_handle_t  owner;          /* clipboard owner */
    user_handle_t  viewer;         /* clipboard viewer */
    unsigned int   seqno;          /* current sequence number */
@END


3251 3252 3253 3254 3255 3256 3257 3258 3259 3260
/* Set the clipboard viewer window */
@REQ(set_clipboard_viewer)
    user_handle_t  viewer;         /* clipboard viewer */
    user_handle_t  previous;       /* if non-zero, check that this was the previous viewer */
@REPLY
    user_handle_t  old_viewer;     /* previous clipboard viewer */
    user_handle_t  owner;          /* clipboard owner */
@END


3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272
/* Add a clipboard listener window */
@REQ(add_clipboard_listener)
    user_handle_t  window;         /* clipboard listener window */
@END


/* Remove a clipboard listener window */
@REQ(remove_clipboard_listener)
    user_handle_t  window;         /* clipboard listener window */
@END


3273 3274 3275
/* Open a security token */
@REQ(open_token)
    obj_handle_t   handle;    /* handle to the thread or process */
3276 3277
    unsigned int   access;    /* access rights to the new token */
    unsigned int   attributes;/* object attributes */
3278 3279 3280 3281 3282 3283
    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
3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301


/* 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
3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321

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

3322 3323 3324 3325 3326 3327 3328 3329 3330 3331
/* 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

3332
@REQ(duplicate_token)
3333 3334 3335
    obj_handle_t  handle;        /* handle to the token to duplicate */
    unsigned int  access;        /* access rights to the new token */
    int           primary;       /* is the new token to be a primary one? */
3336
    int           impersonation_level; /* impersonation level of the new token */
3337
    VARARG(objattr,object_attributes); /* object attributes */
3338 3339 3340
@REPLY
    obj_handle_t  new_handle; /* duplicated handle */
@END
Mike McCormack's avatar
Mike McCormack committed
3341

3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355
@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
3356

3357
@REQ(get_token_sid)
3358
    obj_handle_t    handle;       /* handle to the token */
3359
    unsigned int    which_sid;    /* which SID to retrieve from the token */
3360
@REPLY
3361 3362
    data_size_t     sid_len;      /* length needed to store sid */
    VARARG(sid,SID);              /* the sid specified by which_sid from the token */
3363 3364
@END

3365 3366 3367
@REQ(get_token_groups)
    obj_handle_t    handle;       /* handle to the token */
@REPLY
3368
    data_size_t     user_len;     /* length needed to store user */
3369
    VARARG(user,token_groups);    /* groups the token's user belongs to */
3370 3371
@END

3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383
@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

3384 3385 3386 3387 3388 3389
@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

3390 3391 3392 3393 3394 3395 3396 3397
@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

3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413

struct handle_info
{
    process_id_t owner;
    obj_handle_t handle;
    unsigned int access;
};

/* Return a list of all opened handles */
@REQ(get_system_handles)
@REPLY
    unsigned int    count;        /* number of handles */
    VARARG(data,handle_infos);    /* array of handle_infos */
@END


Mike McCormack's avatar
Mike McCormack committed
3414 3415
/* Create a mailslot */
@REQ(create_mailslot)
3416
    unsigned int   access;        /* wanted access rights */
3417
    timeout_t      read_timeout;
3418
    unsigned int   max_msgsize;
3419
    VARARG(objattr,object_attributes); /* object attributes */
Mike McCormack's avatar
Mike McCormack committed
3420 3421 3422 3423 3424 3425 3426 3427
@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 */
3428
    timeout_t      read_timeout;
3429
    unsigned int   flags;
Mike McCormack's avatar
Mike McCormack committed
3430
@REPLY
3431
    timeout_t      read_timeout;
3432
    unsigned int   max_msgsize;
Mike McCormack's avatar
Mike McCormack committed
3433 3434
@END
#define MAILSLOT_SET_READ_TIMEOUT  1
3435 3436 3437 3438 3439


/* Create a directory object */
@REQ(create_directory)
    unsigned int   access;        /* access flags */
3440
    VARARG(objattr,object_attributes); /* object attributes */
3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454
@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
3455 3456


3457 3458 3459 3460 3461
/* Get a directory entry by index */
@REQ(get_directory_entry)
    obj_handle_t   handle;             /* handle to the directory */
    unsigned int   index;              /* entry index */
@REPLY
3462
    data_size_t    name_len;           /* length of the entry name in bytes */
3463 3464 3465 3466 3467
    VARARG(name,unicode_str,name_len); /* entry name */
    VARARG(type,unicode_str);          /* entry type */
@END


3468 3469 3470
/* Create a symbolic link object */
@REQ(create_symlink)
    unsigned int   access;        /* access flags */
3471
    VARARG(objattr,object_attributes); /* object attributes */
3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492
    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
3493
    data_size_t    total;         /* total needed size for name */
3494 3495
    VARARG(target_name,unicode_str); /* target name */
@END
3496 3497 3498 3499 3500 3501 3502 3503


/* 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 */
3504
    unsigned int   handle_count;  /* object handle count */
3505 3506
    data_size_t    total;         /* total needed size for name */
    VARARG(name,unicode_str);     /* object name */
3507
@END
3508

3509

3510 3511 3512 3513 3514 3515 3516 3517 3518
/* Query object type name information */
@REQ(get_object_type)
    obj_handle_t   handle;        /* handle to the object */
@REPLY
    data_size_t    total;         /* needed size for type name */
    VARARG(type,unicode_str);     /* type name */
@END


3519 3520 3521 3522 3523 3524
/* Unlink a named object */
@REQ(unlink_object)
    obj_handle_t   handle;        /* handle to the object */
@END


3525 3526 3527 3528 3529 3530
/* 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
3531 3532 3533 3534 3535 3536

/* Allocate a locally-unique identifier */
@REQ(allocate_locally_unique_id)
@REPLY
    luid_t         luid;
@END
3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552


/* 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 */
3553
    client_ptr_t user_ptr;        /* opaque ptr for use by client */
3554
    obj_handle_t manager;         /* device manager */
3555 3556 3557 3558 3559 3560 3561 3562 3563 3564
    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
3565 3566


3567
/* Retrieve the next pending device irp request */
3568 3569
@REQ(get_next_device_request)
    obj_handle_t manager;         /* handle to the device manager */
3570 3571
    obj_handle_t prev;            /* handle to the previous irp */
    unsigned int status;          /* status of the previous irp */
3572
@REPLY
3573 3574
    irp_params_t params;          /* irp parameters */
    obj_handle_t next;            /* handle to the next irp */
3575 3576
    process_id_t client_pid;      /* pid of process calling irp */
    thread_id_t  client_tid;      /* tid of thread calling irp */
3577 3578
    data_size_t  in_size;         /* total needed input size */
    data_size_t  out_size;        /* needed output size */
3579
    VARARG(next_data,bytes);      /* input data of the next irp */
3580
@END
3581 3582 3583 3584 3585 3586 3587


/* 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
3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600


/* 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
3601 3602 3603 3604 3605 3606


/* Create I/O completion port */
@REQ(create_completion)
    unsigned int access;          /* desired access to a port */
    unsigned int concurrent;      /* max number of concurrent active threads */
3607
    VARARG(objattr,object_attributes); /* object attributes */
3608 3609 3610 3611 3612 3613 3614 3615 3616 3617
@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 */
3618
    VARARG(filename,unicode_str); /* port name */
3619 3620 3621 3622 3623 3624 3625 3626
@REPLY
    obj_handle_t handle;          /* port handle */
@END


/* add completion to completion port */
@REQ(add_completion)
    obj_handle_t  handle;         /* port handle */
3627 3628
    apc_param_t   ckey;           /* completion key */
    apc_param_t   cvalue;         /* completion value */
3629
    apc_param_t   information;    /* IO_STATUS_BLOCK Information */
3630 3631 3632 3633 3634 3635 3636 3637
    unsigned int  status;         /* completion result */
@END


/* get completion from completion port queue */
@REQ(remove_completion)
    obj_handle_t handle;          /* port handle */
@REPLY
3638 3639
    apc_param_t   ckey;           /* completion key */
    apc_param_t   cvalue;         /* completion value */
3640
    apc_param_t   information;    /* IO_STATUS_BLOCK Information */
3641 3642 3643 3644 3645 3646 3647 3648 3649 3650
    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
3651 3652 3653 3654 3655


/* associate object with completion port */
@REQ(set_completion_info)
    obj_handle_t  handle;         /* object handle */
3656
    apc_param_t   ckey;           /* completion key */
3657
    obj_handle_t  chandle;        /* port handle */
3658
@END
3659 3660 3661 3662 3663


/* check for associated completion and push msg */
@REQ(add_fd_completion)
    obj_handle_t   handle;        /* async' object */
3664
    apc_param_t    cvalue;        /* completion value */
3665
    apc_param_t    information;   /* IO_STATUS_BLOCK Information */
3666 3667
    unsigned int   status;        /* completion status */
@END
3668 3669


3670 3671
/* set fd disposition information */
@REQ(set_fd_disp_info)
3672 3673 3674 3675 3676
    obj_handle_t handle;          /* handle to a file or directory */
    int          unlink;          /* whether to unlink file on close */
@END


3677 3678 3679 3680
/* set fd name information */
@REQ(set_fd_name_info)
    obj_handle_t handle;          /* handle to a file or directory */
    obj_handle_t rootdir;         /* root directory */
3681
    int          link;            /* link instead of renaming */
3682 3683 3684 3685
    VARARG(filename,string);      /* new file name */
@END


3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702
/* 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
3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715


/* Allocate an arbitrary user handle */
@REQ(alloc_user_handle)
@REPLY
    user_handle_t  handle;        /* allocated handle */
@END


/* Free an arbitrary user handle */
@REQ(free_user_handle)
    user_handle_t  handle;        /* handle to free*/
@END
3716 3717 3718 3719 3720 3721 3722


/* Set/get the current cursor */
@REQ(set_cursor)
    unsigned int   flags;         /* flags for fields to set (see below) */
    user_handle_t  handle;        /* handle to the cursor */
    int            show_count;    /* show count increment/decrement */
3723 3724
    int            x;             /* cursor position */
    int            y;
3725
    rectangle_t    clip;          /* cursor clip rectangle */
3726
    unsigned int   clip_msg;      /* message to post on cursor clip changes */
3727 3728 3729
@REPLY
    user_handle_t  prev_handle;   /* previous handle */
    int            prev_count;    /* previous show count */
3730 3731
    int            prev_x;        /* previous position */
    int            prev_y;
3732 3733
    int            new_x;         /* new position */
    int            new_y;
3734
    rectangle_t    new_clip;      /* new clip rectangle */
3735
    unsigned int   last_change;   /* time of last position change */
3736 3737 3738
@END
#define SET_CURSOR_HANDLE 0x01
#define SET_CURSOR_COUNT  0x02
3739
#define SET_CURSOR_POS    0x04
3740
#define SET_CURSOR_CLIP   0x08
3741
#define SET_CURSOR_NOCLIP 0x10
3742 3743


3744 3745 3746 3747 3748 3749
/* Modify the list of registered rawinput devices */
@REQ(update_rawinput_devices)
    VARARG(devices,rawinput_devices);
@END


3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760
/* Retrieve the suspended context of a thread */
@REQ(get_suspend_context)
@REPLY
    VARARG(context,context);   /* thread context */
@END


/* Store the suspend context of a thread */
@REQ(set_suspend_context)
    VARARG(context,context);   /* thread context */
@END
3761 3762 3763 3764 3765 3766 3767 3768 3769


/* Create a new job object */
@REQ(create_job)
    unsigned int access;          /* wanted access rights */
    VARARG(objattr,object_attributes); /* object attributes */
@REPLY
    obj_handle_t handle;          /* handle to the job */
@END
3770 3771


3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782
/* Open a job object */
@REQ(open_job)
    unsigned int access;          /* wanted access rights */
    unsigned int attributes;      /* object attributes */
    obj_handle_t rootdir;         /* root directory */
    VARARG(name,unicode_str);     /* object name */
@REPLY
    obj_handle_t handle;          /* handle to the job */
@END


3783 3784 3785 3786 3787
/* Assign a job object to a process */
@REQ(assign_job)
    obj_handle_t job;             /* handle to the job */
    obj_handle_t process;         /* handle to the process */
@END
3788 3789 3790 3791 3792 3793 3794


/* Check if a process is associated with a job */
@REQ(process_in_job)
    obj_handle_t job;             /* handle to the job */
    obj_handle_t process;         /* handle to the process */
@END
3795 3796 3797 3798 3799 3800 3801


/* Set limit flags on a job */
@REQ(set_job_limits)
    obj_handle_t handle;          /* handle to the job */
    unsigned int limit_flags;     /* new limit flags */
@END
3802 3803 3804 3805 3806 3807 3808 3809


/* Set new completion port for a job */
@REQ(set_job_completion_port)
    obj_handle_t job;             /* handle to the job */
    obj_handle_t port;            /* handle to the completion port */
    client_ptr_t key;             /* key to send with completion messages */
@END
3810 3811 3812 3813 3814 3815 3816


/* Terminate all processes associated with the job  */
@REQ(terminate_job)
    obj_handle_t handle;          /* handle to the job */
    int          status;          /* process exit code */
@END