protocol.def 120 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 272 273
    client_ptr_t    callback;      /* client-side callback to call upon end of async */
    client_ptr_t    iosb;          /* I/O status block in client addr space */
    client_ptr_t    arg;           /* opaque user data to pass to callback */
274
    apc_param_t     cvalue;        /* completion value to use for completion events */
275 276
} async_data_t;

277
/* structures for extra message data */
278

279 280 281 282 283 284
struct hardware_msg_data
{
    lparam_t        info;      /* extra info */
    int             x;         /* x position */
    int             y;         /* y position */
    unsigned int    hw_id;     /* unique id */
285
    unsigned int    flags;     /* hook flags */
286 287 288 289
    union
    {
        int type;
        struct
290 291 292 293 294 295 296
        {
            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
297 298 299 300 301 302 303
        {
            int            type;    /* RIM_TYPEMOUSE */
            int            x;       /* x coordinate */
            int            y;       /* y coordinate */
            unsigned int   data;    /* mouse data */
        } mouse;
    } rawinput;
304 305
};

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

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

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 349 350
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;

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

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

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

374 375 376 377 378 379
typedef struct
{
    unsigned int low_part;
    int          high_part;
} luid_t;

380 381 382 383 384
#define MAX_ACL_LEN 65535

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

struct object_attributes
{
    obj_handle_t rootdir; /* root directory */
    data_size_t sd_len;   /* length of security_descriptor data. may be 0 */
399
    data_size_t name_len; /* length of the name string. may be 0 */
400 401
    /* VARARG(sd,security_descriptor); */
    /* VARARG(name,unicode_str); */
402 403
};

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

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

typedef union
{
    enum select_op op;
    struct
    {
426
        enum select_op  op;      /* SELECT_WAIT or SELECT_WAIT_ALL */
427 428
        obj_handle_t    handles[MAXIMUM_WAIT_OBJECTS];
    } wait;
429 430 431 432 433 434
    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;
435 436 437 438 439 440
    struct
    {
        enum select_op  op;      /* SELECT_KEYED_EVENT_WAIT or SELECT_KEYED_EVENT_RELEASE */
        obj_handle_t    handle;
        client_ptr_t    key;
    } keyed_event;
441 442
} select_op_t;

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

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

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

652 653 654 655 656 657 658 659
struct rawinput_device
{
    unsigned short usage_page;
    unsigned short usage;
    unsigned int   flags;
    user_handle_t  target;
};

660 661 662 663 664
/****************************************************************/
/* Request declarations */

/* Create a new process from the context of the parent */
@REQ(new_process)
665 666 667 668 669 670 671 672
    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 */
673
    cpu_type_t   cpu;            /* CPU that the new process will use */
674 675
    data_size_t  info_size;      /* size of startup info */
    VARARG(info,startup_info,info_size); /* startup information */
676
    VARARG(env,unicode_str);     /* environment for new process */
677
@REPLY
678 679 680 681 682
    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) */
683 684 685 686 687
@END


/* Retrieve information about a newly started process */
@REQ(get_new_process_info)
688
    obj_handle_t info;           /* info handle returned from new_process_request */
689
@REPLY
690
    int          success;      /* did the process start successfully? */
691
    int          exit_code;    /* process exit code if failed */
692 693 694 695 696
@END


/* Create a new thread from the context of the parent */
@REQ(new_thread)
697 698
    unsigned int access;       /* wanted access rights */
    unsigned int attributes;   /* object attributes */
699 700 701
    int          suspend;      /* new thread should be suspended on creation */
    int          request_fd;   /* fd for request pipe */
@REPLY
702
    thread_id_t  tid;          /* thread id */
703
    obj_handle_t handle;       /* thread handle (in the current process) */
704 705 706
@END


707 708 709
/* Retrieve the new process startup info */
@REQ(get_startup_info)
@REPLY
710
    obj_handle_t exe_file;     /* file handle for main exe */
711 712
    data_size_t  info_size;    /* size of startup info */
    VARARG(info,startup_info,info_size); /* startup information */
713
    VARARG(env,unicode_str);   /* environment */
714 715 716 717 718
@END


/* Signal the end of the process initialization */
@REQ(init_process_done)
719
    int          gui;          /* is it a GUI process? */
720
    mod_handle_t module;       /* main module base address */
721
    client_ptr_t ldt_copy;     /* address of LDT copy (in thread address space) */
722
    client_ptr_t entry;        /* process entry point */
723 724 725 726 727 728
@END


/* Initialize a thread; called from the child after fork()/clone() */
@REQ(init_thread)
    int          unix_pid;     /* Unix pid of new thread */
729
    int          unix_tid;     /* Unix tid of new thread */
730
    int          debug_level;  /* new debug level */
731
    client_ptr_t teb;          /* TEB of new thread (in thread address space) */
732
    client_ptr_t entry;        /* entry point or PEB if initial thread (in thread address space) */
733 734
    int          reply_fd;     /* fd for reply pipe */
    int          wait_fd;      /* fd for blocking calls pipe */
735
    cpu_type_t   cpu;          /* CPU that this thread is running on */
736
@REPLY
737 738
    process_id_t pid;          /* process id of the new thread's process */
    thread_id_t  tid;          /* thread id of the new thread */
739
    timeout_t    server_start; /* server start time */
740
    data_size_t  info_size;    /* total size of startup info */
741
    int          version;      /* protocol version */
742
    unsigned int all_cpus;     /* bitset of supported CPUs */
743 744 745 746 747
@END


/* Terminate a process */
@REQ(terminate_process)
748
    obj_handle_t handle;       /* process handle to terminate */
749 750 751 752 753 754 755 756
    int          exit_code;    /* process exit code */
@REPLY
    int          self;         /* suicide? */
@END


/* Terminate a thread */
@REQ(terminate_thread)
757
    obj_handle_t handle;       /* thread handle to terminate */
758 759 760 761 762 763 764 765 766
    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)
767
    obj_handle_t handle;           /* process handle */
768
@REPLY
769
    process_id_t pid;              /* server process id */
770
    process_id_t ppid;             /* server process id of parent */
771
    affinity_t   affinity;         /* process affinity mask */
772
    client_ptr_t peb;              /* PEB address in process address space */
773 774
    timeout_t    start_time;       /* process start time */
    timeout_t    end_time;         /* process end time */
775
    int          exit_code;        /* process exit code */
776
    int          priority;         /* priority class */
777
    cpu_type_t   cpu;              /* CPU that this process is running on */
778
    int          debugger_present; /* process is being debugged */
779 780 781
@END


782
/* Set a process information */
783
@REQ(set_process_info)
784
    obj_handle_t handle;       /* process handle */
785 786
    int          mask;         /* setting mask (see below) */
    int          priority;     /* priority class */
787
    affinity_t   affinity;     /* affinity mask */
788 789 790 791 792 793 794
@END
#define SET_PROCESS_INFO_PRIORITY 0x01
#define SET_PROCESS_INFO_AFFINITY 0x02


/* Retrieve information about a thread */
@REQ(get_thread_info)
795 796
    obj_handle_t handle;        /* thread handle */
    thread_id_t  tid_in;        /* thread id (optional) */
797
@REPLY
798
    process_id_t pid;           /* server process id */
799
    thread_id_t  tid;           /* server thread id */
800
    client_ptr_t teb;           /* thread teb pointer */
801
    affinity_t   affinity;      /* thread affinity mask */
802 803
    timeout_t    creation_time; /* thread creation time */
    timeout_t    exit_time;     /* thread exit time */
804
    int          exit_code;     /* thread exit code */
805
    int          priority;      /* thread priority level */
806
    int          last;          /* last thread in process */
807 808 809
@END


810
/* Set a thread information */
811
@REQ(set_thread_info)
812
    obj_handle_t handle;       /* thread handle */
813 814
    int          mask;         /* setting mask (see below) */
    int          priority;     /* priority class */
815
    affinity_t   affinity;     /* affinity mask */
816
    obj_handle_t token;        /* impersonation token */
817 818 819
@END
#define SET_THREAD_INFO_PRIORITY 0x01
#define SET_THREAD_INFO_AFFINITY 0x02
820
#define SET_THREAD_INFO_TOKEN    0x04
821 822


823 824 825
/* Retrieve information about a module */
@REQ(get_dll_info)
    obj_handle_t handle;       /* process handle */
826
    mod_handle_t base_address; /* base address of module */
827
@REPLY
828
    client_ptr_t entry_point;
829
    data_size_t  size;            /* module size */
830
    data_size_t  filename_len;    /* buffer len in bytes required to store filename */
831
    VARARG(filename,unicode_str); /* file name of module */
832 833 834
@END


835 836
/* Suspend a thread */
@REQ(suspend_thread)
837
    obj_handle_t handle;       /* thread handle */
838 839 840 841 842 843 844
@REPLY
    int          count;        /* new suspend count */
@END


/* Resume a thread */
@REQ(resume_thread)
845
    obj_handle_t handle;       /* thread handle */
846 847 848 849 850 851 852
@REPLY
    int          count;        /* new suspend count */
@END


/* Notify the server that a dll has been loaded */
@REQ(load_dll)
853
    obj_handle_t mapping;      /* file mapping handle */
854
    mod_handle_t base;         /* base address */
855
    client_ptr_t name;         /* ptr to ptr to name (in process addr space) */
856
    data_size_t  size;         /* dll size */
857 858
    int          dbg_offset;   /* debug info offset */
    int          dbg_size;     /* debug info size */
859
    VARARG(filename,unicode_str); /* file name of dll */
860 861 862 863 864
@END


/* Notify the server that a dll is being unloaded */
@REQ(unload_dll)
865
    mod_handle_t base;         /* base address */
866 867 868
@END


869
/* Queue an APC for a thread or process */
870
@REQ(queue_apc)
871
    obj_handle_t handle;       /* thread or process handle */
872
    apc_call_t   call;         /* call arguments */
873 874
@REPLY
    obj_handle_t handle;       /* APC handle */
875
    int          self;         /* run APC in caller itself? */
876 877 878
@END


879 880 881 882 883 884 885 886
/* 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


887 888
/* Close a handle for the current process */
@REQ(close_handle)
889
    obj_handle_t handle;       /* handle to close */
890 891 892 893 894
@END


/* Set a handle information */
@REQ(set_handle_info)
895
    obj_handle_t handle;       /* handle we are interested in */
896 897 898 899
    int          flags;        /* new handle flags */
    int          mask;         /* mask for flags to set */
@REPLY
    int          old_flags;    /* old flag value */
900 901 902
@END


903 904
/* Duplicate a handle */
@REQ(dup_handle)
905 906 907
    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 */
908
    unsigned int access;       /* wanted access rights */
909 910
    unsigned int attributes;   /* object attributes */
    unsigned int options;      /* duplicate options (see below) */
911
@REPLY
912
    obj_handle_t handle;       /* duplicated handle in dst process */
913
    int          self;         /* is the source the current process? */
914
    int          closed;       /* whether the source handle has been closed */
915 916 917 918 919 920 921 922
@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)
923
    process_id_t pid;          /* process id to open */
924
    unsigned int access;       /* wanted access rights */
925
    unsigned int attributes;   /* object attributes */
926
@REPLY
927
    obj_handle_t handle;       /* handle to the process */
928 929 930
@END


931 932
/* Open a handle to a thread */
@REQ(open_thread)
933
    thread_id_t  tid;          /* thread id to open */
934
    unsigned int access;       /* wanted access rights */
935
    unsigned int attributes;   /* object attributes */
936
@REPLY
937
    obj_handle_t handle;       /* handle to the thread */
938 939 940
@END


941 942 943
/* Wait for handles */
@REQ(select)
    int          flags;        /* wait flags (see below) */
944
    client_ptr_t cookie;       /* magic cookie to return to client */
945
    timeout_t    timeout;      /* timeout */
946
    obj_handle_t prev_apc;     /* handle to previous APC */
947
    VARARG(result,apc_result); /* result of previous APC */
948
    VARARG(data,select_op);    /* operation-specific data */
949 950
@REPLY
    timeout_t    timeout;      /* timeout converted to absolute */
951
    apc_call_t   call;         /* APC call arguments */
952
    obj_handle_t apc_handle;   /* handle to next APC */
953
@END
954 955
#define SELECT_ALERTABLE     1
#define SELECT_INTERRUPTIBLE 2
956 957 958 959


/* Create an event */
@REQ(create_event)
960
    unsigned int access;        /* wanted access rights */
961
    unsigned int attributes;    /* object attributes */
962 963
    int          manual_reset;  /* manual reset event */
    int          initial_state; /* initial state of the event */
964
    VARARG(objattr,object_attributes); /* object attributes */
965
@REPLY
966
    obj_handle_t handle;        /* handle to the event */
967 968 969 970
@END

/* Event operation */
@REQ(event_op)
971
    obj_handle_t  handle;       /* handle to event */
972 973 974 975
    int           op;           /* event operation (see below) */
@END
enum event_op { PULSE_EVENT, SET_EVENT, RESET_EVENT };

976 977 978 979 980 981
@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
982 983 984 985

/* Open an event */
@REQ(open_event)
    unsigned int access;        /* wanted access rights */
986
    unsigned int attributes;    /* object attributes */
987
    obj_handle_t rootdir;       /* root directory */
988 989
    VARARG(name,unicode_str);   /* object name */
@REPLY
990
    obj_handle_t handle;        /* handle to the event */
991 992 993
@END


994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
/* Create a keyed event */
@REQ(create_keyed_event)
    unsigned int access;        /* wanted access rights */
    unsigned int attributes;    /* object attributes */
    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


1014 1015
/* Create a mutex */
@REQ(create_mutex)
1016
    unsigned int access;        /* wanted access rights */
1017
    unsigned int attributes;    /* object attributes */
1018
    int          owned;         /* initially owned? */
1019
    VARARG(objattr,object_attributes); /* object attributes */
1020
@REPLY
1021
    obj_handle_t handle;        /* handle to the mutex */
1022 1023 1024 1025 1026
@END


/* Release a mutex */
@REQ(release_mutex)
1027
    obj_handle_t handle;        /* handle to the mutex */
1028 1029
@REPLY
    unsigned int prev_count;    /* value of internal counter, before release */
1030 1031 1032 1033 1034 1035
@END


/* Open a mutex */
@REQ(open_mutex)
    unsigned int access;        /* wanted access rights */
1036
    unsigned int attributes;    /* object attributes */
1037
    obj_handle_t rootdir;       /* root directory */
1038 1039
    VARARG(name,unicode_str);   /* object name */
@REPLY
1040
    obj_handle_t handle;        /* handle to the mutex */
1041 1042 1043 1044 1045
@END


/* Create a semaphore */
@REQ(create_semaphore)
1046
    unsigned int access;        /* wanted access rights */
1047
    unsigned int attributes;    /* object attributes */
1048 1049
    unsigned int initial;       /* initial count */
    unsigned int max;           /* maximum count */
1050
    VARARG(objattr,object_attributes); /* object attributes */
1051
@REPLY
1052
    obj_handle_t handle;        /* handle to the semaphore */
1053 1054 1055 1056 1057
@END


/* Release a semaphore */
@REQ(release_semaphore)
1058
    obj_handle_t handle;        /* handle to the semaphore */
1059 1060 1061 1062 1063
    unsigned int count;         /* count to add to semaphore */
@REPLY
    unsigned int prev_count;    /* previous semaphore count */
@END

1064 1065 1066 1067 1068 1069
@REQ(query_semaphore)
    obj_handle_t handle;       /* handle to the semaphore */
@REPLY
    unsigned int current;      /* current count */
    unsigned int max;          /* maximum count */
@END
1070 1071 1072 1073

/* Open a semaphore */
@REQ(open_semaphore)
    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 semaphore */
1079 1080 1081 1082 1083 1084
@END


/* Create a file */
@REQ(create_file)
    unsigned int access;        /* wanted access rights */
1085
    unsigned int attributes;    /* object attributes */
1086 1087
    unsigned int sharing;       /* sharing flags */
    int          create;        /* file create action */
1088
    unsigned int options;       /* file options */
1089
    unsigned int attrs;         /* file attributes for creation */
1090
    VARARG(objattr,object_attributes); /* object attributes */
1091 1092
    VARARG(filename,string);    /* file name */
@REPLY
1093
    obj_handle_t handle;        /* handle to the file */
1094 1095 1096
@END


1097 1098 1099 1100 1101 1102
/* 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 */
1103
    unsigned int options;       /* file options */
1104 1105 1106 1107 1108 1109
    VARARG(filename,unicode_str); /* file name */
@REPLY
    obj_handle_t handle;        /* handle to the file */
@END


1110 1111 1112
/* Allocate a file handle for a Unix fd */
@REQ(alloc_file_handle)
    unsigned int access;        /* wanted access rights */
1113
    unsigned int attributes;    /* object attributes */
1114 1115
    int          fd;            /* file descriptor on the client side */
@REPLY
1116
    obj_handle_t handle;        /* handle to the file */
1117 1118 1119
@END


1120 1121 1122 1123 1124 1125 1126 1127 1128
/* 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


1129 1130
/* Get a Unix fd to access a file */
@REQ(get_handle_fd)
1131
    obj_handle_t handle;        /* handle to the file */
1132
@REPLY
1133
    int          type;          /* file type (see below) */
1134
    int          cacheable;     /* can fd be cached in the client? */
1135 1136
    unsigned int access;        /* file access rights */
    unsigned int options;       /* file open options */
1137
@END
1138 1139 1140 1141 1142 1143 1144 1145 1146
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 */
1147
    FD_TYPE_CHAR,     /* unspecified char device */
1148 1149 1150
    FD_TYPE_DEVICE,   /* Windows device file */
    FD_TYPE_NB_TYPES
};
1151

1152 1153 1154

/* Flush a file buffers */
@REQ(flush_file)
1155
    obj_handle_t handle;        /* handle to the file */
1156 1157
@REPLY
    obj_handle_t event;         /* event set when finished */
1158 1159 1160 1161 1162
@END


/* Lock a region of a file */
@REQ(lock_file)
1163
    obj_handle_t handle;        /* handle to the file */
1164 1165
    file_pos_t   offset;        /* offset of start of lock */
    file_pos_t   count;         /* count of bytes to lock */
1166 1167 1168 1169 1170
    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? */
1171 1172 1173 1174 1175
@END


/* Unlock a region of a file */
@REQ(unlock_file)
1176
    obj_handle_t handle;        /* handle to the file */
1177 1178
    file_pos_t   offset;        /* offset of start of unlock */
    file_pos_t   count;         /* count of bytes to unlock */
1179 1180 1181 1182 1183 1184
@END


/* Create a socket */
@REQ(create_socket)
    unsigned int access;        /* wanted access rights */
1185
    unsigned int attributes;    /* object attributes */
1186 1187 1188
    int          family;        /* family, see socket manpage */
    int          type;          /* type, see socket manpage */
    int          protocol;      /* protocol, see socket manpage */
1189
    unsigned int flags;         /* socket flags */
1190
@REPLY
1191
    obj_handle_t handle;        /* handle to the new socket */
1192 1193 1194 1195 1196
@END


/* Accept a socket */
@REQ(accept_socket)
1197
    obj_handle_t lhandle;       /* handle to the listening socket */
1198
    unsigned int access;        /* wanted access rights */
1199
    unsigned int attributes;    /* object attributes */
1200
@REPLY
1201
    obj_handle_t handle;        /* handle to the new socket */
1202 1203 1204
@END


1205 1206 1207 1208 1209 1210 1211
/* 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


1212 1213
/* Set socket event parameters */
@REQ(set_socket_event)
1214
    obj_handle_t  handle;        /* handle to the socket */
1215
    unsigned int  mask;          /* event mask */
1216
    obj_handle_t  event;         /* event object */
1217 1218
    user_handle_t window;        /* window to send the message to */
    unsigned int  msg;           /* message to send */
1219 1220 1221 1222 1223
@END


/* Get socket event parameters */
@REQ(get_socket_event)
1224
    obj_handle_t handle;        /* handle to the socket */
1225
    int          service;       /* clear pending? */
1226
    obj_handle_t c_event;       /* event to clear */
1227 1228 1229 1230 1231 1232 1233 1234
@REPLY
    unsigned int mask;          /* event mask */
    unsigned int pmask;         /* pending events */
    unsigned int state;         /* status bits */
    VARARG(errors,ints);        /* event errors */
@END


1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
/* 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


1245
/* Re-enable pending socket events */
1246
@REQ(enable_socket_event)
1247
    obj_handle_t handle;        /* handle to the socket */
1248 1249 1250 1251 1252
    unsigned int mask;          /* events to re-enable */
    unsigned int sstate;        /* status bits to set */
    unsigned int cstate;        /* status bits to clear */
@END

1253
@REQ(set_socket_deferred)
1254 1255
    obj_handle_t handle;        /* handle to the socket */
    obj_handle_t deferred;      /* handle to the socket for which accept() is deferred */
1256
@END
1257

1258
/* Allocate a console (only used by a console renderer) */
1259 1260
@REQ(alloc_console)
    unsigned int access;        /* wanted access rights */
1261
    unsigned int attributes;    /* object attributes */
1262
    process_id_t pid;           /* pid of process which shall be attached to the console */
1263
    int          input_fd;      /* if pid=-1 (bare console to current process), fd for input */
1264
@REPLY
1265 1266
    obj_handle_t handle_in;     /* handle to console input */
    obj_handle_t event;         /* handle to renderer events change notification */
1267 1268 1269 1270 1271 1272 1273 1274
@END


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


1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320
#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)
1321
    obj_handle_t handle;        /* handle to console input events */
1322 1323 1324 1325 1326
@REPLY
    VARARG(data,bytes);         /* the various console_renderer_events */
@END


1327 1328
/* Open a handle to the process console */
@REQ(open_console)
1329
    obj_handle_t from;          /* 0 (resp 1) input (resp output) of current process console */
1330
                                /* otherwise console_in handle to get active screen buffer? */
1331
    unsigned int access;        /* wanted access rights */
1332
    unsigned int attributes;    /* object attributes */
1333
    int          share;         /* share mask (only for output handles) */
1334
@REPLY
1335
    obj_handle_t handle;        /* handle to the console */
1336 1337 1338
@END


1339 1340 1341 1342 1343 1344
/* Get the input queue wait event */
@REQ(get_console_wait_event)
@REPLY
    obj_handle_t handle;
@END

1345 1346
/* Get a console mode (input or output) */
@REQ(get_console_mode)
1347
    obj_handle_t handle;        /* handle to the console */
1348 1349 1350 1351 1352 1353 1354
@REPLY
    int          mode;          /* console mode */
@END


/* Set a console mode (input or output) */
@REQ(set_console_mode)
1355
    obj_handle_t handle;        /* handle to the console */
1356 1357 1358 1359
    int          mode;          /* console mode */
@END


1360 1361
/* Set info about a console (input only) */
@REQ(set_console_input_info)
1362 1363 1364 1365 1366 1367 1368 1369 1370 1371
    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 */
1372 1373 1374 1375 1376
@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
1377
#define SET_CONSOLE_INPUT_INFO_EDITION_MODE     0x10
1378 1379
#define SET_CONSOLE_INPUT_INFO_INPUT_CODEPAGE   0x20
#define SET_CONSOLE_INPUT_INFO_OUTPUT_CODEPAGE  0x40
1380
#define SET_CONSOLE_INPUT_INFO_WIN              0x80
1381 1382 1383 1384


/* Get info about a console (input only) */
@REQ(get_console_input_info)
1385
    obj_handle_t  handle;         /* handle to console input, or 0 for process' console */
1386
@REPLY
1387 1388 1389 1390 1391 1392 1393 1394
    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 */
1395 1396 1397 1398 1399
@END


/* appends a string to console's history */
@REQ(append_console_input_history)
1400
    obj_handle_t handle;        /* handle to console input, or 0 for process' console */
1401 1402 1403 1404 1405 1406
    VARARG(line,unicode_str);   /* line to add */
@END


/* appends a string to console's history */
@REQ(get_console_input_history)
1407
    obj_handle_t handle;        /* handle to console input, or 0 for process' console */
1408 1409
    int          index;         /* index to get line from */
@REPLY
1410
    int          total;         /* total length of line in Unicode chars */
1411 1412 1413 1414 1415 1416
    VARARG(line,unicode_str);   /* line to add */
@END


/* creates a new screen buffer on process' console */
@REQ(create_console_output)
1417
    obj_handle_t handle_in;     /* handle to console input, or 0 for process' console */
1418 1419 1420
    unsigned int access;        /* wanted access rights */
    unsigned int attributes;    /* object attributes */
    unsigned int share;         /* sharing credentials */
1421
    int          fd;            /* for bare consoles, fd the screen-buffer is attached to */
1422
@REPLY
1423
    obj_handle_t handle_out;    /* handle to the screen buffer */
1424 1425 1426
@END


1427
/* Set info about a console (output only) */
1428
@REQ(set_console_output_info)
1429
    obj_handle_t handle;        /* handle to the console */
1430
    int          mask;          /* setting mask (see below) */
1431 1432 1433 1434 1435 1436 1437 1438
    short int    cursor_size;   /* size of cursor (percentage filled) */
    short int    cursor_visible;/* cursor visibility flag */
    short int    cursor_x;      /* position of cursor (x, y) */
    short int    cursor_y;
    short int    width;         /* width of the screen buffer */
    short int    height;        /* height of the screen buffer */
    short int    attr;          /* default attribute */
    short int    win_left;      /* window actually displayed by renderer */
1439
    short int    win_top;       /* the rect area is expressed within the */
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
    short int    win_right;     /* boundaries of the screen buffer */
    short int    win_bottom;
    short int    max_width;     /* maximum size (width x height) for the window */
    short int    max_height;
@END
#define SET_CONSOLE_OUTPUT_INFO_CURSOR_GEOM     0x01
#define SET_CONSOLE_OUTPUT_INFO_CURSOR_POS      0x02
#define SET_CONSOLE_OUTPUT_INFO_SIZE            0x04
#define SET_CONSOLE_OUTPUT_INFO_ATTR            0x08
#define SET_CONSOLE_OUTPUT_INFO_DISPLAY_WINDOW  0x10
#define SET_CONSOLE_OUTPUT_INFO_MAX_SIZE        0x20

1452 1453

/* Get info about a console (output only) */
1454
@REQ(get_console_output_info)
1455
    obj_handle_t handle;        /* handle to the console */
1456
@REPLY
1457 1458 1459 1460 1461 1462 1463 1464
    short int    cursor_size;   /* size of cursor (percentage filled) */
    short int    cursor_visible;/* cursor visibility flag */
    short int    cursor_x;      /* position of cursor (x, y) */
    short int    cursor_y;
    short int    width;         /* width of the screen buffer */
    short int    height;        /* height of the screen buffer */
    short int    attr;          /* default attribute */
    short int    win_left;      /* window actually displayed by renderer */
1465
    short int    win_top;       /* the rect area is expressed within the */
1466 1467 1468 1469
    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;
1470 1471 1472 1473
@END

/* Add input records to a console input queue */
@REQ(write_console_input)
1474
    obj_handle_t handle;        /* handle to the console input */
1475 1476 1477 1478 1479
    VARARG(rec,input_records);  /* input records */
@REPLY
    int          written;       /* number of records written */
@END

1480

1481 1482
/* Fetch input records from a console input queue */
@REQ(read_console_input)
1483
    obj_handle_t handle;        /* handle to the console input */
1484 1485 1486 1487 1488 1489 1490
    int          flush;         /* flush the retrieved records from the queue? */
@REPLY
    int          read;          /* number of records read */
    VARARG(rec,input_records);  /* input records */
@END


1491 1492
/* write data (chars and/or attributes) in a screen buffer */
@REQ(write_console_output)
1493
    obj_handle_t handle;        /* handle to the console output */
1494 1495 1496 1497
    int          x;             /* position where to start writing */
    int          y;
    int          mode;          /* char info (see below) */
    int          wrap;          /* wrap around at end of line? */
1498 1499
    VARARG(data,bytes);         /* info to write */
@REPLY
1500 1501 1502
    int          written;       /* number of char infos actually written */
    int          width;         /* width of screen buffer */
    int          height;        /* height of screen buffer */
1503
@END
1504 1505 1506 1507 1508 1509 1510
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 */
};
1511 1512


1513 1514
/* fill a screen buffer with constant data (chars and/or attributes) */
@REQ(fill_console_output)
1515
    obj_handle_t handle;        /* handle to the console output */
1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527
    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 */
1528
@REQ(read_console_output)
1529
    obj_handle_t handle;        /* handle to the console output */
1530 1531 1532 1533
    int          x;             /* position (x,y) where to start reading */
    int          y;
    int          mode;          /* char info mode */
    int          wrap;          /* wrap around at end of line? */
1534
@REPLY
1535 1536
    int          width;         /* width of screen buffer */
    int          height;        /* height of screen buffer */
1537 1538 1539
    VARARG(data,bytes);
@END

1540

1541 1542
/* move a rect (of data) in screen buffer content */
@REQ(move_console_output)
1543
    obj_handle_t handle;        /* handle to the console output */
1544 1545 1546 1547 1548 1549 1550 1551 1552
    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


1553 1554 1555
/* Sends a signal to a process group */
@REQ(send_console_signal)
    int          signal;        /* the signal to send */
1556
    process_id_t group_id;      /* the group to send the signal to */
1557 1558 1559
@END


1560 1561
/* enable directory change notifications */
@REQ(read_directory_changes)
1562
    unsigned int filter;        /* notification filter */
1563
    int          subtree;       /* watch the subtree? */
1564
    int          want_data;     /* flag indicating whether change data should be collected */
1565
    async_data_t async;         /* async I/O parameters */
1566 1567 1568 1569 1570 1571
@END


@REQ(read_change)
    obj_handle_t handle;
@REPLY
1572
    VARARG(events,filesystem_event);  /* collected filesystem events */
1573 1574 1575 1576 1577
@END


/* Create a file mapping */
@REQ(create_mapping)
1578 1579
    unsigned int access;        /* wanted access rights */
    unsigned int attributes;    /* object attributes */
1580
    unsigned int protect;       /* protection flags (see below) */
1581
    mem_size_t   size;          /* mapping size */
1582
    obj_handle_t file_handle;   /* file handle */
1583
    VARARG(objattr,object_attributes); /* object attributes */
1584
@REPLY
1585
    obj_handle_t handle;        /* handle to the mapping */
1586
@END
1587
/* per-page protection flags */
1588 1589 1590 1591 1592 1593 1594
#define VPROT_READ       0x01
#define VPROT_WRITE      0x02
#define VPROT_EXEC       0x04
#define VPROT_WRITECOPY  0x08
#define VPROT_GUARD      0x10
#define VPROT_NOCACHE    0x20
#define VPROT_COMMITTED  0x40
1595
#define VPROT_WRITEWATCH 0x80
1596 1597 1598 1599
/* per-mapping protection flags */
#define VPROT_IMAGE      0x0100  /* mapping for an exe image */
#define VPROT_SYSTEM     0x0200  /* system view (underlying mmap not under our control) */
#define VPROT_VALLOC     0x0400  /* allocated by VirtualAlloc */
1600
#define VPROT_NOEXEC     0x0800  /* don't force exec permission */
1601 1602 1603 1604 1605


/* Open a mapping */
@REQ(open_mapping)
    unsigned int access;        /* wanted access rights */
1606
    unsigned int attributes;    /* object attributes */
1607
    obj_handle_t rootdir;       /* root directory */
1608 1609
    VARARG(name,unicode_str);   /* object name */
@REPLY
1610
    obj_handle_t handle;        /* handle to the mapping */
1611 1612 1613 1614 1615
@END


/* Get information about a file mapping */
@REQ(get_mapping_info)
1616
    obj_handle_t handle;        /* handle to the mapping */
1617
    unsigned int access;        /* wanted access rights */
1618
@REPLY
1619
    mem_size_t   size;          /* mapping size */
1620 1621
    int          protect;       /* protection flags */
    int          header_size;   /* header size (for VPROT_IMAGE mapping) */
1622
    client_ptr_t base;          /* default base addr (for VPROT_IMAGE mapping) */
1623
    obj_handle_t mapping;       /* duplicate mapping handle unless removable */
1624
    obj_handle_t shared_file;   /* shared mapping file handle */
1625 1626 1627
@END


1628 1629 1630 1631 1632
/* Get a range of committed pages in a file mapping */
@REQ(get_mapping_committed_range)
    obj_handle_t handle;        /* handle to the mapping */
    file_pos_t   offset;        /* starting offset (page-aligned, in bytes) */
@REPLY
1633
    mem_size_t   size;          /* size of range starting at offset (page-aligned, in bytes) */
1634 1635 1636 1637 1638 1639 1640 1641
    int          committed;     /* whether it is a committed range */
@END


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


1646 1647
#define SNAP_PROCESS    0x00000001
#define SNAP_THREAD     0x00000002
1648 1649
/* Create a snapshot */
@REQ(create_snapshot)
1650
    unsigned int attributes;    /* object attributes */
1651
    unsigned int flags;         /* snapshot flags (SNAP_*) */
1652
@REPLY
1653
    obj_handle_t handle;        /* handle to the snapshot */
1654 1655 1656 1657 1658
@END


/* Get the next process from a snapshot */
@REQ(next_process)
1659
    obj_handle_t handle;        /* handle to the snapshot */
1660 1661 1662
    int          reset;         /* reset snapshot position? */
@REPLY
    int          count;         /* process usage count */
1663 1664
    process_id_t pid;           /* process id */
    process_id_t ppid;          /* parent process id */
1665 1666
    int          threads;       /* number of threads */
    int          priority;      /* process priority */
1667
    int          handles;       /* number of handles */
1668
    int          unix_pid;      /* Unix pid */
1669
    VARARG(filename,unicode_str); /* file name of main exe */
1670 1671 1672 1673 1674
@END


/* Get the next thread from a snapshot */
@REQ(next_thread)
1675
    obj_handle_t handle;        /* handle to the snapshot */
1676 1677 1678
    int          reset;         /* reset snapshot position? */
@REPLY
    int          count;         /* thread usage count */
1679 1680
    process_id_t pid;           /* process id */
    thread_id_t  tid;           /* thread id */
1681 1682 1683 1684 1685 1686 1687 1688 1689
    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
1690 1691
    process_id_t  pid;         /* process id */
    thread_id_t   tid;         /* thread id */
1692
    obj_handle_t  wait;        /* wait handle if no event ready */
1693 1694 1695 1696 1697 1698
    VARARG(event,debug_event); /* debug event data */
@END


/* Queue an exception event */
@REQ(queue_exception_event)
1699 1700 1701 1702 1703 1704 1705 1706
    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 */
1707
@REPLY
1708
    obj_handle_t     handle;   /* handle to the queued event */
1709 1710 1711 1712 1713
@END


/* Retrieve the status of an exception event */
@REQ(get_exception_status)
1714
    obj_handle_t     handle;   /* handle to the queued event */
1715
@REPLY
1716 1717 1718 1719 1720 1721
    VARARG(context,context);   /* modified thread context */
@END


/* Continue a debug event */
@REQ(continue_debug_event)
1722 1723
    process_id_t pid;          /* process id to continue */
    thread_id_t  tid;          /* thread id to continue */
1724 1725 1726 1727
    int          status;       /* continuation status */
@END


1728
/* Start/stop debugging an existing process */
1729
@REQ(debug_process)
1730
    process_id_t pid;          /* id of the process to debug */
1731 1732 1733 1734
    int          attach;       /* 1=attaching / 0=detaching from the process */
@END


1735 1736
/* Simulate a breakpoint in a process */
@REQ(debug_break)
1737
    obj_handle_t handle;       /* process handle */
1738 1739 1740 1741 1742
@REPLY
    int          self;         /* was it the caller itself? */
@END


1743 1744 1745
/* Set debugger kill on exit flag */
@REQ(set_debugger_kill_on_exit)
    int          kill_on_exit;  /* 0=detach/1=kill debuggee when debugger dies */
1746 1747 1748 1749 1750
@END


/* Read data from a process address space */
@REQ(read_process_memory)
1751
    obj_handle_t handle;       /* process handle */
1752
    client_ptr_t addr;         /* addr to read from */
1753 1754 1755 1756 1757 1758 1759
@REPLY
    VARARG(data,bytes);        /* result data */
@END


/* Write data to a process address space */
@REQ(write_process_memory)
1760
    obj_handle_t handle;       /* process handle */
1761
    client_ptr_t addr;         /* addr to write to */
1762
    VARARG(data,bytes);        /* data to write */
1763 1764 1765 1766 1767
@END


/* Create a registry key */
@REQ(create_key)
1768
    obj_handle_t parent;       /* handle to the parent key */
1769
    unsigned int access;       /* desired access rights */
1770
    unsigned int attributes;   /* object attributes */
1771
    unsigned int options;      /* creation options */
1772
    data_size_t  namelen;      /* length of key name in bytes */
1773 1774
    VARARG(name,unicode_str,namelen);  /* key name */
    VARARG(class,unicode_str);         /* class name */
1775
@REPLY
1776
    obj_handle_t hkey;         /* handle to the created key */
1777 1778 1779 1780 1781
    int          created;      /* has it been newly created? */
@END

/* Open a registry key */
@REQ(open_key)
1782
    obj_handle_t parent;       /* handle to the parent key */
1783
    unsigned int access;       /* desired access rights */
1784
    unsigned int attributes;   /* object attributes */
1785 1786
    VARARG(name,unicode_str);  /* key name */
@REPLY
1787
    obj_handle_t hkey;         /* handle to the open key */
1788 1789 1790 1791 1792
@END


/* Delete a registry key */
@REQ(delete_key)
1793
    obj_handle_t hkey;         /* handle to the key */
1794 1795 1796
@END


1797 1798 1799 1800 1801 1802
/* Flush a registry key */
@REQ(flush_key)
    obj_handle_t hkey;         /* handle to the key */
@END


1803 1804
/* Enumerate registry subkeys */
@REQ(enum_key)
1805
    obj_handle_t hkey;         /* handle to registry key */
1806
    int          index;        /* index of subkey (or -1 for current key) */
1807
    int          info_class;   /* requested information class */
1808 1809 1810 1811 1812 1813 1814
@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 */
1815
    timeout_t    modif;        /* last modification time */
1816 1817
    data_size_t  total;        /* total length needed for full name and class */
    data_size_t  namelen;      /* length of key name in bytes */
1818 1819
    VARARG(name,unicode_str,namelen);  /* key name */
    VARARG(class,unicode_str);         /* class name */
1820 1821 1822 1823 1824
@END


/* Set a value of a registry key */
@REQ(set_key_value)
1825
    obj_handle_t hkey;         /* handle to registry key */
1826
    int          type;         /* value type */
1827
    data_size_t  namelen;      /* length of value name in bytes */
1828 1829
    VARARG(name,unicode_str,namelen);  /* value name */
    VARARG(data,bytes);                /* value data */
1830 1831 1832 1833 1834
@END


/* Retrieve the value of a registry key */
@REQ(get_key_value)
1835
    obj_handle_t hkey;         /* handle to registry key */
1836
    VARARG(name,unicode_str);  /* value name */
1837 1838
@REPLY
    int          type;         /* value type */
1839
    data_size_t  total;        /* total length needed for data */
1840 1841 1842 1843 1844 1845
    VARARG(data,bytes);        /* value data */
@END


/* Enumerate a value of a registry key */
@REQ(enum_key_value)
1846
    obj_handle_t hkey;         /* handle to registry key */
1847
    int          index;        /* value index */
1848
    int          info_class;   /* requested information class */
1849 1850
@REPLY
    int          type;         /* value type */
1851 1852
    data_size_t  total;        /* total length needed for full name and data */
    data_size_t  namelen;      /* length of value name in bytes */
1853 1854
    VARARG(name,unicode_str,namelen);  /* value name */
    VARARG(data,bytes);                /* value data */
1855 1856 1857 1858 1859
@END


/* Delete a value of a registry key */
@REQ(delete_key_value)
1860
    obj_handle_t hkey;         /* handle to registry key */
1861 1862 1863 1864 1865 1866
    VARARG(name,unicode_str);  /* value name */
@END


/* Load a registry branch from a file */
@REQ(load_registry)
1867 1868
    obj_handle_t hkey;         /* root key to load to */
    obj_handle_t file;         /* file to load from */
1869 1870 1871 1872
    VARARG(name,unicode_str);  /* subkey name */
@END


1873 1874 1875 1876 1877 1878
/* UnLoad a registry branch from a file */
@REQ(unload_registry)
    obj_handle_t hkey;         /* root key to unload to */
@END


1879 1880
/* Save a registry branch to a file */
@REQ(save_registry)
1881 1882
    obj_handle_t hkey;         /* key to save */
    obj_handle_t file;         /* file to save to */
1883 1884 1885
@END


1886
/* Add a registry key change notification */
1887 1888 1889 1890 1891 1892 1893 1894
@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


1895 1896
/* Create a waitable timer */
@REQ(create_timer)
1897
    unsigned int access;        /* wanted access rights */
1898
    unsigned int attributes;    /* object attributes */
1899
    obj_handle_t rootdir;       /* root directory */
1900 1901 1902
    int          manual;        /* manual reset */
    VARARG(name,unicode_str);   /* object name */
@REPLY
1903
    obj_handle_t handle;        /* handle to the timer */
1904 1905 1906 1907 1908 1909
@END


/* Open a waitable timer */
@REQ(open_timer)
    unsigned int access;        /* wanted access rights */
1910
    unsigned int attributes;    /* object attributes */
1911
    obj_handle_t rootdir;       /* root directory */
1912 1913
    VARARG(name,unicode_str);   /* object name */
@REPLY
1914
    obj_handle_t handle;        /* handle to the timer */
1915 1916 1917 1918
@END

/* Set a waitable timer */
@REQ(set_timer)
1919
    obj_handle_t handle;        /* handle to the timer */
1920
    timeout_t    expire;        /* next expiration absolute time */
1921 1922
    client_ptr_t callback;      /* callback function */
    client_ptr_t arg;           /* callback argument */
1923
    int          period;        /* timer period in ms */
1924 1925
@REPLY
    int          signaled;      /* was the timer signaled before this call ? */
1926 1927 1928 1929
@END

/* Cancel a waitable timer */
@REQ(cancel_timer)
1930
    obj_handle_t handle;        /* handle to the timer */
1931 1932
@REPLY
     int         signaled;      /* was the timer signaled before this calltime ? */
1933 1934
@END

1935 1936 1937 1938
/* Get information on a waitable timer */
@REQ(get_timer_info)
    obj_handle_t handle;        /* handle to the timer */
@REPLY
1939
    timeout_t    when;          /* absolute time when the timer next expires */
1940 1941 1942
    int          signaled;      /* is the timer signaled? */
@END

1943 1944 1945

/* Retrieve the current context of a thread */
@REQ(get_thread_context)
1946
    obj_handle_t handle;       /* thread handle */
1947
    unsigned int flags;        /* context flags */
1948
    int          suspend;      /* suspend the thread if needed */
1949
@REPLY
1950
    int          self;         /* was it a handle to the current thread? */
1951 1952 1953 1954 1955 1956
    VARARG(context,context);   /* thread context */
@END


/* Set the current context of a thread */
@REQ(set_thread_context)
1957
    obj_handle_t handle;       /* thread handle */
1958
    int          suspend;      /* suspend the thread if needed */
1959
    VARARG(context,context);   /* thread context */
1960 1961
@REPLY
    int          self;         /* was it a handle to the current thread? */
1962 1963 1964 1965 1966
@END


/* Fetch a selector entry for a thread */
@REQ(get_selector_entry)
1967
    obj_handle_t  handle;      /* thread handle */
1968 1969 1970 1971 1972 1973 1974 1975 1976 1977
    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)
1978
    obj_handle_t  table;       /* which table to add atom to */
1979 1980
    VARARG(name,unicode_str);  /* atom name */
@REPLY
1981
    atom_t        atom;        /* resulting atom */
1982 1983 1984 1985 1986
@END


/* Delete an atom */
@REQ(delete_atom)
1987
    obj_handle_t  table;       /* which table to delete atom from */
1988
    atom_t        atom;        /* atom handle */
1989 1990 1991 1992 1993
@END


/* Find an atom */
@REQ(find_atom)
1994
    obj_handle_t table;        /* which table to find atom from */
1995 1996
    VARARG(name,unicode_str);  /* atom name */
@REPLY
1997
    atom_t       atom;         /* atom handle */
1998 1999 2000
@END


2001 2002 2003
/* Get information about an atom */
@REQ(get_atom_information)
    obj_handle_t table;        /* which table to find atom from */
2004
    atom_t       atom;         /* atom handle */
2005 2006
@REPLY
    int          count;        /* atom lock count */
2007
    int          pinned;       /* whether the atom has been pinned */
2008
    data_size_t  total;        /* actual length of atom name */
2009 2010 2011 2012
    VARARG(name,unicode_str);  /* atom name */
@END


2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028
/* 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 */
2029
@REQ(init_atom_table)
2030 2031 2032
    int          entries;      /* number of entries (only for local) */
@REPLY
    obj_handle_t table;        /* handle to the atom table */
2033 2034 2035 2036 2037 2038
@END


/* Get the message queue of the current thread */
@REQ(get_msg_queue)
@REPLY
2039
    obj_handle_t handle;       /* handle to the queue */
2040 2041 2042
@END


2043 2044 2045 2046 2047 2048
/* Set the file descriptor associated to the current thread queue */
@REQ(set_queue_fd)
    obj_handle_t handle;       /* handle to the file descriptor */
@END


2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068
/* Set the current message queue wakeup mask */
@REQ(set_queue_mask)
    unsigned int wake_mask;    /* wakeup bits mask */
    unsigned int changed_mask; /* changed bits mask */
    int          skip_wait;    /* will we skip waiting if signaled? */
@REPLY
    unsigned int wake_bits;    /* current wake bits */
    unsigned int changed_bits; /* current changed bits */
@END


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


2069 2070
/* Retrieve the process idle event */
@REQ(get_process_idle_event)
2071
    obj_handle_t handle;       /* process handle */
2072
@REPLY
2073
    obj_handle_t event;        /* handle to idle event */
2074 2075 2076 2077 2078
@END


/* Send a message to a thread queue */
@REQ(send_message)
2079
    thread_id_t     id;        /* thread id */
2080
    int             type;      /* message type (see below) */
2081
    int             flags;     /* message flags (see below) */
2082
    user_handle_t   win;       /* window handle */
2083
    unsigned int    msg;       /* message code */
2084 2085
    lparam_t        wparam;    /* parameters */
    lparam_t        lparam;    /* parameters */
2086
    timeout_t       timeout;   /* timeout for reply */
2087
    VARARG(data,message_data); /* message data for sent messages */
2088
@END
2089

2090 2091 2092 2093
@REQ(post_quit_message)
    int             exit_code; /* exit code to return */
@END

2094 2095 2096 2097 2098 2099
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 */
2100
    MSG_CALLBACK_RESULT,/* result of a callback message */
2101 2102
    MSG_OTHER_PROCESS,  /* sent from other process, may include vararg data, always Unicode */
    MSG_POSTED,         /* posted message (from PostMessageW), always Unicode */
2103
    MSG_HARDWARE,       /* hardware message */
2104 2105
    MSG_WINEVENT,       /* winevent message */
    MSG_HOOK_LL         /* low-level hardware hook */
2106
};
2107
#define SEND_MSG_ABORT_IF_HUNG  0x01
2108 2109


2110 2111 2112
/* Send a hardware message to a thread queue */
@REQ(send_hardware_message)
    user_handle_t   win;       /* window handle */
2113 2114
    hw_input_t      input;     /* input data */
    unsigned int    flags;     /* flags (see below) */
2115 2116
@REPLY
    int             wait;      /* do we need to wait for a reply? */
2117 2118 2119 2120
    int             prev_x;    /* previous cursor position */
    int             prev_y;
    int             new_x;     /* new cursor position */
    int             new_y;
2121
    VARARG(keystate,bytes);    /* global state array for all the keys */
2122
@END
2123
#define SEND_HWMSG_INJECTED    0x01
2124 2125


2126 2127
/* Get a message from the current queue */
@REQ(get_message)
2128
    unsigned int    flags;     /* PM_* flags */
2129
    user_handle_t   get_win;   /* window handle to get */
2130 2131
    unsigned int    get_first; /* first message code to get */
    unsigned int    get_last;  /* last message code to get */
2132
    unsigned int    hw_id;     /* id of the previous hardware message (or 0) */
2133 2134
    unsigned int    wake_mask; /* wakeup bits mask */
    unsigned int    changed_mask; /* changed bits mask */
2135
@REPLY
2136
    user_handle_t   win;       /* window handle */
2137
    unsigned int    msg;       /* message code */
2138 2139
    lparam_t        wparam;    /* parameters */
    lparam_t        lparam;    /* parameters */
2140
    int             type;      /* message type */
2141
    unsigned int    time;      /* message time */
2142
    unsigned int    active_hooks; /* active hooks bitmap */
2143
    data_size_t     total;     /* total size of extra data */
2144
    VARARG(data,message_data); /* message data for sent messages */
2145
@END
2146

2147 2148 2149 2150

/* Reply to a sent message */
@REQ(reply_message)
    int             remove;    /* should we remove the message? */
2151
    lparam_t        result;    /* message result */
2152
    VARARG(data,bytes);        /* message data for sent messages */
2153 2154 2155
@END


2156 2157
/* Accept the current hardware message */
@REQ(accept_hardware_message)
2158
    unsigned int    hw_id;     /* id of the hardware message */
2159 2160 2161 2162
    int             remove;    /* should we remove the message? */
@END


2163 2164 2165 2166
/* Retrieve the reply for the last message sent */
@REQ(get_message_reply)
    int             cancel;    /* cancel message if not ready? */
@REPLY
2167
    lparam_t        result;    /* message result */
2168
    VARARG(data,bytes);        /* message data for sent messages */
2169 2170 2171 2172 2173
@END


/* Set a window timer */
@REQ(set_win_timer)
2174
    user_handle_t   win;       /* window handle */
2175 2176
    unsigned int    msg;       /* message to post */
    unsigned int    rate;      /* timer rate in ms */
2177 2178
    lparam_t        id;        /* timer id */
    lparam_t        lparam;    /* message lparam (callback proc) */
2179
@REPLY
2180
    lparam_t        id;        /* timer id */
2181 2182 2183 2184 2185
@END


/* Kill a window timer */
@REQ(kill_win_timer)
2186
    user_handle_t   win;       /* window handle */
2187
    lparam_t        id;        /* timer id */
2188
    unsigned int    msg;       /* message to post */
2189 2190 2191
@END


2192 2193 2194 2195 2196 2197 2198 2199
/* check if the thread owning the window is hung */
@REQ(is_window_hung)
    user_handle_t   win;       /* window handle */
@REPLY
    int is_hung;
@END


2200 2201
/* Retrieve info about a serial port */
@REQ(get_serial_info)
2202
    obj_handle_t handle;       /* handle to comm port */
2203
    int          flags;
2204 2205 2206 2207 2208 2209 2210
@REPLY
    unsigned int readinterval;
    unsigned int readconst;
    unsigned int readmult;
    unsigned int writeconst;
    unsigned int writemult;
    unsigned int eventmask;
2211
    unsigned int cookie;
2212
    unsigned int pending_write;
2213 2214 2215 2216 2217
@END


/* Set info about a serial port */
@REQ(set_serial_info)
2218
    obj_handle_t handle;       /* handle to comm port */
2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
    int          flags;        /* bitmask to set values (see below) */
    unsigned int readinterval;
    unsigned int readconst;
    unsigned int readmult;
    unsigned int writeconst;
    unsigned int writemult;
    unsigned int eventmask;
@END
#define SERIALINFO_SET_TIMEOUTS  0x01
#define SERIALINFO_SET_MASK      0x02
2229
#define SERIALINFO_PENDING_WRITE 0x04
2230
#define SERIALINFO_PENDING_WAIT  0x08
2231 2232


2233
/* Create an async I/O */
2234
@REQ(register_async)
2235
    int          type;          /* type of queue to look after */
2236
    async_data_t async;         /* async I/O parameters */
2237
    int          count;         /* count - usually # of bytes to be read/written */
2238 2239 2240 2241 2242 2243
@END
#define ASYNC_TYPE_READ  0x01
#define ASYNC_TYPE_WRITE 0x02
#define ASYNC_TYPE_WAIT  0x03


2244 2245 2246
/* Cancel all async op on a fd */
@REQ(cancel_async)
    obj_handle_t handle;        /* handle to comm port, socket or file */
2247 2248
    client_ptr_t iosb;          /* I/O status block (NULL=all) */
    int          only_thread;   /* cancel matching this thread */
2249 2250 2251
@END


2252 2253
/* Perform an ioctl on a file */
@REQ(ioctl)
2254
    ioctl_code_t   code;          /* ioctl code */
2255
    async_data_t   async;         /* async I/O parameters */
2256
    int            blocking;      /* whether it's a blocking ioctl */
2257 2258
    VARARG(in_data,bytes);        /* ioctl input data */
@REPLY
2259 2260
    obj_handle_t   wait;          /* handle to wait on for blocking ioctl */
    unsigned int   options;       /* device open options */
2261 2262 2263 2264
    VARARG(out_data,bytes);       /* ioctl output data */
@END


2265 2266 2267 2268 2269 2270 2271 2272 2273
/* Store results of an async ioctl */
@REQ(set_ioctl_result)
    obj_handle_t manager;         /* handle to the device manager */
    obj_handle_t handle;          /* handle to the ioctl */
    unsigned int status;          /* status of the ioctl */
    VARARG(data,bytes);           /* output data of the ioctl */
@END


2274 2275 2276
/* Retrieve results of an async ioctl */
@REQ(get_ioctl_result)
    obj_handle_t   handle;        /* handle to the device */
2277
    client_ptr_t   user_arg;      /* user arg used to identify the request */
2278 2279 2280 2281 2282
@REPLY
    VARARG(out_data,bytes);       /* ioctl output data */
@END


2283 2284
/* Create a named pipe */
@REQ(create_named_pipe)
2285
    unsigned int   access;
2286
    unsigned int   attributes;   /* object attributes */
2287
    unsigned int   options;
2288
    unsigned int   sharing;
2289 2290 2291
    unsigned int   maxinstances;
    unsigned int   outsize;
    unsigned int   insize;
2292
    timeout_t      timeout;
2293
    unsigned int   flags;
2294
    VARARG(objattr,object_attributes); /* object attributes */
2295
@REPLY
2296
    obj_handle_t   handle;       /* handle to the pipe */
2297 2298
@END

2299 2300 2301 2302
/* 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
2303
#define NAMED_PIPE_SERVER_END           0x8000
2304

2305
/* Get named pipe information by handle */
2306
@REQ(get_named_pipe_info)
2307
    obj_handle_t   handle;
2308 2309
@REPLY
    unsigned int   flags;
2310
    unsigned int   sharing;
2311
    unsigned int   maxinstances;
2312
    unsigned int   instances;
2313 2314 2315 2316
    unsigned int   outsize;
    unsigned int   insize;
@END

2317 2318 2319 2320 2321
/* Set named pipe information by handle */
@REQ(set_named_pipe_info)
    obj_handle_t   handle;
    unsigned int   flags;
@END
2322 2323 2324

/* Create a window */
@REQ(create_window)
2325 2326
    user_handle_t  parent;      /* parent window */
    user_handle_t  owner;       /* owner window */
2327
    atom_t         atom;        /* class atom */
2328
    mod_handle_t   instance;    /* module instance */
2329
    VARARG(class,unicode_str);  /* class name */
2330
@REPLY
2331
    user_handle_t  handle;      /* created window */
2332 2333
    user_handle_t  parent;      /* full handle of parent */
    user_handle_t  owner;       /* full handle of owner */
2334
    int            extra;       /* number of extra bytes */
2335
    client_ptr_t   class_ptr;   /* pointer to class in client address space */
2336 2337 2338 2339 2340 2341 2342 2343 2344
@END


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


2345 2346
/* Retrieve the desktop window for the current thread */
@REQ(get_desktop_window)
2347
    int            force;       /* force creation if it doesn't exist */
2348
@REPLY
2349 2350
    user_handle_t  top_window;  /* handle to the desktop window */
    user_handle_t  msg_window;  /* handle to the top-level HWND_MESSAGE parent */
2351 2352 2353
@END


2354 2355 2356 2357 2358 2359
/* 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 */
2360
    user_handle_t  prev_owner;  /* full handle of previous owner */
2361 2362 2363
@END


2364 2365 2366 2367 2368
/* 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 */
2369
    user_handle_t  last_active; /* last active popup */
2370 2371
    process_id_t   pid;         /* process owning the window */
    thread_id_t    tid;         /* thread owning the window */
2372
    atom_t         atom;        /* class atom */
2373
    int            is_unicode;  /* ANSI or unicode */
2374
@END
2375 2376


2377 2378
/* Set some information in a window */
@REQ(set_window_info)
2379 2380
    unsigned short flags;         /* flags for fields to set (see below) */
    short int      is_unicode;    /* ANSI or unicode */
2381
    user_handle_t  handle;        /* handle to the window */
2382 2383 2384
    unsigned int   style;         /* window style */
    unsigned int   ex_style;      /* window extended style */
    unsigned int   id;            /* window id */
2385
    mod_handle_t   instance;      /* creator instance */
2386
    lparam_t       user_data;     /* user-specific data */
2387
    int            extra_offset;  /* offset to set in extra bytes */
2388
    data_size_t    extra_size;    /* size to set in extra bytes */
2389
    lparam_t       extra_value;   /* value to set in extra bytes */
2390 2391 2392
@REPLY
    unsigned int   old_style;     /* old window style */
    unsigned int   old_ex_style;  /* old window extended style */
2393
    mod_handle_t   old_instance;  /* old creator instance */
2394 2395
    lparam_t       old_user_data; /* old user-specific data */
    lparam_t       old_extra_value; /* old value in extra bytes */
2396
    unsigned int   old_id;        /* old window id */
2397 2398 2399 2400 2401 2402
@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
2403
#define SET_WIN_EXTRA     0x20
2404
#define SET_WIN_UNICODE   0x40
2405 2406


2407 2408 2409 2410 2411 2412 2413 2414 2415 2416
/* 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


2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427
/* 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)
2428
    obj_handle_t   desktop;       /* handle to desktop */
2429
    user_handle_t  parent;        /* parent window */
2430
    atom_t         atom;          /* class atom for the listed children */
2431
    thread_id_t    tid;           /* thread owning the listed children */
2432
    VARARG(class,unicode_str);    /* class name */
2433 2434
@REPLY
    int            count;         /* total count of children */
2435
    VARARG(children,user_handles); /* children handles */
2436 2437 2438
@END


2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449
/* 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


2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462
/* 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
2463

2464 2465
/* Set the position and Z order of a window */
@REQ(set_window_pos)
2466 2467
    unsigned short swp_flags;     /* SWP_* flags */
    unsigned short paint_flags;   /* paint flags (see below) */
2468
    user_handle_t  handle;        /* handle to the window */
2469
    user_handle_t  previous;      /* previous window in Z order */
2470 2471
    rectangle_t    window;        /* window rectangle (in parent coords) */
    rectangle_t    client;        /* client rectangle (in parent coords) */
2472
    VARARG(valid,rectangles);     /* valid rectangles from WM_NCCALCSIZE (in parent coords) */
2473 2474
@REPLY
    unsigned int   new_style;     /* new window style */
2475
    unsigned int   new_ex_style;  /* new window extended style */
2476
    user_handle_t  surface_win;   /* window that needs a surface update */
2477
@END
2478 2479
#define SET_WINPOS_PAINT_SURFACE 0x01  /* window has a paintable surface */
#define SET_WINPOS_PIXEL_FORMAT  0x02  /* window has a custom pixel format */
2480 2481 2482 2483

/* Get the window and client rectangles of a window */
@REQ(get_window_rectangles)
    user_handle_t  handle;        /* handle to the window */
2484
    int            relative;      /* coords relative to (see below) */
2485 2486
@REPLY
    rectangle_t    window;        /* window rectangle */
2487
    rectangle_t    visible;       /* visible part of the window rectangle */
2488 2489
    rectangle_t    client;        /* client rectangle */
@END
2490 2491 2492 2493 2494 2495 2496
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 */
};
2497 2498


2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513
/* 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


2514 2515 2516 2517 2518 2519 2520
/* 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 */
2521
    int            mirror;        /* whether to mirror the x coordinate */
2522 2523
@END

2524

2525 2526 2527 2528 2529
/* 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
2530
    user_handle_t  top_win;       /* top window to clip against */
2531 2532
    rectangle_t    top_rect;      /* top window visible rect with screen coords */
    rectangle_t    win_rect;      /* window rect in screen coords */
2533
    unsigned int   paint_flags;   /* paint flags (from SET_WINPOS_* flags) */
2534
    data_size_t    total_size;    /* total size of the resulting region */
2535
    VARARG(region,rectangles);    /* list of rectangles for the region (in screen coords) */
2536 2537 2538
@END


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


2549 2550 2551 2552
/* Get the window region */
@REQ(get_window_region)
    user_handle_t  window;        /* handle to the window */
@REPLY
2553
    data_size_t    total_size;    /* total size of the resulting region */
2554
    VARARG(region,rectangles);    /* list of rectangles for the region (in window coords) */
2555 2556 2557 2558 2559 2560
@END


/* Set the window region */
@REQ(set_window_region)
    user_handle_t  window;        /* handle to the window */
2561
    int            redraw;        /* redraw the window? */
2562
    VARARG(region,rectangles);    /* list of rectangles for the region (in window coords) */
2563 2564 2565
@END


2566 2567 2568
/* Get the window update region */
@REQ(get_update_region)
    user_handle_t  window;        /* handle to the window */
2569
    user_handle_t  from_child;    /* child to start searching from */
2570 2571 2572 2573
    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) */
2574
    data_size_t    total_size;    /* total size of the resulting region */
2575
    VARARG(region,rectangles);    /* list of rectangles for the region (in screen coords) */
2576 2577 2578 2579 2580 2581 2582 2583
@END
#define UPDATE_NONCLIENT       0x01  /* get region for repainting non-client area */
#define UPDATE_ERASE           0x02  /* get region for erasing client area */
#define UPDATE_PAINT           0x04  /* get region for painting client area */
#define UPDATE_INTERNALPAINT   0x08  /* get region if internal paint is pending */
#define UPDATE_ALLCHILDREN     0x10  /* force repaint of all children */
#define UPDATE_NOCHILDREN      0x20  /* don't try to repaint any children */
#define UPDATE_NOREGION        0x40  /* don't return a region, only the flags */
2584
#define UPDATE_DELAYED_ERASE   0x80  /* still needs erase after BeginPaint */
2585 2586


2587 2588 2589
/* 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 */
2590
    rectangle_t    rect;          /* rectangle that must be visible (in client coords) */
2591 2592 2593
@END


2594 2595 2596 2597
/* 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 */
2598
    VARARG(region,rectangles);    /* list of rectangles for the region (in window coords) */
2599 2600 2601
@END


2602 2603 2604
/* Set a window property */
@REQ(set_window_property)
    user_handle_t  window;        /* handle to the window */
2605
    lparam_t       data;          /* data to store */
2606
    atom_t         atom;          /* property atom (if no name specified) */
2607
    VARARG(name,unicode_str);     /* property name */
2608 2609 2610 2611 2612 2613
@END


/* Remove a window property */
@REQ(remove_window_property)
    user_handle_t  window;        /* handle to the window */
2614 2615
    atom_t         atom;          /* property atom (if no name specified) */
    VARARG(name,unicode_str);     /* property name */
2616
@REPLY
2617
    lparam_t       data;          /* data stored in property */
2618 2619 2620 2621 2622 2623
@END


/* Get a window property */
@REQ(get_window_property)
    user_handle_t  window;        /* handle to the window */
2624 2625
    atom_t         atom;          /* property atom (if no name specified) */
    VARARG(name,unicode_str);     /* property name */
2626
@REPLY
2627
    lparam_t       data;          /* data stored in property */
2628 2629 2630 2631 2632 2633 2634
@END


/* Get the list of properties of a window */
@REQ(get_window_properties)
    user_handle_t  window;        /* handle to the window */
@REPLY
2635
    int            total;         /* total number of properties */
2636 2637
    VARARG(props,properties);     /* list of properties */
@END
2638 2639


2640 2641 2642 2643
/* Create a window station */
@REQ(create_winstation)
    unsigned int flags;           /* window station flags */
    unsigned int access;          /* wanted access rights */
2644
    unsigned int attributes;      /* object attributes */
2645 2646 2647 2648 2649 2650 2651 2652 2653
    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 */
2654
    unsigned int attributes;      /* object attributes */
2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679
    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


2680 2681 2682 2683 2684 2685 2686 2687 2688
/* 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


2689 2690 2691 2692
/* Create a desktop */
@REQ(create_desktop)
    unsigned int flags;           /* desktop flags */
    unsigned int access;          /* wanted access rights */
2693
    unsigned int attributes;      /* object attributes */
2694 2695 2696 2697 2698 2699 2700 2701
    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)
2702
    obj_handle_t winsta;          /* window station to open (null allowed) */
2703 2704
    unsigned int flags;           /* desktop flags */
    unsigned int access;          /* wanted access rights */
2705
    unsigned int attributes;      /* object attributes */
2706 2707 2708 2709 2710 2711
    VARARG(name,unicode_str);     /* object name */
@REPLY
    obj_handle_t handle;          /* handle to the desktop */
@END


2712 2713 2714 2715 2716 2717 2718 2719 2720 2721
/* 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


2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741
/* 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


2742 2743 2744 2745 2746 2747 2748 2749 2750 2751
/* 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


2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764
/* Get/set information about a user object (window station or desktop) */
@REQ(set_user_object_info)
    obj_handle_t handle;          /* handle to the object */
    unsigned int flags;           /* information to set */
    unsigned int obj_flags;       /* new object flags */
@REPLY
    int          is_desktop;      /* is object a desktop? */
    unsigned int old_obj_flags;   /* old object flags */
    VARARG(name,unicode_str);     /* object name */
@END
#define SET_USER_OBJECT_FLAGS 1


2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787
/* 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


2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806
/* 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 */
2807 2808
    user_handle_t  cursor;        /* handle to the cursor */
    int            show_count;    /* cursor show count */
2809 2810
    rectangle_t    rect;          /* caret rectangle */
@END
2811

2812 2813 2814 2815 2816 2817 2818 2819

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


2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831
/* 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 */
2832
    int            async;         /* whether to change the async state too */
2833 2834 2835
    VARARG(keystate,bytes);       /* state array for all the keys */
@END

2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857
/* 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
2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868

/* 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 */
2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900


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


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


/* Set a window hook */
@REQ(set_hook)
    int            id;             /* id of the hook */
2906
    process_id_t   pid;            /* id of process to set the hook into */
2907
    thread_id_t    tid;            /* id of thread to set the hook into */
2908 2909
    int            event_min;
    int            event_max;
2910
    client_ptr_t   proc;           /* hook procedure */
2911
    int            flags;
2912
    int            unicode;        /* is it a unicode hook? */
2913
    VARARG(module,unicode_str);    /* module name */
2914 2915
@REPLY
    user_handle_t  handle;         /* handle to the hook */
2916
    unsigned int   active_hooks;   /* active hooks bitmap */
2917 2918 2919 2920 2921 2922
@END


/* Remove a window hook */
@REQ(remove_hook)
    user_handle_t  handle;         /* handle to the hook */
2923
    client_ptr_t   proc;           /* hook procedure if handle is 0 */
2924
    int            id;             /* id of the hook if handle is 0 */
2925 2926
@REPLY
    unsigned int   active_hooks;   /* active hooks bitmap */
2927 2928 2929 2930 2931 2932
@END


/* Start calling a hook chain */
@REQ(start_hook_chain)
    int            id;             /* id of the hook */
2933 2934 2935 2936
    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 */
2937 2938
@REPLY
    user_handle_t  handle;         /* handle to the next hook */
2939 2940
    process_id_t   pid;            /* process id for low-level keyboard/mouse hooks */
    thread_id_t    tid;            /* thread id for low-level keyboard/mouse hooks */
2941
    int            unicode;        /* is it a unicode hook? */
2942
    client_ptr_t   proc;           /* hook procedure */
2943
    unsigned int   active_hooks;   /* active hooks bitmap */
2944
    VARARG(module,unicode_str);    /* module name */
2945 2946 2947 2948 2949 2950 2951 2952 2953
@END


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


2954 2955
/* Get the hook information */
@REQ(get_hook_info)
2956
    user_handle_t  handle;         /* handle to the current hook */
2957
    int            get_next;       /* do we want info about current or next hook? */
2958 2959 2960 2961
    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 */
2962
@REPLY
2963 2964
    user_handle_t  handle;         /* handle to the hook */
    int            id;             /* id of the hook */
2965 2966
    process_id_t   pid;            /* process id for low-level keyboard/mouse hooks */
    thread_id_t    tid;            /* thread id for low-level keyboard/mouse hooks */
2967
    client_ptr_t   proc;           /* hook procedure */
2968
    int            unicode;        /* is it a unicode hook? */
2969
    VARARG(module,unicode_str);    /* module name */
2970
@END
2971 2972


2973 2974 2975 2976 2977
/* Create a window class */
@REQ(create_class)
    int            local;          /* is it a local class? */
    atom_t         atom;           /* class atom */
    unsigned int   style;          /* class style */
2978
    mod_handle_t   instance;       /* module instance */
2979 2980
    int            extra;          /* number of extra class bytes */
    int            win_extra;      /* number of window extra bytes */
2981
    client_ptr_t   client_ptr;     /* pointer to class in client address space */
2982 2983 2984
    VARARG(name,unicode_str);      /* class name */
@REPLY
    atom_t         atom;           /* resulting class atom */
2985 2986 2987 2988 2989 2990
@END


/* Destroy a window class */
@REQ(destroy_class)
    atom_t         atom;           /* class atom */
2991
    mod_handle_t   instance;       /* module instance */
2992
    VARARG(name,unicode_str);      /* class name */
2993
@REPLY
2994
    client_ptr_t   client_ptr;     /* pointer to class in client address space */
2995 2996 2997 2998 2999 3000 3001 3002 3003 3004
@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 */
3005
    mod_handle_t   instance;       /* module instance */
3006
    int            extra_offset;   /* offset to set in extra bytes */
3007
    data_size_t    extra_size;     /* size to set in extra bytes */
3008
    lparam_t       extra_value;    /* value to set in extra bytes */
3009 3010 3011 3012 3013
@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 */
3014
    mod_handle_t   old_instance;   /* previous module instance */
3015
    lparam_t       old_extra_value; /* old value in extra bytes */
3016 3017 3018 3019 3020 3021 3022 3023
@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


3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046
/* Set/get clipboard information */
@REQ(set_clipboard_info)
    unsigned int   flags;       /* flags for fields to set (see below) */
    user_handle_t  clipboard;   /* clipboard window */
    user_handle_t  owner;       /* clipboard owner */
    user_handle_t  viewer;      /* first clipboard viewer */
    unsigned int   seqno;       /* change sequence number */
@REPLY
    unsigned int   flags;           /* status flags (see below) */
    user_handle_t  old_clipboard;   /* old clipboard window */
    user_handle_t  old_owner;       /* old clipboard owner */
    user_handle_t  old_viewer;      /* old clipboard viewer */
    unsigned int   seqno;           /* current sequence number */
@END

#define SET_CB_OPEN      0x001
#define SET_CB_OWNER     0x002
#define SET_CB_VIEWER    0x004
#define SET_CB_SEQNO     0x008
#define SET_CB_RELOWNER  0x010
#define SET_CB_CLOSE     0x020
#define CB_OPEN          0x040
#define CB_OWNER         0x080
3047
#define CB_PROCESS       0x100
3048 3049 3050 3051 3052


/* Open a security token */
@REQ(open_token)
    obj_handle_t   handle;    /* handle to the thread or process */
3053 3054
    unsigned int   access;    /* access rights to the new token */
    unsigned int   attributes;/* object attributes */
3055 3056 3057 3058 3059 3060
    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
3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078


/* 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
3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098

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

3099 3100 3101 3102 3103 3104 3105 3106 3107 3108
/* 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

3109
@REQ(duplicate_token)
3110 3111 3112 3113
    obj_handle_t  handle;        /* handle to the token to duplicate */
    unsigned int  access;        /* access rights to the new token */
    unsigned int  attributes;    /* object attributes */
    int           primary;       /* is the new token to be a primary one? */
3114 3115 3116 3117
    int           impersonation_level; /* impersonation level of the new token */
@REPLY
    obj_handle_t  new_handle; /* duplicated handle */
@END
Mike McCormack's avatar
Mike McCormack committed
3118

3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132
@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
3133

3134
@REQ(get_token_sid)
3135
    obj_handle_t    handle;       /* handle to the token */
3136
    unsigned int    which_sid;    /* which SID to retrieve from the token */
3137
@REPLY
3138 3139
    data_size_t     sid_len;      /* length needed to store sid */
    VARARG(sid,SID);              /* the sid specified by which_sid from the token */
3140 3141
@END

3142 3143 3144
@REQ(get_token_groups)
    obj_handle_t    handle;       /* handle to the token */
@REPLY
3145
    data_size_t     user_len;     /* length needed to store user */
3146
    VARARG(user,token_groups);    /* groups the token's user belongs to */
3147 3148
@END

3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160
@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

3161 3162 3163 3164 3165 3166
@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

3167 3168 3169 3170 3171 3172 3173 3174
@REQ(get_security_object)
    obj_handle_t    handle;       /* handle to the object */
    unsigned int    security_info; /* which parts of security descriptor to get */
@REPLY
    unsigned int    sd_len;         /* buffer size needed for sd */
    VARARG(sd,security_descriptor); /* retrieved security descriptor */
@END

Mike McCormack's avatar
Mike McCormack committed
3175 3176
/* Create a mailslot */
@REQ(create_mailslot)
3177 3178
    unsigned int   access;        /* wanted access rights */
    unsigned int   attributes;    /* object attributes */
3179
    obj_handle_t   rootdir;       /* root directory */
3180
    timeout_t      read_timeout;
3181
    unsigned int   max_msgsize;
Mike McCormack's avatar
Mike McCormack committed
3182 3183 3184 3185 3186 3187 3188 3189 3190
    VARARG(name,unicode_str);     /* mailslot name */
@REPLY
    obj_handle_t   handle;        /* handle to the mailslot */
@END


/* Set mailslot information */
@REQ(set_mailslot_info)
    obj_handle_t   handle;        /* handle to the mailslot */
3191
    timeout_t      read_timeout;
3192
    unsigned int   flags;
Mike McCormack's avatar
Mike McCormack committed
3193
@REPLY
3194
    timeout_t      read_timeout;
3195
    unsigned int   max_msgsize;
Mike McCormack's avatar
Mike McCormack committed
3196 3197
@END
#define MAILSLOT_SET_READ_TIMEOUT  1
3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219


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


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


3222 3223 3224 3225 3226
/* Get a directory entry by index */
@REQ(get_directory_entry)
    obj_handle_t   handle;             /* handle to the directory */
    unsigned int   index;              /* entry index */
@REPLY
3227
    data_size_t    name_len;           /* length of the entry name in bytes */
3228 3229 3230 3231 3232
    VARARG(name,unicode_str,name_len); /* entry name */
    VARARG(type,unicode_str);          /* entry type */
@END


3233 3234 3235 3236 3237
/* Create a symbolic link object */
@REQ(create_symlink)
    unsigned int   access;        /* access flags */
    unsigned int   attributes;    /* object attributes */
    obj_handle_t   rootdir;       /* root directory */
3238
    data_size_t    name_len;      /* length of the symlink name in bytes */
3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260
    VARARG(name,unicode_str,name_len); /* symlink name */
    VARARG(target_name,unicode_str);   /* target name */
@REPLY
    obj_handle_t   handle;        /* handle to the symlink */
@END


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


/* Query a symbolic link object */
@REQ(query_symlink)
    obj_handle_t   handle;        /* handle to the symlink */
@REPLY
3261
    data_size_t    total;         /* total needed size for name */
3262 3263
    VARARG(target_name,unicode_str); /* target name */
@END
3264 3265 3266 3267 3268 3269 3270 3271


/* 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 */
3272 3273
    data_size_t    total;         /* total needed size for name */
    VARARG(name,unicode_str);     /* object name */
3274
@END
3275

3276 3277 3278 3279 3280 3281 3282

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


3283 3284 3285 3286 3287 3288
/* 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
3289 3290 3291 3292 3293 3294

/* Allocate a locally-unique identifier */
@REQ(allocate_locally_unique_id)
@REPLY
    luid_t         luid;
@END
3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310


/* 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 */
3311
    client_ptr_t user_ptr;        /* opaque ptr for use by client */
3312
    obj_handle_t manager;         /* device manager */
3313 3314 3315 3316 3317 3318 3319 3320 3321 3322
    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
3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333


/* Retrieve the next pending device ioctl request */
@REQ(get_next_device_request)
    obj_handle_t manager;         /* handle to the device manager */
    obj_handle_t prev;            /* handle to the previous ioctl */
    unsigned int status;          /* status of the previous ioctl */
    VARARG(prev_data,bytes);      /* output data of the previous ioctl */
@REPLY
    obj_handle_t next;            /* handle to the next ioctl */
    ioctl_code_t code;            /* ioctl code */
3334
    client_ptr_t user_ptr;        /* opaque ptr for the device */
3335 3336
    process_id_t client_pid;      /* pid of process calling ioctl */
    thread_id_t  client_tid;      /* tid of thread calling ioctl */
3337 3338 3339 3340
    data_size_t  in_size;         /* total needed input size */
    data_size_t  out_size;        /* needed output size */
    VARARG(next_data,bytes);      /* input data of the next ioctl */
@END
3341 3342 3343 3344 3345 3346 3347


/* 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
3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360


/* 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
3361 3362 3363 3364 3365 3366 3367 3368


/* Create I/O completion port */
@REQ(create_completion)
    unsigned int access;          /* desired access to a port */
    unsigned int attributes;      /* object attributes */
    unsigned int concurrent;      /* max number of concurrent active threads */
    obj_handle_t rootdir;         /* root directory */
3369
    VARARG(filename,unicode_str); /* port name */
3370 3371 3372 3373 3374 3375 3376 3377 3378 3379
@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 */
3380
    VARARG(filename,unicode_str); /* port name */
3381 3382 3383 3384 3385 3386 3387 3388
@REPLY
    obj_handle_t handle;          /* port handle */
@END


/* add completion to completion port */
@REQ(add_completion)
    obj_handle_t  handle;         /* port handle */
3389 3390
    apc_param_t   ckey;           /* completion key */
    apc_param_t   cvalue;         /* completion value */
3391
    apc_param_t   information;    /* IO_STATUS_BLOCK Information */
3392 3393 3394 3395 3396 3397 3398 3399
    unsigned int  status;         /* completion result */
@END


/* get completion from completion port queue */
@REQ(remove_completion)
    obj_handle_t handle;          /* port handle */
@REPLY
3400 3401
    apc_param_t   ckey;           /* completion key */
    apc_param_t   cvalue;         /* completion value */
3402
    apc_param_t   information;    /* IO_STATUS_BLOCK Information */
3403 3404 3405 3406 3407 3408 3409 3410 3411 3412
    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
3413 3414 3415 3416 3417


/* associate object with completion port */
@REQ(set_completion_info)
    obj_handle_t  handle;         /* object handle */
3418
    apc_param_t   ckey;           /* completion key */
3419
    obj_handle_t  chandle;        /* port handle */
3420
@END
3421 3422 3423 3424 3425


/* check for associated completion and push msg */
@REQ(add_fd_completion)
    obj_handle_t   handle;        /* async' object */
3426
    apc_param_t    cvalue;        /* completion value */
3427
    apc_param_t    information;   /* IO_STATUS_BLOCK Information */
3428 3429
    unsigned int   status;        /* completion status */
@END
3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448


/* 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
3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461


/* 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
3462 3463 3464 3465 3466 3467 3468


/* 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 */
3469 3470
    int            x;             /* cursor position */
    int            y;
3471
    rectangle_t    clip;          /* cursor clip rectangle */
3472
    unsigned int   clip_msg;      /* message to post on cursor clip changes */
3473 3474 3475
@REPLY
    user_handle_t  prev_handle;   /* previous handle */
    int            prev_count;    /* previous show count */
3476 3477
    int            prev_x;        /* previous position */
    int            prev_y;
3478 3479
    int            new_x;         /* new position */
    int            new_y;
3480
    rectangle_t    new_clip;      /* new clip rectangle */
3481
    unsigned int   last_change;   /* time of last position change */
3482 3483 3484
@END
#define SET_CURSOR_HANDLE 0x01
#define SET_CURSOR_COUNT  0x02
3485
#define SET_CURSOR_POS    0x04
3486
#define SET_CURSOR_CLIP   0x08
3487
#define SET_CURSOR_NOCLIP 0x10
3488 3489


3490 3491 3492 3493 3494 3495
/* Modify the list of registered rawinput devices */
@REQ(update_rawinput_devices)
    VARARG(devices,rawinput_devices);
@END


3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506
/* 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