2 * Server request tracing
4 * Copyright (C) 1999 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
27 #include <sys/types.h>
34 #define WIN32_NO_STATUS
41 #include "wine/condrv.h"
43 #include "ddk/ntddser.h"
50 static const void *cur_data
;
51 static data_size_t cur_size
;
53 static const char *get_status_name( unsigned int status
);
55 /* utility functions */
57 static inline void remove_data( data_size_t size
)
59 cur_data
= (const char *)cur_data
+ size
;
63 static void dump_uints( const char *prefix
, const unsigned int *ptr
, int len
)
65 fprintf( stderr
, "%s{", prefix
);
68 fprintf( stderr
, "%08x", *ptr
++ );
69 if (--len
) fputc( ',', stderr
);
74 static void dump_handles( const char *prefix
, const obj_handle_t
*data
, data_size_t size
)
76 data_size_t len
= size
/ sizeof(*data
);
78 fprintf( stderr
,"%s{", prefix
);
81 fprintf( stderr
, "%04x", *data
++ );
82 if (--len
) fputc( ',', stderr
);
87 static void dump_timeout( const char *prefix
, const timeout_t
*time
)
89 fprintf( stderr
, "%s%s", prefix
, get_timeout_str(*time
) );
92 static void dump_abstime( const char *prefix
, const abstime_t
*when
)
94 timeout_t timeout
= abstime_to_timeout( *when
);
95 dump_timeout( prefix
, &timeout
);
98 static void dump_uint64( const char *prefix
, const unsigned __int64
*val
)
100 if ((unsigned int)*val
!= *val
)
101 fprintf( stderr
, "%s%x%08x", prefix
, (unsigned int)(*val
>> 32), (unsigned int)*val
);
103 fprintf( stderr
, "%s%08x", prefix
, (unsigned int)*val
);
106 static void dump_rectangle( const char *prefix
, const rectangle_t
*rect
)
108 fprintf( stderr
, "%s{%d,%d;%d,%d}", prefix
,
109 rect
->left
, rect
->top
, rect
->right
, rect
->bottom
);
112 static void dump_ioctl_code( const char *prefix
, const ioctl_code_t
*code
)
116 #define CASE(c) case c: fprintf( stderr, "%s%s", prefix, #c ); break
117 CASE(IOCTL_CONDRV_ACTIVATE
);
118 CASE(IOCTL_CONDRV_ATTACH_RENDERER
);
119 CASE(IOCTL_CONDRV_CTRL_EVENT
);
120 CASE(IOCTL_CONDRV_FILL_OUTPUT
);
121 CASE(IOCTL_CONDRV_GET_INPUT_INFO
);
122 CASE(IOCTL_CONDRV_GET_MODE
);
123 CASE(IOCTL_CONDRV_GET_OUTPUT_INFO
);
124 CASE(IOCTL_CONDRV_GET_RENDERER_EVENTS
);
125 CASE(IOCTL_CONDRV_GET_TITLE
);
126 CASE(IOCTL_CONDRV_PEEK
);
127 CASE(IOCTL_CONDRV_READ_INPUT
);
128 CASE(IOCTL_CONDRV_READ_OUTPUT
);
129 CASE(IOCTL_CONDRV_SET_MODE
);
130 CASE(IOCTL_CONDRV_SET_OUTPUT_INFO
);
131 CASE(IOCTL_CONDRV_WRITE_CONSOLE
);
132 CASE(IOCTL_CONDRV_WRITE_INPUT
);
133 CASE(IOCTL_CONDRV_WRITE_OUTPUT
);
134 CASE(FSCTL_DISMOUNT_VOLUME
);
135 CASE(FSCTL_PIPE_DISCONNECT
);
136 CASE(FSCTL_PIPE_LISTEN
);
137 CASE(FSCTL_PIPE_PEEK
);
138 CASE(FSCTL_PIPE_WAIT
);
139 CASE(IOCTL_SERIAL_GET_TIMEOUTS
);
140 CASE(IOCTL_SERIAL_GET_WAIT_MASK
);
141 CASE(IOCTL_SERIAL_SET_TIMEOUTS
);
142 CASE(IOCTL_SERIAL_SET_WAIT_MASK
);
143 CASE(WS_SIO_ADDRESS_LIST_CHANGE
);
144 default: fprintf( stderr
, "%s%08x", prefix
, *code
); break;
149 static void dump_client_cpu( const char *prefix
, const client_cpu_t
*code
)
153 #define CASE(c) case CPU_##c: fprintf( stderr, "%s%s", prefix, #c ); break
159 default: fprintf( stderr
, "%s%u", prefix
, *code
); break;
164 static void dump_apc_call( const char *prefix
, const apc_call_t
*call
)
166 fprintf( stderr
, "%s{", prefix
);
170 fprintf( stderr
, "APC_NONE" );
173 dump_uint64( "APC_USER,func=", &call
->user
.user
.func
);
174 dump_uint64( ",args={", &call
->user
.user
.args
[0] );
175 dump_uint64( ",", &call
->user
.user
.args
[1] );
176 dump_uint64( ",", &call
->user
.user
.args
[2] );
177 fputc( '}', stderr
);
180 dump_timeout( "APC_TIMER,time=", &call
->user
.timer
.time
);
181 dump_uint64( ",arg=", &call
->user
.timer
.arg
);
184 dump_uint64( "APC_ASYNC_IO,user=", &call
->async_io
.user
);
185 dump_uint64( ",sb=", &call
->async_io
.sb
);
186 fprintf( stderr
, ",status=%s", get_status_name(call
->async_io
.status
) );
188 case APC_VIRTUAL_ALLOC
:
189 dump_uint64( "APC_VIRTUAL_ALLOC,addr==", &call
->virtual_alloc
.addr
);
190 dump_uint64( ",size=", &call
->virtual_alloc
.size
);
191 dump_uint64( ",zero_bits=", &call
->virtual_alloc
.zero_bits
);
192 fprintf( stderr
, ",op_type=%x,prot=%x", call
->virtual_alloc
.op_type
, call
->virtual_alloc
.prot
);
194 case APC_VIRTUAL_FREE
:
195 dump_uint64( "APC_VIRTUAL_FREE,addr=", &call
->virtual_free
.addr
);
196 dump_uint64( ",size=", &call
->virtual_free
.size
);
197 fprintf( stderr
, ",op_type=%x", call
->virtual_free
.op_type
);
199 case APC_VIRTUAL_QUERY
:
200 dump_uint64( "APC_VIRTUAL_QUERY,addr=", &call
->virtual_query
.addr
);
202 case APC_VIRTUAL_PROTECT
:
203 dump_uint64( "APC_VIRTUAL_PROTECT,addr=", &call
->virtual_protect
.addr
);
204 dump_uint64( ",size=", &call
->virtual_protect
.size
);
205 fprintf( stderr
, ",prot=%x", call
->virtual_protect
.prot
);
207 case APC_VIRTUAL_FLUSH
:
208 dump_uint64( "APC_VIRTUAL_FLUSH,addr=", &call
->virtual_flush
.addr
);
209 dump_uint64( ",size=", &call
->virtual_flush
.size
);
211 case APC_VIRTUAL_LOCK
:
212 dump_uint64( "APC_VIRTUAL_LOCK,addr=", &call
->virtual_lock
.addr
);
213 dump_uint64( ",size=", &call
->virtual_lock
.size
);
215 case APC_VIRTUAL_UNLOCK
:
216 dump_uint64( "APC_VIRTUAL_UNLOCK,addr=", &call
->virtual_unlock
.addr
);
217 dump_uint64( ",size=", &call
->virtual_unlock
.size
);
220 fprintf( stderr
, "APC_MAP_VIEW,handle=%04x", call
->map_view
.handle
);
221 dump_uint64( ",addr=", &call
->map_view
.addr
);
222 dump_uint64( ",size=", &call
->map_view
.size
);
223 dump_uint64( ",offset=", &call
->map_view
.offset
);
224 dump_uint64( ",zero_bits=", &call
->map_view
.zero_bits
);
225 fprintf( stderr
, ",alloc_type=%x,prot=%x", call
->map_view
.alloc_type
, call
->map_view
.prot
);
228 dump_uint64( "APC_UNMAP_VIEW,addr=", &call
->unmap_view
.addr
);
230 case APC_CREATE_THREAD
:
231 dump_uint64( "APC_CREATE_THREAD,func=", &call
->create_thread
.func
);
232 dump_uint64( ",arg=", &call
->create_thread
.arg
);
233 dump_uint64( ",reserve=", &call
->create_thread
.reserve
);
234 dump_uint64( ",commit=", &call
->create_thread
.commit
);
235 fprintf( stderr
, ",flags=%x", call
->create_thread
.flags
);
237 case APC_BREAK_PROCESS
:
238 fprintf( stderr
, "APC_BREAK_PROCESS" );
241 fprintf( stderr
, "type=%u", call
->type
);
244 fputc( '}', stderr
);
247 static void dump_apc_result( const char *prefix
, const apc_result_t
*result
)
249 fprintf( stderr
, "%s{", prefix
);
255 fprintf( stderr
, "APC_ASYNC_IO,status=%s,total=%u",
256 get_status_name( result
->async_io
.status
), result
->async_io
.total
);
258 case APC_VIRTUAL_ALLOC
:
259 fprintf( stderr
, "APC_VIRTUAL_ALLOC,status=%s",
260 get_status_name( result
->virtual_alloc
.status
));
261 dump_uint64( ",addr=", &result
->virtual_alloc
.addr
);
262 dump_uint64( ",size=", &result
->virtual_alloc
.size
);
264 case APC_VIRTUAL_FREE
:
265 fprintf( stderr
, "APC_VIRTUAL_FREE,status=%s",
266 get_status_name( result
->virtual_free
.status
));
267 dump_uint64( ",addr=", &result
->virtual_free
.addr
);
268 dump_uint64( ",size=", &result
->virtual_free
.size
);
270 case APC_VIRTUAL_QUERY
:
271 fprintf( stderr
, "APC_VIRTUAL_QUERY,status=%s",
272 get_status_name( result
->virtual_query
.status
));
273 dump_uint64( ",base=", &result
->virtual_query
.base
);
274 dump_uint64( ",alloc_base=", &result
->virtual_query
.alloc_base
);
275 dump_uint64( ",size=", &result
->virtual_query
.size
);
276 fprintf( stderr
, ",state=%x,prot=%x,alloc_prot=%x,alloc_type=%x",
277 result
->virtual_query
.state
, result
->virtual_query
.prot
,
278 result
->virtual_query
.alloc_prot
, result
->virtual_query
.alloc_type
);
280 case APC_VIRTUAL_PROTECT
:
281 fprintf( stderr
, "APC_VIRTUAL_PROTECT,status=%s",
282 get_status_name( result
->virtual_protect
.status
));
283 dump_uint64( ",addr=", &result
->virtual_protect
.addr
);
284 dump_uint64( ",size=", &result
->virtual_protect
.size
);
285 fprintf( stderr
, ",prot=%x", result
->virtual_protect
.prot
);
287 case APC_VIRTUAL_FLUSH
:
288 fprintf( stderr
, "APC_VIRTUAL_FLUSH,status=%s",
289 get_status_name( result
->virtual_flush
.status
));
290 dump_uint64( ",addr=", &result
->virtual_flush
.addr
);
291 dump_uint64( ",size=", &result
->virtual_flush
.size
);
293 case APC_VIRTUAL_LOCK
:
294 fprintf( stderr
, "APC_VIRTUAL_LOCK,status=%s",
295 get_status_name( result
->virtual_lock
.status
));
296 dump_uint64( ",addr=", &result
->virtual_lock
.addr
);
297 dump_uint64( ",size=", &result
->virtual_lock
.size
);
299 case APC_VIRTUAL_UNLOCK
:
300 fprintf( stderr
, "APC_VIRTUAL_UNLOCK,status=%s",
301 get_status_name( result
->virtual_unlock
.status
));
302 dump_uint64( ",addr=", &result
->virtual_unlock
.addr
);
303 dump_uint64( ",size=", &result
->virtual_unlock
.size
);
306 fprintf( stderr
, "APC_MAP_VIEW,status=%s",
307 get_status_name( result
->map_view
.status
));
308 dump_uint64( ",addr=", &result
->map_view
.addr
);
309 dump_uint64( ",size=", &result
->map_view
.size
);
312 fprintf( stderr
, "APC_UNMAP_VIEW,status=%s",
313 get_status_name( result
->unmap_view
.status
) );
315 case APC_CREATE_THREAD
:
316 fprintf( stderr
, "APC_CREATE_THREAD,status=%s,pid=%04x,tid=%04x,handle=%04x",
317 get_status_name( result
->create_thread
.status
),
318 result
->create_thread
.pid
, result
->create_thread
.tid
, result
->create_thread
.handle
);
320 case APC_BREAK_PROCESS
:
321 fprintf( stderr
, "APC_BREAK_PROCESS,status=%s", get_status_name( result
->break_process
.status
) );
324 fprintf( stderr
, "type=%u", result
->type
);
327 fputc( '}', stderr
);
330 static void dump_async_data( const char *prefix
, const async_data_t
*data
)
332 fprintf( stderr
, "%s{handle=%04x,event=%04x", prefix
, data
->handle
, data
->event
);
333 dump_uint64( ",iosb=", &data
->iosb
);
334 dump_uint64( ",user=", &data
->user
);
335 dump_uint64( ",apc=", &data
->apc
);
336 dump_uint64( ",apc_context=", &data
->apc_context
);
337 fputc( '}', stderr
);
340 static void dump_irp_params( const char *prefix
, const irp_params_t
*data
)
345 fprintf( stderr
, "%s{NONE}", prefix
);
347 case IRP_CALL_CREATE
:
348 fprintf( stderr
, "%s{CREATE,access=%08x,sharing=%08x,options=%08x",
349 prefix
, data
->create
.access
, data
->create
.sharing
, data
->create
.options
);
350 dump_uint64( ",device=", &data
->create
.device
);
351 fprintf( stderr
, ",file=%08x}", data
->create
.file
);
354 fprintf( stderr
, "%s{CLOSE", prefix
);
355 dump_uint64( ",file=", &data
->close
.file
);
356 fputc( '}', stderr
);
359 fprintf( stderr
, "%s{READ,key=%08x,out_size=%u", prefix
, data
->read
.key
,
360 data
->read
.out_size
);
361 dump_uint64( ",pos=", &data
->read
.pos
);
362 dump_uint64( ",file=", &data
->read
.file
);
363 fputc( '}', stderr
);
366 fprintf( stderr
, "%s{WRITE,key=%08x", prefix
, data
->write
.key
);
367 dump_uint64( ",pos=", &data
->write
.pos
);
368 dump_uint64( ",file=", &data
->write
.file
);
369 fputc( '}', stderr
);
372 fprintf( stderr
, "%s{FLUSH", prefix
);
373 dump_uint64( ",file=", &data
->flush
.file
);
374 fputc( '}', stderr
);
377 fprintf( stderr
, "%s{IOCTL", prefix
);
378 dump_ioctl_code( ",code=", &data
->ioctl
.code
);
379 fprintf( stderr
, ",out_size=%u", data
->ioctl
.out_size
);
380 dump_uint64( ",file=", &data
->ioctl
.file
);
381 fputc( '}', stderr
);
384 fprintf( stderr
, "%s{FREE", prefix
);
385 dump_uint64( ",obj=", &data
->free
.obj
);
386 fputc( '}', stderr
);
388 case IRP_CALL_CANCEL
:
389 fprintf( stderr
, "%s{CANCEL", prefix
);
390 dump_uint64( ",irp=", &data
->cancel
.irp
);
391 fputc( '}', stderr
);
396 static void dump_hw_input( const char *prefix
, const hw_input_t
*input
)
401 fprintf( stderr
, "%s{type=MOUSE,x=%d,y=%d,data=%08x,flags=%08x,time=%u",
402 prefix
, input
->mouse
.x
, input
->mouse
.y
, input
->mouse
.data
, input
->mouse
.flags
,
404 dump_uint64( ",info=", &input
->mouse
.info
);
405 fputc( '}', stderr
);
408 fprintf( stderr
, "%s{type=KEYBOARD,vkey=%04hx,scan=%04hx,flags=%08x,time=%u",
409 prefix
, input
->kbd
.vkey
, input
->kbd
.scan
, input
->kbd
.flags
, input
->kbd
.time
);
410 dump_uint64( ",info=", &input
->kbd
.info
);
411 fputc( '}', stderr
);
414 fprintf( stderr
, "%s{type=HARDWARE,msg=%04x", prefix
, input
->hw
.msg
);
415 dump_uint64( ",lparam=", &input
->hw
.lparam
);
416 fputc( '}', stderr
);
419 fprintf( stderr
, "%s{type=%04x}", prefix
, input
->type
);
424 static void dump_luid( const char *prefix
, const luid_t
*luid
)
426 fprintf( stderr
, "%s%d.%u", prefix
, luid
->high_part
, luid
->low_part
);
429 static void dump_varargs_ints( const char *prefix
, data_size_t size
)
431 const int *data
= cur_data
;
432 data_size_t len
= size
/ sizeof(*data
);
434 fprintf( stderr
,"%s{", prefix
);
437 fprintf( stderr
, "%d", *data
++ );
438 if (--len
) fputc( ',', stderr
);
440 fputc( '}', stderr
);
444 static void dump_varargs_uints( const char *prefix
, data_size_t size
)
446 const unsigned int *data
= cur_data
;
448 dump_uints( prefix
, data
, size
/ sizeof(*data
) );
452 static void dump_varargs_uints64( const char *prefix
, data_size_t size
)
454 const unsigned __int64
*data
= cur_data
;
455 data_size_t len
= size
/ sizeof(*data
);
457 fprintf( stderr
,"%s{", prefix
);
460 dump_uint64( "", data
++ );
461 if (--len
) fputc( ',', stderr
);
463 fputc( '}', stderr
);
467 static void dump_varargs_apc_result( const char *prefix
, data_size_t size
)
469 const apc_result_t
*result
= cur_data
;
471 if (size
>= sizeof(*result
))
473 dump_apc_result( prefix
, result
);
474 size
= sizeof(*result
);
479 static void dump_varargs_select_op( const char *prefix
, data_size_t size
)
485 fprintf( stderr
, "%s{}", prefix
);
488 memset( &data
, 0, sizeof(data
) );
489 memcpy( &data
, cur_data
, min( size
, sizeof(data
) ));
491 fprintf( stderr
, "%s{", prefix
);
495 fprintf( stderr
, "NONE" );
498 case SELECT_WAIT_ALL
:
499 fprintf( stderr
, "%s", data
.op
== SELECT_WAIT
? "WAIT" : "WAIT_ALL" );
500 if (size
> offsetof( select_op_t
, wait
.handles
))
501 dump_handles( ",handles=", data
.wait
.handles
,
502 min( size
, sizeof(data
.wait
) ) - offsetof( select_op_t
, wait
.handles
));
504 case SELECT_SIGNAL_AND_WAIT
:
505 fprintf( stderr
, "SIGNAL_AND_WAIT,signal=%04x,wait=%04x",
506 data
.signal_and_wait
.signal
, data
.signal_and_wait
.wait
);
508 case SELECT_KEYED_EVENT_WAIT
:
509 case SELECT_KEYED_EVENT_RELEASE
:
510 fprintf( stderr
, "KEYED_EVENT_%s,handle=%04x",
511 data
.op
== SELECT_KEYED_EVENT_WAIT
? "WAIT" : "RELEASE",
512 data
.keyed_event
.handle
);
513 dump_uint64( ",key=", &data
.keyed_event
.key
);
516 fprintf( stderr
, "op=%u", data
.op
);
519 fputc( '}', stderr
);
523 static void dump_varargs_user_handles( const char *prefix
, data_size_t size
)
525 const user_handle_t
*data
= cur_data
;
526 data_size_t len
= size
/ sizeof(*data
);
528 fprintf( stderr
,"%s{", prefix
);
531 fprintf( stderr
, "%08x", *data
++ );
532 if (--len
) fputc( ',', stderr
);
534 fputc( '}', stderr
);
538 static void dump_varargs_bytes( const char *prefix
, data_size_t size
)
540 const unsigned char *data
= cur_data
;
541 data_size_t len
= min( 1024, size
);
543 fprintf( stderr
,"%s{", prefix
);
546 fprintf( stderr
, "%02x", *data
++ );
547 if (--len
) fputc( ',', stderr
);
549 if (size
> 1024) fprintf( stderr
, "...(total %u)", size
);
550 fputc( '}', stderr
);
554 static void dump_varargs_string( const char *prefix
, data_size_t size
)
556 fprintf( stderr
, "%s\"%.*s\"", prefix
, (int)size
, (const char *)cur_data
);
560 static void dump_varargs_unicode_str( const char *prefix
, data_size_t size
)
562 fprintf( stderr
, "%sL\"", prefix
);
563 dump_strW( cur_data
, size
, stderr
, "\"\"" );
564 fputc( '\"', stderr
);
568 static void dump_varargs_context( const char *prefix
, data_size_t size
)
570 const context_t
*context
= cur_data
;
576 fprintf( stderr
, "%s{}", prefix
);
579 size
= min( size
, sizeof(ctx
) );
580 memset( &ctx
, 0, sizeof(ctx
) );
581 memcpy( &ctx
, context
, size
);
583 fprintf( stderr
,"%s{", prefix
);
584 dump_client_cpu( "cpu=", &ctx
.cpu
);
588 if (ctx
.flags
& SERVER_CTX_CONTROL
)
589 fprintf( stderr
, ",eip=%08x,esp=%08x,ebp=%08x,eflags=%08x,cs=%04x,ss=%04x",
590 ctx
.ctl
.i386_regs
.eip
, ctx
.ctl
.i386_regs
.esp
, ctx
.ctl
.i386_regs
.ebp
,
591 ctx
.ctl
.i386_regs
.eflags
, ctx
.ctl
.i386_regs
.cs
, ctx
.ctl
.i386_regs
.ss
);
592 if (ctx
.flags
& SERVER_CTX_SEGMENTS
)
593 fprintf( stderr
, ",ds=%04x,es=%04x,fs=%04x,gs=%04x",
594 ctx
.seg
.i386_regs
.ds
, ctx
.seg
.i386_regs
.es
,
595 ctx
.seg
.i386_regs
.fs
, ctx
.seg
.i386_regs
.gs
);
596 if (ctx
.flags
& SERVER_CTX_INTEGER
)
597 fprintf( stderr
, ",eax=%08x,ebx=%08x,ecx=%08x,edx=%08x,esi=%08x,edi=%08x",
598 ctx
.integer
.i386_regs
.eax
, ctx
.integer
.i386_regs
.ebx
, ctx
.integer
.i386_regs
.ecx
,
599 ctx
.integer
.i386_regs
.edx
, ctx
.integer
.i386_regs
.esi
, ctx
.integer
.i386_regs
.edi
);
600 if (ctx
.flags
& SERVER_CTX_DEBUG_REGISTERS
)
601 fprintf( stderr
, ",dr0=%08x,dr1=%08x,dr2=%08x,dr3=%08x,dr6=%08x,dr7=%08x",
602 ctx
.debug
.i386_regs
.dr0
, ctx
.debug
.i386_regs
.dr1
, ctx
.debug
.i386_regs
.dr2
,
603 ctx
.debug
.i386_regs
.dr3
, ctx
.debug
.i386_regs
.dr6
, ctx
.debug
.i386_regs
.dr7
);
604 if (ctx
.flags
& SERVER_CTX_FLOATING_POINT
)
606 fprintf( stderr
, ",fp.ctrl=%08x,fp.status=%08x,fp.tag=%08x,fp.err_off=%08x,fp.err_sel=%08x",
607 ctx
.fp
.i386_regs
.ctrl
, ctx
.fp
.i386_regs
.status
, ctx
.fp
.i386_regs
.tag
,
608 ctx
.fp
.i386_regs
.err_off
, ctx
.fp
.i386_regs
.err_sel
);
609 fprintf( stderr
, ",fp.data_off=%08x,fp.data_sel=%08x,fp.cr0npx=%08x",
610 ctx
.fp
.i386_regs
.data_off
, ctx
.fp
.i386_regs
.data_sel
, ctx
.fp
.i386_regs
.cr0npx
);
611 for (i
= 0; i
< 8; i
++)
614 memcpy( ®
, &ctx
.fp
.i386_regs
.regs
[10 * i
], 10 );
615 fprintf( stderr
, ",fp.reg%u=%Lg", i
, reg
);
618 if (ctx
.flags
& SERVER_CTX_EXTENDED_REGISTERS
)
619 dump_uints( ",extended=", (const unsigned int *)ctx
.ext
.i386_regs
,
620 sizeof(ctx
.ext
.i386_regs
) / sizeof(int) );
623 if (ctx
.flags
& SERVER_CTX_CONTROL
)
625 dump_uint64( ",rip=", &ctx
.ctl
.x86_64_regs
.rip
);
626 dump_uint64( ",rbp=", &ctx
.ctl
.x86_64_regs
.rbp
);
627 dump_uint64( ",rsp=", &ctx
.ctl
.x86_64_regs
.rsp
);
628 fprintf( stderr
, ",cs=%04x,ss=%04x,flags=%08x",
629 ctx
.ctl
.x86_64_regs
.cs
, ctx
.ctl
.x86_64_regs
.ss
, ctx
.ctl
.x86_64_regs
.flags
);
631 if (ctx
.flags
& SERVER_CTX_INTEGER
)
633 dump_uint64( ",rax=", &ctx
.integer
.x86_64_regs
.rax
);
634 dump_uint64( ",rbx=", &ctx
.integer
.x86_64_regs
.rbx
);
635 dump_uint64( ",rcx=", &ctx
.integer
.x86_64_regs
.rcx
);
636 dump_uint64( ",rdx=", &ctx
.integer
.x86_64_regs
.rdx
);
637 dump_uint64( ",rsi=", &ctx
.integer
.x86_64_regs
.rsi
);
638 dump_uint64( ",rdi=", &ctx
.integer
.x86_64_regs
.rdi
);
639 dump_uint64( ",r8=", &ctx
.integer
.x86_64_regs
.r8
);
640 dump_uint64( ",r9=", &ctx
.integer
.x86_64_regs
.r9
);
641 dump_uint64( ",r10=", &ctx
.integer
.x86_64_regs
.r10
);
642 dump_uint64( ",r11=", &ctx
.integer
.x86_64_regs
.r11
);
643 dump_uint64( ",r12=", &ctx
.integer
.x86_64_regs
.r12
);
644 dump_uint64( ",r13=", &ctx
.integer
.x86_64_regs
.r13
);
645 dump_uint64( ",r14=", &ctx
.integer
.x86_64_regs
.r14
);
646 dump_uint64( ",r15=", &ctx
.integer
.x86_64_regs
.r15
);
648 if (ctx
.flags
& SERVER_CTX_SEGMENTS
)
649 fprintf( stderr
, ",ds=%04x,es=%04x,fs=%04x,gs=%04x",
650 ctx
.seg
.x86_64_regs
.ds
, ctx
.seg
.x86_64_regs
.es
,
651 ctx
.seg
.x86_64_regs
.fs
, ctx
.seg
.x86_64_regs
.gs
);
652 if (ctx
.flags
& SERVER_CTX_DEBUG_REGISTERS
)
654 dump_uint64( ",dr0=", &ctx
.debug
.x86_64_regs
.dr0
);
655 dump_uint64( ",dr1=", &ctx
.debug
.x86_64_regs
.dr1
);
656 dump_uint64( ",dr2=", &ctx
.debug
.x86_64_regs
.dr2
);
657 dump_uint64( ",dr3=", &ctx
.debug
.x86_64_regs
.dr3
);
658 dump_uint64( ",dr6=", &ctx
.debug
.x86_64_regs
.dr6
);
659 dump_uint64( ",dr7=", &ctx
.debug
.x86_64_regs
.dr7
);
661 if (ctx
.flags
& SERVER_CTX_FLOATING_POINT
)
663 for (i
= 0; i
< 32; i
++)
664 fprintf( stderr
, ",fp%u=%08x%08x%08x%08x", i
,
665 (unsigned int)(ctx
.fp
.x86_64_regs
.fpregs
[i
].high
>> 32),
666 (unsigned int)ctx
.fp
.x86_64_regs
.fpregs
[i
].high
,
667 (unsigned int)(ctx
.fp
.x86_64_regs
.fpregs
[i
].low
>> 32),
668 (unsigned int)ctx
.fp
.x86_64_regs
.fpregs
[i
].low
);
672 if (ctx
.flags
& SERVER_CTX_CONTROL
)
673 fprintf( stderr
, ",iar=%08x,msr=%08x,ctr=%08x,lr=%08x,dar=%08x,dsisr=%08x,trap=%08x",
674 ctx
.ctl
.powerpc_regs
.iar
, ctx
.ctl
.powerpc_regs
.msr
, ctx
.ctl
.powerpc_regs
.ctr
,
675 ctx
.ctl
.powerpc_regs
.lr
, ctx
.ctl
.powerpc_regs
.dar
, ctx
.ctl
.powerpc_regs
.dsisr
,
676 ctx
.ctl
.powerpc_regs
.trap
);
677 if (ctx
.flags
& SERVER_CTX_INTEGER
)
679 for (i
= 0; i
< 32; i
++) fprintf( stderr
, ",gpr%u=%08x", i
, ctx
.integer
.powerpc_regs
.gpr
[i
] );
680 fprintf( stderr
, ",cr=%08x,xer=%08x",
681 ctx
.integer
.powerpc_regs
.cr
, ctx
.integer
.powerpc_regs
.xer
);
683 if (ctx
.flags
& SERVER_CTX_DEBUG_REGISTERS
)
684 for (i
= 0; i
< 8; i
++) fprintf( stderr
, ",dr%u=%08x", i
, ctx
.debug
.powerpc_regs
.dr
[i
] );
685 if (ctx
.flags
& SERVER_CTX_FLOATING_POINT
)
687 for (i
= 0; i
< 32; i
++) fprintf( stderr
, ",fpr%u=%g", i
, ctx
.fp
.powerpc_regs
.fpr
[i
] );
688 fprintf( stderr
, ",fpscr=%g", ctx
.fp
.powerpc_regs
.fpscr
);
692 if (ctx
.flags
& SERVER_CTX_CONTROL
)
693 fprintf( stderr
, ",sp=%08x,lr=%08x,pc=%08x,cpsr=%08x",
694 ctx
.ctl
.arm_regs
.sp
, ctx
.ctl
.arm_regs
.lr
,
695 ctx
.ctl
.arm_regs
.pc
, ctx
.ctl
.arm_regs
.cpsr
);
696 if (ctx
.flags
& SERVER_CTX_INTEGER
)
697 for (i
= 0; i
< 13; i
++) fprintf( stderr
, ",r%u=%08x", i
, ctx
.integer
.arm_regs
.r
[i
] );
698 if (ctx
.flags
& SERVER_CTX_DEBUG_REGISTERS
)
700 for (i
= 0; i
< 8; i
++)
701 fprintf( stderr
, ",bcr%u=%08x,bvr%u=%08x",
702 i
, ctx
.debug
.arm_regs
.bcr
[i
], i
, ctx
.debug
.arm_regs
.bvr
[i
] );
703 fprintf( stderr
, ",wcr0=%08x,wvr0=%08x",
704 ctx
.debug
.arm_regs
.wcr
[0], ctx
.debug
.arm_regs
.wvr
[0] );
706 if (ctx
.flags
& SERVER_CTX_FLOATING_POINT
)
708 for (i
= 0; i
< 32; i
++)
710 fprintf( stderr
, ",d%u=", i
);
711 dump_uint64( "", &ctx
.fp
.arm_regs
.d
[i
] );
713 fprintf( stderr
, ",fpscr=%08x", ctx
.fp
.arm_regs
.fpscr
);
717 if (ctx
.flags
& SERVER_CTX_CONTROL
)
719 dump_uint64( ",sp=", &ctx
.ctl
.arm64_regs
.sp
);
720 dump_uint64( ",pc=", &ctx
.ctl
.arm64_regs
.pc
);
721 dump_uint64( ",pstate=", &ctx
.ctl
.arm64_regs
.pstate
);
723 if (ctx
.flags
& SERVER_CTX_INTEGER
)
725 for (i
= 0; i
< 31; i
++)
727 fprintf( stderr
, ",x%u=", i
);
728 dump_uint64( "", &ctx
.integer
.arm64_regs
.x
[i
] );
731 if (ctx
.flags
& SERVER_CTX_DEBUG_REGISTERS
)
733 for (i
= 0; i
< 8; i
++)
735 fprintf( stderr
, ",bcr%u=%08x,bvr%u=", i
, ctx
.debug
.arm64_regs
.bcr
[i
], i
);
736 dump_uint64( "", &ctx
.debug
.arm64_regs
.bvr
[i
] );
738 for (i
= 0; i
< 2; i
++)
740 fprintf( stderr
, ",wcr%u=%08x,wvr%u=", i
, ctx
.debug
.arm64_regs
.wcr
[i
], i
);
741 dump_uint64( "", &ctx
.debug
.arm64_regs
.wvr
[i
] );
744 if (ctx
.flags
& SERVER_CTX_FLOATING_POINT
)
746 for (i
= 0; i
< 32; i
++)
748 fprintf( stderr
, ",q%u=", i
);
749 dump_uint64( "", &ctx
.fp
.arm64_regs
.q
[i
].high
);
750 dump_uint64( "", &ctx
.fp
.arm64_regs
.q
[i
].low
);
752 fprintf( stderr
, ",fpcr=%08x,fpsr=%08x", ctx
.fp
.arm64_regs
.fpcr
, ctx
.fp
.arm64_regs
.fpsr
);
756 fputc( '}', stderr
);
760 static void dump_varargs_debug_event( const char *prefix
, data_size_t size
)
767 fprintf( stderr
, "%s{}", prefix
);
770 size
= min( size
, sizeof(event
) );
771 memset( &event
, 0, sizeof(event
) );
772 memcpy( &event
, cur_data
, size
);
776 case EXCEPTION_DEBUG_EVENT
:
777 fprintf( stderr
, "%s{exception,first=%d,exc_code=%08x,flags=%08x", prefix
,
778 event
.exception
.first
, event
.exception
.exc_code
, event
.exception
.flags
);
779 dump_uint64( ",record=", &event
.exception
.record
);
780 dump_uint64( ",address=", &event
.exception
.address
);
781 fprintf( stderr
, ",params={" );
782 event
.exception
.nb_params
= min( event
.exception
.nb_params
, EXCEPTION_MAXIMUM_PARAMETERS
);
783 for (i
= 0; i
< event
.exception
.nb_params
; i
++)
785 dump_uint64( "", &event
.exception
.params
[i
] );
786 if (i
< event
.exception
.nb_params
) fputc( ',', stderr
);
788 fprintf( stderr
, "}}" );
790 case CREATE_THREAD_DEBUG_EVENT
:
791 fprintf( stderr
, "%s{create_thread,thread=%04x", prefix
, event
.create_thread
.handle
);
792 dump_uint64( ",teb=", &event
.create_thread
.teb
);
793 dump_uint64( ",start=", &event
.create_thread
.start
);
794 fputc( '}', stderr
);
796 case CREATE_PROCESS_DEBUG_EVENT
:
797 fprintf( stderr
, "%s{create_process,file=%04x,process=%04x,thread=%04x", prefix
,
798 event
.create_process
.file
, event
.create_process
.process
,
799 event
.create_process
.thread
);
800 dump_uint64( ",base=", &event
.create_process
.base
);
801 fprintf( stderr
, ",offset=%d,size=%d",
802 event
.create_process
.dbg_offset
, event
.create_process
.dbg_size
);
803 dump_uint64( ",teb=", &event
.create_process
.teb
);
804 dump_uint64( ",start=", &event
.create_process
.start
);
805 dump_uint64( ",name=", &event
.create_process
.name
);
806 fprintf( stderr
, ",unicode=%d}", event
.create_process
.unicode
);
808 case EXIT_THREAD_DEBUG_EVENT
:
809 fprintf( stderr
, "%s{exit_thread,code=%d}", prefix
, event
.exit
.exit_code
);
811 case EXIT_PROCESS_DEBUG_EVENT
:
812 fprintf( stderr
, "%s{exit_process,code=%d}", prefix
, event
.exit
.exit_code
);
814 case LOAD_DLL_DEBUG_EVENT
:
815 fprintf( stderr
, "%s{load_dll,file=%04x", prefix
, event
.load_dll
.handle
);
816 dump_uint64( ",base=", &event
.load_dll
.base
);
817 fprintf( stderr
, ",offset=%d,size=%d",
818 event
.load_dll
.dbg_offset
, event
.load_dll
.dbg_size
);
819 dump_uint64( ",name=", &event
.load_dll
.name
);
820 fprintf( stderr
, ",unicode=%d}", event
.load_dll
.unicode
);
822 case UNLOAD_DLL_DEBUG_EVENT
:
823 fprintf( stderr
, "%s{unload_dll", prefix
);
824 dump_uint64( ",base=", &event
.unload_dll
.base
);
825 fputc( '}', stderr
);
827 case 0: /* zero is the code returned on timeouts */
828 fprintf( stderr
, "%s{}", prefix
);
831 fprintf( stderr
, "%s{code=??? (%d)}", prefix
, event
.code
);
837 /* dump a unicode string contained in a buffer; helper for dump_varargs_startup_info */
838 static data_size_t
dump_inline_unicode_string( const char *prefix
, data_size_t pos
, data_size_t len
, data_size_t total_size
)
840 fputs( prefix
, stderr
);
841 if (pos
>= total_size
) return pos
;
842 if (len
> total_size
- pos
) len
= total_size
- pos
;
843 dump_strW( (const WCHAR
*)cur_data
+ pos
/sizeof(WCHAR
), len
, stderr
, "\"\"" );
844 return pos
+ (len
/ sizeof(WCHAR
)) * sizeof(WCHAR
);
847 static void dump_varargs_startup_info( const char *prefix
, data_size_t size
)
850 data_size_t pos
= sizeof(info
);
852 memset( &info
, 0, sizeof(info
) );
853 memcpy( &info
, cur_data
, min( size
, sizeof(info
) ));
856 "%s{debug_flags=%x,console_flags=%x,console=%04x,hstdin=%04x,hstdout=%04x,hstderr=%04x,"
857 "x=%u,y=%u,xsize=%u,ysize=%u,xchars=%u,ychars=%u,attribute=%02x,flags=%x,show=%u",
858 prefix
, info
.debug_flags
, info
.console_flags
, info
.console
,
859 info
.hstdin
, info
.hstdout
, info
.hstderr
, info
.x
, info
.y
, info
.xsize
, info
.ysize
,
860 info
.xchars
, info
.ychars
, info
.attribute
, info
.flags
, info
.show
);
861 pos
= dump_inline_unicode_string( ",curdir=L\"", pos
, info
.curdir_len
, size
);
862 pos
= dump_inline_unicode_string( "\",dllpath=L\"", pos
, info
.dllpath_len
, size
);
863 pos
= dump_inline_unicode_string( "\",imagepath=L\"", pos
, info
.imagepath_len
, size
);
864 pos
= dump_inline_unicode_string( "\",cmdline=L\"", pos
, info
.cmdline_len
, size
);
865 pos
= dump_inline_unicode_string( "\",title=L\"", pos
, info
.title_len
, size
);
866 pos
= dump_inline_unicode_string( "\",desktop=L\"", pos
, info
.desktop_len
, size
);
867 pos
= dump_inline_unicode_string( "\",shellinfo=L\"", pos
, info
.shellinfo_len
, size
);
868 pos
= dump_inline_unicode_string( "\",runtime=L\"", pos
, info
.runtime_len
, size
);
869 fprintf( stderr
, "\"}" );
873 static void dump_varargs_rectangles( const char *prefix
, data_size_t size
)
875 const rectangle_t
*rect
= cur_data
;
876 data_size_t len
= size
/ sizeof(*rect
);
878 fprintf( stderr
,"%s{", prefix
);
881 dump_rectangle( "", rect
++ );
882 if (--len
) fputc( ',', stderr
);
884 fputc( '}', stderr
);
888 static void dump_varargs_message_data( const char *prefix
, data_size_t size
)
890 /* FIXME: dump the structured data */
891 dump_varargs_bytes( prefix
, size
);
894 static void dump_varargs_properties( const char *prefix
, data_size_t size
)
896 const property_data_t
*prop
= cur_data
;
897 data_size_t len
= size
/ sizeof(*prop
);
899 fprintf( stderr
,"%s{", prefix
);
902 fprintf( stderr
, "{atom=%04x,str=%d", prop
->atom
, prop
->string
);
903 dump_uint64( ",data=", &prop
->data
);
904 fputc( '}', stderr
);
906 if (--len
) fputc( ',', stderr
);
908 fputc( '}', stderr
);
912 static void dump_varargs_LUID_AND_ATTRIBUTES( const char *prefix
, data_size_t size
)
914 const LUID_AND_ATTRIBUTES
*lat
= cur_data
;
915 data_size_t len
= size
/ sizeof(*lat
);
917 fprintf( stderr
,"%s{", prefix
);
920 fprintf( stderr
, "{luid=%08x%08x,attr=%x}",
921 lat
->Luid
.HighPart
, lat
->Luid
.LowPart
, lat
->Attributes
);
923 if (--len
) fputc( ',', stderr
);
925 fputc( '}', stderr
);
929 static void dump_inline_sid( const char *prefix
, const SID
*sid
, data_size_t size
)
934 if ((FIELD_OFFSET(SID
, SubAuthority
[0]) > size
) ||
935 (FIELD_OFFSET(SID
, SubAuthority
[sid
->SubAuthorityCount
]) > size
))
937 fprintf( stderr
, "<invalid sid>" );
941 fprintf( stderr
,"%s{", prefix
);
942 fprintf( stderr
, "S-%u-%u", sid
->Revision
, MAKELONG(
943 MAKEWORD( sid
->IdentifierAuthority
.Value
[5],
944 sid
->IdentifierAuthority
.Value
[4] ),
945 MAKEWORD( sid
->IdentifierAuthority
.Value
[3],
946 sid
->IdentifierAuthority
.Value
[2] ) ) );
947 for (i
= 0; i
< sid
->SubAuthorityCount
; i
++)
948 fprintf( stderr
, "-%u", sid
->SubAuthority
[i
] );
949 fputc( '}', stderr
);
952 static void dump_varargs_SID( const char *prefix
, data_size_t size
)
954 const SID
*sid
= cur_data
;
955 dump_inline_sid( prefix
, sid
, size
);
959 static void dump_inline_acl( const char *prefix
, const ACL
*acl
, data_size_t size
)
961 const ACE_HEADER
*ace
;
964 fprintf( stderr
,"%s{", prefix
);
967 if (size
< sizeof(ACL
))
969 fprintf( stderr
, "<invalid acl>}" );
973 ace
= (const ACE_HEADER
*)(acl
+ 1);
974 for (i
= 0; i
< acl
->AceCount
; i
++)
976 const SID
*sid
= NULL
;
977 data_size_t sid_size
= 0;
979 if (size
< sizeof(ACE_HEADER
) || size
< ace
->AceSize
) break;
980 size
-= ace
->AceSize
;
981 if (i
!= 0) fputc( ',', stderr
);
982 fprintf( stderr
, "{AceType=" );
983 switch (ace
->AceType
)
985 case ACCESS_DENIED_ACE_TYPE
:
986 sid
= (const SID
*)&((const ACCESS_DENIED_ACE
*)ace
)->SidStart
;
987 sid_size
= ace
->AceSize
- FIELD_OFFSET(ACCESS_DENIED_ACE
, SidStart
);
988 fprintf( stderr
, "ACCESS_DENIED_ACE_TYPE,Mask=%x",
989 ((const ACCESS_DENIED_ACE
*)ace
)->Mask
);
991 case ACCESS_ALLOWED_ACE_TYPE
:
992 sid
= (const SID
*)&((const ACCESS_ALLOWED_ACE
*)ace
)->SidStart
;
993 sid_size
= ace
->AceSize
- FIELD_OFFSET(ACCESS_ALLOWED_ACE
, SidStart
);
994 fprintf( stderr
, "ACCESS_ALLOWED_ACE_TYPE,Mask=%x",
995 ((const ACCESS_ALLOWED_ACE
*)ace
)->Mask
);
997 case SYSTEM_AUDIT_ACE_TYPE
:
998 sid
= (const SID
*)&((const SYSTEM_AUDIT_ACE
*)ace
)->SidStart
;
999 sid_size
= ace
->AceSize
- FIELD_OFFSET(SYSTEM_AUDIT_ACE
, SidStart
);
1000 fprintf( stderr
, "SYSTEM_AUDIT_ACE_TYPE,Mask=%x",
1001 ((const SYSTEM_AUDIT_ACE
*)ace
)->Mask
);
1003 case SYSTEM_ALARM_ACE_TYPE
:
1004 sid
= (const SID
*)&((const SYSTEM_ALARM_ACE
*)ace
)->SidStart
;
1005 sid_size
= ace
->AceSize
- FIELD_OFFSET(SYSTEM_ALARM_ACE
, SidStart
);
1006 fprintf( stderr
, "SYSTEM_ALARM_ACE_TYPE,Mask=%x",
1007 ((const SYSTEM_ALARM_ACE
*)ace
)->Mask
);
1009 case SYSTEM_MANDATORY_LABEL_ACE_TYPE
:
1010 sid
= (const SID
*)&((const SYSTEM_MANDATORY_LABEL_ACE
*)ace
)->SidStart
;
1011 sid_size
= ace
->AceSize
- FIELD_OFFSET(SYSTEM_MANDATORY_LABEL_ACE
, SidStart
);
1012 fprintf( stderr
, "SYSTEM_MANDATORY_LABEL_ACE_TYPE,Mask=%x",
1013 ((const SYSTEM_MANDATORY_LABEL_ACE
*)ace
)->Mask
);
1016 fprintf( stderr
, "unknown<%d>", ace
->AceType
);
1019 fprintf( stderr
, ",AceFlags=%x", ace
->AceFlags
);
1021 dump_inline_sid( ",Sid=", sid
, sid_size
);
1022 ace
= (const ACE_HEADER
*)((const char *)ace
+ ace
->AceSize
);
1023 fputc( '}', stderr
);
1026 fputc( '}', stderr
);
1029 static void dump_varargs_ACL( const char *prefix
, data_size_t size
)
1031 const ACL
*acl
= cur_data
;
1032 dump_inline_acl( prefix
, acl
, size
);
1033 remove_data( size
);
1036 static void dump_inline_security_descriptor( const char *prefix
, const struct security_descriptor
*sd
, data_size_t size
)
1038 fprintf( stderr
,"%s{", prefix
);
1039 if (size
>= sizeof(struct security_descriptor
))
1041 size_t offset
= sizeof(struct security_descriptor
);
1042 fprintf( stderr
, "control=%08x", sd
->control
);
1043 if ((sd
->owner_len
> FIELD_OFFSET(SID
, SubAuthority
[255])) || (offset
+ sd
->owner_len
> size
))
1046 dump_inline_sid( ",owner=", (const SID
*)((const char *)sd
+ offset
), sd
->owner_len
);
1048 fprintf( stderr
, ",owner=<not present>" );
1049 offset
+= sd
->owner_len
;
1050 if ((sd
->group_len
> FIELD_OFFSET(SID
, SubAuthority
[255])) || (offset
+ sd
->group_len
> size
))
1053 dump_inline_sid( ",group=", (const SID
*)((const char *)sd
+ offset
), sd
->group_len
);
1055 fprintf( stderr
, ",group=<not present>" );
1056 offset
+= sd
->group_len
;
1057 if ((sd
->sacl_len
>= MAX_ACL_LEN
) || (offset
+ sd
->sacl_len
> size
))
1059 dump_inline_acl( ",sacl=", (const ACL
*)((const char *)sd
+ offset
), sd
->sacl_len
);
1060 offset
+= sd
->sacl_len
;
1061 if ((sd
->dacl_len
>= MAX_ACL_LEN
) || (offset
+ sd
->dacl_len
> size
))
1063 dump_inline_acl( ",dacl=", (const ACL
*)((const char *)sd
+ offset
), sd
->dacl_len
);
1064 offset
+= sd
->dacl_len
;
1066 fputc( '}', stderr
);
1069 static void dump_varargs_security_descriptor( const char *prefix
, data_size_t size
)
1071 const struct security_descriptor
*sd
= cur_data
;
1072 dump_inline_security_descriptor( prefix
, sd
, size
);
1073 remove_data( size
);
1076 static void dump_varargs_token_groups( const char *prefix
, data_size_t size
)
1078 const struct token_groups
*tg
= cur_data
;
1080 fprintf( stderr
,"%s{", prefix
);
1081 if (size
>= sizeof(struct token_groups
))
1083 size_t offset
= sizeof(*tg
);
1084 fprintf( stderr
, "count=%08x,", tg
->count
);
1085 if (tg
->count
* sizeof(unsigned int) <= size
)
1088 const unsigned int *attr
= (const unsigned int *)(tg
+ 1);
1090 offset
+= tg
->count
* sizeof(unsigned int);
1092 fputc( '[', stderr
);
1093 for (i
= 0; i
< tg
->count
; i
++)
1095 const SID
*sid
= (const SID
*)((const char *)cur_data
+ offset
);
1097 fputc( ',', stderr
);
1098 fputc( '{', stderr
);
1099 fprintf( stderr
, "attributes=%08x", attr
[i
] );
1100 dump_inline_sid( ",sid=", sid
, size
- offset
);
1101 if ((offset
+ FIELD_OFFSET(SID
, SubAuthority
[0]) > size
) ||
1102 (offset
+ FIELD_OFFSET(SID
, SubAuthority
[sid
->SubAuthorityCount
]) > size
))
1104 offset
+= FIELD_OFFSET(SID
, SubAuthority
[sid
->SubAuthorityCount
]);
1105 fputc( '}', stderr
);
1107 fputc( ']', stderr
);
1110 fputc( '}', stderr
);
1113 static void dump_varargs_process_info( const char *prefix
, data_size_t size
)
1115 data_size_t pos
= 0;
1118 fprintf( stderr
,"%s{", prefix
);
1120 while (size
- pos
>= sizeof(struct process_info
))
1122 const struct process_info
*process
;
1123 pos
= (pos
+ 7) & ~7;
1124 process
= (const struct process_info
*)((const char *)cur_data
+ pos
);
1125 if (size
- pos
< sizeof(*process
)) break;
1126 if (pos
) fputc( ',', stderr
);
1127 dump_timeout( "{start_time=", &process
->start_time
);
1128 fprintf( stderr
, ",thread_count=%u,priority=%d,pid=%04x,parent_pid=%04x,handle_count=%u,unix_pid=%d,",
1129 process
->thread_count
, process
->priority
, process
->pid
,
1130 process
->parent_pid
, process
->handle_count
, process
->unix_pid
);
1131 pos
+= sizeof(*process
);
1133 pos
= dump_inline_unicode_string( "name=L\"", pos
, process
->name_len
, size
);
1135 pos
= (pos
+ 7) & ~7;
1136 fprintf( stderr
, "\",threads={" );
1137 for (i
= 0; i
< process
->thread_count
; i
++)
1139 const struct thread_info
*thread
= (const struct thread_info
*)((const char *)cur_data
+ pos
);
1140 if (size
- pos
< sizeof(*thread
)) break;
1141 if (i
) fputc( ',', stderr
);
1142 dump_timeout( "{start_time=", &thread
->start_time
);
1143 fprintf( stderr
, ",tid=%04x,base_priority=%d,current_priority=%d,unix_tid=%d}",
1144 thread
->tid
, thread
->base_priority
, thread
->current_priority
, thread
->unix_tid
);
1145 pos
+= sizeof(*thread
);
1147 fprintf( stderr
, "}}" );
1149 fputc( '}', stderr
);
1150 remove_data( size
);
1153 static void dump_varargs_object_attributes( const char *prefix
, data_size_t size
)
1155 const struct object_attributes
*objattr
= cur_data
;
1157 fprintf( stderr
,"%s{", prefix
);
1162 if (size
< sizeof(*objattr
) ||
1163 (size
- sizeof(*objattr
) < objattr
->sd_len
) ||
1164 (size
- sizeof(*objattr
) - objattr
->sd_len
< objattr
->name_len
))
1166 fprintf( stderr
, "***invalid***}" );
1167 remove_data( size
);
1171 fprintf( stderr
, "rootdir=%04x,attributes=%08x", objattr
->rootdir
, objattr
->attributes
);
1172 dump_inline_security_descriptor( ",sd=", (const struct security_descriptor
*)(objattr
+ 1), objattr
->sd_len
);
1173 str
= (const WCHAR
*)objattr
+ (sizeof(*objattr
) + objattr
->sd_len
) / sizeof(WCHAR
);
1174 fprintf( stderr
, ",name=L\"" );
1175 dump_strW( str
, objattr
->name_len
, stderr
, "\"\"" );
1176 fputc( '\"', stderr
);
1177 remove_data( (sizeof(*objattr
) + (objattr
->sd_len
& ~1) + (objattr
->name_len
& ~1) + 3) & ~3 );
1179 fputc( '}', stderr
);
1182 static void dump_varargs_filesystem_event( const char *prefix
, data_size_t size
)
1184 static const char * const actions
[] = {
1196 fprintf( stderr
,"%s{", prefix
);
1199 const struct filesystem_event
*event
= cur_data
;
1200 data_size_t len
= (offsetof( struct filesystem_event
, name
[event
->len
] ) + sizeof(int)-1)
1201 / sizeof(int) * sizeof(int);
1202 if (size
< len
) break;
1203 if (event
->action
< ARRAY_SIZE( actions
) && actions
[event
->action
])
1204 fprintf( stderr
, "{action=%s", actions
[event
->action
] );
1206 fprintf( stderr
, "{action=%u", event
->action
);
1207 fprintf( stderr
, ",name=\"%.*s\"}", event
->len
, event
->name
);
1210 if (size
)fputc( ',', stderr
);
1212 fputc( '}', stderr
);
1215 static void dump_varargs_pe_image_info( const char *prefix
, data_size_t size
)
1217 pe_image_info_t info
;
1221 fprintf( stderr
, "%s{}", prefix
);
1224 memset( &info
, 0, sizeof(info
) );
1225 memcpy( &info
, cur_data
, min( size
, sizeof(info
) ));
1227 fprintf( stderr
, "%s{", prefix
);
1228 dump_uint64( "base=", &info
.base
);
1229 dump_uint64( ",entry_point=", &info
.entry_point
);
1230 dump_uint64( ",map_size=", &info
.map_size
);
1231 dump_uint64( ",stack_size=", &info
.stack_size
);
1232 dump_uint64( ",stack_commit=", &info
.stack_commit
);
1233 fprintf( stderr
, ",zerobits=%08x,subsystem=%08x,subsystem_low=%04x,subsystem_high=%04x,gp=%08x"
1234 ",image_charact=%04x,dll_charact=%04x,machine=%04x,contains_code=%u,image_flags=%02x"
1235 ",loader_flags=%08x,header_size=%08x,file_size=%08x,checksum=%08x",
1236 info
.zerobits
, info
.subsystem
, info
.subsystem_low
, info
.subsystem_high
, info
.gp
,
1237 info
.image_charact
, info
.dll_charact
, info
.machine
, info
.contains_code
, info
.image_flags
,
1238 info
.loader_flags
, info
.header_size
, info
.file_size
, info
.checksum
);
1239 dump_client_cpu( ",cpu=", &info
.cpu
);
1240 fputc( '}', stderr
);
1241 remove_data( size
);
1244 static void dump_varargs_rawinput_devices(const char *prefix
, data_size_t size
)
1246 const struct rawinput_device
*device
;
1248 fprintf( stderr
, "%s{", prefix
);
1249 while (size
>= sizeof(*device
))
1252 fprintf( stderr
, "{usage_page=%04x,usage=%04x,flags=%08x,target=%08x}",
1253 device
->usage_page
, device
->usage
, device
->flags
, device
->target
);
1254 size
-= sizeof(*device
);
1255 remove_data( sizeof(*device
) );
1256 if (size
) fputc( ',', stderr
);
1258 fputc( '}', stderr
);
1261 static void dump_varargs_handle_infos( const char *prefix
, data_size_t size
)
1263 const struct handle_info
*handle
;
1265 fprintf( stderr
, "%s{", prefix
);
1266 while (size
>= sizeof(*handle
))
1269 fprintf( stderr
, "{owner=%04x,handle=%04x,access=%08x}",
1270 handle
->owner
, handle
->handle
, handle
->access
);
1271 size
-= sizeof(*handle
);
1272 remove_data( sizeof(*handle
) );
1273 if (size
) fputc( ',', stderr
);
1275 fputc( '}', stderr
);
1278 typedef void (*dump_func
)( const void *req
);
1280 /* Everything below this line is generated automatically by tools/make_requests */
1281 /* ### make_requests begin ### */
1283 static void dump_new_process_request( const struct new_process_request
*req
)
1285 fprintf( stderr
, " parent_process=%04x", req
->parent_process
);
1286 fprintf( stderr
, ", inherit_all=%d", req
->inherit_all
);
1287 fprintf( stderr
, ", create_flags=%08x", req
->create_flags
);
1288 fprintf( stderr
, ", socket_fd=%d", req
->socket_fd
);
1289 fprintf( stderr
, ", exe_file=%04x", req
->exe_file
);
1290 fprintf( stderr
, ", access=%08x", req
->access
);
1291 dump_client_cpu( ", cpu=", &req
->cpu
);
1292 fprintf( stderr
, ", info_size=%u", req
->info_size
);
1293 dump_varargs_object_attributes( ", objattr=", cur_size
);
1294 dump_varargs_startup_info( ", info=", min(cur_size
,req
->info_size
) );
1295 dump_varargs_unicode_str( ", env=", cur_size
);
1298 static void dump_new_process_reply( const struct new_process_reply
*req
)
1300 fprintf( stderr
, " info=%04x", req
->info
);
1301 fprintf( stderr
, ", pid=%04x", req
->pid
);
1302 fprintf( stderr
, ", handle=%04x", req
->handle
);
1305 static void dump_exec_process_request( const struct exec_process_request
*req
)
1307 fprintf( stderr
, " socket_fd=%d", req
->socket_fd
);
1308 dump_client_cpu( ", cpu=", &req
->cpu
);
1311 static void dump_get_new_process_info_request( const struct get_new_process_info_request
*req
)
1313 fprintf( stderr
, " info=%04x", req
->info
);
1316 static void dump_get_new_process_info_reply( const struct get_new_process_info_reply
*req
)
1318 fprintf( stderr
, " success=%d", req
->success
);
1319 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1322 static void dump_new_thread_request( const struct new_thread_request
*req
)
1324 fprintf( stderr
, " process=%04x", req
->process
);
1325 fprintf( stderr
, ", access=%08x", req
->access
);
1326 fprintf( stderr
, ", suspend=%d", req
->suspend
);
1327 fprintf( stderr
, ", request_fd=%d", req
->request_fd
);
1328 dump_varargs_object_attributes( ", objattr=", cur_size
);
1331 static void dump_new_thread_reply( const struct new_thread_reply
*req
)
1333 fprintf( stderr
, " tid=%04x", req
->tid
);
1334 fprintf( stderr
, ", handle=%04x", req
->handle
);
1337 static void dump_get_startup_info_request( const struct get_startup_info_request
*req
)
1341 static void dump_get_startup_info_reply( const struct get_startup_info_reply
*req
)
1343 fprintf( stderr
, " info_size=%u", req
->info_size
);
1344 dump_varargs_startup_info( ", info=", min(cur_size
,req
->info_size
) );
1345 dump_varargs_unicode_str( ", env=", cur_size
);
1348 static void dump_init_process_done_request( const struct init_process_done_request
*req
)
1350 fprintf( stderr
, " gui=%d", req
->gui
);
1351 dump_uint64( ", module=", &req
->module
);
1352 dump_uint64( ", ldt_copy=", &req
->ldt_copy
);
1353 dump_uint64( ", entry=", &req
->entry
);
1356 static void dump_init_process_done_reply( const struct init_process_done_reply
*req
)
1358 fprintf( stderr
, " suspend=%d", req
->suspend
);
1361 static void dump_init_thread_request( const struct init_thread_request
*req
)
1363 fprintf( stderr
, " unix_pid=%d", req
->unix_pid
);
1364 fprintf( stderr
, ", unix_tid=%d", req
->unix_tid
);
1365 fprintf( stderr
, ", debug_level=%d", req
->debug_level
);
1366 dump_uint64( ", teb=", &req
->teb
);
1367 dump_uint64( ", entry=", &req
->entry
);
1368 fprintf( stderr
, ", reply_fd=%d", req
->reply_fd
);
1369 fprintf( stderr
, ", wait_fd=%d", req
->wait_fd
);
1370 dump_client_cpu( ", cpu=", &req
->cpu
);
1373 static void dump_init_thread_reply( const struct init_thread_reply
*req
)
1375 fprintf( stderr
, " pid=%04x", req
->pid
);
1376 fprintf( stderr
, ", tid=%04x", req
->tid
);
1377 dump_timeout( ", server_start=", &req
->server_start
);
1378 fprintf( stderr
, ", info_size=%u", req
->info_size
);
1379 fprintf( stderr
, ", version=%d", req
->version
);
1380 fprintf( stderr
, ", all_cpus=%08x", req
->all_cpus
);
1381 fprintf( stderr
, ", suspend=%d", req
->suspend
);
1384 static void dump_terminate_process_request( const struct terminate_process_request
*req
)
1386 fprintf( stderr
, " handle=%04x", req
->handle
);
1387 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1390 static void dump_terminate_process_reply( const struct terminate_process_reply
*req
)
1392 fprintf( stderr
, " self=%d", req
->self
);
1395 static void dump_terminate_thread_request( const struct terminate_thread_request
*req
)
1397 fprintf( stderr
, " handle=%04x", req
->handle
);
1398 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1401 static void dump_terminate_thread_reply( const struct terminate_thread_reply
*req
)
1403 fprintf( stderr
, " self=%d", req
->self
);
1406 static void dump_get_process_info_request( const struct get_process_info_request
*req
)
1408 fprintf( stderr
, " handle=%04x", req
->handle
);
1411 static void dump_get_process_info_reply( const struct get_process_info_reply
*req
)
1413 fprintf( stderr
, " pid=%04x", req
->pid
);
1414 fprintf( stderr
, ", ppid=%04x", req
->ppid
);
1415 dump_uint64( ", affinity=", &req
->affinity
);
1416 dump_uint64( ", peb=", &req
->peb
);
1417 dump_timeout( ", start_time=", &req
->start_time
);
1418 dump_timeout( ", end_time=", &req
->end_time
);
1419 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1420 fprintf( stderr
, ", priority=%d", req
->priority
);
1421 dump_client_cpu( ", cpu=", &req
->cpu
);
1422 fprintf( stderr
, ", debugger_present=%d", req
->debugger_present
);
1423 fprintf( stderr
, ", debug_children=%d", req
->debug_children
);
1424 dump_varargs_pe_image_info( ", image=", cur_size
);
1427 static void dump_get_process_vm_counters_request( const struct get_process_vm_counters_request
*req
)
1429 fprintf( stderr
, " handle=%04x", req
->handle
);
1432 static void dump_get_process_vm_counters_reply( const struct get_process_vm_counters_reply
*req
)
1434 dump_uint64( " peak_virtual_size=", &req
->peak_virtual_size
);
1435 dump_uint64( ", virtual_size=", &req
->virtual_size
);
1436 dump_uint64( ", peak_working_set_size=", &req
->peak_working_set_size
);
1437 dump_uint64( ", working_set_size=", &req
->working_set_size
);
1438 dump_uint64( ", pagefile_usage=", &req
->pagefile_usage
);
1439 dump_uint64( ", peak_pagefile_usage=", &req
->peak_pagefile_usage
);
1442 static void dump_set_process_info_request( const struct set_process_info_request
*req
)
1444 fprintf( stderr
, " handle=%04x", req
->handle
);
1445 fprintf( stderr
, ", mask=%d", req
->mask
);
1446 fprintf( stderr
, ", priority=%d", req
->priority
);
1447 dump_uint64( ", affinity=", &req
->affinity
);
1450 static void dump_get_thread_info_request( const struct get_thread_info_request
*req
)
1452 fprintf( stderr
, " handle=%04x", req
->handle
);
1453 fprintf( stderr
, ", access=%08x", req
->access
);
1456 static void dump_get_thread_info_reply( const struct get_thread_info_reply
*req
)
1458 fprintf( stderr
, " pid=%04x", req
->pid
);
1459 fprintf( stderr
, ", tid=%04x", req
->tid
);
1460 dump_uint64( ", teb=", &req
->teb
);
1461 dump_uint64( ", entry_point=", &req
->entry_point
);
1462 dump_uint64( ", affinity=", &req
->affinity
);
1463 fprintf( stderr
, ", exit_code=%d", req
->exit_code
);
1464 fprintf( stderr
, ", priority=%d", req
->priority
);
1465 fprintf( stderr
, ", last=%d", req
->last
);
1466 fprintf( stderr
, ", suspend_count=%d", req
->suspend_count
);
1467 fprintf( stderr
, ", dbg_hidden=%d", req
->dbg_hidden
);
1468 fprintf( stderr
, ", desc_len=%u", req
->desc_len
);
1469 dump_varargs_unicode_str( ", desc=", cur_size
);
1472 static void dump_get_thread_times_request( const struct get_thread_times_request
*req
)
1474 fprintf( stderr
, " handle=%04x", req
->handle
);
1477 static void dump_get_thread_times_reply( const struct get_thread_times_reply
*req
)
1479 dump_timeout( " creation_time=", &req
->creation_time
);
1480 dump_timeout( ", exit_time=", &req
->exit_time
);
1481 fprintf( stderr
, ", unix_pid=%d", req
->unix_pid
);
1482 fprintf( stderr
, ", unix_tid=%d", req
->unix_tid
);
1485 static void dump_set_thread_info_request( const struct set_thread_info_request
*req
)
1487 fprintf( stderr
, " handle=%04x", req
->handle
);
1488 fprintf( stderr
, ", mask=%d", req
->mask
);
1489 fprintf( stderr
, ", priority=%d", req
->priority
);
1490 dump_uint64( ", affinity=", &req
->affinity
);
1491 dump_uint64( ", entry_point=", &req
->entry_point
);
1492 fprintf( stderr
, ", token=%04x", req
->token
);
1493 dump_varargs_unicode_str( ", desc=", cur_size
);
1496 static void dump_get_dll_info_request( const struct get_dll_info_request
*req
)
1498 fprintf( stderr
, " handle=%04x", req
->handle
);
1499 dump_uint64( ", base_address=", &req
->base_address
);
1502 static void dump_get_dll_info_reply( const struct get_dll_info_reply
*req
)
1504 dump_uint64( " entry_point=", &req
->entry_point
);
1505 fprintf( stderr
, ", filename_len=%u", req
->filename_len
);
1506 dump_varargs_unicode_str( ", filename=", cur_size
);
1509 static void dump_suspend_thread_request( const struct suspend_thread_request
*req
)
1511 fprintf( stderr
, " handle=%04x", req
->handle
);
1514 static void dump_suspend_thread_reply( const struct suspend_thread_reply
*req
)
1516 fprintf( stderr
, " count=%d", req
->count
);
1519 static void dump_resume_thread_request( const struct resume_thread_request
*req
)
1521 fprintf( stderr
, " handle=%04x", req
->handle
);
1524 static void dump_resume_thread_reply( const struct resume_thread_reply
*req
)
1526 fprintf( stderr
, " count=%d", req
->count
);
1529 static void dump_load_dll_request( const struct load_dll_request
*req
)
1531 fprintf( stderr
, " dbg_offset=%u", req
->dbg_offset
);
1532 dump_uint64( ", base=", &req
->base
);
1533 dump_uint64( ", name=", &req
->name
);
1534 fprintf( stderr
, ", dbg_size=%u", req
->dbg_size
);
1535 dump_varargs_unicode_str( ", filename=", cur_size
);
1538 static void dump_unload_dll_request( const struct unload_dll_request
*req
)
1540 dump_uint64( " base=", &req
->base
);
1543 static void dump_queue_apc_request( const struct queue_apc_request
*req
)
1545 fprintf( stderr
, " handle=%04x", req
->handle
);
1546 dump_apc_call( ", call=", &req
->call
);
1549 static void dump_queue_apc_reply( const struct queue_apc_reply
*req
)
1551 fprintf( stderr
, " handle=%04x", req
->handle
);
1552 fprintf( stderr
, ", self=%d", req
->self
);
1555 static void dump_get_apc_result_request( const struct get_apc_result_request
*req
)
1557 fprintf( stderr
, " handle=%04x", req
->handle
);
1560 static void dump_get_apc_result_reply( const struct get_apc_result_reply
*req
)
1562 dump_apc_result( " result=", &req
->result
);
1565 static void dump_close_handle_request( const struct close_handle_request
*req
)
1567 fprintf( stderr
, " handle=%04x", req
->handle
);
1570 static void dump_set_handle_info_request( const struct set_handle_info_request
*req
)
1572 fprintf( stderr
, " handle=%04x", req
->handle
);
1573 fprintf( stderr
, ", flags=%d", req
->flags
);
1574 fprintf( stderr
, ", mask=%d", req
->mask
);
1577 static void dump_set_handle_info_reply( const struct set_handle_info_reply
*req
)
1579 fprintf( stderr
, " old_flags=%d", req
->old_flags
);
1582 static void dump_dup_handle_request( const struct dup_handle_request
*req
)
1584 fprintf( stderr
, " src_process=%04x", req
->src_process
);
1585 fprintf( stderr
, ", src_handle=%04x", req
->src_handle
);
1586 fprintf( stderr
, ", dst_process=%04x", req
->dst_process
);
1587 fprintf( stderr
, ", access=%08x", req
->access
);
1588 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1589 fprintf( stderr
, ", options=%08x", req
->options
);
1592 static void dump_dup_handle_reply( const struct dup_handle_reply
*req
)
1594 fprintf( stderr
, " handle=%04x", req
->handle
);
1595 fprintf( stderr
, ", self=%d", req
->self
);
1596 fprintf( stderr
, ", closed=%d", req
->closed
);
1599 static void dump_make_temporary_request( const struct make_temporary_request
*req
)
1601 fprintf( stderr
, " handle=%04x", req
->handle
);
1604 static void dump_open_process_request( const struct open_process_request
*req
)
1606 fprintf( stderr
, " pid=%04x", req
->pid
);
1607 fprintf( stderr
, ", access=%08x", req
->access
);
1608 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1611 static void dump_open_process_reply( const struct open_process_reply
*req
)
1613 fprintf( stderr
, " handle=%04x", req
->handle
);
1616 static void dump_open_thread_request( const struct open_thread_request
*req
)
1618 fprintf( stderr
, " tid=%04x", req
->tid
);
1619 fprintf( stderr
, ", access=%08x", req
->access
);
1620 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1623 static void dump_open_thread_reply( const struct open_thread_reply
*req
)
1625 fprintf( stderr
, " handle=%04x", req
->handle
);
1628 static void dump_select_request( const struct select_request
*req
)
1630 fprintf( stderr
, " flags=%d", req
->flags
);
1631 dump_uint64( ", cookie=", &req
->cookie
);
1632 dump_abstime( ", timeout=", &req
->timeout
);
1633 fprintf( stderr
, ", size=%u", req
->size
);
1634 fprintf( stderr
, ", prev_apc=%04x", req
->prev_apc
);
1635 dump_varargs_apc_result( ", result=", cur_size
);
1636 dump_varargs_select_op( ", data=", min(cur_size
,req
->size
) );
1637 dump_varargs_context( ", context=", cur_size
);
1640 static void dump_select_reply( const struct select_reply
*req
)
1642 dump_apc_call( " call=", &req
->call
);
1643 fprintf( stderr
, ", apc_handle=%04x", req
->apc_handle
);
1644 dump_varargs_context( ", context=", cur_size
);
1647 static void dump_create_event_request( const struct create_event_request
*req
)
1649 fprintf( stderr
, " access=%08x", req
->access
);
1650 fprintf( stderr
, ", manual_reset=%d", req
->manual_reset
);
1651 fprintf( stderr
, ", initial_state=%d", req
->initial_state
);
1652 dump_varargs_object_attributes( ", objattr=", cur_size
);
1655 static void dump_create_event_reply( const struct create_event_reply
*req
)
1657 fprintf( stderr
, " handle=%04x", req
->handle
);
1660 static void dump_event_op_request( const struct event_op_request
*req
)
1662 fprintf( stderr
, " handle=%04x", req
->handle
);
1663 fprintf( stderr
, ", op=%d", req
->op
);
1666 static void dump_event_op_reply( const struct event_op_reply
*req
)
1668 fprintf( stderr
, " state=%d", req
->state
);
1671 static void dump_query_event_request( const struct query_event_request
*req
)
1673 fprintf( stderr
, " handle=%04x", req
->handle
);
1676 static void dump_query_event_reply( const struct query_event_reply
*req
)
1678 fprintf( stderr
, " manual_reset=%d", req
->manual_reset
);
1679 fprintf( stderr
, ", state=%d", req
->state
);
1682 static void dump_open_event_request( const struct open_event_request
*req
)
1684 fprintf( stderr
, " access=%08x", req
->access
);
1685 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1686 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1687 dump_varargs_unicode_str( ", name=", cur_size
);
1690 static void dump_open_event_reply( const struct open_event_reply
*req
)
1692 fprintf( stderr
, " handle=%04x", req
->handle
);
1695 static void dump_create_keyed_event_request( const struct create_keyed_event_request
*req
)
1697 fprintf( stderr
, " access=%08x", req
->access
);
1698 dump_varargs_object_attributes( ", objattr=", cur_size
);
1701 static void dump_create_keyed_event_reply( const struct create_keyed_event_reply
*req
)
1703 fprintf( stderr
, " handle=%04x", req
->handle
);
1706 static void dump_open_keyed_event_request( const struct open_keyed_event_request
*req
)
1708 fprintf( stderr
, " access=%08x", req
->access
);
1709 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1710 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1711 dump_varargs_unicode_str( ", name=", cur_size
);
1714 static void dump_open_keyed_event_reply( const struct open_keyed_event_reply
*req
)
1716 fprintf( stderr
, " handle=%04x", req
->handle
);
1719 static void dump_create_mutex_request( const struct create_mutex_request
*req
)
1721 fprintf( stderr
, " access=%08x", req
->access
);
1722 fprintf( stderr
, ", owned=%d", req
->owned
);
1723 dump_varargs_object_attributes( ", objattr=", cur_size
);
1726 static void dump_create_mutex_reply( const struct create_mutex_reply
*req
)
1728 fprintf( stderr
, " handle=%04x", req
->handle
);
1731 static void dump_release_mutex_request( const struct release_mutex_request
*req
)
1733 fprintf( stderr
, " handle=%04x", req
->handle
);
1736 static void dump_release_mutex_reply( const struct release_mutex_reply
*req
)
1738 fprintf( stderr
, " prev_count=%08x", req
->prev_count
);
1741 static void dump_open_mutex_request( const struct open_mutex_request
*req
)
1743 fprintf( stderr
, " access=%08x", req
->access
);
1744 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1745 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1746 dump_varargs_unicode_str( ", name=", cur_size
);
1749 static void dump_open_mutex_reply( const struct open_mutex_reply
*req
)
1751 fprintf( stderr
, " handle=%04x", req
->handle
);
1754 static void dump_query_mutex_request( const struct query_mutex_request
*req
)
1756 fprintf( stderr
, " handle=%04x", req
->handle
);
1759 static void dump_query_mutex_reply( const struct query_mutex_reply
*req
)
1761 fprintf( stderr
, " count=%08x", req
->count
);
1762 fprintf( stderr
, ", owned=%d", req
->owned
);
1763 fprintf( stderr
, ", abandoned=%d", req
->abandoned
);
1766 static void dump_create_semaphore_request( const struct create_semaphore_request
*req
)
1768 fprintf( stderr
, " access=%08x", req
->access
);
1769 fprintf( stderr
, ", initial=%08x", req
->initial
);
1770 fprintf( stderr
, ", max=%08x", req
->max
);
1771 dump_varargs_object_attributes( ", objattr=", cur_size
);
1774 static void dump_create_semaphore_reply( const struct create_semaphore_reply
*req
)
1776 fprintf( stderr
, " handle=%04x", req
->handle
);
1779 static void dump_release_semaphore_request( const struct release_semaphore_request
*req
)
1781 fprintf( stderr
, " handle=%04x", req
->handle
);
1782 fprintf( stderr
, ", count=%08x", req
->count
);
1785 static void dump_release_semaphore_reply( const struct release_semaphore_reply
*req
)
1787 fprintf( stderr
, " prev_count=%08x", req
->prev_count
);
1790 static void dump_query_semaphore_request( const struct query_semaphore_request
*req
)
1792 fprintf( stderr
, " handle=%04x", req
->handle
);
1795 static void dump_query_semaphore_reply( const struct query_semaphore_reply
*req
)
1797 fprintf( stderr
, " current=%08x", req
->current
);
1798 fprintf( stderr
, ", max=%08x", req
->max
);
1801 static void dump_open_semaphore_request( const struct open_semaphore_request
*req
)
1803 fprintf( stderr
, " access=%08x", req
->access
);
1804 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1805 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1806 dump_varargs_unicode_str( ", name=", cur_size
);
1809 static void dump_open_semaphore_reply( const struct open_semaphore_reply
*req
)
1811 fprintf( stderr
, " handle=%04x", req
->handle
);
1814 static void dump_create_file_request( const struct create_file_request
*req
)
1816 fprintf( stderr
, " access=%08x", req
->access
);
1817 fprintf( stderr
, ", sharing=%08x", req
->sharing
);
1818 fprintf( stderr
, ", create=%d", req
->create
);
1819 fprintf( stderr
, ", options=%08x", req
->options
);
1820 fprintf( stderr
, ", attrs=%08x", req
->attrs
);
1821 dump_varargs_object_attributes( ", objattr=", cur_size
);
1822 dump_varargs_string( ", filename=", cur_size
);
1825 static void dump_create_file_reply( const struct create_file_reply
*req
)
1827 fprintf( stderr
, " handle=%04x", req
->handle
);
1830 static void dump_open_file_object_request( const struct open_file_object_request
*req
)
1832 fprintf( stderr
, " access=%08x", req
->access
);
1833 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1834 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
1835 fprintf( stderr
, ", sharing=%08x", req
->sharing
);
1836 fprintf( stderr
, ", options=%08x", req
->options
);
1837 dump_varargs_unicode_str( ", filename=", cur_size
);
1840 static void dump_open_file_object_reply( const struct open_file_object_reply
*req
)
1842 fprintf( stderr
, " handle=%04x", req
->handle
);
1845 static void dump_alloc_file_handle_request( const struct alloc_file_handle_request
*req
)
1847 fprintf( stderr
, " access=%08x", req
->access
);
1848 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1849 fprintf( stderr
, ", fd=%d", req
->fd
);
1852 static void dump_alloc_file_handle_reply( const struct alloc_file_handle_reply
*req
)
1854 fprintf( stderr
, " handle=%04x", req
->handle
);
1857 static void dump_get_handle_unix_name_request( const struct get_handle_unix_name_request
*req
)
1859 fprintf( stderr
, " handle=%04x", req
->handle
);
1862 static void dump_get_handle_unix_name_reply( const struct get_handle_unix_name_reply
*req
)
1864 fprintf( stderr
, " name_len=%u", req
->name_len
);
1865 dump_varargs_string( ", name=", cur_size
);
1868 static void dump_get_handle_fd_request( const struct get_handle_fd_request
*req
)
1870 fprintf( stderr
, " handle=%04x", req
->handle
);
1873 static void dump_get_handle_fd_reply( const struct get_handle_fd_reply
*req
)
1875 fprintf( stderr
, " type=%d", req
->type
);
1876 fprintf( stderr
, ", cacheable=%d", req
->cacheable
);
1877 fprintf( stderr
, ", access=%08x", req
->access
);
1878 fprintf( stderr
, ", options=%08x", req
->options
);
1881 static void dump_get_directory_cache_entry_request( const struct get_directory_cache_entry_request
*req
)
1883 fprintf( stderr
, " handle=%04x", req
->handle
);
1886 static void dump_get_directory_cache_entry_reply( const struct get_directory_cache_entry_reply
*req
)
1888 fprintf( stderr
, " entry=%d", req
->entry
);
1889 dump_varargs_ints( ", free=", cur_size
);
1892 static void dump_flush_request( const struct flush_request
*req
)
1894 dump_async_data( " async=", &req
->async
);
1897 static void dump_flush_reply( const struct flush_reply
*req
)
1899 fprintf( stderr
, " event=%04x", req
->event
);
1902 static void dump_get_file_info_request( const struct get_file_info_request
*req
)
1904 fprintf( stderr
, " handle=%04x", req
->handle
);
1905 fprintf( stderr
, ", info_class=%08x", req
->info_class
);
1908 static void dump_get_file_info_reply( const struct get_file_info_reply
*req
)
1910 dump_varargs_bytes( " data=", cur_size
);
1913 static void dump_get_volume_info_request( const struct get_volume_info_request
*req
)
1915 fprintf( stderr
, " handle=%04x", req
->handle
);
1916 fprintf( stderr
, ", info_class=%08x", req
->info_class
);
1919 static void dump_get_volume_info_reply( const struct get_volume_info_reply
*req
)
1921 dump_varargs_bytes( " data=", cur_size
);
1924 static void dump_lock_file_request( const struct lock_file_request
*req
)
1926 fprintf( stderr
, " handle=%04x", req
->handle
);
1927 dump_uint64( ", offset=", &req
->offset
);
1928 dump_uint64( ", count=", &req
->count
);
1929 fprintf( stderr
, ", shared=%d", req
->shared
);
1930 fprintf( stderr
, ", wait=%d", req
->wait
);
1933 static void dump_lock_file_reply( const struct lock_file_reply
*req
)
1935 fprintf( stderr
, " handle=%04x", req
->handle
);
1936 fprintf( stderr
, ", overlapped=%d", req
->overlapped
);
1939 static void dump_unlock_file_request( const struct unlock_file_request
*req
)
1941 fprintf( stderr
, " handle=%04x", req
->handle
);
1942 dump_uint64( ", offset=", &req
->offset
);
1943 dump_uint64( ", count=", &req
->count
);
1946 static void dump_create_socket_request( const struct create_socket_request
*req
)
1948 fprintf( stderr
, " access=%08x", req
->access
);
1949 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1950 fprintf( stderr
, ", family=%d", req
->family
);
1951 fprintf( stderr
, ", type=%d", req
->type
);
1952 fprintf( stderr
, ", protocol=%d", req
->protocol
);
1953 fprintf( stderr
, ", flags=%08x", req
->flags
);
1956 static void dump_create_socket_reply( const struct create_socket_reply
*req
)
1958 fprintf( stderr
, " handle=%04x", req
->handle
);
1961 static void dump_accept_socket_request( const struct accept_socket_request
*req
)
1963 fprintf( stderr
, " lhandle=%04x", req
->lhandle
);
1964 fprintf( stderr
, ", access=%08x", req
->access
);
1965 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
1968 static void dump_accept_socket_reply( const struct accept_socket_reply
*req
)
1970 fprintf( stderr
, " handle=%04x", req
->handle
);
1973 static void dump_accept_into_socket_request( const struct accept_into_socket_request
*req
)
1975 fprintf( stderr
, " lhandle=%04x", req
->lhandle
);
1976 fprintf( stderr
, ", ahandle=%04x", req
->ahandle
);
1979 static void dump_set_socket_event_request( const struct set_socket_event_request
*req
)
1981 fprintf( stderr
, " handle=%04x", req
->handle
);
1982 fprintf( stderr
, ", mask=%08x", req
->mask
);
1983 fprintf( stderr
, ", event=%04x", req
->event
);
1984 fprintf( stderr
, ", window=%08x", req
->window
);
1985 fprintf( stderr
, ", msg=%08x", req
->msg
);
1988 static void dump_get_socket_event_request( const struct get_socket_event_request
*req
)
1990 fprintf( stderr
, " handle=%04x", req
->handle
);
1991 fprintf( stderr
, ", service=%d", req
->service
);
1992 fprintf( stderr
, ", c_event=%04x", req
->c_event
);
1995 static void dump_get_socket_event_reply( const struct get_socket_event_reply
*req
)
1997 fprintf( stderr
, " mask=%08x", req
->mask
);
1998 fprintf( stderr
, ", pmask=%08x", req
->pmask
);
1999 fprintf( stderr
, ", state=%08x", req
->state
);
2000 dump_varargs_ints( ", errors=", cur_size
);
2003 static void dump_get_socket_info_request( const struct get_socket_info_request
*req
)
2005 fprintf( stderr
, " handle=%04x", req
->handle
);
2008 static void dump_get_socket_info_reply( const struct get_socket_info_reply
*req
)
2010 fprintf( stderr
, " family=%d", req
->family
);
2011 fprintf( stderr
, ", type=%d", req
->type
);
2012 fprintf( stderr
, ", protocol=%d", req
->protocol
);
2015 static void dump_enable_socket_event_request( const struct enable_socket_event_request
*req
)
2017 fprintf( stderr
, " handle=%04x", req
->handle
);
2018 fprintf( stderr
, ", mask=%08x", req
->mask
);
2019 fprintf( stderr
, ", sstate=%08x", req
->sstate
);
2020 fprintf( stderr
, ", cstate=%08x", req
->cstate
);
2023 static void dump_set_socket_deferred_request( const struct set_socket_deferred_request
*req
)
2025 fprintf( stderr
, " handle=%04x", req
->handle
);
2026 fprintf( stderr
, ", deferred=%04x", req
->deferred
);
2029 static void dump_alloc_console_request( const struct alloc_console_request
*req
)
2031 fprintf( stderr
, " access=%08x", req
->access
);
2032 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2033 fprintf( stderr
, ", pid=%04x", req
->pid
);
2034 fprintf( stderr
, ", input_fd=%d", req
->input_fd
);
2037 static void dump_alloc_console_reply( const struct alloc_console_reply
*req
)
2039 fprintf( stderr
, " handle_in=%04x", req
->handle_in
);
2042 static void dump_free_console_request( const struct free_console_request
*req
)
2046 static void dump_attach_console_request( const struct attach_console_request
*req
)
2048 fprintf( stderr
, " pid=%04x", req
->pid
);
2051 static void dump_get_console_wait_event_request( const struct get_console_wait_event_request
*req
)
2053 fprintf( stderr
, " handle=%04x", req
->handle
);
2056 static void dump_get_console_wait_event_reply( const struct get_console_wait_event_reply
*req
)
2058 fprintf( stderr
, " event=%04x", req
->event
);
2061 static void dump_append_console_input_history_request( const struct append_console_input_history_request
*req
)
2063 fprintf( stderr
, " handle=%04x", req
->handle
);
2064 dump_varargs_unicode_str( ", line=", cur_size
);
2067 static void dump_get_console_input_history_request( const struct get_console_input_history_request
*req
)
2069 fprintf( stderr
, " handle=%04x", req
->handle
);
2070 fprintf( stderr
, ", index=%d", req
->index
);
2073 static void dump_get_console_input_history_reply( const struct get_console_input_history_reply
*req
)
2075 fprintf( stderr
, " total=%d", req
->total
);
2076 dump_varargs_unicode_str( ", line=", cur_size
);
2079 static void dump_create_console_output_request( const struct create_console_output_request
*req
)
2081 fprintf( stderr
, " handle_in=%04x", req
->handle_in
);
2082 fprintf( stderr
, ", access=%08x", req
->access
);
2083 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2084 fprintf( stderr
, ", share=%08x", req
->share
);
2085 fprintf( stderr
, ", fd=%d", req
->fd
);
2088 static void dump_create_console_output_reply( const struct create_console_output_reply
*req
)
2090 fprintf( stderr
, " handle_out=%04x", req
->handle_out
);
2093 static void dump_get_next_console_request_request( const struct get_next_console_request_request
*req
)
2095 fprintf( stderr
, " handle=%04x", req
->handle
);
2096 fprintf( stderr
, ", signal=%d", req
->signal
);
2097 fprintf( stderr
, ", read=%d", req
->read
);
2098 fprintf( stderr
, ", status=%08x", req
->status
);
2099 dump_varargs_bytes( ", out_data=", cur_size
);
2102 static void dump_get_next_console_request_reply( const struct get_next_console_request_reply
*req
)
2104 fprintf( stderr
, " code=%08x", req
->code
);
2105 fprintf( stderr
, ", output=%08x", req
->output
);
2106 fprintf( stderr
, ", out_size=%u", req
->out_size
);
2107 dump_varargs_bytes( ", in_data=", cur_size
);
2110 static void dump_read_directory_changes_request( const struct read_directory_changes_request
*req
)
2112 fprintf( stderr
, " filter=%08x", req
->filter
);
2113 fprintf( stderr
, ", subtree=%d", req
->subtree
);
2114 fprintf( stderr
, ", want_data=%d", req
->want_data
);
2115 dump_async_data( ", async=", &req
->async
);
2118 static void dump_read_change_request( const struct read_change_request
*req
)
2120 fprintf( stderr
, " handle=%04x", req
->handle
);
2123 static void dump_read_change_reply( const struct read_change_reply
*req
)
2125 dump_varargs_filesystem_event( " events=", cur_size
);
2128 static void dump_create_mapping_request( const struct create_mapping_request
*req
)
2130 fprintf( stderr
, " access=%08x", req
->access
);
2131 fprintf( stderr
, ", flags=%08x", req
->flags
);
2132 fprintf( stderr
, ", file_access=%08x", req
->file_access
);
2133 dump_uint64( ", size=", &req
->size
);
2134 fprintf( stderr
, ", file_handle=%04x", req
->file_handle
);
2135 dump_varargs_object_attributes( ", objattr=", cur_size
);
2138 static void dump_create_mapping_reply( const struct create_mapping_reply
*req
)
2140 fprintf( stderr
, " handle=%04x", req
->handle
);
2143 static void dump_open_mapping_request( const struct open_mapping_request
*req
)
2145 fprintf( stderr
, " access=%08x", req
->access
);
2146 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2147 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
2148 dump_varargs_unicode_str( ", name=", cur_size
);
2151 static void dump_open_mapping_reply( const struct open_mapping_reply
*req
)
2153 fprintf( stderr
, " handle=%04x", req
->handle
);
2156 static void dump_get_mapping_info_request( const struct get_mapping_info_request
*req
)
2158 fprintf( stderr
, " handle=%04x", req
->handle
);
2159 fprintf( stderr
, ", access=%08x", req
->access
);
2162 static void dump_get_mapping_info_reply( const struct get_mapping_info_reply
*req
)
2164 dump_uint64( " size=", &req
->size
);
2165 fprintf( stderr
, ", flags=%08x", req
->flags
);
2166 fprintf( stderr
, ", shared_file=%04x", req
->shared_file
);
2167 dump_varargs_pe_image_info( ", image=", cur_size
);
2170 static void dump_map_view_request( const struct map_view_request
*req
)
2172 fprintf( stderr
, " mapping=%04x", req
->mapping
);
2173 fprintf( stderr
, ", access=%08x", req
->access
);
2174 dump_uint64( ", base=", &req
->base
);
2175 dump_uint64( ", size=", &req
->size
);
2176 dump_uint64( ", start=", &req
->start
);
2179 static void dump_unmap_view_request( const struct unmap_view_request
*req
)
2181 dump_uint64( " base=", &req
->base
);
2184 static void dump_get_mapping_committed_range_request( const struct get_mapping_committed_range_request
*req
)
2186 dump_uint64( " base=", &req
->base
);
2187 dump_uint64( ", offset=", &req
->offset
);
2190 static void dump_get_mapping_committed_range_reply( const struct get_mapping_committed_range_reply
*req
)
2192 dump_uint64( " size=", &req
->size
);
2193 fprintf( stderr
, ", committed=%d", req
->committed
);
2196 static void dump_add_mapping_committed_range_request( const struct add_mapping_committed_range_request
*req
)
2198 dump_uint64( " base=", &req
->base
);
2199 dump_uint64( ", offset=", &req
->offset
);
2200 dump_uint64( ", size=", &req
->size
);
2203 static void dump_is_same_mapping_request( const struct is_same_mapping_request
*req
)
2205 dump_uint64( " base1=", &req
->base1
);
2206 dump_uint64( ", base2=", &req
->base2
);
2209 static void dump_list_processes_request( const struct list_processes_request
*req
)
2213 static void dump_list_processes_reply( const struct list_processes_reply
*req
)
2215 fprintf( stderr
, " info_size=%u", req
->info_size
);
2216 fprintf( stderr
, ", process_count=%d", req
->process_count
);
2217 dump_varargs_process_info( ", data=", min(cur_size
,req
->info_size
) );
2220 static void dump_wait_debug_event_request( const struct wait_debug_event_request
*req
)
2222 fprintf( stderr
, " get_handle=%d", req
->get_handle
);
2225 static void dump_wait_debug_event_reply( const struct wait_debug_event_reply
*req
)
2227 fprintf( stderr
, " pid=%04x", req
->pid
);
2228 fprintf( stderr
, ", tid=%04x", req
->tid
);
2229 fprintf( stderr
, ", wait=%04x", req
->wait
);
2230 dump_varargs_debug_event( ", event=", cur_size
);
2233 static void dump_queue_exception_event_request( const struct queue_exception_event_request
*req
)
2235 fprintf( stderr
, " first=%d", req
->first
);
2236 fprintf( stderr
, ", code=%08x", req
->code
);
2237 fprintf( stderr
, ", flags=%08x", req
->flags
);
2238 dump_uint64( ", record=", &req
->record
);
2239 dump_uint64( ", address=", &req
->address
);
2240 fprintf( stderr
, ", len=%u", req
->len
);
2241 dump_varargs_uints64( ", params=", min(cur_size
,req
->len
) );
2244 static void dump_queue_exception_event_reply( const struct queue_exception_event_reply
*req
)
2246 fprintf( stderr
, " handle=%04x", req
->handle
);
2249 static void dump_get_exception_status_request( const struct get_exception_status_request
*req
)
2251 fprintf( stderr
, " handle=%04x", req
->handle
);
2254 static void dump_continue_debug_event_request( const struct continue_debug_event_request
*req
)
2256 fprintf( stderr
, " pid=%04x", req
->pid
);
2257 fprintf( stderr
, ", tid=%04x", req
->tid
);
2258 fprintf( stderr
, ", status=%d", req
->status
);
2261 static void dump_debug_process_request( const struct debug_process_request
*req
)
2263 fprintf( stderr
, " pid=%04x", req
->pid
);
2264 fprintf( stderr
, ", attach=%d", req
->attach
);
2267 static void dump_set_debugger_kill_on_exit_request( const struct set_debugger_kill_on_exit_request
*req
)
2269 fprintf( stderr
, " kill_on_exit=%d", req
->kill_on_exit
);
2272 static void dump_read_process_memory_request( const struct read_process_memory_request
*req
)
2274 fprintf( stderr
, " handle=%04x", req
->handle
);
2275 dump_uint64( ", addr=", &req
->addr
);
2278 static void dump_read_process_memory_reply( const struct read_process_memory_reply
*req
)
2280 dump_varargs_bytes( " data=", cur_size
);
2283 static void dump_write_process_memory_request( const struct write_process_memory_request
*req
)
2285 fprintf( stderr
, " handle=%04x", req
->handle
);
2286 dump_uint64( ", addr=", &req
->addr
);
2287 dump_varargs_bytes( ", data=", cur_size
);
2290 static void dump_create_key_request( const struct create_key_request
*req
)
2292 fprintf( stderr
, " access=%08x", req
->access
);
2293 fprintf( stderr
, ", options=%08x", req
->options
);
2294 dump_varargs_object_attributes( ", objattr=", cur_size
);
2295 dump_varargs_unicode_str( ", class=", cur_size
);
2298 static void dump_create_key_reply( const struct create_key_reply
*req
)
2300 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2301 fprintf( stderr
, ", created=%d", req
->created
);
2304 static void dump_open_key_request( const struct open_key_request
*req
)
2306 fprintf( stderr
, " parent=%04x", req
->parent
);
2307 fprintf( stderr
, ", access=%08x", req
->access
);
2308 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2309 dump_varargs_unicode_str( ", name=", cur_size
);
2312 static void dump_open_key_reply( const struct open_key_reply
*req
)
2314 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2317 static void dump_delete_key_request( const struct delete_key_request
*req
)
2319 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2322 static void dump_flush_key_request( const struct flush_key_request
*req
)
2324 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2327 static void dump_enum_key_request( const struct enum_key_request
*req
)
2329 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2330 fprintf( stderr
, ", index=%d", req
->index
);
2331 fprintf( stderr
, ", info_class=%d", req
->info_class
);
2334 static void dump_enum_key_reply( const struct enum_key_reply
*req
)
2336 fprintf( stderr
, " subkeys=%d", req
->subkeys
);
2337 fprintf( stderr
, ", max_subkey=%d", req
->max_subkey
);
2338 fprintf( stderr
, ", max_class=%d", req
->max_class
);
2339 fprintf( stderr
, ", values=%d", req
->values
);
2340 fprintf( stderr
, ", max_value=%d", req
->max_value
);
2341 fprintf( stderr
, ", max_data=%d", req
->max_data
);
2342 dump_timeout( ", modif=", &req
->modif
);
2343 fprintf( stderr
, ", total=%u", req
->total
);
2344 fprintf( stderr
, ", namelen=%u", req
->namelen
);
2345 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->namelen
) );
2346 dump_varargs_unicode_str( ", class=", cur_size
);
2349 static void dump_set_key_value_request( const struct set_key_value_request
*req
)
2351 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2352 fprintf( stderr
, ", type=%d", req
->type
);
2353 fprintf( stderr
, ", namelen=%u", req
->namelen
);
2354 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->namelen
) );
2355 dump_varargs_bytes( ", data=", cur_size
);
2358 static void dump_get_key_value_request( const struct get_key_value_request
*req
)
2360 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2361 dump_varargs_unicode_str( ", name=", cur_size
);
2364 static void dump_get_key_value_reply( const struct get_key_value_reply
*req
)
2366 fprintf( stderr
, " type=%d", req
->type
);
2367 fprintf( stderr
, ", total=%u", req
->total
);
2368 dump_varargs_bytes( ", data=", cur_size
);
2371 static void dump_enum_key_value_request( const struct enum_key_value_request
*req
)
2373 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2374 fprintf( stderr
, ", index=%d", req
->index
);
2375 fprintf( stderr
, ", info_class=%d", req
->info_class
);
2378 static void dump_enum_key_value_reply( const struct enum_key_value_reply
*req
)
2380 fprintf( stderr
, " type=%d", req
->type
);
2381 fprintf( stderr
, ", total=%u", req
->total
);
2382 fprintf( stderr
, ", namelen=%u", req
->namelen
);
2383 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->namelen
) );
2384 dump_varargs_bytes( ", data=", cur_size
);
2387 static void dump_delete_key_value_request( const struct delete_key_value_request
*req
)
2389 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2390 dump_varargs_unicode_str( ", name=", cur_size
);
2393 static void dump_load_registry_request( const struct load_registry_request
*req
)
2395 fprintf( stderr
, " file=%04x", req
->file
);
2396 dump_varargs_object_attributes( ", objattr=", cur_size
);
2399 static void dump_unload_registry_request( const struct unload_registry_request
*req
)
2401 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2404 static void dump_save_registry_request( const struct save_registry_request
*req
)
2406 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2407 fprintf( stderr
, ", file=%04x", req
->file
);
2410 static void dump_set_registry_notification_request( const struct set_registry_notification_request
*req
)
2412 fprintf( stderr
, " hkey=%04x", req
->hkey
);
2413 fprintf( stderr
, ", event=%04x", req
->event
);
2414 fprintf( stderr
, ", subtree=%d", req
->subtree
);
2415 fprintf( stderr
, ", filter=%08x", req
->filter
);
2418 static void dump_create_timer_request( const struct create_timer_request
*req
)
2420 fprintf( stderr
, " access=%08x", req
->access
);
2421 fprintf( stderr
, ", manual=%d", req
->manual
);
2422 dump_varargs_object_attributes( ", objattr=", cur_size
);
2425 static void dump_create_timer_reply( const struct create_timer_reply
*req
)
2427 fprintf( stderr
, " handle=%04x", req
->handle
);
2430 static void dump_open_timer_request( const struct open_timer_request
*req
)
2432 fprintf( stderr
, " access=%08x", req
->access
);
2433 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
2434 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
2435 dump_varargs_unicode_str( ", name=", cur_size
);
2438 static void dump_open_timer_reply( const struct open_timer_reply
*req
)
2440 fprintf( stderr
, " handle=%04x", req
->handle
);
2443 static void dump_set_timer_request( const struct set_timer_request
*req
)
2445 fprintf( stderr
, " handle=%04x", req
->handle
);
2446 dump_timeout( ", expire=", &req
->expire
);
2447 dump_uint64( ", callback=", &req
->callback
);
2448 dump_uint64( ", arg=", &req
->arg
);
2449 fprintf( stderr
, ", period=%d", req
->period
);
2452 static void dump_set_timer_reply( const struct set_timer_reply
*req
)
2454 fprintf( stderr
, " signaled=%d", req
->signaled
);
2457 static void dump_cancel_timer_request( const struct cancel_timer_request
*req
)
2459 fprintf( stderr
, " handle=%04x", req
->handle
);
2462 static void dump_cancel_timer_reply( const struct cancel_timer_reply
*req
)
2464 fprintf( stderr
, " signaled=%d", req
->signaled
);
2467 static void dump_get_timer_info_request( const struct get_timer_info_request
*req
)
2469 fprintf( stderr
, " handle=%04x", req
->handle
);
2472 static void dump_get_timer_info_reply( const struct get_timer_info_reply
*req
)
2474 dump_timeout( " when=", &req
->when
);
2475 fprintf( stderr
, ", signaled=%d", req
->signaled
);
2478 static void dump_get_thread_context_request( const struct get_thread_context_request
*req
)
2480 fprintf( stderr
, " handle=%04x", req
->handle
);
2481 fprintf( stderr
, ", flags=%08x", req
->flags
);
2484 static void dump_get_thread_context_reply( const struct get_thread_context_reply
*req
)
2486 fprintf( stderr
, " self=%d", req
->self
);
2487 fprintf( stderr
, ", handle=%04x", req
->handle
);
2488 dump_varargs_context( ", context=", cur_size
);
2491 static void dump_set_thread_context_request( const struct set_thread_context_request
*req
)
2493 fprintf( stderr
, " handle=%04x", req
->handle
);
2494 dump_varargs_context( ", context=", cur_size
);
2497 static void dump_set_thread_context_reply( const struct set_thread_context_reply
*req
)
2499 fprintf( stderr
, " self=%d", req
->self
);
2502 static void dump_get_selector_entry_request( const struct get_selector_entry_request
*req
)
2504 fprintf( stderr
, " handle=%04x", req
->handle
);
2505 fprintf( stderr
, ", entry=%d", req
->entry
);
2508 static void dump_get_selector_entry_reply( const struct get_selector_entry_reply
*req
)
2510 fprintf( stderr
, " base=%08x", req
->base
);
2511 fprintf( stderr
, ", limit=%08x", req
->limit
);
2512 fprintf( stderr
, ", flags=%02x", req
->flags
);
2515 static void dump_add_atom_request( const struct add_atom_request
*req
)
2517 fprintf( stderr
, " table=%04x", req
->table
);
2518 dump_varargs_unicode_str( ", name=", cur_size
);
2521 static void dump_add_atom_reply( const struct add_atom_reply
*req
)
2523 fprintf( stderr
, " atom=%04x", req
->atom
);
2526 static void dump_delete_atom_request( const struct delete_atom_request
*req
)
2528 fprintf( stderr
, " table=%04x", req
->table
);
2529 fprintf( stderr
, ", atom=%04x", req
->atom
);
2532 static void dump_find_atom_request( const struct find_atom_request
*req
)
2534 fprintf( stderr
, " table=%04x", req
->table
);
2535 dump_varargs_unicode_str( ", name=", cur_size
);
2538 static void dump_find_atom_reply( const struct find_atom_reply
*req
)
2540 fprintf( stderr
, " atom=%04x", req
->atom
);
2543 static void dump_get_atom_information_request( const struct get_atom_information_request
*req
)
2545 fprintf( stderr
, " table=%04x", req
->table
);
2546 fprintf( stderr
, ", atom=%04x", req
->atom
);
2549 static void dump_get_atom_information_reply( const struct get_atom_information_reply
*req
)
2551 fprintf( stderr
, " count=%d", req
->count
);
2552 fprintf( stderr
, ", pinned=%d", req
->pinned
);
2553 fprintf( stderr
, ", total=%u", req
->total
);
2554 dump_varargs_unicode_str( ", name=", cur_size
);
2557 static void dump_set_atom_information_request( const struct set_atom_information_request
*req
)
2559 fprintf( stderr
, " table=%04x", req
->table
);
2560 fprintf( stderr
, ", atom=%04x", req
->atom
);
2561 fprintf( stderr
, ", pinned=%d", req
->pinned
);
2564 static void dump_empty_atom_table_request( const struct empty_atom_table_request
*req
)
2566 fprintf( stderr
, " table=%04x", req
->table
);
2567 fprintf( stderr
, ", if_pinned=%d", req
->if_pinned
);
2570 static void dump_init_atom_table_request( const struct init_atom_table_request
*req
)
2572 fprintf( stderr
, " entries=%d", req
->entries
);
2575 static void dump_init_atom_table_reply( const struct init_atom_table_reply
*req
)
2577 fprintf( stderr
, " table=%04x", req
->table
);
2580 static void dump_get_msg_queue_request( const struct get_msg_queue_request
*req
)
2584 static void dump_get_msg_queue_reply( const struct get_msg_queue_reply
*req
)
2586 fprintf( stderr
, " handle=%04x", req
->handle
);
2589 static void dump_set_queue_fd_request( const struct set_queue_fd_request
*req
)
2591 fprintf( stderr
, " handle=%04x", req
->handle
);
2594 static void dump_set_queue_mask_request( const struct set_queue_mask_request
*req
)
2596 fprintf( stderr
, " wake_mask=%08x", req
->wake_mask
);
2597 fprintf( stderr
, ", changed_mask=%08x", req
->changed_mask
);
2598 fprintf( stderr
, ", skip_wait=%d", req
->skip_wait
);
2601 static void dump_set_queue_mask_reply( const struct set_queue_mask_reply
*req
)
2603 fprintf( stderr
, " wake_bits=%08x", req
->wake_bits
);
2604 fprintf( stderr
, ", changed_bits=%08x", req
->changed_bits
);
2607 static void dump_get_queue_status_request( const struct get_queue_status_request
*req
)
2609 fprintf( stderr
, " clear_bits=%08x", req
->clear_bits
);
2612 static void dump_get_queue_status_reply( const struct get_queue_status_reply
*req
)
2614 fprintf( stderr
, " wake_bits=%08x", req
->wake_bits
);
2615 fprintf( stderr
, ", changed_bits=%08x", req
->changed_bits
);
2618 static void dump_get_process_idle_event_request( const struct get_process_idle_event_request
*req
)
2620 fprintf( stderr
, " handle=%04x", req
->handle
);
2623 static void dump_get_process_idle_event_reply( const struct get_process_idle_event_reply
*req
)
2625 fprintf( stderr
, " event=%04x", req
->event
);
2628 static void dump_send_message_request( const struct send_message_request
*req
)
2630 fprintf( stderr
, " id=%04x", req
->id
);
2631 fprintf( stderr
, ", type=%d", req
->type
);
2632 fprintf( stderr
, ", flags=%d", req
->flags
);
2633 fprintf( stderr
, ", win=%08x", req
->win
);
2634 fprintf( stderr
, ", msg=%08x", req
->msg
);
2635 dump_uint64( ", wparam=", &req
->wparam
);
2636 dump_uint64( ", lparam=", &req
->lparam
);
2637 dump_timeout( ", timeout=", &req
->timeout
);
2638 dump_varargs_message_data( ", data=", cur_size
);
2641 static void dump_post_quit_message_request( const struct post_quit_message_request
*req
)
2643 fprintf( stderr
, " exit_code=%d", req
->exit_code
);
2646 static void dump_send_hardware_message_request( const struct send_hardware_message_request
*req
)
2648 fprintf( stderr
, " win=%08x", req
->win
);
2649 dump_hw_input( ", input=", &req
->input
);
2650 fprintf( stderr
, ", flags=%08x", req
->flags
);
2653 static void dump_send_hardware_message_reply( const struct send_hardware_message_reply
*req
)
2655 fprintf( stderr
, " wait=%d", req
->wait
);
2656 fprintf( stderr
, ", prev_x=%d", req
->prev_x
);
2657 fprintf( stderr
, ", prev_y=%d", req
->prev_y
);
2658 fprintf( stderr
, ", new_x=%d", req
->new_x
);
2659 fprintf( stderr
, ", new_y=%d", req
->new_y
);
2660 dump_varargs_bytes( ", keystate=", cur_size
);
2663 static void dump_get_message_request( const struct get_message_request
*req
)
2665 fprintf( stderr
, " flags=%08x", req
->flags
);
2666 fprintf( stderr
, ", get_win=%08x", req
->get_win
);
2667 fprintf( stderr
, ", get_first=%08x", req
->get_first
);
2668 fprintf( stderr
, ", get_last=%08x", req
->get_last
);
2669 fprintf( stderr
, ", hw_id=%08x", req
->hw_id
);
2670 fprintf( stderr
, ", wake_mask=%08x", req
->wake_mask
);
2671 fprintf( stderr
, ", changed_mask=%08x", req
->changed_mask
);
2674 static void dump_get_message_reply( const struct get_message_reply
*req
)
2676 fprintf( stderr
, " win=%08x", req
->win
);
2677 fprintf( stderr
, ", msg=%08x", req
->msg
);
2678 dump_uint64( ", wparam=", &req
->wparam
);
2679 dump_uint64( ", lparam=", &req
->lparam
);
2680 fprintf( stderr
, ", type=%d", req
->type
);
2681 fprintf( stderr
, ", x=%d", req
->x
);
2682 fprintf( stderr
, ", y=%d", req
->y
);
2683 fprintf( stderr
, ", time=%08x", req
->time
);
2684 fprintf( stderr
, ", active_hooks=%08x", req
->active_hooks
);
2685 fprintf( stderr
, ", total=%u", req
->total
);
2686 dump_varargs_message_data( ", data=", cur_size
);
2689 static void dump_reply_message_request( const struct reply_message_request
*req
)
2691 fprintf( stderr
, " remove=%d", req
->remove
);
2692 dump_uint64( ", result=", &req
->result
);
2693 dump_varargs_bytes( ", data=", cur_size
);
2696 static void dump_accept_hardware_message_request( const struct accept_hardware_message_request
*req
)
2698 fprintf( stderr
, " hw_id=%08x", req
->hw_id
);
2701 static void dump_get_message_reply_request( const struct get_message_reply_request
*req
)
2703 fprintf( stderr
, " cancel=%d", req
->cancel
);
2706 static void dump_get_message_reply_reply( const struct get_message_reply_reply
*req
)
2708 dump_uint64( " result=", &req
->result
);
2709 dump_varargs_bytes( ", data=", cur_size
);
2712 static void dump_set_win_timer_request( const struct set_win_timer_request
*req
)
2714 fprintf( stderr
, " win=%08x", req
->win
);
2715 fprintf( stderr
, ", msg=%08x", req
->msg
);
2716 fprintf( stderr
, ", rate=%08x", req
->rate
);
2717 dump_uint64( ", id=", &req
->id
);
2718 dump_uint64( ", lparam=", &req
->lparam
);
2721 static void dump_set_win_timer_reply( const struct set_win_timer_reply
*req
)
2723 dump_uint64( " id=", &req
->id
);
2726 static void dump_kill_win_timer_request( const struct kill_win_timer_request
*req
)
2728 fprintf( stderr
, " win=%08x", req
->win
);
2729 dump_uint64( ", id=", &req
->id
);
2730 fprintf( stderr
, ", msg=%08x", req
->msg
);
2733 static void dump_is_window_hung_request( const struct is_window_hung_request
*req
)
2735 fprintf( stderr
, " win=%08x", req
->win
);
2738 static void dump_is_window_hung_reply( const struct is_window_hung_reply
*req
)
2740 fprintf( stderr
, " is_hung=%d", req
->is_hung
);
2743 static void dump_get_serial_info_request( const struct get_serial_info_request
*req
)
2745 fprintf( stderr
, " handle=%04x", req
->handle
);
2746 fprintf( stderr
, ", flags=%d", req
->flags
);
2749 static void dump_get_serial_info_reply( const struct get_serial_info_reply
*req
)
2751 fprintf( stderr
, " eventmask=%08x", req
->eventmask
);
2752 fprintf( stderr
, ", cookie=%08x", req
->cookie
);
2753 fprintf( stderr
, ", pending_write=%08x", req
->pending_write
);
2756 static void dump_set_serial_info_request( const struct set_serial_info_request
*req
)
2758 fprintf( stderr
, " handle=%04x", req
->handle
);
2759 fprintf( stderr
, ", flags=%d", req
->flags
);
2762 static void dump_register_async_request( const struct register_async_request
*req
)
2764 fprintf( stderr
, " type=%d", req
->type
);
2765 dump_async_data( ", async=", &req
->async
);
2766 fprintf( stderr
, ", count=%d", req
->count
);
2769 static void dump_cancel_async_request( const struct cancel_async_request
*req
)
2771 fprintf( stderr
, " handle=%04x", req
->handle
);
2772 dump_uint64( ", iosb=", &req
->iosb
);
2773 fprintf( stderr
, ", only_thread=%d", req
->only_thread
);
2776 static void dump_get_async_result_request( const struct get_async_result_request
*req
)
2778 dump_uint64( " user_arg=", &req
->user_arg
);
2781 static void dump_get_async_result_reply( const struct get_async_result_reply
*req
)
2783 fprintf( stderr
, " size=%u", req
->size
);
2784 dump_varargs_bytes( ", out_data=", cur_size
);
2787 static void dump_read_request( const struct read_request
*req
)
2789 dump_async_data( " async=", &req
->async
);
2790 dump_uint64( ", pos=", &req
->pos
);
2793 static void dump_read_reply( const struct read_reply
*req
)
2795 fprintf( stderr
, " wait=%04x", req
->wait
);
2796 fprintf( stderr
, ", options=%08x", req
->options
);
2797 dump_varargs_bytes( ", data=", cur_size
);
2800 static void dump_write_request( const struct write_request
*req
)
2802 dump_async_data( " async=", &req
->async
);
2803 dump_uint64( ", pos=", &req
->pos
);
2804 dump_varargs_bytes( ", data=", cur_size
);
2807 static void dump_write_reply( const struct write_reply
*req
)
2809 fprintf( stderr
, " wait=%04x", req
->wait
);
2810 fprintf( stderr
, ", options=%08x", req
->options
);
2811 fprintf( stderr
, ", size=%u", req
->size
);
2814 static void dump_ioctl_request( const struct ioctl_request
*req
)
2816 dump_ioctl_code( " code=", &req
->code
);
2817 dump_async_data( ", async=", &req
->async
);
2818 dump_varargs_bytes( ", in_data=", cur_size
);
2821 static void dump_ioctl_reply( const struct ioctl_reply
*req
)
2823 fprintf( stderr
, " wait=%04x", req
->wait
);
2824 fprintf( stderr
, ", options=%08x", req
->options
);
2825 dump_varargs_bytes( ", out_data=", cur_size
);
2828 static void dump_set_irp_result_request( const struct set_irp_result_request
*req
)
2830 fprintf( stderr
, " handle=%04x", req
->handle
);
2831 fprintf( stderr
, ", status=%08x", req
->status
);
2832 fprintf( stderr
, ", size=%u", req
->size
);
2833 dump_varargs_bytes( ", data=", cur_size
);
2836 static void dump_create_named_pipe_request( const struct create_named_pipe_request
*req
)
2838 fprintf( stderr
, " access=%08x", req
->access
);
2839 fprintf( stderr
, ", options=%08x", req
->options
);
2840 fprintf( stderr
, ", sharing=%08x", req
->sharing
);
2841 fprintf( stderr
, ", maxinstances=%08x", req
->maxinstances
);
2842 fprintf( stderr
, ", outsize=%08x", req
->outsize
);
2843 fprintf( stderr
, ", insize=%08x", req
->insize
);
2844 dump_timeout( ", timeout=", &req
->timeout
);
2845 fprintf( stderr
, ", flags=%08x", req
->flags
);
2846 dump_varargs_object_attributes( ", objattr=", cur_size
);
2849 static void dump_create_named_pipe_reply( const struct create_named_pipe_reply
*req
)
2851 fprintf( stderr
, " handle=%04x", req
->handle
);
2854 static void dump_set_named_pipe_info_request( const struct set_named_pipe_info_request
*req
)
2856 fprintf( stderr
, " handle=%04x", req
->handle
);
2857 fprintf( stderr
, ", flags=%08x", req
->flags
);
2860 static void dump_create_window_request( const struct create_window_request
*req
)
2862 fprintf( stderr
, " parent=%08x", req
->parent
);
2863 fprintf( stderr
, ", owner=%08x", req
->owner
);
2864 fprintf( stderr
, ", atom=%04x", req
->atom
);
2865 dump_uint64( ", instance=", &req
->instance
);
2866 fprintf( stderr
, ", dpi=%d", req
->dpi
);
2867 fprintf( stderr
, ", awareness=%d", req
->awareness
);
2868 dump_varargs_unicode_str( ", class=", cur_size
);
2871 static void dump_create_window_reply( const struct create_window_reply
*req
)
2873 fprintf( stderr
, " handle=%08x", req
->handle
);
2874 fprintf( stderr
, ", parent=%08x", req
->parent
);
2875 fprintf( stderr
, ", owner=%08x", req
->owner
);
2876 fprintf( stderr
, ", extra=%d", req
->extra
);
2877 dump_uint64( ", class_ptr=", &req
->class_ptr
);
2878 fprintf( stderr
, ", dpi=%d", req
->dpi
);
2879 fprintf( stderr
, ", awareness=%d", req
->awareness
);
2882 static void dump_destroy_window_request( const struct destroy_window_request
*req
)
2884 fprintf( stderr
, " handle=%08x", req
->handle
);
2887 static void dump_get_desktop_window_request( const struct get_desktop_window_request
*req
)
2889 fprintf( stderr
, " force=%d", req
->force
);
2892 static void dump_get_desktop_window_reply( const struct get_desktop_window_reply
*req
)
2894 fprintf( stderr
, " top_window=%08x", req
->top_window
);
2895 fprintf( stderr
, ", msg_window=%08x", req
->msg_window
);
2898 static void dump_set_window_owner_request( const struct set_window_owner_request
*req
)
2900 fprintf( stderr
, " handle=%08x", req
->handle
);
2901 fprintf( stderr
, ", owner=%08x", req
->owner
);
2904 static void dump_set_window_owner_reply( const struct set_window_owner_reply
*req
)
2906 fprintf( stderr
, " full_owner=%08x", req
->full_owner
);
2907 fprintf( stderr
, ", prev_owner=%08x", req
->prev_owner
);
2910 static void dump_get_window_info_request( const struct get_window_info_request
*req
)
2912 fprintf( stderr
, " handle=%08x", req
->handle
);
2915 static void dump_get_window_info_reply( const struct get_window_info_reply
*req
)
2917 fprintf( stderr
, " full_handle=%08x", req
->full_handle
);
2918 fprintf( stderr
, ", last_active=%08x", req
->last_active
);
2919 fprintf( stderr
, ", pid=%04x", req
->pid
);
2920 fprintf( stderr
, ", tid=%04x", req
->tid
);
2921 fprintf( stderr
, ", atom=%04x", req
->atom
);
2922 fprintf( stderr
, ", is_unicode=%d", req
->is_unicode
);
2923 fprintf( stderr
, ", dpi=%d", req
->dpi
);
2924 fprintf( stderr
, ", awareness=%d", req
->awareness
);
2927 static void dump_set_window_info_request( const struct set_window_info_request
*req
)
2929 fprintf( stderr
, " flags=%04x", req
->flags
);
2930 fprintf( stderr
, ", is_unicode=%d", req
->is_unicode
);
2931 fprintf( stderr
, ", handle=%08x", req
->handle
);
2932 fprintf( stderr
, ", style=%08x", req
->style
);
2933 fprintf( stderr
, ", ex_style=%08x", req
->ex_style
);
2934 fprintf( stderr
, ", id=%08x", req
->id
);
2935 dump_uint64( ", instance=", &req
->instance
);
2936 dump_uint64( ", user_data=", &req
->user_data
);
2937 fprintf( stderr
, ", extra_offset=%d", req
->extra_offset
);
2938 fprintf( stderr
, ", extra_size=%u", req
->extra_size
);
2939 dump_uint64( ", extra_value=", &req
->extra_value
);
2942 static void dump_set_window_info_reply( const struct set_window_info_reply
*req
)
2944 fprintf( stderr
, " old_style=%08x", req
->old_style
);
2945 fprintf( stderr
, ", old_ex_style=%08x", req
->old_ex_style
);
2946 dump_uint64( ", old_instance=", &req
->old_instance
);
2947 dump_uint64( ", old_user_data=", &req
->old_user_data
);
2948 dump_uint64( ", old_extra_value=", &req
->old_extra_value
);
2949 fprintf( stderr
, ", old_id=%08x", req
->old_id
);
2952 static void dump_set_parent_request( const struct set_parent_request
*req
)
2954 fprintf( stderr
, " handle=%08x", req
->handle
);
2955 fprintf( stderr
, ", parent=%08x", req
->parent
);
2958 static void dump_set_parent_reply( const struct set_parent_reply
*req
)
2960 fprintf( stderr
, " old_parent=%08x", req
->old_parent
);
2961 fprintf( stderr
, ", full_parent=%08x", req
->full_parent
);
2962 fprintf( stderr
, ", dpi=%d", req
->dpi
);
2963 fprintf( stderr
, ", awareness=%d", req
->awareness
);
2966 static void dump_get_window_parents_request( const struct get_window_parents_request
*req
)
2968 fprintf( stderr
, " handle=%08x", req
->handle
);
2971 static void dump_get_window_parents_reply( const struct get_window_parents_reply
*req
)
2973 fprintf( stderr
, " count=%d", req
->count
);
2974 dump_varargs_user_handles( ", parents=", cur_size
);
2977 static void dump_get_window_children_request( const struct get_window_children_request
*req
)
2979 fprintf( stderr
, " desktop=%04x", req
->desktop
);
2980 fprintf( stderr
, ", parent=%08x", req
->parent
);
2981 fprintf( stderr
, ", atom=%04x", req
->atom
);
2982 fprintf( stderr
, ", tid=%04x", req
->tid
);
2983 dump_varargs_unicode_str( ", class=", cur_size
);
2986 static void dump_get_window_children_reply( const struct get_window_children_reply
*req
)
2988 fprintf( stderr
, " count=%d", req
->count
);
2989 dump_varargs_user_handles( ", children=", cur_size
);
2992 static void dump_get_window_children_from_point_request( const struct get_window_children_from_point_request
*req
)
2994 fprintf( stderr
, " parent=%08x", req
->parent
);
2995 fprintf( stderr
, ", x=%d", req
->x
);
2996 fprintf( stderr
, ", y=%d", req
->y
);
2997 fprintf( stderr
, ", dpi=%d", req
->dpi
);
3000 static void dump_get_window_children_from_point_reply( const struct get_window_children_from_point_reply
*req
)
3002 fprintf( stderr
, " count=%d", req
->count
);
3003 dump_varargs_user_handles( ", children=", cur_size
);
3006 static void dump_get_window_tree_request( const struct get_window_tree_request
*req
)
3008 fprintf( stderr
, " handle=%08x", req
->handle
);
3011 static void dump_get_window_tree_reply( const struct get_window_tree_reply
*req
)
3013 fprintf( stderr
, " parent=%08x", req
->parent
);
3014 fprintf( stderr
, ", owner=%08x", req
->owner
);
3015 fprintf( stderr
, ", next_sibling=%08x", req
->next_sibling
);
3016 fprintf( stderr
, ", prev_sibling=%08x", req
->prev_sibling
);
3017 fprintf( stderr
, ", first_sibling=%08x", req
->first_sibling
);
3018 fprintf( stderr
, ", last_sibling=%08x", req
->last_sibling
);
3019 fprintf( stderr
, ", first_child=%08x", req
->first_child
);
3020 fprintf( stderr
, ", last_child=%08x", req
->last_child
);
3023 static void dump_set_window_pos_request( const struct set_window_pos_request
*req
)
3025 fprintf( stderr
, " swp_flags=%04x", req
->swp_flags
);
3026 fprintf( stderr
, ", paint_flags=%04x", req
->paint_flags
);
3027 fprintf( stderr
, ", handle=%08x", req
->handle
);
3028 fprintf( stderr
, ", previous=%08x", req
->previous
);
3029 dump_rectangle( ", window=", &req
->window
);
3030 dump_rectangle( ", client=", &req
->client
);
3031 dump_varargs_rectangles( ", valid=", cur_size
);
3034 static void dump_set_window_pos_reply( const struct set_window_pos_reply
*req
)
3036 fprintf( stderr
, " new_style=%08x", req
->new_style
);
3037 fprintf( stderr
, ", new_ex_style=%08x", req
->new_ex_style
);
3038 fprintf( stderr
, ", surface_win=%08x", req
->surface_win
);
3039 fprintf( stderr
, ", needs_update=%d", req
->needs_update
);
3042 static void dump_get_window_rectangles_request( const struct get_window_rectangles_request
*req
)
3044 fprintf( stderr
, " handle=%08x", req
->handle
);
3045 fprintf( stderr
, ", relative=%d", req
->relative
);
3046 fprintf( stderr
, ", dpi=%d", req
->dpi
);
3049 static void dump_get_window_rectangles_reply( const struct get_window_rectangles_reply
*req
)
3051 dump_rectangle( " window=", &req
->window
);
3052 dump_rectangle( ", client=", &req
->client
);
3055 static void dump_get_window_text_request( const struct get_window_text_request
*req
)
3057 fprintf( stderr
, " handle=%08x", req
->handle
);
3060 static void dump_get_window_text_reply( const struct get_window_text_reply
*req
)
3062 fprintf( stderr
, " length=%u", req
->length
);
3063 dump_varargs_unicode_str( ", text=", cur_size
);
3066 static void dump_set_window_text_request( const struct set_window_text_request
*req
)
3068 fprintf( stderr
, " handle=%08x", req
->handle
);
3069 dump_varargs_unicode_str( ", text=", cur_size
);
3072 static void dump_get_windows_offset_request( const struct get_windows_offset_request
*req
)
3074 fprintf( stderr
, " from=%08x", req
->from
);
3075 fprintf( stderr
, ", to=%08x", req
->to
);
3076 fprintf( stderr
, ", dpi=%d", req
->dpi
);
3079 static void dump_get_windows_offset_reply( const struct get_windows_offset_reply
*req
)
3081 fprintf( stderr
, " x=%d", req
->x
);
3082 fprintf( stderr
, ", y=%d", req
->y
);
3083 fprintf( stderr
, ", mirror=%d", req
->mirror
);
3086 static void dump_get_visible_region_request( const struct get_visible_region_request
*req
)
3088 fprintf( stderr
, " window=%08x", req
->window
);
3089 fprintf( stderr
, ", flags=%08x", req
->flags
);
3092 static void dump_get_visible_region_reply( const struct get_visible_region_reply
*req
)
3094 fprintf( stderr
, " top_win=%08x", req
->top_win
);
3095 dump_rectangle( ", top_rect=", &req
->top_rect
);
3096 dump_rectangle( ", win_rect=", &req
->win_rect
);
3097 fprintf( stderr
, ", paint_flags=%08x", req
->paint_flags
);
3098 fprintf( stderr
, ", total_size=%u", req
->total_size
);
3099 dump_varargs_rectangles( ", region=", cur_size
);
3102 static void dump_get_surface_region_request( const struct get_surface_region_request
*req
)
3104 fprintf( stderr
, " window=%08x", req
->window
);
3107 static void dump_get_surface_region_reply( const struct get_surface_region_reply
*req
)
3109 dump_rectangle( " visible_rect=", &req
->visible_rect
);
3110 fprintf( stderr
, ", total_size=%u", req
->total_size
);
3111 dump_varargs_rectangles( ", region=", cur_size
);
3114 static void dump_get_window_region_request( const struct get_window_region_request
*req
)
3116 fprintf( stderr
, " window=%08x", req
->window
);
3119 static void dump_get_window_region_reply( const struct get_window_region_reply
*req
)
3121 fprintf( stderr
, " total_size=%u", req
->total_size
);
3122 dump_varargs_rectangles( ", region=", cur_size
);
3125 static void dump_set_window_region_request( const struct set_window_region_request
*req
)
3127 fprintf( stderr
, " window=%08x", req
->window
);
3128 fprintf( stderr
, ", redraw=%d", req
->redraw
);
3129 dump_varargs_rectangles( ", region=", cur_size
);
3132 static void dump_get_update_region_request( const struct get_update_region_request
*req
)
3134 fprintf( stderr
, " window=%08x", req
->window
);
3135 fprintf( stderr
, ", from_child=%08x", req
->from_child
);
3136 fprintf( stderr
, ", flags=%08x", req
->flags
);
3139 static void dump_get_update_region_reply( const struct get_update_region_reply
*req
)
3141 fprintf( stderr
, " child=%08x", req
->child
);
3142 fprintf( stderr
, ", flags=%08x", req
->flags
);
3143 fprintf( stderr
, ", total_size=%u", req
->total_size
);
3144 dump_varargs_rectangles( ", region=", cur_size
);
3147 static void dump_update_window_zorder_request( const struct update_window_zorder_request
*req
)
3149 fprintf( stderr
, " window=%08x", req
->window
);
3150 dump_rectangle( ", rect=", &req
->rect
);
3153 static void dump_redraw_window_request( const struct redraw_window_request
*req
)
3155 fprintf( stderr
, " window=%08x", req
->window
);
3156 fprintf( stderr
, ", flags=%08x", req
->flags
);
3157 dump_varargs_rectangles( ", region=", cur_size
);
3160 static void dump_set_window_property_request( const struct set_window_property_request
*req
)
3162 fprintf( stderr
, " window=%08x", req
->window
);
3163 dump_uint64( ", data=", &req
->data
);
3164 fprintf( stderr
, ", atom=%04x", req
->atom
);
3165 dump_varargs_unicode_str( ", name=", cur_size
);
3168 static void dump_remove_window_property_request( const struct remove_window_property_request
*req
)
3170 fprintf( stderr
, " window=%08x", req
->window
);
3171 fprintf( stderr
, ", atom=%04x", req
->atom
);
3172 dump_varargs_unicode_str( ", name=", cur_size
);
3175 static void dump_remove_window_property_reply( const struct remove_window_property_reply
*req
)
3177 dump_uint64( " data=", &req
->data
);
3180 static void dump_get_window_property_request( const struct get_window_property_request
*req
)
3182 fprintf( stderr
, " window=%08x", req
->window
);
3183 fprintf( stderr
, ", atom=%04x", req
->atom
);
3184 dump_varargs_unicode_str( ", name=", cur_size
);
3187 static void dump_get_window_property_reply( const struct get_window_property_reply
*req
)
3189 dump_uint64( " data=", &req
->data
);
3192 static void dump_get_window_properties_request( const struct get_window_properties_request
*req
)
3194 fprintf( stderr
, " window=%08x", req
->window
);
3197 static void dump_get_window_properties_reply( const struct get_window_properties_reply
*req
)
3199 fprintf( stderr
, " total=%d", req
->total
);
3200 dump_varargs_properties( ", props=", cur_size
);
3203 static void dump_create_winstation_request( const struct create_winstation_request
*req
)
3205 fprintf( stderr
, " flags=%08x", req
->flags
);
3206 fprintf( stderr
, ", access=%08x", req
->access
);
3207 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3208 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
3209 dump_varargs_unicode_str( ", name=", cur_size
);
3212 static void dump_create_winstation_reply( const struct create_winstation_reply
*req
)
3214 fprintf( stderr
, " handle=%04x", req
->handle
);
3217 static void dump_open_winstation_request( const struct open_winstation_request
*req
)
3219 fprintf( stderr
, " access=%08x", req
->access
);
3220 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3221 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
3222 dump_varargs_unicode_str( ", name=", cur_size
);
3225 static void dump_open_winstation_reply( const struct open_winstation_reply
*req
)
3227 fprintf( stderr
, " handle=%04x", req
->handle
);
3230 static void dump_close_winstation_request( const struct close_winstation_request
*req
)
3232 fprintf( stderr
, " handle=%04x", req
->handle
);
3235 static void dump_get_process_winstation_request( const struct get_process_winstation_request
*req
)
3239 static void dump_get_process_winstation_reply( const struct get_process_winstation_reply
*req
)
3241 fprintf( stderr
, " handle=%04x", req
->handle
);
3244 static void dump_set_process_winstation_request( const struct set_process_winstation_request
*req
)
3246 fprintf( stderr
, " handle=%04x", req
->handle
);
3249 static void dump_enum_winstation_request( const struct enum_winstation_request
*req
)
3251 fprintf( stderr
, " index=%08x", req
->index
);
3254 static void dump_enum_winstation_reply( const struct enum_winstation_reply
*req
)
3256 fprintf( stderr
, " next=%08x", req
->next
);
3257 dump_varargs_unicode_str( ", name=", cur_size
);
3260 static void dump_create_desktop_request( const struct create_desktop_request
*req
)
3262 fprintf( stderr
, " flags=%08x", req
->flags
);
3263 fprintf( stderr
, ", access=%08x", req
->access
);
3264 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3265 dump_varargs_unicode_str( ", name=", cur_size
);
3268 static void dump_create_desktop_reply( const struct create_desktop_reply
*req
)
3270 fprintf( stderr
, " handle=%04x", req
->handle
);
3273 static void dump_open_desktop_request( const struct open_desktop_request
*req
)
3275 fprintf( stderr
, " winsta=%04x", req
->winsta
);
3276 fprintf( stderr
, ", flags=%08x", req
->flags
);
3277 fprintf( stderr
, ", access=%08x", req
->access
);
3278 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3279 dump_varargs_unicode_str( ", name=", cur_size
);
3282 static void dump_open_desktop_reply( const struct open_desktop_reply
*req
)
3284 fprintf( stderr
, " handle=%04x", req
->handle
);
3287 static void dump_open_input_desktop_request( const struct open_input_desktop_request
*req
)
3289 fprintf( stderr
, " flags=%08x", req
->flags
);
3290 fprintf( stderr
, ", access=%08x", req
->access
);
3291 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3294 static void dump_open_input_desktop_reply( const struct open_input_desktop_reply
*req
)
3296 fprintf( stderr
, " handle=%04x", req
->handle
);
3299 static void dump_close_desktop_request( const struct close_desktop_request
*req
)
3301 fprintf( stderr
, " handle=%04x", req
->handle
);
3304 static void dump_get_thread_desktop_request( const struct get_thread_desktop_request
*req
)
3306 fprintf( stderr
, " tid=%04x", req
->tid
);
3309 static void dump_get_thread_desktop_reply( const struct get_thread_desktop_reply
*req
)
3311 fprintf( stderr
, " handle=%04x", req
->handle
);
3314 static void dump_set_thread_desktop_request( const struct set_thread_desktop_request
*req
)
3316 fprintf( stderr
, " handle=%04x", req
->handle
);
3319 static void dump_enum_desktop_request( const struct enum_desktop_request
*req
)
3321 fprintf( stderr
, " winstation=%04x", req
->winstation
);
3322 fprintf( stderr
, ", index=%08x", req
->index
);
3325 static void dump_enum_desktop_reply( const struct enum_desktop_reply
*req
)
3327 fprintf( stderr
, " next=%08x", req
->next
);
3328 dump_varargs_unicode_str( ", name=", cur_size
);
3331 static void dump_set_user_object_info_request( const struct set_user_object_info_request
*req
)
3333 fprintf( stderr
, " handle=%04x", req
->handle
);
3334 fprintf( stderr
, ", flags=%08x", req
->flags
);
3335 fprintf( stderr
, ", obj_flags=%08x", req
->obj_flags
);
3338 static void dump_set_user_object_info_reply( const struct set_user_object_info_reply
*req
)
3340 fprintf( stderr
, " is_desktop=%d", req
->is_desktop
);
3341 fprintf( stderr
, ", old_obj_flags=%08x", req
->old_obj_flags
);
3342 dump_varargs_unicode_str( ", name=", cur_size
);
3345 static void dump_register_hotkey_request( const struct register_hotkey_request
*req
)
3347 fprintf( stderr
, " window=%08x", req
->window
);
3348 fprintf( stderr
, ", id=%d", req
->id
);
3349 fprintf( stderr
, ", flags=%08x", req
->flags
);
3350 fprintf( stderr
, ", vkey=%08x", req
->vkey
);
3353 static void dump_register_hotkey_reply( const struct register_hotkey_reply
*req
)
3355 fprintf( stderr
, " replaced=%d", req
->replaced
);
3356 fprintf( stderr
, ", flags=%08x", req
->flags
);
3357 fprintf( stderr
, ", vkey=%08x", req
->vkey
);
3360 static void dump_unregister_hotkey_request( const struct unregister_hotkey_request
*req
)
3362 fprintf( stderr
, " window=%08x", req
->window
);
3363 fprintf( stderr
, ", id=%d", req
->id
);
3366 static void dump_unregister_hotkey_reply( const struct unregister_hotkey_reply
*req
)
3368 fprintf( stderr
, " flags=%08x", req
->flags
);
3369 fprintf( stderr
, ", vkey=%08x", req
->vkey
);
3372 static void dump_attach_thread_input_request( const struct attach_thread_input_request
*req
)
3374 fprintf( stderr
, " tid_from=%04x", req
->tid_from
);
3375 fprintf( stderr
, ", tid_to=%04x", req
->tid_to
);
3376 fprintf( stderr
, ", attach=%d", req
->attach
);
3379 static void dump_get_thread_input_request( const struct get_thread_input_request
*req
)
3381 fprintf( stderr
, " tid=%04x", req
->tid
);
3384 static void dump_get_thread_input_reply( const struct get_thread_input_reply
*req
)
3386 fprintf( stderr
, " focus=%08x", req
->focus
);
3387 fprintf( stderr
, ", capture=%08x", req
->capture
);
3388 fprintf( stderr
, ", active=%08x", req
->active
);
3389 fprintf( stderr
, ", foreground=%08x", req
->foreground
);
3390 fprintf( stderr
, ", menu_owner=%08x", req
->menu_owner
);
3391 fprintf( stderr
, ", move_size=%08x", req
->move_size
);
3392 fprintf( stderr
, ", caret=%08x", req
->caret
);
3393 fprintf( stderr
, ", cursor=%08x", req
->cursor
);
3394 fprintf( stderr
, ", show_count=%d", req
->show_count
);
3395 dump_rectangle( ", rect=", &req
->rect
);
3398 static void dump_get_last_input_time_request( const struct get_last_input_time_request
*req
)
3402 static void dump_get_last_input_time_reply( const struct get_last_input_time_reply
*req
)
3404 fprintf( stderr
, " time=%08x", req
->time
);
3407 static void dump_get_key_state_request( const struct get_key_state_request
*req
)
3409 fprintf( stderr
, " tid=%04x", req
->tid
);
3410 fprintf( stderr
, ", key=%d", req
->key
);
3413 static void dump_get_key_state_reply( const struct get_key_state_reply
*req
)
3415 fprintf( stderr
, " state=%02x", req
->state
);
3416 dump_varargs_bytes( ", keystate=", cur_size
);
3419 static void dump_set_key_state_request( const struct set_key_state_request
*req
)
3421 fprintf( stderr
, " tid=%04x", req
->tid
);
3422 fprintf( stderr
, ", async=%d", req
->async
);
3423 dump_varargs_bytes( ", keystate=", cur_size
);
3426 static void dump_set_foreground_window_request( const struct set_foreground_window_request
*req
)
3428 fprintf( stderr
, " handle=%08x", req
->handle
);
3431 static void dump_set_foreground_window_reply( const struct set_foreground_window_reply
*req
)
3433 fprintf( stderr
, " previous=%08x", req
->previous
);
3434 fprintf( stderr
, ", send_msg_old=%d", req
->send_msg_old
);
3435 fprintf( stderr
, ", send_msg_new=%d", req
->send_msg_new
);
3438 static void dump_set_focus_window_request( const struct set_focus_window_request
*req
)
3440 fprintf( stderr
, " handle=%08x", req
->handle
);
3443 static void dump_set_focus_window_reply( const struct set_focus_window_reply
*req
)
3445 fprintf( stderr
, " previous=%08x", req
->previous
);
3448 static void dump_set_active_window_request( const struct set_active_window_request
*req
)
3450 fprintf( stderr
, " handle=%08x", req
->handle
);
3453 static void dump_set_active_window_reply( const struct set_active_window_reply
*req
)
3455 fprintf( stderr
, " previous=%08x", req
->previous
);
3458 static void dump_set_capture_window_request( const struct set_capture_window_request
*req
)
3460 fprintf( stderr
, " handle=%08x", req
->handle
);
3461 fprintf( stderr
, ", flags=%08x", req
->flags
);
3464 static void dump_set_capture_window_reply( const struct set_capture_window_reply
*req
)
3466 fprintf( stderr
, " previous=%08x", req
->previous
);
3467 fprintf( stderr
, ", full_handle=%08x", req
->full_handle
);
3470 static void dump_set_caret_window_request( const struct set_caret_window_request
*req
)
3472 fprintf( stderr
, " handle=%08x", req
->handle
);
3473 fprintf( stderr
, ", width=%d", req
->width
);
3474 fprintf( stderr
, ", height=%d", req
->height
);
3477 static void dump_set_caret_window_reply( const struct set_caret_window_reply
*req
)
3479 fprintf( stderr
, " previous=%08x", req
->previous
);
3480 dump_rectangle( ", old_rect=", &req
->old_rect
);
3481 fprintf( stderr
, ", old_hide=%d", req
->old_hide
);
3482 fprintf( stderr
, ", old_state=%d", req
->old_state
);
3485 static void dump_set_caret_info_request( const struct set_caret_info_request
*req
)
3487 fprintf( stderr
, " flags=%08x", req
->flags
);
3488 fprintf( stderr
, ", handle=%08x", req
->handle
);
3489 fprintf( stderr
, ", x=%d", req
->x
);
3490 fprintf( stderr
, ", y=%d", req
->y
);
3491 fprintf( stderr
, ", hide=%d", req
->hide
);
3492 fprintf( stderr
, ", state=%d", req
->state
);
3495 static void dump_set_caret_info_reply( const struct set_caret_info_reply
*req
)
3497 fprintf( stderr
, " full_handle=%08x", req
->full_handle
);
3498 dump_rectangle( ", old_rect=", &req
->old_rect
);
3499 fprintf( stderr
, ", old_hide=%d", req
->old_hide
);
3500 fprintf( stderr
, ", old_state=%d", req
->old_state
);
3503 static void dump_set_hook_request( const struct set_hook_request
*req
)
3505 fprintf( stderr
, " id=%d", req
->id
);
3506 fprintf( stderr
, ", pid=%04x", req
->pid
);
3507 fprintf( stderr
, ", tid=%04x", req
->tid
);
3508 fprintf( stderr
, ", event_min=%d", req
->event_min
);
3509 fprintf( stderr
, ", event_max=%d", req
->event_max
);
3510 dump_uint64( ", proc=", &req
->proc
);
3511 fprintf( stderr
, ", flags=%d", req
->flags
);
3512 fprintf( stderr
, ", unicode=%d", req
->unicode
);
3513 dump_varargs_unicode_str( ", module=", cur_size
);
3516 static void dump_set_hook_reply( const struct set_hook_reply
*req
)
3518 fprintf( stderr
, " handle=%08x", req
->handle
);
3519 fprintf( stderr
, ", active_hooks=%08x", req
->active_hooks
);
3522 static void dump_remove_hook_request( const struct remove_hook_request
*req
)
3524 fprintf( stderr
, " handle=%08x", req
->handle
);
3525 dump_uint64( ", proc=", &req
->proc
);
3526 fprintf( stderr
, ", id=%d", req
->id
);
3529 static void dump_remove_hook_reply( const struct remove_hook_reply
*req
)
3531 fprintf( stderr
, " active_hooks=%08x", req
->active_hooks
);
3534 static void dump_start_hook_chain_request( const struct start_hook_chain_request
*req
)
3536 fprintf( stderr
, " id=%d", req
->id
);
3537 fprintf( stderr
, ", event=%d", req
->event
);
3538 fprintf( stderr
, ", window=%08x", req
->window
);
3539 fprintf( stderr
, ", object_id=%d", req
->object_id
);
3540 fprintf( stderr
, ", child_id=%d", req
->child_id
);
3543 static void dump_start_hook_chain_reply( const struct start_hook_chain_reply
*req
)
3545 fprintf( stderr
, " handle=%08x", req
->handle
);
3546 fprintf( stderr
, ", pid=%04x", req
->pid
);
3547 fprintf( stderr
, ", tid=%04x", req
->tid
);
3548 fprintf( stderr
, ", unicode=%d", req
->unicode
);
3549 dump_uint64( ", proc=", &req
->proc
);
3550 fprintf( stderr
, ", active_hooks=%08x", req
->active_hooks
);
3551 dump_varargs_unicode_str( ", module=", cur_size
);
3554 static void dump_finish_hook_chain_request( const struct finish_hook_chain_request
*req
)
3556 fprintf( stderr
, " id=%d", req
->id
);
3559 static void dump_get_hook_info_request( const struct get_hook_info_request
*req
)
3561 fprintf( stderr
, " handle=%08x", req
->handle
);
3562 fprintf( stderr
, ", get_next=%d", req
->get_next
);
3563 fprintf( stderr
, ", event=%d", req
->event
);
3564 fprintf( stderr
, ", window=%08x", req
->window
);
3565 fprintf( stderr
, ", object_id=%d", req
->object_id
);
3566 fprintf( stderr
, ", child_id=%d", req
->child_id
);
3569 static void dump_get_hook_info_reply( const struct get_hook_info_reply
*req
)
3571 fprintf( stderr
, " handle=%08x", req
->handle
);
3572 fprintf( stderr
, ", id=%d", req
->id
);
3573 fprintf( stderr
, ", pid=%04x", req
->pid
);
3574 fprintf( stderr
, ", tid=%04x", req
->tid
);
3575 dump_uint64( ", proc=", &req
->proc
);
3576 fprintf( stderr
, ", unicode=%d", req
->unicode
);
3577 dump_varargs_unicode_str( ", module=", cur_size
);
3580 static void dump_create_class_request( const struct create_class_request
*req
)
3582 fprintf( stderr
, " local=%d", req
->local
);
3583 fprintf( stderr
, ", atom=%04x", req
->atom
);
3584 fprintf( stderr
, ", style=%08x", req
->style
);
3585 dump_uint64( ", instance=", &req
->instance
);
3586 fprintf( stderr
, ", extra=%d", req
->extra
);
3587 fprintf( stderr
, ", win_extra=%d", req
->win_extra
);
3588 dump_uint64( ", client_ptr=", &req
->client_ptr
);
3589 fprintf( stderr
, ", name_offset=%u", req
->name_offset
);
3590 dump_varargs_unicode_str( ", name=", cur_size
);
3593 static void dump_create_class_reply( const struct create_class_reply
*req
)
3595 fprintf( stderr
, " atom=%04x", req
->atom
);
3598 static void dump_destroy_class_request( const struct destroy_class_request
*req
)
3600 fprintf( stderr
, " atom=%04x", req
->atom
);
3601 dump_uint64( ", instance=", &req
->instance
);
3602 dump_varargs_unicode_str( ", name=", cur_size
);
3605 static void dump_destroy_class_reply( const struct destroy_class_reply
*req
)
3607 dump_uint64( " client_ptr=", &req
->client_ptr
);
3610 static void dump_set_class_info_request( const struct set_class_info_request
*req
)
3612 fprintf( stderr
, " window=%08x", req
->window
);
3613 fprintf( stderr
, ", flags=%08x", req
->flags
);
3614 fprintf( stderr
, ", atom=%04x", req
->atom
);
3615 fprintf( stderr
, ", style=%08x", req
->style
);
3616 fprintf( stderr
, ", win_extra=%d", req
->win_extra
);
3617 dump_uint64( ", instance=", &req
->instance
);
3618 fprintf( stderr
, ", extra_offset=%d", req
->extra_offset
);
3619 fprintf( stderr
, ", extra_size=%u", req
->extra_size
);
3620 dump_uint64( ", extra_value=", &req
->extra_value
);
3623 static void dump_set_class_info_reply( const struct set_class_info_reply
*req
)
3625 fprintf( stderr
, " old_atom=%04x", req
->old_atom
);
3626 fprintf( stderr
, ", base_atom=%04x", req
->base_atom
);
3627 dump_uint64( ", old_instance=", &req
->old_instance
);
3628 dump_uint64( ", old_extra_value=", &req
->old_extra_value
);
3629 fprintf( stderr
, ", old_style=%08x", req
->old_style
);
3630 fprintf( stderr
, ", old_extra=%d", req
->old_extra
);
3631 fprintf( stderr
, ", old_win_extra=%d", req
->old_win_extra
);
3634 static void dump_open_clipboard_request( const struct open_clipboard_request
*req
)
3636 fprintf( stderr
, " window=%08x", req
->window
);
3639 static void dump_open_clipboard_reply( const struct open_clipboard_reply
*req
)
3641 fprintf( stderr
, " owner=%08x", req
->owner
);
3644 static void dump_close_clipboard_request( const struct close_clipboard_request
*req
)
3648 static void dump_close_clipboard_reply( const struct close_clipboard_reply
*req
)
3650 fprintf( stderr
, " viewer=%08x", req
->viewer
);
3651 fprintf( stderr
, ", owner=%08x", req
->owner
);
3654 static void dump_empty_clipboard_request( const struct empty_clipboard_request
*req
)
3658 static void dump_set_clipboard_data_request( const struct set_clipboard_data_request
*req
)
3660 fprintf( stderr
, " format=%08x", req
->format
);
3661 fprintf( stderr
, ", lcid=%08x", req
->lcid
);
3662 dump_varargs_bytes( ", data=", cur_size
);
3665 static void dump_set_clipboard_data_reply( const struct set_clipboard_data_reply
*req
)
3667 fprintf( stderr
, " seqno=%08x", req
->seqno
);
3670 static void dump_get_clipboard_data_request( const struct get_clipboard_data_request
*req
)
3672 fprintf( stderr
, " format=%08x", req
->format
);
3673 fprintf( stderr
, ", render=%d", req
->render
);
3674 fprintf( stderr
, ", cached=%d", req
->cached
);
3675 fprintf( stderr
, ", seqno=%08x", req
->seqno
);
3678 static void dump_get_clipboard_data_reply( const struct get_clipboard_data_reply
*req
)
3680 fprintf( stderr
, " from=%08x", req
->from
);
3681 fprintf( stderr
, ", owner=%08x", req
->owner
);
3682 fprintf( stderr
, ", seqno=%08x", req
->seqno
);
3683 fprintf( stderr
, ", total=%u", req
->total
);
3684 dump_varargs_bytes( ", data=", cur_size
);
3687 static void dump_get_clipboard_formats_request( const struct get_clipboard_formats_request
*req
)
3689 fprintf( stderr
, " format=%08x", req
->format
);
3692 static void dump_get_clipboard_formats_reply( const struct get_clipboard_formats_reply
*req
)
3694 fprintf( stderr
, " count=%08x", req
->count
);
3695 dump_varargs_uints( ", formats=", cur_size
);
3698 static void dump_enum_clipboard_formats_request( const struct enum_clipboard_formats_request
*req
)
3700 fprintf( stderr
, " previous=%08x", req
->previous
);
3703 static void dump_enum_clipboard_formats_reply( const struct enum_clipboard_formats_reply
*req
)
3705 fprintf( stderr
, " format=%08x", req
->format
);
3708 static void dump_release_clipboard_request( const struct release_clipboard_request
*req
)
3710 fprintf( stderr
, " owner=%08x", req
->owner
);
3713 static void dump_release_clipboard_reply( const struct release_clipboard_reply
*req
)
3715 fprintf( stderr
, " viewer=%08x", req
->viewer
);
3716 fprintf( stderr
, ", owner=%08x", req
->owner
);
3719 static void dump_get_clipboard_info_request( const struct get_clipboard_info_request
*req
)
3723 static void dump_get_clipboard_info_reply( const struct get_clipboard_info_reply
*req
)
3725 fprintf( stderr
, " window=%08x", req
->window
);
3726 fprintf( stderr
, ", owner=%08x", req
->owner
);
3727 fprintf( stderr
, ", viewer=%08x", req
->viewer
);
3728 fprintf( stderr
, ", seqno=%08x", req
->seqno
);
3731 static void dump_set_clipboard_viewer_request( const struct set_clipboard_viewer_request
*req
)
3733 fprintf( stderr
, " viewer=%08x", req
->viewer
);
3734 fprintf( stderr
, ", previous=%08x", req
->previous
);
3737 static void dump_set_clipboard_viewer_reply( const struct set_clipboard_viewer_reply
*req
)
3739 fprintf( stderr
, " old_viewer=%08x", req
->old_viewer
);
3740 fprintf( stderr
, ", owner=%08x", req
->owner
);
3743 static void dump_add_clipboard_listener_request( const struct add_clipboard_listener_request
*req
)
3745 fprintf( stderr
, " window=%08x", req
->window
);
3748 static void dump_remove_clipboard_listener_request( const struct remove_clipboard_listener_request
*req
)
3750 fprintf( stderr
, " window=%08x", req
->window
);
3753 static void dump_open_token_request( const struct open_token_request
*req
)
3755 fprintf( stderr
, " handle=%04x", req
->handle
);
3756 fprintf( stderr
, ", access=%08x", req
->access
);
3757 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3758 fprintf( stderr
, ", flags=%08x", req
->flags
);
3761 static void dump_open_token_reply( const struct open_token_reply
*req
)
3763 fprintf( stderr
, " token=%04x", req
->token
);
3766 static void dump_set_global_windows_request( const struct set_global_windows_request
*req
)
3768 fprintf( stderr
, " flags=%08x", req
->flags
);
3769 fprintf( stderr
, ", shell_window=%08x", req
->shell_window
);
3770 fprintf( stderr
, ", shell_listview=%08x", req
->shell_listview
);
3771 fprintf( stderr
, ", progman_window=%08x", req
->progman_window
);
3772 fprintf( stderr
, ", taskman_window=%08x", req
->taskman_window
);
3775 static void dump_set_global_windows_reply( const struct set_global_windows_reply
*req
)
3777 fprintf( stderr
, " old_shell_window=%08x", req
->old_shell_window
);
3778 fprintf( stderr
, ", old_shell_listview=%08x", req
->old_shell_listview
);
3779 fprintf( stderr
, ", old_progman_window=%08x", req
->old_progman_window
);
3780 fprintf( stderr
, ", old_taskman_window=%08x", req
->old_taskman_window
);
3783 static void dump_adjust_token_privileges_request( const struct adjust_token_privileges_request
*req
)
3785 fprintf( stderr
, " handle=%04x", req
->handle
);
3786 fprintf( stderr
, ", disable_all=%d", req
->disable_all
);
3787 fprintf( stderr
, ", get_modified_state=%d", req
->get_modified_state
);
3788 dump_varargs_LUID_AND_ATTRIBUTES( ", privileges=", cur_size
);
3791 static void dump_adjust_token_privileges_reply( const struct adjust_token_privileges_reply
*req
)
3793 fprintf( stderr
, " len=%08x", req
->len
);
3794 dump_varargs_LUID_AND_ATTRIBUTES( ", privileges=", cur_size
);
3797 static void dump_get_token_privileges_request( const struct get_token_privileges_request
*req
)
3799 fprintf( stderr
, " handle=%04x", req
->handle
);
3802 static void dump_get_token_privileges_reply( const struct get_token_privileges_reply
*req
)
3804 fprintf( stderr
, " len=%08x", req
->len
);
3805 dump_varargs_LUID_AND_ATTRIBUTES( ", privileges=", cur_size
);
3808 static void dump_check_token_privileges_request( const struct check_token_privileges_request
*req
)
3810 fprintf( stderr
, " handle=%04x", req
->handle
);
3811 fprintf( stderr
, ", all_required=%d", req
->all_required
);
3812 dump_varargs_LUID_AND_ATTRIBUTES( ", privileges=", cur_size
);
3815 static void dump_check_token_privileges_reply( const struct check_token_privileges_reply
*req
)
3817 fprintf( stderr
, " has_privileges=%d", req
->has_privileges
);
3818 dump_varargs_LUID_AND_ATTRIBUTES( ", privileges=", cur_size
);
3821 static void dump_duplicate_token_request( const struct duplicate_token_request
*req
)
3823 fprintf( stderr
, " handle=%04x", req
->handle
);
3824 fprintf( stderr
, ", access=%08x", req
->access
);
3825 fprintf( stderr
, ", primary=%d", req
->primary
);
3826 fprintf( stderr
, ", impersonation_level=%d", req
->impersonation_level
);
3827 dump_varargs_object_attributes( ", objattr=", cur_size
);
3830 static void dump_duplicate_token_reply( const struct duplicate_token_reply
*req
)
3832 fprintf( stderr
, " new_handle=%04x", req
->new_handle
);
3835 static void dump_access_check_request( const struct access_check_request
*req
)
3837 fprintf( stderr
, " handle=%04x", req
->handle
);
3838 fprintf( stderr
, ", desired_access=%08x", req
->desired_access
);
3839 fprintf( stderr
, ", mapping_read=%08x", req
->mapping_read
);
3840 fprintf( stderr
, ", mapping_write=%08x", req
->mapping_write
);
3841 fprintf( stderr
, ", mapping_execute=%08x", req
->mapping_execute
);
3842 fprintf( stderr
, ", mapping_all=%08x", req
->mapping_all
);
3843 dump_varargs_security_descriptor( ", sd=", cur_size
);
3846 static void dump_access_check_reply( const struct access_check_reply
*req
)
3848 fprintf( stderr
, " access_granted=%08x", req
->access_granted
);
3849 fprintf( stderr
, ", access_status=%08x", req
->access_status
);
3850 fprintf( stderr
, ", privileges_len=%08x", req
->privileges_len
);
3851 dump_varargs_LUID_AND_ATTRIBUTES( ", privileges=", cur_size
);
3854 static void dump_get_token_sid_request( const struct get_token_sid_request
*req
)
3856 fprintf( stderr
, " handle=%04x", req
->handle
);
3857 fprintf( stderr
, ", which_sid=%08x", req
->which_sid
);
3860 static void dump_get_token_sid_reply( const struct get_token_sid_reply
*req
)
3862 fprintf( stderr
, " sid_len=%u", req
->sid_len
);
3863 dump_varargs_SID( ", sid=", cur_size
);
3866 static void dump_get_token_groups_request( const struct get_token_groups_request
*req
)
3868 fprintf( stderr
, " handle=%04x", req
->handle
);
3871 static void dump_get_token_groups_reply( const struct get_token_groups_reply
*req
)
3873 fprintf( stderr
, " user_len=%u", req
->user_len
);
3874 dump_varargs_token_groups( ", user=", cur_size
);
3877 static void dump_get_token_default_dacl_request( const struct get_token_default_dacl_request
*req
)
3879 fprintf( stderr
, " handle=%04x", req
->handle
);
3882 static void dump_get_token_default_dacl_reply( const struct get_token_default_dacl_reply
*req
)
3884 fprintf( stderr
, " acl_len=%u", req
->acl_len
);
3885 dump_varargs_ACL( ", acl=", cur_size
);
3888 static void dump_set_token_default_dacl_request( const struct set_token_default_dacl_request
*req
)
3890 fprintf( stderr
, " handle=%04x", req
->handle
);
3891 dump_varargs_ACL( ", acl=", cur_size
);
3894 static void dump_set_security_object_request( const struct set_security_object_request
*req
)
3896 fprintf( stderr
, " handle=%04x", req
->handle
);
3897 fprintf( stderr
, ", security_info=%08x", req
->security_info
);
3898 dump_varargs_security_descriptor( ", sd=", cur_size
);
3901 static void dump_get_security_object_request( const struct get_security_object_request
*req
)
3903 fprintf( stderr
, " handle=%04x", req
->handle
);
3904 fprintf( stderr
, ", security_info=%08x", req
->security_info
);
3907 static void dump_get_security_object_reply( const struct get_security_object_reply
*req
)
3909 fprintf( stderr
, " sd_len=%08x", req
->sd_len
);
3910 dump_varargs_security_descriptor( ", sd=", cur_size
);
3913 static void dump_get_system_handles_request( const struct get_system_handles_request
*req
)
3917 static void dump_get_system_handles_reply( const struct get_system_handles_reply
*req
)
3919 fprintf( stderr
, " count=%08x", req
->count
);
3920 dump_varargs_handle_infos( ", data=", cur_size
);
3923 static void dump_create_mailslot_request( const struct create_mailslot_request
*req
)
3925 fprintf( stderr
, " access=%08x", req
->access
);
3926 dump_timeout( ", read_timeout=", &req
->read_timeout
);
3927 fprintf( stderr
, ", max_msgsize=%08x", req
->max_msgsize
);
3928 dump_varargs_object_attributes( ", objattr=", cur_size
);
3931 static void dump_create_mailslot_reply( const struct create_mailslot_reply
*req
)
3933 fprintf( stderr
, " handle=%04x", req
->handle
);
3936 static void dump_set_mailslot_info_request( const struct set_mailslot_info_request
*req
)
3938 fprintf( stderr
, " handle=%04x", req
->handle
);
3939 dump_timeout( ", read_timeout=", &req
->read_timeout
);
3940 fprintf( stderr
, ", flags=%08x", req
->flags
);
3943 static void dump_set_mailslot_info_reply( const struct set_mailslot_info_reply
*req
)
3945 dump_timeout( " read_timeout=", &req
->read_timeout
);
3946 fprintf( stderr
, ", max_msgsize=%08x", req
->max_msgsize
);
3949 static void dump_create_directory_request( const struct create_directory_request
*req
)
3951 fprintf( stderr
, " access=%08x", req
->access
);
3952 dump_varargs_object_attributes( ", objattr=", cur_size
);
3955 static void dump_create_directory_reply( const struct create_directory_reply
*req
)
3957 fprintf( stderr
, " handle=%04x", req
->handle
);
3960 static void dump_open_directory_request( const struct open_directory_request
*req
)
3962 fprintf( stderr
, " access=%08x", req
->access
);
3963 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
3964 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
3965 dump_varargs_unicode_str( ", directory_name=", cur_size
);
3968 static void dump_open_directory_reply( const struct open_directory_reply
*req
)
3970 fprintf( stderr
, " handle=%04x", req
->handle
);
3973 static void dump_get_directory_entry_request( const struct get_directory_entry_request
*req
)
3975 fprintf( stderr
, " handle=%04x", req
->handle
);
3976 fprintf( stderr
, ", index=%08x", req
->index
);
3979 static void dump_get_directory_entry_reply( const struct get_directory_entry_reply
*req
)
3981 fprintf( stderr
, " name_len=%u", req
->name_len
);
3982 dump_varargs_unicode_str( ", name=", min(cur_size
,req
->name_len
) );
3983 dump_varargs_unicode_str( ", type=", cur_size
);
3986 static void dump_create_symlink_request( const struct create_symlink_request
*req
)
3988 fprintf( stderr
, " access=%08x", req
->access
);
3989 dump_varargs_object_attributes( ", objattr=", cur_size
);
3990 dump_varargs_unicode_str( ", target_name=", cur_size
);
3993 static void dump_create_symlink_reply( const struct create_symlink_reply
*req
)
3995 fprintf( stderr
, " handle=%04x", req
->handle
);
3998 static void dump_open_symlink_request( const struct open_symlink_request
*req
)
4000 fprintf( stderr
, " access=%08x", req
->access
);
4001 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
4002 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
4003 dump_varargs_unicode_str( ", name=", cur_size
);
4006 static void dump_open_symlink_reply( const struct open_symlink_reply
*req
)
4008 fprintf( stderr
, " handle=%04x", req
->handle
);
4011 static void dump_query_symlink_request( const struct query_symlink_request
*req
)
4013 fprintf( stderr
, " handle=%04x", req
->handle
);
4016 static void dump_query_symlink_reply( const struct query_symlink_reply
*req
)
4018 fprintf( stderr
, " total=%u", req
->total
);
4019 dump_varargs_unicode_str( ", target_name=", cur_size
);
4022 static void dump_get_object_info_request( const struct get_object_info_request
*req
)
4024 fprintf( stderr
, " handle=%04x", req
->handle
);
4027 static void dump_get_object_info_reply( const struct get_object_info_reply
*req
)
4029 fprintf( stderr
, " access=%08x", req
->access
);
4030 fprintf( stderr
, ", ref_count=%08x", req
->ref_count
);
4031 fprintf( stderr
, ", handle_count=%08x", req
->handle_count
);
4032 fprintf( stderr
, ", total=%u", req
->total
);
4033 dump_varargs_unicode_str( ", name=", cur_size
);
4036 static void dump_get_object_type_request( const struct get_object_type_request
*req
)
4038 fprintf( stderr
, " handle=%04x", req
->handle
);
4041 static void dump_get_object_type_reply( const struct get_object_type_reply
*req
)
4043 fprintf( stderr
, " total=%u", req
->total
);
4044 dump_varargs_unicode_str( ", type=", cur_size
);
4047 static void dump_get_token_impersonation_level_request( const struct get_token_impersonation_level_request
*req
)
4049 fprintf( stderr
, " handle=%04x", req
->handle
);
4052 static void dump_get_token_impersonation_level_reply( const struct get_token_impersonation_level_reply
*req
)
4054 fprintf( stderr
, " impersonation_level=%d", req
->impersonation_level
);
4057 static void dump_allocate_locally_unique_id_request( const struct allocate_locally_unique_id_request
*req
)
4061 static void dump_allocate_locally_unique_id_reply( const struct allocate_locally_unique_id_reply
*req
)
4063 dump_luid( " luid=", &req
->luid
);
4066 static void dump_create_device_manager_request( const struct create_device_manager_request
*req
)
4068 fprintf( stderr
, " access=%08x", req
->access
);
4069 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
4072 static void dump_create_device_manager_reply( const struct create_device_manager_reply
*req
)
4074 fprintf( stderr
, " handle=%04x", req
->handle
);
4077 static void dump_create_device_request( const struct create_device_request
*req
)
4079 fprintf( stderr
, " rootdir=%04x", req
->rootdir
);
4080 dump_uint64( ", user_ptr=", &req
->user_ptr
);
4081 fprintf( stderr
, ", manager=%04x", req
->manager
);
4082 dump_varargs_unicode_str( ", name=", cur_size
);
4085 static void dump_delete_device_request( const struct delete_device_request
*req
)
4087 fprintf( stderr
, " manager=%04x", req
->manager
);
4088 dump_uint64( ", device=", &req
->device
);
4091 static void dump_get_next_device_request_request( const struct get_next_device_request_request
*req
)
4093 fprintf( stderr
, " manager=%04x", req
->manager
);
4094 fprintf( stderr
, ", prev=%04x", req
->prev
);
4095 fprintf( stderr
, ", status=%08x", req
->status
);
4096 dump_uint64( ", user_ptr=", &req
->user_ptr
);
4099 static void dump_get_next_device_request_reply( const struct get_next_device_request_reply
*req
)
4101 dump_irp_params( " params=", &req
->params
);
4102 fprintf( stderr
, ", next=%04x", req
->next
);
4103 fprintf( stderr
, ", client_tid=%04x", req
->client_tid
);
4104 dump_uint64( ", client_thread=", &req
->client_thread
);
4105 fprintf( stderr
, ", in_size=%u", req
->in_size
);
4106 dump_varargs_bytes( ", next_data=", cur_size
);
4109 static void dump_get_kernel_object_ptr_request( const struct get_kernel_object_ptr_request
*req
)
4111 fprintf( stderr
, " manager=%04x", req
->manager
);
4112 fprintf( stderr
, ", handle=%04x", req
->handle
);
4115 static void dump_get_kernel_object_ptr_reply( const struct get_kernel_object_ptr_reply
*req
)
4117 dump_uint64( " user_ptr=", &req
->user_ptr
);
4120 static void dump_set_kernel_object_ptr_request( const struct set_kernel_object_ptr_request
*req
)
4122 fprintf( stderr
, " manager=%04x", req
->manager
);
4123 fprintf( stderr
, ", handle=%04x", req
->handle
);
4124 dump_uint64( ", user_ptr=", &req
->user_ptr
);
4127 static void dump_grab_kernel_object_request( const struct grab_kernel_object_request
*req
)
4129 fprintf( stderr
, " manager=%04x", req
->manager
);
4130 dump_uint64( ", user_ptr=", &req
->user_ptr
);
4133 static void dump_release_kernel_object_request( const struct release_kernel_object_request
*req
)
4135 fprintf( stderr
, " manager=%04x", req
->manager
);
4136 dump_uint64( ", user_ptr=", &req
->user_ptr
);
4139 static void dump_get_kernel_object_handle_request( const struct get_kernel_object_handle_request
*req
)
4141 fprintf( stderr
, " manager=%04x", req
->manager
);
4142 dump_uint64( ", user_ptr=", &req
->user_ptr
);
4143 fprintf( stderr
, ", access=%08x", req
->access
);
4146 static void dump_get_kernel_object_handle_reply( const struct get_kernel_object_handle_reply
*req
)
4148 fprintf( stderr
, " handle=%04x", req
->handle
);
4151 static void dump_make_process_system_request( const struct make_process_system_request
*req
)
4155 static void dump_make_process_system_reply( const struct make_process_system_reply
*req
)
4157 fprintf( stderr
, " event=%04x", req
->event
);
4160 static void dump_get_token_statistics_request( const struct get_token_statistics_request
*req
)
4162 fprintf( stderr
, " handle=%04x", req
->handle
);
4165 static void dump_get_token_statistics_reply( const struct get_token_statistics_reply
*req
)
4167 dump_luid( " token_id=", &req
->token_id
);
4168 dump_luid( ", modified_id=", &req
->modified_id
);
4169 fprintf( stderr
, ", primary=%d", req
->primary
);
4170 fprintf( stderr
, ", impersonation_level=%d", req
->impersonation_level
);
4171 fprintf( stderr
, ", group_count=%d", req
->group_count
);
4172 fprintf( stderr
, ", privilege_count=%d", req
->privilege_count
);
4175 static void dump_create_completion_request( const struct create_completion_request
*req
)
4177 fprintf( stderr
, " access=%08x", req
->access
);
4178 fprintf( stderr
, ", concurrent=%08x", req
->concurrent
);
4179 dump_varargs_object_attributes( ", objattr=", cur_size
);
4182 static void dump_create_completion_reply( const struct create_completion_reply
*req
)
4184 fprintf( stderr
, " handle=%04x", req
->handle
);
4187 static void dump_open_completion_request( const struct open_completion_request
*req
)
4189 fprintf( stderr
, " access=%08x", req
->access
);
4190 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
4191 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
4192 dump_varargs_unicode_str( ", filename=", cur_size
);
4195 static void dump_open_completion_reply( const struct open_completion_reply
*req
)
4197 fprintf( stderr
, " handle=%04x", req
->handle
);
4200 static void dump_add_completion_request( const struct add_completion_request
*req
)
4202 fprintf( stderr
, " handle=%04x", req
->handle
);
4203 dump_uint64( ", ckey=", &req
->ckey
);
4204 dump_uint64( ", cvalue=", &req
->cvalue
);
4205 dump_uint64( ", information=", &req
->information
);
4206 fprintf( stderr
, ", status=%08x", req
->status
);
4209 static void dump_remove_completion_request( const struct remove_completion_request
*req
)
4211 fprintf( stderr
, " handle=%04x", req
->handle
);
4214 static void dump_remove_completion_reply( const struct remove_completion_reply
*req
)
4216 dump_uint64( " ckey=", &req
->ckey
);
4217 dump_uint64( ", cvalue=", &req
->cvalue
);
4218 dump_uint64( ", information=", &req
->information
);
4219 fprintf( stderr
, ", status=%08x", req
->status
);
4222 static void dump_query_completion_request( const struct query_completion_request
*req
)
4224 fprintf( stderr
, " handle=%04x", req
->handle
);
4227 static void dump_query_completion_reply( const struct query_completion_reply
*req
)
4229 fprintf( stderr
, " depth=%08x", req
->depth
);
4232 static void dump_set_completion_info_request( const struct set_completion_info_request
*req
)
4234 fprintf( stderr
, " handle=%04x", req
->handle
);
4235 dump_uint64( ", ckey=", &req
->ckey
);
4236 fprintf( stderr
, ", chandle=%04x", req
->chandle
);
4239 static void dump_add_fd_completion_request( const struct add_fd_completion_request
*req
)
4241 fprintf( stderr
, " handle=%04x", req
->handle
);
4242 dump_uint64( ", cvalue=", &req
->cvalue
);
4243 dump_uint64( ", information=", &req
->information
);
4244 fprintf( stderr
, ", status=%08x", req
->status
);
4245 fprintf( stderr
, ", async=%d", req
->async
);
4248 static void dump_set_fd_completion_mode_request( const struct set_fd_completion_mode_request
*req
)
4250 fprintf( stderr
, " handle=%04x", req
->handle
);
4251 fprintf( stderr
, ", flags=%08x", req
->flags
);
4254 static void dump_set_fd_disp_info_request( const struct set_fd_disp_info_request
*req
)
4256 fprintf( stderr
, " handle=%04x", req
->handle
);
4257 fprintf( stderr
, ", unlink=%d", req
->unlink
);
4260 static void dump_set_fd_name_info_request( const struct set_fd_name_info_request
*req
)
4262 fprintf( stderr
, " handle=%04x", req
->handle
);
4263 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
4264 fprintf( stderr
, ", link=%d", req
->link
);
4265 fprintf( stderr
, ", replace=%d", req
->replace
);
4266 dump_varargs_string( ", filename=", cur_size
);
4269 static void dump_get_window_layered_info_request( const struct get_window_layered_info_request
*req
)
4271 fprintf( stderr
, " handle=%08x", req
->handle
);
4274 static void dump_get_window_layered_info_reply( const struct get_window_layered_info_reply
*req
)
4276 fprintf( stderr
, " color_key=%08x", req
->color_key
);
4277 fprintf( stderr
, ", alpha=%08x", req
->alpha
);
4278 fprintf( stderr
, ", flags=%08x", req
->flags
);
4281 static void dump_set_window_layered_info_request( const struct set_window_layered_info_request
*req
)
4283 fprintf( stderr
, " handle=%08x", req
->handle
);
4284 fprintf( stderr
, ", color_key=%08x", req
->color_key
);
4285 fprintf( stderr
, ", alpha=%08x", req
->alpha
);
4286 fprintf( stderr
, ", flags=%08x", req
->flags
);
4289 static void dump_alloc_user_handle_request( const struct alloc_user_handle_request
*req
)
4293 static void dump_alloc_user_handle_reply( const struct alloc_user_handle_reply
*req
)
4295 fprintf( stderr
, " handle=%08x", req
->handle
);
4298 static void dump_free_user_handle_request( const struct free_user_handle_request
*req
)
4300 fprintf( stderr
, " handle=%08x", req
->handle
);
4303 static void dump_set_cursor_request( const struct set_cursor_request
*req
)
4305 fprintf( stderr
, " flags=%08x", req
->flags
);
4306 fprintf( stderr
, ", handle=%08x", req
->handle
);
4307 fprintf( stderr
, ", show_count=%d", req
->show_count
);
4308 fprintf( stderr
, ", x=%d", req
->x
);
4309 fprintf( stderr
, ", y=%d", req
->y
);
4310 dump_rectangle( ", clip=", &req
->clip
);
4311 fprintf( stderr
, ", clip_msg=%08x", req
->clip_msg
);
4314 static void dump_set_cursor_reply( const struct set_cursor_reply
*req
)
4316 fprintf( stderr
, " prev_handle=%08x", req
->prev_handle
);
4317 fprintf( stderr
, ", prev_count=%d", req
->prev_count
);
4318 fprintf( stderr
, ", prev_x=%d", req
->prev_x
);
4319 fprintf( stderr
, ", prev_y=%d", req
->prev_y
);
4320 fprintf( stderr
, ", new_x=%d", req
->new_x
);
4321 fprintf( stderr
, ", new_y=%d", req
->new_y
);
4322 dump_rectangle( ", new_clip=", &req
->new_clip
);
4323 fprintf( stderr
, ", last_change=%08x", req
->last_change
);
4326 static void dump_get_rawinput_buffer_request( const struct get_rawinput_buffer_request
*req
)
4328 fprintf( stderr
, " rawinput_size=%u", req
->rawinput_size
);
4329 fprintf( stderr
, ", buffer_size=%u", req
->buffer_size
);
4332 static void dump_get_rawinput_buffer_reply( const struct get_rawinput_buffer_reply
*req
)
4334 fprintf( stderr
, " next_size=%u", req
->next_size
);
4335 fprintf( stderr
, ", count=%08x", req
->count
);
4336 dump_varargs_bytes( ", data=", cur_size
);
4339 static void dump_update_rawinput_devices_request( const struct update_rawinput_devices_request
*req
)
4341 dump_varargs_rawinput_devices( " devices=", cur_size
);
4344 static void dump_get_rawinput_devices_request( const struct get_rawinput_devices_request
*req
)
4348 static void dump_get_rawinput_devices_reply( const struct get_rawinput_devices_reply
*req
)
4350 fprintf( stderr
, " device_count=%08x", req
->device_count
);
4351 dump_varargs_rawinput_devices( ", devices=", cur_size
);
4354 static void dump_create_job_request( const struct create_job_request
*req
)
4356 fprintf( stderr
, " access=%08x", req
->access
);
4357 dump_varargs_object_attributes( ", objattr=", cur_size
);
4360 static void dump_create_job_reply( const struct create_job_reply
*req
)
4362 fprintf( stderr
, " handle=%04x", req
->handle
);
4365 static void dump_open_job_request( const struct open_job_request
*req
)
4367 fprintf( stderr
, " access=%08x", req
->access
);
4368 fprintf( stderr
, ", attributes=%08x", req
->attributes
);
4369 fprintf( stderr
, ", rootdir=%04x", req
->rootdir
);
4370 dump_varargs_unicode_str( ", name=", cur_size
);
4373 static void dump_open_job_reply( const struct open_job_reply
*req
)
4375 fprintf( stderr
, " handle=%04x", req
->handle
);
4378 static void dump_assign_job_request( const struct assign_job_request
*req
)
4380 fprintf( stderr
, " job=%04x", req
->job
);
4381 fprintf( stderr
, ", process=%04x", req
->process
);
4384 static void dump_process_in_job_request( const struct process_in_job_request
*req
)
4386 fprintf( stderr
, " job=%04x", req
->job
);
4387 fprintf( stderr
, ", process=%04x", req
->process
);
4390 static void dump_set_job_limits_request( const struct set_job_limits_request
*req
)
4392 fprintf( stderr
, " handle=%04x", req
->handle
);
4393 fprintf( stderr
, ", limit_flags=%08x", req
->limit_flags
);
4396 static void dump_set_job_completion_port_request( const struct set_job_completion_port_request
*req
)
4398 fprintf( stderr
, " job=%04x", req
->job
);
4399 fprintf( stderr
, ", port=%04x", req
->port
);
4400 dump_uint64( ", key=", &req
->key
);
4403 static void dump_get_job_info_request( const struct get_job_info_request
*req
)
4405 fprintf( stderr
, " handle=%04x", req
->handle
);
4408 static void dump_get_job_info_reply( const struct get_job_info_reply
*req
)
4410 fprintf( stderr
, " total_processes=%d", req
->total_processes
);
4411 fprintf( stderr
, ", active_processes=%d", req
->active_processes
);
4414 static void dump_terminate_job_request( const struct terminate_job_request
*req
)
4416 fprintf( stderr
, " handle=%04x", req
->handle
);
4417 fprintf( stderr
, ", status=%d", req
->status
);
4420 static void dump_suspend_process_request( const struct suspend_process_request
*req
)
4422 fprintf( stderr
, " handle=%04x", req
->handle
);
4425 static void dump_resume_process_request( const struct resume_process_request
*req
)
4427 fprintf( stderr
, " handle=%04x", req
->handle
);
4430 static const dump_func req_dumpers
[REQ_NB_REQUESTS
] = {
4431 (dump_func
)dump_new_process_request
,
4432 (dump_func
)dump_exec_process_request
,
4433 (dump_func
)dump_get_new_process_info_request
,
4434 (dump_func
)dump_new_thread_request
,
4435 (dump_func
)dump_get_startup_info_request
,
4436 (dump_func
)dump_init_process_done_request
,
4437 (dump_func
)dump_init_thread_request
,
4438 (dump_func
)dump_terminate_process_request
,
4439 (dump_func
)dump_terminate_thread_request
,
4440 (dump_func
)dump_get_process_info_request
,
4441 (dump_func
)dump_get_process_vm_counters_request
,
4442 (dump_func
)dump_set_process_info_request
,
4443 (dump_func
)dump_get_thread_info_request
,
4444 (dump_func
)dump_get_thread_times_request
,
4445 (dump_func
)dump_set_thread_info_request
,
4446 (dump_func
)dump_get_dll_info_request
,
4447 (dump_func
)dump_suspend_thread_request
,
4448 (dump_func
)dump_resume_thread_request
,
4449 (dump_func
)dump_load_dll_request
,
4450 (dump_func
)dump_unload_dll_request
,
4451 (dump_func
)dump_queue_apc_request
,
4452 (dump_func
)dump_get_apc_result_request
,
4453 (dump_func
)dump_close_handle_request
,
4454 (dump_func
)dump_set_handle_info_request
,
4455 (dump_func
)dump_dup_handle_request
,
4456 (dump_func
)dump_make_temporary_request
,
4457 (dump_func
)dump_open_process_request
,
4458 (dump_func
)dump_open_thread_request
,
4459 (dump_func
)dump_select_request
,
4460 (dump_func
)dump_create_event_request
,
4461 (dump_func
)dump_event_op_request
,
4462 (dump_func
)dump_query_event_request
,
4463 (dump_func
)dump_open_event_request
,
4464 (dump_func
)dump_create_keyed_event_request
,
4465 (dump_func
)dump_open_keyed_event_request
,
4466 (dump_func
)dump_create_mutex_request
,
4467 (dump_func
)dump_release_mutex_request
,
4468 (dump_func
)dump_open_mutex_request
,
4469 (dump_func
)dump_query_mutex_request
,
4470 (dump_func
)dump_create_semaphore_request
,
4471 (dump_func
)dump_release_semaphore_request
,
4472 (dump_func
)dump_query_semaphore_request
,
4473 (dump_func
)dump_open_semaphore_request
,
4474 (dump_func
)dump_create_file_request
,
4475 (dump_func
)dump_open_file_object_request
,
4476 (dump_func
)dump_alloc_file_handle_request
,
4477 (dump_func
)dump_get_handle_unix_name_request
,
4478 (dump_func
)dump_get_handle_fd_request
,
4479 (dump_func
)dump_get_directory_cache_entry_request
,
4480 (dump_func
)dump_flush_request
,
4481 (dump_func
)dump_get_file_info_request
,
4482 (dump_func
)dump_get_volume_info_request
,
4483 (dump_func
)dump_lock_file_request
,
4484 (dump_func
)dump_unlock_file_request
,
4485 (dump_func
)dump_create_socket_request
,
4486 (dump_func
)dump_accept_socket_request
,
4487 (dump_func
)dump_accept_into_socket_request
,
4488 (dump_func
)dump_set_socket_event_request
,
4489 (dump_func
)dump_get_socket_event_request
,
4490 (dump_func
)dump_get_socket_info_request
,
4491 (dump_func
)dump_enable_socket_event_request
,
4492 (dump_func
)dump_set_socket_deferred_request
,
4493 (dump_func
)dump_alloc_console_request
,
4494 (dump_func
)dump_free_console_request
,
4495 (dump_func
)dump_attach_console_request
,
4496 (dump_func
)dump_get_console_wait_event_request
,
4497 (dump_func
)dump_append_console_input_history_request
,
4498 (dump_func
)dump_get_console_input_history_request
,
4499 (dump_func
)dump_create_console_output_request
,
4500 (dump_func
)dump_get_next_console_request_request
,
4501 (dump_func
)dump_read_directory_changes_request
,
4502 (dump_func
)dump_read_change_request
,
4503 (dump_func
)dump_create_mapping_request
,
4504 (dump_func
)dump_open_mapping_request
,
4505 (dump_func
)dump_get_mapping_info_request
,
4506 (dump_func
)dump_map_view_request
,
4507 (dump_func
)dump_unmap_view_request
,
4508 (dump_func
)dump_get_mapping_committed_range_request
,
4509 (dump_func
)dump_add_mapping_committed_range_request
,
4510 (dump_func
)dump_is_same_mapping_request
,
4511 (dump_func
)dump_list_processes_request
,
4512 (dump_func
)dump_wait_debug_event_request
,
4513 (dump_func
)dump_queue_exception_event_request
,
4514 (dump_func
)dump_get_exception_status_request
,
4515 (dump_func
)dump_continue_debug_event_request
,
4516 (dump_func
)dump_debug_process_request
,
4517 (dump_func
)dump_set_debugger_kill_on_exit_request
,
4518 (dump_func
)dump_read_process_memory_request
,
4519 (dump_func
)dump_write_process_memory_request
,
4520 (dump_func
)dump_create_key_request
,
4521 (dump_func
)dump_open_key_request
,
4522 (dump_func
)dump_delete_key_request
,
4523 (dump_func
)dump_flush_key_request
,
4524 (dump_func
)dump_enum_key_request
,
4525 (dump_func
)dump_set_key_value_request
,
4526 (dump_func
)dump_get_key_value_request
,
4527 (dump_func
)dump_enum_key_value_request
,
4528 (dump_func
)dump_delete_key_value_request
,
4529 (dump_func
)dump_load_registry_request
,
4530 (dump_func
)dump_unload_registry_request
,
4531 (dump_func
)dump_save_registry_request
,
4532 (dump_func
)dump_set_registry_notification_request
,
4533 (dump_func
)dump_create_timer_request
,
4534 (dump_func
)dump_open_timer_request
,
4535 (dump_func
)dump_set_timer_request
,
4536 (dump_func
)dump_cancel_timer_request
,
4537 (dump_func
)dump_get_timer_info_request
,
4538 (dump_func
)dump_get_thread_context_request
,
4539 (dump_func
)dump_set_thread_context_request
,
4540 (dump_func
)dump_get_selector_entry_request
,
4541 (dump_func
)dump_add_atom_request
,
4542 (dump_func
)dump_delete_atom_request
,
4543 (dump_func
)dump_find_atom_request
,
4544 (dump_func
)dump_get_atom_information_request
,
4545 (dump_func
)dump_set_atom_information_request
,
4546 (dump_func
)dump_empty_atom_table_request
,
4547 (dump_func
)dump_init_atom_table_request
,
4548 (dump_func
)dump_get_msg_queue_request
,
4549 (dump_func
)dump_set_queue_fd_request
,
4550 (dump_func
)dump_set_queue_mask_request
,
4551 (dump_func
)dump_get_queue_status_request
,
4552 (dump_func
)dump_get_process_idle_event_request
,
4553 (dump_func
)dump_send_message_request
,
4554 (dump_func
)dump_post_quit_message_request
,
4555 (dump_func
)dump_send_hardware_message_request
,
4556 (dump_func
)dump_get_message_request
,
4557 (dump_func
)dump_reply_message_request
,
4558 (dump_func
)dump_accept_hardware_message_request
,
4559 (dump_func
)dump_get_message_reply_request
,
4560 (dump_func
)dump_set_win_timer_request
,
4561 (dump_func
)dump_kill_win_timer_request
,
4562 (dump_func
)dump_is_window_hung_request
,
4563 (dump_func
)dump_get_serial_info_request
,
4564 (dump_func
)dump_set_serial_info_request
,
4565 (dump_func
)dump_register_async_request
,
4566 (dump_func
)dump_cancel_async_request
,
4567 (dump_func
)dump_get_async_result_request
,
4568 (dump_func
)dump_read_request
,
4569 (dump_func
)dump_write_request
,
4570 (dump_func
)dump_ioctl_request
,
4571 (dump_func
)dump_set_irp_result_request
,
4572 (dump_func
)dump_create_named_pipe_request
,
4573 (dump_func
)dump_set_named_pipe_info_request
,
4574 (dump_func
)dump_create_window_request
,
4575 (dump_func
)dump_destroy_window_request
,
4576 (dump_func
)dump_get_desktop_window_request
,
4577 (dump_func
)dump_set_window_owner_request
,
4578 (dump_func
)dump_get_window_info_request
,
4579 (dump_func
)dump_set_window_info_request
,
4580 (dump_func
)dump_set_parent_request
,
4581 (dump_func
)dump_get_window_parents_request
,
4582 (dump_func
)dump_get_window_children_request
,
4583 (dump_func
)dump_get_window_children_from_point_request
,
4584 (dump_func
)dump_get_window_tree_request
,
4585 (dump_func
)dump_set_window_pos_request
,
4586 (dump_func
)dump_get_window_rectangles_request
,
4587 (dump_func
)dump_get_window_text_request
,
4588 (dump_func
)dump_set_window_text_request
,
4589 (dump_func
)dump_get_windows_offset_request
,
4590 (dump_func
)dump_get_visible_region_request
,
4591 (dump_func
)dump_get_surface_region_request
,
4592 (dump_func
)dump_get_window_region_request
,
4593 (dump_func
)dump_set_window_region_request
,
4594 (dump_func
)dump_get_update_region_request
,
4595 (dump_func
)dump_update_window_zorder_request
,
4596 (dump_func
)dump_redraw_window_request
,
4597 (dump_func
)dump_set_window_property_request
,
4598 (dump_func
)dump_remove_window_property_request
,
4599 (dump_func
)dump_get_window_property_request
,
4600 (dump_func
)dump_get_window_properties_request
,
4601 (dump_func
)dump_create_winstation_request
,
4602 (dump_func
)dump_open_winstation_request
,
4603 (dump_func
)dump_close_winstation_request
,
4604 (dump_func
)dump_get_process_winstation_request
,
4605 (dump_func
)dump_set_process_winstation_request
,
4606 (dump_func
)dump_enum_winstation_request
,
4607 (dump_func
)dump_create_desktop_request
,
4608 (dump_func
)dump_open_desktop_request
,
4609 (dump_func
)dump_open_input_desktop_request
,
4610 (dump_func
)dump_close_desktop_request
,
4611 (dump_func
)dump_get_thread_desktop_request
,
4612 (dump_func
)dump_set_thread_desktop_request
,
4613 (dump_func
)dump_enum_desktop_request
,
4614 (dump_func
)dump_set_user_object_info_request
,
4615 (dump_func
)dump_register_hotkey_request
,
4616 (dump_func
)dump_unregister_hotkey_request
,
4617 (dump_func
)dump_attach_thread_input_request
,
4618 (dump_func
)dump_get_thread_input_request
,
4619 (dump_func
)dump_get_last_input_time_request
,
4620 (dump_func
)dump_get_key_state_request
,
4621 (dump_func
)dump_set_key_state_request
,
4622 (dump_func
)dump_set_foreground_window_request
,
4623 (dump_func
)dump_set_focus_window_request
,
4624 (dump_func
)dump_set_active_window_request
,
4625 (dump_func
)dump_set_capture_window_request
,
4626 (dump_func
)dump_set_caret_window_request
,
4627 (dump_func
)dump_set_caret_info_request
,
4628 (dump_func
)dump_set_hook_request
,
4629 (dump_func
)dump_remove_hook_request
,
4630 (dump_func
)dump_start_hook_chain_request
,
4631 (dump_func
)dump_finish_hook_chain_request
,
4632 (dump_func
)dump_get_hook_info_request
,
4633 (dump_func
)dump_create_class_request
,
4634 (dump_func
)dump_destroy_class_request
,
4635 (dump_func
)dump_set_class_info_request
,
4636 (dump_func
)dump_open_clipboard_request
,
4637 (dump_func
)dump_close_clipboard_request
,
4638 (dump_func
)dump_empty_clipboard_request
,
4639 (dump_func
)dump_set_clipboard_data_request
,
4640 (dump_func
)dump_get_clipboard_data_request
,
4641 (dump_func
)dump_get_clipboard_formats_request
,
4642 (dump_func
)dump_enum_clipboard_formats_request
,
4643 (dump_func
)dump_release_clipboard_request
,
4644 (dump_func
)dump_get_clipboard_info_request
,
4645 (dump_func
)dump_set_clipboard_viewer_request
,
4646 (dump_func
)dump_add_clipboard_listener_request
,
4647 (dump_func
)dump_remove_clipboard_listener_request
,
4648 (dump_func
)dump_open_token_request
,
4649 (dump_func
)dump_set_global_windows_request
,
4650 (dump_func
)dump_adjust_token_privileges_request
,
4651 (dump_func
)dump_get_token_privileges_request
,
4652 (dump_func
)dump_check_token_privileges_request
,
4653 (dump_func
)dump_duplicate_token_request
,
4654 (dump_func
)dump_access_check_request
,
4655 (dump_func
)dump_get_token_sid_request
,
4656 (dump_func
)dump_get_token_groups_request
,
4657 (dump_func
)dump_get_token_default_dacl_request
,
4658 (dump_func
)dump_set_token_default_dacl_request
,
4659 (dump_func
)dump_set_security_object_request
,
4660 (dump_func
)dump_get_security_object_request
,
4661 (dump_func
)dump_get_system_handles_request
,
4662 (dump_func
)dump_create_mailslot_request
,
4663 (dump_func
)dump_set_mailslot_info_request
,
4664 (dump_func
)dump_create_directory_request
,
4665 (dump_func
)dump_open_directory_request
,
4666 (dump_func
)dump_get_directory_entry_request
,
4667 (dump_func
)dump_create_symlink_request
,
4668 (dump_func
)dump_open_symlink_request
,
4669 (dump_func
)dump_query_symlink_request
,
4670 (dump_func
)dump_get_object_info_request
,
4671 (dump_func
)dump_get_object_type_request
,
4672 (dump_func
)dump_get_token_impersonation_level_request
,
4673 (dump_func
)dump_allocate_locally_unique_id_request
,
4674 (dump_func
)dump_create_device_manager_request
,
4675 (dump_func
)dump_create_device_request
,
4676 (dump_func
)dump_delete_device_request
,
4677 (dump_func
)dump_get_next_device_request_request
,
4678 (dump_func
)dump_get_kernel_object_ptr_request
,
4679 (dump_func
)dump_set_kernel_object_ptr_request
,
4680 (dump_func
)dump_grab_kernel_object_request
,
4681 (dump_func
)dump_release_kernel_object_request
,
4682 (dump_func
)dump_get_kernel_object_handle_request
,
4683 (dump_func
)dump_make_process_system_request
,
4684 (dump_func
)dump_get_token_statistics_request
,
4685 (dump_func
)dump_create_completion_request
,
4686 (dump_func
)dump_open_completion_request
,
4687 (dump_func
)dump_add_completion_request
,
4688 (dump_func
)dump_remove_completion_request
,
4689 (dump_func
)dump_query_completion_request
,
4690 (dump_func
)dump_set_completion_info_request
,
4691 (dump_func
)dump_add_fd_completion_request
,
4692 (dump_func
)dump_set_fd_completion_mode_request
,
4693 (dump_func
)dump_set_fd_disp_info_request
,
4694 (dump_func
)dump_set_fd_name_info_request
,
4695 (dump_func
)dump_get_window_layered_info_request
,
4696 (dump_func
)dump_set_window_layered_info_request
,
4697 (dump_func
)dump_alloc_user_handle_request
,
4698 (dump_func
)dump_free_user_handle_request
,
4699 (dump_func
)dump_set_cursor_request
,
4700 (dump_func
)dump_get_rawinput_buffer_request
,
4701 (dump_func
)dump_update_rawinput_devices_request
,
4702 (dump_func
)dump_get_rawinput_devices_request
,
4703 (dump_func
)dump_create_job_request
,
4704 (dump_func
)dump_open_job_request
,
4705 (dump_func
)dump_assign_job_request
,
4706 (dump_func
)dump_process_in_job_request
,
4707 (dump_func
)dump_set_job_limits_request
,
4708 (dump_func
)dump_set_job_completion_port_request
,
4709 (dump_func
)dump_get_job_info_request
,
4710 (dump_func
)dump_terminate_job_request
,
4711 (dump_func
)dump_suspend_process_request
,
4712 (dump_func
)dump_resume_process_request
,
4715 static const dump_func reply_dumpers
[REQ_NB_REQUESTS
] = {
4716 (dump_func
)dump_new_process_reply
,
4718 (dump_func
)dump_get_new_process_info_reply
,
4719 (dump_func
)dump_new_thread_reply
,
4720 (dump_func
)dump_get_startup_info_reply
,
4721 (dump_func
)dump_init_process_done_reply
,
4722 (dump_func
)dump_init_thread_reply
,
4723 (dump_func
)dump_terminate_process_reply
,
4724 (dump_func
)dump_terminate_thread_reply
,
4725 (dump_func
)dump_get_process_info_reply
,
4726 (dump_func
)dump_get_process_vm_counters_reply
,
4728 (dump_func
)dump_get_thread_info_reply
,
4729 (dump_func
)dump_get_thread_times_reply
,
4731 (dump_func
)dump_get_dll_info_reply
,
4732 (dump_func
)dump_suspend_thread_reply
,
4733 (dump_func
)dump_resume_thread_reply
,
4736 (dump_func
)dump_queue_apc_reply
,
4737 (dump_func
)dump_get_apc_result_reply
,
4739 (dump_func
)dump_set_handle_info_reply
,
4740 (dump_func
)dump_dup_handle_reply
,
4742 (dump_func
)dump_open_process_reply
,
4743 (dump_func
)dump_open_thread_reply
,
4744 (dump_func
)dump_select_reply
,
4745 (dump_func
)dump_create_event_reply
,
4746 (dump_func
)dump_event_op_reply
,
4747 (dump_func
)dump_query_event_reply
,
4748 (dump_func
)dump_open_event_reply
,
4749 (dump_func
)dump_create_keyed_event_reply
,
4750 (dump_func
)dump_open_keyed_event_reply
,
4751 (dump_func
)dump_create_mutex_reply
,
4752 (dump_func
)dump_release_mutex_reply
,
4753 (dump_func
)dump_open_mutex_reply
,
4754 (dump_func
)dump_query_mutex_reply
,
4755 (dump_func
)dump_create_semaphore_reply
,
4756 (dump_func
)dump_release_semaphore_reply
,
4757 (dump_func
)dump_query_semaphore_reply
,
4758 (dump_func
)dump_open_semaphore_reply
,
4759 (dump_func
)dump_create_file_reply
,
4760 (dump_func
)dump_open_file_object_reply
,
4761 (dump_func
)dump_alloc_file_handle_reply
,
4762 (dump_func
)dump_get_handle_unix_name_reply
,
4763 (dump_func
)dump_get_handle_fd_reply
,
4764 (dump_func
)dump_get_directory_cache_entry_reply
,
4765 (dump_func
)dump_flush_reply
,
4766 (dump_func
)dump_get_file_info_reply
,
4767 (dump_func
)dump_get_volume_info_reply
,
4768 (dump_func
)dump_lock_file_reply
,
4770 (dump_func
)dump_create_socket_reply
,
4771 (dump_func
)dump_accept_socket_reply
,
4774 (dump_func
)dump_get_socket_event_reply
,
4775 (dump_func
)dump_get_socket_info_reply
,
4778 (dump_func
)dump_alloc_console_reply
,
4781 (dump_func
)dump_get_console_wait_event_reply
,
4783 (dump_func
)dump_get_console_input_history_reply
,
4784 (dump_func
)dump_create_console_output_reply
,
4785 (dump_func
)dump_get_next_console_request_reply
,
4787 (dump_func
)dump_read_change_reply
,
4788 (dump_func
)dump_create_mapping_reply
,
4789 (dump_func
)dump_open_mapping_reply
,
4790 (dump_func
)dump_get_mapping_info_reply
,
4793 (dump_func
)dump_get_mapping_committed_range_reply
,
4796 (dump_func
)dump_list_processes_reply
,
4797 (dump_func
)dump_wait_debug_event_reply
,
4798 (dump_func
)dump_queue_exception_event_reply
,
4803 (dump_func
)dump_read_process_memory_reply
,
4805 (dump_func
)dump_create_key_reply
,
4806 (dump_func
)dump_open_key_reply
,
4809 (dump_func
)dump_enum_key_reply
,
4811 (dump_func
)dump_get_key_value_reply
,
4812 (dump_func
)dump_enum_key_value_reply
,
4818 (dump_func
)dump_create_timer_reply
,
4819 (dump_func
)dump_open_timer_reply
,
4820 (dump_func
)dump_set_timer_reply
,
4821 (dump_func
)dump_cancel_timer_reply
,
4822 (dump_func
)dump_get_timer_info_reply
,
4823 (dump_func
)dump_get_thread_context_reply
,
4824 (dump_func
)dump_set_thread_context_reply
,
4825 (dump_func
)dump_get_selector_entry_reply
,
4826 (dump_func
)dump_add_atom_reply
,
4828 (dump_func
)dump_find_atom_reply
,
4829 (dump_func
)dump_get_atom_information_reply
,
4832 (dump_func
)dump_init_atom_table_reply
,
4833 (dump_func
)dump_get_msg_queue_reply
,
4835 (dump_func
)dump_set_queue_mask_reply
,
4836 (dump_func
)dump_get_queue_status_reply
,
4837 (dump_func
)dump_get_process_idle_event_reply
,
4840 (dump_func
)dump_send_hardware_message_reply
,
4841 (dump_func
)dump_get_message_reply
,
4844 (dump_func
)dump_get_message_reply_reply
,
4845 (dump_func
)dump_set_win_timer_reply
,
4847 (dump_func
)dump_is_window_hung_reply
,
4848 (dump_func
)dump_get_serial_info_reply
,
4852 (dump_func
)dump_get_async_result_reply
,
4853 (dump_func
)dump_read_reply
,
4854 (dump_func
)dump_write_reply
,
4855 (dump_func
)dump_ioctl_reply
,
4857 (dump_func
)dump_create_named_pipe_reply
,
4859 (dump_func
)dump_create_window_reply
,
4861 (dump_func
)dump_get_desktop_window_reply
,
4862 (dump_func
)dump_set_window_owner_reply
,
4863 (dump_func
)dump_get_window_info_reply
,
4864 (dump_func
)dump_set_window_info_reply
,
4865 (dump_func
)dump_set_parent_reply
,
4866 (dump_func
)dump_get_window_parents_reply
,
4867 (dump_func
)dump_get_window_children_reply
,
4868 (dump_func
)dump_get_window_children_from_point_reply
,
4869 (dump_func
)dump_get_window_tree_reply
,
4870 (dump_func
)dump_set_window_pos_reply
,
4871 (dump_func
)dump_get_window_rectangles_reply
,
4872 (dump_func
)dump_get_window_text_reply
,
4874 (dump_func
)dump_get_windows_offset_reply
,
4875 (dump_func
)dump_get_visible_region_reply
,
4876 (dump_func
)dump_get_surface_region_reply
,
4877 (dump_func
)dump_get_window_region_reply
,
4879 (dump_func
)dump_get_update_region_reply
,
4883 (dump_func
)dump_remove_window_property_reply
,
4884 (dump_func
)dump_get_window_property_reply
,
4885 (dump_func
)dump_get_window_properties_reply
,
4886 (dump_func
)dump_create_winstation_reply
,
4887 (dump_func
)dump_open_winstation_reply
,
4889 (dump_func
)dump_get_process_winstation_reply
,
4891 (dump_func
)dump_enum_winstation_reply
,
4892 (dump_func
)dump_create_desktop_reply
,
4893 (dump_func
)dump_open_desktop_reply
,
4894 (dump_func
)dump_open_input_desktop_reply
,
4896 (dump_func
)dump_get_thread_desktop_reply
,
4898 (dump_func
)dump_enum_desktop_reply
,
4899 (dump_func
)dump_set_user_object_info_reply
,
4900 (dump_func
)dump_register_hotkey_reply
,
4901 (dump_func
)dump_unregister_hotkey_reply
,
4903 (dump_func
)dump_get_thread_input_reply
,
4904 (dump_func
)dump_get_last_input_time_reply
,
4905 (dump_func
)dump_get_key_state_reply
,
4907 (dump_func
)dump_set_foreground_window_reply
,
4908 (dump_func
)dump_set_focus_window_reply
,
4909 (dump_func
)dump_set_active_window_reply
,
4910 (dump_func
)dump_set_capture_window_reply
,
4911 (dump_func
)dump_set_caret_window_reply
,
4912 (dump_func
)dump_set_caret_info_reply
,
4913 (dump_func
)dump_set_hook_reply
,
4914 (dump_func
)dump_remove_hook_reply
,
4915 (dump_func
)dump_start_hook_chain_reply
,
4917 (dump_func
)dump_get_hook_info_reply
,
4918 (dump_func
)dump_create_class_reply
,
4919 (dump_func
)dump_destroy_class_reply
,
4920 (dump_func
)dump_set_class_info_reply
,
4921 (dump_func
)dump_open_clipboard_reply
,
4922 (dump_func
)dump_close_clipboard_reply
,
4924 (dump_func
)dump_set_clipboard_data_reply
,
4925 (dump_func
)dump_get_clipboard_data_reply
,
4926 (dump_func
)dump_get_clipboard_formats_reply
,
4927 (dump_func
)dump_enum_clipboard_formats_reply
,
4928 (dump_func
)dump_release_clipboard_reply
,
4929 (dump_func
)dump_get_clipboard_info_reply
,
4930 (dump_func
)dump_set_clipboard_viewer_reply
,
4933 (dump_func
)dump_open_token_reply
,
4934 (dump_func
)dump_set_global_windows_reply
,
4935 (dump_func
)dump_adjust_token_privileges_reply
,
4936 (dump_func
)dump_get_token_privileges_reply
,
4937 (dump_func
)dump_check_token_privileges_reply
,
4938 (dump_func
)dump_duplicate_token_reply
,
4939 (dump_func
)dump_access_check_reply
,
4940 (dump_func
)dump_get_token_sid_reply
,
4941 (dump_func
)dump_get_token_groups_reply
,
4942 (dump_func
)dump_get_token_default_dacl_reply
,
4945 (dump_func
)dump_get_security_object_reply
,
4946 (dump_func
)dump_get_system_handles_reply
,
4947 (dump_func
)dump_create_mailslot_reply
,
4948 (dump_func
)dump_set_mailslot_info_reply
,
4949 (dump_func
)dump_create_directory_reply
,
4950 (dump_func
)dump_open_directory_reply
,
4951 (dump_func
)dump_get_directory_entry_reply
,
4952 (dump_func
)dump_create_symlink_reply
,
4953 (dump_func
)dump_open_symlink_reply
,
4954 (dump_func
)dump_query_symlink_reply
,
4955 (dump_func
)dump_get_object_info_reply
,
4956 (dump_func
)dump_get_object_type_reply
,
4957 (dump_func
)dump_get_token_impersonation_level_reply
,
4958 (dump_func
)dump_allocate_locally_unique_id_reply
,
4959 (dump_func
)dump_create_device_manager_reply
,
4962 (dump_func
)dump_get_next_device_request_reply
,
4963 (dump_func
)dump_get_kernel_object_ptr_reply
,
4967 (dump_func
)dump_get_kernel_object_handle_reply
,
4968 (dump_func
)dump_make_process_system_reply
,
4969 (dump_func
)dump_get_token_statistics_reply
,
4970 (dump_func
)dump_create_completion_reply
,
4971 (dump_func
)dump_open_completion_reply
,
4973 (dump_func
)dump_remove_completion_reply
,
4974 (dump_func
)dump_query_completion_reply
,
4980 (dump_func
)dump_get_window_layered_info_reply
,
4982 (dump_func
)dump_alloc_user_handle_reply
,
4984 (dump_func
)dump_set_cursor_reply
,
4985 (dump_func
)dump_get_rawinput_buffer_reply
,
4987 (dump_func
)dump_get_rawinput_devices_reply
,
4988 (dump_func
)dump_create_job_reply
,
4989 (dump_func
)dump_open_job_reply
,
4994 (dump_func
)dump_get_job_info_reply
,
5000 static const char * const req_names
[REQ_NB_REQUESTS
] = {
5003 "get_new_process_info",
5006 "init_process_done",
5008 "terminate_process",
5011 "get_process_vm_counters",
5034 "create_keyed_event",
5041 "release_semaphore",
5046 "alloc_file_handle",
5047 "get_handle_unix_name",
5049 "get_directory_cache_entry",
5057 "accept_into_socket",
5061 "enable_socket_event",
5062 "set_socket_deferred",
5066 "get_console_wait_event",
5067 "append_console_input_history",
5068 "get_console_input_history",
5069 "create_console_output",
5070 "get_next_console_request",
5071 "read_directory_changes",
5078 "get_mapping_committed_range",
5079 "add_mapping_committed_range",
5083 "queue_exception_event",
5084 "get_exception_status",
5085 "continue_debug_event",
5087 "set_debugger_kill_on_exit",
5088 "read_process_memory",
5089 "write_process_memory",
5102 "set_registry_notification",
5108 "get_thread_context",
5109 "set_thread_context",
5110 "get_selector_entry",
5114 "get_atom_information",
5115 "set_atom_information",
5122 "get_process_idle_event",
5124 "post_quit_message",
5125 "send_hardware_message",
5128 "accept_hardware_message",
5129 "get_message_reply",
5142 "create_named_pipe",
5143 "set_named_pipe_info",
5146 "get_desktop_window",
5151 "get_window_parents",
5152 "get_window_children",
5153 "get_window_children_from_point",
5156 "get_window_rectangles",
5159 "get_windows_offset",
5160 "get_visible_region",
5161 "get_surface_region",
5162 "get_window_region",
5163 "set_window_region",
5164 "get_update_region",
5165 "update_window_zorder",
5167 "set_window_property",
5168 "remove_window_property",
5169 "get_window_property",
5170 "get_window_properties",
5171 "create_winstation",
5174 "get_process_winstation",
5175 "set_process_winstation",
5179 "open_input_desktop",
5181 "get_thread_desktop",
5182 "set_thread_desktop",
5184 "set_user_object_info",
5186 "unregister_hotkey",
5187 "attach_thread_input",
5189 "get_last_input_time",
5192 "set_foreground_window",
5194 "set_active_window",
5195 "set_capture_window",
5201 "finish_hook_chain",
5209 "set_clipboard_data",
5210 "get_clipboard_data",
5211 "get_clipboard_formats",
5212 "enum_clipboard_formats",
5213 "release_clipboard",
5214 "get_clipboard_info",
5215 "set_clipboard_viewer",
5216 "add_clipboard_listener",
5217 "remove_clipboard_listener",
5219 "set_global_windows",
5220 "adjust_token_privileges",
5221 "get_token_privileges",
5222 "check_token_privileges",
5227 "get_token_default_dacl",
5228 "set_token_default_dacl",
5229 "set_security_object",
5230 "get_security_object",
5231 "get_system_handles",
5233 "set_mailslot_info",
5236 "get_directory_entry",
5242 "get_token_impersonation_level",
5243 "allocate_locally_unique_id",
5244 "create_device_manager",
5247 "get_next_device_request",
5248 "get_kernel_object_ptr",
5249 "set_kernel_object_ptr",
5250 "grab_kernel_object",
5251 "release_kernel_object",
5252 "get_kernel_object_handle",
5253 "make_process_system",
5254 "get_token_statistics",
5255 "create_completion",
5258 "remove_completion",
5260 "set_completion_info",
5261 "add_fd_completion",
5262 "set_fd_completion_mode",
5265 "get_window_layered_info",
5266 "set_window_layered_info",
5267 "alloc_user_handle",
5270 "get_rawinput_buffer",
5271 "update_rawinput_devices",
5272 "get_rawinput_devices",
5278 "set_job_completion_port",
5291 { "ABANDONED_WAIT_0", STATUS_ABANDONED_WAIT_0
},
5292 { "ACCESS_DENIED", STATUS_ACCESS_DENIED
},
5293 { "ACCESS_VIOLATION", STATUS_ACCESS_VIOLATION
},
5294 { "ADDRESS_ALREADY_ASSOCIATED", STATUS_ADDRESS_ALREADY_ASSOCIATED
},
5295 { "ALERTED", STATUS_ALERTED
},
5296 { "ALIAS_EXISTS", STATUS_ALIAS_EXISTS
},
5297 { "BAD_DEVICE_TYPE", STATUS_BAD_DEVICE_TYPE
},
5298 { "BAD_IMPERSONATION_LEVEL", STATUS_BAD_IMPERSONATION_LEVEL
},
5299 { "BUFFER_OVERFLOW", STATUS_BUFFER_OVERFLOW
},
5300 { "BUFFER_TOO_SMALL", STATUS_BUFFER_TOO_SMALL
},
5301 { "CANCELLED", STATUS_CANCELLED
},
5302 { "CANNOT_DELETE", STATUS_CANNOT_DELETE
},
5303 { "CANT_OPEN_ANONYMOUS", STATUS_CANT_OPEN_ANONYMOUS
},
5304 { "CANT_WAIT", STATUS_CANT_WAIT
},
5305 { "CHILD_MUST_BE_VOLATILE", STATUS_CHILD_MUST_BE_VOLATILE
},
5306 { "CONNECTION_ABORTED", STATUS_CONNECTION_ABORTED
},
5307 { "CONNECTION_DISCONNECTED", STATUS_CONNECTION_DISCONNECTED
},
5308 { "CONNECTION_REFUSED", STATUS_CONNECTION_REFUSED
},
5309 { "CONNECTION_RESET", STATUS_CONNECTION_RESET
},
5310 { "DEBUGGER_INACTIVE", STATUS_DEBUGGER_INACTIVE
},
5311 { "DEVICE_BUSY", STATUS_DEVICE_BUSY
},
5312 { "DIRECTORY_NOT_EMPTY", STATUS_DIRECTORY_NOT_EMPTY
},
5313 { "DISK_FULL", STATUS_DISK_FULL
},
5314 { "DLL_NOT_FOUND", STATUS_DLL_NOT_FOUND
},
5315 { "ERROR_CLASS_ALREADY_EXISTS", 0xc0010000 | ERROR_CLASS_ALREADY_EXISTS
},
5316 { "ERROR_CLASS_DOES_NOT_EXIST", 0xc0010000 | ERROR_CLASS_DOES_NOT_EXIST
},
5317 { "ERROR_CLASS_HAS_WINDOWS", 0xc0010000 | ERROR_CLASS_HAS_WINDOWS
},
5318 { "ERROR_CLIPBOARD_NOT_OPEN", 0xc0010000 | ERROR_CLIPBOARD_NOT_OPEN
},
5319 { "ERROR_HOTKEY_ALREADY_REGISTERED", 0xc0010000 | ERROR_HOTKEY_ALREADY_REGISTERED
},
5320 { "ERROR_HOTKEY_NOT_REGISTERED", 0xc0010000 | ERROR_HOTKEY_NOT_REGISTERED
},
5321 { "ERROR_INVALID_CURSOR_HANDLE", 0xc0010000 | ERROR_INVALID_CURSOR_HANDLE
},
5322 { "ERROR_INVALID_INDEX", 0xc0010000 | ERROR_INVALID_INDEX
},
5323 { "ERROR_INVALID_WINDOW_HANDLE", 0xc0010000 | ERROR_INVALID_WINDOW_HANDLE
},
5324 { "ERROR_NO_MORE_USER_HANDLES", 0xc0010000 | ERROR_NO_MORE_USER_HANDLES
},
5325 { "ERROR_WINDOW_OF_OTHER_THREAD", 0xc0010000 | ERROR_WINDOW_OF_OTHER_THREAD
},
5326 { "FILE_DELETED", STATUS_FILE_DELETED
},
5327 { "FILE_IS_A_DIRECTORY", STATUS_FILE_IS_A_DIRECTORY
},
5328 { "FILE_LOCK_CONFLICT", STATUS_FILE_LOCK_CONFLICT
},
5329 { "GENERIC_NOT_MAPPED", STATUS_GENERIC_NOT_MAPPED
},
5330 { "HANDLES_CLOSED", STATUS_HANDLES_CLOSED
},
5331 { "HANDLE_NOT_CLOSABLE", STATUS_HANDLE_NOT_CLOSABLE
},
5332 { "HOST_UNREACHABLE", STATUS_HOST_UNREACHABLE
},
5333 { "ILLEGAL_FUNCTION", STATUS_ILLEGAL_FUNCTION
},
5334 { "IMAGE_NOT_AT_BASE", STATUS_IMAGE_NOT_AT_BASE
},
5335 { "INFO_LENGTH_MISMATCH", STATUS_INFO_LENGTH_MISMATCH
},
5336 { "INSTANCE_NOT_AVAILABLE", STATUS_INSTANCE_NOT_AVAILABLE
},
5337 { "INSUFFICIENT_RESOURCES", STATUS_INSUFFICIENT_RESOURCES
},
5338 { "INVALID_CID", STATUS_INVALID_CID
},
5339 { "INVALID_DEVICE_REQUEST", STATUS_INVALID_DEVICE_REQUEST
},
5340 { "INVALID_FILE_FOR_SECTION", STATUS_INVALID_FILE_FOR_SECTION
},
5341 { "INVALID_HANDLE", STATUS_INVALID_HANDLE
},
5342 { "INVALID_IMAGE_FORMAT", STATUS_INVALID_IMAGE_FORMAT
},
5343 { "INVALID_IMAGE_NE_FORMAT", STATUS_INVALID_IMAGE_NE_FORMAT
},
5344 { "INVALID_IMAGE_NOT_MZ", STATUS_INVALID_IMAGE_NOT_MZ
},
5345 { "INVALID_IMAGE_PROTECT", STATUS_INVALID_IMAGE_PROTECT
},
5346 { "INVALID_IMAGE_WIN_16", STATUS_INVALID_IMAGE_WIN_16
},
5347 { "INVALID_IMAGE_WIN_64", STATUS_INVALID_IMAGE_WIN_64
},
5348 { "INVALID_LOCK_SEQUENCE", STATUS_INVALID_LOCK_SEQUENCE
},
5349 { "INVALID_OWNER", STATUS_INVALID_OWNER
},
5350 { "INVALID_PARAMETER", STATUS_INVALID_PARAMETER
},
5351 { "INVALID_PIPE_STATE", STATUS_INVALID_PIPE_STATE
},
5352 { "INVALID_READ_MODE", STATUS_INVALID_READ_MODE
},
5353 { "INVALID_SECURITY_DESCR", STATUS_INVALID_SECURITY_DESCR
},
5354 { "IO_TIMEOUT", STATUS_IO_TIMEOUT
},
5355 { "KERNEL_APC", STATUS_KERNEL_APC
},
5356 { "KEY_DELETED", STATUS_KEY_DELETED
},
5357 { "MAPPED_FILE_SIZE_ZERO", STATUS_MAPPED_FILE_SIZE_ZERO
},
5358 { "MORE_PROCESSING_REQUIRED", STATUS_MORE_PROCESSING_REQUIRED
},
5359 { "MUTANT_NOT_OWNED", STATUS_MUTANT_NOT_OWNED
},
5360 { "NAME_TOO_LONG", STATUS_NAME_TOO_LONG
},
5361 { "NETWORK_BUSY", STATUS_NETWORK_BUSY
},
5362 { "NETWORK_UNREACHABLE", STATUS_NETWORK_UNREACHABLE
},
5363 { "NOT_ALL_ASSIGNED", STATUS_NOT_ALL_ASSIGNED
},
5364 { "NOT_A_DIRECTORY", STATUS_NOT_A_DIRECTORY
},
5365 { "NOT_FOUND", STATUS_NOT_FOUND
},
5366 { "NOT_IMPLEMENTED", STATUS_NOT_IMPLEMENTED
},
5367 { "NOT_MAPPED_VIEW", STATUS_NOT_MAPPED_VIEW
},
5368 { "NOT_REGISTRY_FILE", STATUS_NOT_REGISTRY_FILE
},
5369 { "NOT_SAME_DEVICE", STATUS_NOT_SAME_DEVICE
},
5370 { "NOT_SUPPORTED", STATUS_NOT_SUPPORTED
},
5371 { "NO_DATA_DETECTED", STATUS_NO_DATA_DETECTED
},
5372 { "NO_IMPERSONATION_TOKEN", STATUS_NO_IMPERSONATION_TOKEN
},
5373 { "NO_MEMORY", STATUS_NO_MEMORY
},
5374 { "NO_MORE_ENTRIES", STATUS_NO_MORE_ENTRIES
},
5375 { "NO_SUCH_DEVICE", STATUS_NO_SUCH_DEVICE
},
5376 { "NO_SUCH_FILE", STATUS_NO_SUCH_FILE
},
5377 { "NO_TOKEN", STATUS_NO_TOKEN
},
5378 { "OBJECT_NAME_COLLISION", STATUS_OBJECT_NAME_COLLISION
},
5379 { "OBJECT_NAME_EXISTS", STATUS_OBJECT_NAME_EXISTS
},
5380 { "OBJECT_NAME_INVALID", STATUS_OBJECT_NAME_INVALID
},
5381 { "OBJECT_NAME_NOT_FOUND", STATUS_OBJECT_NAME_NOT_FOUND
},
5382 { "OBJECT_PATH_INVALID", STATUS_OBJECT_PATH_INVALID
},
5383 { "OBJECT_PATH_NOT_FOUND", STATUS_OBJECT_PATH_NOT_FOUND
},
5384 { "OBJECT_PATH_SYNTAX_BAD", STATUS_OBJECT_PATH_SYNTAX_BAD
},
5385 { "OBJECT_TYPE_MISMATCH", STATUS_OBJECT_TYPE_MISMATCH
},
5386 { "PENDING", STATUS_PENDING
},
5387 { "PIPE_BROKEN", STATUS_PIPE_BROKEN
},
5388 { "PIPE_BUSY", STATUS_PIPE_BUSY
},
5389 { "PIPE_CLOSING", STATUS_PIPE_CLOSING
},
5390 { "PIPE_CONNECTED", STATUS_PIPE_CONNECTED
},
5391 { "PIPE_DISCONNECTED", STATUS_PIPE_DISCONNECTED
},
5392 { "PIPE_EMPTY", STATUS_PIPE_EMPTY
},
5393 { "PIPE_LISTENING", STATUS_PIPE_LISTENING
},
5394 { "PIPE_NOT_AVAILABLE", STATUS_PIPE_NOT_AVAILABLE
},
5395 { "PRIVILEGE_NOT_HELD", STATUS_PRIVILEGE_NOT_HELD
},
5396 { "PROCESS_IN_JOB", STATUS_PROCESS_IN_JOB
},
5397 { "PROCESS_IS_TERMINATING", STATUS_PROCESS_IS_TERMINATING
},
5398 { "PROCESS_NOT_IN_JOB", STATUS_PROCESS_NOT_IN_JOB
},
5399 { "REPARSE_POINT_NOT_RESOLVED", STATUS_REPARSE_POINT_NOT_RESOLVED
},
5400 { "SECTION_TOO_BIG", STATUS_SECTION_TOO_BIG
},
5401 { "SEMAPHORE_LIMIT_EXCEEDED", STATUS_SEMAPHORE_LIMIT_EXCEEDED
},
5402 { "SHARING_VIOLATION", STATUS_SHARING_VIOLATION
},
5403 { "SHUTDOWN_IN_PROGRESS", STATUS_SHUTDOWN_IN_PROGRESS
},
5404 { "SUSPEND_COUNT_EXCEEDED", STATUS_SUSPEND_COUNT_EXCEEDED
},
5405 { "THREAD_IS_TERMINATING", STATUS_THREAD_IS_TERMINATING
},
5406 { "TIMEOUT", STATUS_TIMEOUT
},
5407 { "TOO_MANY_OPENED_FILES", STATUS_TOO_MANY_OPENED_FILES
},
5408 { "UNSUCCESSFUL", STATUS_UNSUCCESSFUL
},
5409 { "USER_APC", STATUS_USER_APC
},
5410 { "USER_MAPPED_FILE", STATUS_USER_MAPPED_FILE
},
5411 { "VOLUME_DISMOUNTED", STATUS_VOLUME_DISMOUNTED
},
5412 { "WAS_LOCKED", STATUS_WAS_LOCKED
},
5413 { "WSAEACCES", 0xc0010000 | WSAEACCES
},
5414 { "WSAEADDRINUSE", 0xc0010000 | WSAEADDRINUSE
},
5415 { "WSAEADDRNOTAVAIL", 0xc0010000 | WSAEADDRNOTAVAIL
},
5416 { "WSAEAFNOSUPPORT", 0xc0010000 | WSAEAFNOSUPPORT
},
5417 { "WSAEALREADY", 0xc0010000 | WSAEALREADY
},
5418 { "WSAEBADF", 0xc0010000 | WSAEBADF
},
5419 { "WSAECONNABORTED", 0xc0010000 | WSAECONNABORTED
},
5420 { "WSAECONNREFUSED", 0xc0010000 | WSAECONNREFUSED
},
5421 { "WSAECONNRESET", 0xc0010000 | WSAECONNRESET
},
5422 { "WSAEDESTADDRREQ", 0xc0010000 | WSAEDESTADDRREQ
},
5423 { "WSAEDQUOT", 0xc0010000 | WSAEDQUOT
},
5424 { "WSAEFAULT", 0xc0010000 | WSAEFAULT
},
5425 { "WSAEHOSTDOWN", 0xc0010000 | WSAEHOSTDOWN
},
5426 { "WSAEHOSTUNREACH", 0xc0010000 | WSAEHOSTUNREACH
},
5427 { "WSAEINPROGRESS", 0xc0010000 | WSAEINPROGRESS
},
5428 { "WSAEINTR", 0xc0010000 | WSAEINTR
},
5429 { "WSAEINVAL", 0xc0010000 | WSAEINVAL
},
5430 { "WSAEISCONN", 0xc0010000 | WSAEISCONN
},
5431 { "WSAELOOP", 0xc0010000 | WSAELOOP
},
5432 { "WSAEMFILE", 0xc0010000 | WSAEMFILE
},
5433 { "WSAEMSGSIZE", 0xc0010000 | WSAEMSGSIZE
},
5434 { "WSAENAMETOOLONG", 0xc0010000 | WSAENAMETOOLONG
},
5435 { "WSAENETDOWN", 0xc0010000 | WSAENETDOWN
},
5436 { "WSAENETRESET", 0xc0010000 | WSAENETRESET
},
5437 { "WSAENETUNREACH", 0xc0010000 | WSAENETUNREACH
},
5438 { "WSAENOBUFS", 0xc0010000 | WSAENOBUFS
},
5439 { "WSAENOPROTOOPT", 0xc0010000 | WSAENOPROTOOPT
},
5440 { "WSAENOTCONN", 0xc0010000 | WSAENOTCONN
},
5441 { "WSAENOTEMPTY", 0xc0010000 | WSAENOTEMPTY
},
5442 { "WSAENOTSOCK", 0xc0010000 | WSAENOTSOCK
},
5443 { "WSAEOPNOTSUPP", 0xc0010000 | WSAEOPNOTSUPP
},
5444 { "WSAEPFNOSUPPORT", 0xc0010000 | WSAEPFNOSUPPORT
},
5445 { "WSAEPROCLIM", 0xc0010000 | WSAEPROCLIM
},
5446 { "WSAEPROTONOSUPPORT", 0xc0010000 | WSAEPROTONOSUPPORT
},
5447 { "WSAEPROTOTYPE", 0xc0010000 | WSAEPROTOTYPE
},
5448 { "WSAEREMOTE", 0xc0010000 | WSAEREMOTE
},
5449 { "WSAESHUTDOWN", 0xc0010000 | WSAESHUTDOWN
},
5450 { "WSAESOCKTNOSUPPORT", 0xc0010000 | WSAESOCKTNOSUPPORT
},
5451 { "WSAESTALE", 0xc0010000 | WSAESTALE
},
5452 { "WSAETIMEDOUT", 0xc0010000 | WSAETIMEDOUT
},
5453 { "WSAETOOMANYREFS", 0xc0010000 | WSAETOOMANYREFS
},
5454 { "WSAEUSERS", 0xc0010000 | WSAEUSERS
},
5455 { "WSAEWOULDBLOCK", 0xc0010000 | WSAEWOULDBLOCK
},
5459 /* ### make_requests end ### */
5460 /* Everything above this line is generated automatically by tools/make_requests */
5462 static const char *get_status_name( unsigned int status
)
5465 static char buffer
[10];
5469 for (i
= 0; status_names
[i
].name
; i
++)
5470 if (status_names
[i
].value
== status
) return status_names
[i
].name
;
5472 sprintf( buffer
, "%x", status
);
5476 void trace_request(void)
5478 enum request req
= current
->req
.request_header
.req
;
5479 if (req
< REQ_NB_REQUESTS
)
5481 fprintf( stderr
, "%04x: %s(", current
->id
, req_names
[req
] );
5482 if (req_dumpers
[req
])
5484 cur_data
= get_req_data();
5485 cur_size
= get_req_data_size();
5486 req_dumpers
[req
]( ¤t
->req
);
5488 fprintf( stderr
, " )\n" );
5490 else fprintf( stderr
, "%04x: %d(?)\n", current
->id
, req
);
5493 void trace_reply( enum request req
, const union generic_reply
*reply
)
5495 if (req
< REQ_NB_REQUESTS
)
5497 fprintf( stderr
, "%04x: %s() = %s",
5498 current
->id
, req_names
[req
], get_status_name(current
->error
) );
5499 if (reply_dumpers
[req
])
5501 fprintf( stderr
, " {" );
5502 cur_data
= current
->reply_data
;
5503 cur_size
= reply
->reply_header
.reply_size
;
5504 reply_dumpers
[req
]( reply
);
5505 fprintf( stderr
, " }" );
5507 fputc( '\n', stderr
);
5509 else fprintf( stderr
, "%04x: %d() = %s\n",
5510 current
->id
, req
, get_status_name(current
->error
) );